Intel® Edge AI for IoT Developers Nanodegree
助教微信
udacity公众号
Nanodegree key: nd131
Version: 1.0.0
Locale: en-us
In this Nanodegree program, you will learn how to develop and optimize Edge AI systems, using Intel’s® OpenVINO™ toolkit.
Content
Part 01 : Welcome to the Program
Before diving into the program, let’s first find out more about what taking a Udacity Nanodegree program is like and what it takes to succeed. We’ll also cover software requirements and pre-requisites.
Module 01: Nanodegree Program Orientation
- Lesson 01: Nanodegree Program IntroductionBefore diving into the program, let’s first find out more about what taking a Udacity Nanodegree program is like and how to succeed. We’ll also cover software requirements and pre-requisites.
- Concept 01: Welcome to Udacity
- Concept 02: Welcome to the Nanodegree Program Experience
- Concept 03: How to Succeed
- Concept 04: Welcome to Intel® Edge AI for IoT Developers
- Concept 05: Prerequisites & Other Requirements
- Concept 06: Notebooks and Workspaces
- Concept 07: Graffiti Tutorial
Part 02 : Edge AI Fundamentals with OpenVINO™
Welcome to Edge AI Fundamentals with OpenVINO™, where you’ll learn about the basics of AI at the Edge, leverage pre-trained models available with the Intel® Distribution of OpenVINO Toolkit™, convert and optimize other models with the Model Optimizer, and perform inference with the Inference Engine. Additionally, you’ll learn some additional topics for edge applications, like MQTT and how to stream video to servers.
- Lesson 01: Nanodegree Program IntroductionBefore diving into the program, let’s first find out more about what taking a Udacity Nanodegree program is like and how to succeed. We’ll also cover software requirements and pre-requisites.
Module 01: Edge AI Fundamentals with OpenVINO™
- Lesson 01: Introduction to AI at the EdgeGet introduced to AI at the Edge, and find out about the topics you’ll learn throughout the rest of the course.
- Concept 01: Instructor Intro
- Concept 02: What is AI at the Edge?
- Concept 03: Why is AI at the Edge Important?
- Concept 04: Applications of AI at the Edge
- Concept 05: Historical Context
- Concept 06: Course Structure
- Concept 07: Why Are the Topics Distinct?
- Concept 08: Relevant Tools and Prerequisites
- Concept 09: What You Will Build
- Concept 10: Recap
- Lesson 02: Leveraging Pre-Trained ModelsUtilize Pre-Trained Models from the Intel® Distribution of OpenVINO™ Toolkit to build powerful edge applications, without the need to train your own model.
- Concept 01: Introduction
- Concept 02: The OpenVINO™ Toolkit
- Concept 03: Pre-Trained Models in OpenVINO™
- Concept 04: Types of Computer Vision Models
- Concept 05: Case Studies in Computer Vision
- Concept 06: Available Pre-Trained Models in OpenVINO™
- Concept 07: Exercise: Loading Pre-Trained Models
- Concept 08: Solution: Loading Pre-Trained Models
- Concept 09: Optimizations on the Pre-Trained Models
- Concept 10: Choosing the Right Model for Your App
- Concept 11: Pre-processing Inputs
- Concept 12: Exercise: Pre-processing Inputs
- Concept 13: Solution: Pre-processing Inputs
- Concept 14: Handling Network Outputs
- Concept 15: Running Your First Edge App
- Concept 16: Exercise: Deploy An App at the Edge
- Concept 17: Solution: Deploy An App at the Edge
- Concept 18: Recap
- Concept 19: Lesson Glossary
- Lesson 03: The Model OptimizerExplore the Model Optimizer, which allows you to take models trained with many different Deep Learning frameworks and create an Intermediate Representation useful with the Inference Engine.
- Concept 01: Introduction
- Concept 02: The Model Optimizer
- Concept 03: Optimization Techniques
- Concept 04: Supported Frameworks
- Concept 05: Intermediate Representations
- Concept 06: Using the Model Optimizer with TensorFlow Models
- Concept 07: Exercise: Convert a TF Model
- Concept 08: Solution: Convert a TF Model
- Concept 09: Using the Model Optimizer with Caffe Models
- Concept 10: Exercise: Convert a Caffe Model
- Concept 11: Solution: Convert a Caffe Model
- Concept 12: Using the Model Optimizer with ONNX Models
- Concept 13: Exercise: Convert an ONNX Model
- Concept 14: Solution: Convert an ONNX Model
- Concept 15: Cutting Parts of a Model
- Concept 16: Supported Layers
- Concept 17: Custom Layers
- Concept 18: Exercise: Custom Layers
- Concept 19: Recap
- Concept 20: Lesson Glossary
- Lesson 04: The Inference EngineDive deeper into the Inference Engine, and perform inference in the OpenVINO™ Toolkit. By the end, you’ll know the full workflow for OpenVINO™ fundamentals and be ready to integrate into an app.
- Concept 01: Introduction
- Concept 02: The Inference Engine
- Concept 03: Supported Devices
- Concept 04: Using the Inference Engine with an IR
- Concept 05: Exercise: Feed an IR to the Inference Engine
- Concept 06: Solution: Feed an IR to the Inference Engine
- Concept 07: Sending Inference Requests to the IE
- Concept 08: Asynchronous Requests
- Concept 09: Exercise: Inference Requests
- Concept 10: Solution: Inference Requests
- Concept 11: Handling Results
- Concept 12: Integrating into Your App
- Concept 13: Exercise: Integrate into an App
- Concept 14: Solution: Integrate into an App
- Concept 15: Behind the Scenes of Inference Engine
- Concept 16: Recap
- Concept 17: Lesson Glossary
- Lesson 05: Deploying an Edge AppWith the OpenVINO™ Toolkit fundamentals down, you’re ready to move onto more topics to get your edge app up and running. Learn about handling input streams, MQTT and more as you finish the course!
- Concept 01: Introduction
- Concept 02: OpenCV Basics
- Concept 03: Handling Input Streams
- Concept 04: Exercise: Handling Input Streams
- Concept 05: Solution: Handling Input Streams
- Concept 06: Gathering Useful Information from Model Outputs
- Concept 07: Exercise: Process Model Outputs
- Concept 08: Solution: Process Model Outputs
- Concept 09: Intro to MQTT
- Concept 10: Communicating with MQTT
- Concept 11: Streaming Images to a Server
- Concept 12: Handling Statistics and Images from a Node Server
- Concept 13: Exercise: Server Communications
- Concept 14: Solution: Server Communications
- Concept 15: Analyzing Performance Basics
- Concept 16: Model Use Cases
- Concept 17: Concerning End User Needs
- Concept 18: Recap
- Concept 19: Lesson Glossary
- Concept 20: Course Recap
- Concept 21: Partner with Intel
- Lesson 06: Project: Deploy a People Counter App at the EdgeShow off your new skills by deploying a people counter app at the edge! Go through the full OpenVINO™ Toolkit workflow, along with handling video streams and sending data with MQTT to build your app.Project Description - Deploy a People Counter App at the EdgeProject Rubric - Deploy a People Counter App at the Edge
- Lesson 07: Optimize Your GitHub ProfileOther 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 ProfileProject Rubric - Optimize Your GitHub Profile
- 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 03 : Choosing the Right Hardware
Grow your expertise in choosing the right hardware. Identify key hardware specifications of various
hardware types (CPU, VPU, FPGA, and Integrated GPU). Utilize the DevCloud to test model performance
and deploy power-efficient deep neural network inference on on the various hardware types. Finally, you
will distribute workload on available compute devices in order to improve model performance.
- Lesson 01: Introduction to AI at the EdgeGet introduced to AI at the Edge, and find out about the topics you’ll learn throughout the rest of the course.
Module 01: Choosing the Right Hardware
- Lesson 01: Introduction to Hardware at the EdgeLearn about the key hardware types used on IoT devices and the basics of designing an Edge AI system.
- Concept 01: Instructor Introduction
- Concept 02: Course Overview
- Concept 03: Changes in OpenVINO 2020.1
- Concept 04: Lesson Overview
- Concept 05: Why is Choosing the Right Hardware Important?
- Concept 06: Design of Edge AI Systems
- Concept 07: Analyze
- Concept 08: Design
- Concept 09: Develop
- Concept 10: Test and Deploy
- Concept 11: Basic Terminology
- Concept 12: Intel DevCloud
- Concept 13: Updating Your Workspace
- Concept 14: Walkthrough: Using Intel DevCloud
- Concept 15: Exercise: Using Intel DevCloud
- Concept 16: Lesson Review
- Lesson 02: CPUs and Integrated GPUsUse the Intel® Devcloud for the Edge for running deep learning models on the CPU and Integrated GPU.
- Concept 01: Lesson Overview
- Concept 02: CPU Basics
- Concept 03: Threads and Processes
- Concept 04: Multithreading and Multiprocessing
- Concept 05: Introduction to Intel Processors
- Concept 06: Intel CPU Architecture
- Concept 07: CPU Specifications (Part 1)
- Concept 08: CPU Specifications (Part 2)
- Concept 09: Exercise: CPU Scenario
- Concept 10: Updating Your Workspace
- Concept 11: Walkthrough: CPU and the DevCloud
- Concept 12: Exercise: CPU and the Devcloud
- Concept 13: Integrated GPU (IGPU)
- Concept 14: Walkthrough: IGPU and the DevCloud
- Concept 15: IGPU and Batch Processing
- Concept 16: Exercise: IGPU Scenario
- Concept 17: Exercise: IGPU and the DevCloud
- Concept 18: Lesson Review
- Lesson 03: VPUsIdentify the key specifications of Intel® VPUs and use the Intel® DevCloud for the Edge to run deep learning models on the VPU.
- Concept 01: Lesson Overview
- Concept 02: Introduction to VPUs
- Concept 03: Architecture of VPUs
- Concept 04: Myriad X Characteristics
- Concept 05: Intel Neural Compute Stick 2
- Concept 06: Exercise: VPU Scenario
- Concept 07: Updating Your Workspace
- Concept 08: Walkthrough: VPU and the DevCloud
- Concept 09: Exercise: VPU and the DevCloud
- Concept 10: Multi-Device Plugin
- Concept 11: Walkthrough: Multi-Device Plugin and the DevCloud
- Concept 12: Exercise: Multi Device Plugin on DevCloud
- Concept 13: Lesson Review
- Lesson 04: FPGAsIdentify the key specifications of Intel® FPGAs and utilize the HETERO Plugin to enable efficient hardware utilization.
- Concept 01: Lesson Overview
- Concept 02: Introduction to FPGAs
- Concept 03: Architecture of FPGAs
- Concept 04: Programming FPGAs
- Concept 05: FPGA Specifications
- Concept 06: Intel Vision Accelerator Design
- Concept 07: Exercise: FPGA Scenario
- Concept 08: Updating Your Workspace
- Concept 09: Walkthrough: FPGA and the DevCloud
- Concept 10: Exercise: FPGA and the DevCloud
- Concept 11: Heterogeneous Plugin
- Concept 12: Exercise: Heterogeneous Plugin on DevCloud
- Concept 13: Lesson Review
- Concept 14: Course Review
- Lesson 05: Project: Smart Queuing SystemGiven real-world scenarios to build a queuing system, use your knowledge of hardware specifications to identify which hardware types work best, and then test the application using the Intel® DevCloud.Project Description - Smart Queuing SystemProject Rubric - Smart Queuing System
- Concept 01: Project Overview
- Concept 02: Part 1: Hardware Proposal
- Concept 03: Scenario 1: Manufacturing
- Concept 04: Scenario 2: Retail
- Concept 05: Scenario 3: Transportation
- Concept 06: Part 2: Testing your Hardware
- Concept 07: Step 1: Create the Python Script
- Concept 08: Step 2: Create Job Submission Script
- Concept 09: Step 3: Manufacturing Scenario
- Concept 10: Step 4: Retail Scenario
- Concept 11: Step 5: Transportation Scenario
- Concept 12: Step 6: Submit your Project
- Lesson 06: Take 30 Min to Improve your LinkedInFind 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 ProfileProject Rubric - Improve Your LinkedIn Profile
- 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 : Optimization Techniques and Tools
Learn how to optimize your model and application code to reduce inference time when running your
model at the edge. Use different software optimization techniques to improve the inference time of your
model. Calculate how computationally expensive your model is. Use DL Workbench to optimize your
model and benchmark the performance of your model. Use a VTune amplifier to find and fix hotspots in
your application code. Finally, package your application code and data so that it can be easily deployed to
multiple devices.
- Lesson 01: Introduction to Hardware at the EdgeLearn about the key hardware types used on IoT devices and the basics of designing an Edge AI system.
Module 01: Optimization Techniques and Tools
- Lesson 01: Introduction to Software OptimizationThis lesson introduces software optimization (SO), when and why you should use it, and the broad classes of SO algorithms
- Concept 01: Instructor Introduction
- Concept 02: Course Overview
- Concept 03: Installing OpenVINO
- Concept 04: Lesson Overview
- Concept 05: What is Software Optimization and Why Does it Matter?
- Concept 06: Types of Software Optimization
- Concept 07: Performance Metrics
- Concept 08: Some Other Performance Metrics
- Concept 09: When do we do Software Optimization?
- Concept 10: Lesson Review
- Lesson 02: Reducing Model OperationsImplement optimization techniques that improve performance by reducing the number of model operations.
- Concept 01: Lesson Overview
- Concept 02: Calculating Model FLOPs: Dense Layers
- Concept 03: Calculating Model FLOPS: Convolutional Layers
- Concept 04: Calculate the FLOPs in a model
- Concept 05: Using Efficient Layers: Pooling Layers
- Concept 06: Exercise: Pooling Performance
- Concept 07: Using Efficient Layers: Separable Convolutions
- Concept 08: Exercise: Separable Convolutions Performance
- Concept 09: Measuring Layerwise Performance
- Concept 10: Exercise: Measuring Layerwise Performance
- Concept 11: Model Pruning
- Concept 12: Lesson Review
- Lesson 03: Reducing Model SizeOne of the ways to perform software optimization is to reduce the size of the model. In this lesson you will learn about the different algorithms used to do that.
- Concept 01: Lesson Overview
- Concept 02: Introduction to Quantization
- Concept 03: Benchmarking Model Performance
- Concept 04: Exercise: Benchmarking Model Performance
- Concept 05: Advanced Benchmarking
- Concept 06: Exercise: Advanced Benchmarking
- Concept 07: How Quantization is Done
- Concept 08: Quantizing a Model using DL Workbench
- Concept 09: Exercise: Quantizing a Model Using DL Workbench
- Concept 10: Model Compression
- Concept 11: Knowledge Distillation
- Concept 12: Lesson Review
- Lesson 04: Other Optimization Tools and TechniquesUse VTune Amplifier to measure hotspots in your application code.
- Concept 01: Lesson Overview
- Concept 02: Introduction to Intel VTune
- Concept 03: Exercise: Profiling Using VTune
- Concept 04: Advanced Concepts in Intel VTune
- Concept 05: Exercise: Advanced Profiling Using VTune Amplifier
- Concept 06: Packaging Your Application
- Concept 07: Exercise: Packaging Your Application
- Concept 08: Exercise: Deploying Runtime Package
- Concept 09: Lesson Review
- Concept 10: Course Review
- Lesson 05: Project: Computer Pointer ControllerDemonstrate your ability to run multiple models in the OpenVINO toolkit on the same machine to control your computer pointer using your eye gaze.Project Description - Computer Pointer ControllerProject Rubric - Computer Pointer Controller
- Lesson 01: Introduction to Software OptimizationThis lesson introduces software optimization (SO), when and why you should use it, and the broad classes of SO algorithms
【点击购买】
若有收获，就点个赞吧
0 人点赞
