AI Programming with Python Nanodegree v5.0.0

Let's focus on library packages for Python, such as : Numpy (which adds support for large data),Pandas (which is used for data manipulation and analysis)And Matplotlib (which is used for data visualization).

Module 01: Lessons
- Lesson 01: Anaconda
  Anaconda is a package and environment manager built specifically for data. Learn how to use Anaconda to improve your data analysis workflow.
- Lesson 02: Jupyter Notebooks
  Learn how to use Jupyter Notebooks to create documents combining code, text, images, and more.
- Lesson 03: NumPy
  Learn the basics of NumPy and how to use it to create and manipulate arrays.
- Lesson 04: Pandas
  Learn the basics of Pandas Series and DataFrames and how to use them to load and process data.
- Lesson 05: Matplotlib and Seaborn Part 1
  Learn how to use matplotlib and seaborn to visualize your data. In this lesson, you will learn how to create visualizations to depict the distributions of single variables.
- Lesson 06: Matplotlib and Seaborn Part 2
  In this lesson, you will use matplotlib and seaborn to create visualizations to depict the relationships between two variables.

Part 08 : Linear Algebra Essentials

Learn the basics of the beautiful world of Linear Algebra andwhy it is such an important mathematical tool in the world of AI.

Module 01: Lessons
- Lesson 01: Introduction
  Take a sneak peek into the beautiful world of Linear Algebra and learn why it is such an important mathematical tool.
- Lesson 02: Vectors
  Learn about vectors, the basic building block of Linear Algebra.
- Lesson 03: Linear Combination
  Learn how to scale and add vectors and how to visualize the process.
- Lesson 04: Linear Transformation and Matrices
  What is a linear transformation and how is it directly related to matrices? Learn how to apply the math and visualize the concept.
Module 02: Labs
- Lesson 01: Vectors Lab
  Learn how to graph 2D vectors.
  - Concept 01: Vectors Lab
  - Concept 02: Vectors Lab Solution
- Lesson 02: Linear Combination Lab
  Learn how to computationally determine a vector's span and solve a simple system of equations.
  - Concept 01: Linear Combination
  - Concept 02: Linear Combination Lab Solution
- Lesson 03: Linear Mapping Lab
  Learn how to solve some problems computationally using vectors and matrices.
- Lesson 04: Linear Algebra in Neural Networks
  Take a peek into the world of Neural Networks and see how it related directly to Linear Algebra!

Part 09 : Calculus Essentials

Welcome to Calculus Essentials.

Part 10 : Supervised Learning

Learn to build supervised machine learning models to make data-informed decisions. Learn to evaluate and validate the quality of your models.

Module 01: Supervised Learning
- Lesson 01: Machine Learning Bird's Eye View
  Before diving into the many algorithms of machine learning, it is important to take a step back and understand the big picture associated with the entire field.
- Lesson 02: Linear Regression
  Linear regression is one of the most fundamental algorithms in machine learning. In this lesson, learn how linear regression works!
- Lesson 03: Perceptron Algorithm
  The perceptron algorithm is an algorithm for classifying data. It is the building block of neural networks.
- Lesson 04: Decision Trees
  Decision trees are a structure for decision-making where each decision leads to a set of consequences or additional decisions.
- Lesson 05: Naive Bayes
  Naive Bayesian Algorithms are powerful tools for creating classifiers for incoming labeled data. Specifically Naive Bayes is frequently used with text data and classification problems.
- Lesson 06: Support Vector Machines
  Support vector machines are a common method used for classification problems. They have been proven effective using what is known as the 'kernel' trick!
- Lesson 07: Ensemble Methods
  Bagging and boosting are two common ensemble methods for combining simple algorithms to make more advanced models that work better than the simple algorithms would on their own.
- Lesson 08: Model Evaluation Metrics
  Learn the main metrics to evaluate models, such as accuracy, precision, recall, and more!
- Lesson 09: Training and Tuning
  Learn the main types of errors that can occur during training, and several methods to deal with them and optimize your machine learning models.
- Lesson 10: Finding Donors Project
  You've covered a wide variety of methods for performing supervised learning -- now it's time to put those into action!
  
  Project Description - Finding Donors for CharityML
  
  Project Rubric - Finding Donors for CharityML

Part 11 : Deep Learning

Gain a solid foundation in neural networks, deep learning, and PyTorch.

Module 01: Deep Learning
- Lesson 01: Introduction to Neural Networks
  In this lesson, Luis will give you solid foundations on deep learning and neural networks. You'll also implement gradient descent and backpropagation in python right here in the classroom.
- Lesson 02: Implementing Gradient Descent
  Mat will introduce you to a different error function and guide you through implementing gradient descent using numpy matrix multiplication.
- Lesson 03: Training Neural Networks
  Now that you know what neural networks are, in this lesson you will learn several techniques to improve their training.
- Lesson 04: Keras
  In this section you'll get a hands-on introduction to Keras. You'll learn to apply it to analyze movie reviews.
- Lesson 05: Deep Learning with PyTorch (updated version)
  Learn how to use PyTorch for building deep learning models.
- Lesson 06: Deep Learning with PyTorch
  Learn how to use PyTorch for building deep learning models
- Lesson 07: Image Classifier Project
  In this project, you'll build a Python application that can train an image classifier on a dataset, then predict new images using the trained model.
  
  Project Description - Create Your Own Image Classifier
  
  Project Rubric - Create Your Own Image Classifier

Part 12 : Unsupervised Learning

Learn to build unsupervised machine learning models, and use essential data processing techniques like scaling and PCA.

Module 01: Unsupervised Learning
- Lesson 01: Clustering
  Clustering is one of the most common methods of unsupervised learning. Here, we'll discuss the K-means clustering algorithm.
- Lesson 02: Hierarchical and Density Based Clustering
  We continue to look at clustering methods. Here, we'll discuss hierarchical clustering and density-based clustering (DBSCAN).
- Lesson 03: Gaussian Mixture Models and Cluster Validation
  In this lesson, we discuss Gaussian mixture model clustering. We then talk about the cluster analysis process and how to validate clustering results.
- Lesson 04: Dimensionality Reduction and PCA
  Often we need to reduce a large number of features in our data to a smaller, more relevant set. Principal Component Analysis, or PCA, is a method of feature extraction and dimensionality reduction.
- Lesson 05: Random Projection and ICA
  In this lesson, we will look at two other methods for feature extraction and dimensionality reduction: Random Projection and Independent Component Analysis (ICA).
- Lesson 06: Project: Identify Customer Segments
  In this project, you'll apply your unsupervised learning skills to two demographics datasets, to identify segments and clusters in the population, and see how customers of a company map to them.
  
  Project Description - Creating Customer Segments with Arvato
  
  Project Rubric - Creating Customer Segments with Arvato

Part 13 : Convolutional Neural Networks

Learn how to build convolutional networks and use them to classify images (faces, melanomas, etc.) based on patterns and objects that appear in them. Use these networks to learn data compression and image de-noising.

Module 01: Convolutional Neural Networks
- Lesson 01: Convolutional Neural Networks
  Convolutional Neural Networks allow for spatial pattern recognition. Alexis and Cezanne go over how they help us dramatically improve performance in image classification.
