Nanodegree key: nd891
Version: 5.0.0
Locale: enus
Master the computer vision skills behind advances in robotics and automation. Write programs to analyze images, implement feature extraction, and recognize objects using deep learning models.
Content
Part 01 : Introduction to Computer Vision

Module 01:
Introduction to the Nanodegree

Lesson 01: Welcome to Computer Vision
Welcome to the Computer Vision Nanodegree program!
 Concept 01: Welcome to the Computer Vision Nanodegree Program
 Concept 02: Computer Vision in Industry
 Concept 03: Course Outline
 Concept 04: Projects and Topics
 Concept 05: Partnership with Industry
 Concept 06: Learning in the Classroom
 Concept 07: Community Guidelines
 Concept 08: Moving Forward!
 Concept 09: Access the Career Portal

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.

Lesson 03: Get Help with Your Account
What to do if you have questions about your account or general questions about the program.

Lesson 04: Image Representation & Classification
Learn how images are represented numerically and implement image processing techniques, such as color masking and binary classification.
 Concept 01: Intro to Pattern Recognition
 Concept 02: Emotional Intelligence
 Concept 03: Computer Vision Pipeline
 Concept 04: Training a Model
 Concept 05: Separating Data
 Concept 06: AffdexMe Demo
 Concept 07: Image Formation
 Concept 08: Images as Grids of Pixels
 Concept 09: Notebook: Images as Numerical Data
 Concept 10: Color Images
 Concept 11: Color or Grayscale?
 Concept 12: Notebook: Visualizing RGB Channels
 Concept 13: Color Thresholds
 Concept 14: Coding a Blue Screen
 Concept 15: Notebook: Blue Screen
 Concept 16: Notebook: Green Screen
 Concept 17: Color Spaces and Transforms
 Concept 18: Notebook: Color Conversion
 Concept 19: Day and Night Classification Challenge
 Concept 20: Notebook: Load and Visualize the Data
 Concept 21: Labeled Data and Accuracy
 Concept 22: Distinguishing Traits
 Concept 23: Features
 Concept 24: Standardizing Output
 Concept 25: Notebook: Standardizing Day and Night Images
 Concept 26: Average Brightness
 Concept 27: Notebook: Average Brightness Feature Extraction
 Concept 28: Classification
 Concept 29: Notebook: Classification
 Concept 30: Evaluation Metrics
 Concept 31: Notebook: Accuracy and Misclassification
 Concept 32: Review and the Computer Vision Pipeline

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.
 Concept 01: Filters and Finding Edges
 Concept 02: Frequency in Images
 Concept 03: Notebook: Fourier Transforms
 Concept 04: Quiz: Fourier Tranform Image
 Concept 05: Highpass Filters
 Concept 06: Quiz: Kernels
 Concept 07: Creating a Filter
 Concept 08: Gradients and Sobel Filters
 Concept 09: Notebook: Finding Edges
 Concept 10: Lowpass Filters
 Concept 11: Gaussian Blur
 Concept 12: Notebook: Gaussian Blur
 Concept 13: Notebook: Fourier Transforms of Filters
 Concept 14: Convolutional Layer
 Concept 15: Canny Edge Detector
 Concept 16: Notebook: Canny Edge Detection
 Concept 17: Shape Detection
 Concept 18: Hough Transform
 Concept 19: Quiz: Hough Space
 Concept 20: Hough Line Detection
 Concept 21: Notebook: Hough Detections
 Concept 22: Object Recognition & Introducing Haar Cascades
 Concept 23: Haar Cascades
 Concept 24: Notebook: Haar Cascade Face Detection
 Concept 25: Face Recognition and the Dangers of Bias
 Concept 26: Beyond Edges, Selecting Different Features

Lesson 06: Types of Features & Image Segmentation
Program a corner detector and learn techniques, like kmeans clustering, for segmenting an image into unique parts.
 Concept 01: Types of Features
 Concept 02: Corner Detectors
 Concept 03: Notebook: Find the Corners
 Concept 04: Dilation and Erosion
 Concept 05: Image Segmentation
 Concept 06: Image Contours
 Concept 07: Notebook: Find Contours and Features
 Concept 08: Solution: Find Contours and Features
 Concept 09: Kmeans Clustering
 Concept 10: Kmeans Implementation
 Concept 11: Notebook: Kmeans Clustering

