python代码实现

神经网络的构建，NeuralNetwork.py

import numpy as np


# layers:  A list of integers which represents the actual architecture of the feedforward
# network. For example, a value of [2,2,1] would imply that our first input layer has two nodes,
# our hidden layer has two nodes, and our final output layer has one node.

# alpha:这里我们可以指定神经网络的学习率。此值在权重更新阶段应用。


class NeuralNetwork:
    def __init__(self, layers, alpha=0.1):
        self.W = []
        self.layers = layers
        self.alpha = alpha

        # 初始化权重矩阵
        for i in np.arange(0, len(layers) - 2):
            w = np.random.randn(layers[i] + 1, layers[i + 1] + 1)
            self.W.append(w / np.sqrt(layers[i]))

            # 上述for代码解释：例如，假设layers[i] = 2, layers[i + 1] = 2。因此，我们的权值矩阵将是2x2，以连接各层之间的所有节点集。然而，在这里我们需要小心，因为我们忘记了一个重要的组成部分——偏见项。为了解释这种偏差，我们在层数[i]和层数[i + 1]上加1——这样做会改变我们的权值矩阵w，使形状3x3给定当前层的2 + 1个节点和下一层的2 + 1个节点。我们通过除以当前层中节点数量的平方根来缩放w，从而标准化每个神经元输出[57]的方差(第19行)。

        # 构造函数中需要处理的特殊情况，其中输入连接需要一个偏置项，但输出不需要
        w = np.random.randn(layers[-2] + 1, layers[-1])
        self.W.append(w / np.sqrt(layers[-2]))


    # 定义的一个对函数调试有用处的函数，主要是得到当前网络的架构层数，以及每一层的节点数
    def __repr__(self):
        # construct  and  return  a  string  that  represents  the  network

        # architecture
        return "NeuralNetwork:  {}".format("-".join(str(l) for l in self.layers))

    # 定义sigmoid激活函数
    def sigmoid(self, x):
        return 1.0 / (1 + np.exp(-x))


    # 同时我们将在反向传播过程中用到上述sigmoid函数的导数
    def sigmoid_deriv(self, x):
        return x * (1 - x)

    # 需要注意的是无论何时需要适用反向传播函数，再次注意，无论何时执行反向传播，您都希望选择一个可微的激活函数。

    # 定义一个fit函数来训练我们的神经网络
    def fit(self, X, y, epochs=1000, displayUpdate=100):
        X = np.c_[X, np.ones((X.shape[0]))]

        for epoch in np.arange(0, epochs):
            for (x, target) in zip(X, y):
                self.fit_partial(x, target)

            if epoch == 0 or (epoch + 1) % displayUpdate == 0:
                loss = self.calculate_loss(X, y)
                print("[INFO] epoch={}, loss={:.7f}".format(epoch + 1, loss))


    # 反向传播函数的核心在下面的函数中
    def fit_partial(self, x, y):
        # 初始化一个保存每层输出的网络
        A = [np.atleast_2d(x)]


        # 开始向前传播
        for layer in np.arange(0, len(self.W)):
            # 得到每层网络的权值和网络层的数据点之间的乘积
            net = A[layer].dot(self.W[layer])

            # 通过激活函数得到每层网络的输出
            out = self.sigmoid(net)

            # 将输出追加到A中
            A.append(out)

            # We start looping over every layer in the network on Line 71. The net input to the current layer
            # is computed by taking the dot product between the activation and the weight matrix (Line 76). The
            # net output of the current layer is then computed by passing the net input through the nonlinear
            # sigmoid activation function. Once we have the net output, we add it to our list of activations (Line
            # 84).

        # 进行反向传播
        error = A[-1] - y

        # 从这里开始，我们需要应用链式法则并构建我们的94 # delta ' D '列表;delta中的第一个条目是95 #，即输出层的误差乘以激活函数对输出值的导数96 #

        D = [error * self.sigmoid_deriv(A[-1])]

        # 向后传递的第一阶段是计算我们的错误，或者简单地计算我们的预测标签和地面真相标签之间的差值(第91行)。由于激活列表A中的最后一个条目包含了网络的输出，我们可以通过A[-1]访问输出预测。值y是输入数据点x的目标输出。

        #接下来，我们需要开始应用链式法则来构建delta的列表d。delta将被用来更新我们的权值矩阵，按学习速率缩放。delta列表中的第一个条目是输出层的误差乘以输出值的sigmoid的导数(第97行)。

        for layer in np.arange(len(A) - 2, 0, -1):
            delta = D[-1].dot(self.W[layer].T)
            delta = delta * self.sigmoid_deriv(A[layer])
            D.append(delta)

            # 在第103行，我们开始对网络中的每一层进行循环(忽略前面的两层，因为它们已经在第97行中被计入了)，因为我们需要反向计算每一层的增量更新。当前层的delta等于前一层的delta，用当前层的权值矩阵点乘D[-1](第109行)。为了完成delta的计算，我们通过将层的激活通过我们的s形函数的导数(第110行)来乘以它。然后，我们用刚刚计算的增量更新增量D列表(第111行)。

            # 看看这段代码，我们可以看到反向传播步骤是迭代的——我们只是从上一层取delta，用当前层的权值点乘它，然后乘以激活的导数。这个过程不断重复，直到我们到达网络的第一层。

        # 翻转D矩阵
        D = D[::-1]

        for layer in np.arange(0, len(self.W)):
            self.W[layer] += -self.alpha * A[layer].T.dot(D[layer])


    # 定义预测函数
    def predict(self, X, addBias=True):
        p = np.atleast_2d(X)
        if addBias:
            p = np.c_[p, np.ones((p.shape[0]))]

        for layer in np.arange(0, len(self.W)):
            p = self.sigmoid(np.dot(p, self.W[layer]))
        return p

    # 定义的一个计算训练集中损失的函数
    def calculate_loss(self, X, targets):
        targets = np.atleast_2d(targets)
        predictions = self.predict(X, addBias=False)
        loss = 0.5 * np.sum((predictions - targets) ** 2)

        return loss

在MINIST手写数据集上进行训练并测试，nn_mist.py

from pyimagesearch.nn import NeuralNetwork
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn import datasets


# 开始训练MINIST数据集
print("[INFO]  loading  MNIST  (sample)  dataset...")
digits = datasets.load_digits()
data = digits.data.astype("float") # 将数据集转换为float类型
data = (data - data.min()) / (data.max() - data.min())  # 作归一化处理
print("[INFO]  samples:  {},  dim:  {}".format(data.shape[0], data.shape[1]))

# 将数据集进行分分类，75%作为训练集，25%作为测试集
(trainX,  testX,  trainY,  testY)  =  train_test_split(data, digits.target,  test_size=0.25)

# 使用one-hot编码将对应的标签进行向量化
trainY  =  LabelBinarizer().fit_transform(trainY)
testY  =  LabelBinarizer().fit_transform(testY)


# 训练网络
print("[INFO]  training  network...")
nn  =  NeuralNetwork.NeuralNetwork([trainX.shape[1], 32, 16, 10]) # 初始化神经网络
print("[INFO]  {}".format(nn))
nn.fit(trainX,  trainY,  epochs=1000) # 对神经网络进行训练


# 测试网络，并标准化输出对应的一些指标
print("[INFO]  evaluating  network...")
predictions  =  nn.predict(testX)
predictions  =  predictions.argmax(axis=1)
print(classification_report(testY.argmax(axis=1),  predictions))