- Lesson 02: Cloud Computing
  Take advantage of Amazon's GPUs to train your neural network faster. In this lesson, you'll setup an instance on AWS and train a neural network on a GPU.
- Lesson 03: Transfer Learning
  Learn how to apply a pre-trained network to a new problem with transfer learning.
- Lesson 04: Weight Initialization
  In this lesson, you'll learn how to find good initial weights for a neural network. Having good initial weights can place the neural network closer to the optimal solution.
- Lesson 05: Autoencoders
  Autoencoders are neural networks used for data compression, image de-noising, and dimensionality reduction. Here, you'll build autoencoders using PyTorch.
Module 02: Style Transfer
- Lesson 01: Style Transfer
  Learn how to use a pre-trained network to extract content and style features from an image. Implement style transfer with your own images!
Module 03: Project: Dog-Breed Classifier
- Lesson 01: Project: Dog-Breed Classifier
  In this project, you will learn how to build a pipeline to process real-world, user-supplied images. Given an image of a dog, your algorithm will identify an estimate of the canine’s breed.
  
  Project Description - Dog-Breed Classifier
  
  Project Rubric - Dog-Breed Classifier
  - Concept 01: CNN Project: Dog Breed Classifier
  - Concept 02: Dog Project Workspace
Module 04: Deep Learning for Cancer Detection
- Lesson 01: Deep Learning for Cancer Detection
  In this lesson, Sebastian Thrun teaches us about his groundbreaking work detecting skin cancer with convolutional neural networks.
Module 05: Jobs in Deep Learning
- Lesson 01: Jobs in Deep Learning
  To kick off your industry research, learn about real world applications of Deep Learning and common questions about jobs in this field.
  - Concept 01: Jobs in Deep Learning
  - Concept 02: Real-World Applications of Deep Learning
- Lesson 02: 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.
  
  Project Description - Optimize Your GitHub Profile
  
  Project Rubric - Optimize Your GitHub Profile

Part 14 : Recurrent Neural Networks

Build your own recurrent networks and long short-term memory networks with PyTorch; perform sentiment analysis and use recurrent networks to generate new text from TV scripts.

Module 01: Recurrent Neural Networks
- Lesson 01: Recurrent Neural Networks
  Explore how memory can be incorporated into a deep learning model using recurrent neural networks (RNNs). Learn how RNNs can learn from and generate ordered sequences of data.
- Lesson 02: Long Short-Term Memory Networks (LSTMs)
  Luis explains Long Short-Term Memory Networks (LSTM), and similar architectures which have the benefits of preserving long term memory.
- Lesson 03: Implementation of RNN & LSTM
  Learn how to represent memory in code. Then define and train RNNs in PyTorch and apply them to tasks that involve sequential data.
- Lesson 04: Hyperparameters
  Learn about a number of different hyperparameters that are used in defining and training deep learning models. We'll discuss starting values and intuitions for tuning each hyperparameter.
- Lesson 05: Embeddings & Word2Vec
  In this lesson, you'll learn about embeddings in neural networks by implementing the Word2Vec model.
- Lesson 06: Sentiment Prediction RNN
  Implement a sentiment prediction RNN for predicting whether a movie review is positive or negative!
Module 02: Project: Generate TV Scripts
- Lesson 01: Project: Generate TV Scripts
  Generate a TV script by defining and training a recurrent neural network.
  
  Project Description - Generate TV Scripts
  
  Project Rubric - Generate TV Scripts
Module 03: Attention
- Lesson 01: Attention
  Attention is one of the most important recent innovations in deep learning. In this section, you'll learn how attention models work and go over a basic code implementation.

Part 15 : Generative Adversarial Networks

Learn to understand and implement a Deep Convolutional GAN (generative adversarial network) to generate realistic images, with Ian Goodfellow, the inventor of GANs, and Jun-Yan Zhu, the creator of CycleGANs.

Module 01: Generative Adversarial Networks
- Lesson 01: Generative Adversarial Networks
  Ian Goodfellow, the inventor of GANs, introduces you to these exciting models. You'll also implement your own GAN on the MNIST dataset.
- Lesson 02: Deep Convolutional GANs
  In this lesson you'll implement a Deep Convolution GAN to generate complex color images of house numbers.
Module 02: Pix2Pix & CycleGAN
- Lesson 01: Pix2Pix & CycleGAN
  Jun-Yan Zhu, on of the creators of the CycleGAN, will lead you through Pix2Pix and CycleGAN formulations that learn to do image-to-image translation tasks!
- Lesson 02: Implementing a CycleGAN
  Cezanne will show you how to implement a CycleGAN in PyTorch and translate images from the summer to winter domains.
Module 03: Project: Generate Faces
- Lesson 01: Project: Generate Faces
  Define two adversarial networks, a generator and discriminator, and train them until you can generate realistic faces.
  
  Project Description - Generate Faces
  
  Project Rubric - Generate Faces

Part 16 : Deploying a Model

Train and deploy your own sentiment analysis model using Amazon's SageMaker. Deployment gives you the ability to use a trained model to analyze new, user input. Build a model, deploy it, and create a gateway for accessing it from a website.

Module 01: Deployment
- Lesson 01: Introduction to Deployment
  This lesson will familiarizing the student with cloud and deployment terminology along with demonstrating how deployment fits within the machine learning workflow.
- Lesson 02: Building a Model using SageMaker
  Learn how to use Amazon’s SageMaker service to predict Boston housing prices using SageMaker’s built-in XGBoost algorithm.
- Lesson 03: Deploying and Using a Model
  In this lesson students will learn how to deploy a model using SageMaker and how to make use of their deployed model with a simple web application.
- Lesson 04: Hyperparameter Tuning
  In this lesson students will see how to use SageMaker’s automatic hyperparameter tuning tools on the Boston housing prices model from lesson 2 and with a sentiment analysis model.
- Lesson 05: Updating a Model
  In this lesson students will learn how to update their model to account for changes in the underlying data used to train their model.
Module 02: Project: Deploying a Sentiment Analysis Model
- Lesson 01: Project: Deploying a Sentiment Analysis Model
  In this project, you will build and deploy a neural network which predicts the sentiment of a user-provided movie review. In addition, you will create a simple web app that uses your deployed model.
  
  Project Description - Deploying a Sentiment Analysis Model
  
  Project Rubric - Deploying a Sentiment Analysis Model

Part 17 : Machine Learning, Case Studies

Welcome to learn the Machine Learning, Case Studies.

Lesson 01: Population Segmentation
Train and deploy unsupervised models (PCA and k-means clustering) to group US counties by similarities and differences. Visualize the trained model attributes and interpret the results.
Lesson 02: Payment Fraud Detection
Train a linear model to do credit card fraud detection. Improve the model by accounting for class imbalance in the training data and tuning for a specific performance metric.
Lesson 03: Interview Segment: SageMaker as a Tool & the Future of ML
If you're interested in how SageMaker has developed to serve businesses and learners, take a look at this short interview segment with Dan Mbanga.
Lesson 04: Deploying Custom Models
Design and train a custom PyTorch classifier by writing a training script. This is an especially useful skill for tasks that cannot be easily solved by built-in algorithms.
Lesson 05: Time-Series Forecasting
Learn how to format time series data into context (input) and prediction (output) data, and train the built-in algorithm, DeepAR; this uses an RNN to find recurring patterns in time series data.
Lesson 06: Project
Project Description - Plagiarism Detector

