*just watched mean girls*

I’ve decided that I like that brand of teen chick flick. Anything with Girl Punk is made of w00t.

Tomorrow I will get back to work on my project.

In my post of http://alsuren.wordpress.com/2008/07/31/, I introduced the Hidden Markov Modelling framework upon which the rest of the project is based. In today’s post, I will go over a few of the different models that can be plugged into the framework, and discuss their Practical limitations.

As the work on this section is still in progress, this post is likely to be quite rough until I’ve explored a few things. You will also notice that my TODO list is embedded in this post. If you have any thoughts on what I should put to the top of the TODO list, please post a comment at the bottom. Also, I have made many assertions that may not actually be valid. If you see something that looks wrong, feel free to point it out.

One of the useful properties of Markov Models is that the same model parameters used in the inference/tracking model can also be used to generate synthetic data. This is useful, as it lets you listen to what your model *thinks* a song sounds like, and compare it against the real thing. Throughout the rest of this project, we will try to make sure that we can generate synthetic data from our model, and that it sounds similar to what we expect music to sound like. Here are a few such models.

Deterministic Model

In the last post, we looked at a generative model that looks like the following Graphical Model:

We used a State Transition Matrix that looked like this:

and a look-up table as our output model. Essentially, the only thing that was random in the system was its start position.

Resilience to Noise

This model will immediately fail in the presence of any noise.

Implementation Issues

This model was not implemented, as it is completely unrealistic.

Coin Toss Speed Model

A possible extension to this model is to have a position transition matrix which looks like:

Where p is the probability of moving on to the next position in the bar. If p=1, the system will behave exactly like our previous model. This has an expected rate of progress of p, and the position after time t is binomial distributed.

Problems with the Generative Model

There are many limitations to this model. The first is that it has no notion of what its speed has been in the past, so it will speed up and slow down at random like a primary school child, or an acid jazz musician.

Resilience to Noise

This model is better than the previous model, because if music is generated with the model, and then slowed down, it is still capable of tracking the bar position, whereas the old system would simply output a uniform probability of 0 for all possible positions.

Because of the position is no longer deterministic, it is impossible to track the bar position *exactly*, but the best guess of the algorithm will be as good as that of a human observer. If the values of P(x[t]=position | a[0...t]) are plotted as brightness values on an image for each value of x and t, areas of uncertainty in x will look blurred. They will tend to be sharp just after the start of a note, and blurred towards the end.

If the music is sped up at any instant to more than 1 x per t, then this model will output all zeros from that point onwards. Similarly, if any notes are not played, or are played in the wrong order, the model will fail.

Implementation Issues

This model was not implemented.

Coin Toss Emission Model

One way to amend the above model is to change the emission model. We say that the musician will only play the note recorded in the score with a probability of e (notes are dropped with probability 1-e). Also, with probability s, a note will be picked at random, and played instead. If e=1, and s=0, this will behave like the above model.

Problems with the Generative Model

In addition to the above problems, long continuous notes will often be cut into chunks by sections of dropped notes, and there will be random squeaks. It will sound even more like a child learning to play than the previous model.

Resilience to Noise

If notes are removed from or added to the piece, they will be treated as randomly dropped/inserted notes, and the tracking will continue as before. If the piece is temporarily sped up to greater than 1 x per t, the resulting notes can be explained away as random insertions.

Implementation Issues

This model was not implemented. All of the above models require something to infer the notes played with high precision. This is possible, but extremely expensive computationally.

Gaussian Emission Model

This is the first emission model that was implemented in Python. The format of input/output to the model is mono .wav data with 44100 samples per second.

Rather than having notes written in the score, we will say that the score just contains the loudness of the music at that point. Every hundredth of a second, the musician will output 441 samples of (Gaussian) white noise with variance equal to that indicated in the score (in reality, the variance will be Gaussian distributed). TODO: Add a wav file sample of the output.

When observing, the value of P(samples | x[t]) is actually the Gaussian probability density function, given by
P(samples | x[t]) = (1/(sqrt(2*pi)*sigma) ** 441) * exp( -var(samples)*441 / (2*(sigma ** 2)) ).
Where sigma is taken from the score, and var(samples) is the variance of the samples. It is left as an exercise for the readers to verify the correctness of the mathematics for this, if they so wish. The important thing is that the maximum likelihood position for x[t] is the one that has the same variance as the observed samples. This is shown for 10 samples below, and for 441 samples below that.
http://www.srcf.ucam.org/~dl325/swingbar/doc/oGivenVar10.png
http://www.srcf.ucam.org/~dl325/swingbar/doc/oGivenVar441.png