Lesson 07: Feature Vectors
Learn how to describe objects and images using feature vectors.
 Concept 01: Corners and Object Detection
 Concept 02: Feature Vectors
 Concept 03: RealTime Feature Detection
 Concept 04: Introduction to ORB
 Concept 05: FAST
 Concept 06: Quiz: FAST Keypoints
 Concept 07: BRIEF
 Concept 08: Scale and Rotation Invariance
 Concept 09: Notebook: Image Pyramids
 Concept 10: Feature Matching
 Concept 11: ORB in Video
 Concept 12: Notebook: Implementing ORB
 Concept 13: HOG
 Concept 14: Notebook: Implementing HOG
 Concept 15: Learning to Find Features

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.
 Concept 01: Introduction to CNN Layers
 Concept 02: Review: Training a Neural Network
 Concept 03: Lesson Outline and Data
 Concept 04: CNN Architecture, VGG16
 Concept 05: Convolutional Layers
 Concept 06: Defining Layers in PyTorch
 Concept 07: Notebook: Visualizing a Convolutional Layer
 Concept 08: Pooling, VGG16 Architecture
 Concept 09: Pooling Layers
 Concept 10: Notebook: Visualizing a Pooling Layer
 Concept 11: FullyConnected Layers, VGG16
 Concept 12: Notebook: Visualizing FashionMNIST
 Concept 13: Training in PyTorch
 Concept 14: Notebook: Fashion MNIST Training Exercise
 Concept 15: Notebook: FashionMNIST, Solution 1
 Concept 16: Review: Dropout
 Concept 17: Notebook: FashionMNIST, Solution 2
 Concept 18: Network Structure
 Concept 19: Feature Visualization
 Concept 20: Feature Maps
 Concept 21: First Convolutional Layer
 Concept 22: Visualizing CNNs (Part 2)
 Concept 23: Visualizing Activations
 Concept 24: Notebook: Feature Viz for FashionMNIST
 Concept 25: Last Feature Vector and tSNE
 Concept 26: Occlusion, Saliency, and Guided Backpropagation
 Concept 27: Summary of Feature Viz
 Concept 28: Image Classification & Regression Challenges

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.

Lesson 10: Jobs in Computer Vision
Learn about common jobs in computer vision, and get tips on how to stay active in the community.

Lesson 11: 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 02 : Optional: 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 03 : Advanced Computer Vision & Deep Learning

Module 01:
Advanced Computer Vision and Deep Learning

Lesson 01: Advanced CNN Architectures
Learn about advances in CNN architectures and see how regionbased CNN’s, like Faster RCNN, have allowed for fast, localized object recognition in images.
 Concept 01: CNN's and Scene Understanding
 Concept 02: More than Classification
 Concept 03: Classification and Localization
 Concept 04: Bounding Boxes and Regression
 Concept 05: Quiz: Loss Values
 Concept 06: Region Proposals
 Concept 07: RCNN
 Concept 08: Fast RCNN
 Concept 09: Faster RCNN
 Concept 10: Detection With and Without Proposals

Lesson 02: YOLO
Learn about the YOLO (You Only Look Once) multiobject detection model and work with a YOLO implementation.
 Concept 01: Introduction to YOLO
 Concept 02: YOLO Output
 Concept 03: Sliding Windows, Revisited
 Concept 04: CNN & Sliding Windows
 Concept 05: Using a Grid
 Concept 06: Training on a Grid
 Concept 07: Generating Bounding Boxes
 Concept 08: Quiz: Generating Boxes and Detecting Objects
 Concept 09: Too Many Boxes
 Concept 10: Intersection over Union (IoU)
 Concept 11: Quiz: IoU and Overlap Limits
 Concept 12: NonMaximal Suppression
 Concept 13: Anchor Boxes
 Concept 14: YOLO Algorithm
 Concept 15: Notebook: 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.
 Concept 01: RNN's in Computer Vision
 Concept 02: RNN Introduction
 Concept 03: RNN History
 Concept 04: RNN Applications
 Concept 05: Feedforward Neural NetworkReminder
 Concept 06: The Feedforward Process
 Concept 07: Feedforward Quiz
 Concept 08: Backpropagation Theory
 Concept 09: Backpropagation  Example (part a)
 Concept 10: Backpropagation Example (part b)
 Concept 11: Backpropagation Quiz
 Concept 12: RNN (part a)
 Concept 13: RNN (part b)
 Concept 14: RNN Unfolded Model
 Concept 15: Unfolded Model Quiz
 Concept 16: RNN Example
 Concept 17: Backpropagation Through Time (part a)
 Concept 18: Backpropagation Through Time (part b)
 Concept 19: Backpropagation Through Time (part c)
 Concept 20: BPTT Quiz 1
 Concept 21: BPTT Quiz 2
 Concept 22: BPTT Quiz 3
 Concept 23: Some more math
 Concept 24: RNN Summary
 Concept 25: From RNN to LSTM
 Concept 26: Wrap Up