Project Rubric - Plagiarism Detector

Part 18 : Software Engineering

Software engineering skills are increasingly important for data scientists. In this course, you'll learn best practices for writing software. Then you'll work on your software skills by coding a Python package and a web data dashboard.

Module 01: Software Engineering
- Lesson 01: Introduction to Software Engineering
  Welcome to Software Engineering for Data Scientists! Learn about the course and meet your instructors.
- Lesson 02: Software Engineering Practices Pt I
  Learn software engineering practices and how they apply in data science. Part one covers clean and modular code, code efficiency, refactoring, documentation, and version control.
- Lesson 03: Software Engineering Practices Pt II
  Learn software engineering practices and how they apply in data science. Part two covers testing code, logging, and conducting code reviews.
- Lesson 04: Introduction to Object-Oriented Programming
  Learn the basics of object-oriented programming so that you can build your own Python package.
- Lesson 05: Portfolio Exercise: Upload a Package to PyPi
  Create your own Python package and upload your package to PyPi.
- Lesson 06: Web Development
  Develop a data dashboard using Flask, Bootstrap, Plotly and Pandas.
- Lesson 07: Portfolio Exercise: Deploy a Data Dashboard
  Customize the data dashboard from the previous lesson to make it your own. Upload the dashboard to the web.

Part 19 : Data Engineering

In data engineering for data scientists, you will practice building ETL, NLP, and machine learning pipelines.

Module 01: Data Engineering
- Lesson 01: Introduction to Data Engineering
  You will get an introduction to the data engineering for data scientists course and project. The lessons include ETL pipelines, natural language pipelines, and machine learning pipelines.
- Lesson 02: ETL Pipelines
  ETL stands for extract, transform, and load. This is the most common type of data pipeline, and you will practice each step in this lesson.
- Lesson 03: NLP Pipelines
  In order to complete the project at the end of the course, you will need some natural language processing skills. Here you will practice engineering machine learning features from text data.
- Lesson 04: Machine Learning Pipelines
  You'll use the Scikit-Learn package to code a machine learning pipeline. With these skills, you can ingest data, create features, and train a machine learning algorithm in just one step.
Module 02: Project
- Lesson 01: Project: Disaster Response Pipeline
  You’ll build a machine learning pipeline to categorize emergency messages based on the needs communicated by the sender.
  
  Project Description - Disaster Response Pipelines
  
  Project Rubric - Disaster Response Pipelines
Module 03: Career Support
- Lesson 01: 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.
  
  Project Description - Improve Your LinkedIn Profile
  
  Project Rubric - Improve Your LinkedIn Profile

Part 20 : Experimental Design & Recommendations

Learn to design experiments and analyze A/B test results. Explore approaches for building recommendation systems.

Module 01: Intro to Experiment Design and Recommendation Engines
- Lesson 01: Intro to Experiment Design and Recommendation Engines
  Why do we care about experiment design and recommendation engines? In this lesson, you'll get an overview of the topics you'll learn in this course.
Module 02: Experiment Design & A/B Testing
- Lesson 01: Concepts in Experiment Design
  In this lesson, you will learn about conceptual topics that must be considered when designing and running an experiment, in order to ensure good, interpretable results.
- Lesson 02: Statistical Considerations in Testing
  In this lesson, you will learn how statistics can be used to benefit the design of an experiment, as well as additional statistical tests that can be used to analyze results.
- Lesson 03: A/B Testing Case Study
  In this lesson, you will go through an A/B Testing case study to see how the conceptual and statistical concepts covered in the previous lessons can be applied in experiment designs.
- Lesson 04: Portfolio Exercise: Starbucks
  In this lesson, you will analyze data that was originally used in screening interviews for data scientists at Starbucks.
Module 03: Recommendation Engines
- Lesson 01: Introduction to Recommendation Engines
  In this lesson, you will learn about the different methods used to create recommendation engines.
- Lesson 02: Matrix Factorization for Recommendations
  In this lesson, you will learn how machine learning is being used to make recommendations.
Module 04: Project: Recommendations with IBM
- Lesson 01: Recommendation Engines
  Put your skills to work to make recommendations for IBM Watson Studio's data platform.
  
  Project Description - Recommendations with IBM
  
  Project Rubric - Recommendations with IBM

Part 21 : Data Modeling

Learn to create relational and NoSQL data models to fit the diverse needs of data consumers. Use ETL to build databases in PostgreSQL and Apache Cassandra.

Module 01: Data Modeling
- Lesson 01: Introduction to Data Modeling
  In this lesson, students will learn the basic difference between relational and non-relational databases, and how each type of database fits the diverse needs of data consumers.
- Lesson 02: Relational Data Models
  In this lesson, students understand the purpose of data modeling, the strengths and weaknesses of relational databases, and create schemas and tables in Postgres
- Lesson 03: Project: Data Modeling with Postgres
  Students will model user activity data to create a database and ETL pipeline in Postgres for a music streaming app. They will define Fact and Dimension tables and insert data into new tables.
  
  Project Description - Data Modeling with Postgres
  
  Project Rubric - Data Modeling with Postgres
- Lesson 04: NoSQL Data Models
  Students will understand when to use non-relational databases based on the data business needs, their strengths and weaknesses, and how to creates tables in Apache Cassandra.
- Lesson 05: Project: Data Modeling with Apache Cassandra
  Students will model event data to create a non-relational database and ETL pipeline for a music streaming app. They will define queries and tables for a database built using Apache Cassandra.
  
  Project Description - Data Modeling with Apache Cassandra
  
  Project Rubric - Data Modeling with Apache Cassandra

Part 22 : Cloud Data Warehouses

Welcome to learn the Cloud Data Warehouses.

Module 01: Cloud Data Warehouses

Part 23 : Data Lakes with Spark

Welcome to learn the Data Lakes with Spark.

Module 01: Data Lakes with Spark
- Lesson 01: The Power of Spark
  In this lesson, you will learn about the problems that Apache Spark is designed to solve. You'll also learn about the greater Big Data ecosystem and how Spark fits into it.
- Lesson 02: Data Wrangling with Spark
  In this lesson, we'll dive into how to use Spark for cleaning and aggregating data.
- Lesson 03: Setting up Spark Clusters with AWS
  In this lesson, you will learn to run Spark on a distributed cluster in AWS UI and AWS CLI.
- Lesson 04: Debugging and Optimization
  In this lesson, you will learn best practices for debugging and optimizing your Spark applications.
- Lesson 05: Introduction to Data Lakes
  In this lesson, you'll learn to need for a data lake, how it's different from a data warehouse, and various options to implement it on AWS
- Lesson 06: Project: Data Lake
  Students will build a data lake and an ETL pipeline in Spark that loads data from S3, processes the data into analytics tables, and loads them back into S3.
  
  Project Description - Data Lake
  
  Project Rubric - Data Lake
