Nanodegree key: nd113
Version: 3.0.0
Locale: en-us
Learn the essentials of building a self-driving car, including probability, C++, machine learning, and linear algebra.
Content
Part 01 : Orientation
Welcome to the Intro to Self-Driving Cars Nanodegree program! In this section you'll get a sneak peak of the classroom, meet the team, and learn about the services provided. Then you'll take a readiness assessment and check out some learning resources to help you make the most out of your experience.
-
Module 01:
Welcome to Intro to Self-Driving Cars!
-
Lesson 01: Introduction
Welcome to the Intro to Self-Driving Cars Nanodegree program! We are excited to have you and hope you are looking forward to learning about this game-changing field!
-
-
Module 02:
Career Support
-
Lesson 01: Get Help with Your Account
What to do if you have questions about your account or general questions about the program.
-
Lesson 02: Knowledge, Community, and Careers
You are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.
-
-
Module 03:
Readiness
-
Lesson 01: The Carla Chronicles: Back on Track
Work through the readiness assessment with Carla and her friends to make sure you are ready to begin your own personal adventure with self-driving cars!
- Concept 01: The Carla Chronicles: Back on Track
- Concept 02: Meet the Crew
- Concept 03: Wheel Size Matters
- Concept 04: Challenge: Rotation
- Concept 05: Lost in Space
- Concept 06: Challenge: Localization
- Concept 07: It's Getting Hot in Here
- Concept 08: Challenge: Changing Tire Size
- Concept 09: What's the Plan, Stan?
- Concept 10: Challenge: Planning
- Concept 11: The Split Decision
- Concept 12: Challenge: Shortest Path
- Concept 13: The End?
- Concept 14: Thanks for Helping Carla!
-
Lesson 02: Get Ready
While you wait for your classroom to open, refresh your math and programming skills with these helpful resources.
-
Part 02 : Bayesian Thinking
Learn the framework that underlies a self-driving carâÃÂÃÂs understanding of itself and the world around it, and to see the world the way a self-driving car does.
-
Module 01:
Bayesian Thinking
-
Lesson 01: Introduction
A brief introduction to Bayesian Thinking from Sebastian.
-
Lesson 02: Joy Ride
A quick introduction to controlling a (simulated) car with code. Parts 1 and 2 will show you how to control gas and steering and in part 3 you'll program a car to parallel park.
-
Lesson 03: Probability
Learn the basics of probability - the language of robotics. This lesson will focus on the math. In later lessons you'll apply this math in Python code.
- Concept 01: Uncertainty in Driving
- Concept 02: Uncertainty in Robotics
- Concept 03: Learning Objectives Explained
- Concept 04: Learning Objectives - Probability
- Concept 05: Probability
- Concept 06: Flipping Coins
- Concept 07: Fair Coin
- Concept 08: Loaded Coin 1
- Concept 09: Loaded Coin 2
- Concept 10: Loaded Coin 3
- Concept 11: Complementary Outcomes
- Concept 12: Probability in Robotics
- Concept 13: Two Flips 1
- Concept 14: Two Flips 2
- Concept 15: Two Flips 3
- Concept 16: Two Flips 4
- Concept 17: Two Flips 5
- Concept 18: Two Cars 1-5
- Concept 19: One Head 1
- Concept 20: One Head 2
- Concept 21: One Of Three 1
- Concept 22: One Of Three 2
- Concept 23: Even Roll
- Concept 24: Doubles
- Concept 25: Summary
- Concept 26: [Optional] Cars and Probability
-
Lesson 04: Conditional Probability
In order to infer meaning from noisy sensor measurements, a self driving car needs to use the math of Conditional Probability. Learn this math from Sebastian (and then apply it in the next lesson).
- Concept 01: Conditional Probability
- Concept 02: Intro to Conditional Probability
- Concept 03: Estimating Based on Conditions
- Concept 04: Dependent Events and Conditional Probability
- Concept 05: Learning Objective Recap Explained
- Concept 06: Learning Objectives - Probability
- Concept 07: Learning Objectives - Conditional Probability
- Concept 08: Dependent Things
- Concept 09: Notation Note
- Concept 10: Medical Example 1
- Concept 11: Medical Example 2
- Concept 12: Medical Example 3
- Concept 13: Medical Example 4
- Concept 14: Medical Example 5
- Concept 15: Medical Example 6
- Concept 16: Medical Example 7
- Concept 17: Medical Example 8
- Concept 18: Total Probability
- Concept 19: Two Coins 1
- Concept 20: Two Coins 2
- Concept 21: Two Coins 3
- Concept 22: Two Coins 4
- Concept 23: Summary
- Concept 24: [Optional] Cars and Conditional Probability
-
Lesson 05: Programming Probability in Python
Your chance to learn basic Python syntax while applying what you learned about probability and conditional probability in the last two lessons.
- Concept 01: Learn by Doing
- Concept 02: Your First Programming Practice!
- Concept 03: Python Variables [demonstration]
- Concept 04: Data Types [demonstration]
- Concept 05: Python Control Flow [demonstration]
- Concept 06: For Loops [demonstration]
- Concept 07: Lists and Loops [demonstration]
- Concept 08: List Comprehensions [demonstration]
- Concept 09: Python's random Library [demonstration]
- Concept 10: Learning with Playgrounds
- Concept 11: Simulating Coin Flips [playground]
- Concept 12: Functions [demonstration]
- Concept 13: Simulating Probabilities [demonstration]
- Concept 14: Exercises
- Concept 15: Probability of Collision [exercise]
- Concept 16: Probability of Collision [solution]
-
Lesson 06: Bayes' Rule
Learn about Bayes' Rule from Sebastian and get your first peek at how a self driving car uses Bayes' Rule to understand where in the world it is.
- Concept 01: Reducing Uncertainty
- Concept 02: Bayes' Rule and Robotics
- Concept 03: Learning from Sensor Data
- Concept 04: Using Sensor Data
- Concept 05: Learning Objectives - Conditional Probability
- Concept 06: Learning Objectives - Bayes' Rule
- Concept 07: Bayes Rule
- Concept 08: Cancer Test
- Concept 09: Prior And Posterior
- Concept 10: Normalizing 1
- Concept 11: Normalizing 2
- Concept 12: Normalizing 3
- Concept 13: Total Probability
- Concept 14: Bayes Rule Diagram
- Concept 15: Equivalent Diagram
- Concept 16: Cancer Probabilities
- Concept 17: Probability Given Test
- Concept 18: Normalizer
- Concept 19: Normalizing Probability
- Concept 20: Disease Test 1
- Concept 21: Disease Test 2
- Concept 22: Disease Test 3
- Concept 23: Disease Test 4
- Concept 24: Disease Test 5
- Concept 25: Disease Test 6
- Concept 26: Bayes Rule Summary
- Concept 27: Robot Sensing 1
- Concept 28: Robot Sensing 2
- Concept 29: Robot Sensing 3
- Concept 30: Robot Sensing 4
- Concept 31: Robot Sensing 5
- Concept 32: Robot Sensing 6
- Concept 33: Robot Sensing 7
- Concept 34: Robot Sensing 8
- Concept 35: Generalizing
- Concept 36: Sebastian At Home
-
Lesson 07: Programming Bayes' Rule and World Representations
In this lesson, you can expect a lot of hands-on practice programming Bayesian probability in Python, and representing a 2D world that you'll need to localize a car.
- Concept 01: Bayes' Rule Steps
- Concept 02: Programming Probabilities [exercise]
- Concept 03: Total Probability [exercise]
- Concept 04: Testing the Total
- Concept 05: Programming Bayes' Rule [exercise]
- Concept 06: Testing Bayes' Rule
- Concept 07: Arrays [demonstration]
- Concept 08: Array Iteration and Stopping [exercise]
- Concept 09: 2D Arrays and the Robot World [demonstration]
- Concept 10: 2D Iteration [demonstration]
- Concept 11: Pattern Matching [exercise]
- Concept 12: Why use Numpy Arrays [demonstration]
-
Lesson 08: Probability Distributions
Learn how a robot represents it's belief about uncertain quantities using something known as a probability distribution .
- Concept 01: Probability Distributions
- Concept 02: Intro to Probability Distributions Part One
- Concept 03: Intro to Probability Distributions Part Two
- Concept 04: Learning Objectives - Bayes' Rule
- Concept 05: Discrete vs. Continuous Variables
- Concept 06: Discrete Probability Distributions
- Concept 07: Discrete Probability [Exercise]
- Concept 08: Discrete Probability [Exercise] Solution
- Concept 09: Continuous Variables
- Concept 10: Landing Probability
- Concept 11: Spinning Probability
- Concept 12: Stops Nowhere
- Concept 13: Range Probability
- Concept 14: Range Probability 2
- Concept 15: Range Probability 3
- Concept 16: Continuous Probability Distributions
- Concept 17: Density
- Concept 18: Birth Time Density
- Concept 19: Changing Density
- Concept 20: Changing Density 2
- Concept 21: Check Density
- Concept 22: Calculate Density
- Concept 23: Density Properties
- Concept 24: Summary
-
Lesson 09: Programming Probability Distributions
Apply what you've learned in this course by programming and visualizing probability distributions.
- Concept 01: Prepare for a Challenge
- Concept 02: Programming Probability Distributions
- Concept 03: Math in Python [demonstration]
- Concept 04: Uniform Distribution [exercise]
- Concept 05: Uniform Distribution Solution
- Concept 06: Function Improvements [exercise]
- Concept 07: Function Improvements Solution
- Concept 08: Plotting in Python [demonstration]
- Concept 09: Visualizing Uniform Distributions [exercise]
- Concept 10: Visualizing Uniform Distributions Solution
- Concept 11: Visualizing Piece-wise Uniform Distributions
- Concept 12: Visualizing Piece-Wise Distributions [exercise]
- Concept 13: Visualizing Piece-Wise Distributions Solution
- Concept 14: 1-D Car World [exercise]
- Concept 15: 1-D Car World Solution
- Concept 16: 2-D Car World [demonstration]
- Concept 17: 2-D Car World [exercise]
- Concept 18: 2-D Car World Solution
- Concept 19: Conclusion
-
Lesson 10: Gaussian Distributions
You will work with a specific continuous probability distribution called the Gaussian distribution. A Gaussian distribution helps describe uncertainty in sensor measurements and a vehicle's location.
- Concept 01: Introduction
- Concept 02: Continuous Distributions
- Concept 03: Gaussian Distributions
- Concept 04: Gaussian Equation
- Concept 05: Mean
- Concept 06: Standard Deviation
- Concept 07: Plotting Gaussians in Python [exercise]
- Concept 08: Plotting Gaussians in Python [Solution]
- Concept 09: Area Under the Curve
- Concept 10: Calculating Area Under the Curve in Python
- Concept 11: Calculating Area Under the Curve [Solution]
- Concept 12: Central Limit Theorem [Optional]
- Concept 13: Central Limit Theorem [Optional Demo]
- Concept 14: Conclusion
-
Lesson 11: Robot Localization
Sebastian Thrun will give you an overview of the theory behind localization!
- Concept 01: About this Lesson
- Concept 02: Introduction
- Concept 03: Localization
- Concept 04: Total Probability
- Concept 05: Uniform Probability Quiz
- Concept 06: Uniform Distribution
- Concept 07: Generalized Uniform Distribution
- Concept 08: Probability After Sense
- Concept 09: Compute Sum
- Concept 10: Normalize Distribution
- Concept 11: pHit and pMiss
- Concept 12: Sum of Probabilities
- Concept 13: Sense Function
- Concept 14: Normalized Sense Function
- Concept 15: Test Sense Function
- Concept 16: Multiple Measurements
- 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: Nanodegree Note
- Concept 30: Formal Definition of Probability 1
- Concept 31: Formal Definition of Probability 2
- Concept 32: Formal Definition of Probability 3
- Concept 33: Bayes' Rule
- Concept 34: Cancer Test
- Concept 35: Theorem of Total Probability
- Concept 36: Coin Flip Quiz
- Concept 37: Two Coin Quiz
-
Lesson 12: Histogram Filter in Python
Write the
senseandmovefunctions for a 2 dimensional histogram filter in Python.
-
Part 03 : Working with Matrices
This course will focus on two tools which are vital to self-driving car engineers: object oriented programming and linear algebra.
-
Module 01:
Working with Matrices
-
Lesson 01: Section Overview
An introduction to the amazing tools and algorithms you'll learn in this lesson.
-
Lesson 02: Introduction to Kalman Filters
Learn the intuition behind the Kalman Filter, a vehicle tracking algorithm and implement a one-dimensional tracker of your own.
- 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 1
- Concept 09: Measurement and Motion 2
- Concept 10: Shifting the Mean
- Concept 11: Predicting the Peak
- Concept 12: Parameter Update
- Concept 13: Parameter Update 2
- Concept 14: Separated Gaussians
- Concept 15: Separated Gaussians 2
- Concept 16: New Mean and Variance
- Concept 17: Gaussian Motion
- Concept 18: Predict Function
- Concept 19: Kalman Filter Code
- Concept 20: Kalman Prediction
- Concept 21: A Break from Kalman Filters
-
Lesson 03: State and Object-Oriented Programming
In this lesson, students will learn about representing the state of a car in programming as classes and objects and mathematically as vectors that can be changed with linear algebra!
- Concept 01: Localization Steps
- Concept 02: Intro to State
- Concept 03: Motion Models
- Concept 04: Quiz: Predicting State
- Concept 05: A Different Model
- Concept 06: Kinematics
- Concept 07: Quantifying State
- Concept 08: Lesson Outline
- Concept 09: Always Moving
- Concept 10: Objects
- Concept 11: Car Object
- Concept 12: Interacting with a Car Object
- Concept 13: Car Class
- Concept 14: Car Class File
- Concept 15: Look at the Class Code
- Concept 16: Turn Right
- Concept 17: Adding Color
- Concept 18: Instantiate Multiple Cars
- Concept 19: Color Class
- Concept 20: Overloading Functions
- Concept 21: Overloading Color Addition
- Concept 22: State Vector
- Concept 23: State Transformation Matrix
- Concept 24: Matrix Multiplication
- Concept 25: 1D State Vector and More Multiplication
- Concept 26: Modify Predict State
- Concept 27: Working with Matrices
-
Lesson 04: Matrices and Transformation of State
Linear Algebra is a rich branch of math and a useful tool. In this lesson you'll learn about the matrix operations that underly multidimensional Kalman Filters.
- Concept 01: Connection to Kalman Filters
- Concept 02: Kalman Prediction
- Concept 03: Kalman Filter Land
- Concept 04: Kalman Filter Prediction
- Concept 05: Another Prediction
- Concept 06: More Kalman Filters
- Concept 07: A Note on Notation
- Concept 08: Kalman Filter Design
- Concept 09: Let's Look at Where we Are
- Concept 10: The Kalman Filter Equations
- Concept 11: Simplifying the Kalman Filter Equations
- Concept 12: The Rest of the Lesson
- Concept 13: Representing State with Matrices
- Concept 14: Kalman Equation Reference
- Concept 15: What is a vector?
- Concept 16: Vectors in Python
- Concept 17: Coding Vectors
- Concept 18: Coding Vectors (solution)
- Concept 19: Guide to Mathematical Notation
- Concept 20: Matrices in Python
- Concept 21: Coding Matrices
- Concept 22: Coding Matrices (Solution)
- Concept 23: Matrix Addition
- Concept 24: Coding Matrix Addition
- Concept 25: Coding Matrix Addition (Solution)
- Concept 26: Matrix Multiplication
- Concept 27: Coding Matrix Multiplication
- Concept 28: Coding Matrix Multiplication (Solution)
- Concept 29: Transpose of a Matrix
- Concept 30: Coding the Transpose
- Concept 31: Coding the Transpose (Solution)
- Concept 32: The Identity Matrix
- Concept 33: Coding Identity Matrix
- Concept 34: Coding Identity Matrix (Solution)
- Concept 35: Matrix Inverse
- Concept 36: Coding Matrix Inverse
- Concept 37: Coding Matrix Inverse (Solution)
- Concept 38: What to Take Away from this Lesson
-
Lesson 05: Implement Matrix Class
Practice using your object oriented programming and matrix math skills by filling out the methods in a partially-completed
Matrixclass.
-
Part 04 : C++ Basics
This course is the first step in a rewarding journey towards C++ expertise. The goal is translation: get a program written in Python, and translate it into C++.
-
Module 01:
C++ Basics
-
Lesson 01: C++ Getting Started
The differences between C++ and Python and how to write C++ code.
- Concept 01: Introduction
- Concept 02: Lesson Overview
- Concept 03: Elecia White
- Concept 04: Why C++
- Concept 05: Python and C++ Comparison
- Concept 06: Static vs Dynamic Typing
- Concept 07: C++ - A Statically Typed Language
- Concept 08: Basic Data Types
- Concept 09: Floating versus Double [demonstration]
- Concept 10: Doubles are Bigger
- Concept 11: Common Errors and Error Messages
- Concept 12: C++ Functions
- Concept 13: Anatomy of a Function
- Concept 14: Multiple Outputs
- Concept 15: Two Functions Same Name
- Concept 16: Function Signatures 1
- Concept 17: Function Signatures 2
- Concept 18: If and Boolean Logic
- Concept 19: While and For Loops
- Concept 20: Switch Statement
- Concept 21: Libraries
- Concept 22: Forge on!
-
Lesson 02: C++ Vectors
To program matrix algebra operations and translate your Python code, you will need to use C++ Vectors. These vectors are similar to Python lists, but the syntax can be somewhat tricky.
- Concept 01: C++ Vectors
- Concept 02: Namespaces
- Concept 03: Python Lists vs. C++ Vectors
- Concept 04: Initializing Vector Values
- Concept 05: Vector Methods
- Concept 06: Vectors and For Loops
- Concept 07: Math and Vectors
- Concept 08: 1D Vector Playground
- Concept 09: 2D Vectors
- Concept 10: 2D Vectors and For Loops
- Concept 11: 2D Vector Playground
- Concept 12: Next Lesson
-
Lesson 03: Practical C++
Learn how to write C++ code on your own computer and compile it into a executable program without running into too many compilation errors.
-
Lesson 04: C++ Object Oriented Programming
Learn the syntax of C++ object oriented programming as well as some of the additional OOP features provided by the language.
- Concept 01: Introduction
- Concept 02: Python vs. C++
- Concept 03: Why use Object Oriented Programming?
- Concept 04: Using a Class in C++ [Demo]
- Concept 05: Explanation of the Main.cpp File
- Concept 06: Practice Using a Class
- Concept 07: Review: Anatomy of a Class
- Concept 08: Other Facets of C++ Classes
- Concept 09: Private and Public
- Concept 10: Header Files
- Concept 11: Inclusion Guards
- Concept 12: Implement a Class
- Concept 13: Class Variables
- Concept 14: Class Function Declarations
- Concept 15: Constructor Functions
- Concept 16: Set and Get Functions
- Concept 17: Matrix Functions
- Concept 18: Use an Inclusion Guard
- Concept 19: Instantiate an Object
- Concept 20: Running your Program Locally
-
Lesson 05: Python and C++ Speed
In this lesson, we'll compare the execution times of C++ and Python programs.
-
Lesson 06: Translate Python to C++
Apply your knowledge of C++ syntax by translating the Histogram Filter code from the first course into C++.
-
Part 05 : Performance Programming in C++
Explore how to write good code that runs correctly. WeâÃÂÃÂll focus primarily on low level features of C++, but weâÃÂÃÂll discuss other best practices as well.
-
Module 01:
Performance Programming in C++
-
Lesson 01: C++ Intro to Optimization
Optimizing C++ involves understanding how a computer actually runs your programs. You'll learn how C++ uses the CPU and RAM to execute your code and get a sense for what can slow things down.
- Concept 01: Course Introduction
- Concept 02: Empathize with the Computer
- Concept 03: Intro to Computer Hardware
- Concept 04: Embedded Terminal Explanation
- Concept 05: Demo: Machine Code
- Concept 06: Assembly Language
- Concept 07: Binary
- Concept 08: Demo: Binary
- Concept 09: Demo: Binary Floats
- Concept 10: Memory and the CPU
- Concept 11: Demo: Stack vs Heap
- Concept 12: Outro
-
Lesson 02: C++ Optimization Practice
Now you understand how C++ programs execute. It's time to learn specific optimization techniques and put them into practice. This lesson will prepare you for the lesson's code optimization project.
- Concept 01: Introduction
- Concept 02: Software Development and Optimization
- Concept 03: Optimization Techniques
- Concept 04: Dead Code
- Concept 05: Exercise: Remove Dead Code
- Concept 06: If Statements
- Concept 07: Exercise: If Statements
- Concept 08: For Loops
- Concept 09: Exercise: For Loops
- Concept 10: Intermediate Variables
- Concept 11: Exercise: Intermediate Variables
- Concept 12: Vector Storage
- Concept 13: Exercise: Vector Storage
- Concept 14: References
- Concept 15: Exercise: References
- Concept 16: Sebastian's Synchronization Story
- Concept 17: Static Keyword
- Concept 18: Exercise: Static Keyword
- Concept 19: Speed Challenge
-
Lesson 03: Project: Optimize Histogram Filter
Get ready to optimize some C++ code. You are provided with a working 2-dimensional histogram filter; your job is to get the histogram filter code to run faster!
-
Part 06 : Navigating Data Structures
Algorithmic thinking is a skill youâÃÂÃÂll refine throughout your career. In this course youâÃÂÃÂll focus on frequently used data structures and algorithms.
-
Module 01:
Navigating Data Structures
-
Lesson 01: How to Solve Problems
In this lesson you'll solve a hard problem with the help of Dave Evans and you'll learn a systematic approach to solving hard computer programming problems as you do.
- Concept 01: Course Overview
- Concept 02: About this Lesson
- Concept 03: How to Solve Problems
- Concept 04: Days Between Dates
- Concept 05: Attempting the Problem [workspace]
- Concept 06: First Step
- Concept 07: Understanding a Problem
- Concept 08: The First Rule
- Concept 09: What Are the Inputs
- Concept 10: How Are Inputs Represented
- Concept 11: What Are the Outputs
- Concept 12: Obey the Rules
- Concept 13: Next Step
- Concept 14: The Expected Output
- Concept 15: Take the Next Step
- Concept 16: Try an Example
- Concept 17: Harder Example
- Concept 18: Algorithm Pseudocode
- Concept 19: Should We Implement It
- Concept 20: Different Approach
- Concept 21: Simple Mechanical Algorithm
- Concept 22: Don't Optimize Prematurely
- Concept 23: What Should We Write First
- Concept 24: Define Simple nextDay
- Concept 25: Making Progress Is Good
- Concept 26: What Should We Do Next
- Concept 27: Define daysBetweenDates
- Concept 28: Step One Pseudocode
- Concept 29: Step Two Helper Function
- Concept 30: Step Three daysBetweenDates
- Concept 31: Test for Valid Inputs
- Concept 32: Real World Problem
- Concept 33: Best Strategy
- Concept 34: Completing the Problem
- Concept 35: Finish daysBetweenDates
- Concept 36: Solution Step I
- Concept 37: Solution Step II
- Concept 38: Solution Step III
- Concept 39: Solution Step IV
- Concept 40: Conclusion
-
Lesson 02: Data Structures
The list isn't the only structure for storing data! In this lesson you'll learn about sets, dictionaries and other Python data structures.
- Concept 01: Lesson Overview
- Concept 02: Tracking Tickets
- Concept 03: Design Tradeoffs
- Concept 04: Three Approaches
- Concept 05: Representing a Single Ticket
- Concept 06: The problems with strings and lists
- Concept 07: Intro to Dictionaries
- Concept 08: Intro to Dictionaries 2
- Concept 09: Keys and Values
- Concept 10: Adding Labels
- Concept 11: Implementing Labels (and Introducing Sets)
- Concept 12: Performance Considerations
- Concept 13: Lists, Timing, and Performance
- Concept 14: How Lists Work
- Concept 15: Performance of Sets and Dictionaries
- Concept 16: How Sets and Dictionaries Work
- Concept 17: Other Data Structures [optional]
- Concept 18: Choosing good data structures
- Concept 19: Conclusion
-
Lesson 03: The Search Problem
When programming a car to drive itself you run into problems. Many of these are "search" problems. In this lesson you'll learn what search problems are and several algorithms for solving them.
- Concept 01: Lesson Overview
- Concept 02: Introduction
- Concept 03: What Is A Problem?
- Concept 04: Example: Route Finding
- Concept 05: Quiz: Tree Search
- Concept 06: Tree Search Continued
- Concept 07: Quiz: Graph Search
- Concept 08: Quiz: Breadth First Search 1
- Concept 09: Breadth First Search 2
- Concept 10: Quiz: Breadth First Search 3
- Concept 11: Breadth First Search 4
- Concept 12: Breadth First Search 5
- Concept 13: Uniform Cost Search
- Concept 14: Uniform Cost Search 1
- Concept 15: Uniform Cost Search 2
- Concept 16: Uniform Cost Search 3
- Concept 17: Uniform Cost Search 4
- Concept 18: Uniform Cost Search 5
- Concept 19: Quiz: Search Comparison
- Concept 20: Search Comparison 1
- Concept 21: Quiz: Search Comparison 2
- Concept 22: Search Comparison 3
- Concept 23: On Uniform Cost
- Concept 24: A* Search
- Concept 25: A* Search 1
- Concept 26: A* Search 2
- Concept 27: A* Search 3
- Concept 28: A* Search 4
- Concept 29: A* Search 5
- Concept 30: Optimistic Heuristic
- Concept 31: Quiz: Sliding Blocks Puzzle
- Concept 32: Sliding Blocks Puzzle 1
- Concept 33: Sliding Blocks Puzzle 2
- Concept 34: Problems with Search
- Concept 35: A Note on Implementation
-
Lesson 04: Implement Route Planner
In this lesson you will actually implement a Google-maps style routing algorithm using A star search.
-
Part 07 : Career Services
These Career Services will ensure you make meaningful connections with industry professionals to accelerate your career growth - whether looking for a job or opportunities to collaborate with your peers. Unlike your Nanodegree projects, you do not need to meet specifications on these Services to progress in your program. Submit these Career Services once, and get honest, personalized feedback and next steps from Udacity Career Coaches!
-
Module 01:
Career Services
-
Lesson 01: Industry Research
You're building your online presence. Now learn how to share your story, understand the tech landscape better, and meet industry professionals.
- Concept 01: Self-Reflection: Design Your Blueprint for Success
- Concept 02: Debrief: Self-Reflection Exercise Part 1
- Concept 03: Debrief: Self-Reflection Exercise Part 2
- Concept 04: Map Your Career Journey
- Concept 05: Debrief: Map Your Career Journey
- Concept 06: Conduct an Informational Interview
- Concept 07: How to Request an Informational Interview
- Concept 08: Ways to Connect
- Concept 09: Ask Good Questions
- Concept 10: Debrief: Sample Questions Quiz
- Concept 11: Keep the Conversation Going
-
Lesson 02: Take 30 Min to Improve your LinkedIn
Find your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.
- Concept 01: Get Opportunities with LinkedIn
- Concept 02: Use Your Story to Stand Out
- Concept 03: Why Use an Elevator Pitch
- Concept 04: Create Your Elevator Pitch
- Concept 05: Use Your Elevator Pitch on LinkedIn
- Concept 06: Create Your Profile With SEO In Mind
- Concept 07: Profile Essentials
- Concept 08: Work Experiences & Accomplishments
- Concept 09: Build and Strengthen Your Network
- Concept 10: Reaching Out on LinkedIn
- Concept 11: Boost Your Visibility
- Concept 12: Up Next
-
Lesson 03: Optimize Your GitHub Profile
Other professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.
- Concept 01: Prove Your Skills With GitHub
- Concept 02: Introduction
- Concept 03: GitHub profile important items
- Concept 04: Good GitHub repository
- Concept 05: Interview with Art - Part 1
- Concept 06: Identify fixes for example âÃÂÃÂbadâÃÂàprofile
- Concept 07: Quick Fixes #1
- Concept 08: Quick Fixes #2
- Concept 09: Writing READMEs with Walter
- Concept 10: Interview with Art - Part 2
- Concept 11: Commit messages best practices
- Concept 12: Reflect on your commit messages
- Concept 13: Participating in open source projects
- Concept 14: Interview with Art - Part 3
- Concept 15: Participating in open source projects 2
- Concept 16: Starring interesting repositories
- Concept 17: Next Steps
-
Part 08 : Vehicle Motion and Control
This course is a crash course in two branches of mathematics which are crucial to self driving cars: calculus and trigonometry. You will learn how a self driving car uses various motion sensors to help it understand its own motion.
At the end of this course you will use raw sensor data (which give information about distance driven, acceleration, and rotation rates) to reconstruct a vehicle's trajectory through space.
-
Module 01:
Vehicle Motion and Control
-
Lesson 01: Odometers, Speedometers and Derivatives
Gain a conceptual understanding of the derivative and basic calculus by plotting points and finding slopes.
- Concept 01: Teleoperation at Phantom Auto
- Concept 02: Inertial Navigation
- Concept 03: Course Overview
- Concept 04: Inertial Navigation Sensors
- Concept 05: Afternoon Drive
- Concept 06: Delta x over Delta t
- Concept 07: Reducing Delta t
- Concept 08: Plotting Position vs. Time
- Concept 09: Interpreting Position vs. Time Graphs
- Concept 10: Average vs. Instantaneous Speed
- Concept 11: Defining the Derivative
- Concept 12: Understanding the Derivative
- Concept 13: Differential Notation
- Concept 14: A "Typical" Calculus Problem
- Concept 15: How Odometers Work
- Concept 16: Speed from Position Data
- Concept 17: Position, Velocity, and Acceleration
- Concept 18: Implement an Accelerometer
- Concept 19: Summary
-
Lesson 02: Accelerometers, Rate Gyros and Integrals
Learn how integrals can be used to calculate accumulated changes by finding the area under a curve.
- Concept 01: Lesson Introduction
- Concept 02: Differentiation Recap
- Concept 03: Acceleration Basics
- Concept 04: Plotting Elevator Acceleration
- Concept 05: Reasoning About Two Peaks
- Concept 06: The Integral: Area Under a Curve
- Concept 07: Approximating the Integral
- Concept 08: Approximating Integrals with Code
- Concept 09: Integrating Accelerometer Data
- Concept 10: Rate Gyros
- Concept 11: Integrating Rate Gyro Data
- Concept 12: Working with Real Data
- Concept 13: Accumulating Errors
- Concept 14: Sensor Strengths and Weaknesses
- Concept 15: Lesson Summary
-
Lesson 03: Two Dimensional Robot Motion and Trigonometry
Learn the basics of trigonometry and how to decompose a self driving car's motion into X and Y components.
- Concept 01: Lesson Introduction
- Concept 02: Plotting Robot Motion (right angles only)
- Concept 03: Plotting Robot Motion Solution
- Concept 04: Moving at an Angle
- Concept 05: Moving at 53.13 Degrees
- Concept 06: Who Cares About 53.13 Degrees?
- Concept 07: The Power of Trigonometry
- Concept 08: Opposite, Adjacent, Hypotenuse
- Concept 09: Trigonometric Ratios
- Concept 10: Looking up Sin, Cos, and Tan
- Concept 11: Trigonometry and Vehicle Motion
- Concept 12: Solving Trig Problems
- Concept 13: Keeping Track of x and y
- Concept 14: Keeping Track of x and y (solution)
- Concept 15: Conclusion
-
Lesson 04: Reconstructing Trajectories from Sensor Data
Use raw acceleration, displacement, and angular rotation data from a vehicle's accelerometer, odometer, and rate gyros to reconstruct a vehicle's X, Y trajectory.
-
Part 09 : Computer Vision and Machine Learning
In this course youâÃÂÃÂll learn how a computer sees an image, and how we can use machine learning to teach a computer to identify images programmatically.
-
Module 01:
Computer Vision and Machine Learning
-
Lesson 01: Computer Vision and Classification
Students will learn how to program an image classifier using computer vision techniques. Along the way you'll learn about machine learning, color transformation, feature extraction, and more!
- Concept 01: Deep Learning at NVIDIA
- Concept 02: Classifying Sebastian
- Concept 03: Welcome to Computer Vision
- Concept 04: Introducing Tarin
- Concept 05: Vision and Self-Driving Cars
- Concept 06: LiDAR Data
- Concept 07: Image Classification Pipeline
- Concept 08: Quiz: Classification Steps
- Concept 09: Learning to Classify Images
- Concept 10: What is Machine Learning?
- Concept 11: Training a Model
- Concept 12: Quiz: Choose Layers of Separation
- Concept 13: Images as Grids of Pixels
- Concept 14: Notebook: Images as Numerical Data
- Concept 15: Color Images
- Concept 16: Color or Grayscale?
- Concept 17: Notebook: Visualizing RGB Channels
- Concept 18: Pre-processing
- Concept 19: Notebook: Cropping and Resizing
- Concept 20: Color Masking
- Concept 21: Installing OpenCV, Instructions
- Concept 22: Green Screen Car
- Concept 23: Notebook: Green Screen Background
- Concept 24: Color Spaces and Transforms
- Concept 25: HSV Conversion
- Concept 26: Notebook: Color Conversion
- Concept 27: Day and Night Classification
- Concept 28: Notebook: Load and Visualize the Data
- Concept 29: Labeled Data and Accuracy
- Concept 30: Distinguishing Traits
- Concept 31: Feature Extraction
- Concept 32: Features
- Concept 33: Standardizing Output
- Concept 34: Notebook: Standardizing Day and Night Images
- Concept 35: Average Brightness
- Concept 36: Notebook: Average Brightness Feature Extraction
- Concept 37: Features and Classification
- Concept 38: Selecting Features
- Concept 39: Filters and Finding Edges
- Concept 40: High-pass Filter
- Concept 41: Quiz: Kernels
- Concept 42: Notebook: Finding Edges
- Concept 43: Convolution in Self-Driving Cars
- Concept 44: Notebook: Histograms and Feature Vectors
- Concept 45: Classification
- Concept 46: Notebook: Classification
- Concept 47: Convolutional Neural Networks
- Concept 48: Evaluation Metrics
- Concept 49: Notebook: Accuracy and Misclassification
- Concept 50: Congratulations!!
- Concept 51: Ends and Beginnings!
-
Lesson 02: Traffic Light Classifier
Build a classification pipeline that takes in an image of a traffic and outputs a label that classifies the image as a: red, green, or yellow traffic light.
-
Part 10 : Graduation!
Congratulations! You're ready to graduate. Learn how you can continue your Udacity journey by enrolling in a Career-Ready Nanodegree Program
-
Module 01:
Congratulations!
-
Lesson 01: Congratulations! You've finished!
Congratulations! You've reached the end of the Intro to Self-Driving Cars Nanodegree program!
-
-
Module 02:
Your next Nanodegree
-
Lesson 01: Your next Nanodegree
Enroll in a Career-Ready Nanodegree program
-