Problems with the Generative Model

The fact that the sound generated is white means that it sounds like a brush on a drum. Also, as the variance of the samples is used as the observation: observing a song, and then generating sound that matches those observations makes the song unrecognisible.
http://www.srcf.ucam.org/~dl325/swingbar/doc/data/VIC70187.mp3
http://www.srcf.ucam.org/~dl325/swingbar/doc/data/100.wav

Resilience to Noise

This model is very good at tracking synthetic data. One thing to be careful of is that the variance of the input, and that of the score are the same, and that there is not too much clipping, or quantisation error (.wav stores 16bit signed integer values).

Implementation Issues

There is a lot of scope for numerical instability here. Rather than implementing the formula for P(samples | x[t]) given above, it is recommended to implement log(P(samples | x[t])), and then use exp() after. Also, rather than passing P(a[0...t] | x[t]) through the algorithm (which decays to zero exponentially quickly), one should pass through P(x[t] | a[0...t]), whose sum remains constant at all times. If one is interested in P(a[0...t] | x[t]), it is possible to return P(a[t] | x[t], a[0...t-1]) for each t along with each P(x[t] | a[0...t]). It is then possible to take logs, and use the cumsum() function to calculate the log likelihood at each t.

Extra State Variable for the Speed

Previously, we have looked at only a single state variable. Now, we will add a second variable for the speed, v[t]. Rather than having the position advancing randomly, we now make the position advance by v[t] each time. The Graphical Model now looks like this:
http://www.srcf.ucam.org/~dl325/swingbar/doc/barPointer.png
It is possible to do an analysis similar to that done in the last post, in order to find an expression for P(a[0...t-1] | x[t-1], v[t-1]), and so on. An alteranative approach (suggested by C. M. Bishop) is to merge the states, to look like the diagram below, and simply construct a single large transition matrix.
http://www.srcf.ucam.org/~dl325/swingbar/doc/barPointerSimple.png

Setting v to 1 will make the system behave like the original model. Letting v[t] = 1 with probability p, or v[t] = 0 with probability 1 - p will make the system behave like the Coin Toss Speed Model. Alternatively, if we have a state transition matrix for v that looks like the diagram below, we will be able to generate constant tempo music by making p small.

Problems with the Generative Model

The model will either only generate music with 3 speeds, or wander all over the place.

If p is small, it will only be able to track music at 3 tempos. If p is large, it will lose track of the beat too quickly when there is a break in the music. [TODO: Create some graphs of what the spread looks like for some values of p, and work out the conditions on p to get a spread of x with a single maximum.]

Resilience to Noise

This model works for synthetic data under many forms of noise for single instrument pieces, but if multiple instruments are played, or voices are included in the song, it will fail.

Implementation Issues