- Lesson 07: 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.
  
  Project Description - Optimize Your GitHub Profile
  
  Project Rubric - Optimize Your GitHub Profile

Part 24 : Data Pipelines with Airflow

Welcome to learn the Data Pipelines with Airflow.

Module 01: Data Pipelines with Airflow
- Lesson 01: Data Pipelines
  Students will get an introduction to data pipelines, Apache Airflow as a data pipeline solution, how Airflow works, how to configure and scheduling data pipelines with Airflow and debug a pipeline job
- Lesson 02: Data Quality
  Students will learn how to track data lineage and set up data pipeline schedules, partition data to optimize pipelines, investigating Data Quality issues, and write tests to ensure data quality.
- Lesson 03: Production Data Pipelines
  In this last lesson, students will learn how to build Pipelines with maintainability and reusability in mind. They will also learn about pipeline monitoring.
- Lesson 04: Project: Data Pipelines
  Students continue to work on the music streaming company’s data infrastructure by creating and automating a set of data pipelines with Airflow, monitoring and debugging production pipelines
  
  Project Description - Data Pipelines
  
  Project Rubric - Data Pipelines

Part 25 : C++ Programming

Welcome to learn the beauty of C++ Programming.

Module 01: C++ Programming
- Lesson 01: C++ Getting Started
  The differences between C++ and Python and how to write C++ code.
- 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.
- 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.
- Lesson 05: Python and C++ Speed
  In this lesson, we'll compare the execution times of C++ and Python programs.
- Lesson 06: 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.
- Lesson 07: 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.
- Lesson 08: 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 26 : Computer Vision

Welcome to learn the beauty of Computer Vision.

Lesson 01: Welcome to Computer Vision
Welcome to the Computer Vision Nanodegree program!
Lesson 04: Image Representation & Classification
Learn how images are represented numerically and implement image processing techniques, such as color masking and binary classification.
Lesson 05: Convolutional Filters and Edge Detection
Learn about frequency in images and implement your own image filters for detecting edges and shapes in an image. Use a computer vision library to perform face detection.
Lesson 06: Types of Features & Image Segmentation
Program a corner detector and learn techniques, like k-means clustering, for segmenting an image into unique parts.
Lesson 07: Feature Vectors
Learn how to describe objects and images using feature vectors.
Lesson 08: CNN Layers and Feature Visualization
Define and train your own convolution neural network for clothing recognition. Use feature visualization techniques to see what a network has learned.
Lesson 09: Project: Facial Keypoint Detection
Apply your knowledge of image processing and deep learning to create a CNN for facial keypoint (eyes, mouth, nose, etc.) detection.

Project Description - Facial Keypoint Detection

Project Rubric - Facial Keypoint Detection

Part 27 : Cloud Computing

Learn how to build and train your data in Cloud Computing

Module 01: Optional: Cloud Computing
- Lesson 01: Cloud Computing with Google Cloud
  Learn how to leverage GPUs on Google Cloud for machine learning and scientific computing.

Part 28 : Advanced Computer Vision & Deep Learning

Learn the Advanced Computer Vision & Deep Learning.

Module 01: Advanced Computer Vision & Deep Learning
- Lesson 01: Advanced CNN Architectures
  Learn about advances in CNN architectures and see how region-based CNN’s, like Faster R-CNN, have allowed for fast, localized object recognition in images.
- Lesson 02: YOLO
  Learn about the YOLO (You Only Look Once) multi-object detection model and work with a YOLO implementation.
- Lesson 03: RNN's
  Explore how memory can be incorporated into a deep learning model using recurrent neural networks (RNNs). Learn how RNNs can learn from and generate ordered sequences of data.
- Lesson 04: Long Short-Term Memory Networks (LSTMs)
  Luis explains Long Short-Term Memory Networks (LSTM), and similar architectures which have the benefits of preserving long term memory.
- Lesson 05: Hyperparameters
  Learn about a number of different hyperparameters that are used in defining and training deep learning models. We'll discuss starting values and intuitions for tuning each hyperparameter.
- Lesson 06: Optional: Attention Mechanisms
  Attention is one of the most important recent innovations in deep learning. In this section, you'll learn how attention models work and go over a basic code implementation.
- Lesson 07: Image Captioning
  Learn how to combine CNNs and RNNs to build a complex, automatic image captioning model.
- Lesson 08: Project: Image Captioning
  Train a CNN-RNN model to predict captions for a given image. Your main task will be to implement an effective RNN decoder for a CNN encoder.
  
  Project Description - Image Captioning
  
  Project Rubric - Image Captioning
- Lesson 09: 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.
  
  Project Description - Improve Your LinkedIn Profile
  
  Project Rubric - Improve Your LinkedIn Profile

Part 29 : Object Tracking and Localization

Welcome to Object Tracking and Localization.

Module 01: Object Tracking and Localization
- Lesson 01: Introduction to Motion
  This lesson introduces a way to represent motion mathematically, outlines what you'll learn in this section, and introduces optical flow.
- Lesson 02: Robot Localization
  Learn to implement a Bayesian filter to locate a robot in space and represent uncertainty in robot motion.
- Lesson 03: Mini-project: 2D Histogram Filter
  Write sense and move functions (and debug) a 2D histogram filter!
- Lesson 04: Introduction to Kalman Filters
  Learn the intuition behind the Kalman Filter, a vehicle tracking algorithm, and implement a one-dimensional tracker of your own.
- Lesson 05: Representing State and Motion
  Learn about representing the state of a car in a vector that can be modified using linear algebra.
- Lesson 06: 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.
- Lesson 07: Simultaneous Localization and Mapping
  Learn how to implement SLAM: simultaneously localize an autonomous vehicle and create a map of landmarks in an environment.
- Lesson 08: Optional: Vehicle Motion and Calculus
  Review the basics of calculus and see how to derive the x and y components of a self-driving car's motion from sensor measurements and other data.
- Lesson 09: Project: Landmark Detection & Tracking (SLAM)
  Implement SLAM, a robust method for tracking an object over time and mapping out its surrounding environment, using elements of probability, motion models, and linear algebra.
  
  Project Description - Landmark Detection & Tracking (SLAM)
  
  Project Rubric - Landmark Detection & Tracking (SLAM)
  - Concept 01: Project Overview
  - Concept 02: Project: Landmark Detection & Tracking (SLAM)

Part 30 : Natural Language Processing

This section provides an overview of the program and introduces the fundamentals of Natural Language Processing through symbolic manipulation, including text cleaning, normalization, and tokenization. You'll then build a part of speech tagger using hidden Markov models.

Module 01: Introduction to Natural Language Processing
- Lesson 01: Welcome to Natural Language Processing
  Welcome to the Natural Language Processing Nanodegree program!
  - Concept 01: Welcome to the Natural Language Processing Nanodegree
  - Concept 02: Community Guidelines
- Lesson 04: Intro to NLP
  Arpan will give you an overview of how to build a Natural Language Processing pipeline.
- Lesson 05: Text Processing
  Learn to prepare text obtained from different sources for further processing, by cleaning, normalizing and splitting it into individual words or tokens.
- Lesson 06: Spam Classifier with Naive Bayes
  In this section, you'll learn how to build a spam e-mail classifier using the naive Bayes algorithm.
