TinyML. Machine Learning with TensorFlow Lite on Arduino and Ultra-Low-Power Microcontrollers Pete Warden, Daniel Situnayake

Kup polskie wydanie:

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

• Preface
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments
• 1. Introduction
  • Embedded Devices
  • Changing Landscape
• 2. Getting Started
  • Who Is This Book Aimed At?
  • What Hardware Do You Need?
  • What Software Do You Need?
  • What Do We Hope Youll Learn?
• 3. Getting Up to Speed on Machine Learning
  • What Machine Learning Actually Is
  • The Deep Learning Workflow
    • Decide on a Goal
    • Collect a Dataset
      • Selecting data
      • Collecting data
      • Labeling data
      • Our final dataset
    • Design a Model Architecture
      • Generating features from data
        • Windowing
        • Normalization
      • Thinking with ML
    • Train the Model
      • Underfitting and overfitting
      • Training, validation, and testing
    • Convert the Model
    • Run Inference
    • Evaluate and Troubleshoot
  • Wrapping Up
• 4. The Hello World of TinyML: Building and Training a Model
  • What Were Building
  • Our Machine Learning Toolchain
    • Python and Jupyter Notebooks
    • Google Colaboratory
    • TensorFlow and Keras
  • Building Our Model
    • Importing Dependencies
    • Generating Data
    • Splitting the Data
    • Defining a Basic Model
  • Training Our Model
    • Training Metrics
    • Graphing the History
    • Improving Our Model
    • Testing
  • Converting the Model for TensorFlow Lite
    • Converting to a C File
  • Wrapping Up
• 5. The Hello World of TinyML: Building an Application
  • Walking Through the Tests
    • Including Dependencies
    • Setting Up the Test
    • Getting Ready to Log Data
    • Mapping Our Model
    • Creating an AllOpsResolver
    • Defining a Tensor Arena
    • Creating an Interpreter
    • Inspecting the Input Tensor
    • Running Inference on an Input
    • Reading the Output
    • Running the Tests
      • Grabbing the code
      • Using Make to run the tests
  • Project File Structure
  • Walking Through the Source
    • Starting with main_functions.cc
    • Handling Output with output_handler.cc
    • Wrapping Up main_functions.cc
    • Understanding main.cc
    • Running Our Application
  • Wrapping Up
• 6. The Hello World of TinyML: Deploying to Microcontrollers
  • What Exactly Is a Microcontroller?
  • Arduino
    • Handling Output on Arduino
    • Running the Example
    • Making Your Own Changes
  • SparkFun Edge
    • Handling Output on SparkFun Edge
    • Running the Example
      • Build the binary
      • Sign the binary
      • Flash the binary
        • Attach the programmer to the board
        • Attach the programmer to your computer
        • Run the script to flash your board
    • Testing the Program
    • Viewing Debug Data
    • Making Your Own Changes
  • ST Microelectronics STM32F746G Discovery Kit
    • Handling Output on STM32F746G
    • Running the Example
    • Making Your Own Changes
  • Wrapping Up
• 7. Wake-Word Detection: Building an Application
  • What Were Building
  • Application Architecture
    • Introducing Our Model
    • All the Moving Parts
  • Walking Through the Tests
    • The Basic Flow
    • The Audio Provider
    • The Feature Provider
      • How the feature provider converts audio to a spectrogram
    • The Command Recognizer
    • The Command Responder
  • Listening for Wake Words
    • Running Our Application
  • Deploying to Microcontrollers
    • Arduino
      • Responding to commands on Arduino
      • Running the example
      • Making your own changes
    • SparkFun Edge
      • Responding to commands on SparkFun Edge
      • Running the example
        • Build the binary
        • Sign the binary
        • Flash the binary
        • Attach the programmer to the board
        • Attach the programmer to your computer
        • Run the script to flash your board
      • Testing the program
      • Viewing debug data
      • Making your own changes
    • ST Microelectronics STM32F746G Discovery Kit
      • Responding to commands on STM32F746G
      • Running the example
      • Testing the program
      • Viewing debug data
      • Making your own changes
  • Wrapping Up
