
ALVINN, an autonomous land vehicle in a neural network (1989) [pdf] - scvalencia
http://repository.cmu.edu/cgi/viewcontent.cgi?article=2874&context=compsci
======
Animats
I've been in that autonomous vehicle, although it wasn't moving at the time.
Their road-follower worked only in very good circumstances.

The amazing thing is how much progress there's been in CPU power. That thing
took three racks of computers, and a crew of 5, to drive 5 MPH. They had a 3D
LIDAR, though, with a line scanner and a tilting mirror. That was better than
most of the LIDAR units until recently.

~~~
jacquesm
Animats, you've been at this longer than anybody on HN from what I can see,
question for you: What in your estimate is going to be the failure rate of
these self-driving set-ups and what kind of failsafe measures to gracefully
shut-down are still on the table once a major sensor fails?

I'm wondering about this because I miss this element in most of the
discussions around the theme, a human having a heart attack or a stroke behind
the wheel is almost certainly going to cause an accident (one sided at best,
multiple vehicles at worst). But I don't quite see how that translates into
sensor failure (or even CPU failure) in a self driving car.

~~~
hsjoberg
You will always have a redudancy of sensors in case they fail. The front
looking camera usually does have a complimentary lidar and most cars are even
equipped with both camera and radar in case a sensor goes AWOL. This will be
the case is selfdriving cars as well. I think they will have even more
redudancy then we see with ADAS cars today.

~~~
jacquesm
Every sentence you wrote contains the word 'will', so they are 'forward
looking statements' and evidence free. I understand that we'd _like_ this to
be so but there is no guarantee that it will be the case and a single, non-
redundant sensor going down could have immediate impact on the cars ability to
get itself off the road in a safe way.

This wasn't about opinions but about the state-of-the-art and the facts as we
know them today. What will happen in the future is anybody's guess, my guess
is that before long there will be a couple of major crashes involving self
driving cars resulting in mandatory redundant systems and redundant (quorum
based, see Animats' comment) processing units. Otherwise self driving cars
will end up with a bad reputation, even if the chances of failure with any
individual vehicle are small.

Statistically speaking the number of components and the their internal
complexity are good indicators of how frequently you can expect such a system
to fail. Self driving cars are sufficiently complex that these are legitimate
sources of worry and simply waving those worries away with what 'will' happen
does nothing for me, it is the _how_ that interests me.

~~~
hsjoberg
Ofc they will fail at some point, there is nothing magical about a self-
driving car. What I meant with the previous post is that it could be fail-
operational see for example the volvo drive-me.

------
cr0sh
Now easily replicable (in smaller form) with a smartphone and an Arduino:

[http://blog.davidsingleton.org/nnrccar/](http://blog.davidsingleton.org/nnrccar/)

Interesting story behind the creation of that: David Singleton was one of my
"classmates" in Andrew Ng's ML Class in the Fall of 2011 - I was both amazed
and pleased that he managed to create this demonstration after we had played
around with building a neural network using Octave, and after seeing the many
video clips (about ALVINN) that were a part of the class that showed how it
worked.

That class ultimately led to the founding of Coursera - the class the
Sebastian Thrun and Peter Norvig were running at the same time (AI Class) let
to Udacity. Coursera still offers that original ML Class (called something
else now).

As a part of Udacity's Self-Driving Car Engineer Nanodegree, one of the
projects in the first term was to get a simulated car to drive around a track.
Many (if not most) of us chose to implement NVidia's End-to-End CNN approach
(there were also a few that repurposed ImageNet) - either in whole or in a
modified form. Ultimately, with the right amount of training and datasets, the
car would drive well around the track.

I find it amazing how far we've come in the short amount of time between that
ML Class course and today, in the development of machine learning. I just hope
we don't fall into another winter that'll take a decade or more to pull back
out of...

------
edejong
This ALVINN promotional video is a good demonstration of the (1989)
technology:
[https://www.youtube.com/watch?v=ilP4aPDTBPE](https://www.youtube.com/watch?v=ilP4aPDTBPE)

------
omarforgotpwd
Basically the same core design as Tesla autopilot and other autonomous
software today... but the hardware to make a useful finished product just
weren't available yet. Way ahead of it's time.

~~~
tachyonbeam
It's not _just_ a matter of hardware. People didn't really know how to train
neural networks more than 1-2 layers deep at the time. This is also before
convolutional neural networks were invented by LeCun.

This network is literally 30x32 pixels => two NN layers => steering decisions.
No convolution, no semantic segmentation. It's a very cool technical
demonstration, but we've come a long way since, on every front.

~~~
cr0sh
...and apparently it still took a good amount of time to train.

If you dig enough thru the various papers and such written about ALVIIN,
you'll find links to older projects, and a couple of "follow on" ones as well.

One of the earlier projects that (I believe) led to ALVINN was the CMU
Terragator - this was a custom 6-wheel chassis about the size of a large quad-
cycle that was designed to navigate around the CMU campus. It was basically a
testing platform for autonomous vehicle technologies. IIRC, this was around
1984 or so.

After the Terragator, but prior to ALVINN (and ultimately led to the funding
for ALVIIN) there was a project to develop a radio-controlled vehicle that
could navigate through an unstructured environment (a cluttered alleyway,
IIRC) called "DAVE".

These projects and more are all referenced in the NVidia End-to-End CNN paper.

