AI 与嵌入式方向学习路线

2. AI 基础

Python 编程（2 周）

# 嵌入式 AI 必备 Python 技能
1. 基础语法
   - 数据类型、控制流
   - 函数、类、模块
2. 科学计算库
import numpy as np
arr = np.array([1, 2, 3])
matrix = np.random.randn(3, 3)
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [4, 5, 6])
3. 数据处理
import pandas as pd
data = pd.read_csv('sensor_data.csv')

机器学习基础（1 个月）

# 必须理解的核心概念
1. 监督学习
   - 线性回归：温度预测
   - 逻辑回归：故障分类
   - 决策树：规则推理
   - SVM：小样本分类
2. 非监督学习
   - K-Means：数据聚类
   - 异常检测：故障诊断
3. 深度学习入门
   - 神经网络原理
   - 前向传播、反向传播
   - 损失函数、优化器

# 示例：简单的温度预测模型
from sklearn.linear_model import LinearRegression
X = [[1], [2], [3], [4], [5]]
y = [20, 22, 24, 26, 28]
model = LinearRegression()
model.fit(X, y)
prediction = model.predict([[6]])
print(f"预测温度：{prediction[0]:.2f}°C")

推荐资源：

• 课程：机器学习在线课程
• 书籍：《机器学习实战》
• 实践：竞赛平台

深度学习框架（1 个月）

# TensorFlow/Keras（嵌入式部署用 TFLite）
1. Keras 构建模型
from tensorflow import keras
from tensorflow.keras import layers
model = keras.Sequential([
    layers.Conv2D(32, 3, activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D(),
    layers.Flatten(),
    layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=5)

2. 模型量化（关键！）
import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

3. PyTorch（可选）
import torch
import torch.nn as nn
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, 3)
        self.fc = nn.Linear(32*26*26, 10)
    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

推荐资源：

• 官方教程：TensorFlow 官网
• 视频：深度学习教程
• 实践：MNIST 手写数字识别

🚀 第二阶段：边缘 AI 技术（3-4 个月）

1. TinyML 核心技术

模型压缩与量化（1 个月）

# 四大核心技术
1. 剪枝（Pruning）
import tensorflow_model_optimization as tfmot
prune_low_magnitude = tfmot.sparsity.keras.prune_low_magnitude
pruning_params = {
    'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(
        initial_sparsity=0.0,
        final_sparsity=0.5,
        begin_step=0,
        end_step=1000
    )
}
model_for_pruning = prune_low_magnitude(model, **pruning_params)

2. 量化（Quantization）
# INT8 量化（32 位 → 8 位，速度提升 4 倍，模型缩小 4 倍）
converter = tf.lite.TFLiteConverter.from_keras_model(model)
def representative_dataset():
    for _ in range(100):
        yield [np.random.randn(1, 28, 28, 1).astype(np.float32)]
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8
tflite_model = converter.convert()

3. 知识蒸馏（Knowledge Distillation）
class Distiller(keras.Model):
    def __init__(self, student, teacher):
        super().__init__()
        self.teacher = teacher
        self.student = student
    def compile(self, optimizer, student_loss, distillation_loss, alpha=0.1):
        super().compile(optimizer=optimizer)
        self.student_loss = student_loss
        self.distillation_loss = distillation_loss
        self.alpha = alpha
    def train_step(self, data):
        x, y = data
        teacher_predictions = self.teacher(x, training=False)
        with tf.GradientTape() as tape:
            student_predictions = self.student(x, training=True)
            student_loss = self.student_loss(y, student_predictions)
            distillation_loss = self.distillation_loss(
                tf.nn.softmax(teacher_predictions),
                tf.nn.softmax(student_predictions)
            )
            loss = self.alpha * student_loss + (1 - self.alpha) * distillation_loss
            trainable_vars = self.student.trainable_variables
            gradients = tape.gradient(loss, trainable_vars)
            self.optimizer.apply_gradients(zip(gradients, trainable_vars))
        return {"loss": loss}

4. MobileNet 架构
from tensorflow.keras.applications import MobileNetV2
base_model = MobileNetV2(
    input_shape=(224, 224, 3),
    alpha=0.35,
    include_top=False,
    weights='imagenet'
)

模型大小对比：

原始 ResNet50: 98MB
↓ 剪枝 50% 49MB
↓ INT8 量化 12MB
↓ 知识蒸馏到 MobileNetV2 3MB ✅ 适合嵌入式部署