• 8. Wake-Word Detection: Training a Model
  • Training Our New Model
    • Training in Colab
      • Enable GPU training
      • Configure training
      • Install dependencies
      • Load TensorBoard
      • Begin training
      • Wait for training to complete
        • Keeping Colab running
      • Freeze the graph
      • Convert to TensorFlow Lite
      • Create a C array
  • Using the Model in Our Project
    • Replacing the Model
    • Updating the Labels
    • Updating command_responder.cc
      • Arduino
      • SparkFun Edge
      • STM32F746G
    • Other Ways to Run the Scripts
  • How the Model Works
    • Visualizing the Inputs
    • How Does Feature Generation Work?
    • Understanding the Model Architecture
    • Understanding the Model Output
  • Training with Your Own Data
    • The Speech Commands Dataset
    • Training on Your Own Dataset
    • How to Record Your Own Audio
    • Data Augmentation
    • Model Architectures
  • Wrapping Up
• 9. Person Detection: Building an Application
  • What Were Building
  • Application Architecture
    • Introducing Our Model
    • All the Moving Parts
  • Walking Through the Tests
    • The Basic Flow
    • The Image Provider
    • The Detection Responder
  • Detecting People
  • Deploying to Microcontrollers
    • Arduino
      • Which camera module to buy
      • Capturing images on arduino
      • Responding to detections on Arduino
      • Running the example
      • Making your own changes
    • SparkFun Edge
      • Which camera module to buy
      • Capturing images on SparkFun Edge
      • Responding to detections on SparkFun Edge
      • Running the example
        • Build the binary
        • Sign the binary
        • Flash the binary
        • Attach the programmer to the board
        • Attach the programmer to your computer
        • Run the script to flash your board
      • Testing the program
      • Viewing debug data
      • Making your own changes
  • Wrapping Up
• 10. Person Detection: Training a Model
  • Picking a Machine
  • Setting Up a Google Cloud Platform Instance
  • Training Framework Choice
  • Building the Dataset
  • Training the Model
  • TensorBoard
  • Evaluating the Model
  • Exporting the Model to TensorFlow Lite
    • Exporting to a GraphDef Protobuf File
    • Freezing the Weights
    • Quantizing and Converting to TensorFlow Lite
    • Converting to a C Source File
  • Training for Other Categories
  • Understanding the Architecture
  • Wrapping Up
• 11. Magic Wand: Building an Application
  • What Were Building
  • Application Architecture
    • Introducing Our Model
    • All the Moving Parts
  • Walking Through the Tests
    • The Basic Flow
    • The Accelerometer Handler
    • The Gesture Predictor
    • The Output Handler
  • Detecting Gestures
  • Deploying to Microcontrollers
    • Arduino
      • Arduino constants
      • Capturing accelerometer data on Arduino
      • Responding to gestures on Arduino
      • Running the example
      • Making your own changes
    • SparkFun Edge
      • Capturing accelerometer data on SparkFun Edge
      • Responding to gestures on SparkFun Edge
      • Running the example
        • Build the binary
        • Sign the binary
        • Flash the binary
        • Attach the programmer to the board
        • Attach the programmer to your computer
        • Run the script to flash your board
      • Testing the Program
      • Making your own changes
  • Wrapping Up
• 12. Magic Wand: Training a Model
  • Training a Model
    • Training in Colab
      • Enable GPU Training
      • Install dependencies
      • Prepare the data
      • Load TensorBoard
      • Begin training
      • Evaluate the results
      • Create a C array
    • Other Ways to Run the Scripts
  • How the Model Works
    • Visualizing the Input
    • Understanding the Model Architecture
  • Training with Your Own Data
    • Capturing Data
      • SparkFun Edge
      • Logging data
    • Modifying the Training Scripts
    • Training
    • Using the New Model
  • Wrapping Up
    • Learning Machine Learning
    • Whats Next
