Nanodegree key: nd013
Version: 1.0.0
Locale: enus
Work on some of the most cuttingedge technologies and help make the selfdriving car revolution a reality!
Content
Part 01 : Computer Vision and Deep Learning
In this term, you'll become an expert in applying Computer Vision and Deep Learning on automotive problems. You will teach the car to detect lane lines, predict steering angle, and more all based on just camera data!

Module 01: Introduction

Lesson 01: Welcome
Welcome! This lesson will introduce you to the program, help you discover the services we provide, and show you all the incredible projects you'll build!
 Concept 01: Why SelfDriving Cars?
 Concept 02: Meet Your Instructors
 Concept 03: Overview of ND Program
 Concept 04: What Projects Will You Build?
 Concept 05: Nanodegree Support
 Concept 06: Career Support
 Concept 07: Community Code of Conduct
 Concept 08: Deadline Policy
 Concept 09: Class Schedule
 Concept 10: Rating Your Career Confidence
 Concept 11: SelfDriving Car History
 Concept 12: The Great Robot Race (Optional)
 Concept 13: SelfDriving Car Quiz

Lesson 02: Workspaces
An introduction to and explanation of Linuxbased workspaces that can be interfaced via a shell (BASH).

Lesson 03: Computer Vision Fundamentals
In this first lesson, you'll discover some basic computer vision techniques to find lane markings on the road. We’ll dive much deeper into computer vision in later lessons, so relax and have fun!
 Concept 01: Power of Cameras
 Concept 02: Setting up the Problem
 Concept 03: Color Selection
 Concept 04: Color Selection Code Example
 Concept 05: Color Selection
 Concept 06: Region Masking
 Concept 07: Color and Region Combined
 Concept 08: Color Region
 Concept 09: Finding Lines of Any Color
 Concept 10: What is Computer Vision?
 Concept 11: Canny Edge Detection
 Concept 12: Canny to Detect Lane Lines
 Concept 13: Canny Edges
 Concept 14: Hough Transform
 Concept 15: Hough Transform to Find Lane Lines
 Concept 16: Hough Transform

Lesson 04: Finding Lane Lines Project
In the first project, apply your new computer vision skills to find lane markings on the road!


Module 02: Careers: Orientation

Lesson 01: Career Services Available to You
As you learn the skills you’ll need in order to work in the autonomous vehicle industry, you’ll see optional Career Lessons and Projects that will help ensure you're best presenting your new skills to potential employers. Meet the Careers team who will help you meet your career goals.


Module 03: Deep Learning

Lesson 01: Introduction to Neural Networks
Learn to build and train neural networks, starting with the foundations in linear and logistic regression, and culminating in backpropagation and multilayer perceptron networks.
 Concept 01: Neural Network Intuition
 Concept 02: Introduction to Deep Learning
 Concept 03: Starting Machine Learning
 Concept 04: A Note on Deep Learning
 Concept 05: Quiz: Housing Prices
 Concept 06: Solution: Housing Prices
 Concept 07: Linear to Logistic Regression
 Concept 08: Classification Problems 1
 Concept 09: Classification Problems 2
 Concept 10: Linear Boundaries
 Concept 11: Higher Dimensions
 Concept 12: Perceptrons
 Concept 13: Perceptrons II
 Concept 14: Why "Neural Networks"?
 Concept 15: Perceptrons as Logical Operators
 Concept 16: Perceptron Trick
 Concept 17: Perceptron Algorithm
 Concept 18: NonLinear Regions
 Concept 19: Error Functions
 Concept 20: Logloss Error Function
 Concept 21: Discrete vs Continuous
 Concept 22: Softmax
 Concept 23: OneHot Encoding
 Concept 24: Maximum Likelihood
 Concept 25: Maximizing Probabilities
 Concept 26: CrossEntropy 1
 Concept 27: CrossEntropy 2
 Concept 28: MultiClass Cross Entropy
 Concept 29: Logistic Regression
 Concept 30: Gradient Descent
 Concept 31: Gradient Descent: The Code
 Concept 32: Perceptron vs Gradient Descent
 Concept 33: Continuous Perceptrons
 Concept 34: Nonlinear Data
 Concept 35: NonLinear Models
 Concept 36: Neural Network Architecture
 Concept 37: Feedforward
 Concept 38: Multilayer Perceptrons
 Concept 39: Backpropagation
 Concept 40: Further Reading
 Concept 41: Create Your Own NN
 Concept 42: Summary

Lesson 02: MiniFlow
In this assignment, you will build your own neural network library from scratch! Your library, MiniFlow, will behave much like TensorFlow, Google's deep learning library.
 Concept 01: Introduction to MiniFlow
 Concept 02: Introduction
 Concept 03: Graphs
 Concept 04: MiniFlow Architecture
 Concept 05: Forward Propagation
 Concept 06: Forward Propagation Solution
 Concept 07: Learning and Loss
 Concept 08: Linear Transform
 Concept 09: Sigmoid Function
 Concept 10: Cost
 Concept 11: Gradient Descent Part 1
 Concept 12: Gradient Descent Part 2
 Concept 13: Backpropagation
 Concept 14: Stochastic Gradient Descent
 Concept 15: SGD Solution
 Concept 16: Under the Hood Part 1
 Concept 17: Under the Hood Part 2
 Concept 18: Outro

Lesson 03: Introduction to TensorFlow
Vincent Vanhoucke, Principal Scientist at Google Brain, introduces you to deep learning and Tensorflow, Google's deep learning framework.
 Concept 01: Deep Learning Frameworks
 Concept 02: Introduction to Deep Neural Networks
 Concept 03: What is Deep Learning?
 Concept 04: Solving Problems  Big and Small
 Concept 05: Let's Get Started!
 Concept 06: Installing TensorFlow
 Concept 07: Hello, Tensor World!
 Concept 08: Quiz: Tensorflow Input
 Concept 09: Quiz: Tensorflow Math
 Concept 10: Transition to Classification
 Concept 11: Supervised Classification
 Concept 12: Let's make a deal
 Concept 13: Training Your Logistic Classifier
 Concept 14: TensorFlow Linear Function
 Concept 15: Quiz: Linear Function
 Concept 16: Linear Update
 Concept 17: Quiz: Softmax
 Concept 18: Quiz: TensorFlow Softmax Workspaces
 Concept 19: OneHot Encoding
 Concept 20: Quiz: OneHot Encoding
 Concept 21: Cross Entropy
 Concept 22: Minimizing Cross Entropy
 Concept 23: Practical Aspects of Learning
 Concept 24: Quiz: Numerical Stability
 Concept 25: Normalized Inputs and Initial Weights
 Concept 26: Measuring Performance
 Concept 27: Transition: Overfitting > Dataset Size
 Concept 28: Validation and Test Set Size
 Concept 29: Validation Set Size
 Concept 30: Validation Test Set Size Continued
 Concept 31: Optimizing a Logistic Classifier
 Concept 32: Stochastic Gradient Descent
 Concept 33: Momentum and Learning Rate Decay
 Concept 34: Parameter Hyperspace!
 Concept 35: Quiz: Minibatch
 Concept 36: Quiz 2: Minibatch
 Concept 37: Epochs
 Concept 38: AWS GPU Instances
 Concept 39: Intro TensorFlow Neural Network
 Concept 40: Lab: Neural Network Workspaces

