bp算法python代碼（什麼是BP算法）

本文目錄一覽：

• 1、求教python代碼報錯原因
• 2、BP神經網絡建立2-2-1的網絡層來逼近一個二元函數f(x,y)=0.1*x^2-0.7*x*y
• 3、怎樣用python構建一個卷積神經網絡
• 4、你好，想跟你要一下神經網絡的代碼，看到你之前解答過問題，謝謝了
• 5、有沒有用python實現的遺傳算法優化BP神經網絡的代碼
• 6、python 利用pybrain庫實現的BP神經網絡 算法 不會畫收斂圖 求助

求教python代碼報錯原因

你的程序主要問題是生成的隨機數矩陣與X,Y矩陣點積時維數不匹配,

我幫你改完了,你看看吧(改動的地方見注釋)

from numpy import random, dot, exp, array

def fp(input):

l1 = 1/(1+exp(-dot(input, w0)))

l2 = 1/(1+exp(-dot(l1, w1.T))) #這裡w1改成w1.T

return l1, l2

def bp(l1, l2, y):

error = y – l2

slope = l2 * (1-l2)

l1_delta = error * slope

l0_slope = l1 * (1-l1)

l0_error = l1_delta.dot(w1.T)

l0_delta = l0_slope * l0_error

return l0_delta, l1_delta

X = array([[0,0,1],[0,1,1],[1,0,1],[1,1,1]]) #這裡array內加中括號

Y = array([0,1,1,0]).T

random.seed(1)

w0 = random.random((3,4)) * 2 – 1 #這裡(4,4)改成(3,4)

w1 = random.random((1,4)) * 2 – 1 #這裡(4,1)改成(1,4),w0改成w1

for it in range(10000):

l0 = X

l1, l2 = fp(l0)

l0_delta, l1_delta = bp(l1, l2, Y)#這裡小寫y改成大寫Y,l1delta改成l1_delta

w1= w1 + dot(l1.T, l1_delta)

w0= w0 + dot(l0.T, l0_delta)

print(fp([0,0,0])[1])

源代碼(注意源代碼的縮進)

BP神經網絡建立2-2-1的網絡層來逼近一個二元函數f(x,y)=0.1*x^2-0.7*x*y

while( count==0 || (Error/100)0.001 ) 這句話的count==0有何意義？應該是count=maxcount。當然這一句也不影響程序。

一直沒反應，說明沒有收斂，即小error0.001的目標一直達不到，可能陷入局部極小點中了。

也沒仔細看你的程序，你對照下經典程序吧，第一個案例就是自己編程的BP算法。

怎樣用python構建一個卷積神經網絡

用keras框架較為方便

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

以下轉自wphh的博客。

#coding:utf-8

”’

    GPU run command:

        THEANO_FLAGS=mode=FAST_RUN,device=gpu,floatX=float32 python cnn.py

    CPU run command:

        python cnn.py

2016.06.06更新：

這份代碼是keras開發初期寫的，當時keras還沒有現在這麼流行，文檔也還沒那麼豐富，所以我當時寫了一些簡單的教程。

現在keras的API也發生了一些的變化，建議及推薦直接上keras.io看更加詳細的教程。

”’

#導入各種用到的模塊組件

from __future__ import absolute_import

from __future__ import print_function

from keras.preprocessing.image import ImageDataGenerator

from keras.models import Sequential

from keras.layers.core import Dense, Dropout, Activation, Flatten

from keras.layers.advanced_activations import PReLU

from keras.layers.convolutional import Convolution2D, MaxPooling2D

from keras.optimizers import SGD, Adadelta, Adagrad

from keras.utils import np_utils, generic_utils

from six.moves import range

from data import load_data

import random

import numpy as np

np.random.seed(1024)  # for reproducibility

#加載數據

data, label = load_data()

#打亂數據

index = [i for i in range(len(data))]

random.shuffle(index)

data = data[index]

label = label[index]

print(data.shape[0], ‘ samples’)

#label為0~9共10個類別，keras要求格式為binary class matrices,轉化一下，直接調用keras提供的這個函數

label = np_utils.to_categorical(label, 10)

###############

#開始建立CNN模型

###############

#生成一個model

model = Sequential()

#第一個卷積層，4個卷積核，每個卷積核大小5*5。1表示輸入的圖片的通道,灰度圖為1通道。

#border_mode可以是valid或者full，具體看這裡說明：

#激活函數用tanh

#你還可以在model.add(Activation(‘tanh’))後加上dropout的技巧: model.add(Dropout(0.5))

