Autoreload

Executing this on ipython forces ipython to reload functions each time it executes them, really usefull if you are testing and modifying at the same time!

%load_ext autoreload
%autoreload 2


IPv4 vs IPvs6 article

Nice simple summary of Internet Protocol version 4 vs. version 6

http://mashable.com/2011/02/03/ipv4-ipv6-guide/

Pythonize your emacs

Awesomely simple step by step guides for setting up a Python environment on emacs.

Basic Environment:
http://www.yilmazhuseyin.com/blog/dev/basic-emacs-setup/

Further Setup:
http://www.yilmazhuseyin.com/blog/dev/emacs-setup-python-development/

The posts were written by Huseyin Yilmaz

Return to things that are meaningful

This inspires me everytime and is worth remembering..


Return to Awe - Jason Silva & the Melodysheep

Cold-start- and Warm-start-approach

In the field of machine learning, you may have come across the terms cold-start- and warm-start-approach. Roughly, here's what they are:

Cold-start-approach: Each problem is solved independently from the next, for example, a bunch of logistic regression problems are computed in order to find the best regularization parameter  λ. This can be efficient when multiple processors are used as the problems can be solved simultaneously.


Warm-start-approach: Each problem is solved using previously computed data as the starting point for the next computation. It can be done efficiently with a single processor as the problems are solved more sequentially.

Using git's bisect to find out where it all broke

When working on a project with with several contributors, it can be quite a pain if the lastest commit breaks. Using blame is one way to go, but if this doesn't yield the solution or the
place where shit went wrong, git bisect can be used to systematically track the point or commit
where things broke, which is a nice debugging tool.

Here's a nice tutorial on the matter:

DeprecationWarnings in Python 2.7

If you're using Python versino 2.7, you may notice that the DeprecationWarning no longer displays. This has been de-activated by default, however, it can be switched back on by, for example, doing the following in iPython 


>>> import warnings 
>>> warnings.simplefilter("always") 

If you now call a deprecated class on purpose, iPython will display the full DeprecationWarning

Hosting your html on Github

If you want to host a webpage on Github, here's how I do it.

For example, the documentation to some project you've done in, say, Python, has been generated using something like Sphinx, or you've just got some html files.. Nonetheless, you want to host an online version of this documentation as a pre-built website on github.

This is especially useful if you've made some changes to the documentation/website of a Github repository, and you want to show it easily to your peers for review, without having them first fork it and build it in order to see what you've done.
Note that these instructions are from how I do it on ubuntu 11.10.