Lesson 04: Deep Neural Networks
Vincent walks you through how to go from a simple neural network to a deep neural network. You'll learn about why additional layers can help and how to prevent overfitting.
 Concept 01: Let's Go Deeper
 Concept 02: Intro to Deep Neural Networks
 Concept 03: Number of Parameters
 Concept 04: Linear Models are Limited
 Concept 05: Rectified Linear Units
 Concept 06: Network of ReLUs
 Concept 07: 2Layer Neural Network
 Concept 08: Quiz: TensorFlow ReLu
 Concept 09: No Neurons
 Concept 10: The Chain Rule
 Concept 11: Backprop
 Concept 12: Deep Neural Network in TensorFlow
 Concept 13: Training a Deep Learning Network
 Concept 14: Save and Restore TensorFlow Models
 Concept 15: Finetuning
 Concept 16: Regularization Intro
 Concept 17: Regularization
 Concept 18: Regularization Quiz
 Concept 19: Dropout
 Concept 20: Dropout Pt. 2
 Concept 21: Quiz: TensorFlow Dropout
 Concept 22: Quiz 2: TensorFlow Dropout

Lesson 05: Convolutional Neural Networks
Vincent explains the theory behind Convolutional Neural Networks and how they help us dramatically improve performance in image classification.
 Concept 01: CNNs Have Taken Over
 Concept 02: Intro To CNNs
 Concept 03: Color
 Concept 04: Statistical Invariance
 Concept 05: Convolutional Networks
 Concept 06: Intuition
 Concept 07: Filters
 Concept 08: Feature Map Sizes
 Concept 09: Convolutions continued
 Concept 10: Parameters
 Concept 11: Quiz: Convolution Output Shape
 Concept 12: Solution: Convolution Output Shape
 Concept 13: Quiz: Number of Parameters
 Concept 14: Solution: Number of Parameters
 Concept 15: Quiz: Parameter Sharing
 Concept 16: Solution: Parameter Sharing
 Concept 17: Visualizing CNNs
 Concept 18: TensorFlow Convolution Layer
 Concept 19: Explore The Design Space
 Concept 20: TensorFlow Max Pooling
 Concept 21: Quiz: Pooling Intuition
 Concept 22: Solution: Pooling Intuition
 Concept 23: Quiz: Pooling Mechanics
 Concept 24: Solution: Pooling Mechanics
 Concept 25: Quiz: Pooling Practice
 Concept 26: Solution: Pooling Practice
 Concept 27: Quiz: Average Pooling
 Concept 28: Solution: Average Pooling
 Concept 29: 1x1 Convolutions
 Concept 30: Inception Module
 Concept 31: Convolutional Network in TensorFlow
 Concept 32: TensorFlow Convolution Layer
 Concept 33: Solution: TensorFlow Convolution Layer
 Concept 34: TensorFlow Pooling Layer
 Concept 35: Solution: TensorFlow Pooling Layer
 Concept 36: Lab: LeNet in TensorFlow
 Concept 37: LeNet Lab Workspace
 Concept 38: CNNs  Additional Resources

Lesson 06: LeNet for Traffic Signs
Using the infamous LeNet neural network architecture, take your first steps toward building a Traffic Sign classifier!
 Concept 01: LeNet Architecture
 Concept 02: AWS GPU Instances
 Concept 03: LeNet Data
 Concept 04: LeNet Implementation
 Concept 05: LeNet Training Pipeline
 Concept 06: LeNet Evaluation Pipeline
 Concept 07: LeNet Training the Model
 Concept 08: LeNet Testing
 Concept 09: LeNet on AWS
 Concept 10: LeNet for Traffic Signs
 Concept 11: Visualizing Layers

Lesson 07: Traffic Sign Classifier Project
You just finished getting your feet wet with deep learning. Now put your skills to the test by using deep learning to build your own model to classify different traffic signs!

Lesson 08: Keras
Take on the neural network framework, Keras. You'll be amazed how few lines of code you'll need to build and train deep neural networks!
 Concept 01: Deep Learning Breakthroughs
 Concept 02: Introduction
 Concept 03: Deep Learning Frameworks
 Concept 04: High Level Frameworks
 Concept 05: Keras Overview
 Concept 06: Neural Networks in Keras
 Concept 07: Convolutions in Keras
 Concept 08: Pooling in Keras
 Concept 09: Dropout in Keras
 Concept 10: Testing in Keras
 Concept 11: Conclusion

Lesson 09: Transfer Learning
Learn about some of the most famous neural network architectures and how you can use them. By the end of this lesson, you'll know how to create new models by leveraging existing canonical networks.
 Concept 01: Introduction
 Concept 02: Bryan Catanzaro
 Concept 03: GPU vs. CPU
 Concept 04: Transfer Learning
 Concept 05: Deep Learning History
 Concept 06: ImageNet
 Concept 07: AlexNet
 Concept 08: Lab: AlexNet
 Concept 09: Lab: ImageNet Inference
 Concept 10: Lab: Traffic Sign Inference
 Concept 11: Lab: Solution  Traffic Sign Inference
 Concept 12: Lab: Feature Extraction
 Concept 13: Lab: Solution  Feature Extraction
 Concept 14: Lab: Training the Feature Extractor
 Concept 15: Lab: Solution  Training the Feature Extractor
 Concept 16: Lab: Conclusion
 Concept 17: AlexNet Today
 Concept 18: VGG
 Concept 19: Empirics
 Concept 20: GoogLeNet
 Concept 21: ResNet
 Concept 22: Lab: VGG, Inception (GoogLeNet) and ResNet
 Concept 23: Lab: Cifar10 Aside
 Concept 24: Lab: Feature Extraction with Cifar10
 Concept 25: Lab: Solution  Feature Extraction with Cifar10
 Concept 26: Lab: Feature Extraction with Traffic Signs
 Concept 27: Lab: Solution  Feature Extraction with Traffic Signs
 Concept 28: Lab: Transfer Learning Summary
 Concept 29: Outro

Lesson 10: Behavioral Cloning Project
Put your deep learning skills to the test with this project! Train a deep neural network to drive a car like you!
 Concept 01: Vehicle Simulator
 Concept 02: Intro to Behavioral Cloning Project
 Concept 03: Project Resources
 Concept 04: Running the Simulator
 Concept 05: Data Collection Tactics
 Concept 06: Data Collection Strategies
 Concept 07: Data Visualization
 Concept 08: Training the Network
 Concept 09: Running Your Network
 Concept 10: Data Preprocessing
 Concept 11: More Networks
 Concept 12: Data Augmentation
 Concept 13: Using Multiple Cameras
 Concept 14: Cropping Images in Keras
 Concept 15: Even More Powerful Network
 Concept 16: More Data Collection
 Concept 17: Visualizing Loss
 Concept 18: Generators
 Concept 19: Recording Video in Autonomous Mode
 Concept 20: Project Workspace Instructions
 Concept 21: Project Behavioral Cloning
 Concept 22: Share your success  Behavioral Cloning


Module 04: Computer Vision

Lesson 01: Camera Calibration
Learn how to calibrate your camera to remove inherent distortions that can affect its perception of the world.
 Concept 01: The Challenges with Cameras
 Concept 02: Welcome to Computer Vision
 Concept 03: Overview
 Concept 04: Getting Started
 Concept 05: Distortion Correction
 Concept 06: Effects of Distortion
 Concept 07: Pinhole Camera Model
 Concept 08: Image Formation
 Concept 09: Measuring Distortion
 Concept 10: Finding Corners
 Concept 11: Calibrating Your Camera
 Concept 12: Correcting for Distortion
 Concept 13: Lane Curvature
 Concept 14: Perspective Transform
 Concept 15: Curvature and Perspective
 Concept 16: Transform a Stop Sign
 Concept 17: Intuitions
 Concept 18: Undistort and Transform
 Concept 19: How I Did It
 Concept 20: Coming Up

Lesson 02: Gradients and Color Spaces
Learn how to use gradient thresholds and different color spaces to more easily identify lane markings on the road.
 Concept 01: Gradient Threshold
 Concept 02: Sobel Operator
 Concept 03: Applying Sobel
 Concept 04: Magnitude of the Gradient
 Concept 05: Direction of the Gradient
 Concept 06: Combining Thresholds
 Concept 07: Color Spaces
 Concept 08: Color Thresholding
 Concept 09: HLS intuitions
 Concept 10: HLS and Color Thresholds
 Concept 11: HLS Quiz
 Concept 12: Color and Gradient

