Python3 反向传播神经网络-Min-Batch(根据吴恩达课程讲解编写)

 # -*- coding: utf-8 -*-
 """
 Created on Sat Jan 20 13:47:54 2018

 @author: markli
 """
 import numpy as np;
 import random;

 def tanh(x):
     return np.tanh(x);

 def tanh_derivative(x):
     return 1.0 - np.tanh(x)*np.tanh(x);

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

 def logistic_derivative(x):
     return logistic(x)*(1-logistic(x));

 def ReLU(x,a=1):
     return max(0,a * x);

 def ReLU_derivative(x,a=1):
     return 0 if x < 0 else a;

 class NeuralNetwork:
     '''
     Z = W * x + b
     A = sigmod(Z)
     Z 净输入
     x 样本集合 m * n n 个特征 m 个样本数量
     b 偏移量
     W 权重
     A 净输出
     '''
     def __init__(self,layers,active_function=[logistic],active_function_der=[logistic_derivative],learn_rate=0.9):
         self.weights = [2*np.random.randn(x,y)-1 for x,y in zip(layers[1:],layers[:-1])]; #weight 取值范围（-1,1）
         self.B = [2*np.random.randn(x,1)-1 for x in layers[1:]]; #b 取值范围（-1,1）
         self.learnRate = learn_rate;
         self.size = len(layers);
         self.sigmoids = [];
         self.sigmoids_der = [];
         for i in range(len(layers)-1):
             if(len(active_function) == self.size-1):
                 self.sigmoids = active_function;
             else:
                 self.sigmoids.append(active_function[0]);
             if(len(active_function_der)== self.size-1):
                 self.sigmoids_der = active_function_der;
             else:
                 self.sigmoids_der.append(active_function_der[0]);

     '''后向传播算法'''
     def BackPropgation(self,X,Y):
         """
         X size*n 维，size大小为Mini_Batch_size 值大小,n 个特征
         Y size*l 维，size大小为Mini_Batch_sieze 值大小，l 个类标签
         一次计算size个样本带来的w,b的变化量
         """
         deltb = [np.zeros(b.shape) for b in self.B];
         deltw = [np.zeros(w.shape) for w in self.weights];

         active = np.transpose(X);
         actives = [active];
         zs = [];
         i=0;
         #前向传播
         for w,b in zip(self.weights,self.B):
             z = np.dot(w,active) + b;
             zs.append(z);
             active = self.sigmoids[i](z);
             actives.append(active);
             i = i+1;

         Y = np.transpose(Y); #转置
         cost = self.cost(actives[-1], Y) #成本函数 计算对a的一阶导数
         z = zs[-1];
         delta = np.multiply(cost,self.sigmoids_der[-1](z)); #计算输出层(最后一层)的变化量
         deltb[-1] = np.sum(delta,axis=1,keepdims=True); #计算输出层(最后一层)b的size次累计变化量 l*1 维
         deltw[-1] = np.dot(delta, np.transpose(actives[-2]));#计算输出层(最后一层)w的size次累计变化量 x*l 维
         for i in range(2,self.size):
             z = zs[-i]; #当前层的z值
             sp = self.sigmoids_der[-i](z); #对z的偏导数值
             delta = np.multiply(np.dot(np.transpose(self.weights[-i+1]), delta), sp); #求出当前层的误差
             #deltb = delta;
             deltb[-i] = np.sum(delta,axis=1,keepdims=True); #当前层b的size次累计变化量 l*1 维
             deltw[-i] = np.dot(delta, np.transpose(actives[-i-1])); # 当前层w的size次累计变化量 x*l

         return deltw,deltb;

     def fit(self,X,Y,mini_batch_size,epochs=1000):

         N = len(Y);
         for i in range(epochs):
             randomlist = np.random.randint(0,N-mini_batch_size,int(N/mini_batch_size));
             batch_X = [X[k:k+mini_batch_size] for k in randomlist];
             batch_Y = [Y[k:k+mini_batch_size] for k in randomlist];
             for m in range(len(batch_Y)):
                 deltw,deltb = self.BackPropgation(batch_X[m],batch_Y[m]);
                 self.weights = [w - (self.learnRate / mini_batch_size) * dw for w,dw in zip(self.weights,deltw)];
                 self.B = [b - (self.learnRate / mini_batch_size) * db for b,db in zip(self.B,deltb)];
 #        path = sys.path[0];
 #        with open(path,'w',encoding='utf8') as f:
 #            for j in range(len(self.weights)-1):
 #                f.write(self.weights[j+1]);
 #                f.write(self.activeFunction[j+1]);
 #                f.write(self.activeFunctionDer[j+1]);
 #        f.close();

     def predict(self,x):
         """前向传播"""
         i = 0;
         for b, w in zip(self.B, self.weights):
             x = self.sigmoids[i](np.dot(w, x)+b);
             i = i + 1;
         return x

     def cost(self,a,y):
         """
         损失函数对z的偏导数的除输出层对z的导数的因子部分
         完整表达式 为 （a - y）* sigmod_derivative(z)
         由于此处不知道输出层的激活函数故不写出来，在具体调用位置加上
         """
         return a-y;

该算法按照吴恩达先生讲述的BP神经网络算法编写，实现了一次进行Mini_Batch_size 次的训练。下面给出测试代码和测试结果。

 import numpy as np
 from sklearn.datasets import load_digits
 from sklearn.metrics import confusion_matrix, classification_report
 from sklearn.preprocessing import LabelBinarizer
 from FullNeuralNetwork import  NeuralNetwork
 from sklearn.cross_validation import train_test_split

 digits = load_digits();
 X = digits.data;
 y = digits.target;
 X -= X.min(); # normalize the values to bring them into the range 0-1
 X /= X.max();

 nn = NeuralNetwork([64,100,10]);
 X_train, X_test, y_train, y_test = train_test_split(X, y);
 labels_train = LabelBinarizer().fit_transform(y_train);
 labels_test = LabelBinarizer().fit_transform(y_test);

 # X_train.shape (1347,64)
 #y_train.shape(1347)
 #labels_train.shape (1347,10)
 #labels_test.shape(450,10)

 print ("start fitting");

 #print(Data);
 nn.fit(X_train,labels_train,epochs=500,mini_batch_size=8);
 result = nn.predict(X_test.T);
 predictions = [np.argmax(result[:,y]) for y in range(result.shape[1])];

 print(predictions);
 #for i in range(result.shape[1]):
 #    y = result[:,i];
 #    predictions.append(np.argmax(y));
 ##print(np.atleast_2d(predictions).shape);
 print (confusion_matrix(y_test,predictions));
 print (classification_report(y_test,predictions));
  

测试结果：

总体效果还可以，需要调一调其中的参数。之前发布的代码我后来仔细看了一下，发现算法有误，现在改正过来了。基本没什么错误了，哈哈哈。