In order to get acceptable resolution in speeds, the score must be *very* large (1000 or more for 10 possible speeds). This means that for each operation, a 10000 item long vector for P(a[0...t-1] | x[t-1], v[t-1]) must be multiplied by the 10000×10000 speed transition matrix. This is a reasonably expensive thing to do, but the matrix is very sparse, and has regular structure (it will only have of the order of 30000 non-zero elements, and it contains sub-matrices which have very low bandwidth. If using LAPACK (most matrix algebra systems will use this either directly or indirectly) then it is possible to inform the computer of this sparseness, and speed up the computation with very little effort. At best, this will square root the cost of computation for a single
Another problem is that creating a single large transition matrix is very expensive in terms of memory. If a dense matrix representation is used, it will generally require a contiguous block of memory to be allocated from the heap. For large scores, memory fragmentation will make this impossible. Luckily, this only ever needs to be done once for each model, and once it has completed the matrix can be converted to a sparse format.

An alternative implementation is to separate the state variables, and do some maths [TODO: does anyone want me to do this here? I have it written in my folder]. This way, the state transition matrix for speed, P(v[t] | v[t-1]) becomes a 10×10 with items only in the 3 diagonals. The transition matrix for P(x[t] | x[t-1], v[t-1]) then becomes a Kronecker delta again, and can be evaluated using slice operations again. Instinctively, this would seem far quicker than the simplistic method outlined above, but if a scripting language like Python or Matlab is used, then the interpreter overhead for the slicing operations may turn out to be significant for small matrices. Also, a clever LAPACK implementation could concievably reduce the original matrix multiplication to this anyway.

It is also possible to turn the speed transition matrix into a symmetrically extended 1-D convolution, using the kernel [p, 1-2p, p].

[TODO: plot a graph of execution time vs array size for each implementation]

Filtered Gaussian Emission Model

Rather than storing just a single value of the variance, the spectrum will be split up onto bands, using a Discrete Wavelet Transform. Each band will therefore have its variance stored in the score.

In order to generate music, the musician will look in his score, and generate random noise for each band at the appropriate variance. He will then inverse DWT the bands, to get the real signal.

Problems with the Generative Model

I’ve not implemented it yet, so I don’t know what it sounds like. I should have it done by the weekend, as I see my supervisor on Monday.

Resilience to Noise

It should filter out other instruments better than the previous model, but we’ll have to see.

Implementation Issues

I am currently in the process of implementing this model.

[EDIT 1: Largely re-structured to give more context for the fundamental concepts.]
[EDIT 2: Addressed some of Gavin's points (link to a description of D-separation, and some general cleaning up of algebra.) Thanks Gav.
Also added some headings to help the casual reader.
Also note that I have changed my wordpress theme, so that the diagrams don't get completely chewed up by your web browser.]
This post is an outline of my project so far. It is a kind-of 0th draft for what my report might contain. Please give feedback on how readable it all is (note: I already know that my diagrams use () and my text uses []. Unfortunately, I have a lot of diagrams, so changing this by hand would be tedious. I will write a script to do it for me at some point soon. I will also find a way to re-size my diagrams so that they fit on the page nicely). It’s likely to be mostly maths, but I’ll try to keep it as readable as possible, with as many pictures as possible. Please read as far as you can follow, and then post a comment, or email, or facebook, or MSN, or whatever telling me what I need to clarify.

Introduction

The aim of this project is to analyse music, specifically focussing on rhythm. Before this can be done, we need to be able to track where we are in a bar. Once we can track where we are in the bar, we can start to extract useful features, and not be completely thrown off if two songs are very slightly faster or slower than each other. In order to do *this*, we need to have a model of how music is generated.

Toy Model of Music Generation

A really simple model would be the following:

Physical Description

Assume that a musician always plays music at the same tempo, and that he always plays the same bar in a loop. The musician starts at a random position in the bar, to make things a little random. Every hundredth of a second, the musician looks at his score, which tells him what to play for that hundredth of a second. He then keeps playing that note for a hundredth of a second, before moving on to the next position, and looking at his score again.

Note that this model of a musician is very limited. It might be valid for a music box, but not a human. That’s okay, because we are only studying it to introduce markov models. In the next article, we will explore more robust models, and outline the practical problems encountered when implementing them.

Technical Description

We call his position in the bar his state. Because we cannot observe x, we call it a “hidden state variable”. It has a state transition diagram that looks like this:

The fact that the notes he plays are determined by his position in the bar can be represented using a trellis diagram:

The trellis diagram is a Graphical Model of our system. Arrows on a graphical model are always in the direction cause -> effect. The above trellis diagram also shows the fact that x[t] is only dependant on x[t-1] (in this case, x[t] = (x[t-1] + 1) % (X+1), using C-style syntax)

Observation Model

All we observe is what our musician plays at each time instant (marked a[t] on the diagram), and we wish to guess where he is in the bar at each time instant (x[t]). A good goal is to guess the value of x[t] that is most likely, given our observations, and our model (the score).

Base Case

We will start with a single observation.

At t=0, we observe that he is playing a C#. We wish to evaluate P(x[0]=position | a[0]=C# ) for each possible position in the bar, and pick the maximum. As a Graphical Model (shown below), a[0] is filled in, as its value has been given, and we wish to evaluate the probability of x[0] for each position. We will use more complicated graphical models later, so it is worthwhile familiarising yourself with the notation.

The same information can also be shown in a form that will be more familiar to the general public: The Venn Diagram below shows the events x[0]=6, and a[0]=C#. Note that the diagram is not to scale.

x[0]

The white circle represents the event that the musician starts (”x[0]“) at position 6 in the bar (”x[0]=6″). If out diagram were to scale, the proportion of diagram covered by this circle would represent the probability of this event happening. We refer to this probability as P(x[0]=6). Because we model the musician as starting in a random position in the score, this is 1 / the number of possible starting positions.

a[0]

The event that the first note we hear is a C# (”a[0]=C#”) is coloured in blue (this is arbitrary). The proportion of the diagram covered by the blue circle is the probability that a[0]=C#. We denote this as P(a[0]=C#). This can be found by working out the proportion of the score that contains a C#.

Conditional Probability, and Philosophy

At this point, a common objection is “But you just told us that we observed him playing a C#, so surely P(a[0]=C#)=1?” This is a good point, that needs clarifying. Usually, when we wish to evaluate P(a[0]=C#) given that we have observed C#, we write P(a[0]=C# | a[0]=C#) (read the “|” as “given”). Now, strictly, when we write P(a[0]=C#), we should really write P(a[0]=C# | model) instead. This is an important philosophical point, because P(a[0]=C#) could be interpreted as P(a[0]=C# | omniscience), which is always either 0 or 1. For the rest of this article, wherever nothing is noted as “given”, assume “given nothing other than my model”. This point is worthy of an article on its own, but we will not dwell on it any further here.

a[0] given x[0]

The proportion of the x[0]=6 circle that is also covered by the a[0]=C# circle represents the probability that a[0]=C# given that x[0]=6 (written as P(a[0]=C# | x[0]=6)). This can actually be read directly from the score: If there is a C# written in the position 6 in the score, then we have a 100% chance of hearing a C# (this would be represented by putting the 6 circle entirely within the C# circle). Otherwise it is 0 (which would be represented by not letting the circles overlap). Rather than having to create hundreds of diagrams, we will simply say “this diagram is not to scale”, and let the reader use his imagination.

x[0] given a[0]

The proportion of the a[0]=C# circle that is also covered by the x[0]=6 circle represents the probability of the musician having started in position 6, given that we have heard a C#. P(x[0]=6 | a[0]=C#). This is what we wish to calculate in order to find our best guess of where we started. We will get back to this later.

a[0] AND x[0]

The area where both circles overlap represents the probability that both a[0]=C# and x[0]=6. We write this as P(x[0]=6, a[0]=C#). It should be noted that this can be calculated as P(x[0]=6 | a[0]=C#) * P(a[0]=C#). This result is known as the product rule of probability.

A more Consice and General Notation

At this point, we will clean up the notation a little. Previously, we have explicitly written a[0]=C#, but the results above also work if we are interested in the event a[0]=D (simply replace C# with D), or a[0]>C# (if you consider one note to be greater than another). In order to capture this generality, we could use another variable for the note, but this very quickly becomes clunky. Instead, we will simply leave out the =C#. This has the added advantage that there is only a single = on each line, making things neater. When actually writing algorithms, the =C# can be substituted back in, as long as it is done consistently.

returning to x[0] given a[0]

Re-writing the product rule using the new notation looks like this:
P(x[0], a[0]) = P(x[0] | a[0]) * P(a[0])
P(x[0], a[0]) = P(a[0] | x[0]) * P(x[0])

and therefore:
P(x[0] | a[0]) * P(a[0]) = P(a[0] | x[0]) * P(x[0])

Re-arranging to get an expression for P(x[0] | a[0]):
P(x[0] | a[0]) = P(a[0] | x[0]) * P(x[0]) / P(a[0])
Those of you in the know will recognise this as Bayes’ rule.

Numerical Example, and Consolidation

The terms on the right hand side are all known, as seen above. But how is this useful? To make this useful, we must substitute in some terms. First, we substitute in our observation, and the position we’re wanting to test:
P(x[0]=6 | a[0]=C#) = P(a[0]=C# | x[0]=6) * P(x[0]=6) / P(a[0]=C#)

Then we can read the probabilities from our model. Let’s say there is a C# at position 6, and also at 7, 8, and 9. Let’s also say that the score is 20 positions long. That means:
P(a[0]=C# | x[0]=6) = 1
P(x[0]=6) = 1/20
P(a[0]=C#) = 4/20

Therefore:
P(x[0]=6 | a[0]=C#) = 1 * (1/20) / (4/20)
P(x[0]=6 | a[0]=C#) = 1/4

This is also the case for x[0] = 7, 8, or 9. It is 0 elsewhere, because the P(a[0]=C# | x[0]=10) term goes to 0. A useful check is that if we sum over all possible values of x[0], we get 4 * 1/4 + 16 * 0 = 1.

Considering More Obaservations

So by observing just a single snippet of a note, we can narrow down our position to one of 4 positions. This is useful, but it is only the start. Now we wish to incorporate some more observations, and build up a better guess about where we are in the bar.

Recursive Definition of P(x[t-1] | a[0...t-1])

In order to do this, we will jump straight to time t, and use all previous observations. We wish to calculate the probability of x[t] given all of the observations from a[0] to a[t], written P(x[t] | a[0...t]). We would like to get this in terms of P(x[t-1] | a[0...t-1]) and other known quantities, because that way, we can iterate from t=0 (the result for which is already known, from above) and only require the the output of the last iteration each time. This is a common pattern in convolutional error correction codes, as it lets us take into account all previous observations without running out of memory by trying to store P(x[t] | a[0...t]) for all previous t (you can just store the position of each maximum).

The first thing we do is use Bayes’ rule to make sure that we only have terms that can be factorised using the product rule. We will substitute terms back in later.

P(x[t] | a[0...t]) = P(a[0...t] | x[t]) * P(x[t]) / P(a[0...t]) — [1]

To help you follow this, I should point out that in each line of working, I will expand a single term from the right hand side of the last line. First, take P(a[0...t] | x[t]) (graphical model below).

D-Separation and Conditional Independance

In this model, we notice that x[t] is a given node, and that it blocks the path between a[t] and a[t-1]. We say that a[t] and a[t-1] are conditionally independent given x[t], so you can bring a[t] out of the expression, simply by multiplying, as you can do with any independent random variables. http://www.biomedcentral.com/1471-2105/8/S6/S5/figure/F3 is a useful summary of some situations where we can or can’t quickly infer conditional independence using d-separation.
P(a[0...t] | x[t]) = P(a[0...t-1] | x[t]) * P(a[t] | x[t]) — [2]

By the law of total probability (http://en.wikipedia.org/wiki/Law_of_total_probability):
P(a[0...t-1] | x[t]) = sum_position( P(a[0...t-1], x[t-1]=position | x[t]) ) — [3]

P(a[0...t-1], x[t-1] | x[t]) = P(a[0...t-1]| x[t-1], x[t]) * P(x[t-1] | x[t]) — [4]

P(a[0...t-1]| x[t-1], x[t]) looks like this:

Notice that the path between a[t-1] and x[t] is blocked by x[t-1], so there is no point in conditioning on x[t]. i.e.
P(a[0...t-1]| x[t-1], x[t]) = P(a[0...t-1]| x[t-1]) — [5]
Notice that this is the same form as the left hand side of [2]. This will come in useful later.

Returning to [4],
P(x[t-1] | x[t]) = P(x[t] | x[t-1]) * P(x[t-1]) / P(x[t])
but, if not conditioned upon anything:
P(x[t]) = P(x[t-1]) , so:
P(x[t-1] | x[t]) = P(x[t] | x[t-1]) — [6]
Note that in our case, P(x[t] | x[t-1]) is 1 where x[t] = x[t-1] + 1, and 0 elsewhere, but we will keep this expression general, as it will be useful later.

Now substitute [6] and [5] into [4] into [3] into [2], and we get:
P(a[0...t] | x[t]) = P(a[t] | x[t]) * sum_position( P(a[0...t-1] | x[t-1]=position) * P(x[t] | x[t-1]=position) ) — [7]

Returning to [1], we need to find an expression for P(a[0...t]). Using the law of total probability, we find:
P(a[0...t]) = sum_position( P(a[0...t] | x[t]=position) * P(x[t]=position) )

But P(x[t]) is a constant, so we can take it outside the sum:
P(a[0...t]) = P(x[t]) *sum_position( P(a[0...t] | x[t]=position) ) — [8]

Now, we substitute [8] into [1] and cancel:
P(x[t] | a[0...t]) = P(a[0...t] | x[t]) / sum( P(a[0...t] | x[t]) ) — [9]

Consolidation

So we now have an expression [9] for P(x[t] | a[0...t]) in terms of P(a[0...t] | x[t]), and we have an expression [] for P(a[0...t] | x[t]) in terms of P(a[0...t-1] | x[t-1]).
Setting t=0, we find that P(a[0] | x[0]) is something that we have already evaluated (we call this the base case of the recursion). We can now go from t=1 onwards, and find values of P(a[0...t] | x[t]), using the formula in [7], then substitute into [9], and find a maximum, and we have a very sensible guess of where we are in the bar at time t.

Some Implementation Considerations

It should be noted that when we have very few observations, we will not have a single distinct maximum. In this toy example, we start with 4 after 1 observation, then 3, then 2, then 1. In more practical models, we tend to be even more unsure, and for even longer periods of time. Storing the full array of probabilities in this case is a possible idea, but can cause us to swallow memory. Trying to fit a probability distribution to the matrix will often let us capture the structure in just a few parameters.

It should also be noted that there are many tweaks that can be made to speed this calculation up for the toy model shown here. In this model, P(x[t] | x[t-1]) is a Kronecker delta function, so sums can be translated into index operations in C-inspired languages, or into slice operations in fortran-inspired languages. We have not made this optimisation here, because later, we will use non-deterministic state transitions, so the generality of being able to substitute an arbitrary state transition matrix will come in useful. The same goes for the emission probabilities: Currently, we are using a deterministic model, but in the next article, we will explore models which fit to real data.

I’ll do this in roughly reverse chronological order, for want of a better way:

I found out yesterday that I got a 2:2. This is very frustrating, though it puts me in good company. Thinking back, I guess there are enough exams that were probably worth a 2:2 or worse and where I should have been getting a first (Data Transmission, Signal and Pattern Processing, silly bits on Software) and our group project was really dreadful (though Dave Forster managed a 2:1, so it can’t have been that bad). At the end of the day, I knew that I wasn’t getting the first that I was predicted by many, but I didn’t let myself think I’d done *that* badly. A mark breakdown would be interesting to look at.

I’d like to think that I’m worth more (to a company) than a 2:2, but if I can’t perform well in exams, and I can’t do projects, then I have no justification for saying that I am: No matter what my supervisors might think.

My 4th year project is looking very exciting. I’m doubtless boring most of my friends horribly about it, but such is life. Right now, I’m getting very frustrated by the Engineering library because they require a signature or email from your supervisor before they let you take a book out over the holidays. This makes my life hard because my official supervisor is never around the department, and I’m not allowed to use the email from my de facto supervisor that recommended the book in the first place. The problem is made worse because everyone is really busy during may week going to functions etc. What they really need is to allow either your supervisor or your DoS, because I’ve seen Digby loads of times this week.

John’s may ball was good. Interestingly, Hughes Hall was probably a better performance/lesson, even though we only really seemed to care about John’s. Performing has to be the best way to do a may ball, because:
1) It costs you £30 rather than £130.
2) You have all of your troupe there to hang around with, which is a bigger group than you would tend to get from within college.
3) Performance outfits are often more comfortable than ball dresses/shoes (for girls)
4) You have green-room areas to go back to, where you can store more clothes for if you get cold (the girls ended up in jeans and leather jackets etc. by the end).

DJing on Monday was kinda horrible, because I didn’t know my music collection well enough, and it wasn’t an especially big collection (2GB on an SD card). On the other hand, I now know that everyone can shut up and stop trying to get me to play stuff at less than 120bpm for charleston-derived stuff. I also recognise that it would be sensible to buy a usb sound card, so I can preview tracks before I play them. Alternatively, I could just get a shift-on with my project, so I can just cluster my collection, and work from that. Also, if anyone can tell me how to fix my eeepc so that it stops trying to mount my SD card repeatedly, and it keeps the mount point there after I eject, so amarok doesn’t get confused: that would be nice.

Some of you might be familiar with python (or haskell, or erlang or …)’s map, filter, and reduce functions. You may also be familiar with lambda expressions, and think that they’re really ugly (especially in python)

If so, check this out (genuine input and output lines from ipython)


In [358]: filter(var==2, [1,2,3,4,5,4,3,2,1])
Out[358]: [2, 2]

In [363]: filter(var>2, [1,2,3,4,5,4,3,2,1])
Out[362]: [3, 4, 5, 4, 3]


So how did I do it? Well if I could get it to indent correctly then it might look like this:

class Placeholder(object):
    def __lt__(self, other):
        def match(arg):
            return arg < other
        return match
    def __ge__(self, other):
        def match(arg):
            return arg >= other
        return match
    def __le__(self, other):
        def match(arg):
            return arg <= other
        return match
    def __eq__(self, other):
        def match(arg):
            return arg == other
        return match

var=Placeholder()

Now, I *think* this should generalise to map as well, for things like
map(var*5, [1,2,3,4,5,6,5,4,3,2,1] )
just implement __mul__ and friends. Annoyingly, there is also an __rmul__ function, so you don’t know which will be called. Also, don’t let python try to use __cmp__, because it actually checks the type of its return value (so you can’t return a curried function)

Okay, that’s enough g33k for tonight.

[edit: fixed lessthan and greaterthan signs]

Alex pointed me at http://en.wikipedia.org/wiki/Peer_Name_Resolution_Protocol, saying it was confusing him. I’m not surprised: It appears to be made of epic lolz (as you might expect from redmond)

From what I’ve gathered, it’s basically a patented, “secure” version of zeroconf, for use in p2p applications. “Features” include:

a) public key “secured” name resolution, of the form hash(key):name.
b) IPv6 only.
c) Can be extended to the internetz at large, using a known server (provided exclusively by MS).

Now correct me if I’m wrong, but surely 1 is not possible in a P2P system? Here’s my thinking:

1) The client must have before-hand knowledge of the public key.
2) The server must have knowledge of the private key.
3) All nodes in a P2P network are both clients and servers.
4) For commercially installable software, the client machine cannot be trusted.