Lesson 03: Advanced Techniques for Lane Finding
Discover more advanced computer vision techniques to improve upon your lane lines algorithm!
 Concept 01: Reviewing Steps
 Concept 02: Processing Each Image
 Concept 03: Finding the Lines: Histogram Peaks
 Concept 04: Finding the Lines: Sliding Window
 Concept 05: Finding the Lines: Search from Prior
 Concept 06: Another Sliding Window Search
 Concept 07: Measuring Curvature I
 Concept 08: Measuring Curvature II

Lesson 04: Advanced Lane Finding Project
Build a pipeline using distortion correction, image rectification, color transforms, and gradient thresholding to identify lane lines and their curvature in a video.

Lesson 05: Machine Learning and Stanley
Learn about classification, training and testing, and run a naive Bayes classifier using Scikit Learn.
 Concept 01: Intro to Classifiers
 Concept 02: ML in The Google SelfDriving Car
 Concept 03: Stanley Terrain Classification
 Concept 04: Speed Scatterplot: Grade and Bumpiness
 Concept 05: Speed Scatterplot 2
 Concept 06: Speed Scatterplot 3
 Concept 07: From Scatterplots to Predictions
 Concept 08: From Scatterplots to Predictions 2
 Concept 09: From Scatterplots to Decision Surfaces
 Concept 10: A Good Linear Decision Surface
 Concept 11: Transition to Using Naive Bayes
 Concept 12: NB Decision Boundary in Python
 Concept 13: Getting Started With sklearn
 Concept 14: Gaussian NB Example
 Concept 15: GaussianNB Deployment on Terrain Data
 Concept 16: Calculating NB Accuracy
 Concept 17: Training and Testing Data
 Concept 18: Naive Bayes Strengths and Weaknesses
 Concept 19: Congrats on Learning Naive Bayes

Lesson 06: Support Vector Machines
See how support vector machines work, and code one using Scikit Learn.
 Concept 01: Welcome to SVM
 Concept 02: Separating Line
 Concept 03: Choosing Between Separating Lines
 Concept 04: Maximizing the Margin
 Concept 05: Practice with Margins
 Concept 06: SVMs and Tricky Data Distributions
 Concept 07: SVM Response to Outliers
 Concept 08: SVM Outlier Practice
 Concept 09: Handoff to Katie
 Concept 10: SVM in SKlearn
 Concept 11: Coding Up the SVM
 Concept 12: Nonlinear SVMs
 Concept 13: Nonlinear Data
 Concept 14: A New Feature
 Concept 15: Visualizing the New Feature
 Concept 16: Separating with the New Feature
 Concept 17: Practice Making a New Feature
 Concept 18: Kernel Trick
 Concept 19: Playing Around with Kernel Choices
 Concept 20: Kernel and Gamma
 Concept 21: SVM C Parameter
 Concept 22: SVM Gamma Parameter
 Concept 23: Overfitting
 Concept 24: SVM Strengths and Weaknesses

Lesson 07: Decision Trees
Learn about decision trees, including entropy and information gain.
 Concept 01: Welcome To Decision Trees
 Concept 02: Linearly Separable Data
 Concept 03: Multiple Linear Questions
 Concept 04: Constructing a Decision Tree First Split
 Concept 05: Constructing a Decision Tree 2nd Split
 Concept 06: Class Labels After Second Split
 Concept 07: Constructing A Decision Tree/Third Split
 Concept 08: Coding A Decision Tree
 Concept 09: Decision Tree Accuracy
 Concept 10: Decision Tree Parameters
 Concept 11: Min Samples Split
 Concept 12: Decision Tree Accuracy
 Concept 13: Data Impurity and Entropy
 Concept 14: Minimizing Impurity in Splitting
 Concept 15: Formula of Entropy
 Concept 16: Entropy Calculation Part 1
 Concept 17: Entropy Calculation Part 2
 Concept 18: Entropy Calculation Part 3
 Concept 19: Entropy Calculation Part 4
 Concept 20: Entropy Calculation Part 5
 Concept 21: Information Gain
 Concept 22: Information Gain Calculation Part 1
 Concept 23: Information Gain Calculation Part 2
 Concept 24: Information Gain Calculation Part 3
 Concept 25: Information Gain Calculation Part 4
 Concept 26: Information Gain Calculation Part 5
 Concept 27: Information Gain Calculation Part 6
 Concept 28: Information Gain Calculation Part 7
 Concept 29: Information Gain Calculation Part 8
 Concept 30: Information Gain Calculation Part 9
 Concept 31: Information Gain Calculation Part 10
 Concept 32: Tuning Criterion Parameter
 Concept 33: BiasVariance Dilemma
 Concept 34: DT Strengths and Weaknesses

Lesson 08: Object Detection
In this lesson, you'll learn how to detect and track vehicles using color and gradient features and a support vector machine classifier.
 Concept 01: Intro to Vehicle Tracking
 Concept 02: Arpan and Drew
 Concept 03: Finding Cars
 Concept 04: Object Detection Overview
 Concept 05: Manual Vehicle Detection
 Concept 06: Features
 Concept 07: Feature Intuition
 Concept 08: Color Features
 Concept 09: Template Matching
 Concept 10: Template Matching Quiz
 Concept 11: Color Histogram Features
 Concept 12: Histograms of Color
 Concept 13: Histogram Comparison
 Concept 14: Color Spaces
 Concept 15: Explore Color Spaces
 Concept 16: Spatial Binning of Color
 Concept 17: Gradient Features
 Concept 18: HOG Features
 Concept 19: Data Exploration
 Concept 20: scikitimage HOG
 Concept 21: Combining Features
 Concept 22: Combine and Normalize Features
 Concept 23: Build a Classifier
 Concept 24: Labeled Data
 Concept 25: Data Preparation
 Concept 26: Train a Classifier
 Concept 27: Parameter Tuning
 Concept 28: Color Classify
 Concept 29: HOG Classify
 Concept 30: Sliding Windows
 Concept 31: How many windows?
 Concept 32: Sliding Window Implementation
 Concept 33: Multiscale Windows
 Concept 34: Search and Classify
 Concept 35: Hog Subsampling Window Search
 Concept 36: False Positives
 Concept 37: Multiple Detections & False Positives
 Concept 38: Tracking Pipeline
 Concept 39: Summary
 Concept 40: Traditional vs. Deep Learning Approach

Lesson 09: Vehicle Detection and Tracking Project
In the final Term 1 project, you'll leverage your object detection abilities toward a video pipeline for vehicle detection and tracking.


Module 05: Term 2 C++ Readiness
Part 02 : Sensor Fusion, Localization, and Control
In this term, you'll learn how to use an array of sensor data to perceive the environment and control the vehicle. You'll evaluate sensor data from camera, radar, lidar, and GPS, and use these in closedloop controllers that actuate the vehicle.

Module 01: Introduction to Term 2

Lesson 01: Welcome
Congratulations once more on completing term 1! Your diligent studying and newly honed skills have brought you one major step closer to graduating the program and getting into the field. Today, you begin Term 2, and we can't wait for you to jump in.


Module 02: Sensor Fusion

Lesson 01: Introduction and Sensors
Meet the team at Mercedes who will help you track objects in realtime with Sensor Fusion.

