當前位置:首頁 » 編程語言 » python實現bp神經網路

python實現bp神經網路

發布時間: 2022-09-28 06:42:03

『壹』 怎樣用python構建一個卷積神經網路模型

上周末利用python簡單實現了一個卷積神經網路,只包含一個卷積層和一個maxpooling層,pooling層後面的多層神經網路採用了softmax形式的輸出。實驗輸入仍然採用MNIST圖像使用10個feature map時,卷積和pooling的結果分別如下所示。


部分源碼如下:

[python]view plain

  • #coding=utf-8

  • '''''

  • Createdon2014年11月30日

  • @author:Wangliaofan

  • '''

  • importnumpy

  • importstruct

  • importmatplotlib.pyplotasplt

  • importmath

  • importrandom

  • import

  • #test

  • defsigmoid(inX):

  • if1.0+numpy.exp(-inX)==0.0:

  • return999999999.999999999

  • return1.0/(1.0+numpy.exp(-inX))

  • defdifsigmoid(inX):

  • returnsigmoid(inX)*(1.0-sigmoid(inX))

  • deftangenth(inX):

  • return(1.0*math.exp(inX)-1.0*math.exp(-inX))/(1.0*math.exp(inX)+1.0*math.exp(-inX))

  • defcnn_conv(in_image,filter_map,B,type_func='sigmoid'):

  • #in_image[num,featuremap,row,col]=>in_image[Irow,Icol]

  • #featuresmap[kfilter,row,col]

  • #type_func['sigmoid','tangenth']

  • #out_feature[kfilter,Irow-row+1,Icol-col+1]

  • shape_image=numpy.shape(in_image)#[row,col]

  • #print"shape_image",shape_image

  • shape_filter=numpy.shape(filter_map)#[kfilter,row,col]

  • ifshape_filter[1]>shape_image[0]orshape_filter[2]>shape_image[1]:

  • raiseException

  • shape_out=(shape_filter[0],shape_image[0]-shape_filter[1]+1,shape_image[1]-shape_filter[2]+1)

  • out_feature=numpy.zeros(shape_out)

  • k,m,n=numpy.shape(out_feature)

  • fork_idxinrange(0,k):

  • #rotate180tocalculateconv

  • c_filter=numpy.rot90(filter_map[k_idx,:,:],2)

  • forr_idxinrange(0,m):

  • forc_idxinrange(0,n):

  • #conv_temp=numpy.zeros((shape_filter[1],shape_filter[2]))

  • conv_temp=numpy.dot(in_image[r_idx:r_idx+shape_filter[1],c_idx:c_idx+shape_filter[2]],c_filter)

  • sum_temp=numpy.sum(conv_temp)

  • iftype_func=='sigmoid':

  • out_feature[k_idx,r_idx,c_idx]=sigmoid(sum_temp+B[k_idx])

  • eliftype_func=='tangenth':

  • out_feature[k_idx,r_idx,c_idx]=tangenth(sum_temp+B[k_idx])

  • else:

  • raiseException

  • returnout_feature

  • defcnn_maxpooling(out_feature,pooling_size=2,type_pooling="max"):

  • k,row,col=numpy.shape(out_feature)

  • max_index_Matirx=numpy.zeros((k,row,col))

  • out_row=int(numpy.floor(row/pooling_size))

  • out_col=int(numpy.floor(col/pooling_size))

  • out_pooling=numpy.zeros((k,out_row,out_col))

  • fork_idxinrange(0,k):

  • forr_idxinrange(0,out_row):

  • forc_idxinrange(0,out_col):

  • temp_matrix=out_feature[k_idx,pooling_size*r_idx:pooling_size*r_idx+pooling_size,pooling_size*c_idx:pooling_size*c_idx+pooling_size]

  • out_pooling[k_idx,r_idx,c_idx]=numpy.amax(temp_matrix)

  • max_index=numpy.argmax(temp_matrix)

  • #printmax_index

  • #printmax_index/pooling_size,max_index%pooling_size

  • max_index_Matirx[k_idx,pooling_size*r_idx+max_index/pooling_size,pooling_size*c_idx+max_index%pooling_size]=1

  • returnout_pooling,max_index_Matirx

  • defpoolwithfunc(in_pooling,W,B,type_func='sigmoid'):

  • k,row,col=numpy.shape(in_pooling)

  • out_pooling=numpy.zeros((k,row,col))

  • fork_idxinrange(0,k):

  • forr_idxinrange(0,row):

  • forc_idxinrange(0,col):

  • out_pooling[k_idx,r_idx,c_idx]=sigmoid(W[k_idx]*in_pooling[k_idx,r_idx,c_idx]+B[k_idx])

  • returnout_pooling

  • #out_featureistheoutputofconv

  • defbackErrorfromPoolToConv(theta,max_index_Matirx,out_feature,pooling_size=2):

  • k1,row,col=numpy.shape(out_feature)

  • error_conv=numpy.zeros((k1,row,col))

  • k2,theta_row,theta_col=numpy.shape(theta)

  • ifk1!=k2:

  • raiseException

  • foridx_kinrange(0,k1):

  • foridx_rowinrange(0,row):

  • foridx_colinrange(0,col):

  • error_conv[idx_k,idx_row,idx_col]=

  • max_index_Matirx[idx_k,idx_row,idx_col]*

  • float(theta[idx_k,idx_row/pooling_size,idx_col/pooling_size])*

  • difsigmoid(out_feature[idx_k,idx_row,idx_col])

  • returnerror_conv

  • defbackErrorfromConvToInput(theta,inputImage):

  • k1,row,col=numpy.shape(theta)

  • #print"theta",k1,row,col

  • i_row,i_col=numpy.shape(inputImage)

  • ifrow>i_roworcol>i_col:

  • raiseException

  • filter_row=i_row-row+1

  • filter_col=i_col-col+1

  • detaW=numpy.zeros((k1,filter_row,filter_col))

  • #thesamewithconvvalidinmatlab

  • fork_idxinrange(0,k1):

  • foridx_rowinrange(0,filter_row):

  • foridx_colinrange(0,filter_col):

  • subInputMatrix=inputImage[idx_row:idx_row+row,idx_col:idx_col+col]

  • #print"subInputMatrix",numpy.shape(subInputMatrix)

  • #rotatetheta180

  • #printnumpy.shape(theta)

  • theta_rotate=numpy.rot90(theta[k_idx,:,:],2)

  • #print"theta_rotate",theta_rotate

  • dotMatrix=numpy.dot(subInputMatrix,theta_rotate)

  • detaW[k_idx,idx_row,idx_col]=numpy.sum(dotMatrix)

  • detaB=numpy.zeros((k1,1))

  • fork_idxinrange(0,k1):

  • detaB[k_idx]=numpy.sum(theta[k_idx,:,:])

  • returndetaW,detaB

  • defloadMNISTimage(absFilePathandName,datanum=60000):

  • images=open(absFilePathandName,'rb')

  • buf=images.read()

  • index=0

  • magic,numImages,numRows,numColumns=struct.unpack_from('>IIII',buf,index)

  • printmagic,numImages,numRows,numColumns

  • index+=struct.calcsize('>IIII')

  • ifmagic!=2051:

  • raiseException

  • datasize=int(784*datanum)

  • datablock=">"+str(datasize)+"B"

  • #nextmatrix=struct.unpack_from('>47040000B',buf,index)

  • nextmatrix=struct.unpack_from(datablock,buf,index)

  • nextmatrix=numpy.array(nextmatrix)/255.0

  • #nextmatrix=nextmatrix.reshape(numImages,numRows,numColumns)

  • #nextmatrix=nextmatrix.reshape(datanum,1,numRows*numColumns)

  • nextmatrix=nextmatrix.reshape(datanum,1,numRows,numColumns)

  • returnnextmatrix,numImages

  • defloadMNISTlabels(absFilePathandName,datanum=60000):

  • labels=open(absFilePathandName,'rb')

  • buf=labels.read()

  • index=0

  • magic,numLabels=struct.unpack_from('>II',buf,index)

  • printmagic,numLabels

  • index+=struct.calcsize('>II')

  • ifmagic!=2049:

  • raiseException

  • datablock=">"+str(datanum)+"B"

  • #nextmatrix=struct.unpack_from('>60000B',buf,index)

  • nextmatrix=struct.unpack_from(datablock,buf,index)

  • nextmatrix=numpy.array(nextmatrix)

  • returnnextmatrix,numLabels

  • defsimpleCNN(numofFilter,filter_size,pooling_size=2,maxIter=1000,imageNum=500):

  • decayRate=0.01

  • MNISTimage,num1=loadMNISTimage("F:\train-images-idx3-ubyte",imageNum)

  • printnum1

  • row,col=numpy.shape(MNISTimage[0,0,:,:])

  • out_Di=numofFilter*((row-filter_size+1)/pooling_size)*((col-filter_size+1)/pooling_size)

  • MLP=BMNN2.MuiltilayerANN(1,[128],out_Di,10,maxIter)

  • MLP.setTrainDataNum(imageNum)

  • MLP.loadtrainlabel("F:\train-labels-idx1-ubyte")

  • MLP.initialweights()

  • #MLP.printWeightMatrix()

  • rng=numpy.random.RandomState(23455)

  • W_shp=(numofFilter,filter_size,filter_size)

  • W_bound=numpy.sqrt(numofFilter*filter_size*filter_size)

  • W_k=rng.uniform(low=-1.0/W_bound,high=1.0/W_bound,size=W_shp)

  • B_shp=(numofFilter,)

  • B=numpy.asarray(rng.uniform(low=-.5,high=.5,size=B_shp))

  • cIter=0

  • whilecIter<maxIter:

  • cIter+=1

  • ImageNum=random.randint(0,imageNum-1)

  • conv_out_map=cnn_conv(MNISTimage[ImageNum,0,:,:],W_k,B,"sigmoid")

  • out_pooling,max_index_Matrix=cnn_maxpooling(conv_out_map,2,"max")

  • pool_shape=numpy.shape(out_pooling)

  • MLP_input=out_pooling.reshape(1,1,out_Di)

  • #printnumpy.shape(MLP_input)

  • DetaW,DetaB,temperror=MLP.backwardPropogation(MLP_input,ImageNum)

  • ifcIter%50==0:

  • printcIter,"Temperror:",temperror

  • #printnumpy.shape(MLP.Theta[MLP.Nl-2])

  • #printnumpy.shape(MLP.Ztemp[0])

  • #printnumpy.shape(MLP.weightMatrix[0])

  • theta_pool=MLP.Theta[MLP.Nl-2]*MLP.weightMatrix[0].transpose()

  • #printnumpy.shape(theta_pool)

  • #print"theta_pool",theta_pool

  • temp=numpy.zeros((1,1,out_Di))

  • temp[0,:,:]=theta_pool

  • back_theta_pool=temp.reshape(pool_shape)

  • #print"back_theta_pool",numpy.shape(back_theta_pool)

  • #print"back_theta_pool",back_theta_pool

  • error_conv=backErrorfromPoolToConv(back_theta_pool,max_index_Matrix,conv_out_map,2)

  • #print"error_conv",numpy.shape(error_conv)

  • #printerror_conv

  • conv_DetaW,conv_DetaB=backErrorfromConvToInput(error_conv,MNISTimage[ImageNum,0,:,:])

  • #print"W_k",W_k

  • #print"conv_DetaW",conv_DetaW

