ESP32开发进阶: 训练神经网络

最新推荐文章于 2024-09-14 08:18:58 发布
最新推荐文章于 2024-09-14 08:18:58 发布
阅读量193 收藏
点赞数 1
分类专栏： ESP32开发进阶 文章标签： 机器学习 深度学习 边缘计算 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53529450/article/details/140695918
版权

一、网络设定

        我们设定一个简单的前馈神经网络，其结构如下：

  1. 输入层：节点数：2，接收输入数据，每个输入样本包含2个特征，例如 {1.0, 0.0}, {0.0, 1.0} 等。

  2. 隐藏层：节点数：2，处理和提取输入数据的特征，

    1. 激活函数:使用 Sigmoid 激活函数 sigmoid(x) = 1 / (1 + exp(-x))

    2. 权重矩阵（Weights from Input to Hidden）：

      float weights_input_hidden[INPUT_NODES][HIDDEN_NODES] = {
  {0.15, 0.25},
  {0.20, 0.30}
};

      这是一个 2x2 的权重矩阵，用于连接输入层和隐藏层。

    3. 偏置（Biases for Hidden Layer）：

      float bias_hidden[HIDDEN_NODES] = {0.35, 0.35};

      这是一个包含2个偏置值的数组，分别对应每个隐藏层节点。

    4. 每个隐藏层节点计算如下：

      h_j = sigmoid\left(\sum_{i=1}^{n} (x_i \cdot w_{ij} + b_j)\right)

      其中 x_i是输入节点值，w_{ij}是权重，b_j是偏置。

  3. 输出层：节点数：1，给出最终的预测结果。

    1. 激活函数：使用 Sigmoid 激活函数

    2. 权重矩阵：

      float weights_hidden_output[HIDDEN_NODES][OUTPUT_NODES] = {
  {0.40},
  {0.50}
};

      这是一个 2x1 的权重矩阵，用于连接隐藏层和输出层。

    3. 偏置：

      float bias_output[OUTPUT_NODES] = {0.60};
      这是一个包含1个偏置值的数组，分别对应每个隐藏层节点。
    4. 输出层节点计算如下：y = sigmoid\left(\sum_{j=1}^{m} (h_j \cdot w_{jo} + b_o)\right)其中 h_j是隐藏层节点值，w_{jo}是权重，b_o 是偏置。

        整体网络设定如下图所示：

二、Arduino端代码

        首先，是初始化部分（权重和偏置的定义）

float weights_input_hidden[INPUT_NODES][HIDDEN_NODES] = {
  {0.15, 0.25},
  {0.20, 0.30}
};

float weights_hidden_output[HIDDEN_NODES][OUTPUT_NODES] = {
  {0.40},
  {0.50}
};

float bias_hidden[HIDDEN_NODES] = {0.35, 0.35};
float bias_output[OUTPUT_NODES] = {0.60};

        接着，前向传播通过计算每一层的加权输入和激活输出来推断输入样本的预测值。

void forward_propagation(float input[]) {
  for (int i = 0; i < INPUT_NODES; i++) {
    input_layer[i] = input[i];
  }

  for (int j = 0; j < HIDDEN_NODES; j++) {
    hidden_layer[j] = 0;
    for (int i = 0; i < INPUT_NODES; i++) {
      hidden_layer[j] += input_layer[i] * weights_input_hidden[i][j];
    }
    hidden_layer[j] += bias_hidden[j];
    hidden_layer[j] = sigmoid(hidden_layer[j]);
  }

  for (int k = 0; k < OUTPUT_NODES; k++) {
    output_layer[k] = 0;
    for (int j = 0; j < HIDDEN_NODES; j++) {
      output_layer[k] += hidden_layer[j] * weights_hidden_output[j][k];
    }
    output_layer[k] += bias_output[k];
    output_layer[k] = sigmoid(output_layer[k]);
  }
}

        最后，反向传播通过计算误差并根据误差调整权重和偏置，以最小化损失函数。