- Lesson 07: Part of Speech Tagging with HMMs
  Luis will give you an overview of several part-of-speech tagging, including a deeper dive on hidden Markov models.
- Lesson 08: Project: Part of Speech Tagging
  In this project, you'll build a hidden Markov model for part of speech tagging with a universal tagset.
  
  Project Description - Part of Speech Tagging
  
  Project Rubric - Part of Speech Tagging

Part 31 : Computing with Natural Language

Learn how to Computing with Natural Language.

Module 01: Computing with Natural Language
- Lesson 01: Feature extraction and embeddings
  Transform text using methods like Bag-of-Words, TF-IDF, Word2Vec and GloVE to extract features that you can use in machine learning models.
- Lesson 02: Topic Modeling
  In this section, you'll learn to split a collection of documents into topics using Latent Dirichlet Analysis (LDA). In the lab, you'll be able to apply this model to a dataset of news articles.
- Lesson 03: Sentiment Analysis
  Learn about using several machine learning classifiers, including Recurrent Neural Networks, to predict the sentiment in text. Apply this to a dataset of movie reviews.
- Lesson 04: Sequence to Sequence
  Here you'll learn about a specific architecture of RNNs for generating one sequence from another sequence. These RNNs are useful for chatbots, machine translation, and more!
- Lesson 05: Deep Learning Attention
  Attention is one of the most important recent innovations in deep learning. In this section, you'll learn attention, and you'll go over a basic implementation of it in the lab.
- Lesson 06: RNN Keras Lab
  This section will prepare you for the Machine Translation project. Here you will get hands-on practice with RNNs in Keras.
- Lesson 07: Project: Machine Translation
  Apply the skills you've learnt in Natural Language Processing to the challenging and extremely rewarding task of Machine Translation. Bonne chance!
  
  Project Description - Project: Machine Translation
  
  Project Rubric - Project: Machine Translation

Part 32 : Communicating with Natural Language

Learn how to Communicating with Natural Language.

Module 01: Communicating with Natural Language
- Lesson 01: Intro to Voice User Interfaces
  Get acquainted with the principles and applications of VUI, and get introduced to Alexa skills.
- Lesson 02: (Optional) Alexa History Skill
  Build your own Alexa skill and deploy it!
- Lesson 03: Speech Recognition
  Learn how an ASR pipeline works.
- Lesson 04: Project: DNN Speech Recognizer
  Build a deep neural network that functions as part of an end-to-end automatic speech recognition pipeline.
  
  Project Description - Project: DNN Speech Recognizer
  
  Project Rubric - Project: DNN Speech Recognizer

Part 33 : Introduction to Deep Reinforcement Learning

Welcome to Learn the beauty of Deep Reinforcement Learning.

Module 01: Introduction to Deep Reinforcement Learning
- Lesson 05: Introduction to RL
  Reinforcement learning is a type of machine learning where the machine or software agent learns how to maximize its performance at a task.
- Lesson 06: The RL Framework: The Problem
  Learn how to mathematically formulate tasks as Markov Decision Processes.
- Lesson 07: The RL Framework: The Solution
  In reinforcement learning, agents learn to prioritize different decisions based on the rewards and punishments associated with different outcomes.
- Lesson 08: Monte Carlo Methods
  Write your own implementation of Monte Carlo control to teach an agent to play Blackjack!
- Lesson 09: Temporal-Difference Methods
  Learn about how to apply temporal-difference methods such as SARSA, Q-Learning, and Expected SARSA to solve both episodic and continuing tasks.
- Lesson 10: Solve OpenAI Gym's Taxi-v2 Task
  With reinforcement learning now in your toolbox, you're ready to explore a mini project using OpenAI Gym!
- Lesson 11: RL in Continuous Spaces
  Learn how to adapt traditional algorithms to work with continuous spaces.

Part 34 : Value-Based Methods

Learn how Value-Based Methods works.

Module 01: Value-Based Methods
- Lesson 01: Study Plan
  Obtain helpful resources to accelerate your learning in the second part of the Nanodegree program.
  - Concept 01: Study Plan
  - Concept 02: Deep RL for Robotics
- Lesson 02: Deep Q-Networks
  Extend value-based reinforcement learning methods to complex problems using deep neural networks.
- Lesson 03: Navigation
  Train an agent to navigate a large world and collect yellow bananas, while avoiding blue bananas.
  
  Project Description - Navigation
  
  Project Rubric - Navigation
- Lesson 04: Opportunities in Deep Reinforcement Learning
  Learn about common career opportunities in deep reinforcement learning, and get tips on how to stay active in the community.

Part 35 : Policy-Based Methods

Learn how Policy-Based Methods works.

Module 01: Policy-Based Methods
- Lesson 01: Study Plan
  Obtain helpful resources to accelerate your learning in the third part of the Nanodegree program.
  - Concept 01: Study Plan
- Lesson 02: Introduction to Policy-Based Methods
  Policy-based methods try to directly optimize for the optimal policy.
- Lesson 03: Policy Gradient Methods
  Policy gradient methods search for the optimal policy through gradient ascent.
- Lesson 04: Proximal Policy Optimization
  Learn what Proximal Policy Optimization (PPO) is and how it can improve policy gradients. Also learn how to implement the algorithm by training a computer to play the Atari Pong game.
- Lesson 05: Actor-Critic Methods
  Miguel Morales explains how to combine value-based and policy-based methods, bringing together the best of both worlds, to solve challenging reinforcement learning problems.
- Lesson 06: Deep RL for Finance (Optional)
  Learn how to apply deep reinforcement learning techniques for optimal execution of portfolio transactions.
- Lesson 07: Continuous Control
  Train a double-jointed arm to reach target locations.
  
  Project Description - Continuous Control
  
  Project Rubric - Continuous Control

Part 36 : Introduction to Artificial Intelligence

Welcome to the Introduction to Artificial Intelligence.

Module 01: Introduction to Artificial Intelligence
- Lesson 04: Intro to Artificial Intelligence
  An introduction to basic AI concepts and the challenge of answering "what is AI?"
- Lesson 05: Solving Sudoku With AI
  In this lesson, you'll dive right in and apply Artificial Intelligence to solve every Sudoku puzzle.
- Lesson 08: Build a Sudoku Solver
  Use constraint propagation and search to build an agent that reasons like a human would to efficiently solve any Sudoku puzzle.
  
  Project Description - Build a Sudoku Solver
  
  Project Rubric - Build a Sudoku Solver
  - Concept 01: Project Intro
  - Concept 02: Project Workspace
- Lesson 09: Jobs in AI
  Learn about common jobs in artificial intelligence, and get tips on how to stay active in the community.
  - Concept 01: Jobs in AI

Part 37 : Constraint Satisfaction Problems

Take a deep dive into the constraint satisfaction problem framework and further explore constraint propagation, backtracking search, and other CSP techniques. Complete a classroom exercise using a powerful CSP solver on a variety of problems to gain experience framing new problems as CSPs.

Module 01: Constraint Satisfaction Problems
- Lesson 01: Constraint Satisfaction Problems
  Expand from the constraint propagation technique used in the Sudoku project to the Constraint Satisfaction Problem framework that can be used to solve a wide range of general problems.
