[kctess5]

That's not exactly what the car in [1] does. They use stochastic optimal control methods, which are more domain specific. They perform forward simulation on a lot of trajectories and effectively pick a good one. They also use localization so control is based more on current position than sensor inputs. The machine learning component is the dynamics model identifications - determining how the car reacts to control inputs. The model is basically a complicated function with a few inputs and outputs, which tend to be smoothly varying, so ml techniques work very well. This is fairly standard in model predictive control since empirical motion models tend to outperform ones that are physics based.

Edit: looking at the paper, they apparently use many physics based models of the car as a basis, but then use ml to mix the models together.

[soared]

Unfortunately I don't know enough to see the difference, or even understand most of your comment :). I only read about ml for fun, I don't do anything with it! If understand it, the racecar computes potential paths it could take, while the drone looks at what caused it to fall vs. continue flying?

[kctess5]

No worries :) the drone basically generates a big dataset of "crashing" and "not crashing" video clips from the camera. It then feeds all that into a convolutional neural net, which can (after training is complete) give control decisions based on the camera which avoid obstacles. This is very "black box" in the sense that it's hard to say exactly how the system is working.

The car, on the other hand, uses hand written algorithms to forward simulate various controls. Based on the forward simulations, it can pick controls which are predicted to give good results. Forward simulation relies on a model of how the car reacts to any possible control. However, this model is complicated because of the nonlinear dynamics going on (inertia, wheel slip, etc). Therefore, they use ml techniques to identify the model.

[gridspy]

In the car case:

We write programs that predict how the car will drive given steering inputs. Because we're not sure, we write several programs that give slightly different answers.

Given a driving input, all the programs predict the future : Parent comment called this "forward simulation."

We pick the program that has worked well in the past and do what it says to do - that program drives the wheel of the car.

We measure what actually happens to the car. We then remember which algorithm actually gave us the right answers (might be different from the one we picked to steer) - next time, we'll trust that one more.

Because it's annoying to keep writing more programs, we figure out what we can tune - like a left / right balance knob on the stereo or a base / treble knob. In this case, it might be a "ground slipperiness" or friction knob.

So as well as picking the programs, we ask the algorithm to tweak the "friction" knob and try to pick a setting that seems to match reality.

---

In the flying case:

We make a "black box" full of sheets of numbers and put a picture into one side. Each dot in the picture does some maths with the first sheet of numbers which makes a new "picture" for the next sheet.

We run maths based on remembered numbers and the answer (say 0.0 - 1.0) tells us "safe to fly" or not. Lets say 1.0 is safe (0.0 unsafe, in-between unsure).

Once we figure out that a given picture was safe we go backwards through the sheets of numbers to apply "back propagation" and change them - we make the "safe" picture output something closer to 1. Perhaps it output 0.50 before, now that same picture outputs 0.51. If the picture was unsafe, we adjust the other way.

We do that LOTS of times. Eventually safe pictures output 0.91 and unsafe ones 0.12 or something. We show the computer a new picture, and we call the answer "Safe" (say 0.8-1.0) "unsafe" (0.0-0.2) and unsure (0.2-0.8). We fly only towards pictures which are "safe".

Everyone pops champagne. We didn't learn much - only that lots of numbers can solve more wacky problems than before. It's hard to generalise what the computer "learnt" or really understand it.