5) 2, 3 imply that all copies of the software include the “private” key.
6) 4, 5 imply that the private key cannot be trusted

lolz on line 6.

So a) is not valid for the target market (to be honest: why the hell would you want security at the dns level anyway? Surely that’s what SASL crap and SSL are for?)

b) is probably about the only thing I’ve found that you need IP6 for.

c) makes it a bit like standard DNS then, I guess… except without the whole “dhcp support” or “interoperable implementations”, or any of the things you might want to help you avoid painful configuration issues.

I don’t need to talk about the blues dancing workshop, because a) it was obviously going to be amazing and b) rob has already blogged about it: http://www.srcf.ucam.org/~rec53/wp/archives/161

The other important event of the weekend was that my mum and dad came up. They have a van, which is a complete tax dodge, but nevermind. This means that I will have no trouble getting my stuffs back home in the holidays. They also brought my eeepc.

Now the eeepc does live up to its name: it’s very [squ]eee and quite [w]eee. There are a few little gems about it: the charger is like an oversized phone charger, for example, and there’s a light on the webcam that tells you when it’s being used. The user manual is pretty priceless. Version E3509, which I found and mirrored here: http://www.srcf.ucam.org/~dl325/scratch/e3509_15G06Q001001.pdf
gems include:
“The solid-state disk drive’s head retracts when the power is turned OFF to prevent scratching of the solid-state disk drive surface during transportation” — 1-5
The finger in 1-7 pointing to the power button
Section 5 contains some really useful hints for optimising windows XP for low disk usage. It seems that you can get windows (without office obv, and no backup partition) into about 2GB. The Xandros they have installed contains a complete recovery partition and OOo, Konq and Firefox, Kontact and Thunderbird, and webcam utilities etc. and leaves you with ~ a gig (can’t remember, and I need to run: will add the real number later.)