model.add(Convolution2D(4, 5, 5, border_mode=’valid’,input_shape=(1,28,28))) 

model.add(Activation(‘tanh’))

#第二個卷積層，8個卷積核，每個卷積核大小3*3。4表示輸入的特徵圖個數，等於上一層的卷積核個數

#激活函數用tanh

#採用maxpooling，poolsize為(2,2)

model.add(Convolution2D(8, 3, 3, border_mode=’valid’))

model.add(Activation(‘tanh’))

model.add(MaxPooling2D(pool_size=(2, 2)))

#第三個卷積層，16個卷積核，每個卷積核大小3*3

#激活函數用tanh

#採用maxpooling，poolsize為(2,2)

model.add(Convolution2D(16, 3, 3, border_mode=’valid’)) 

model.add(Activation(‘relu’))

model.add(MaxPooling2D(pool_size=(2, 2)))

#全連接層，先將前一層輸出的二維特徵圖flatten為一維的。

#Dense就是隱藏層。16就是上一層輸出的特徵圖個數。4是根據每個卷積層計算出來的：(28-5+1)得到24,(24-3+1)/2得到11，(11-3+1)/2得到4

#全連接有128個神經元節點,初始化方式為normal

model.add(Flatten())

model.add(Dense(128, init=’normal’))

model.add(Activation(‘tanh’))

#Softmax分類，輸出是10類別

model.add(Dense(10, init=’normal’))

model.add(Activation(‘softmax’))

#############

#開始訓練模型

##############

#使用SGD + momentum

#model.compile里的參數loss就是損失函數(目標函數)

sgd = SGD(lr=0.05, decay=1e-6, momentum=0.9, nesterov=True)

model.compile(loss=’categorical_crossentropy’, optimizer=sgd,metrics=[“accuracy”])

#調用fit方法，就是一個訓練過程. 訓練的epoch數設為10，batch_size為100．

#數據經過隨機打亂shuffle=True。verbose=1，訓練過程中輸出的信息，0、1、2三種方式都可以，無關緊要。show_accuracy=True，訓練時每一個epoch都輸出accuracy。

#validation_split=0.2，將20%的數據作為驗證集。

model.fit(data, label, batch_size=100, nb_epoch=10,shuffle=True,verbose=1,validation_split=0.2)

“””

#使用data augmentation的方法

#一些參數和調用的方法，請看文檔

datagen = ImageDataGenerator(

        featurewise_center=True, # set input mean to 0 over the dataset

        samplewise_center=False, # set each sample mean to 0

        featurewise_std_normalization=True, # divide inputs by std of the dataset

        samplewise_std_normalization=False, # divide each input by its std

        zca_whitening=False, # apply ZCA whitening

        rotation_range=20, # randomly rotate images in the range (degrees, 0 to 180)

        width_shift_range=0.2, # randomly shift images horizontally (fraction of total width)

        height_shift_range=0.2, # randomly shift images vertically (fraction of total height)

        horizontal_flip=True, # randomly flip images

        vertical_flip=False) # randomly flip images

# compute quantities required for featurewise normalization 

# (std, mean, and principal components if ZCA whitening is applied)

datagen.fit(data)

for e in range(nb_epoch):

    print(‘-‘*40)

    print(‘Epoch’, e)

    print(‘-‘*40)

    print(“Training…”)

    # batch train with realtime data augmentation

    progbar = generic_utils.Progbar(data.shape[0])

    for X_batch, Y_batch in datagen.flow(data, label):

        loss,accuracy = model.train(X_batch, Y_batch,accuracy=True)

        progbar.add(X_batch.shape[0], values=[(“train loss”, loss),(“accuracy:”, accuracy)] )

“””

你好，想跟你要一下神經網絡的代碼，看到你之前解答過問題，謝謝了

// BP.cpp : Defines the entry point for the console application.

//該程序實現神經網絡的BP算法，輸入節點數，輸出節點數，隱層數，隱層節點數任意，由用戶決定。

//其中隱層數指的是總共層數包含輸出層，比如說異或算法為2層，第一層節點數為2，第二層也即輸出層節點數為1，輸入點數為2 。

//但是該程序對異或算法實現並不理想，對多層多節點的神經網絡有較好的結果

#include “stdafx.h”

#include “iostream.h”

#include time.h

#include stdlib.h

#include fstream

#include math.h

#include “stdio.h “

#define MAXCOUNT 1e5 //迭代訓練次數上限 1的10的正5次冪

//精度0.001的隨機浮點數,範圍在-0.5——0.5

