Nanodegree key: nd891
Version: 5.0.0
Locale: en-us
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: High-pass Filters
- Concept 06: Quiz: Kernels
- Concept 07: Creating a Filter
- Concept 08: Gradients and Sobel Filters
- Concept 09: Notebook: Finding Edges
- Concept 10: Low-pass 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 k-means 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: K-means Clustering
- Concept 10: K-means Implementation
- Concept 11: Notebook: K-means 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: Real-Time 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, VGG-16
- Concept 05: Convolutional Layers
- Concept 06: Defining Layers in PyTorch
- Concept 07: Notebook: Visualizing a Convolutional Layer
- Concept 08: Pooling, VGG-16 Architecture
- Concept 09: Pooling Layers
- Concept 10: Notebook: Visualizing a Pooling Layer
- Concept 11: Fully-Connected Layers, VGG-16
- 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 t-SNE
- 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 region-based CNN’s, like Faster R-CNN, 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: R-CNN
- Concept 08: Fast R-CNN
- Concept 09: Faster R-CNN
- Concept 10: Detection With and Without Proposals
-
Lesson 02: YOLO
Learn about the YOLO (You Only Look Once) multi-object 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: Non-Maximal 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 Network-Reminder
- 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 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.
- 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: Character-Level RNN
- Concept 14: Sequence Batching
- Concept 15: Notebook: Character-Level 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 Self-Attention
- 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: CNN-RNN 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 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.
-
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: 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.
- 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 self-driving 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 pre-trained 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 pre-trained 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: Fashion-MNIST 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 Pre-initialized Weights
- Concept 11: Solution: Random vs Pre-initialized 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: Fully-Convolutional Neural Networks & Semantic Segmentation
Get a high-level overview of how fully-convolutional 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: FCN-8 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 2-dimensional histogram filter; your job is to get the histogram filter code to run faster!
-