Lesson 04: Long ShortTerm Memory Networks (LSTMs)
Luis explains Long ShortTerm Memory Networks (LSTM), and similar architectures which have the benefits of preserving long term memory.
 Concept 01: Intro to LSTM
 Concept 02: RNN vs LSTM
 Concept 03: Basics of LSTM
 Concept 04: Architecture of LSTM
 Concept 05: Notebook: LSTM Structure and Hidden State, PyTorch
 Concept 06: The Learn Gate
 Concept 07: The Forget Gate
 Concept 08: The Remember Gate
 Concept 09: The Use Gate
 Concept 10: Putting it All Together
 Concept 11: Quiz
 Concept 12: Notebook: LSTM for Part of Speech Tagging
 Concept 13: CharacterLevel RNN
 Concept 14: Sequence Batching
 Concept 15: Notebook: CharacterLevel LSTM
 Concept 16: Other architectures

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.
 Concept 01: Introducing Jay
 Concept 02: Introduction
 Concept 03: Learning Rate
 Concept 04: Learning Rate
 Concept 05: Minibatch Size
 Concept 06: Number of Training Iterations / Epochs
 Concept 07: Number of Hidden Units / Layers
 Concept 08: RNN Hyperparameters
 Concept 09: RNN Hyperparameters
 Concept 10: Sources & References

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.
 Concept 01: Introduction to Attention
 Concept 02: Encoders and Decoders
 Concept 03: Elective: Text Sentiment Analysis
 Concept 04: Sequence to Sequence Recap
 Concept 05: Encoding  Attention Overview
 Concept 06: Decoding  Attention Overview
 Concept 07: Attention Overview
 Concept 08: Attention Encoder
 Concept 09: Attention Decoder
 Concept 10: Attention Encoder & Decoder
 Concept 11: Bahdanau and Luong Attention
 Concept 12: Multiplicative Attention
 Concept 13: Additive Attention
 Concept 14: Additive and Multiplicative Attention
 Concept 15: Computer Vision Applications
 Concept 16: Other Attention Methods
 Concept 17: The Transformer and SelfAttention
 Concept 18: Notebook: Attention Basics
 Concept 19: [SOLUTION]: Attention Basics
 Concept 20: Outro

Lesson 07: Image Captioning
Learn how to combine CNNs and RNNs to build a complex, automatic image captioning model.
 Concept 01: Introduction to Image Captioning
 Concept 02: Leveraging Neural Networks
 Concept 03: Captions and the COCO Dataset
 Concept 04: Visualize the Dataset
 Concept 05: CNNRNN Model
 Concept 06: The Glue, Feature Vector
 Concept 07: Tokenizing Captions
 Concept 08: Tokenizing Words
 Concept 09: RNN Training
 Concept 10: Video Captioning
 Concept 11: On to the Project!

Lesson 08: Project: Image Captioning
Train a CNNRNN model to predict captions for a given image. Your main task will be to implement an effective RNN decoder for a CNN encoder.

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.
 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

Part 04 : Object Tracking and Localization

