最最最基本神经网络及其原理、程序

目录

1.前言

[2. 神经元概念](#2. 神经元概念)

[3. 双神经元反馈神经网络实例程序](#3. 双神经元反馈神经网络实例程序)

[4. 实例程序分析](#4. 实例程序分析)

[4.1 代码结构与功能](#4.1 代码结构与功能)

[4.2 train方法解析](#4.2 train方法解析)

[5. 总结](#5. 总结)

---

1.前言

关于神经网络基础，网上已经很多很多了，这里就笼统几句话带过。

至于为什么要写这篇博客，主要是网上关于神经网络的库太多太方便了，许多人享受着便利就遗忘了其本质，我后续将从最基础的神经网络开始搭建，一直往后学习不同神经网络结构并加以改进。

2. 神经元概念

如下，所谓神经元其实就是几个乘法运算器（乘权重）和一个加法运算器（加偏zhi），最后再经过一个激活函数得到神经元输出

也就是说，每个神经元，都有权重，偏置，激活函数类型这三个参数。

比如一个双输入的神经元，

而神经元反向传播部分的损失函数求偏导、梯度下降算法也很好理解，网上教程很多。

3. 双神经元反馈神经网络实例程序

首先确定神经网络结构，如下：

接着攥写程序：

import numpy as np
import matplotlib.pyplot as plt


def sigmoid(x):
    # Sigmoid 激活函数: f(x) = 1 / (1 + e^(-x))
    return 1 / (1 + np.exp(-x))


def deriv_sigmoid(x):
    # Sigmoid 的导数: f'(x) = f(x) * (1 - f(x))
    fx = sigmoid(x)
    return fx * (1 - fx)


def mse_loss(y_true, y_pred):
    # y_true and y_pred 都是等长度的 numpy 数组.
    return ((y_true - y_pred) ** 2).mean()


class OurNeuralNetwork:
    def __init__(self):
        # 权重（weights）
        self.w1 = np.random.normal()
        self.w2 = np.random.normal()
        self.w3 = np.random.normal()
        self.w4 = np.random.normal()
        self.w5 = np.random.normal()
        self.w6 = np.random.normal()

        # 偏移量（biases）
        self.b1 = np.random.normal()
        self.b2 = np.random.normal()
        self.b3 = np.random.normal()

    def feedforward(self, x):
        # x 是有 2个元素的 numpy 数组.
        h1 = sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
        h2 = sigmoid(self.w3 * x[0] + self.w4 * x[1] + self.b2)
        o1 = sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
        return o1

    def train(self, data, all_y_trues):
        learn_rate = 0.1
        epochs = 1000  # 对整个数据集的训练总次数
        loss_date = []

        for epoch in range(epochs):
            for x, y_true in zip(data, all_y_trues):
                # --- 进行前馈操作 (我们后面要用到这些变量)
                sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
                h1 = sigmoid(sum_h1)

                sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
                h2 = sigmoid(sum_h2)

                sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
                o1 = sigmoid(sum_o1)
                y_pred = o1

                # --- 计算偏导数.
                # --- 命名方式：d_L_d_w1 代表 "dL / dw1"，即 L对 w1求偏导
                d_L_d_ypred = -2 * (y_true - y_pred)

                # 神经元 o1
                d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1)
                d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1)
                d_ypred_d_b3 = deriv_sigmoid(sum_o1)

                d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1)
                d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1)

                # 神经元 h1
                d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1)
                d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1)
                d_h1_d_b1 = deriv_sigmoid(sum_h1)

                # 神经元 h2
                d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
                d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
                d_h2_d_b2 = deriv_sigmoid(sum_h2)

                # --- 更新权重（w）与偏移量（b）
                # 神经元 h1
                self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1
                self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2
                self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1

                # 神经元 h2
                self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3
                self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4
                self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2

                # 神经元 o1
                self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5
                self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6
                self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3

            # --- 在每10次迭代结束后计算总 loss并打印出来
            if epoch % 10 == 0:
                y_preds = np.apply_along_axis(self.feedforward, 1, data)
                loss = mse_loss(all_y_trues, y_preds)
                loss_date.append(loss)
                print("Epoch %d loss: %.3f" % (epoch, loss))
        return loss_date


# 定义数据集 data
data = np.array([
    [-2, -1],  # Alice
    [25, 6],  # Bob
    [17, 4],  # Charlie
    [-15, -6],  # Diana
])
all_y_trues = np.array([
    1,  # Alice
    0,  # Bob
    0,  # Charlie
    1,  # Diana
])

# 训练我们的神经网络!
network = OurNeuralNetwork()
lossdata = network.train(data, all_y_trues)

# 神经网络预测
emily = np.array([-7, -3])  # 128 磅, 63 英寸
frank = np.array([20, 2])  # 155 磅, 68 英寸
print("Emily: %.3f" % network.feedforward(emily))  # 0.951 - 女性
print("Frank: %.3f" % network.feedforward(frank))  # 0.039 - 男性

fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_xlabel("epoch")  # 横坐标名
ax.set_ylabel("loss")  # 纵坐标名
ax.set_title("Neural Network Loss vs. Epochs")
epoch = range(0, 1000, 10)  # 100个点
plt.plot(epoch, lossdata)  # 绘图
plt.show()

4. 实例程序分析

4.1 代码结构与功能

1. 导入库 ：导入了 numpy 用于数值计算，matplotlib 用于绘图。

2. 定义激活函数及其导数 ：实现了 sigmoid 激活函数和它的导数，用于神经元的激活。

3. 定义损失函数 ：使用均方误差（MSE）作为损失函数，用于衡量预测值与真实值之间的差异。

4. 定义神经网络类 ：OurNeuralNetwork 类实现了神经网络的结构和功能，包括初始化权重和偏移量、前向传播（feedforward）、训练（train）等方法。

5. 数据集定义 ：定义了一个简单的数据集，包含 4 个样本，每个样本有 2 个特征，以及对应的真实标签。

6. 训练神经网络 ：创建神经网络实例，调用 train 方法进行训练，输出每 10 次迭代的损失值，并保存损失数据。

7. 预测新样本 ：对两个新样本 Emily 和 Frank 进行预测，输出预测结果。

8. 绘制损失曲线 ：使用 matplotlib 绘制损失值随训练轮数变化的曲线，直观展示训练过程中的损失变化情况。

4.2 train方法解析

训练过程概览如下：

• 前向传播 ：计算输入经过各层神经元后的输出值。

• 计算损失 ：根据预测值和真实值计算均方误差损失。

• 反向传播 ：计算损失函数对各个权重和偏移量的梯度，通过链式法则逐层传递梯度。

• 更新参数 ：使用梯度下降法，根据学习率和梯度更新权重和偏移量，以最小化损失函数。

5. 总结

本文通过一个双神经元反馈神经网络实例，详细介绍了神经网络的基本概念、结构和训练过程。从神经元的定义到整个神经网络的构建和训练，再到对新样本的预测和损失曲线的绘制，全面展示了神经网络的工作原理。该实例程序是一个很好的神经网络入门示例，为深入学习神经网络奠定了基础。 我是橙色小博，关注我，在人工智能领域一起学习进步。