Lesson 02: Kalman Filters
Learn from the best! Sebastian Thrun will walk you through the usage and concepts of a Kalman Filter using Python.
 Concept 01: Introduction
 Concept 02: Tracking Intro
 Concept 03: Gaussian Intro
 Concept 04: Variance Comparison
 Concept 05: Preferred Gaussian
 Concept 06: Evaluate Gaussian
 Concept 07: Maximize Gaussian
 Concept 08: Measurement and Motion
 Concept 09: Shifting the Mean
 Concept 10: Predicting the Peak
 Concept 11: Parameter Update
 Concept 12: Parameter Update 2
 Concept 13: Separated Gaussians
 Concept 14: Separated Gaussians 2
 Concept 15: New Mean and Variance
 Concept 16: Gaussian Motion
 Concept 17: Predict Function
 Concept 18: Kalman Filter Code
 Concept 19: Kalman Prediction
 Concept 20: Kalman Filter Land
 Concept 21: Kalman Filter Prediciton
 Concept 22: Another Prediction
 Concept 23: More Kalman Filters
 Concept 24: Kalman Filter Design
 Concept 25: Kalman Matrices
 Concept 26: Conclusion

Lesson 03: C++ Checkpoint
Are you ready to build Kalman Filters with C++? Take these quizzes to find out.
 Concept 01: High Performance Computing
 Concept 02: [Optional] Beta Test our Upcoming C++ Course
 Concept 03: Challenge 1
 Concept 04: Challenge 1 Solution
 Concept 05: Challenge 2
 Concept 06: Challenge 2 Solution
 Concept 07: Challenge 3
 Concept 08: Challenge 3 Solution
 Concept 09: Challenge 4
 Concept 10: Challenge 4 Solution
 Concept 11: Challenge 5
 Concept 12: Challenge 5 Solution
 Concept 13: Outro and Advice

Lesson 04: Lidar and Radar Fusion with Kalman Filters in C++
In this lesson, you'll build a Kalman Filter in C++ that's capable of handling data from multiple sources. Why C++? Its performance enables the application of object tracking with a Kalman Filter in realtime.
 Concept 01: Kalman Filters in C++
 Concept 02: Intro
 Concept 03: Lesson Map and Fusion Flow
 Concept 04: Lesson Variables and Equations
 Concept 05: Estimation Problem Refresh
 Concept 06: Kalman Filter Intuition
 Concept 07: Kalman Filter Equations in C++ Part 1
 Concept 08: Kalman Filter Equations in C++ Part 2
 Concept 09: State Prediction
 Concept 10: Process Covariance Matrix
 Concept 11: Laser Measurements Part 1
 Concept 12: Laser Measurements Part 2
 Concept 13: Laser Measurements Part 3
 Concept 14: Laser Measurements Part 4
 Concept 15: Radar Measurements
 Concept 16: Mapping with a Nonlinear Function
 Concept 17: Extended Kalman Filter
 Concept 18: Multivariate Taylor Series Expansion
 Concept 19: Jacobian Matrix Part 1
 Concept 20: Jacobian Matrix Part 2
 Concept 21: EKF Algorithm Generalization
 Concept 22: Sensor Fusion General Flow
 Concept 23: Evaluating KF Performance Part 1
 Concept 24: Evaluating KF Performance 2
 Concept 25: Outro

Lesson 05: Extended Kalman Filter Project
In this project, you'll apply everything you've learned so far about Sensor Fusion by implementing an Extended Kalman Filter in C++!
 Concept 01: Back to Bayes Theorem
 Concept 02: Intro to Extended Kalman Filter Project
 Concept 03: Data File
 Concept 04: File Structure
 Concept 05: Main.cpp
 Concept 06: Project Code
 Concept 07: Tips and Tricks
 Concept 08: Project Resources
 Concept 09: Project Instructions for workspaces
 Concept 10: Project Extended Kalman Filter GPU
 Concept 11: Project Instructions for local setup
 Concept 12: uWebSocketIO Starter Guide
 Concept 13: Environment Setup (Windows)
 Concept 14: Environment Setup (Linux)
 Concept 15: Environment Setup (Mac)
 Concept 16: Compiling and Running the Project

Lesson 06: Unscented Kalman Filters
While Extended Kalman Filters work great for linear motion, real objects rarely move linearly. With Unscented Kalman Filters, you'll be able to accurately track nonlinear motion!
 Concept 01: Introduction
 Concept 02: The CTRV Model
 Concept 03: The CTRV Model State Vector
 Concept 04: CTRV Differential Equation
 Concept 05: CTRV Integral 1
 Concept 06: CTRV Integral 2
 Concept 07: CTRV Zero Yaw Rate
 Concept 08: CTRV Process Noise Vector
 Concept 09: CTRV Process Noise Position
 Concept 10: UKF Process Chain
 Concept 11: What Problem Does the UKF Solve?
 Concept 12: UKF Basics Unscented Transformation
 Concept 13: Generating Sigma Points
 Concept 14: Generating Sigma Points Assignment 1
 Concept 15: Generating Sigma Points Assignment 2
 Concept 16: UKF Augmentation
 Concept 17: Augmentation Assignment 1
 Concept 18: Augmentation Assignment 2
 Concept 19: Sigma Point Prediction
 Concept 20: Sigma Point Prediction Assignment 1
 Concept 21: Sigma Point Prediction Assignment 2
 Concept 22: Predicted Mean and Covariance
 Concept 23: Predicted Mean and Covariance Assignment 1
 Concept 24: Predicted Mean and Covariance Assignment 2
 Concept 25: Measurement Prediction
 Concept 26: Predict Radar Measurement Assignment 1
 Concept 27: Predict Radar Measurement Assignment 2
 Concept 28: UKF Update
 Concept 29: UKF Update Assignment 1
 Concept 30: UKF Update Assignment 2
 Concept 31: Parameters and Consistency
 Concept 32: What to Expect from the Project
 Concept 33: Story Time
 Concept 34: Outro

Lesson 07: Unscented Kalman Filter Project
Put your skills to the test! Use C++ to code an Unscented Kalman Filter capable of tracking nonlinear motion.


Module 03: Localization

Lesson 01: Introduction to Localization
Meet the team that will guide you through the localization lessons!

Lesson 02: Localization Overview
Sebastian Thrun will give you an overview of the theory behind localization!
 Concept 01: Introduction
 Concept 02: Localization
 Concept 03: Total Probability
 Concept 04: Uniform Probability Quiz
 Concept 05: Uniform Distribution
 Concept 06: Generalized Uniform Distribution
 Concept 07: Probability After Sense
 Concept 08: Compute Sum
 Concept 09: Normalize Distribution
 Concept 10: pHit and pMiss
 Concept 11: Sum of Probabilities
 Concept 12: Sense Function
 Concept 13: Normalized Sense Function
 Concept 14: Test Sense Function
 Concept 15: Multiple Measurements
 Concept 16: Lesson Breakpoint
 Concept 17: Exact Motion
 Concept 18: Move Function
 Concept 19: Inexact Motion 1
 Concept 20: Inexact Motion 2
 Concept 21: Inexact Motion 3
 Concept 22: Inexact Move Function
 Concept 23: Limit Distribution Quiz
 Concept 24: Move Twice
 Concept 25: Move 1000
 Concept 26: Sense and Move
 Concept 27: Sense and Move 2
 Concept 28: Localization Summary
 Concept 29: Formal Definition of Probability 1
 Concept 30: Formal Definition of Probability 2
 Concept 31: Formal Definition of Probability 3
 Concept 32: Bayes' Rule
 Concept 33: Cancer Test
 Concept 34: Theorem of Total Probability
 Concept 35: Coin Flip Quiz
 Concept 36: Two Coin Quiz