• 13. TensorFlow Lite for Microcontrollers
  • What Is TensorFlow Lite for Microcontrollers?
    • TensorFlow
    • TensorFlow Lite
    • TensorFlow Lite for Microcontrollers
    • Requirements
    • Why Is the Model Interpreted?
    • Project Generation
  • Build Systems
    • Specializing Code
    • Makefiles
    • Writing Tests
  • Supporting a New Hardware Platform
    • Printing to a Log
    • Implementing DebugLog()
    • Running All the Targets
    • Integrating with the Makefile Build
  • Supporting a New IDE or Build System
  • Integrating Code Changes Between Projects and Repositories
  • Contributing Back to Open Source
  • Supporting New Hardware Accelerators
  • Understanding the File Format
    • FlatBuffers
  • Porting TensorFlow Lite Mobile Ops to Micro
    • Separate the Reference Code
    • Create a Micro Copy of the Operator
    • Port the Test to the Micro Framework
    • Build a Bazel Test
    • Add Your Op to AllOpsResolver
    • Build a Makefile Test
  • Wrapping Up
• 14. Designing Your Own TinyML Applications
  • The Design Process
  • Do You Need a Microcontroller, or Would a Larger Device Work?
  • Understanding Whats Possible
  • Follow in Someone Elses Footsteps
  • Find Some Similar Models to Train
  • Look at the Data
  • Wizard of Oz-ing
  • Get It Working on the Desktop First
• 15. Optimizing Latency
  • First Make Sure It Matters
  • Hardware Changes
  • Model Improvements
    • Estimating Model Latency
    • How to Speed Up Your Model
  • Quantization
  • Product Design
  • Code Optimizations
    • Performance Profiling
      • Blinky
      • Shotgun profiling
      • Debug logging
      • Logic analyzer
      • Timer
      • Profiler
  • Optimizing Operations
    • Look for Implementations That Are Already Optimized
    • Write Your Own Optimized Implementation
    • Taking Advantage of Hardware Features
    • Accelerators and Coprocessors
  • Contributing Back to Open Source
  • Wrapping Up
• 16. Optimizing Energy Usage
  • Developing Intuition
    • Typical Component Power Usage
    • Hardware Choice
  • Measuring Real Power Usage
  • Estimating Power Usage for a Model
  • Improving Power Usage
    • Duty Cycling
    • Cascading Design
  • Wrapping Up
• 17. Optimizing Model and Binary Size
  • Understanding Your Systems Limits
  • Estimating Memory Usage
    • Flash Usage
    • RAM Usage
  • Ballpark Figures for Model Accuracy and Size on Different Problems
    • Speech Wake-Word Model
    • Accelerometer Predictive Maintenance Model
    • Person Presence Detection
  • Model Choice
  • Reducing the Size of Your Executable
    • Measuring Code Size
    • How Much Space Is Tensorflow Lite for Microcontrollers Taking?
    • OpResolver
    • Understanding the Size of Individual Functions
    • Framework Constants
  • Truly Tiny Models
  • Wrapping Up
• 18. Debugging
  • Accuracy Loss Between Training and Deployment
    • Preprocessing Differences
    • Debugging Preprocessing
    • On-Device Evaluation
  • Numerical Differences
    • Are the Differences a Problem?
    • Establish a Metric
    • Compare Against a Baseline
    • Swap Out Implementations
  • Mysterious Crashes and Hangs
    • Desktop Debugging
    • Log Tracing
    • Shotgun Debugging
    • Memory Corruption
  • Wrapping Up
• 19. Porting Models from TensorFlow to TensorFlow Lite
  • Understand What Ops Are Needed
  • Look at Existing Op Coverage in Tensorflow Lite
  • Move Preprocessing and Postprocessing into Application Code
  • Implement Required Ops if Necessary
  • Optimize Ops
  • Wrapping Up
• 20. Privacy, Security, and Deployment
  • Privacy
    • The Privacy Design Document
      • Data collection
      • Data usage
      • Data sharing and storage
      • Consent
    • Using a PDD
  • Security
    • Protecting Models
  • Deployment
    • Moving from a Development Board to a Product
  • Wrapping Up
• 21. Learning More
  • The TinyML Foundation
  • SIG Micro
  • The TensorFlow Website
  • Other Frameworks
  • Twitter
  • Friends of TinyML
  • Wrapping Up
• A. Using and Generating an Arduino Library Zip
• B. Capturing Audio on Arduino
• Index

pokaż cały spis treści

ukryj recenzje