『貳』 如何用 Python 構建神經網路擇時模型

import math
import random
random.seed(0)
def rand(a,b): #隨機函數
return (b-a)*random.random()+a
def make_matrix(m,n,fill=0.0):#創建一個指定大小的矩陣
mat = []
for i in range(m):
mat.append([fill]*n)
return mat
#定義sigmoid函數和它的導數
def sigmoid(x):
return 1.0/(1.0+math.exp(-x))
def sigmoid_derivate(x):
return x*(1-x) #sigmoid函數的導數
class BPNeuralNetwork:
def __init__(self):#初始化變數
self.input_n = 0
self.hidden_n = 0
self.output_n = 0
self.input_cells = []
self.hidden_cells = []
self.output_cells = []
self.input_weights = []
self.output_weights = []
self.input_correction = []
self.output_correction = []
#三個列表維護:輸入層,隱含層,輸出層神經元
def setup(self,ni,nh,no):
self.input_n = ni+1 #輸入層+偏置項
self.hidden_n = nh #隱含層
self.output_n = no #輸出層
#初始化神經元
self.input_cells = [1.0]*self.input_n
self.hidden_cells= [1.0]*self.hidden_n
self.output_cells= [1.0]*self.output_n
#初始化連接邊的邊權
self.input_weights = make_matrix(self.input_n,self.hidden_n) #鄰接矩陣存邊權:輸入層->隱藏層
self.output_weights = make_matrix(self.hidden_n,self.output_n) #鄰接矩陣存邊權:隱藏層->輸出層
#隨機初始化邊權:為了反向傳導做准備--->隨機初始化的目的是使對稱失效
for i in range(self.input_n):
for h in range(self.hidden_n):
self.input_weights[i][h] = rand(-0.2 , 0.2) #由輸入層第i個元素到隱藏層第j個元素的邊權為隨機值
for h in range(self.hidden_n):
for o in range(self.output_n):
self.output_weights[h][o] = rand(-2.0, 2.0) #由隱藏層第i個元素到輸出層第j個元素的邊權為隨機值
#保存校正矩陣,為了以後誤差做調整
self.input_correction = make_matrix(self.input_n , self.hidden_n)
self.output_correction = make_matrix(self.hidden_n,self.output_n)
#輸出預測值
def predict(self,inputs):
#對輸入層進行操作轉化樣本
for i in range(self.input_n-1):
self.input_cells[i] = inputs[i] #n個樣本從0~n-1
#計算隱藏層的輸出,每個節點最終的輸出值就是權值*節點值的加權和
for j in range(self.hidden_n):
total = 0.0
for i in range(self.input_n):
total+=self.input_cells[i]*self.input_weights[i][j]
# 此處為何是先i再j,以隱含層節點做大循環,輸入樣本為小循環,是為了每一個隱藏節點計算一個輸出值,傳輸到下一層
self.hidden_cells[j] = sigmoid(total) #此節點的輸出是前一層所有輸入點和到該點之間的權值加權和
for k in range(self.output_n):
total = 0.0
for j in range(self.hidden_n):
total+=self.hidden_cells[j]*self.output_weights[j][k]
self.output_cells[k] = sigmoid(total) #獲取輸出層每個元素的值
return self.output_cells[:] #最後輸出層的結果返回
#反向傳播演算法:調用預測函數,根據反向傳播獲取權重後前向預測,將結果與實際結果返回比較誤差
def back_propagate(self,case,label,learn,correct):
#對輸入樣本做預測
self.predict(case) #對實例進行預測
output_deltas = [0.0]*self.output_n #初始化矩陣
for o in range(self.output_n):
error = label[o] - self.output_cells[o] #正確結果和預測結果的誤差:0,1,-1
output_deltas[o]= sigmoid_derivate(self.output_cells[o])*error#誤差穩定在0~1內
#隱含層誤差
hidden_deltas = [0.0]*self.hidden_n
for h in range(self.hidden_n):
error = 0.0
for o in range(self.output_n):
error+=output_deltas[o]*self.output_weights[h][o]
hidden_deltas[h] = sigmoid_derivate(self.hidden_cells[h])*error
#反向傳播演算法求W
#更新隱藏層->輸出權重
for h in range(self.hidden_n):
for o in range(self.output_n):
change = output_deltas[o]*self.hidden_cells[h]
#調整權重:上一層每個節點的權重學習*變化+矯正率
self.output_weights[h][o] += learn*change + correct*self.output_correction[h][o]
#更新輸入->隱藏層的權重
for i in range(self.input_n):
for h in range(self.hidden_n):
change = hidden_deltas[h]*self.input_cells[i]
self.input_weights[i][h] += learn*change + correct*self.input_correction[i][h]
self.input_correction[i][h] = change
#獲取全局誤差
error = 0.0
for o in range(len(label)):
error = 0.5*(label[o]-self.output_cells[o])**2 #平方誤差函數
return error
def train(self,cases,labels,limit=10000,learn=0.05,correct=0.1):
for i in range(limit): #設置迭代次數
error = 0.0
for j in range(len(cases)):#對輸入層進行訪問
label = labels[j]
case = cases[j]
error+=self.back_propagate(case,label,learn,correct) #樣例,標簽,學習率,正確閾值
def test(self): #學習異或
cases = [
[0, 0],
[0, 1],
[1, 0],
[1, 1],
] #測試樣例
labels = [[0], [1], [1], [0]] #標簽
self.setup(2,5,1) #初始化神經網路:輸入層,隱藏層,輸出層元素個數
self.train(cases,labels,10000,0.05,0.1) #可以更改
for case in cases:
print(self.predict(case))
if __name__ == '__main__':
nn = BPNeuralNetwork()
nn.test()

