Cython is essentially a Python to C translator. Cython allows you to use syntax similar to Python, while achieving speeds near that of C.
This post describes how to use Cython to speed up a single Python function involving ‘tight loops’. I’ll leave more complicated applications - with many functions and classes - for a later post.
Should I use Cython?
If you’re using Python and need performance there are a variety of options, see quantecon for a detailed comparison. And of course you could always choose a different language like Julia, or be brave and learn C itself.
While the static compilation approach of Cython may not be cutting edge, Cython is mature, well documented and capable of handling large complicated projects. Cython code lies behind many of the big Python scientific libraries including
Our example function evaluates a Radial Basis Function (RBF) approximation scheme. We assume each data point is a ‘center’ and use Gaussian type RBFs
so our function takes an input data array \( X\) of shape (N, D), a parameter array \( \beta\) of length N and a ‘bandwidth’ parameter \(\theta\) and return an array of fitted values \( \hat Y \) of length N.
Here’s the naive Python implementation
Let’s make up some data
Timing this in
IPython we get
Dam those Python loops are slow!
So in this case we’re lucky and there’s an external
numpy based implementation
Much better. But what if we want to go faster or we don’t have a library we can use.
A Cython version - implemented in the file
fastloop.pyx - looks something like this
So far all we’ve done is add some type declarations. For local variables we use the
cdef keyword. For arrays we use ‘memoryviews’ which can accept numpy arrays as input.
Note that you don’t have to add type declarations in a
*.pyx file. Any lines which use untyped variables will just remain in Python rather than being translated to C.
To compile we need a
setup.py script, that looks something like this
then we compile from the terminal with
which generates a C code file
fastloop.c and a compiled Python extension
Lets test it out
OK, but we can do a better. With Cython there are a few ‘tricks’ involved in achieving good performance. Here’s the first one, if we type this in the terminal
we generate a
fastloop.html file which we can open in a browser
Lines highlighted yellow are still using Python and are slowing our code down. Our goal is get rid of yellow lines, especially any inside of loops.
Out first problem is that we’re still using the Python exponential function. We need to replace this with the C version. The main functions from
math.h are included in the Cython
libc library, so we just replace
from math import exp with
Next we need to add some compiler directives, the easiest way is to add this line to the top of the file
Note that with these checks turned off you can get segmentation faults rather than nice error messages, so its best to debug your code before putting this line in.
Next we can consider playing with compiler flags (these are C tricks rather than Cython tricks as such). When using
gcc the most important option seems to be
-ffast-math. From my limited experience, this can improve speeds a lot, with no noticeable loss of reliability. To implement these changes we need to modify our
Now if we run
cython fastloop.pyx -a again we will see the loops are now free of Python
The yellow outside the loops is irrelevant here (but would matter if we needed to call this function many times within another loop).
Now if we recompile and test it out we get
OK, now we’re getting there.
Calling C functions
So what else can we do? Well it turns out the exponential function is a bit of a bottleneck here, even the C version. One option is to use a fast approximation to the exponential function
From Cython its easy to call C code. Put the above code in
vfastexp.h, then just add the following to our
So now we can just use
exp_approx() in place of
exp(). This gives us
|Method||Time (ms)||Speed up|
|Cython with approximation||15||751|
So there are a few tricks to learn, but once your on top of them Cython is fast and easy to use. Maybe not as easy as Python, but certainly much better than learning C.