Lesson 03: Markov Localization
In this lesson, you'll learn the math behind localization as well as how to implement Markov localization in C++.
 Concept 01: Return to Bayes' Rule
 Concept 02: Overview
 Concept 03: Localization Posterior: Introduction
 Concept 04: Localization Posterior Explanation and Implementation
 Concept 05: Bayes' Rule
 Concept 06: Bayes' Filter For Localization
 Concept 07: Calculate Localization Posterior
 Concept 08: Initialize Belief State
 Concept 09: Initialize Priors Function
 Concept 10: Solution: Initialize Priors Function
 Concept 11: Quiz: How Much Data?
 Concept 12: How Much Data: Explanation
 Concept 13: Derivation Outline
 Concept 14: Apply Bayes Rule with Additional Conditions
 Concept 15: Bayes Rule and Law of Total Probability
 Concept 16: Total Probability and Markov Assumption
 Concept 17: Markov Assumption for Motion Model: Quiz
 Concept 18: Markov Assumption for Motion Model: Explanation
 Concept 19: After Applying Markov Assumption: Quiz
 Concept 20: Recursive Structure
 Concept 21: Lesson Breakpoint
 Concept 22: Implementation Details for Motion Model
 Concept 23: Noise in Motion Model: Quiz
 Concept 24: Noise in Motion Model: Solution
 Concept 25: Determine Probabilities
 Concept 26: Motion Model Probabiity I
 Concept 27: Motion Model Probability II
 Concept 28: Coding the Motion Model
 Concept 29: Solution: Coding the Motion Model
 Concept 30: Observation Model Introduction
 Concept 31: Markov Assumption for Observation Model
 Concept 32: Finalize the Bayes Localization Filter
 Concept 33: Bayes Filter Theory Summary
 Concept 34: Observation Model Probability
 Concept 35: Get Pseudo Ranges
 Concept 36: Solution: Get Pseudo Ranges
 Concept 37: Coding the Observation Model
 Concept 38: Solution: Coding the Observation Model
 Concept 39: Coding the Full Filter
 Concept 40: Solution: Coding the Full Filter
 Concept 41: Conclusion

Lesson 04: Motion Models
Here you'll learn about vehicle movement and motion models to predict where your car will be at a future time.
 Concept 01: Motion in Autonomy
 Concept 02: Lesson Introduction
 Concept 03: Motion Models: Bicycle Model
 Concept 04: Yaw Rate and Velocity
 Concept 05: Note on Frames of Reference
 Concept 06: Roll, Pitch and Yaw: Quiz
 Concept 07: Odometry
 Concept 08: Odometry Errors: Quiz
 Concept 09: Odometry Errors: Solution
 Concept 10: Conclusion

Lesson 05: Particle Filters
Now, Sebastian will teach you what a particle filter is and will teach the theory and math behind the particle filter.
 Concept 01: Field Trip
 Concept 02: State Space
 Concept 03: Belief Modality
 Concept 04: Efficiency
 Concept 05: Exact or Approximate
 Concept 06: Particle Filters
 Concept 07: Using Robot Class
 Concept 08: Robot Class Details
 Concept 09: Moving Robot
 Concept 10: Add Noise
 Concept 11: Robot World
 Concept 12: Creating Particles
 Concept 13: Robot Particles
 Concept 14: Importance Weight
 Concept 15: Resampling
 Concept 16: Never Sampled 1
 Concept 17: Never Sampled 2
 Concept 18: Never Sampled 3
 Concept 19: New Particle
 Concept 20: Resampling Wheel
 Concept 21: Orientation 1
 Concept 22: Orientation 2
 Concept 23: Error
 Concept 24: You and Sebastian
 Concept 25: Filters
 Concept 26: 2012

Lesson 06: Implementation of a Particle Filter
Now that you understand how a particle filter works, you'll learn how to code a particle filter.
 Concept 01: Particle Filters in C++
 Concept 02: Introduction
 Concept 03: Pseudocode
 Concept 04: Initialization
 Concept 05: Program Gaussian Sampling: Code
 Concept 06: Program Gaussian Sampling: Code Solution
 Concept 07: Prediction Step
 Concept 08: Calculate Prediction Step: Quiz
 Concept 09: Calculate Prediction Step Quiz Explanation
 Concept 10: Data Association: Nearest Neighbor
 Concept 11: Nearest Neighbor Advantages and Disadvantages
 Concept 12: Update Step
 Concept 13: Calculating Error
 Concept 14: Transformations and Associations
 Concept 15: Converting Landmark Observations
 Concept 16: Quiz: Landmarks
 Concept 17: Landmarks Quiz Solution
 Concept 18: Quiz: Association
 Concept 19: Quiz: Particle Weights
 Concept 20: Particle Weights Solution
 Concept 21: Explanation of Project Code

Lesson 07: Kidnapped Vehicle Project
In this project, you'll build a particle filter and combine it with a real map to localize a vehicle!


Module 04: Control

Lesson 01: PID Control
In this lesson you'll learn about and how to use PID controllers with Sebastian!
 Concept 01: Intro
 Concept 02: PID Control
 Concept 03: Proportional Control
 Concept 04: Implement P Controller
 Concept 05: P Controller Solution
 Concept 06: Oscillations
 Concept 07: PD Controller
 Concept 08: PD Controller Solution
 Concept 09: Systematic Bias
 Concept 10: Is PD Enough
 Concept 11: PID implementation
 Concept 12: PID Implementation Solution
 Concept 13: Twiddle
 Concept 14: Parameter Optimization
 Concept 15: Parameter Optimization Solution
 Concept 16: Outro

Lesson 02: PID Controller Project
Implement a PID Controller to race around the lake track.

Lesson 03: Vehicle Models
In this lesson, you'll learn about kinematic and dynamic vehicle models. We'll use these later with Model Predictive Control.
 Concept 01: Intro
 Concept 02: Vehicle Models
 Concept 03: State
 Concept 04: Building a Kinematic Model
 Concept 05: Global Kinematic Model
 Concept 06: Solution: Global Kinematic Model
 Concept 07: Following Trajectories
 Concept 08: Fitting Polynomials
 Concept 09: Solution: Fitting Polynomials
 Concept 10: Errors
 Concept 11: Dynamic Models
 Concept 12: Dynamic Models  Forces
 Concept 13: Dynamic Models  Slip Angle
 Concept 14: Dynamic Models  Slip Ratio
 Concept 15: Dynamic Models  Tire Models
 Concept 16: Actuator Constraints
 Concept 17: Outro

Lesson 04: Model Predictive Control
In this lesson, you'll learn how to frame the control problem as an optimization problem over time horizons. This is Model Predictive Control!
 Concept 01: Intro
 Concept 02: Reference State
 Concept 03: Dealing With Stopping
 Concept 04: Additional Cost Considerations
 Concept 05: Length and Duration
 Concept 06: Putting It All Together
 Concept 07: Latency
 Concept 08: Mind The Line
 Concept 09: Solution: Mind The Line
 Concept 10: Tuning MPC
 Concept 11: Outro

Lesson 05: Model Predictive Control Project
In this project, you'll implement Model Predictive Control to drive the vehicle around the track even with additional latency between commands!


Module 05: Supporting Content

Lesson 01: Geometry and Trigonometry Refresher
This optional content is designed to refresh knowledge of trigonometry and geometry, in support of Self Driving Car Engineer term 2 objectives.
 Concept 01: About this Lesson
 Concept 02: Two Dimensional Robot Motion and Trigonometry
 Concept 03: Lesson Introduction
 Concept 04: Plotting Robot Motion (right angles only)
 Concept 05: Plotting Robot Motion Solution
 Concept 06: Moving at an Angle
 Concept 07: Moving at 53.13 Degrees
 Concept 08: Who Cares About 53.13 Degrees?
 Concept 09: The Power of Trigonometry
 Concept 10: Opposite, Adjacent, Hypotenuse
 Concept 11: Trigonometric Ratios
 Concept 12: Looking up Sin, Cos, and Tan
 Concept 13: Trigonometry and Vehicle Motion
 Concept 14: Solving Trig Problems
 Concept 15: Keeping Track of x and y
 Concept 16: Keeping Track of x and y (solution)
 Concept 17: Conclusion