The only peeves I have are the windows-like “single user, who’s able to do pretty much everything” feel, and the large quantities of bespoke that have been piled on (you can’t set konq to do tabbed browsing, for example, and they’ve renamed *everything* apart from firefox) Also, it took Tom K to show me where the ~ was, after 5 minutes of my complaining.

So yeah: might be installing xubuntu if anyone can lend me a decent sized usb stick or remind me where my old 1GB SD card went. kthxbi

These terms do not just apply to romantic love: they also apply to my friends, and to my academic interests:
Do not expect my love without reason. I will love you for the reasons that you present to me in the form of your strengths.
Do not let me believe that I can be loved without reason: If I cannot strive to earn your love, I cannot love you.
Do not believe that I am bound to you love you just because I have loved you in the past.
Do not expect me to tell you that I love you if I don’t. If I am unsure, I will tell you that I don’t .

If you wish to meet me on these terms, I will meet you on these terms. If you wish to be met on any other terms, state them and they will be considered. I will attempt to keep a revised list of my terms up on my wiki.

*doesn’t know why he bothers with titles, when they contain nothing that’s not in the tags*

This is the feedback I got from IBM:

Your strongest exercise was your “Standard Interview”. You provided sound
examples of your drive and leadership, not only in technological
situations but also in your other interests. You clearly highlighted your
interest in developing your technical skills and proved yourself to hold a
great passion for technology.