Module 01:
Object Tracking & 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.
 Concept 01: Probability Review
 Concept 02: Uncertainty and Bayes' Rule
 Concept 03: Reducing Uncertainty
 Concept 04: Probability Distributions
 Concept 05: Localization
 Concept 06: Total Probability
 Concept 07: Notebook: 1D Robot World
 Concept 08: Probability After Sense
 Concept 09: Notebook: Probability After Sense
 Concept 10: Normalize Distribution
 Concept 11: Sense Function
 Concept 12: Notebook: Sense Function
 Concept 13: Answer: Sense Function
 Concept 14: Normalized Sense Function
 Concept 15: Notebook: Normalized Sense Function
 Concept 16: Answer: Normalized Sense Function
 Concept 17: Test Sense Function
 Concept 18: Multiple Measurements
 Concept 19: Notebook: Multiple Measurements
 Concept 20: Answer: Multiple Measurements
 Concept 21: Exact Motion
 Concept 22: Move Function
 Concept 23: Notebook: Move Function
 Concept 24: Answer: Move Function
 Concept 25: Inexact Motion
 Concept 26: Inexact Move Function
 Concept 27: Notebook: Inexact Move Function
 Concept 28: Answer: Inexact Move Function
 Concept 29: Limit Distribution
 Concept 30: Move Twice
 Concept 31: Move 1000
 Concept 32: Notebook: Multiple Moves
 Concept 33: Sense and Move
 Concept 34: Notebook: Sense and Move Cycle
 Concept 35: Answer: Sense and Move
 Concept 36: Sense and Move 2
 Concept 37: Localization Summary
 Concept 38: C++ Elective & Implementation

Lesson 03: Miniproject: 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 onedimensional tracker of your own.
 Concept 01: Kalman Filters and Linear Algebra
 Concept 02: Introduction
 Concept 03: Tracking Intro
 Concept 04: Answer: Tracking Intro
 Concept 05: Gaussian Intro
 Concept 06: Answer: Gaussian Intro
 Concept 07: Quiz: Variance and Preferred Gaussian
 Concept 08: Answer: Variance and Preferred Gaussian
 Concept 09: Gaussian Function and Maximum
 Concept 10: Quiz: Shifting the Mean
 Concept 11: Answer: Shifting the Mean
 Concept 12: Quiz: Predicting the Peak
 Concept 13: Answer: Predicting the Peak
 Concept 14: Quiz: Parameter Update
 Concept 15: Answer: Parameter Update
 Concept 16: Notebook: New Mean and Variance
 Concept 17: Solution: New Mean and Variance
 Concept 18: Quiz: Gaussian Motion
 Concept 19: Answer: Gaussian Motion
 Concept 20: Predict Function
 Concept 21: Notebook: Predict Function
 Concept 22: Answer: Predict Function
 Concept 23: Kalman Filter Code
 Concept 24: Notebook: 1D Kalman Filter
 Concept 25: Answer: 1D Kalman Filter
 Concept 26: Kalman Prediction
 Concept 27: Next: Motion Models and State

Lesson 05: Representing State and Motion
Learn about representing the state of a car in a vector that can be modified using 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: Car Object
 Concept 11: Interacting with a Car Object
 Concept 12: Look at the Class Code
 Concept 13: Turn Right
 Concept 14: Adding Color
 Concept 15: Instantiate Multiple Cars
 Concept 16: Color Class
 Concept 17: Overloading Functions
 Concept 18: Overloading Color Addition
 Concept 19: State Vector
 Concept 20: State Transformation Matrix
 Concept 21: Matrix Multiplication
 Concept 22: 1D State Vector and More Multiplication
 Concept 23: Modify Predict State
 Concept 24: Working with Matrices

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.
 Concept 01: Kalman Filter Land
 Concept 02: Kalman Filter Prediction
 Concept 03: Another Prediction
 Concept 04: More Kalman FIlters
 Concept 05: A Note on Notation
 Concept 06: Kalman Filter Design
 Concept 07: Let's Look at Where We Are
 Concept 08: The Kalman Filter Equations
 Concept 09: Simplifying the Kalman Filter Equations
 Concept 10: The Rest of the Lesson
 Concept 11: Representing State with Matrices
 Concept 12: Kalman Equation Reference
 Concept 13: What is a vector?
 Concept 14: Vectors in Python
 Concept 15: Coding Vectors
 Concept 16: Coding Vectors (solution)
 Concept 17: Guide to Mathematical Notation
 Concept 18: Matrices in Python
 Concept 19: Coding Matrices
 Concept 20: Coding Matrices (Solution)
 Concept 21: Matrix Addition
 Concept 22: Coding Matrix Addition
 Concept 23: Matrix Multiplication
 Concept 24: Coding Matrix Multiplication
 Concept 25: Transpose of a Matrix
 Concept 26: Coding the Transpose
 Concept 27: The Identity Matrix
 Concept 28: Coding Identity Matrix
 Concept 29: Matrix Inverse
 Concept 30: Coding Matrix Inverse
 Concept 31: What to Take Away from this Lesson

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.
 Concept 01: Introduction to SLAM
 Concept 02: Quiz: Graph SLAM
 Concept 03: Answer: Graph SLAM
 Concept 04: Quiz: Implementing Constraints
 Concept 05: Answer: Implementing Constraints
 Concept 06: Quiz: Adding Landmarks
 Concept 07: Answer: Adding Landmarks
 Concept 08: Quiz: Matrix Modification
 Concept 09: Answer: Matrix Modification
 Concept 10: Quiz: Untouched Fields
 Concept 11: Answer: Untouched Fields
 Concept 12: Quiz: Omega and Xi
 Concept 13: Notebook: Omega and Xi
 Concept 14: Quiz: Landmark Position
 Concept 15: Answer: Landmark Position
 Concept 16: Notebook: Including Sensor Measurements
 Concept 17: Quiz: Introducing Noise
 Concept 18: Answer: Introducing Noise
 Concept 19: Confident Measurements
 Concept 20: Notebook: Confident Measurements
 Concept 21: SLAM Summary