推荐资源：

• 论文：MobileNet、EfficientNet 系列
• 课程：TinyML 课程
• 工具：TensorFlow Model Optimization Toolkit

2. 嵌入式 AI 框架

TensorFlow Lite（重点，1.5 个月）

# PC 端训练 → 嵌入式推理完整流程
## Part 1: 模型训练（PC 端）
import tensorflow as tf
from tensorflow import keras
model = keras.Sequential([
    keras.layers.Conv2D(32, 3, activation='relu', input_shape=(96, 96, 3)),
    keras.layers.MaxPooling2D(),
    keras.layers.Conv2D(64, 3, activation='relu'),
    keras.layers.MaxPooling2D(),
    keras.layers.Flatten(),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dropout(0.5),
    keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=10, validation_split=0.2)
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
import tensorflow_model_optimization as tfmot
q_aware_model = tfmot.quantization.keras.quantize_model(model)
q_aware_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
q_aware_model.fit(train_images, train_labels, epochs=3)
converter = tf.lite.TFLiteConverter.from_keras_model(q_aware_model)
tflite_model = converter.convert()
with open('model_quantized.tflite', 'wb') as f:
    f.write(tflite_model)

## Part 2: 微控制器部署（STM32/ESP32）
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "model_data.h"
constexpr int kTensorArenaSize = 60 * 1024;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroErrorReporter micro_error_reporter;
tflite::AllOpsResolver resolver;
const tflite::Model* model = tflite::GetModel(model_data);
tflite::MicroInterpreter interpreter(
    model, resolver, tensor_arena, kTensorArenaSize, &micro_error_reporter
);
interpreter.AllocateTensors();
TfLiteTensor* input = interpreter.input(0);
for (int i = 0; i < 96*96*3; i++) {
    input->data.int8[i] = image_data[i];
}
TfLiteStatus invoke_status = interpreter.Invoke();
TfLiteTensor* output = interpreter.output(0);
int8_t max_score = -128;
int predicted_class = 0;
for (int i = 0; i < 10; i++) {
    if (output->data.int8[i] > max_score) {
        max_score = output->data.int8[i];
        predicted_class = i;
    }
}
printf("预测类别：%d, 置信度：%d\n", predicted_class, max_score);

实战项目：语音唤醒词识别

硬件：ESP32 + I2S 麦克风
模型：1D CNN（关键词检测）
流程：
1. 采集音频（16kHz 采样）
2. 提取 MFCC 特征（音频 → 频谱图）
3. TFLite 推理
4. 检测到"Hi AI"触发唤醒

推荐资源：

• 官方：TensorFlow Lite for Microcontrollers
• 书籍：《TinyML: Machine Learning with TensorFlow Lite》
• 开源项目：TensorFlow Micro Examples

Edge Impulse（最简单，1 个月）

# 无代码/低代码边缘 AI 平台
学习路线：
1. 注册 Edge Impulse 账号
2. 创建项目 → 数据采集
3. 设计模型（拖拽式界面）
4. 训练 → 部署到硬件
支持硬件：
- Arduino Nano 33 BLE Sense
- ESP32
- 树莓派
- STM32
典型项目：
1. 手势识别（加速度计）
2. 关键词识别（麦克风）
3. 图像分类（摄像头）
优势：
✅ 自动生成嵌入式代码（Arduino/C++）
✅ 内置数据增强
✅ 自动优化模型
✅ 实时性能分析

部署示例：
#include <your_project_inferencing.h>
void setup() {
    Serial.begin(115200);
}
void loop() {
    float features[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE];
    get_sensor_data(features);
    signal_t signal;
    numpy::signal_from_buffer(features, EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, &signal);
    ei_impulse_result_t result;
    run_classifier(&signal, &result, false);
    for (int i = 0; i < EI_CLASSIFIER_LABEL_COUNT; i++) {
        Serial.printf("%s: %.2f\n", result.classification[i].label, result.classification[i].value );
    }
}

推荐资源：

• 官网：Edge Impulse
• 社区：论坛有大量示例项目

其他框架（了解）

1. NCNN（腾讯） - 专为移动端优化 - C++ 实现，速度极快
2. MNN（阿里） - 轻量级推理引擎 - 支持多种硬件加速
3. OpenVINO（Intel） - 专为 Intel 硬件优化
4. CMSIS-NN（ARM） - ARM Cortex-M 优化 - 汇编级加速

3. 硬件加速

神经网络加速器（1 个月）

# AI 专用芯片/模块
1. Coral Edge TPU - Google 设计的 AI 加速器 - 4 TOPS 算力
2. Kendryte K210 - 0.23 TOPS 算力 - RISC-V 架构
3. BL702（博流） - RISC-V + NPU - 超低功耗
4. Jetson Nano（高端） - NVIDIA GPU - 适合复杂 AI 任务

FPGA 加速（选学）

用 Verilog/VHDL 实现神经网络加速
优势：可定制化硬件、极低延迟、并行计算
入门平台：Xilinx PYNQ-Z2、Intel DE10-Nano

🔬 第三阶段：实战项目（2-3 个月）

项目 1：智能门锁人脸识别

硬件清单：

- STM32H7（主控，400MHz）
- OV2640 摄像头（QVGA 320x240）
- LCD 屏幕（显示）
- 舵机（开锁）

技术栈：

1. 人脸检测：MTCNN（轻量版）
2. 人脸识别：MobileFaceNet
3. 模型量化：INT8
4. 推理引擎：TFLite Micro
性能指标：
- 检测速度：200ms/帧
- 识别准确率：95%+
- 内存占用：<512KB

完整代码框架：

// main.c
#include "camera.h"
#include "lcd.h"
#include "face_detection.h"
#include "face_recognition.h"
void main() {
    Camera_Init();
    LCD_Init();
    FaceDetection_Init();
    FaceRecognition_Init();
    while(1) {
        uint8_t* image = Camera_Capture();
        BoundingBox bbox;
        if (FaceDetection_Detect(image, &bbox)) {
            uint8_t face_region[112*112*3];
            CropFace(image, &bbox, face_region);
            int person_id = FaceRecognition_Identify(face_region);
            if (IsAuthorized(person_id)) {
                UnlockDoor();
                LCD_ShowString("Welcome!");
            } else {
                LCD_ShowString("Access Denied");
            }
        }
        Delay_ms(100);
    }
}

// face_detection.c（TFLite 推理）
#include "model_face_detection.h"
int FaceDetection_Detect(uint8_t* image, BoundingBox* bbox) {
    uint8_t input[128*128*3];
    ResizeImage(image, 320, 240, input, 128, 128);
    TfLiteTensor* input_tensor = interpreter->input(0);
    memcpy(input_tensor->data.int8, input, 128*128*3);
    interpreter->Invoke();
    TfLiteTensor* output = interpreter->output(0);
    if (output->data.f[0] > 0.9) {
        bbox->x = output->data.f[1] * 320;
        bbox->y = output->data.f[2] * 240;
        bbox->w = output->data.f[3] * 320;
        bbox->h = output->data.f[4] * 240;
        return 1;
    }
    return 0;
}

项目 2：工业设备故障预测

应用场景：电机振动异常检测

硬件：

- ESP32（WiFi 上传数据）
- MPU6050（加速度计）
- OLED 显示屏

AI 模型：

# 1. 数据采集
# 采集正常运行时的振动数据（3 轴加速度）
# 采集故障时的数据（轴承损坏、不平衡等）
# 2. 特征工程
import numpy as np
from scipy import signal
def extract_features(accel_data):
    features = []
    features.append(np.mean(accel_data))
    features.append(np.std(accel_data))
    features.append(np.max(accel_data))
    features.append(np.sqrt(np.mean(accel_data**2)))
    fft = np.fft.fft(accel_data)
    freq_magnitudes = np.abs(fft)[:len(fft)//2]
    features.append(np.max(freq_magnitudes))
    features.append(np.argmax(freq_magnitudes))
    return np.array(features)

# 3. 构建模型（1D CNN + LSTM）
from tensorflow import keras
from tensorflow.keras import layers
model = keras.Sequential([
    layers.Conv1D(32, 3, activation='relu', input_shape=(window_size, 3)),
    layers.MaxPooling1D(2),
    layers.Conv1D(64, 3, activation='relu'),
    layers.GlobalMaxPooling1D(),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(3, activation='softmax')
])

# 4. 量化部署
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

ESP32 推理代码：

// ESP32 Arduino 代码
#include <Wire.h>
#include <MPU6050.h>
#include <WiFi.h>
#include "model.h"
MPU6050 mpu;
TfLiteTensor* input;
TfLiteTensor* output;
#define WINDOW_SIZE 100
float accel_buffer[WINDOW_SIZE][3];
int buffer_index = 0;
void setup() {
    Wire.begin();
    mpu.initialize();
    WiFi.begin(ssid, password);
    initTFLite();
}
void loop() {
    int16_t ax, ay, az;
    mpu.getAcceleration(&ax, &ay, &az);
    accel_buffer[buffer_index][0] = ax / 16384.0;
    accel_buffer[buffer_index][1] = ay / 16384.0;
    accel_buffer[buffer_index][2] = az / 16384.0;
    buffer_index++;
    if (buffer_index >= WINDOW_SIZE) {
        for (int i = 0; i < WINDOW_SIZE; i++) {
            for (int j = 0; j < 3; j++) {
                input->data.f[i*3 + j] = accel_buffer[i][j];
            }
        }
        interpreter->Invoke();
        float normal_prob = output->data.f[0];
        float warning_prob = output->data.f[1];
        float fault_prob = output->data.f[2];
        if (fault_prob > 0.8) {
            Serial.println("检测到故障!");
            sendAlertToCloud();
        } else if (warning_prob > 0.6) {
            Serial.println("预警：设备异常");
        } else {
            Serial.println("运行正常");
        }
        buffer_index = 0;
    }
    delay(10);
}

项目 3：智能垃圾分类（视觉识别）

硬件：

- 树莓派 4B + Coral USB 加速器
- 树莓派摄像头
- 舵机（控制垃圾桶盖）

技术方案：

# 1. 模型训练（垃圾分类数据集）
import tensorflow as tf
from tensorflow.keras.applications import MobileNetV2
base_model = MobileNetV2(
    input_shape=(224, 224, 3),
    include_top=False,
    weights='imagenet'
)
base_model.trainable = False
model = tf.keras.Sequential([
    base_model,
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(4, activation='softmax')
])

# 2. Edge TPU 转换
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset_gen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
tflite_model = converter.convert()
!edgetpu_compiler model.tflite

# 3. 树莓派部署
from picamera import PiCamera
from pycoral.utils import edgetpu
from pycoral.adapters import common, classify
import RPi.GPIO as GPIO
camera = PiCamera()
interpreter = edgetpu.make_interpreter('model_edgetpu.tflite')
interpreter.allocate_tensors()
SERVO_PIN = 18
GPIO.setup(SERVO_PIN, GPIO.OUT)
pwm = GPIO.PWM(SERVO_PIN, 50)
CLASSES = ['可回收', '有害垃圾', '厨余垃圾', '其他垃圾']
while True:
    camera.capture('temp.jpg')
    image = Image.open('temp.jpg').resize((224, 224))
    common.set_input(interpreter, image)
    interpreter.invoke()
    classes = classify.get_classes(interpreter, top_k=1)
    category = CLASSES[classes[0].id]
    confidence = classes[0].score
    if confidence > 0.8:
        print(f"识别为：{category}, 置信度：{confidence:.2%}")
        open_bin(category)
    time.sleep(2)

项目 4：可穿戴健康监测

硬件：

- nRF52832（蓝牙低功耗芯片）
- MAX30102（心率血氧传感器）
- MPU6050（姿态传感器）
- 纽扣电池供电

AI 功能：

1. 心率异常检测（LSTM 时序模型）
2. 跌倒检测（加速度突变识别）
3. 睡眠质量分析（多传感器融合）

核心代码：

// nRF52 SDK 开发
#include "nrf_delay.h"
#include "max30102.h"
#include "mpu6050.h"
#include "tflite_micro.h"
#define HEART_RATE_WINDOW 60
float hr_buffer[HEART_RATE_WINDOW];
int hr_index = 0;
void main() {
    MAX30102_Init();
    MPU6050_Init();
    BLE_Init();
    TFLite_Init("heart_rate_model.tflite");
    while(1) {
        uint8_t hr = MAX30102_GetHeartRate();
        hr_buffer[hr_index++] = hr;
        int16_t ax, ay, az;
        MPU6050_GetAccel(&ax, &ay, &az);
        float accel_magnitude = sqrt(ax*ax + ay*ay + az*az);
        if (accel_magnitude > FALL_THRESHOLD) {
            SendFallAlert();
        }
        if (hr_index >= HEART_RATE_WINDOW) {
            float anomaly_score = RunHeartRateModel(hr_buffer);
            if (anomaly_score > 0.8) {
                SendHeartRateAlert();
            }
            hr_index = 0;
        }
        BLE_SendData(hr, ax, ay, az);
        nrf_delay_ms(1000);
    }
}

float RunHeartRateModel(float* data) {
    float normalized[HEART_RATE_WINDOW];
    for (int i = 0; i < HEART_RATE_WINDOW; i++) {
        normalized[i] = (data[i] - 60.0) / 40.0;
    }
    TfLiteTensor* input = interpreter->input(0);
    memcpy(input->data.f, normalized, sizeof(normalized));
    interpreter->Invoke();
    TfLiteTensor* output = interpreter->output(0);
    return output->data.f[0];
}

📱 第四阶段：高级专题（按需学习）

1. 端云协同

架构：设备端（轻量模型） + 云端（复杂模型）
场景：
- 初筛在设备，详细分析在云端
- 设备资源不足时上传云端
技术栈：
- MQTT 协议（设备 ↔ 云）
- 云平台服务
- 模型热更新（OTA）

2. 联邦学习

# 隐私保护的分布式训练
import tensorflow_federated as tff
def create_keras_model():
    return tf.keras.Sequential([
        tf.keras.layers.Dense(10, activation='relu'),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
def model_fn():
    keras_model = create_keras_model()
    return tff.learning.from_keras_model(
        keras_model, input_spec=..., loss=tf.keras.losses.SparseCategoricalCrossentropy(),
        metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]
    )
iterative_process = tff.learning.build_federated_averaging_process(model_fn)
state = iterative_process.initialize()
for round_num in range(10):
    state, metrics = iterative_process.next(state, federated_train_data)
    print(f'round {round_num}, metrics={metrics}')

3. 神经架构搜索（NAS）

# 自动设计适合嵌入式的网络结构
from keras_tuner import HyperModel, RandomSearch
class MyHyperModel(HyperModel):
    def build(self, hp):
        model = keras.Sequential()
        for i in range(hp.Int('num_layers', 1, 5)):
            model.add(layers.Conv2D(
                filters=hp.Choice(f'filters_{i}', [16, 32, 64]),
                kernel_size=3, activation='relu'
            ))
            model.add(layers.MaxPooling2D())
            model.add(layers.Flatten())
        model.add(layers.Dense(10, activation='softmax'))
        model.compile(
            optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']
        )
        return model
tuner = RandomSearch(
    MyHyperModel(), objective='val_accuracy', max_trials=50, executions_per_trial=2
)
tuner.search(train_data, train_labels, epochs=10, validation_split=0.2)
best_model = tuner.get_best_models(num_models=1)[0]

🛠️ 工具链和开发环境

必备软件

# Python 环境
conda create -n tinyml python=3.9
conda activate tinyml
pip install tensorflow==2.13
pip install tensorflow-model-optimization
pip install numpy pandas matplotlib scikit-learn

# 嵌入式开发
# STM32: STM32CubeIDE
# ESP32: Arduino IDE / ESP-IDF
# 树莓派：Raspberry Pi OS

# AI 工具
pip install edge-impulse-cli
pip install pycoral
pip install onnx onnxruntime
pip install netron

推荐硬件采购清单

入门套件：
├─ Arduino Nano 33 BLE Sense（内置 9 轴 IMU、麦克风、温湿度）
├─ ESP32-CAM（摄像头、WiFi/BT）
└─ 各种传感器套装

进阶套件：
├─ STM32H7 开发板
├─ OV2640 摄像头
├─ Coral USB Accelerator
├─ 树莓派 4B 4GB
└─ 各种模块

专业套件：
├─ Jetson Nano 4GB
├─ RealSense 深度相机
├─ Lidar 传感器
└─ 高精度 IMU

📖 学习资源汇总

在线课程

1. TinyML 课程
2. Edge AI and Computer Vision
3. 嵌入式 AI 系统

书籍

1. 《TinyML》
2. 《AI at the Edge》
3. 《嵌入式深度学习》

开源项目

1. TensorFlow Examples
2. Edge Impulse Projects
3. EloquentTinyML

论文

1. MobileNets 系列
2. EfficientNet 系列
3. YOLO-Nano

🎯 就业方向

岗位类型

1. 嵌入式 AI 工程师
2. 边缘计算工程师
3. AIoT 开发工程师
4. 计算机视觉工程师（嵌入式方向）
5. 自动驾驶感知工程师