Part 03 : Path Planning, Concentrations, and Systems
In this term, you'll learn how to plan where the vehicle should go, how the vehicle systems work together to get it there, and you'll perform a deepdive into a concentration of your choice.

Module 01: Introduction to Term 3

Lesson 01: Welcome
Welcome to Term 3! This term includes path planning, an elective concentration, and system integration, which is the capstone of the program. You'll run your code on Udacity's own selfdriving car!


Module 02: Path Planning

Lesson 01: Search
In this lesson you will learn about discrete path planning and algorithms for solving the path planning problem.
 Concept 01: Motion Planning
 Concept 02: Introduction to Path Planning
 Concept 03: About this Lesson
 Concept 04: Motion Planning
 Concept 05: Compute Cost
 Concept 06: Compute Cost 2
 Concept 07: Optimal Path
 Concept 08: Optimal Path 2
 Concept 09: Maze
 Concept 10: Maze 2
 Concept 11: First Search Program
 Concept 12: Expansion Grid
 Concept 13: Print Path
 Concept 14: A*
 Concept 15: Implement A*
 Concept 16: A* in Action
 Concept 17: Dynamic Programming
 Concept 18: Computing Value
 Concept 19: Computing Value 2
 Concept 20: Value Program
 Concept 21: Optimum Policy
 Concept 22: Left Turn Policy
 Concept 23: Planning Conclusion

Lesson 02: Prediction
In this lesson you'll learn how to use data from sensor fusion to generate predictions about the likely behavior of moving objects.
 Concept 01: Introduction and Overview
 Concept 02: I/O Recap
 Concept 03: ModelBased vs DataDriven Approaches
 Concept 04: Which is Best?
 Concept 05: Data Driven Example  Trajectory Clustering
 Concept 06: Trajectory Clustering 2  Online Prediction
 Concept 07: Thinking about Model Based Approaches
 Concept 08: Frenet Coordinates
 Concept 09: Process Models
 Concept 10: More on Process Models
 Concept 11: Multimodal Estimation
 Concept 12: Summary of Data Driven and Model Based Approaches
 Concept 13: Overview of Hybrid Approaches
 Concept 14: Intro to Naive Bayes
 Concept 15: Naive Bayes Quiz
 Concept 16: Implement Naive Bayes C++
 Concept 17: Implement Naive Bayes C++ (solution)
 Concept 18: Conclusion

Lesson 03: Behavior Planning
In this lesson you'll learn how to think about high level behavior planning in a self driving car.
 Concept 01: Where To
 Concept 02: Lesson Outline
 Concept 03: Understanding Output
 Concept 04: The Behavior Problem
 Concept 05: Finite State Machines
 Concept 06: Formalizing Finite State Machines
 Concept 07: FSM Intuition
 Concept 08: States for Self Driving Cars
 Concept 09: The States We'll Use
 Concept 10: Inputs to Transition Functions
 Concept 11: Behavior Planning Pseudocode
 Concept 12: Create a Cost Function  Speed Penalty
 Concept 13: Example Cost Function  Lane Change Penalty
 Concept 14: Implement a Cost Function in C++
 Concept 15: Implement a Cost Function in C++ (solution)
 Concept 16: Implement a Second Cost Function in C++
 Concept 17: Implement a Second Cost Function in C++ (solution)
 Concept 18: Cost Function Design and Weight Tweaking
 Concept 19: Cost Function Matching
 Concept 20: Scheduling Compute Time
 Concept 21: Implement Behavior Planner in C++
 Concept 22: Implement Behavior Planner in C++ (solution)
 Concept 23: Conclusion

Lesson 04: Trajectory Generation
In this lesson, you’ll use C++ and the Eigen linear algebra library to build candidate trajectories for the vehicle to follow.
 Concept 01: From Behavior to Trajectory
 Concept 02: Lesson Overview
 Concept 03: The Motion Planning Problem
 Concept 04: Properties of Motion Planning Algorithms
 Concept 05: Types of Motion Planning Algorithms
 Concept 06: A* Reminder
 Concept 07: A* Reminder Solution
 Concept 08: Hybrid A* Introduction
 Concept 09: Hybrid A* Tradeoffs
 Concept 10: Hybrid A* Tradeoffs Solution
 Concept 11: Hybrid A* in Practice
 Concept 12: Hybrid A* Heuristics
 Concept 13: Hybrid A* Pseudocode
 Concept 14: Implement Hybrid A* in C++
 Concept 15: Implement Hybrid A* in C++ (solution)
 Concept 16: Environment Classification
 Concept 17: Frenet Reminder
 Concept 18: The Need for Time
 Concept 19: s, d, and t
 Concept 20: Trajectory Matching
 Concept 21: Structured Trajectory Generation Overview
 Concept 22: Trajectories with Boundary Conditions
 Concept 23: Jerk Minimizing Trajectories
 Concept 24: Derivation Overview
 Concept 25: Derivation Details 2
 Concept 26: Polynomial Trajectory Generation
 Concept 27: Implement Quintic Polynomial Solver C++
 Concept 28: Implement Quintic Polynomial Solver Solution
 Concept 29: What should be checked?
 Concept 30: Implementing Feasibility
 Concept 31: Putting it All Together
 Concept 32: Polynomial Trajectory Reading (optional)
 Concept 33: Polynomial Trajectory Generation Playground
 Concept 34: Conclusion

Lesson 05: Path Planning Project
Drive a car down a highway with other cars using your own path planner.

Lesson 06: Coming Up: Electives
An overview of the elective options and how to proceed.


Module 03: Elective: Advanced Deep Learning

Lesson 01: Elective: Advanced Deep Learning
Students in this specialization, built with the NVIDIA Deep Learning Institute, will learn about semantic segmentation, and inference optimization, active areas of deep learning research.

Lesson 02: Fully Convolutional Networks
In this lesson you'll learn the motivation for Fully Convolutional Networks and how they are structured.
 Concept 01: Intro
 Concept 02: Why Fully Convolutional Networks (FCNs) ?
 Concept 03: Fully Convolutional Networks
 Concept 04: Fully Connected to 1x1 Convolution
 Concept 05: 1x1 Convolution Quiz
 Concept 06: 1x1 Convolution Quiz Solution
 Concept 07: Transposed Convolutions
 Concept 08: Transposed Convolution Quiz
 Concept 09: Transposed Convolution Quiz Solution
 Concept 10: Skip Connections
 Concept 11: FCNs In The Wild
 Concept 12: Outro

Lesson 03: Scene Understanding
In this lesson you'll be introduced to the problem of Scene Understanding and the role FCNs play.
 Concept 01: Intro
 Concept 02: Bounding Boxes
 Concept 03: Semantic Segmentation
 Concept 04: Scene Understanding
 Concept 05: IoU
 Concept 06: IOU Example
 Concept 07: IoU Quiz
 Concept 08: IOU Solution
 Concept 09: FCN8  Encoder
 Concept 10: FCN8  Decoder
 Concept 11: FCN8  Classification & Loss
 Concept 12: Object Detection Lab
 Concept 13: Outro

Lesson 04: Inference Performance
In this lesson you'll become familiar with various optimizations in an effort to squeeze every last bit of performance at inference.
 Concept 01: Intro
 Concept 02: Why Bother With Performance
 Concept 03: Semantic Segmentation Revisited
 Concept 04: Interlude: Using The AMI
 Concept 05: Freezing Graphs
 Concept 06: Graph Transforms
 Concept 07: Fusion
 Concept 08: Optimizing For Inference
 Concept 09: Reducing Precision
 Concept 10: Quantization Quiz
 Concept 11: Quantization Conversion
 Concept 12: 8bit Calculations
 Concept 13: Compilation
 Concept 14: AOT & JIT
 Concept 15: Reusing The Graph
 Concept 16: Outro

