That line will generate an infinite list containing even numbers. I can look @ that line all day and wonder at the beauty of this language. Haskell is God’s language.

In the Japanese alphabet(s), a character is composed of strokes. These strokes have a fixed order. This restriction is pretty much all you need. I grab the stroke’s end points and centroid and then normalize.

Once, a stroke is finished, a nearest-neighbor classifier runs and fetches 3 best matches. I have had very decent performance with this approach. Right now, no information about the distance between successive strokes is used. Incorporating that should improve performance by a significant amount.

Here’s a video of the classifier in action:

The full source code (very kludgy) is on github.

I have further ideas on improving the perf and training with some Kanji.

Enjoy :)

My goal was to be able to record finger gestures and then detect them when a user makes these gestures. I had 2 goals in mind – no OpenCV (i.e. I will use just depth data) and no wearing special stuff to guide anything.

So, let us see what I did. Basically, I used the CandescentNUI Hand Tracker to get a collection of fingertip locations and points and then applied two techniques to try and recognize the gestures we make.

First, I tried using the Passive-Aggressive algorithm by Crammer et. al. This algorithm uses an online-learning approach to build a hyperplane (in 3 dimensions, this is a plane, in 2 dimensions – a line etc. Basically, this is what is defined when you try to define a “surface” like structure for a space. Take 2 non-parallel vectors in 3D space and you can construct the entirety of the 2D world. The hyperplane is just that – an entire space (a subspace with 1 dim less than the one we are operating in).

The hyperplane is supposed to act like a brick wall (if we’re in 3D – no point visualizing a higher dimension). When we see a new data point come in, we want to inspect on which side of the wall it lies and then we can “detect” or label this point. This is the binary classifier.

The dataset consists of raw point coordinates in the space of the human palm seen by the kinect. Now it turns out that the online passive-aggressive algorithm fails at constructing a decent hyperplane separating 2 classes (data points for 2 different gestures).

The obvious hack was to deploy a nearest neighbors classifier. The trick I used was that I ran a large cluster k-means on the data and built myself a dataset consisting entirely of cluster centers. So I was able to reduce the neighbors tenfold and still get fantastic performance. A simple technique worked fabulously in this situation and I couldn’t be more pleased.

Here is a video of the gesture-detector in action. The annotations should show you what to look @

The source is up on github. The code is very kludgy and I will fix it up after finals week. In case you’re in a hurry : http://github.com/shriphani/KinectSpell 

Now, it is time to try and avoid failing in the finals x(.

Anyway, I promised myself that coursework would be for learning and not for grades but that hasn’t worked wonders for me – maybe grad school will offer some fresh perspective on education (which I desperately need since I have been a bit demotivated by these fuck-ups that are out of my control).

Oh well – my GPA’s ok and 1 dip in performance will not kill it.

Reductions were (I am using the past tense since I haven’t picked such problems up in the recent past) central to proving NP Completeness. One of the rather interesting pitfalls undergrads @ Purdue seem to be facing is in understanding the reduction process.

In particular, I could boil their confusion down to something like this:

I know something about problem “a” (in this case, “a” is NP-Complete). So, if I need to figure something out about the NP-Completeness of some problem “b”, I will make a sincere effort to solve it using “a”. If I solve it using “a”, “b” is NP-Complete.

WRONG! I am a math major and I see the temptation to use a known problem’s solution to make some inferences about an unknown problem but seriously that is not what you are looking for here.

The fail in this approach is that no one is able to grasp the correct trail of thought. This is how you think:

I have some information about the perf of a, let me use that to make some inferences about b.

How do you infer stuff about b using a?

Let us say we are faced with the following problem:

You are sitting in level 1 of the Lawson CS Building. Your goal is to go to the basement.
Last week, you figured out:

• How to get to Level 2 from Level 1 (takes 2 minutes)
• How to get from Level 1 to the basement.  (takes 4 minutes)

So, here’s a diagram and a problem description:

To be solved: Get to basement from level 1

What we know: Getting to level 2 from level 1 (takes 2 minutes), Getting to basement from level 2 (takes 4 minutes)

So, if you apply the ass-backwards thinking that most people seem to do, we would go from level 1 to level 2 and then go to the basement from there in a grand total of 6 minutes.

Ok, what then? Well, using the problem solving structure you were applying before, you ended up concluding that going from level 1 to the basement will take 6 minutes (just like how you concluded that b is now NP-Complete).

But that is dead wrong. From what we see, the path you choose to solving a problem tells you nothing about how easily the problem can be solved!
When you chose to solve “b” using “a”, you made a (potentially stupid) choice about how to solve “b”. Possibly “b” could have a polynomial time solution and you still chose to apply a solution to it that won’t finish till your grandkids are born.

Here is how you approach that problem:

• You know something about “a”. More precisely, you know “a” is NP-Complete. You know that there is no polynomial time algorithm known for “a”.
• You then decide, “Hey, let me see if I can solve “a” using “b”.
• If you figure out you can solve “a” using “b”, then obviously, the theoretical lower bound you computed for “a”, holds for “b”.  You now know that “b” cannot do better than “a” (if it did, you might have proved P = NP :)).
• Well, now we know that since “b” cannot do better than “a”, “b” is NP-Complete    (You still need to prove that “b” is in NP but I am assuming you know how to do that)

That wasn’t so hard, was it?

Some salient features of Scheme code I’ve written so far (not features of scheme but shit “I” do with it):

• Aggressive use of map-reduce. I found this too sexy, I use it everywhere.
• If it compiles, it is most definitely correct (at least I’ve never had runtime fuck-ups happen to me – this is pretty nice since with some thinking I could accomplish quite a lot in scheme).
• I have very aggressively used lambdas.

Keeping these new habits in mind, I sat down to tackle a p-set yesterday and finished in no time. I then was unable to comprehend the reason why I was so slow compared to the demo of his own solution (I was implementing the arc-consistency heuristic to solve n-queens). Upon investigation, I saw rubbish like this in my code:

Well foo-that-returns array was supposed to return a subset of values that satisfied a proposition (from an original finite domain). I totally carried over my rubbish habits from other prog languages ([] is #f and [...] is #t so I will continue to use those) rather than doing:

This looks a lot better and it was a lot faster. My reasoning for this speed improvement is that I just obtained a rather large array, checked for emptiness and then threw it away causing the scheme GC to kick in. Using some makes it look a lot more like a quantifier which is precisely how this procedure must be written. This summer, I really need to rock SICP and fix my shoddy half-knowledge situation with regards to functional programming.

Besides that, my research seemed to hit a roadblock close to the end of this semester when a sudden miracle (and a reddit-browsing approach to lit. search) led me to fix things so I can still declare victory. I will not post more about my work since I am applying the Mao approach (is it even Mao? I don’t know) – “Keep your head low and rise to the top, then the world will take notice”. I have a bad habit of gloating after I post stuff here, it is best if I only put materials here after I finish (and hopefully produce a sexy paper).

Anyway, more posts (better in quality than this) to follow.

I finished the buffer manager and we were about to go write the heap when I decided to take a break. This super-smart dude decides to kick off. I see his code after a short while:

FileWriter a = new FileWriter()……

I’m like “DUDE !   NO I/O OPERATIONS!”

I manage to extract a blank stare out of him.

I try to explain, “We do not write any I/O code. We wrote an entire buffer manager for a reason you know”.

He nods. I return after 10 mins, he’s typing away furiously with more FileWriter … blah blah blah.

I explain the concept of the DB again – “cost is measured in no. of I/O ops. The buffer manager exists to page things in and out. What the fuck are you doing !”

The third time he gives up. I had to finish the heap file.

I just wonder what is the department doing ? How can we unleash such graduates on the world ?   I know why. We expect code to be given to us with 5 functions done so we can fill in the other 3. FILL_IN_THE_BLANK programming.

I want to go break something now.

I recently made the switch from Mac OS X to Windows (I now own a 17” XPS which is an absolute beast of a machine). I have recently developed a major habit of wasting my time on sites like reddit, facebook (the addiction is rather huge here), gizmodo, engadget and the like. To get work done, it was imperative I used my web browser lesser than usual. Luckily, I found one of the best apps ever written to boost productivity: SelfControl came to my rescue here. SelfControl allows you to type in a list of sites you want to block and you are all set. Essentially, the one stop solution for people with my problem.

I couldn’t find a free app on Windows (which sucks) so I decided to go write my own. Of course, this doesn’t even match the awesomeness that SelfControl packs in its UI (I use the command line and a text file for user input and SelfControl has absolutely the best user interface for the job) and I still don’t have persistence across reboots etc working (* yet).

My “app” (a small script) reads in domains from .\list.txt (you can change it in the script) and adds this one line to the System hosts file:

127.0.0.1    _user_submitted_domain_

and voila, site is blocked. For running the app, you need to supply no. of minutes blocked as a command line argument. So you would run:

python WinSelfControl.py #number_of_minutes

and it should go block it.

Of course, there are some quirks. For example: www.facebook.com is needed to block facebook. I initally added just facebook.com and it didn’t work (probably my misunderstanding of how hosts files work).

Also, this app isn’t persistent across shutdowns. If you shut-down in the middle of its execution, you will have to kick out the lines added to the hosts file yourself. So beware!

This was the product of a few hours and at last I can get back to productivity.

I have only tested this on a 64 bit Windows 7 machine. Also, this code looks like spaghetti code and it might break something. So no warranties there.
Source uploaded here: http://shriphani.com/scripts/WinSelfControl.py

Besides this, Microsoft interview on Tuesday, thanksgiving break and finals approaching fast etc. etc. Whatever.