- Lesson 02: CSP Coding Exercise
  Practice formulating some classical example problems as CSPs, and then to explore using a powerful open source constraint satisfaction tool called Z3 from Microsoft Research to solve them.
- Lesson 03: Additional Readings
  Reading list of applications and additional topics related to CSPs.
  - Concept 01: Reading List

Part 38 : Classical Search

Learn classical graph search algorithms--including uninformed search techniques like breadth-first and depth-first search and informed search with heuristics including A*. These algorithms are at the heart of many classical AI techniques, and have been used for planning, optimization, problem solving, and more. Complete the lesson by teaching PacMan to search with these techniques to solve increasingly complex domains.

Module 01: Classical Search
- Lesson 01: Introduction
  Peter Norvig, co-author of Artificial Intelligence: A Modern Approach, explains a framework for search problems, and introduces uninformed & informed search strategies to solve them.
- Lesson 02: Uninformed Search
  Peter introduces uninformed search strategies—which can only solve problems by generating successor states and distinguishing between goal and non-goal states.
- Lesson 03: Informed Search
  Peter introduces informed search strategies, which means that they use problem-specific knowledge to find solutions more efficiently than an uninformed search.
- Lesson 04: Classroom Exercise: Search
  Complete a practice exercise where you'll implement informed and uninformed search strategies for the game PacMan.
- Lesson 05: Additional Search Topics
  References to additional readings on search.

Part 39 : Automated Planning

Learn to represent general problem domains with symbolic logic and use search to find optimal plans for achieving your agent’s goals. Planning & scheduling systems power modern automation & logistics operations, and aerospace applications like the Hubble telescope & NASA Mars rovers.

Module 01: Automated Planning
- Lesson 01: Symbolic Logic & Reasoning
  Peter Norvig returns to explain propositional logic and first-order logic, which provide a symbolic logic framework that enables AI agents to reason about their actions.
- Lesson 02: Introduction to Planning
  Peter Norvig defines automated planning problems in comparison to more general problem solving techniques to set the stage for classical planning algorithms in the next lesson.
- Lesson 03: Classical Planning
  Peter presents a survey of Classical Planning techniques: forward planning (progression search) & backward planning (regression search).
- Lesson 04: Build a Forward-Planning Agent
  In this project you’ll use experiment with search and symbolic logic to build an agent that automatically develops and executes plans to achieve their goals.
  
  Project Description - Build a Forward-Planning Agent
  
  Project Rubric - Build a Forward-Planning Agent
  - Concept 01: Project Intro
  - Concept 02: Workspace
- Lesson 05: Additional Planning Topics
  Peter discusses plan space search & situational calculus. Finish the lesson with readings on advanced planning topics & modern applications of automated planning.

Part 40 : Optimization Problems

Learn about iterative improvement optimization problems and classical algorithms emphasizing gradient-free methods for solving them. These techniques can often be used on intractable problems to find solutions that are "good enough" for practical purposes, and have been used extensively in fields like Operations Research & logistics. Finish the lesson by completing a classroom exercise comparing the different algorithms' performance on a variety of problems.

Module 01: Optimization Problems
- Lesson 01: Introduction
  Thad Starner introduces the concept of iterative improvement problems, a class of optimization problems that can be solved with global optimization or local search techniques covered in this lesson.
- Lesson 02: Hill Climbing
  Thad introduces Hill Climbing, a very simple local search optimization technique that works well on many iterative improvement problems.
- Lesson 03: Simulated Annealing
  Thad explains Simulated Annealing, a classical global optimization technique for optimization.
- Lesson 04: Genetic Algorithms
  Thad introduces another optimization technique: Genetic Algorithms, which uses a population of samples to make iterative improvements towards the goal.
- Lesson 05: Optimization Exercise
  Complete a classroom exercise implementing simulated annealing to solve the traveling salesman problem.
  - Concept 01: Local Search Exercise
  - Concept 02: Coding Exercise: Local Search
- Lesson 06: Additional Optimization Topics
  Review similarities of the techniques introduced in this lesson with links to readings on advanced optimization topics, then complete an optimization exercise in the classroom.
  - Concept 01: Similarities Between Optimizers
  - Concept 02: Reading List

Part 41 : Adversarial Search -

Learn how to search in multi-agent environments (including decision making in competitive environments) using the minimax theorem from game theory. Then build an agent that can play games better than any human.

Module 01: Adversarial Search
- Lesson 01: Search in Multiagent Domains
  Thad returns to teach search in multi-agent domains, using the Minimax theorem to solve adversarial problems and build agents that make better decisions than humans.
- Lesson 02: Optimizing Minimax Search
  Thad explains some of the limitations of minimax search and introduces optimizations & changes that make it practical in more complex domains.
- Lesson 03: Build an Adversarial Game Playing Agent
  Extend classical search to adversarial domains, to build agents that make good decisions without any human intervention—such as the DeepMind AlphaGo agent.
  
  Project Description - Build an Adversarial Game Playing Agent
  
  Project Rubric - Build an Adversarial Game Playing Agent
  - Concept 01: Project Introduction
  - Concept 02: Workspace
- Lesson 04: Extending Minimax Search
  Thad introduces extensions to minimax search to support more than two players and non-deterministic domains.
- Lesson 05: Additional Adversarial Search Topics
  Introduce Monte Carlo Tree Search, a highly-successful search technique in game domains, along with a reading list for other advanced adversarial search topics.

Part 42 : Probabilistic Models

Learn to use Bayes Nets to represent complex probability distributions, and algorithms for sampling from those distributions. Then learn the algorithms used to train, predict, and evaluate Hidden Markov Models for pattern recognition. HMMs have been used for gesture recognition in computer vision, gene sequence identification in bioinformatics, speech generation & part of speech tagging in natural language processing, and more.

Module 01: Probabilistic Models
- Lesson 01: Probability
  Sebastian Thrun briefly reviews basic probability theory including discrete distributions, independence, joint probabilities, and conditional distributions to model uncertainty in the real world.
- Lesson 02: Naive Bayes
  In this section, you'll learn how to build a spam e-mail classifier using the naive Bayes algorithm.
- Lesson 03: Bayes Nets
  Sebastian explains using Bayes Nets as a compact graphical model to encode probability distributions for efficient analysis.
- Lesson 04: Inference in Bayes Nets
  Sebastian explains probabilistic inference using Bayes Nets, i.e. how to use evidence to calculate probabilities from the network.
- Lesson 05: Hidden Markov Models
  Learn Hidden Markov Models, and apply them to part-of-speech tagging, a very popular problem in Natural Language Processing.
- Lesson 06: Part of Speech Tagging
  In this project you will build a hidden Markov model (HMM) to perform part of speech tagging, a common pre-processing step in Natural Language Processing.
  
  Project Description - Part of Speech Tagging
  
  Project Rubric - Part of Speech Tagging
  - Concept 01: Introduction
  - Concept 02: Workspace: Part of Speech Tagging
- Lesson 07: Dynamic Time Warping
  Thad explains the Dynamic Time Warping technique for working with time-series data.

Part 43 : Intro to Self-Driving Cars

Welcome to Learn How Self-Driving Cars works.