Lesson 05: Semantic Segmentation Project
Train segmentation networks, which paint each pixel of the image a different color, based on its class. Use segmented images to find free space on the road.


Module 04: Elective: Functional Safety

Lesson 01: Elective: Functional Safety
If you choose the Functional Safety specialization, built with Elektrobit, you’ll learn functional safety frameworks to ensure that vehicles are safe, both at the system and component levels.

Lesson 02: Introduction to Functional Safety
You will learn to make safer vehicles using risk evaluation and systems engineering.
 Concept 01: Introduction to the Functional Safety Module
 Concept 02: Introduction to the Lesson
 Concept 03: What is Safety?
 Concept 04: What is Functional Safety?
 Concept 05: Introduction to Identifying Hazards
 Concept 06: Sebastian and Technology Errors
 Concept 07: Introduction to Evaluating Risks
 Concept 08: Reducing Risk with Systems Engineering
 Concept 09: Introduction to ISO 26262
 Concept 10: The Full V Model
 Concept 11: Summary
 Concept 12: Sebastian Talks About SelfDriving Car Risks

Lesson 03: Functional Safety: Safety Plan
A functional safety plan is critical to any functional safety project. Here you will learn what goes into a safety plan so that you can document your own.

Lesson 04: Functional Safety: Hazard Analysis and Risk Assessment
In a hazard analysis and risk assessment, you will identify vehicular malfunctions and evaluate their risk levels. You can then derive safety goals defining how your vehicle will remain safe.
 Concept 01: Introduction
 Concept 02: Advanced Driver Assistance System
 Concept 03: Item Definition
 Concept 04: Introduction to Hazard Analysis and Risk Assessment
 Concept 05: Sebastian Discussing Hazards
 Concept 06: Situational Analysis
 Concept 07: Identification of Hazards
 Concept 08: Risk Assessment, Severity, Exposure, Controllability
 Concept 09: Automotive Safety Integrity Levels (ASIL)
 Concept 10: Safety Goals
 Concept 11: Lesson Summary

Lesson 05: Functional Safety: Functional Safety Concept
You will derive functional safety requirements from the safety goals and then add extra functionality to the system diagram. Finally you document your work, a part of functional safety.
 Concept 01: Introduction
 Concept 02: Functional Safety Analysis
 Concept 03: Functional Safety Requirements
 Concept 04: Allocation to the Architecture
 Concept 05: Architecture Refinement
 Concept 06: ASIL Inheritance
 Concept 07: ASIL Decomposition
 Concept 08: Fault Tolerant Time Interval
 Concept 09: Warning and Degradation Concept
 Concept 10: Verification and Validation Acceptance Criteria
 Concept 11: Sebastian On Requirements and Testing
 Concept 12: Summary

Lesson 06: Functional Safety: Technical Safety Concept
Once you have derived functional safety requirements, you drill down into more detail. In the technical safety concept, you refine your requirements into technical safety requirements.
 Concept 01: Introduction
 Concept 02: Deriving Technical Safety Requirements
 Concept 03: Other Types of Technical Safety Requirements
 Concept 04: Technical Safety Requirement Attributes
 Concept 05: Allocation of Requirements to System Architecture Elements
 Concept 06: Sebastian on Testing
 Concept 07: Summary

Lesson 07: Functional Safety at the Software and Hardware Levels
The last step in the vehicle safety design phase is to derive hardware and software safety requirements. In this lesson, you will derive these requirements and refine a software system architecture.
 Concept 01: Introduction
 Concept 02: V model
 Concept 03: Hardware Failure Metrics
 Concept 04: Programming Languages
 Concept 05: MISRA C++ Lab
 Concept 06: Software Safety Lifecycle
 Concept 07: Software Safety Requirements Lane Departure Warning
 Concept 08: Other Sources of Software Safety Requirements
 Concept 09: Freedom from Interference  Spatial
 Concept 10: Freedom from Interference  Temporal
 Concept 11: Freedom from Interference  Temporal Part 2
 Concept 12: Sebastian and Temporal Interference
 Concept 13: Freedom from Interference  Communication
 Concept 14: System Architecture Safety Design Patterns
 Concept 15: Lesson Summary
 Concept 16: Module Summary

Lesson 08: Elective Project: Functional Safety
It's time to start the functional safety project! You will be creating a safety case for a lane assistance system.
Project Description  Functional Safety of a Lane Assistance System
Project Rubric  Functional Safety of a Lane Assistance System


Module 05: System Integration

Lesson 01: Autonomous Vehicle Architecture
Learn about the system architecture for Carla, Udacity's autonomous vehicle.
 Concept 01: Putting it All Together
 Concept 02: Introduction
 Concept 03: The Sensor Subsystem
 Concept 04: The Perception Subsystem
 Concept 05: Perception Subsystem Components
 Concept 06: The Planning Subsystem
 Concept 07: Planning Subsystem Components
 Concept 08: The Control Subsystem
 Concept 09: On to the code!

Lesson 02: Introduction to ROS
Obtain an architectural overview of the Robot Operating System Framework and setup your own ROS environment on your computer.
 Concept 01: Communication Between Systems
 Concept 02: Introduction
 Concept 03: Welcome to ROS Essentials
 Concept 04: Build Robots with ROS
 Concept 05: Brief History of ROS
 Concept 06: Nodes and Topics
 Concept 07: Message Passing
 Concept 08: Services
 Concept 09: Compute Graph
 Concept 10: Turtlesim Overview
 Concept 11: ROS Workspace Instructions
 Concept 12: ROS Workspace
 Concept 13: Your Virtual Machine
 Concept 14: Source the ROS Environment
 Concept 15: Run Turtlesim
 Concept 16: Turtlesim Comms: List Nodes
 Concept 17: Turtlesim Comms: List Topics
 Concept 18: Turtlesim Comms: Get Topic Info
 Concept 19: Turtlesim Comms: Message Information
 Concept 20: Turtlesim Comms: Echo a Topic
 Concept 21: Recap

Lesson 03: Packages & Catkin Workspaces
Learn about ROS workspace structure, essential command line utilities, and how to manage software packages within a project. Harnessing these will be key to building shippable software using ROS.

Lesson 04: Writing ROS Nodes
ROS Nodes are a key abstraction that allows a robot system to be built modularly. In this lesson, you'll learn how to write them using Python.
 Concept 01: Closing In
 Concept 02: Overview
 Concept 03: ROS Publishers
 Concept 04: Simple Mover
 Concept 05: Simple Mover: The Code
 Concept 06: ROS Services
 Concept 07: Arm Mover
 Concept 08: Arm Mover: The Code
 Concept 09: Arm Mover: Launch and Interact
 Concept 10: ROS Subscribers
 Concept 11: Look Away
 Concept 12: Look Away: The Code
 Concept 13: Look Away: Launch and Interact
 Concept 14: Logging
 Concept 15: Recap
 Concept 16: Outro

Lesson 05: System Integration Project
Run your code on Carla, Udacity's autonomous vehicle!
 Concept 01: Have Fun!
 Concept 02: Introduction
 Concept 03: Getting Started
 Concept 04: Project Overview
 Concept 05: Waypoint Updater Node (Partial)
 Concept 06: Waypoint Updater Partial Walkthrough
 Concept 07: DBW Node
 Concept 08: DBW Walkthrough
 Concept 09: Traffic Light Detection Node
 Concept 10: Detection Walkthrough
 Concept 11: Waypoint Updater Node (Full)
 Concept 12: Full Waypoint Walkthrough
 Concept 13: Project Workspace Instructions
 Concept 14: Project Submission and Getting Feedback
 Concept 15: Capstone Project Workspace


Module 06: Completing the Program

Lesson 01: Completing the Program
Congratulations! You've reached the end of the SelfDriving Car Engineer Nanodegree program! Read on to learn how to officially complete the program and graduate.