『叄』 有沒有用python實現的遺傳演算法優化BP神經網路的代碼

下面是函數實現的代碼部分:
clc
clear all
close all
%% 載入神經網路的訓練樣本 測試樣本每列一個樣本 輸入P 輸出T,T是標簽
%樣本數據就是前面問題描述中列出的數據
%epochs是計算時根據輸出誤差返回調整神經元權值和閥值的次數
load data
% 初始隱層神經元個數
hiddennum=31;
% 輸入向量的最大值和最小值
threshold=[0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1];
inputnum=size(P,1); % 輸入層神經元個數
outputnum=size(T,1); % 輸出層神經元個數
w1num=inputnum*hiddennum; % 輸入層到隱層的權值個數
w2num=outputnum*hiddennum;% 隱層到輸出層的權值個數
N=w1num+hiddennum+w2num+outputnum; %待優化的變數的個數
%% 定義遺傳演算法參數
NIND=40; %個體數目
MAXGEN=50; %最大遺傳代數
PRECI=10; %變數的二進制位數
GGAP=0.95; %代溝
px=0.7; %交叉概率
pm=0.01; %變異概率
trace=zeros(N+1,MAXGEN); %尋優結果的初始值
FieldD=[repmat(PRECI,1,N);repmat([-0.5;0.5],1,N);repmat([1;0;1;1],1,N)]; %區域描述器
Chrom=crtbp(NIND,PRECI*N); %初始種群
%% 優化
gen=0; %代計數器
X=bs2rv(Chrom,FieldD); %計算初始種群的十進制轉換
ObjV=Objfun(X,P,T,hiddennum,P_test,T_test); %計算目標函數值
while gen

