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

【实验目的】

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

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

【实验内容】

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），请判断这三只蚊子的类型。

【实验报告要求】

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

 【代码如下】

import numpy as np

data = np.loadtxt("./data.txt")
data1 = np.array(data.T)
# print(data)
# len(data[1]) 15
weight = np.array([0.5] * 15)


# print(weight)

def sigmoid(x):
    return 1 / (1 + np.exp(-x))


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


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


class OurNeurlNetwork():
    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.w5 * 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.w5 * 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_y_pred = -2 * (y_true - y_pred)
                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)

                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_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)
                self.w1 -= learn_rate * d_L_y_pred * d_ypred_d_h1 * d_h1_d_w1
                self.w2 -= learn_rate * d_L_y_pred * d_ypred_d_h1 * d_h1_d_w2
                self.b1 -= learn_rate * d_L_y_pred * d_ypred_d_h1 * d_h1_d_b1
                self.w3 -= learn_rate * d_L_y_pred * d_ypred_d_h2 * d_h2_d_w3
                self.w4 -= learn_rate * d_L_y_pred * d_ypred_d_h2 * d_h2_d_w4
                self.b2 -= learn_rate * d_L_y_pred * d_ypred_d_h2 * d_h2_d_b2
                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))



if __name__ == '__main__':
    data = np.loadtxt("./data.txt")
    data1 = np.array(data)
    all_y_trues = np.array([
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
    ])
    network = OurNeurlNetwork()
    network.train(data, all_y_trues)
    #预测1：
    kind1 = np.array([1.24,1.80])
    score1 = network.feedforward(kind1)
    if(score1<=0.5):
        print("kind1 is apf,score1 is %.3f"%score1)
    else:
        print("kind1 is af,score1 is %.3f"%score1)
    #预测2：
    kind2 = np.array([1.28, 1.84])
    score2 = network.feedforward(kind2)
    if (score2 <= 0.5):
        print("kind2 is apf,score2 is %.3f" % score2)
    else:
        print("kind2 is af,score2 is %.3f" % score2)
    #预测3：
    kind3 = np.array([1.40, 2.04])
    score3 = network.feedforward(kind3)
    if (score3 <= 0.5):
        print("kind3 is apf,score3 is %.3f" % score3)
    else:
        print("kind3 is af,score3 is %.3f" % score3)

【预测结果如下】

 

神经网络的应用场景：

• 数据压缩
• 模式识别
• 计算机视觉
• 声纳目标识别
• 语音识别
• 手写字符识别