Lesson 08: Optional: Vehicle Motion and Calculus
Review the basics of calculus and see how to derive the x and y components of a selfdriving car's motion from sensor measurements and other data.
 Concept 01: Introduction to Odometry
 Concept 02: Inertial Navigation Sensors
 Concept 03: Plotting Position vs. Time
 Concept 04: Interpreting Position vs. Time Graphs
 Concept 05: A "Typical" Calculus Problem
 Concept 06: How Odometers Work
 Concept 07: Speed from Position Data
 Concept 08: Position, Velocity, and Acceleration
 Concept 09: Implement an Accelerometer
 Concept 10: Differentiation Recap
 Concept 11: Acceleration Basics
 Concept 12: Plotting Elevator Acceleration
 Concept 13: Reasoning About Two Peaks
 Concept 14: The Integral: Area Under a Curve
 Concept 15: Approximating the Integral
 Concept 16: Approximating Integrals with Code
 Concept 17: Integrating Accelerometer Data
 Concept 18: Rate Gyros
 Concept 19: Integrating Rate Gyro Data
 Concept 20: Working with Real Data
 Concept 21: Accumulating Errors
 Concept 22: Sensor Strengths and Weaknesses
 Concept 23: Summary and Back to Trigonometry
 Concept 24: Trigonometry and Vehicle Motion
 Concept 25: Solving Trig Problems
 Concept 26: Keeping Track of x and y
 Concept 27: Keeping Track of x and y (solution)
 Concept 28: Conclusion
 Concept 29: Project Overview
 Concept 30: Lab  Reconstructing Trajectories

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.

Part 05 (Elective) : Applications of Computer Vision and Deep Learning
Take a quick look at a few really cool applications of deep learning and computer vision, such as Neural Style Transfer, that using pretrained models.

Module 01:
Applying Computer Vision and Deep Learning Models

Lesson 01: Applying Deep Learning Models
Try out a few really cool applications of computer vision and deep learning, such as style transfer, using pretrained models that others have generously provided on Github.

Part 06 (Elective) : Review: Training A Neural Network
Review how neural networks turn an input into an output and how they monitor errors as they train. This section will also cover methods to avoid overfitting your data.

Module 01:
How Neural Networks Train

Lesson 01: Feedforward and Backpropagation
Short introduction to neural networks: how they train by doing a feedforward pass then performing backpropagation.

Lesson 02: Training Neural Networks
Now that you know what neural networks are, in this lesson you will learn several techniques to improve their training.
 Concept 01: Instructor
 Concept 02: Training Optimization
 Concept 03: Testing
 Concept 04: Overfitting and Underfitting
 Concept 05: Early Stopping
 Concept 06: Regularization
 Concept 07: Regularization 2
 Concept 08: Dropout
 Concept 09: Local Minima
 Concept 10: Random Restart
 Concept 11: Vanishing Gradient
 Concept 12: Other Activation Functions
 Concept 13: Batch vs Stochastic Gradient Descent
 Concept 14: Learning Rate Decay
 Concept 15: Momentum
 Concept 16: Error Functions Around the World

Lesson 03: Deep Learning with PyTorch
Learn how to use PyTorch for building deep learning models
 Concept 01: Instructor
 Concept 02: Introducing PyTorch
 Concept 03: PyTorch Tensors
 Concept 04: Defining Networks
 Concept 05: Training Networks
 Concept 06: FashionMNIST Exercise
 Concept 07: Inference & Validation
 Concept 08: Saving and Loading Trained Networks
 Concept 09: Loading Data Sets with Torchvision
 Concept 10: Transfer Learning
 Concept 11: Transfer Learning Solution

