神经网络简单源码

❶ 如何用代码编写一个神经网络异或运算器

配置环境、安装合适的库、下载数据集……有时候学习深度学习的前期工作很让人沮丧，如果只是为了试试现在人人都谈的深度学习，做这些麻烦事似乎很不值当。但好在我们也有一些更简单的方法可以体验深度学习。近日，编程学习平台 Scrimba 联合创始人 Per Harald Borgen 在 Medium 上发文介绍了一种仅用30行 JavaScript 代码就创建出了一个神经网络的教程，而且使用的工具也只有 Node.js、Synaptic.js 和浏览器而已。另外，作者还做了一个交互式 Scrimba 教程，也许能帮你理解其中的复杂概念。

Synaptic.js：http://synaptic.juancazala.com

Node.js：http://nodejs.org

Scrimba 教程：http://scrimba.com/casts/cast-1980

Synaptic.js 让你可以使用 Node.js 和浏览器做深度学习。在这篇文章中，我将介绍如何使用 Synaptic.js 创建和训练神经网络。

//创建网络const { Layer, Network }= window.synaptic;var inputLayer = new Layer(2);var hiddenLayer = new Layer(3);var outputLayer = new Layer(1);

inputLayer.project(hiddenLayer);

hiddenLayer.project(outputLayer);var myNetwork = new Network({

input: inputLayer,

hidden:[hiddenLayer],

output: outputLayer

});//训练网络——学习异或运算var learningRate =.3;for (var i =0; i <20000; i++)

{//0,0=>0

myNetwork.activate([0,0]);

myNetwork.propagate(learningRate,[0]);//0,1=>1

myNetwork.activate([0,1]);

myNetwork.propagate(learningRate,[1]);//1,0=>1

myNetwork.activate([1,0]);

myNetwork.propagate(learningRate,[1]);//1,1=>0

myNetwork.activate([1,1]);

myNetwork.propagate(learningRate,[0]);

}//测试网络console.log(myNetwork.activate([0,0]));//[0.0]console.log(myNetwork.activate([0,1]));//[0.]console.log(myNetwork.activate([1,0]));//[0.]console.log(myNetwork.activate([1,1]));//[0.0]

我们将创建一个最简单的神经网络：一个可以执行异或运算的网络。上面就是这个网络的全部代码，但在我们深入解读这些代码之前，首先我们先了解一下神经网络的基础知识。

神经元和突触

神经网络的基本构造模块是神经元。神经元就像是一个函数，有几个输入，然后可以得到一个输出。神经元的种类有很多。我们的网络将使用 sigmoid 神经元，它可以输入任何数字并将其压缩到0 到1 之间。下图就是一个 sigmoid 神经元。它的输入是5，输出是1。箭头被称为突触，可以将该神经元与网络中的其它层连接到一起。

现在训练这个网络：

// train the network - learn XORvar learningRate =.3;for (var i =0; i <20000; i++){ //0,0=>0

myNetwork.activate([0,0]);

myNetwork.propagate(learningRate,[0]);//0,1=>1

myNetwork.activate([0,1]);

myNetwork.propagate(learningRate,[1]);//1,0=>1

myNetwork.activate([1,0]);

myNetwork.propagate(learningRate,[1]);//1,1=>0

myNetwork.activate([1,1]);

myNetwork.propagate(learningRate,[0]);

}

这里我们运行该网络20000次。每一次我们都前向和反向传播4 次，为该网络输入4 组可能的输入：[0,0][0,1][1,0][1,1]。

首先我们执行 myNetwork.activate([0,0])，其中[0,0]是我们发送给该网络的数据点。这是前向传播，也称为激活这个网络。在每次前向传播之后，我们需要执行反向传播，这时候网络会更新自己的权重和偏置。

反向传播是通过这行代码完成的：myNetwork.propagate(learningRate,[0])，其中 learningRate 是一个常数，给出了网络每次应该调整的权重的量。第二个参数0 是给定输入[0,0]对应的正确输出。

然后，该网络将自己的预测与正确的标签进行比较，从而了解自己的正确程度有多少。

然后网络使用这个比较为基础来校正自己的权重和偏置值，这样让自己的下一次猜测更加正确一点。

这个过程如此反复20000次之后，我们可以使用所有四种可能的输入来检查网络的学习情况：

->[0.0]console.log(myNetwork.activate([0,1]));

->[0.]console.log(myNetwork.activate([1,0]));

->[0.]console.log(myNetwork.activate([1,1]));

->[0.0]

如果我们将这些值四舍五入到最近的整数，我们就得到了正确的异或运算结果。

这样就完成了。尽管这仅仅只碰到了神经网络的表皮，但也足以帮助你进一步探索 Synaptic 和继续学习了。http://github.com/cazala/synaptic/wiki 这里还包含了更多好教程。

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

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

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

2. 训练模型
这是我们将教神经网络做出准确预测的阶段。每个输入将具有权重（正或负）。
这意味着具有大量正权重或大量负权重的输入将对结果输出产生更大的影响。

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

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

❸ 怎样用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