//rand()取0到32767,最大為2147483647. %模運算表示餘數為0到1000之間，所以乘上浮點數0。001f就是0-1之間的數，再減去0.5,就是-0.5到+0.5

float randf()

{

return (float)((rand() % 1001) * 0.001f-0.5);

}

//高斯隨機數產生函數

//這樣生成的高斯分布隨機數序列的期望為0.0，方差為1.0。若指定期望為E，方差為V，則只需增加：X = X * V + E;

double gaussrand()

{

static double V1, V2, S;

static int phase = 0;

double X;

if(phase == 0) {

do {

double U1 = (double)rand() / RAND_MAX;

double U2 = (double)rand() / RAND_MAX;

V1 = 2 * U1 – 1;

V2 = 2 * U2 – 1;

S = V1 * V1 + V2 * V2;

} while(S = 1 || S == 0);

X = V1 * sqrt(-2 * log(S) / S);

} else

X = V2 * sqrt(-2 * log(S) / S );

phase = 1 – phase;

return X;

}

//定義一個多層前向BP網絡

class BP

{

public:

double ***p;//記錄所有的權值

double ***ddp;//記錄所有的權值增量

int *pnode;//記錄每一層的節點數

double **pnodey;//記錄每組每一層的節點的輸出值

double **ddlj;//記錄每組每一層的節點的ddlj

double **pX; //記錄輸入樣本

double **pY; //記錄輸入理想輸出值

int Sidenum; //隱層數目

int Inputnodenum;

int outputnodenum;

int yangbenzushu;

BP()

{

Sidenum=0;

Inputnodenum=0;

outputnodenum=0;

yangbenzushu=0;

}

~BP()

{

for(int m=0;mSidenum;m++)

{

for(int n=0;npnode[m+1];n++)

{

delete[] p[m][n];

delete[] ddp[m][n];

}

delete[] p[m];

delete[] ddp[m];

}

delete[] p;

delete[] ddp;

p=NULL;

ddp=NULL;

if(p==NULL)

delete [] pnode;

for(int M=0;MSidenum;M++)

{

delete[] pnodey[M];

delete[] ddlj[M];

}

delete[] pnodey;

delete[] ddlj;

pnodey=NULL;

ddlj=NULL;

}

//完成所有權值的初始化

void getW(int sidenum,int inputnodenum,int outputnodenum1,int yangbenzu)

{

Sidenum=sidenum;

yangbenzushu= yangbenzu;//樣本組數目

Inputnodenum=inputnodenum;

outputnodenum=outputnodenum1;

p=new double **[sidenum];//記錄所有權值

ddp=new double **[sidenum];//權值增量

pnode=new int [sidenum+1];//包含輸入層，輸出層每一層的節點數.

for(int i=0;isidenum+1;i++)

{

int data=0;

cout”請輸入第”i”層節點數”endl;

cindata;

pnode[i]=data;

}

for (int j=0;jsidenum;j++) // 初始化權值, 不包含輸入層,但是包含輸出層.第0層表示第一個隱層

{

p[j]=new double* [pnode[j+1]]; //首先P[j]層有多少個節點,就有多少個指針,每個指針指向一個權值數組.因為p[j]是二級指針,存放的是某指針的地址,某指針可以指向一維數組.

ddp[j]=new double*[pnode[j+1]];//同上

for (int k=0;kpnode[j+1];k++)

{

ddp[j][k]=new double[pnode[j]+1];//表示第j層的第k個節點指向的是一個數組,這個數組裡存的是這個節點的權值.

p[j][k]=new double[pnode[j]+1];

for (int t=0;tpnode[j]+1;t++) //pnode[j]+1 表示第j層的輸入點個數.

{

ddp[j][k][t]=0;//每一層的權值初始化為0 表示的是第j層的第k個節點,第t個輸入的輸入權值.

if(t==0)p[j][k][t]=-fabs(randf());//每一層的閥值初始化 第0個元素.

else p[j][k][t]=randf();//每一層的權值初始化

}

}

}

//為記錄每一層的節點的輸出值和ddlj的指針開闢內存

pnodey=new double *[Sidenum]; //一共有Sidenum層.

ddlj=new double *[Sidenum];

for(int p=0;pSidenum;p++)

{

pnodey[p] = new double [pnode[p+1]+1];//每層一共有節點數+1個輸出

ddlj[p]=new double [pnode[p+1]];// 這個是做什麼的？？

pnodey[p][0]=1;//每組每層的首值為1,這個值是為了與閾值相乘,這也是為什麼會有上面+1個輸出

}

}

/**********************/

//每個節點輸出函數

double fas(double s)

{

double t;

t=1.0/(exp(-s)+1);

return t;

}

/************************************************/

//該函數用來記錄樣本值和理想輸出值

void INPUT(int yangbenzushu1 )

{

pY=new double*[yangbenzushu1];//yangbenzushu1數量個理想輸出

pX=new double*[yangbenzushu1];//yangbenzushu1數量個樣本

for(int yu=0;yuyangbenzushu1;yu++)

{

pX[yu]=new double[Inputnodenum+1];//每個樣本的維數是輸入點個數+1

pY[yu]=new double[outputnodenum+1];//輸出的維數也是輸出點個數+1

}

//每組樣本的首值賦為1， 這樣就可以使下標對應的比較好

for(int yu1=0;yu1yangbenzushu1;yu1++)

{

pX[yu1][0]=1;

pY[yu1][0]=1;

}

cout”請輸入樣本輸入值”endl;

for(int yuy=0;yuyyangbenzushu1;yuy++)

for(int yy=1;yy=Inputnodenum;yy++)

{

if(yy==Inputnodenum) coutendl;

cout”X[“yuy”]””[“yy”]=”‘ ‘;

cinpX[yuy][yy];

}

cout”請輸入樣本理想輸出值”endl;

for(int yuy1=0;yuy1yangbenzushu1;yuy1++)

for(int yy1=1;yy1=outputnodenum;yy1++)

{ //if(yy==Inputnodenum) coutendl;

cout”Y[“yuy1”]””[“yy1”]=”‘ ‘;

cinpY[yuy1][yy1];

}

}

/****************************************************************************/

//計算每個節點的輸出值

double computeYl(int KK)//KK代表第幾組組號

{

double sum1=0;

//把所有的層的每一個節點的輸出值算出來並記錄在pnodey里,不包含輸入點值

for(int y=0;ySidenum;y++)//層數

{

for(int r=1;rpnode[y+1]+1;r++)//本節點數，加1是為了下標好看

{

double sum=0;

for(int z=0;zpnode[y]+1;z++)//前一層的節點數

{

if(y==0)sum+= pX[KK][z]*p[y][r-1][z];

else

sum+=pnodey[y-1][z]*p[y][r-1][z];

}

pnodey[y][r]=fas(sum);

}

}

for(int j=1;j=outputnodenum;j++)

sum1+=pow(pY[KK][j]-pnodey[Sidenum-1][j],2);

return sum1;

}

/**********************************************************/

//Compute Back-Propagation-Errors

void ComputeBackPropagationErrors(int gf)//gf代表組號

{//計算所有的ddlj[][]

//for(int gf=0;gfyangbenzushu;gf++)//組數

for(int q=Sidenum-1;q=0;q–)//從最後一層開始

{

if(q==Sidenum-1)//如果是最外一層的話

{

for(int rt=0;rtpnode[q+1];rt++)//每層的節點數

ddlj[q][rt]=pnodey[q][rt+1]*(1-pnodey[q][rt+1])*(pY[gf][rt+1]-pnodey[q][rt+1]) ;

}

else

{

for(int ry=0;rypnode[q+1];ry++)

{

double sumtemp=0;

for(int fg=0;fgpnode[q+2];fg++)

sumtemp+=ddlj[q+1][fg]*p[q+1][fg][ry+1];

ddlj[q][ry] = pnodey[q][ry+1]*(1-pnodey[q][ry+1])* sumtemp;

}

}

}

//計算所有的ddp[][]

//for(int gf1=0;gf1yangbenzushu;gf1++)//組數

for(int l=0;lSidenum;l++)//層數

for(int JJ=0;JJpnode[l+1];JJ++)//每一層的節點數

for(int i=0;ipnode[l]+1;i++)//前一層的節點數

{

if(l==0)//如果是第一層的話，y值為輸入的X值

ddp[l][JJ][i]=ddlj[l][JJ]*pX[gf][i];

else

ddp[l][JJ][i]=ddlj[l][JJ]*pnodey[l-1][i];

}

}

/*************************************************************************/

void UpdatetheWeightsusingBPAlgorithm()

{

for(int cent=0;centSidenum;cent++)//層數

for(int J=0;Jpnode[cent+1];J++)//每一層的節點數

for(int i=0;ipnode[cent]+1;i++)//前一層的節點數

p[cent][J][i]+=0.2*ddp[cent][J][i];

}

/***************************************************************************/

double xunlianErrors()//定義訓練誤差函數

{

double error=0;

double sum=0;

double temp=0;

double temp1=0;

for(int gf1=0;gf1yangbenzushu;gf1++)//組數

{

temp= computeYl(gf1);

//temp1=zhengquelv(gf1);

//sum+=temp1;

for(int jj=1;jj=outputnodenum;jj++)

coutpnodey[Sidenum-1][jj];

error+=temp;

}

// sum=sum/yangbenzushu;

cout”用訓練集所得到的正確率：”sumendl;

return error/yangbenzushu;

}

/****************************************************************************/

double jiaoyanErrors(int yangbenzushu1 )//定義校驗誤差函數

{

double error=0;

double sum=0;

double temp=0;

double temp1=0;

for(int gf1=0;gf1yangbenzushu1;gf1++)//組數

{

temp= computeYl(gf1);

for(int jj=1;jj=outputnodenum;jj++)

coutpnodey[Sidenum-1][jj];

//temp1=zhengquelv(gf1);

//sum+=temp1;

error+=temp;

}

//sum=sum/yangbenzushu1;

//cout”用校驗集所得到的正確率：”sumendl;

return error/yangbenzushu1;

}

/********************************************************************/

double zhengquelv(int KK)

{

int count=0;

double av=0;

//for(int gf1=0;gf1yangbenzushu;gf1++)//組數

for(int jj=1;jj=outputnodenum;jj++)

{

if (pnodey[Sidenum-1][jj]0) pnodey[Sidenum-1][jj]=1;

else pnodey[Sidenum-1][jj]=0;

if(pY[KK][jj]==pnodey[Sidenum-1][jj])count++;

}

av=(double)count/outputnodenum;

return av;

}

/***********************************************************************/

void freeINput()

{

if(pX!=NULL)

{

for(int u=0;uyangbenzushu;u++)

delete []pX[u];

delete []pX;

pX=NULL;

}

if(pY!=NULL)

{

for(int u1=0;u1yangbenzushu;u1++)

delete []pY[u1];

delete []pY;

pY=NULL;

}

}

/***************************************************************/

//輸出所有的權值

void wputout()

{

for (int j=0;jSidenum;j++)

{

cout”第[“j+1”]層權值為：”endl;

for (int k=0;kpnode[j+1];k++)

{

//if(k==pnode[j+1]-1) coutendl;

for (int t=0;tpnode[j]+1;t++)

{

coutp[j][k][t]’ ‘;

if(t==pnode[j]) coutendl;

}

}

}

}

/**********************************************************/

};