Part 07 (Elective) : Skin Cancer Detection
Learn how to utilize neural networks to distinguish between images of benign and cancerous skin tissue.

Module 01:
Deep Learning for Cancer Detection

Lesson 01: Deep Learning for Cancer Detection with Sebastian Thrun
Sebastian Thrun teaches us about his groundbreaking work detecting skin cancer with convolutional neural networks.
 Concept 01: Intro
 Concept 02: Skin Cancer
 Concept 03: Survival Probability of Skin Cancer
 Concept 04: Medical Classification
 Concept 05: The data
 Concept 06: Image Challenges
 Concept 07: Quiz: Data Challenges
 Concept 08: Solution: Data Challenges
 Concept 09: Training the Neural Network
 Concept 10: Quiz: Random vs Preinitialized Weights
 Concept 11: Solution: Random vs Preinitialized Weight
 Concept 12: Validating the Training
 Concept 13: Quiz: Sensitivity and Specificity
 Concept 14: Solution: Sensitivity and Specificity
 Concept 15: More on Sensitivity and Specificity
 Concept 16: Quiz: Diagnosing Cancer
 Concept 17: Solution: Diagnosing Cancer
 Concept 18: Refresh on ROC Curves
 Concept 19: Quiz: ROC Curve
 Concept 20: Solution: ROC Curve
 Concept 21: Comparing our Results with Doctors
 Concept 22: Visualization
 Concept 23: What is the network looking at?
 Concept 24: Refresh on Confusion Matrices
 Concept 25: Confusion Matrix
 Concept 26: Conclusion
 Concept 27: Useful Resources
 Concept 28: Mini Project Introduction
 Concept 29: Mini Project: Dermatologist AI

Part 08 (Elective) : Text Sentiment Analysis
Learn how to create a simple neural network for analyzing the sentiment (bad or good) in the text of movie reviews.

Module 01:
Sentiment Analysis

Lesson 01: Sentiment Analysis
In this lesson, Andrew Trask, the author of Grokking Deep Learning, will walk you through using neural networks for sentiment analysis.
 Concept 01: Introducing Andrew Trask
 Concept 02: Meet Andrew
 Concept 03: Materials
 Concept 04: The Notebooks
 Concept 05: Framing the Problem
 Concept 06: Mini Project 1
 Concept 07: Mini Project 1 Solution
 Concept 08: Transforming Text into Numbers
 Concept 09: Mini Project 2
 Concept 10: Mini Project 2 Solution
 Concept 11: Building a Neural Network
 Concept 12: Mini Project 3
 Concept 13: Mini Project 3 Solution
 Concept 14: Understanding Neural Noise
 Concept 15: Mini Project 4
 Concept 16: Understanding Inefficiencies in our Network
 Concept 17: Mini Project 5
 Concept 18: Mini Project 5 Solution
 Concept 19: Further Noise Reduction
 Concept 20: Mini Project 6
 Concept 21: Mini Project 6 Solution
 Concept 22: Analysis: What's Going on in the Weights?
 Concept 23: Conclusion

Part 09 (Elective) : More Deep Learning Models

Module 01:
Scene Understanding

Lesson 01: FullyConvolutional Neural Networks & Semantic Segmentation
Get a highlevel overview of how fullyconvolutional neural networks work, and see how they can be used to classify every pixel in an image.
 Concept 01: Intro
 Concept 02: Why Fully Convolutional Networks (FCNs) ?
 Concept 03: Fully Convolutional Networks
 Concept 04: Fully Connected to 1x1 Convolution
 Concept 05: Transposed Convolutions
 Concept 06: Skip Connections
 Concept 07: FCNs In The Wild
 Concept 08: Bounding Boxes
 Concept 09: Semantic Segmentation
 Concept 10: Semantic Segmentation and FCN's
 Concept 11: Scene Understanding
 Concept 12: IoU
 Concept 13: IOU Example
 Concept 14: FCN8 Architecture
 Concept 15: Outro

Part 10 (Elective) : C++ Programming

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.


Module 02:
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 2dimensional histogram filter; your job is to get the histogram filter code to run faster!