『肆』 python 利用pybrain庫實現的BP神經網路 演算法 不會畫收斂圖 求助

這個神經網路只能處理分兩類的的情況,這是由這個神經網路的結構決定了的。 如果想應付分多類的情況,必須對輸出層作softmax處理。

『伍』 復雜神經網路模型用什麼軟體

bp神經網路能用MATLAB,
理論上編程語言都可以,比如VB,C語言,過程也都是建模、量化、運算及結果輸出(圖、表),但是matlab發展到現在,集成了很多的工具箱,所以用的最為廣泛,用其他的就得是要從源碼開發入手了。
bp神經網路是一種演算法,只要是演算法就可以用任何軟體工具,只要編譯器或者解釋器支持,c,c++,python,來進行實現,只是實現時的復雜程度有區別而已

『陸』 python做BP神經網路,進行數據預測,訓練的輸入和輸出值都存在負數,為什麼預測值永遠為正數

因為sigmoid就是預測0到1之間的連續值。通常當二分類預測使用,你的問題是否復合二分類如果可以就把類別換成0和1就可以了,如果是做回歸那就不行了,要換其他損失函數

『柒』 從零開始用Python構建神經網路

從零開始用Python構建神經網路
動機:為了更加深入的理解深度學習,我們將使用 python 語言從頭搭建一個神經網路,而不是使用像 Tensorflow 那樣的封裝好的框架。我認為理解神經網路的內部工作原理,對數據科學家來說至關重要。
這篇文章的內容是我的所學,希望也能對你有所幫助。
神經網路是什麼?
介紹神經網路的文章大多數都會將它和大腦進行類比。如果你沒有深入研究過大腦與神經網路的類比,那麼將神經網路解釋為一種將給定輸入映射為期望輸出的數學關系會更容易理解。
神經網路包括以下組成部分
? 一個輸入層,x
? 任意數量的隱藏層
? 一個輸出層,?
? 每層之間有一組權值和偏置,W and b
? 為隱藏層選擇一種激活函數,σ。在教程中我們使用 Sigmoid 激活函數
下圖展示了 2 層神經網路的結構(注意:我們在計算網路層數時通常排除輸入層)