void main()

{

BP bp;

int count=0;//用來統計所用的迭代次數

//FILE *fp;

int inputnodenum,outnodenum,sidenum,yangbenzunum;

double error;

cout”請輸入：輸入點數，輸出點數，隱層數”endl;

cininputnodenumoutnodenumsidenum;

cout”請輸入樣本組數”endl;

cinyangbenzunum;

//第一步初始化所有的權值

bp.getW(sidenum,inputnodenum,outnodenum,yangbenzunum);

//第二步輸入樣本組

bp.INPUT(yangbenzunum);

for(;;count++)

{

double sum=0;

double temp=0;

for(int fuzu=0;fuzuyangbenzunum;fuzu++)

{

//第三步計算所有y值

temp=bp.computeYl(fuzu);

//第四步Compute Back-Propagation-Errors

bp.ComputeBackPropagationErrors(fuzu);

//第五步Update the Weights using BP Algorithm

bp.UpdatetheWeightsusingBPAlgorithm();

sum+=temp;

}

//第六步判斷是否收斂

error=sum/2*yangbenzunum;

//freopen(“debug\\out.txt”,”w”,stdout);

//fp=freopen( “out.txt”, “w”, stdout) ;

// coutcount’ ‘errorendl;

// fclose(stdout);//關閉文件

/*if(count==1000)couterrorendl;

if(count==1500)couterrorendl;

if(count==1600)couterrorendl;*/

//if(count==10000)couterrorendl;

if(error1.02)

{

cout”循環收斂””迭代次數為：”countendl;

//bp.freeINput();//釋放X Y空間

break;

}

}

cout”權值為：”endl;

bp.wputout();

double XUNLIANER=bp.xunlianErrors();

//cout”訓練誤差為：”XUNLIANERendl;

bp.freeINput();//釋放X Y空間

/*

cout”請輸入校驗樣本: “endl;

int jiaoyannum=0;

cinjiaoyannum;

bp.INPUT(jiaoyannum);

double jiaoyanER=bp.jiaoyanErrors(jiaoyannum);

cout”校驗誤差為:”jiaoyanERendl;

//fclose( stdout ) ;*/

}

有沒有用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處理。