Parallel Python

Parallel Python (PP) is a great start in getting code to run in several computers. It works on a versatile client/server model, where generic servers must be launched to do the actual computations and the user must right a client which interacts with the several servers. The nice thing about this module is how fast you are up and running. Basically you pass arguments, and a function pointer to PP and it handles the distribution and gathering of results. Load balancing, passing extra data, and anything that can’t be done with a single function will be outside the realm of this module.

MPI4Py

MPI is something that I never used, the documentation is sparing, and overall very mysterious. That said, the potential is great. There are several MPI implementations for Python, and I picked this one because it seemed the easiest to install and start using. Essentially when using MPI4Py your script is called in parallel on multiple CPU cores and/or computers and the MPI element makes sure that all the instances talk to each other. What is cool is that variables in your program are both local to an instance, but at the same time can be shared seamlessly with your other instances. The documentation is very good, but the actual MPI standards are very odd and worth learning more about particularly because it can be used with computer clusters.

The setup

My main computer runs Snow Leopard and I have become a stickler to running all my applications in 64bit. Not for performance gains (although this does enable the use of OpenCL which  is 64bit only), but for consistency. Actual computations are left for my schools computer cluster which uses some linux distribution and are also 64bit machines.

• Python-2.6
• Matlab 2010a on the mac (64bit)
• Matlab 7.6 on linux (32+64bit)

Great, but what about my old code

The first hurdle to the transition is making all that old Matlab code work. Once in 1999 someone discovered this problem and wrote PyMat which interfaced Python and Matlab by using Matlab’s shared libraries. While perhaps it still works, the code felt very antiquated. It has been over 10 years since the last update! So I wrote a new version from scratch which was a delight for learning more of the internals of Python.

The nice thing about the module I wrote is that is allows for all matlab functions to be called directly so that:

X = matlab.rand(numpy.array([100 100]), 1)

The following snippet calls Matlab’s native rand function and the result is stored in a numpy array in X. The 1 at the end of the snippet tells the python interface to expect a single return value. In the future this may not be required.

A difficulty in doing this interface is that each Matlab version has slightly different set of function names. This makes the interface have to be slightly tweaked for each version.

Functions that don’t exist

It surprises to see how many helpful functions Matlab has. Particularly saving and opening images and other assorted data types. Numpy while very good doesn’t have a easy to use save routine nor can Numpy natively open arbitrary images. While naturally this is because these features are not part of the project’s mission statement, it does mean more work for the valiant researcher.

Quickly you will see that a handful of functions must be written to do these simple tasks, and while there are plenty of stable modules including PIL and Pickle for opening images and saving data (respectively), it does mean more steps between you and your work.

IDE

Finally by the end of the day you will begin to miss the ugly, Java-esc, Windows-esc and X11-est IDE that Matlab has featured for probably over a decade. Being able to inspect variables, even see the variable names being used, and the ugly but useful debug features is badly missed as well.

By the end

By the end you realize why Matlab exists and is widely used. However, unless someone ventures out and fixes the wholes that exist with Python as a Matlab alternative, people will never have an alternative. Unifying the tools that exist for Python and adding interoperability with Matlab are the first steps to making a really good alternative to the most widely used piece of software in the sciences.

A fork of OpenCV 2.0 can be found at https://code.google.com/p/opencv-cocoa/ which has both the Cocoa and Quicktime updates. This is completely tested so use it with caution. Any help and suggestions are greatly appreciated.

Because Cocoa functions strictly inside a MVC framework there is a small change that you must make at initializing HighGUI that is found here. It boils down to the fact that your code cannot run in the main thread, because Cocoa needs to run there. So to update any existing projects you must remove your code from the main function and place it in an auxiliary function which is called by cvInitSystem.

I have not yet made any benchmarks, so there is a chance that using Cocoa and QTKit at either 32 or 64 bit is not imperative for improving performance of your code. The main purpose is to allow the usage of other libraries in conjunction with OpenCV which already work at 64bit and may depend on Cocoa.

It is extremely easy to write OpenCL kernels (although there is room for improvement) and here is the warping kernel I have written.

mmreader, which I depend on for reading avi movie files no longer works. Images seem to be garbled by some sort of offset and data conversion. I suspect this stems from some 32 to 64 bit conversion that Matlab is not aware of. Anyway, so now I can’t read movies files until they fix Matlab which god knows when it will be.

Update for those thinking of installing Snow Leopard: 2008a, 2009a, 2009b (32 and 64 bit) all work fine. Aside from some bugs that must exist like the one above in specific packages, the general Matlab environment is fully functional.

Day 1: This will be great. I’ll use the Python C API to call python from Matlab. I’ll save the Python state as a Matlab variable and I can always start up my Python session where I left off.

Day 2: Alright.. maybe not. But let’s just try calling Python from C, I just want to make it work, not have it running efficiently.

Day 3: Ok, clearly Python has a crappy API. Moving to the client/server socket communication approach. Phew.. must it be this hard?

% Images = set of 2D matrixes that we want to convert to a movie (values range from 0-255)
% Frames = Pseudo RGB version Frames
% Mov = Matlab structure that holds the movie
Width = 48; Height = 48;
NumberOfFrames = size(Images, 2);
Frames = zeros([Width, Height, 3, NumberOfFrames]);
for i=1:NumberOfFrames,
Frames(:,:,1,i) = Images{i};
Frames(:,:,2,i) = Images{i};
Frames(:,:,3,i) = Images{i};
end
Mov = immovie(Frames);
movie2avi(Mov, 'movie.avi');

First is error that happens in the system_info.py which reads something like:

File "/sw/lib/python2.6/site-packages/numpy/distutils/cpuinfo.py"
line 79, in __getattr__
raise AttributeError,name
AttributeError: _has_sse2

To fix this you must edit the file system_info.py lines 107-114 to becoming:

#if cpu._has_sse2() and (dcomp == 'mingw32' or dcomp == 'gcc'):
extra_args = ['-arch x86_64', '-O3', '-msse2', '-mfpmath=sse', '-malign-double']
#    if get_gcc_version() >= '4.2':
extra_args.append('-mtune=generic')
#    else:
#        extra_args.append('-march=pentium4')
#        extra_args.append('-mtune=pentium4')
#info['extra_compiler_args'].extend(extra_args)}}}

This fixes the above error and also fixes an assembly error that happens later when compiling Blas bindings. The error:

error: can't find a register in class ‘GENERAL_REGS’ while reloading ‘asm’

The error is fixed by specifying the architecture of the computer, in this case x86_64.

Note: These values were generated on different processors and no attempt was made to see which one was ultimately faster. The idea was to see how, independently, each environment performed under complex matrix operations. All values are in seconds and averaged over 100 iterations.

Addition

Multiplication

QR

As you can see, the Mac version is finally starting to get numbers closer to that of Linux and Windows. With a better GUI (Cocoa based) I will finally stop writing C++ code for good.