【算法8】BP神經網絡

單層感知機

多重感知機

BP神經網絡

注意

自定義BP代碼

import numpy as np
import matplotlib.pyplot as plt
def sigmoid(x):
    return 1/(1+np.exp(-x))

def bpnet(X=None,Y=None,maxiter=200,yita=0.75,hidSize=5):
    n,m = X.shape
    net_in = -np.ones([m+1])        #網絡輸入
    out_in = -np.ones([hidSize+1])  #隱層輸出,輸出層的輸入
    w_mid = np.random.rand(m+1,hidSize)  #初始隱層神經元的權值
    w_out = np.random.rand(hidSize+1)    #初始輸出層神經元的權值
    delta_w_mid = np.zeros([m+1,hidSize])  #中間層權值修正量

    Error = np.zeros([maxiter])
    for it in range(maxiter):
        error = np.zeros([n])
        for j in range(n):
            net_in[:m] = X[j,:]  #更新網絡輸入值
            real = Y[j]          #對應實際值
            #===從輸入到隱層輸出
            for i in range(hidSize):
                out_in[i] = sigmoid(sum(net_in*w_mid[:,i]))
            res = sigmoid(sum(out_in*w_out))  #隱層輸出到網絡輸出

            #===輸出層權值修正量
            delta_w_out = yita*res*(1-res)*(real-res)*out_in
            delta_w_out[hidSize] = -yita*res*(1-res)*(real-res)
            w_out = w_out + delta_w_out

            #===中間層權值修正量
            for i in range(hidSize):
                delta_w_mid[:,i] = yita*out_in[i]*(1-out_in[i])*w_out[i]*res*(1-res)*(real-res)*net_in
                delta_w_mid[m,i] = -yita*out_in[i]*(1-out_in[i])*w_out[i]*res*(1-res)*(real-res)
            w_mid = w_mid + delta_w_mid
            error[j] = abs(real-res)
            # print('real: ',real,' res: ',res)
        Error[it] = error.mean()
    plt.plot(Error)
    plt.show()
    return w_mid,w_out

def bpnet_predict(X=None,Y=None,hidSize=5,w_mid=None,w_out=None):
    n,m = X.shape
    net_in = -np.ones([m+1])        #網絡輸入
    out_in = -np.ones([hidSize+1])  #隱層輸出,輸出層的輸入

    for j in range(n):
        net_in[:m] = X[j,:]  #更新網絡輸入值
        real = Y[j]
        #===從輸入到隱層輸出
        for i in range(hidSize):
            out_in[i] = sigmoid(sum(net_in*w_mid[:,i]))
        res = sigmoid(sum(out_in*w_out))  #隱層輸出到網絡輸出
        print('real: ',real,' res: ',res)
    return res

Sklearn中的MLP

class sklearn.neural_network.MLPClassifier (hidden_layer_sizes=(100, ), activation=’relu’,
solver=’adam’, alpha=0.0001, batch_size=’auto’, learning_rate=’constant’, learning_rate_init=0.001,
power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False,
warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False,
validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08, n_iter_no_change=10)

重要參數hidden_layer_sizes

重要參數	意義
hidden_layer_sizes	元組，長度= n_layers - 2，默認值(100, )元祖中包含多少個元素，就表示設定多少隱藏層元祖中的第i個元素表示第i個隱藏層中的神經元數量

例子驗證

import numpy as np
from sklearn.neural_network import MLPClassifier as DNN
from sklearn.metrics import accuracy_score
from sklearn.model_selection import cross_val_score as cv
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.tree import DecisionTreeClassifier as DTC
from sklearn.model_selection import train_test_split as TTS
from time import time
import datetime
data = load_breast_cancer()
X = data.data
y = data.target
Xtrain, Xtest, Ytrain, Ytest = TTS(X,y,test_size=0.3,random_state=420)

times = time()
dnn = DNN(hidden_layer_sizes=(100,),random_state=420)
print(cv(dnn,X,y,cv=5).mean())
print(time() - times)
#使用決策樹進行一個對比
times = time()
clf = DTC(random_state=420)
print(cv(clf,X,y,cv=5).mean())
print(time() - times)

dnn = DNN(hidden_layer_sizes=(100,),random_state=420).fit(Xtrain,Ytrain)
dnn.score(Xtest,Ytest)
#使用重要參數n_layers_
dnn.n_layers_
#可見，默認層數是三層，由於必須要有輸入和輸出層，所以默認其實就只有一層隱藏層
#如果增加一個隱藏層上的神經元個數，會發生什麼呢？
dnn = DNN(hidden_layer_sizes=(200,),random_state=420)
dnn = dnn.fit(Xtrain,Ytrain)
dnn.score(Xtest,Ytest)

#來試試看學習曲線
s = []
for i in range(100,2000,100):
dnn = DNN(hidden_layer_sizes=(int(i),),random_state=420).fit(Xtrain,Ytrain)
s.append(dnn.score(Xtest,Ytest))
print(i,max(s))
plt.figure(figsize=(20,5))
plt.plot(range(100,2000,100),s)
plt.show()
#那如果增加隱藏層，控制神經元個數，會發生什麼呢？
s = []
layers = [(100,),(100,100),(100,100,100),(100,100,100,100),
(100,100,100,100,100),(100,100,100,100,100,100)]
for i in layers:
dnn = DNN(hidden_layer_sizes=(i),random_state=420).fit(Xtrain,Ytrain)
s.append(dnn.score(Xtest,Ytest))
print(i,max(s))
plt.figure(figsize=(20,5))
plt.plot(range(3,9),s)
plt.xticks([3,4,5,6,7,8])
plt.xlabel("Total number of layers")
plt.show()
#如果同時增加隱藏層和神經元個數，會發生什麼呢？
s = []
layers = [(100,),(150,150),(200,200,200),(300,300,300,300)]
for i in layers:
dnn = DNN(hidden_layer_sizes=(i),random_state=420).fit(Xtrain,Ytrain)
s.append(dnn.score(Xtest,Ytest))
print(i,max(s))
plt.figure(figsize=(20,5))
plt.plot(range(3,7),s)
plt.xticks([3,4,5,6])
plt.xlabel("Total number of layers")
plt.show()