1. Firstly, on your Github account (Your profile page where your forks and repositories are shown, create a new repository.
   
2. Give it a name, like for example, project_documentation_online_build.
3. A set of instructions should appear, the first them being Global setup, which I'm assuming you've hopefully done already. Follow the Next steps instructions in your terminal to create your directory with the same name (in my case, project_documentation_online_build). They should go a little something like this:
   
   mkdir project_documentation_online_build
cd project_documentation_online_build
git init
touch README
git add README
git commit -m'first commit'
git remote add origin git@github.com:YourUserName/project_documentation_online_build.git
git push -u origin master


4. You can then create a new branch for this repository called gh-pages like so:
   git symbolic-ref HEAD refs/heads/gh-pages
   
   
5. Switch to this branch:
   git checkout gh-pages
   
   
6. Now you can place all your html files here, like for example your html-build from your Sphinx generated documentation. Once you've placed it all here, you can:
   
   git add .
git commit -a -m "First pages commit"
git push origin gh-pages

Once you've done this, you should receive a message from Github to inform you that your pages has been succesfully built (usually after a couple minutes).
A wee bit later you should be able to check it at http://YourUserName.github.com/project_documentation_online_build/

Note1: If you're page built but it's missing it's theme and pretty colours, add a blank file called .no_jekyll to the main directory in your gh-pages branch and try pushing it again.

Note2: This is just what works for me. If you have any problems, I recommend you check out the GitHub Pages documentation. These instructions, together with those that are displayed upon creating a new repository, are pretty much what I'm summarising here.

Informative features

Let's say you want to generate a synthetic data-set to play around with for classification,
and you set

n_samples = 100
n_features = 1000


and you generate the following data
import numpy as np
import matplotlib.pyplot as plt
X1 = np.asarray(np.randn(n_samples/2, n_features))
X2 = np.asarray(np.randn(n_samples/2, n_features)) + 5
X = np.append(X1, X2, axis=0)
rnd.shuffle(X)

plt.scatter(X[:,0], X[:,1])
plt.show()


For a binary classification, the function which determines our labels is \[y = sign(X \bullet \omega)\]
Where \(\omega\) is our coefficients.
For now, let's set our coefficients equal to a bunch of zeros:
coef = (np.zeros(n_features))
If we wish to make it so that we have, say, 10 informative features, we can for example set 10 of our coefficients equal to a non-zero value. Now when we dot it with our data, X, we will basically
tell it that the 10 non-zero coefficients are our informative features, while the rest that will be
multiplied by zeros are not informative.

So,

coef[:10] = 1
y = np.sign(np.dot(X,coef))


will give us our corresponding labels such that we have 10 informative features.
A way to visualise this, is to use the Scikit-Learn package's f_classif function.
If you have the Scikit-learn package installed, do the following:

from sklearn.feature_selection import f_classif
p,v = f_classif(X,y)
plt.plot(p)
plt.show()


Here you can see that the first 10 features are rated as the most informative.

Cycling with Jinga

I was tweaking the layout.html file for Python's Sphinx and found the following random tit-bit of use when using Jinga:


{%- for rellink in rellinks[1:]|reverse %}
  <div class="{{ loop.cycle('buttonPrevious', 'buttonNext') }}">
   <a href="{{ pathto(rellink[0]) }}">
    {{loop.cycle('Previous', 'Next')}}
  </a>
{%- endfor %}




With loop.cycle you can cycle through strings or divs
as the loop iterates..

In the above example, a div is created first for buttonPrevious and then
the next iteration for buttonNext. The same applies to the strings that determine what gets
printed on the button.

Stashing in Git

If you're working on a branch and which to switch to another for some reason without committing,
or you wish to try out something on the current branch, you can save your current state to the
stash .
Use
git stash save


When you're ready to continue what you were working on, go back to the branch that you used
stash on and use:
git stash apply

If you don't want to use your stash anymore, and just work from your last commit, use
git stash clear

For a more thorough run-through on git-stashing , check out
http://ariejan.net/2008/04/23/git-using-the-stash

doctest_mode in iPython

If you want to import code into iPython that has been copied from the python console
or code that is to be run as a doctest in Python Sphinx, a useful trick to use in iPython
is

%doctest_mode

For example:

>>> import numpy as np
>>> some_value = 35
>>> np.sqrt(some_value)


You can copy this directly into iPython and it will treat it like normal python code.
No need having to copy every line of code after >>>

Fix slow connection (ubuntu 11.10 - Oneiric Ocelot)

If your wireless internet is damn slow after installing ubuntu 11.10,
here's one way to try and fix it:

This method involves forcing iwlagn to not use n, the commands will disable n on the device without making it a permanant change, check first if this work for you, if you notice that the speed improved then continue to make the change permanant. If this solution didn`t work for you, then reboot your computer to revert the chnages.


sudo rmmod -f iwlagn
sudo modprobe iwlagn 11n_disable=1


If you notice that the wifi speed improved, then make the change permanent :

gksudo gedit /etc/modprobe.d/iwlagn-disable11n.conf

and add this line to the file:

options iwlagn 11n_disable=1

save & quit

Important: The above method has been quoted from www.unixmen.com, a site that I've found very useful in the past. The method was the one that worked for me and hence why I want it here. To see the full original post that containts two other methods, please go to the Unixmen post that I am quoting from

Removing tick-labels from an axis in Matplotlib

If you want a make a 3D plot for which you don't want any text on the axis-ticks,
the following should do that (pl = pylab):

fig = pl.figure(1, figsize=(4, 3))
pl.clf()
ax = Axes3D(fig, elev=43.5, azim=-110)
....
....
ax.set_xlabel('X_1')
ax.set_ylabel('X_2')
ax.set_zlabel('Y')
ax.w_xaxis.set_ticklabels([])
ax.w_yaxis.set_ticklabels([])
ax.w_zaxis.set_ticklabels([])

An example plot:

for python with pylab, matplotlib & Axes3D