Part 04 (Career): Career: Job Search Strategies
Opportunity can come when you least expect it, so when your dream job comes along, you want to be ready. In the following lessons, you will learn strategies for conducting a successful job search, including developing a targeted resume and cover letter for that job.

Module 01: Conduct a Job Search

Lesson 01: Conduct a Job Search
Learn how to search for jobs effectively through industry research, and targeting your application to a specific role.


Module 02: Refine Your Resume

Lesson 01: Refine Your EntryLevel Resume
Receive a personalized review of your resume. This resume review is best suited for applicants who have 03 years of work experience in any industry.

Lesson 02: Refine Your Career Change Resume
Receive a personalized review of your resume. This resume review is best suited for applicants who have 3+ years of work experience in an unrelated field.

Lesson 03: Refine Your Prior Industry Experience Resume
Receive a personalized review of your resume. This resume review is best suited for applicants who have 3+ years of work experience in a related field.
Project Description  Resume Review Project (Prior Industry Experience)
Project Rubric  Resume Review Project (Prior Industry Experience)
 Concept 01: Convey Your Skills Concisely
 Concept 02: Effective Resume Components
 Concept 03: Resume Structure
 Concept 04: Describe Your Work Experiences
 Concept 05: Resume Reflection
 Concept 06: Resume Review
 Concept 07: Resume Review (Prior Industry Experience)
 Concept 08: Resources in Your Career Portal


Module 03: Write an Effective Cover Letter

Lesson 01: Craft Your Cover Letter
Get a personalized review of your cover letter. A successful cover letter will convey your enthusiasm, specific technical qualifications, and communication skills applicable to the position.

Part 05 (Career): Career: Networking
Networking is a very important component to a successful job search. In the following lesson, you will learn how tell your unique story to recruiters in a succinct and professional but relatable way.

Module 01: Strengthen Your Online Presence Using LinkedIn

Lesson 01: Develop Your Personal Brand
In this lesson, learn how to tell your unique story in a succinct and professional way. Communicate to employers that you know how to solve problems, overcome challenges, and achieve results.

Lesson 02: LinkedIn Review
Optimize your LinkedIn profile to show up in recruiter searches, build your network, and attract employers. Learn to read your LinkedIn profile through the lens of a recruiter or hiring manager.

Lesson 03: Udacity Professional Profile Review
Update and personalize your Udacity Professional Profile as you complete your Nanodegree program, and make your Profile visible to Udacity hiring partners when you’re ready to start your job search.


Module 02: GitHub Profile Review

Lesson 01: GitHub Profile Review
Review how your GitHub profile, projects, and code represent you as a potential job candidate. Learn to assess your GitHub profile through the eyes of a recruiter or hiring manager.
 Concept 01: Introduction
 Concept 02: GitHub profile important items
 Concept 03: Good GitHub repository
 Concept 04: Interview with Art  Part 1
 Concept 05: Identify fixes for example “bad” profile
 Concept 06: Quick Fixes #1
 Concept 07: Quick Fixes #2
 Concept 08: Writing READMEs with Walter
 Concept 09: Interview with Art  Part 2
 Concept 10: Commit messages best practices
 Concept 11: Reflect on your commit messages
 Concept 12: Participating in open source projects
 Concept 13: Interview with Art  Part 3
 Concept 14: Participating in open source projects 2
 Concept 15: Starring interesting repositories
 Concept 16: Outro

Part 06 (Career): Career: Technical Interview
Learn the skills technical interviewers expect you to know—efficiency, common algorithms, manipulating popular data structures, and how to explain a solution.

Module 01: Prepare for a Technical Interview

Lesson 01: Introduction and Efficiency
Begin the section on data structures and algorithms, including Python and efficiency practice.
 Concept 01: Course Introduction
 Concept 02: Course Outline
 Concept 03: Course Expectations
 Concept 04: Syntax
 Concept 05: Python Practice
 Concept 06: Python: The Basics
 Concept 07: Efficiency
 Concept 08: Notation Intro
 Concept 09: Notation Continued
 Concept 10: Worst Case and Approximation
 Concept 11: Efficiency Practice

Lesson 02: ListBased Collections
Learn the definition of a list in computer science, and see definitions and examples of listbased data structures, arrays, linked lists, stacks, and queues.
 Concept 01: Welcome to Collections
 Concept 02: Lists
 Concept 03: Arrays
 Concept 04: Python Lists
 Concept 05: Linked Lists
 Concept 06: Linked Lists in Depth
 Concept 07: Linked List Practice
 Concept 08: Stacks
 Concept 09: Stacks Details
 Concept 10: Stack Practice
 Concept 11: Queues
 Concept 12: Queue Practice

Lesson 03: Searching and Sorting
Explore how to search and sort with listbased data structures, including binary search and bubble, merge, and quick sort. Learn how to use recursion.
 Concept 01: Binary Search
 Concept 02: Efficiency of Binary Search
 Concept 03: Binary Search Practice
 Concept 04: Recursion
 Concept 05: Recursion Practice
 Concept 06: Intro to Sorting
 Concept 07: Bubble Sort
 Concept 08: Efficiency of Bubble Sort
 Concept 09: Bubble Sort Practice
 Concept 10: Merge Sort
 Concept 11: Efficiency of Merge Sort
 Concept 12: Merge Sort Practice
 Concept 13: Quick Sort
 Concept 14: Efficiency of Quick Sort
 Concept 15: Quick Sort Practice

Lesson 04: Maps and Hashing
Understand the concepts of sets, maps (dictionaries), and hashing. Examine common problems and approaches to hashing, and practice with examples.

Lesson 05: Trees
Learn the concepts and terminology associated with tree data structures. Investigate tree types, such as binary search trees, heaps, and selfbalancing trees.
 Concept 01: Trees
 Concept 02: Tree Basics
 Concept 03: Tree Terminology
 Concept 04: Tree Practice
 Concept 05: Tree Traversal
 Concept 06: DepthFirst Traversals
 Concept 07: Tree Traversal Practice
 Concept 08: Search and Delete
 Concept 09: Insert
 Concept 10: Binary Search Trees
 Concept 11: Binary Tree Practice
 Concept 12: BSTs
 Concept 13: BST Complications
 Concept 14: BST Practice
 Concept 15: Heaps
 Concept 16: Heapify
 Concept 17: Heap Implementation
 Concept 18: SelfBalancing Trees
 Concept 19: RedBlack Trees  Insertion
 Concept 20: Tree Rotations

Lesson 06: Graphs
Examine the theoretical concept of a graph and understand common graph terms, coded representations, properties, traversals, and paths.
 Concept 01: Graph Introduction
 Concept 02: What Is a Graph?
 Concept 03: Directions and Cycles
 Concept 04: Connectivity
 Concept 05: Graph Practice
 Concept 06: Graph Representations
 Concept 07: Adjacency Matrices
 Concept 08: Graph Representation Practice
 Concept 09: Graph Traversal
 Concept 10: DFS
 Concept 11: BFS
 Concept 12: Graph Traversal Practice
 Concept 13: Eulerian Path

Lesson 07: Case Studies in Algorithms
Explore famous computer science problems, specifically the Shortest Path Problem, the Knapsack Problem, and the Traveling Salesman Problem.

Lesson 08: Technical Interviewing Techniques
Learn about the “algorithm” for answering common technical interviewing questions. Practice and get tips for giving interviewers what they’re looking for.
 Concept 01: Interview Introduction
 Concept 02: Clarifying the Question
 Concept 03: Confirming Inputs
 Concept 04: Test Cases
 Concept 05: Brainstorming
 Concept 06: Runtime Analysis
 Concept 07: Coding
 Concept 08: Debugging
 Concept 09: Interview WrapUp
 Concept 10: Time for Live Practice with Pramp
 Concept 11: Next Steps
