# 第8周：人工智能应用（一）- 图像分类CNN ## Slide 1: 封面 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🎓 嵌入式与人工智能 │ │ │ │ 第8周：图像分类与CNN │ │ │ │ ───────────────────────────────────── │ │ │ │ 本周内容： │ │ • 卷积神经网络原理 │ │ • CNN为什么适合图像 │ │ • TensorFlow Lite Micro部署 │ │ │ │ 授课教师：李茂奎老师 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 2: 开场Demo - 手写数字识别 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🔢 开场Demo：手写数字识别 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 在纸上写一个数字 │ │ │ │ ↓ │ │ │ │ ┌──────────┐ │ │ │ │ │ESP32-CAM│ │ │ │ │ │ 📷 │ ← 拍摄手写数字 │ │ │ │ └────┬─────┘ │ │ │ │ │ JPEG │ │ │ │ ┌────▼─────┐ │ │ │ │ │ CNN模型 │ ← AI神经网络识别 │ │ │ │ │ │ │ │ │ │ │ 识别: 7 │ │ │ │ │ │ 置信: 96%│ │ │ │ │ └──────────┘ │ │ │ │ │ │ │ │ 现场演示：ESP32识别手写数字 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 引导语： │ │ "机器是怎么'看懂'我们写的数字的？ │ │ 今天学完CNN，你们就明白了！" │ │ │ │ 📦 物料：ESP32-CAM、纸笔 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 3: 问题导入 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ ❓ 三个问题思考 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 问题1：机器是怎么"看"图像的？ │ │ │ │ 和人眼的原理一样吗？ │ │ │ │ │ │ │ │ ───────────────────────────────────────── │ │ │ │ │ │ │ │ 问题2：什么是卷积？它和图像处理有什么关系？ │ │ │ │ │ │ │ │ ───────────────────────────────────────── │ │ │ │ │ │ │ │ 问题3：ESP32内存那么小，怎么跑得动AI模型？ │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 学习目标：掌握CNN原理 + 模型量化 + TFLite部署 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 4: 传统图像处理 vs 深度学习 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 📊 传统方法 vs 深度学习 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 传统图像处理流程： │ │ │ │ │ │ │ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌─────┐ │ │ │ │ │ 原始 │ → │ 预处理 │ → │ 人工 │ → │ 分类 │ │ │ │ │ │ 图像 │ │ 去噪 │ │ 特征 │ │ 器 │ │ │ │ │ └────────┘ │ 增强 │ │ SIFT │ └─────┘ │ │ │ │ └────────┘ │ HOG │ │ │ │ │ └────────┘ │ │ │ │ │ │ │ │ 问题：❌ 特征需要人工设计，换问题就要重新设计 │ │ │ │ ❌ 泛化能力差 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 深度学习流程： │ │ │ │ │ │ │ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌─────┐ │ │ │ │ │ 原始 │ → │ 神经 │ → │ 自动 │ → │ 分类 │ │ │ │ │ │ 图像 │ │ 网络 │ │ 学习 │ │ 结果 │ │ │ │ │ └────────┘ └────────┘ │ 特征 │ └─────┘ │ │ │ │ └────────┘ │ │ │ │ │ │ │ │ 优势：✅ 端到端学习 ✅ 特征自动学习 ✅ 泛化强 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 5: 人眼 vs 机器视觉 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 👁️ 人眼 vs 机器视觉 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 人眼工作原理： │ │ │ │ │ │ │ │ 光线 → 角膜 → 瞳孔 → 晶状体 → 视网膜 → 大脑处理 │ │ │ │ ↓ ↓ │ │ │ │ 调焦 视觉皮层 │ │ │ │ │ │ │ │ 大脑会自动识别：边缘 → 纹理 → 形状 → 物体 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 机器(CNN)工作原理： │ │ │ │ │ │ │ │ 图像 → 卷积层1 → 池化层1 → 卷积层2 → ... → 分类 │ │ │ │ ↓ ↓ │ │ │ │ 像素 边缘特征 纹理特征 语义特征 类别 │ │ │ │ │ │ │ │ 卷积核就像"滤波器"，逐层提取越来越抽象的特征 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 相似点：都是分层处理，逐步提取高级特征 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 6: 卷积操作原理 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🔬 卷积操作原理 │ │ │ │ 卷积 = 用滤波器（卷积核）在图像上滑动 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 输入图像 (5×5) 卷积核 (3×3) 输出 │ │ │ │ ┌─────────┐ ┌───────┐ ┌───┐ │ │ │ │ │ 1 2 3 1 2│ │ 1 0 1 │ │ 5 │ │ │ │ │ │ 2 1 2 1 3│ ⊗ │ 0 1 0 │ = │ 4 │ │ │ │ │ │ 3 2 1 2 1│ │ 1 0 1 │ │...│ │ │ │ │ │ 1 2 1 3 2│ └───────┘ └───┘ │ │ │ │ │ 2 1 2 1 2│ │ │ │ │ └─────────┘ │ │ │ │ ↓ │ │ │ │ 卷积核在图像上 │ │ │ │ 滑动计算加权和 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 计算过程（以左上角为例）： │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 1×1 + 2×0 + 3×1 + 2×0 + 1×1 + 2×0 + 3×1 + 2×0 + 1×1 │ │ │ │ = 1 + 0 + 3 + 0 + 1 + 0 + 3 + 0 + 1 = 9 │ │ │ │ │ │ │ │ 卷积核相当于"特征检测器"！ │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 7: 常见卷积核 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🔧 常见卷积核与效果 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 1. 边缘检测卷积核 │ │ │ │ ┌─────────┐ 结果：提取图像边缘 │ │ │ │ │-1 -1 -1 │ │ │ │ │ │-1 8 -1 │ ════════ │ │ │ │ │-1 -1 -1 │ 边缘 │ │ │ │ └─────────┘ ════════ │ │ │ │ │ │ │ │ 2. 锐化卷积核 │ │ │ │ ┌─────────┐ 结果：增强细节 │ │ │ │ │ 0 -1 0 │ │ │ │ │ │-1 5 -1 │ 细节更清晰 │ │ │ │ │ 0 -1 0 │ │ │ │ │ └─────────┘ │ │ │ │ │ │ │ │ 3. 模糊卷积核 │ │ │ │ ┌─────────┐ 结果：平滑图像 │ │ │ │ │1 1 1 1 1│ │ │ │ │ │1 1 1 1 1│ │ │ │ │ │1 1 1 1 1│ │ │ │ │ │1 1 1 1 1│ │ │ │ │ │1 1 1 1 1│ │ │ │ │ └─────────┘ ÷ 25 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 不同的卷积核 → 不同的特征提取 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 8: 池化操作 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 📦 池化层 (Pooling) │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 池化 = 降采样，压缩特征图尺寸 │ │ │ │ │ │ │ │ 最大池化 (2×2)： │ │ │ │ │ │ │ │ 输入 (4×4) 输出 (2×2) │ │ │ │ ┌─────────────┐ ┌─────────┐ │ │ │ │ │ 1 5 3 2 │ ┌──┬──┐ │ 5 6 │ │ │ │ │ │ 4 2 1 6 │ │5 │6 │ ├──────┤ │ │ │ │ │ │ → ├──┼──┤ = │ 8 4 │ │ │ │ │ │ 3 8 2 1 │ │8 │4 │ └──────┘ │ │ │ │ │ 1 2 4 3 │ └──┴──┘ │ │ │ │ └─────────────┘ │ │ │ │ 2×2分块 │ │ │ │ 每块取最大值 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 池化的作用： │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ ✓ 减少数据量，降低计算复杂度 │ │ │ │ ✓ 提取显著特征，增强鲁棒性 │ │ │ │ ✓ 控制过拟合 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 9: CNN完整结构 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🏗️ CNN完整结构 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ │ │ │ │ 输入图像 │ │ │ │ (32×32) │ │ │ │ ↓ │ │ │ │ ┌─────────┐ 28×28, 6个特征图 │ │ │ │ │ 卷积层1 │ ← 6个5×5卷积核 │ │ │ │ └────┬────┘ │ │ │ │ ↓ │ │ │ │ ┌─────────┐ 14×14, 6个特征图 │ │ │ │ │ 池化层1 │ ← 2×2最大池化 │ │ │ │ └────┬────┘ │ │ │ │ ↓ │ │ │ │ ┌─────────┐ 10×10, 16个特征图 │ │ │ │ │ 卷积层2 │ ← 16个5×5卷积核 │ │ │ │ └────┬────┘ │ │ │ │ ↓ │ │ │ │ ┌─────────┐ 5×5, 16个特征图 │ │ │ │ │ 池化层2 │ ← 2×2最大池化 │ │ │ │ └────┬────┘ │ │ │ │ ↓ │ │ │ │ ┌─────────┐ │ │ │ │ │ 全连接层 │ ← 120神经元 → 84神经元 │ │ │ │ └────┬────┘ │ │ │ │ ↓ │ │ │ │ ┌─────────┐ │ │ │ │ │ 输出层 │ ← 10类数字分类 │ │ │ │ └─────────┘ │ │ │ │ │ │ │ │ 这就是经典的 LeNet-5 网络！ │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 10: 手写数字识别流程 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🔢 手写数字识别完整流程 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 1️⃣ 输入手写数字图像 (28×28 灰度) │ │ │ │ ┌─────────────────┐ │ │ │ │ │ │ │ │ │ │ │ 手写 "7" │ │ │ │ │ │ │ │ │ │ │ └─────────────────┘ │ │ │ │ │ │ │ │ 2️⃣ CNN特征提取 │ │ │ │ 边缘 → 纹理 → 笔画 → 数字形状 │ │ │ │ │ │ │ │ 3️⃣ 分类输出 │ │ │ │ [0.01, 0.02, 0.85, 0.05, ...] │ │ │ │ 0 1 2 3 │ │ │ │ ↑ │ │ │ │ 最大概率 85%，识别为 "2" │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 为什么CNN适合图像？ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ ✓ 局部连接：每个神经元只连接局部区域 │ │ │ │ ✓ 权值共享：一个卷积核在整个图像上共享权重 │ │ │ │ ✓ 平移不变：识别物体位置不影响 │ │ │ │ ✓ 参数少：比全连接网络少几个数量级 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 11: 模型训练过程 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🎯 模型训练过程 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 训练数据：60000张带标签的手写数字图片 │ │ │ │ │ │ │ │ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ │ │ │ │ │ 0 │ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │...│ │ 9 │ │ │ │ │ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 训练步骤： │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ for each 训练样本: │ │ │ │ 1. 前向传播：输入 → CNN → 输出概率 │ │ │ │ 2. 计算损失：比较输出和真实标签的差异 │ │ │ │ 3. 反向传播：根据损失调整卷积核参数 │ │ │ │ 4. 重复直到收敛 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 训练结果： │ │ • MNIST测试准确率：>98% │ │ • 训练好的模型文件：~1MB (FP32) │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 12: 模型量化 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 📦 模型量化 (Quantization) │ │ │ │ 问题：ESP32只有512KB内存，跑不动1MB的模型 │ │ │ │ 解决：量化 = 32位浮点数 → 8位整数 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 量化前 (Float32) 量化后 (Int8) │ │ │ │ │ │ │ │ 0.5234... → 127 │ │ │ │ -0.1234... → -31 │ │ │ │ 1.2345... → 200 │ │ │ │ │ │ │ │ 每个参数：4字节 每个参数：1字节 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 量化效果： │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 模型大小： 1MB (FP32) → 256KB (Int8) │ │ │ │ ↓ 压缩75% │ │ │ │ │ │ │ │ 内存占用： 1MB → 256KB │ │ │ │ ↓ │ │ │ │ ESP32可用！ ✅ │ │ │ │ │ │ │ │ 精度损失：<1% (可接受) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 13: TensorFlow Lite Micro ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🔧 TensorFlow Lite Micro │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ TFLite Micro = TensorFlow的嵌入式版本 │ │ │ │ │ │ │ │ 支持的平台： │ │ │ │ ✓ ESP32 / ESP32-S3 │ │ │ │ ✓ Arduino │ │ │ │ ✓ STM32 │ │ │ │ ✓ Raspberry Pi Pico │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 使用流程： │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 1️⃣ 训练模型 (Python + TensorFlow) │ │ │ │ │ │ │ │ 2️⃣ 转换模型 │ │ │ │ .h5 (Keras) → .tflite → quantized.tflite │ │ │ │ │ │ │ │ 3️⃣ 生成C数组 │ │ │ │ xxd -i quantized.tflite > model.cc │ │ │ │ │ │ │ │ 4️⃣ ESP32部署 │ │ │ │ Arduino + TFLite Micro库 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 14: ESP32图像分类代码 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 💻 ESP32图像分类代码 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ #include │ │ │ │ #include "model.h" // 预训练模型参数 │ │ │ │ │ │ │ │ // 模型推断 │ │ │ │ void classifyImage(camera_fb_t *fb) { │ │ │ │ │ │ │ │ // 1. 预处理 │ │ │ │ uint8_t input[784]; // 28×28=784 │ │ │ │ convertToGrayscale(fb, input); │ │ │ │ normalize(input); │ │ │ │ │ │ │ │ // 2. 模型推理 │ │ │ │ TfLiteTensor* input = interpreter->input(0); │ │ │ │ TfLiteTensor* output = interpreter->output(0); │ │ │ │ │ │ │ │ // 复制输入数据 │ │ │ │ for (int i = 0; i < 784; i++) { │ │ │ │ input->data.uint8[i] = input[i]; │ │ │ │ } │ │ │ │ │ │ │ │ // 3. 执行推理 │ │ │ │ interpreter->Invoke(); │ │ │ │ │ │ │ │ // 4. 获取结果 │ │ │ │ int digit = argmax(output->data.uint8, 10); │ │ │ │ float conf = output->data.uint8[digit] / 255.0; │ │ │ │ │ │ │ │ Serial.printf("识别: %d, 置信度: %.1f%%\n", │ │ │ │ digit, conf * 100); │ │ │ │ } │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 15: 实验：图像分类部署 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🧪 实验：ESP32手写数字识别 │ │ │ │ 实验目的： │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 1. 掌握TFLite Micro使用方法 │ │ │ │ 2. 在ESP32-CAM上部署图像分类模型 │ │ │ │ 3. 实现手写数字识别 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 器材清单： │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ • ESP32-CAM × 1 │ │ │ │ • 纸和笔 × 1 │ │ │ │ • FTDI编程器 × 1 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 实验步骤： │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 1️⃣ 下载预训练MNIST模型（已量化） │ │ │ │ 2️⃣ Arduino IDE安装TFLite Micro库 │ │ │ │ 3️⃣ 编写代码，导入模型 │ │ │ │ 4️⃣ 烧录到ESP32-CAM │ │ │ │ 5️⃣ 在纸上写数字，摄像头对准 │ │ │ │ 6️⃣ 观察串口输出的识别结果 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ ⚠️ 注意：模型量化版本才能在ESP32上运行！ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 16: 常见问题 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ ⚠️ 常见问题与解决 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 问题1：编译报错 "Out of memory" │ │ │ │ 原因：模型太大 │ │ │ │ 解决：使用量化版本（Int8）的模型 │ │ │ │ │ │ │ │ ───────────────────────────────────────────── │ │ │ │ │ │ │ │ 问题2：识别准确率很低 │ │ │ │ 原因：数字书写不规范或光照问题 │ │ │ │ 解决：写清晰规范的数字，确保光线充足 │ │ │ │ │ │ │ │ ───────────────────────────────────────────── │ │ │ │ │ │ │ │ 问题3：推理速度很慢 │ │ │ │ 原因：模型太大或分辨率太高 │ │ │ │ 解决：减小输入分辨率，优化模型结构 │ │ │ │ │ │ │ │ ───────────────────────────────────────────── │ │ │ │ │ │ │ │ 问题4：模型推理结果不稳定 │ │ │ │ 原因：量化误差或输入预处理不一致 │ │ │ │ 解决：检查预处理步骤，确保归一化一致 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 17: 更多CNN应用 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🚀 CNN的更多应用 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 应用领域 │ 示例 │ │ │ │ ───────────────────────────────────────────── │ │ │ │ 人脸识别 │ 门禁、手机解锁 │ │ │ │ 目标检测 │ 自动驾驶行人检测 │ │ │ │ 图像分割 │ 医学影像肿瘤分割 │ │ │ │ 姿态估计 │ 动作捕捉、游戏交互 │ │ │ │ 语音识别 │ 语音转文字 │ │ │ │ 自然语言处理 │ 文本分类、机器翻译 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 经典CNN架构演进： │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ LeNet (1998) → AlexNet (2012) → ResNet │ │ │ │ 5层 → 8层 → 152层 │ │ │ │ 手写数字 → ImageNet冠军 → 更深更强 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 趋势：从云端 → 边缘（TinyML） │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 18: 本周知识总结 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ ✅ 本周核心知识点 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 1️⃣ CNN核心概念 │ │ │ │ • 卷积：滤波器提取特征 │ │ │ │ • 池化：降采样，减少计算 │ │ │ │ • 全连接：整合特征，分类输出 │ │ │ │ │ │ │ │ 2️⃣ CNN优势 │ │ │ │ • 局部连接 + 权值共享 = 参数少 │ │ │ │ • 平移不变性 = 识别位置不影响 │ │ │ │ • 端到端学习 = 特征自动提取 │ │ │ │ │ │ │ │ 3️⃣ 模型量化 │ │ │ │ • Float32 → Int8，体积减75% │ │ │ │ • 精度损失 <1% │ │ │ │ • ESP32才能运行！ │ │ │ │ │ │ │ │ 4️⃣ TFLite Micro │ │ │ │ • 嵌入式AI推理框架 │ │ │ │ • 支持ESP32/Arduino/STM32 │ │ │ │ • 流程：训练→转换→量化→部署 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 19: 课后作业 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 📝 课后作业 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 理论题（30分） │ │ │ │ ───────────────────────────────────────────── │ │ │ │ 1. 解释卷积和池化的作用。 │ │ │ │ 2. 为什么CNN比全连接网络更适合图像识别？ │ │ │ │ 3. 什么是模型量化？为什么需要量化？ │ │ │ │ │ │ │ │ ───────────────────────────────────────────── │ │ │ │ │ │ │ │ 实践题（70分） │ │ │ │ ───────────────────────────────────────────── │ │ │ │ 1. 完成ESP32手写数字识别实验。 │ │ │ │ 2. 测试不同数字（0-9）的识别准确率。 │ │ │ │ 3. 分析识别错误的数字，讨论原因（选做）。 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 提交截止：下周二上课前 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Slide 20: 下周预告 ``` ┌─────────────────────────────────────────────────────────────┐ │ │ │ 🔮 下周预告：人脸识别与MQTT │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 👤 开场Demo：AI人脸门锁 │ │ │ │ │ │ │ │ ┌──────────┐ │ │ │ │ │ESP32-CAM│ │ │ │ │ │ 📷📷📷 │ ← 拍摄人脸 │ │ │ │ └────┬─────┘ │ │ │ │ │ │ │ │ │ ┌────▼─────┐ │ │ │ │ │ 人脸识别 │ │ │ │ │ │ 身份验证 │ │ │ │ │ └────┬─────┘ │ │ │ │ │ │ │ │ │ ┌────▼─────┐ │ │ │ │ │ 继电器 │ │ │ │ │ │ 🚪开门 │ │ │ │ │ └──────────┘ │ │ │ │ │ │ │ │ 下一节课我们将学习： │ │ │ │ • 人脸检测与人脸识别 │ │ │ │ • MQTT协议 │ │ │ │ • 物联网云平台 │ │ │ │ │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 📦 需要准备：ESP32-CAM、继电器模块 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ---