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处理。