实验四：神经网络算法实验

【实验目的】

理解神经网络原理，掌握神经网络前向推理和后向传播方法；

掌握神经网络模型的编程实现方法。

【实验内容】

1. 1981年生物学家格若根（W.Grogan）和维什（W.Wirth）发现了两类蚊子（或飞蠓midges），他们测量了这两类蚊子每个个体的翼长和触角长，数据如下：

翼长 触角长 类别
1.78 1.14 Apf
1.96 1.18 Apf
1.86 1.20 Apf
1.72 1.24 Apf
2.00 1.26 Apf
2.00 1.28 Apf
1.96 1.30 Apf
1.74 1.36 Af
1.64 1.38 Af
1.82 1.38 Af
1.90 1.38 Af
1.70 1.40 Af
1.82 1.48 Af
1.82 1.54 Af
2.08 1.56 Af

现有三只蚊子的相应数据分别为（1.24，1.80）、（1.28，1.84）、（1.40，2.04），请判断这三只蚊子的类型。

【实验报告要求】

1. 建立三层神经网络模型，编写神经网络训练的推理的代码，实现类型预测；
2. 对照实验内容，撰写实验过程、算法及测试结果，程序不得使用sklearn库；
3. 代码规范化：命名规则、注释；
4. 查阅文献，讨论神经网络的应用场景。

实验步骤：

# python3
# -- coding: utf-8 --
# -------------------------------
# @Author : LiMinG
# @Email : [email protected]
# -------------------------------
# @File : 实验四：神经网络算法实验.py
# @Software : PyCharm
# @Time : 2022/11/16 18:34
# -------------------------------

import numpy as np


# sigmoid函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))  # f(x)=1/(1+exp(-x))


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


def mse_loss(y_true, y_pred):
    return ((y_true - y_pred) ** 2).mean()


class OurNeuralNetwork:
    def __init__(self):
        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()
        self.b1 = np.random.normal()  # 截距项
        self.b2 = np.random.normal()
        self.b3 = np.random.normal()

    def feedforward(self, x):
        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
        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_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
                if epoch % 10 == 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([
    [1.78, 1.14],
    [1.96, 1.18],
    [1.86, 1.20],
    [1.72, 1.24],
    [2.00, 1.26],
    [2.00, 1.28],
    [1.96, 1.30],
    [1.74, 1.36],
    [1.64, 1.38],
    [1.82, 1.38],
    [1.90, 1.38],
    [1.70, 1.40],
    [1.82, 1.48],
    [1.82, 1.54],
    [2.08, 1.56],
])
# 类别:Apf 1, Af 0
all_y_trues = np.array([
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
])
network = OurNeuralNetwork()
network.train(data, all_y_trues)
test1 = np.array([1.24, 1.80])
test2 = np.array([1.28, 1.84])
test3 = np.array([1.40, 2.04])
print("test1: %.3f" % network.feedforward(test1))
print("test2: %.3f" % network.feedforward(test2))
print("test3: %.3f" % network.feedforward(test3))

输出测试的结果：

test1: 0.005
test2: 0.005
test3: 0.005

如果概率大于0.5则类型为Apf，小于0.5则类型为Af

有输出的预测结果知预测三只蚊子的类型为Af

神经网络的应用场景：

1. 人脸识别：人脸识别需要将一幅图像与保存的人脸数据库进行比较，以识别所输入图片中的人。人脸检测机制包括将图像分为两部分：一个包含目标（人脸），另一个提供背景。
2. 命名实体识别（Name Entity recognition，NER）：命名实体识别的主要任务是将命名实体（如Ram，Google，India等）按预定义的类别（如人，组织，地点，时间，日期等）进行分类。目前已经创建了许多NER系统，其中表现最好的使用了神经网络。
3. 语音识别：在家庭自动化，移动电话，虚拟辅助，无人工干预计算，视频游戏等领域有着广泛的应用，神经网络在这方面有着广泛的应用。
4. 签名验证：签名验证技术是一种基于非视觉的技术，对于这个应用，首先要提取签名的特征，或者说是几何特征集，利用这些特征集，我们必须使用一种有效的神经网络算法训练神经网络，训练好的神经网络在验证阶段区分签名的真伪。
5. 语义检测：语义检测决定了两个句子是否具有相同的意思，这一任务对于问答系统来说尤其重要，因为有很多方式来问同一个问题。