Jake Levi jakelevi1996

This is some ^superscript text.

How to convert markdown to PDF:

This post reviews several methods for converting a Markdown (.md) formatted file to PDF, from UNIX or Linux machines.

Using `Pandoc`:

$ pandoc How_I_got_svg-resizer_working_on_Mac_OSX.md -s -o test1.pdf

Makefile cheat sheet

Mostly geared towards GNU make

I've used ->| to indicate a tab character, as it's clearer to read than ⇥

Set a target, its dependencies and the commands to execute in order

target: [dependencies]
-&gt;|

High-Performance Matrix Multiplication

This is a short post that explains how to write a high-performance matrix multiplication program on modern processors. In this tutorial I will use a single core of the Skylake-client CPU with AVX2, but the principles in this post also apply to other processors with different instruction sets (such as AVX512).

Intro

Matrix multiplication is a mathematical operation that defines the product of

Gist "To do" list

Here is my to-do list for Gists/things I intend to write Gists about:

Generic Bayesian linear regression: as basis functions, define some classes with __call__ methods (EG Gaussian, polynomials) which take appropriate parameters to their __init__ method (EG location, scale, polynomial order); a given Bayesian linear regression solution should accept a list of basis functions, whose outputs for each data point can be calculated with the built-in map function, or numpy.vectorise, and compare the output with the MAP and ML solutions, EG:

import numpy as np

class Sigmoid:
    def __init__(self, loc): self.loc = loc
 def __call__(self, x): return 1.0 / (1.0 + np.exp(self.loc - x))

Speed tests

Shown below is some code to perform generic speed tests and save a log-log graph of the results (in this example, eigenvalue decomposition for SPD matrices is being tested). The resulting graph is shown below the code:

import numpy as np
import matplotlib.pyplot as plt
import scipy as sp
from time import perf_counter

	import os
	import scipy.io.wavfile as wav
	# install lame
	# install bleeding edge scipy (needs new cython)
	fname = 'XC135672-Red-winged\ Blackbird1301.mp3'
	oname = 'temp.wav'
	cmd = 'lame --decode {0} {1}'.format( fname,oname )
	os.system(cmd)
	data = wav.read(oname)
	# your code goes here

	"""
	Minimal character-level Vanilla RNN model. Written by Andrej Karpathy (@karpathy)
	BSD License
	"""
	import numpy as np

	# data I/O
	data = open('input.txt', 'r').read() # should be simple plain text file
	chars = list(set(data))
	data_size, vocab_size = len(data), len(chars)

	from tensorflow.python.client import device_lib

	def get_available_gpus():
	local_device_protos = device_lib.list_local_devices()
	return [x.name for x in local_device_protos if x.device_type == 'GPU']

	get_available_gpus()

	"""
	Python is a dynamic language, and it is relatively easy to dynamically create
	and modify things such as classes and objects. Functions, however, are quite
	challenging to create dynamically.

	One area where we might want to do this is in an RPC library, where a function
	defined on a server needs to be available remotely on a client.

	The naive solution is to simply pass arguments to a generic function that
	accepts `args` and `*kwargs`. A lot of information is lost with this approach,