Module 01: Introduction to Self-Driving Cars

Lesson 04: Introduction to Self-Driving Cars - 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!

Part 44 : 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.
  - Concept 01: The Wonderland of Bayes' Law
  - Concept 02: Course Overview
- 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.
  
  Project Description - Joy Ride
  
  Project Rubric - Joy Ride
- 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.
- 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).
- 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.
- 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.
- 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.
- Lesson 08: Probability Distributions
  Learn how a robot represents it's belief about uncertain quantities using something known as a probability distribution.
- Lesson 09: Programming Probability Distributions
  Apply what you've learned in this course by programming and visualizing probability distributions.
- 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.
- Lesson 11: Robot Localization
  Sebastian Thrun will give you an overview of the theory behind localization!
- Lesson 12: Histogram Filter in Python
  Write the sense and move functions for a 2 dimensional histogram filter in Python.

Part 45 : 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.
  - Concept 01: Introduction to Matrices
  - Concept 02: Course Overview
- 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.
- 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!
- 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.
- Lesson 05: Implement Matrix Class
  Practice using your object oriented programming and matrix math skills by filling out the methods in a partially-completed Matrix class.
  
  Project Description - Implement a Matrix Class
  
  Project Rubric - Implement a Matrix Class

Part 46 : 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.
- 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.
- 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.
- 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++.
  
  Project Description - Translate Python to C++
  
  Project Rubric - Translate Python to C++

Part 47 : 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.
- 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.
- 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 48 : 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.
- 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.
- 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.
- Lesson 04: Implement Route Planner
  In this lesson you will actually implement a Google-maps style routing algorithm using A star search.
  
  Project Description - Implement Route Planner
  
  Project Rubric - Implement Route Planner

Part 49 : 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.
- Lesson 02: Accelerometers, Rate Gyros and Integrals
  Learn how integrals can be used to calculate accumulated changes by finding the area under a curve.
- 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.
- 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.
  - Concept 01: Project Overview
  - Concept 02: Lab - Reconstructing Trajectories

Part 50 : Computer Vision, Deep Learning, and Sensor Fusion

Here, you'll first 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, along with working with lidar and radar data later on.

Module 01: Computer Vision, Deep Learning, and Sensor Fusion
- Lesson 04: Computer Vision Fundamentals
  Get a taste of some basic computer vision techniques to find lane markings on the road.
- Lesson 05: Project: Finding Lane Lines
  Write code to identify lane lines on the road, first in an image, and later in a video stream.
  
  Project Description - Finding Lane Lines
  
  Project Rubric - Finding Lane Lines
- Lesson 06: Camera Calibration
  Learn how to calibrate your camera to remove inherent distortions that can affect its perception of the world.
- Lesson 07: Gradients and Color Spaces
  Learn how to use gradient thresholds and different color spaces to more easily identify lane markings on the road.
- Lesson 08: Advanced Computer Vision
  Discover more advanced computer vision techniques to improve upon your lane lines algorithm!
- Lesson 09: Project: Advanced Lane Finding
  Write a software pipeline to identify the lane boundaries in a video from a front-facing camera on a car.
  
  Project Description - Advanced Lane Finding
  
  Project Rubric - Advanced Lane Finding
- Lesson 10: Neural Networks
  Build and train neural networks from linear and logistic regression to backpropagation and multilayer perceptron networks.
- Lesson 11: TensorFlow
  The Principal Scientist at Google Brain introduces you to deep learning and Tensorflow, Google's deep learning framework.
- Lesson 12: Deep Neural Networks
  Learn how to go from a simple neural network to a deep neural network.
- Lesson 13: Convolutional Neural Networks
  Learn the theory behind Convolutional Neural Networks and how they help us dramatically improve performance in image classification.
- Lesson 14: LeNet for Traffic Signs
  Using the infamous LeNet neural network architecture, take your first steps toward building a Traffic Sign classifier!
- Lesson 15: Project: Traffic Sign Classifier
  Put your skills to the test by using deep learning to classify different traffic signs!
  
  Project Description - Traffic Sign Classifier
  
  Project Rubric - Traffic Sign Classifier
- Lesson 16: Keras
  Take on the neural network framework, Keras! Build and train neural networks more easily.
- Lesson 17: Transfer Learning
  Learn about some of the most famous neural network architectures, and how you can use them to create new models by leveraging existing canonical networks.
- Lesson 18: Project: Behavioral Cloning
  Train a deep neural network to drive a car like you!
  
  Project Description - Behavioral Cloning
  
  Project Rubric - Behavioral Cloning
- Lesson 20: Sensors
  Meet the team at Mercedes who will help you track objects in real-time with Sensor Fusion.
- Lesson 21: Kalman Filters
  Sebastian Thrun will walk you through the usage and concepts of a Kalman Filter using Python.
- Lesson 22: C++ Checkpoint
  Are you ready to build Kalman Filters with C++? Take these quizzes to find out!
- Lesson 23: Geometry and Trigonometry Refresher
  This optional content is designed to refresh knowledge of trigonometry and geometry in support of Term 1 objectives.
- Lesson 24: Extended Kalman Filters
  Build a Kalman Filter in C++ that's capable of handling data from multiple sources.
- Lesson 25: Extended Kalman Filters Project
  Apply everything you've learned about Sensor Fusion by implementing an Extended Kalman Filter in C++!
  
  Project Description - Extended Kalman Filters
  
  Project Rubric - Extended Kalman Filters

Part 51 : Localization, Path Planning, Control, and System Integration

Here, you'll expand on your sensor knowledge to localize and control the vehicle. You'll evaluate sensor data from camera, radar, lidar, and GPS, and use these in closed-loop controllers that actuate the vehicle, finishing by combining all your skills on a real self-driving car!.

Module 01: Localization, Path Planning, Control, and System Integration

Part 52 : Unscented Kalman Filters, Model Predictive Control, Advanced Deep Learning / Semantic Segmentation, and Functional Safety here

Here you'll Learn few topics like Unscented Kalman Filters, Model Predictive Control, Advanced Deep Learning / Semantic Segmentation, and Functional Safety here.

Module 01: Additional Content
- Lesson 01: 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.
- Lesson 02: 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 non-linear motion!
- 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.
- 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!
- Lesson 05: Fully Convolutional Networks
  In this lesson you'll learn the motivation for Fully Convolutional Networks and how they are structured.
- Lesson 06: Scene Understanding
  In this lesson you'll be introduced to the problem of Scene Understanding and the role FCNs play.
- Lesson 07: Inference Performance
  In this lesson you'll become familiar with various optimizations in an effort to squeeze every last bit of performance at inference.

Part 53 : Functional Safety

learn to make safer vehicles using risk evaluation and systems engineering.

Module 01: Additional Content
- Lesson 08: Introduction to Functional Safety
  You will learn to make safer vehicles using risk evaluation and systems engineering.
- Lesson 09: 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 10: 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.
- Lesson 11: 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.
- Lesson 12: 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.
- Lesson 13: 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.

Part 54 : Technical Interview Prep

Learn the skills technical interviewers expect you to know—efficiency, common algorithms, manipulating popular data structures, and how to explain a solution.

