人工神經網路已經有無數的開源框架，比如tensorflow，caffe等，可以直接用。但最近需要做一個小樣例，把基本思想講一講，因此自己寫了一個demo，以供參考。

 

下面直接上程式碼，程式碼中有註釋，比較容易理解

ANN.py

# -*- coding:utf-8 -*-

import numpy
import random

class ANN:
    # layers為列表，其長度給出層數，包括輸入和輸出層，每個元素給出每層神經元數量
    # 例如[3, 5, 2]代表輸入引數為3，中間隱藏層有5個神經元，輸出2個結果的神經網路
    def __init__(self, layers):
        self.num_layers = len(layers)
        self.sizes = layers
        self._biases = [numpy.random.randn(y, 1) for y in layers[1:]]
        self._weights = [numpy.random.randn(y, x) for x, y in zip(layers[:-1], layers[1:])]
        
    def _sigmoid(self, z):
        return 1.0/(1.0 + numpy.exp(-z))
        
    # sigmoid函式的導數
    def _Dsigmoid(self, z):
        return self._sigmoid(z)*(1-self._sigmoid(z))
        
    # 計算輸出向量
    def calc(self, input):
        for b, w in zip(self._biases, self._weights):
            input = self._sigmoid(numpy.dot(w, input) + b)
        return input

    # 訓練神經網路
    # trainData: 訓練集
    # epochs:    訓練輪數，對trainData訓練多少輪
    # size:      訓練子集的大小
    # rate:      learning rate，學習速率，步長
    # testData:  測試集    
    def train(self, trainData, epochs, size, rate, testData=None):
        if testData: 
            n_test = len(testData)
        n = len(trainData)
        for j in range(epochs):
            random.shuffle(trainData)
            mini_batches = [trainData[k:k+size] for k in range(0, n, size)]
            for mini_bat in mini_batches:
                self._update(mini_bat, rate)
            if testData:
                error = self.test(testData)
                if (j % (epochs/10) == 0):
                    print("Epoch {0}: error = {1}".format(j, error))
            else:
                if (j % (epochs/10) == 0):
                    print("Epoch {0} complete.".format(j))
                
    def _update(self, mini_batch, rate):
        nabla_b = [numpy.zeros(b.shape) for b in self._biases]
        nabla_w = [numpy.zeros(w.shape) for w in self._weights]
        for x, y in mini_batch:
            delta_b, delta_w = self._backpropagation(x, y)
            nabla_b = [nb + db for nb, db in zip(nabla_b, delta_b)]
            nabla_w = [nw + dw for nw, dw in zip(nabla_w, delta_w)]
        self._weights = [w - (rate/len(mini_batch))*nw for w, nw in zip(self._weights, nabla_w)]
        self._biases = [b - (rate/len(mini_batch))*nb for b, nb in zip(self._biases, nabla_b)]
        
    # 後向傳播演算法
    def _backpropagation(self, x, y):
        nabla_b = [numpy.zeros(b.shape) for b in self._biases]
        nabla_w = [numpy.zeros(w.shape) for w in self._weights]
        # forward
        activation = x
        activations = [x]
        zs = []
        for b, w in zip(self._biases, self._weights):
            z = numpy.dot(w, activation) + b
            zs.append(z)
            activation = self._sigmoid(z)
            activations.append(activation)
        # backward
        delta = self._derivative(activations[-1], y) * self._Dsigmoid(zs[-1])
        nabla_b[-1] = delta
        nabla_w[-1] = numpy.dot(delta, activations[-2].transpose())
        for layer in range(2, self.num_layers):
            z = zs[-layer]
            sp = self._Dsigmoid(z)
            delta = numpy.dot(self._weights[-layer+1].transpose(), delta) * sp
            nabla_b[-layer] = delta
            nabla_w[-layer] = numpy.dot(delta, activations[-layer-1].transpose())
        return (nabla_b, nabla_w)
    
    # 計算測試集誤差，注意此時輸出一定為1維向量
    def test(self, testData):
        test_results = [(self.calc(x), self._translate(y)) for (x, y) in testData]
        err = [output - result for (output, result) in test_results]
        return sum(numpy.dot(ei.transpose(), ei) for ei in err)
    
    # 如有必要，將結果進行編碼，便於和神經網路輸出結果相比較
    # 比如經典的手寫識別，就需要把數字y轉化為向量
    def _translate(self, y):
        return y
        
    # 整個神經網路的導數
    def _derivative(self, output, y):
        return output - y
 

可以看到，得益於numpy的矩陣運算，程式碼非常簡單。

 

下面是測試，使用上面的程式碼擬合and函式

test.py

# -*- coding:utf-8 -*-

import ANN

layers = [2, 2, 2]
input = numpy.array([[0,0],[0,1],[1,0],[1,1]])
out = numpy.array([[1,0],[1,0],[1,0],[0,1]])

inputs = [numpy.reshape(i, (2,1)) for i in input]
outputs = [numpy.reshape(o, (2,1)) for o in out]

data = [(inputs[i], outputs[i]) for i in range(len(inputs))]
net = ANN.ANN(layers)
net.train(data, 50000, len(inputs), 0.1, data)
for i in range(len(inputs)):
    print(inputs[i].T, ": ", net.calc(inputs[i]).T)
 

可以看到，構造了一個2x2x2的神經網路，輸入為2位，輸出為2位，中間層也為2個神經元，即可通過訓練獲得相應的and函式。需要注意的是numpy構造的向量必須和ANN.py中風格一致（如果第一個指標代表行，第二個指標代表列，則輸入輸出均必須為列向量）。計算結果如下：

相關推薦