M2M Day 193: The more I know, the less I need to know
This post is part of Month to Master, a 12-month accelerated learning project. For May, my goal is to build the software part of a self-driving car.
Two days ago, I went through the meat of the self-driving car code and identified the open questions that I had about how it works.
As I’ve been digging into these questions, I’ve begun to realize that, from a purely application standpoint, it’s not super necessary to understand most of the underlying math / computer science to build an effective deep learning system. Naturally, I’m interested, so I’ve been learning as I go, but it’s certainly not essential at all.
Basically, here are the important things to know:
- In a Convolutional Neural Network, at the top of “the stack”, there are convolutional layers that learn which convolution operations (i.e. image manipulations) highlight the best features to learn on.
- Then, there are some Full Connected Layers that try to learn how to produce the correct output based on the features highlighted by the convolutional layers.
- In between, there are some mathematical tricks (like downsampling and rectifiers) that speed up the learning process.
- Determining the shapes and parameters of the layers is usually done empirically (i.e. try different options and pick the configuration that produces the best results).
In regards to #4, in Nvidia’s paper, which describes the deep learning system I’m using, they explain that “the convolutional layers were designed to perform feature extraction and were chosen empirically through a series of experiments that varied layer configurations.”
So, here’s the punchline: The secret to setting up an effective Convolutional Neural Network is to try a bunch of different combinations of the normally used components and see what works the best.
Basically, as long as you understand the basic components, building an effective self-driving car (Nvidia’s is 98% autonomous) is not much more than “guess and check”. (It could be argued that if we want to get the car from 98% to 100% autonomous, we must do a little bit more than guess and check, which is true today, but will probably become less true over time as we ever-increasingly apply more processing power to the problem).
Of course, under the hood, the implementations of all these “basic components” are more complex, but luckily the TensorFlow library has essentially abstracted away all of this work. Plus, we’ve gotten to a point where hobbyists are publishing full open-sourced self-driving car models on GitHub.
I predict that in 18–24 months we get to a level of abstraction where a self-driving car can be created in one-line of code — which I guess means that this month’s learning challenge isn’t going to age very well.
In this regard, this month’s challenge seems to point to the following lesson: Sometimes “learning hard things” is just peeling away the ambiguity or intimidation, and finding that, once you are oriented, things aren’t too challenging.
Since I’m now oriented, I won’t spend any more time digging into the theory (at least for the next week or so). Instead, I’ll shift my focus back to pure application and see if I can expand the capabilities of my self-driving car.
Read the next post. Read the previous post.