That’s interesting, because I thought that went horribly. Seems they were trying to work out what I was good at here.

Your weakest exercise was the “Communications” exercise. It was felt that,
in both your letter and your presentation, you could have delivered your
answers in a more clear and concise fashion.

That’s not surprising: I didn’t have the first clue what they were wanting from me there. If I’ve not posted about that exercise already, poke me already.

Your strongest competency was your “analytical reasoning”. You displayed a
very logical approach to problem solving and a clear ability to cope with
complex issues. You analysed scenarios well and constructed logical
responses based on sound ideas.

Yeah: that was probably because of my efficient data structures that helped us infer our only correct piece of information, and my failed attempt at using algebra to solve a “5 people sitting on chairs” problem.

Your weakest competency was your “planning and organisation”. It was felt
that your presentation did not address the question in hand, which would
have been resolved with clear planning of the task.

Now that’s fucking annoying: I thought they were trying to work out what I was good at with this one, so I showcased a load of my projects, and hoped they would explain “Why am I suited to a career in Information Technology”. Seems they wanted me to spell it out to them. Oh well. I guess I’ll just have to learn how to jump through hoops better.

In other news, it seems that there is a permalink button on OpenStreetMap. If you click it, then change the lat and lon to mlat and mlon, you get a marker. It may be primitive, but I will certainly be using it for all linkerizing in the future: it’s much more convenient than adding points to http://www.cam.ac.uk/map/ , and hilariously more detailed than Google Maps.

