My work with pyplot continues. I spent some time today working with 3D plots. matplotlib (the parent library of pyplot) does a great job making 3D plots with very little code, but it doesnâ€™t quite go far enough to make it trivial.

In my particular case, I had a big collection of 3 dimensional data points. These were actually motion control points related to acceleration, velocity, and brake, but you could just as easily imagine these as lidar points with x, y, and z coordinates.

In a perfect world, Iâ€™d pass these points to pyplot and get a 3D plot.

In an even more perfect world, Iâ€™d pass these points to pyplot and get a 3D contour.

Unfortunately, the world is not perfect. Although it is still pretty awesome that pyplot can create these types of plots in a Jupyter notebook. I just have to configure the data properly.

I took a while to wrap my head around this, but specifically what it turns out I need to do is find a discrete set of x values, and a discrete set of y values, such that I have the z value for every combination of x and y.

It would have been great if pyplot could have interpolated (â€śfilled in the blanksâ€ť) from the values I had at hand. But as far as I can tell, pyplot doesnâ€™t do that.

At first I thought that might sink me, but then I realized that if I chose my z-coordinate properly, and scaled back the range of my y-coordinates, I could achieve this.

The plot wound up looking kind of boring, but boring in this case was good! If it were interesting, I might have been obliged to discard my linear model and start looking for something polynomial. A boring plot means I get to keep my boring (and manageable!) linear modelÂ đź™‚

To try and answer this question, Iâ€™ll begin with a story. In October of 2016, Udacity welcomed the first class of students into our Self-Driving Car Engineer Nanodegree program. Since that historic debut, we have been delighted to enroll over 11,000 students around the world in this program!

Along the way, we learned that while people across the globe were thrilled at the prospect of being able to work on autonomous vehicles, not all of them were equipped to do soâ€”many of them needed additional training to get ready for the rigors and challenges of our curriculum.

In order to provide a viable point-of-entry for these eager learners, we built the Intro to Self-Driving Cars Nanodegree Program, and welcomed the first class of students at the end of 2017. This â€śIntroâ€ť program prepares students with the fundamentals in Python, C++, calculus, linear algebra, statistics, and physics that are necessary to become a Self-Driving Car Engineer.

Both Nanodegree programs are paths to a career in the self-driving car field, but the goals of each program are distinct, as are the skills one learns.

The Self-Driving Car Engineer (SDC) Nanodegree program is an advanced program in which students write programs in Python and C++, and learn new frameworks like ROS and TensorFlow. Students entering SDC should be able to write programs from scratch, and should be comfortable with both calculus and linear algebra. SDC does not require solving differential equations by hand, but does require that students be comfortable interpreting mathematical notation and translating it into code.

The Intro to Self-Driving Cars (iSDC) Nanodegree program is an intermediate program that requires entering students to have only minimal programming and math knowledge. Students entering iSDC should be comfortable reading and modifying code in at least one language (Python helps, since that is first language the program uses). Entering students should also be comfortable with high-school algebra. From there, iSDC teaches the trigonometry, calculus, linear algebra, statistics, and physics that are necessary to succeed in the advanced SDC program.

iSDC does not require an application to enroll, and everybody is welcome. However, students with no programming experience at all might consider starting their journey with Udacityâ€™s Intro to Programming Nanodegree program, and then proceeding on to Intro to Self-Driving Cars. A slightly more mathematical (and more challenging) alternative first step would be Udacityâ€™s Data Analyst Nanodegree Program.

Intermediate programming ability in C++ or Python (the languages of the autonomous vehicle industry)

Basic linear algebra

Basic calculus

Basic statistics

Basic physics

As a student in the Intro to Self-Driving Cars Nanodegree program, youâ€™ll build your skills up over the course of a four-month curriculum path that tackles each of these areas at a pace that is both manageable and rewarding. Best of all, youâ€™ll practice putting these skills to work on the types of projects that real self-driving car engineers work on every day.

If you love self-driving cars, but thought youâ€™d never get the chance to work on them, then this is the program for you.

Enjoy a look at some of the projects our students are building, including Finding Lane Lines, Traffic Sign Classifier, Behavioral Cloning, andÂ more!

Students in our Self-Driving Car Engineer Nanodegree program engage in a project-based curriculum, and from the moment they enroll, they begin addressing key challenges and topics through building specialized projects. Here are all of the projects they build!

Finding LaneÂ Lines

This is the first project students complete, one week into the program.

They learn to work with images, color spaces, thresholds, and gradients, in order to find lane lines on the road. Stack: Python, NumPy, OpenCV

Traffic Sign Classifier

In this project, students train a convolutional neural network to classify traffic signs.

To do so, they use the German Traffic Sign Recognition Benchmark dataset. This particular student went above and beyond to train his network to not only classify signs, but also localize them within the image, and applied his classifier to a video. Stack: Python, NumPy, TensorFlow

Behavioral Cloning

Here, students record training data by manually driving a car around a track in a simulator.

Then they use this camera, steering, and throttle data to train an end-to-end neural network for driving the vehicle, based on NVIDIAâ€™s famous research paper. Stack: Python, NumPy, Keras

Advanced LaneÂ Finding

By applying advanced computer vision techniques, such as sliding window tracking, to a dashcam video, students are able to track lane lines on the road under a variety of challenging conditions. Stack: Python, NumPy, OpenCV

Vehicle Detection andÂ Tracking

Students use machine learning techniques and feature extraction to identify and track vehicles on a highway. Stack: Python, NumPy, scikit-learn, OpenCV

Extended KalmanÂ Filter

An extended Kalman filter merges noisy simulated radar and lidar data to track a vehicle. Stack: C++, Eigen

Unscented KalmanÂ Filter

An unscented Kalman filter merges noisy, highly non-linear simulated radar and lidar data to track a vehicle. Stack: C++, Eigen

Kidnapped Vehicle

Students develop a particle filter in C++ to probabilistically determine a vehicles location relative to a sparse landmark map. Stack: C++

PID Controller

Students build and tune a proportional-integral-derivative controller to steer a vehicle around a test track, following a target trajectory. Stack: C++

Model Predictive Control

Students build and optimize a model predictive controller to steer a vehicle around a test track, following a target trajectory. Stack: C++, ipopt

Path Planning

In this project, students construct a path planner for highway driving based on a finite state machine.

The planner has three components: environmental prediction, maneuver selection, and trajectory generation. Stack: C++

Semantic Segmentation

Students train a pixel-wise segmentation network that identifies and colors road pixels to identify free space for driving. Stack: Python, TensorFlow

Safety Case

Students build a prototype of a safety case for a lane-keeping assistance ADAS feature, including the safety plan, hazard analysis and risk assessment, functional safety concept, technical safety concept, and software requirements.

Programming a Real Self-Driving Car

For this project, students form teams to drive a real self-driving car around the Udacity test track.

The car is required to negotiate a traffic light and follow a waypoint trajectory. Code is built first in the simulator, and then deployed to Udacityâ€™s self-driving car in California. Stack: Python, ROS, Autoware, TensorFlow