What Baxter Means for Research in Robotics

Short story: awesome! You can keep reading now if you want to know why I think so.

Today I was listening to an interview of Rodney Brooks speaking about Baxter. When I saw it featured on IEEE Spectrum I thought: “Cool, let’s see where it goes”. But listening to Brooks describing his creature gives you a different perspective.

Take a decades old task, like automatic assembly. Take a new technology like learning from demonstration. Then show the world that research can go out of the labs and change people’s life. Isn’t that easy?

No it isn’t. I haven’t seen Baxter in action but I bet there are a lot of hacks and assumptions that make it do a proper job. But that’s reasonable, even more, welcome. Most of the papers you’ll read in robotics start with a sentence along the line of:

We need robots  capable of learning from a non-expert to be usable in the real world.

And then it fires up equations, data collection, proofs and lab tests. However Rodney Brooks does something that he’s done in the past, actually he’s built his career around it: he does for real what others only discuss in papers and labs.

Don’t take me wrong, I’m not one more voice saying that research in University should be more application-focused and less theoretical. Baxter is build upon the research people in Universities around the world have done over the past years. Robotics, manipulation, computer vision, they all share the prize here.

This is a praise to all my colleagues who have worked hard and who never believed their research would make a difference. It takes a collective effort to change the world.

And a single mind who figures how to make money out of it.

 

A Short Account of Wrapping C++ in Python

For the AI-challenge competition I am participating to, I found that path planning (using A*) was (obviously!) the  slowest part of my Python code.  It turned out that 80% of the computation was spent planning!

So I decided to find some good C++ code, wrap it in  Python and give it a go. The code I decided to use is MicroPather, which is incredibly easy to use and it seems to be pretty fast.  One only has to cope with passing void* around, and everything is easy.

I had heard a lot of good things from Cython, so I decided to give it a try. Alas, although the new support for classes seems promising, wrapping an already existing class and playing with polymorphism proved very hard.

To cut a long story short, I reverted to the old and  good Boost Python. It took me no time at all! Another proof that sticking to old approaches is still the best solution.

BTW, it’s incredible how an old and seldom updated library like boost::python is still so incredibly good by today’s standards and changing APIs!

Next plan: include python hooks in the c++ A* code, to the best of versatility!

 

The Complex Dance of a Prey

During my research on Emergent Behaviours I’ve been often questioned about the usefulness of something that you can’t control, you can’t predict and seems to be totally random. I’m not going through these points here, I’ll let the future talk about the past.

However, scientifically speaking, I need to prove a few points. In particular I was looking for answers to two questions:

• Can performance improve when allowing emergent behaviours?
• Is an emergent behaviour an expression of randomness?

To answer these questions I set-up a Predator-Prey scenario, where the predator had all the advantages, namely

• It is faster than the prey
• It is programmed by me

Armed with the python library PyEvolve I developed several preys without success. This went on until I decided to blend complexity and goal-pursuing. In other words I trained two recurrent neural networks, one to be complex and the other one to avoid the predator. A third network mixes the twos. The resulting prey speaks by itself:

This proved that complexity, the fertile ground for emergent behaviours, can improve the performance of a goal oriented system.

To answer the second question, I replaced the complex module with a random number generator. The result was awful: the prey could not survive for more than 40s !

Complexity (according to Kolmogorov, is not random. The chaotic processes have laws that a successful prey managed to exploit for survival. This hopefully gives me some breath in the struggle of proving that my research in emergent behaviours will lead to interesting results and ideas.

This work is currently under review in a journal publication… let’s hope for the best!