Module 01: Technical Interview Prep

Lesson 01: Introduction and Efficiency
Begin the section on data structures and algorithms, including Python and efficiency practice.
Lesson 02: List-Based Collections
Learn the definition of a list in computer science, and see definitions and examples of list-based data structures, arrays, linked lists, stacks, and queues.
Lesson 03: Searching and Sorting
Explore how to search and sort with list-based data structures, including binary search and bubble, merge, and quick sort. Learn how to use recursion.
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 self-balancing trees.
Lesson 06: Graphs
Examine the theoretical concept of a graph and understand common graph terms, coded representations, properties, traversals, and paths.
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.
Lesson 09: Practice Behavioral Questions
Practice answering behavioral questions and evaluate sample responses.

Part 55 : Introduction to Autonomous Flight

In this course, you will get an introduction to flight history, challenges, and vehicles. You will learn about our quadrotor test platform, work in our custom simulator, and build your first project—getting a quadrotor to take-off and fly around a backyard!.

Module 01: Introduction to Autonomous Flight
- Lesson 02: Autonomous Flight
  In this lesson you'll get a high level overview of the concepts underlying autonomous flight and the physical components from which flying vehicles are made.
- Lesson 03: Backyard Flyer
  In this lesson you'll write the "Hello, world!" of drone programming as you write event-driven code that causes a quadrotor to take off, fly in a square, and land.
  
  Project Description - Backyard Flyer
  
  Project Rubric - Backyard Flyer
- Lesson 04: Drone Integration
  Walkthrough the steps you need to take to get your code running on an actual drone! We'll show you the steps for the "Intel Aero", but a lot of what you'll learn applies to other drones as well.

Part 56 : Planning

Flying robots must traverse complex, dynamic environments. Wind, obstacles, unreliable sensor data, and other randomness all present significant challenges. In this course, you will learn the fundamentals of aerial path planning. You will begin with 2D problems, optimize your solutions using waypoints, and then scale your solutions to three dimensions. You will apply these skills in your second project—autonomously navigating your drone through a dense urban environment.

Module 01: Planning

Lesson 01: Planning as Search
Solving the planning problem really comes down performing search through a state space to find a path from a start state to a goal state and here you'll get a chance to do just that!
Lesson 02: Flying Car Representation
Your vehicle has a physical size and orientation in the world and here you'll learn how to think about position and orientation as part of your planning solution.
Lesson 03: From Grids to Graphs
Graphs are really just a way of describing how your search space is connected. Here you'll learn about the tradeoffs between grids and graphs and each can be used in your planning representation.
Lesson 04: Moving into 3D
Here you'll make the leap from two dimensions to three dimensions and discover how you can use different representations of your search space to optimize your planning solution.
Lesson 05: Real World Planning
In this lesson, you'll dive deep into some advanced concepts that are crucial to motion planning in the real world, where a consideration for physics and preparedness for the unexpected are crucial.
Lesson 06: Project: 3D Motion Planning
In this project, you'll get a chance to apply what you've learned about 3D motion planning from the last several lessons to plan and execute a mission in a complex urban environment!

Project Description - 3D Motion Planning

Project Rubric - 3D Motion Planning

Part 57 : Controls

In the previous course, we implemented 3D path planning but assumed a solution for actually following paths. In reality, moving a flying vehicle requires determining appropriate low-level motor controls. In this course, you will build a nonlinear cascaded controller and incorporate it into your software in the project.

Module 01: Controls

Lesson 01: Vehicle Dynamics
Learn how flying vehicles move in one and two dimensions by understanding how propellers create forces and moments which cause accelerations and rotations.
Lesson 02: Introduction to Vehicle Control
Learn how to control a drone moving in one dimension using Proportional Integral Derivative (PID) Control.
Lesson 03: Control Architecture
The controls problem becomes more difficult in two dimensions. Learn how to use a cascaded PID control architecture to control a flying vehicle that moves in two dimensions.
Lesson 04: Full 3D Control
In this lesson you'll take everything you've learned so far about vehicle dynamics and control and put it together to control a quadrotor that moves in three dimensions.
Lesson 05: Project: Building a Controller
In this project you'll implement a controller for a quadrotor in C++.

Project Description - Control of a 3D Quadrotor

Project Rubric - Control of a 3D Quadrotor
Lesson 06: Drone Integration
Walkthrough the steps you need to take to get a version of your controls project on a crazyflie!

Part 58 : Estimation

In this course, we will finish peeling back the layers of your autonomous flight solution. Instead of assuming perfect sensor readings, you will utilize sensor fusion and filtering. You will design an Extended Kalman Filter (EKF) to estimate attitude and position from IMU and GPS data of a flying robot.

Module 01: Estimation

Lesson 01: Introduction to Estimation
Review basic probability and learn three approaches to state estimation for a stationary vehicle.
Lesson 02: Introduction to Sensors
In this lesson you'll learn about the sensors a drone uses to localize itself in the world. You'll implement sensor models, analyze sources of error, and perform calibration of various sensors.
Lesson 03: Extended Kalman Filters
In this lesson you'll learn how to estimate the state of a drone that's actually moving! You'll implement a Kalman Filter for a 1D drone and an Extended Kalman Filter for a non-linear 2D drone.
Lesson 04: The 3D EKF and UKF
Take what you learned in the previous lesson and generalize to three dimensions. After learning about the 3D EKF you'll also learn another estimation algorithm called the Unscented Kalman Filter.
Lesson 05: Project: Estimation
In this project you'll implement an estimator to track the position and attitude of a quadrotor moving in three dimensions.

Project Description - Building an Estimator

Project Rubric - Building an Estimator
- Concept 01: Introduction
Lesson 06: GPS Denied Navigation
How do you estimate vehicle state when you don't have GPS? In this lesson you'll learn about optical flow and particle filters as two approaches to solving this problem.

Part 59 : Fixed Wing

While quadrotors are the ideal test platform for aerial robotics, flying cars and other long-range aircrafts leverage the aerodynamic efficiencies of fixed-wing flight. In this course, you will learn how to adapt the concepts you’ve learned so far and successfully fly a fixed-wing aircraft in simulation.

Module 01: Fixed Wing

Lesson 01: Introduction to Fixed-Wing Flight
This lesson provides a brief introduction to Fixed Wing Vehicles, flying cars, and the components of typical fixed-wing aircraft.
Lesson 02: Lift and Drag
Build mathematical models for lift and drag, the aerodynamic forces that make fixed wing flight possible (and difficult).
Lesson 03: Longitudinal Model
Analyze both non-linear and linear models of a fixed-wing aircraft's motion in the x-z plane and use linear algebra to identify two oscillatory "modes" of motion.
Lesson 04: Lateral-Directional Model
Understand the lateral-directional dynamics of fixed wing vehicles by looking at aircraft from above and behind.
Lesson 05: Fixed-Wing Autopilot
Apply the concepts of PID control by implementing an autopilot for fixed wing flight.
Lesson 06: Optional Project: Fixed-Wing Control
In this optional project you will control a simulated fixed-wing aircraft by implementing and tuning your own autopilot in Python.
- Concept 01: Fixed Wing Autopilot
- Concept 02: Hybrid VTOL