void backward_propagation(float input[], float target) {
  float output_error = target - output_layer[0];
  float output_delta = output_error * sigmoid_derivative(output_layer[0]);

  float hidden_error[HIDDEN_NODES];
  float hidden_delta[HIDDEN_NODES];

  for (int j = 0; j < HIDDEN_NODES; j++) {
    hidden_error[j] = output_delta * weights_hidden_output[j][0];
    hidden_delta[j] = hidden_error[j] * sigmoid_derivative(hidden_layer[j]);
  }

  for (int j = 0; j < HIDDEN_NODES; j++) {
    weights_hidden_output[j][0] += learning_rate * output_delta * hidden_layer[j];
  }
  bias_output[0] += learning_rate * output_delta;

  for (int i = 0; i < INPUT_NODES; i++) {
    for (int j = 0; j < HIDDEN_NODES; j++) {
      weights_input_hidden[i][j] += learning_rate * hidden_delta[j] * input_layer[i];
    }
  }
  for (int j = 0; j < HIDDEN_NODES; j++) {
    bias_hidden[j] += learning_rate * hidden_delta[j];
  }
}

        定义四组输入样本及其目标输出，用于训练神经网络, 通过多次迭代训练神经网络，并在每次训练后输出当前的权重和F1-score。完整代码如下:

#include <Arduino.h>
#include <cmath>

// 定义神经网络结构
#define INPUT_NODES 2
#define HIDDEN_NODES 2
#define OUTPUT_NODES 1

// 定义神经网络参数
float input_layer[INPUT_NODES];
float hidden_layer[HIDDEN_NODES];
float output_layer[OUTPUT_NODES];

float weights_input_hidden[INPUT_NODES][HIDDEN_NODES] = {
  {0.15, 0.25},
  {0.20, 0.30}
};

float weights_hidden_output[HIDDEN_NODES][OUTPUT_NODES] = {
  {0.40},
  {0.50}
};

float bias_hidden[HIDDEN_NODES] = {0.35, 0.35};
float bias_output[OUTPUT_NODES] = {0.60};

float learning_rate = 0.1;

// 激活函数和其导数（sigmoid）
float sigmoid(float x) {
  return 1.0 / (1.0 + exp(-x));
}

float sigmoid_derivative(float x) {
  return x * (1.0 - x);
}

// 计算预测值
void forward_propagation(float input[]) {
  for (int i = 0; i < INPUT_NODES; i++) {
    input_layer[i] = input[i];
  }

  for (int j = 0; j < HIDDEN_NODES; j++) {
    hidden_layer[j] = 0;
    for (int i = 0; i < INPUT_NODES; i++) {
      hidden_layer[j] += input_layer[i] * weights_input_hidden[i][j];
    }
    hidden_layer[j] += bias_hidden[j];
    hidden_layer[j] = sigmoid(hidden_layer[j]);
  }

  for (int k = 0; k < OUTPUT_NODES; k++) {
    output_layer[k] = 0;
    for (int j = 0; j < HIDDEN_NODES; j++) {
      output_layer[k] += hidden_layer[j] * weights_hidden_output[j][k];
    }
    output_layer[k] += bias_output[k];
    output_layer[k] = sigmoid(output_layer[k]);
  }
}

// 更新权重和偏置
void backward_propagation(float input[], float target) {
  float output_error = target - output_layer[0];
  float output_delta = output_error * sigmoid_derivative(output_layer[0]);

  float hidden_error[HIDDEN_NODES];
  float hidden_delta[HIDDEN_NODES];

  for (int j = 0; j < HIDDEN_NODES; j++) {
    hidden_error[j] = output_delta * weights_hidden_output[j][0];
    hidden_delta[j] = hidden_error[j] * sigmoid_derivative(hidden_layer[j]);
  }

  for (int j = 0; j < HIDDEN_NODES; j++) {
    weights_hidden_output[j][0] += learning_rate * output_delta * hidden_layer[j];
  }
  bias_output[0] += learning_rate * output_delta;

  for (int i = 0; i < INPUT_NODES; i++) {
    for (int j = 0; j < HIDDEN_NODES; j++) {
      weights_input_hidden[i][j] += learning_rate * hidden_delta[j] * input_layer[i];
    }
  }
  for (int j = 0; j < HIDDEN_NODES; j++) {
    bias_hidden[j] += learning_rate * hidden_delta[j];
  }
}

