python神经网络算法函数（python调用神经网络模型）

本文目录一览：

• 1、有没有用python实现的遗传算法优化BP神经网络的代码
• 2、怎样用python构建一个卷积神经网络
• 3、从零开始用Python构建神经网络
• 4、BP神经网络——Python简单实现三层神经网络（Numpy）
• 5、如何用 Python 构建神经网络择时模型

有没有用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构建一个卷积神经网络

用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)] )

“””

从零开始用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：

整合并完成一个实例

既然我们已经有了包括前向传播和反向传播的完整 Python 代码，那么就将其应用到一个例子上看看它是如何工作的吧。

神经网络可以通过学习得到函数的权重。而我们仅靠观察是不太可能得到函数的权重的。

让我们训练神经网络进行 1500 次迭代，看看会发生什么。 注意观察下面每次迭代的损失函数，我们可以清楚地看到损失函数单调递减到最小值。这与我们之前介绍的梯度下降法一致。

让我们看看经过 1500 次迭代后的神经网络的最终预测结果：

经过 1500 次迭代训练后的预测结果

我们成功了!我们应用前向和方向传播算法成功的训练了神经网络并且预测结果收敛于真实值。

注意预测值和真实值之间存在细微的误差是允许的。这样可以防止模型过拟合并且使得神经网络对于未知数据有着更强的泛化能力。

下一步是什么?

幸运的是我们的学习之旅还没有结束，仍然有很多关于神经网络和深度学习的内容需要学习。例如：

? 除了 Sigmoid 以外，还可以用哪些激活函数

? 在训练网络的时候应用学习率

? 在面对图像分类任务的时候使用卷积神经网络

我很快会写更多关于这个主题的内容，敬请期待!

最后的想法

我自己也从零开始写了很多神经网络的代码

虽然可以使用诸如 Tensorflow 和 Keras 这样的深度学习框架方便的搭建深层网络而不需要完全理解其内部工作原理。但是我觉得对于有追求的数据科学家来说，理解内部原理是非常有益的。

这种练习对我自己来说已成成为重要的时间投入，希望也能对你有所帮助

BP神经网络——Python简单实现三层神经网络（Numpy）

我们将在Python中创建一个NeuralNetwork类，以训练神经元以给出准确的预测。该课程还将具有其他帮助程序功能。

1. 应用Sigmoid函数

我们将使用 Sigmoid函数 （它绘制一条“ S”形曲线）作为神经网络的激活函数。

2. 训练模型

这是我们将教神经网络做出准确预测的阶段。每个输入将具有权重（正或负）。

这意味着具有大量正权重或大量负权重的输入将对结果输出产生更大的影响。

我们最初是将每个权重分配给一个随机数。

本文参考翻译于此网站 —— 原文

如何用 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()