2 層神經網路的結構
用 Python 可以很容易的構建神經網路類

訓練神經網路
這個網路的輸出 ? 為:

你可能會注意到,在上面的等式中,輸出 ? 是 W 和 b 函數。
因此 W 和 b 的值影響預測的准確率. 所以根據輸入數據對 W 和 b 調優的過程就被成為訓練神經網路。
每步訓練迭代包含以下兩個部分:
? 計算預測結果 ?,這一步稱為前向傳播
? 更新 W 和 b,,這一步成為反向傳播
下面的順序圖展示了這個過程:

前向傳播
正如我們在上圖中看到的,前向傳播只是簡單的計算。對於一個基本的 2 層網路來說,它的輸出是這樣的:

我們在 NeuralNetwork 類中增加一個計算前向傳播的函數。為了簡單起見我們假設偏置 b 為0:

但是我們還需要一個方法來評估預測結果的好壞(即預測值和真實值的誤差)。這就要用到損失函數。
損失函數
常用的損失函數有很多種,根據模型的需求來選擇。在本教程中,我們使用誤差平方和作為損失函數。
誤差平方和是求每個預測值和真實值之間的誤差再求和,這個誤差是他們的差值求平方以便我們觀察誤差的絕對值。
訓練的目標是找到一組 W 和 b,使得損失函數最好小,也即預測值和真實值之間的距離最小。
反向傳播
我們已經度量出了預測的誤差(損失),現在需要找到一種方法來傳播誤差,並以此更新權值和偏置。
為了知道如何適當的調整權值和偏置,我們需要知道損失函數對權值 W 和偏置 b 的導數。
回想微積分中的概念,函數的導數就是函數的斜率。