// 计算F1-score
float compute_f1_score(float tp, float fp, float fn) {
  float precision = tp / (tp + fp);
  float recall = tp / (tp + fn);
  return 2 * (precision * recall) / (precision + recall);
}

void print_weights() {
  Serial.println("Weights Input-Hidden:");
  for (int i = 0; i < INPUT_NODES; i++) {
    for (int j = 0; j < HIDDEN_NODES; j++) {
      Serial.printf("w[%d][%d] = %f ", i, j, weights_input_hidden[i][j]);
    }
    Serial.println();
  }

  Serial.println("Weights Hidden-Output:");
  for (int j = 0; j < HIDDEN_NODES; j++) {
    Serial.printf("w[%d][0] = %f ", j, weights_hidden_output[j][0]);
  }
  Serial.println();
}

void setup() {
  // 初始化串口
  Serial.begin(115200);
  while (!Serial) {}

  // 打印欢迎信息
  Serial.println("Hello, ESP32 Neural Network with Training!");
}

void loop() {
  // 输入样本和目标
  float input[][INPUT_NODES] = {{1.0, 0.0}, {0.0, 1.0}, {1.0, 1.0}, {0.0, 0.0}};
  float target[] = {1.0, 1.0, 0.0, 0.0};

  // 初始化统计量
  float tp = 0, fp = 0, fn = 0;

  // 训练
  for (int epoch = 0; epoch < 1000; epoch++) {
    for (int i = 0; i < 4; i++) {
      forward_propagation(input[i]);
      backward_propagation(input[i], target[i]);

      // 更新统计量
      float prediction = output_layer[0] > 0.5 ? 1.0 : 0.0;
      if (prediction == 1.0 && target[i] == 1.0) {
        tp++;
      } else if (prediction == 1.0 && target[i] == 0.0) {
        fp++;
      } else if (prediction == 0.0 && target[i] == 1.0) {
        fn++;
      }
    }

    // 打印权重和F1-score
    Serial.printf("Epoch %d\n", epoch);
    print_weights();
    float f1_score = compute_f1_score(tp, fp, fn);
    Serial.printf("F1-Score: %f\n", f1_score);

    // 重置统计量
    tp = 0;
    fp = 0;
    fn = 0;

    // 延迟一段时间
    delay(100);
  }

  // 停止程序
  while (true) {}
}

        部分打印结果如下：