If you wish to compare:

http://www.openstreetmap.org/?mlat=52.20114&mlon=0.1175&zoom=16&layers=B0FT

and

http://www.cam.ac.uk/map/v4/drawmap.cgi?mp=main;xx=1700;yy=1040;mt=a;mx=1770;my=1122;ma=180;tl=Little St Mary’s Hostel

Also, There’s rumours of being able to embed it as well. I’ll see if I can get that working shortly.

In Body related news, I think my back is strengthening up again. Mostly because I’ve been doing lots of dancing. I expect that by the end of LLX, I’ll be up for aerials and whatnot.

I had a private lesson with Gerald yesterday. We did a lot of body control and posture stuff, which was good for me. It took a lot of time to get started, because my posture is really quite bad. I’m not sure whether we genuinely fixed it, or whether it was a case of “That’s as good as it’s going to get. Let’s move on.” The idea of splitting your body into two sections and controlling them separately is useful. It lets you be aware of where they both are makes it easier to notice when you break your core, and feed back this information to correct it next time. Everything else we did really stems from there.

In my understanding, it seems that when you’re dancing basics, there are 3 things that you should be monitoring: your chest section, your pelvis section, and your partner’s chest section. Once you can be sure that you’re controlling your own sections, you should notice when one of them is not where you want it, and feedback (subtly) on the next basic, to correct.