梯度下降法
如果我們已經求出了導數,我們就可以通過增加或減少導數值來更新權值 W 和偏置 b(參考上圖)。這種方式被稱為梯度下降法。
但是我們不能直接計算損失函數對權值和偏置的導數,因為在損失函數的等式中並沒有顯式的包含他們。因此,我們需要運用鏈式求導發在來幫助計算導數。

鏈式法則用於計算損失函數對 W 和 b 的導數。注意,為了簡單起見。我們只展示了假設網路只有 1 層的偏導數。
這雖然很簡陋,但是我們依然能得到想要的結果—損失函數對權值 W 的導數(斜率),因此我們可以相應的調整權值。
現在我們將反向傳播演算法的函數添加到 Python 代碼中

為了更深入的理解微積分原理和反向傳播中的鏈式求導法則,我強烈推薦 3Blue1Brown 的如下教程:
Youtube:https://youtu.be/tIeHLnjs5U8
整合並完成一個實例
既然我們已經有了包括前向傳播和反向傳播的完整 Python 代碼,那麼就將其應用到一個例子上看看它是如何工作的吧。

神經網路可以通過學習得到函數的權重。而我們僅靠觀察是不太可能得到函數的權重的。
讓我們訓練神經網路進行 1500 次迭代,看看會發生什麼。 注意觀察下面每次迭代的損失函數,我們可以清楚地看到損失函數單調遞減到最小值。這與我們之前介紹的梯度下降法一致。

讓我們看看經過 1500 次迭代後的神經網路的最終預測結果:

