神经网络的基本工作原理——机器学习

目录

​编辑

一、实验内容

二、实验过程

1、算法思想

2、算法原理

3、算法分析

三、源程序代码

四、运行结果及分析

 五、实验总结

---

一、实验内容

---

1. 掌握神经元细胞的数学模型；
2. 理解并掌握神经网络的训练过程；
3. 理解并掌握神经网络中的矩阵运算；
4. 理解三大概念-反向传播，梯度下降，损失函数；
5. 理解神经网络的主要功能。

二、实验过程

---

1、算法思想

---

        人工神经网络是由简单神经元经过相互连接形成网状结构，通过调节各连接的权重值改变连接的强度，进而实现感知判断。

2、算法原理

---

        神经元是神经网络的基本计算单元，也被称作节点或者单元。它可以接受来自其他神经元的输入或者是外部的数据，然后计算一个输出。

        每个输入值都有一个权重,权重的大小取决于这个输入相比于其他输入值的重要性。然后在神经元上执行一个特定的函数 f, 这个函数会该神经元的所有输入值以及其权重进行一个操作。

        传统神经网络结构比较简单，训练时随机初始化输入参数，并开启循环计算输出结果，与实际结果进行比较从而得到损失函数，并更新变量使损失函数结果值极小，当达到误差阈值时即可停止循环。算法原理是在外界输入样本的刺激下不断改变网络的连接权值。

3、算法分析

---

        前馈神经网络是一种单向多层的网络结构，即信息是从输入层开始，逐层向一个方向传递，一直到输出层结束。

        所谓的“前馈”是指输入信号的传播方向为前向，在此过程不调整各层的权值参数

        而反传播时时将误差逐层向后传播，从而实现使用权值参数对特征的记忆，即通过反向传播（BP）算法来计算各层网络中神经元之间边的权重。BP算法具有非线性映射能力，理论上可以逼近任意连续函数，从而实现对模型的学习。

三、源程序代码

---

import numpy as np
 
 
def sigmoid(x):
    # Sigmoid activation function: f(x) = 1 / (1 + e^(-x))
    return 1 / (1 + np.exp(-x))
 
 
def deriv_sigmoid(x):
    # Derivative of sigmoid: f'(x) = f(x) * (1 - f(x))
    fx = sigmoid(x)
    return fx * (1 - fx)
 
 
def mse_loss(y_true, y_pred):
    # y_true和y_pred是相同长度的numpy数组。
    return ((y_true - y_pred) ** 2).mean()
 
 
class OurNeuralNetwork:
    '''
    A neural network with:
      - 2 inputs
      - a hidden layer with 2 neurons (h1, h2)
      - an output layer with 1 neuron (o1)
    *** 免责声明 ***:
      下面的代码是为了简单和演示，而不是最佳的。
      真正的神经网络代码与此完全不同。不要使用此代码。
      相反，读/运行它来理解这个特定的网络是如何工作的。
    '''
 
    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个元素的数字数组。
        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):
        '''
        - data is a (n x 2) numpy array, n = # of samples in the dataset.
        - all_y_trues is a numpy array with n elements.
          Elements in all_y_trues correspond to those in data.
        '''
        learn_rate = 0.1
        epochs = 1000  # 遍历整个数据集的次数
 
        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
 
                # --- 计算偏导数。
                # --- Naming: d_L_d_w1 represents "partial L / partial w1"
                d_L_d_ypred = -2 * (y_true - y_pred)
 
                # Neuron 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)
 
                # Neuron 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)
 
                # Neuron 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)
 
                # --- 更新权重和偏差
                # Neuron 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
 
                # Neuron 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
 
                # Neuron 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
 
            # --- 在每次epoch结束时计算总损失
            if epoch % 100 == 0:
                y_preds = np.apply_along_axis(self.feedforward, 1, data)
                loss = mse_loss(all_y_trues, y_preds)
                print("Epoch %d loss: %.3f" % (epoch, loss))
 
 
# 定义数据集
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()
network.train(data, all_y_trues)

四、运行结果及分析

---

可以看出损失值随着学习率而变化

 五、实验总结

---

        神经网络的主要工作是建立模型和确定权值，一般有前向型和反馈型两种网络结构。

        通常神经网络的学习和训练需要一组输入数据和输出数据对，选择网络模型和传递、训练函数后，神经网络计算得到输出结果，根据实际输出和期望输出之间的误差进行权值的修正，在网络进行判断的时候就只有输入数据而没有预期的输出结果。

        神经网络一个相当重要的能力是其网络能通过它的神经元权值和阈值的不断调整从环境中进行学习，直到网络的输出误差达到预期的结果。