The really intriguing part of the lesson was the end: When we were finishing off, I was quite quick to say “I have my cheque book”, which was a little “I have just bought that time and knowledge off you” of me. His response was difficult to interpret: He was very reluctant to take money in payment. Now I initially thought that this was because he didn’t want to take money from a student, but I’m not so sure: He asked me if I could teach *him* anything that would be interesting to him, so that it could be a knowledge exchange. When I eventually managed to force some money on him, I felt like it wasn’t nearly as much as the lesson was worth to me.

The exchange showed me that we seem to share a few important ideas: “Knowledge is worth more than money, so any exchange involving money will always be unfair.” Also: “It’s better to come off worse in a deal. That way, the other party will always feel the need to repay the debt.” The thing I *didn’t* realise was that he did a PhD in computer vision and augmented reality (this came out when I was trying to think of things I could teach him). Not only that, but he did a couple of years in industry before doing it. Now I was planning to do about 4 years in industry before going for a PhD, but I can see why it might be a good idea to do it after 2. I think I have even more respect for him now.

So we come to the problem of “What can you teach a man who has spent N more years exploring the same stuff you’re interested in?”

The only thing that I’ve thought of so far is that I might be able to teach him some linux crap: He knows C/C++, but uses windows XP on his laptop. He doesn’t use java or C#, so he’s unlikely to be locked in by the same stuff that Alex is screwed by. It might be that he already uses it, but needs windows for iTunes, or it might be that he simply doesn’t use it (for whatever reason).

In the first case, I could show him around Amarok, and tailor my moodbar project to him (he has trouble picking songs that have the right tempo, and he said that it would be useful). In the second case, I could probably tweak a distro for him, and show him around. I expect it would be OpenSuse, or Hardy with instructions to just do security updates, because Ubuntu’s upgrade process has fucked up too many of my friends’ installs.

In other news, I found a way to get around my problem of having no access to external servers on which to play teeworlds: Set up my own on soup.linux.pwf.cam.ac.uk :D. If anyone fancies a game: prod me, and I’ll fire it up again. Because it registers itself on the internet, you get lots of random players joining, which is cool. I might see if I can mod the server to gather some statistics. See if I can train a bot or something. That way, if attacks me for running an IP server on PWF, I can say that it’s a research project, relevant to my course.