經過 1500 次迭代訓練後的預測結果
我們成功了!我們應用前向和方向傳播演算法成功的訓練了神經網路並且預測結果收斂於真實值。
注意預測值和真實值之間存在細微的誤差是允許的。這樣可以防止模型過擬合並且使得神經網路對於未知數據有著更強的泛化能力。
下一步是什麼?
幸運的是我們的學習之旅還沒有結束,仍然有很多關於神經網路和深度學習的內容需要學習。例如:
? 除了 Sigmoid 以外,還可以用哪些激活函數
? 在訓練網路的時候應用學習率
? 在面對圖像分類任務的時候使用卷積神經網路
我很快會寫更多關於這個主題的內容,敬請期待!
最後的想法
我自己也從零開始寫了很多神經網路的代碼
雖然可以使用諸如 Tensorflow 和 Keras 這樣的深度學習框架方便的搭建深層網路而不需要完全理解其內部工作原理。但是我覺得對於有追求的數據科學家來說,理解內部原理是非常有益的。
這種練習對我自己來說已成成為重要的時間投入,希望也能對你有所幫助

『捌』 怎樣用python構建一個卷積神經網路

用keras框架較為方便

首先安裝anaconda,然後通過pip安裝keras

『玖』 Hopfield神經網路用python實現講解

神經網路結構具有以下三個特點:

神經元之間全連接,並且為單層神經網路。

每個神經元既是輸入又是輸出,導致得到的權重矩陣相對稱,故可節約計算量。

在輸入的激勵下,其輸出會產生不斷的狀態變化,這個反饋過程會一直反復進行。假如Hopfield神經網路是一個收斂的穩定網路,則這個反饋與迭代的計算過程所產生的變化越來越小,一旦達到了穩定的平衡狀態,Hopfield網路就會輸出一個穩定的恆值。

Hopfield網路可以儲存一組平衡點,使得當給定網路一組初始狀態時,網路通過自行運行而最終收斂於這個設計的平衡點上。當然,根據熱力學上,平衡狀態分為stable state和metastable state, 這兩種狀態在網路的收斂過程中都是非常可能的。

為遞歸型網路,t時刻的狀態與t-1時刻的輸出狀態有關。之後的神經元更新過程也採用的是非同步更新法(Asynchronous)。

Hopfield神經網路用python實現

『拾』 什麼是BP神經網路

BP演算法的基本思想是:學習過程由信號正向傳播與誤差的反向回傳兩個部分組成;正向傳播時,輸入樣本從輸入層傳入,經各隱層依次逐層處理,傳向輸出層,若輸出層輸出與期望不符,則將誤差作為調整信號逐層反向回傳,對神經元之間的連接權矩陣做出處理,使誤差減小。經反復學習,最終使誤差減小到可接受的范圍。具體步驟如下:
1、從訓練集中取出某一樣本,把信息輸入網路中。
2、通過各節點間的連接情況正向逐層處理後,得到神經網路的實際輸出。
3、計算網路實際輸出與期望輸出的誤差。
4、將誤差逐層反向回傳至之前各層,並按一定原則將誤差信號載入到連接權值上,使整個神經網路的連接權值向誤差減小的方向轉化。
5、対訓練集中每一個輸入—輸出樣本對重復以上步驟,直到整個訓練樣本集的誤差減小到符合要求為止。

熱點內容
糖豆網怎麼上傳視頻 發布:2022-12-09 14:55:22 瀏覽:967
醫保卡密碼忘了應該到哪裡操作 發布:2022-12-09 14:53:37 瀏覽:925
惠普u盤加密 發布:2022-12-09 14:51:53 瀏覽:450
組策略設置的配置類型是什麼 發布:2022-12-09 14:51:32 瀏覽:105
老年機還原出廠設置密碼多少 發布:2022-12-09 14:47:28 瀏覽:954
多線程資料庫插入 發布:2022-12-09 14:44:08 瀏覽:179
阿里雲伺服器日誌 發布:2022-12-09 14:41:34 瀏覽:613
rar解壓軟體下載mac 發布:2022-12-09 14:37:52 瀏覽:986
壓縮加密視頻 發布:2022-12-09 14:37:06 瀏覽:994
易語言編譯病毒 發布:2022-12-09 14:34:24 瀏覽:47