nnerddboy
关注
专栏目录
订阅专栏
基于 tensorflow.js 与 vue 开发的Excel数据神经网络训练平台.zip
02-18
包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【项目质量】： 所有源码都经过严格测试，可以直接运行。 功能在确认正常工作后才上传。 【适用人群】...
【ESP32】手势识别实现笔记：红外温度阵列 | 双三次插值 | 神经网络 | TensorFlow | ESP-DL
npc666666的博客
11-30 2639
到这一步就可以开发了，为了项目条理更加清晰，还需要引入【自定义组件一般而言，自定义组件可以简单理解为一个目录，里面存放一些功能函数，提供给main函数进行调用。打开终端，切换到待创建的目录，输入；（当然可以手动创建目录和文件）components：创建的组件(目录)，位于那个目录下，如果没有这个目录就创建，Cmake管理默认的目录名称叫components，如果起了其它名称，需要用变量进行说明。set(EXTRA_COMPONENT_DIRS ./新名字)led：组件的名称。---Test。
[ESP32]：TFLite Micro推理CIFAR10模型
LINKKEEE的博客
04-26 612
[ESP32]：TFLite Micro推理CIFAR10模型
ESP32神经网络初步使用
andylauren的专栏
08-20 818
本文档描述了如何使用Python和TensorFlow训练一个简单的神经网络模型来预测正弦函数，并将其部署到ESP32微控制器上。
Python-ESPNetv2一个轻量级高效率通用卷积神经网络
08-11
ESPNetv2: 一个轻量级，高效率，通用卷积神经网络
整活时间，通过ncnn在esp32c3上部署神经网络
weixin_45725336的博客
05-29 1022
这篇文章的起因是在b站刷到这个视频，《9块9包邮的单片机就能跑深度学习》,最近也学了ncnn，所以开始整活，主要是在esp32c3的单片机上部署了两层的简单网络来进行minist数据集的识别。
最简单体验TinyML、TensorFlow Lite——ESP32跑机器学习（全代码）
热门推荐
全栈O-Jay的博客
08-12 1万+
最详细、通俗、简单地带你从0到1实现TinyML第一个项目。基于tensorflowlite、python、esp32的嵌入式机器学习。
ESP32教程
明耀的博客
10-19 1267
ESP32教程
单片机温度控制系统进阶：神经网络算法在温度控制中的应用，引领温度控制技术变革
[单片机温度控制系统进阶：神经网络算法在温度控制中的应用，引领温度控制技术变革](https://img-blog.csdnimg.cn/83b34da79ceb43e89ecf7d1d57945dd7.png) # 1. 单片机温度控制系统概述 单片机温度控制系统是一种...
NorthernLight-ESP32:基于ESP32的边缘机器学习监控
03-27
NorthernLight-ESP32:基于ESP32的边缘机器学习监控
ESP32-IDF.rar
10-14
官方EPS32-IDF 最新版。需要的 可以随时下载， 文件中有链接和密码，
神经网络超参数
12-30
深度学习网络的超参数学习论文，文中介绍了深度学习的超参数该根据什么因素进行选择
基于tf1框架的神经网络训练流程.zip
02-17
包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【项目质量】： 所有源码都经过严格测试，可以直接运行。 功能在确认正常工作后才上传。 【适用人群】...
基于膨胀卷积神经网络（Dilated Convolutions）训练好的医疗命名实体识别工具.zip
02-17
包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【项目质量】： 所有源码都经过严格测试，可以直接运行。 功能在确认正常工作后才上传。 【适用人群】...
ESP32 & Tensorflow Lite （二）TensorFlow Lite Hello World
InfiniteYuan
01-10 4440
这篇文章将介绍使用 TensorFlow Lite for Microcontrollers 的基础知识。它包括训练模型，将其转换为 TensorFlow Lite 版本使用以及在微控制器上运行的完整的端到端工作流程。
ESP32-TinyML：探索微型机器学习的新领域
最新发布
gitblog_00477的博客
09-14 296
ESP32-TinyML：探索微型机器学习的新领域 ESP32-TinyML Exploring TinyML with ESP32 MCUs. 项目地址: https://gitcode.com/gh_mirrors/es/E...
ESP32机器学习最邻近算法
跨学科知识视角展现
05-20 507
本教程介绍了如何使用ESP32机器学习。 更详细地介绍了如何使用ESP32 KNN分类器根据对象的颜色对其进行分类。 KNN分类器 为了更好地理解我们将要构建的项目，了解分类器的工作方式很有用。 简而言之，KNN代表k最近邻算法。 该算法属于监督机器学习算法。 KNN假设相似的物体彼此靠近。 KNN尝试为对象分配标签，以测量其与训练阶段看到的其他标签的相似程度。 因此，在此ESP32 KNN机器学习示例中，我们有两个不同的阶段： 第一阶段，我们训练算法，以便可以识别相似之处 我们将算法应用于对象以进行识别
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值