卷积神经网络模型
Ⅰ 形色app用的卷积神经网络的什么模型
CNN卷积神经网络抄是一种深度模型。它其实老早就已经可以成功训练并且应用了（最近可能deep learning太火了，CNNs也往这里面靠。虽然CNNs也属于多层神经网络架构，但把它置身于DL家族，还是有不少人保留自己的理解的）。
它在原始的输入中应用可训练的滤波器trainable filters和局部邻域池化操作local neighborhood pooling operations，得到一个分级的且逐渐复杂的特征表示。有实践表示，如果采用合适的规则化项来训练，它可以达到非常好的效果。CNN还让人青睐的一点就是它会对例如姿势、光照和复杂背景存在不变性。
Ⅱ 卷积神经网络的学习率怎么计算出来的
学习率实际和信号分析里的时间常数是一样的，学习率越小 学习会越精细，但同时学习速度也会降低，因为现实中很多模型都是非线性的，犹如一条曲线，梯度下降采用很多小直线迭代去逼近非线性的曲线，如果每一步跨度太大（学习率）就会失去很多曲线的扭曲信息，局部直线化过严重，跨度太小你要到达曲线的尽头就需要很多很多步，这就需要更多的样本，所以这个也要考虑实际问题再来决定学习率的。
Ⅲ 卷积神经网络 多少隐含层效果最好
卷积神来经网络有以下几源种应用可供研究： 1、基于卷积网络的形状识别 物体的形状是人的视觉系统分析和识别物体的基础，几何形状是物体的本质特征的表现，并具有平移、缩放和旋转不变等特点，所以在模式识别领域，对于形状的分析和识别具有十分重要的意义，而二维图像作为三维图像的特例以及组成部分，因此二维图像的识别是三维图像识别的基础。 2、基于卷积网络的人脸检测 卷积神经网络与传统的人脸检测方法不同，它是通过直接作用于输入样本，用样本来训练网络并最终实现检测任务的。它是非参数型的人脸检测方法，可以省去传统方法中建模、参数估计以及参数检验、重建模型等的一系列复杂过程。本文针对图像中任意大小、位置、姿势、方向、肤色、面部表情和光照条件的人脸。 3、文字识别系统 在经典的模式识别中，一般是事先提取特征。提取诸多特征后，要对这些特征进行相关性分析，找到最能代表字符的特征，去掉对分类无关和自相关的特征。然而，这些特征的提取太过依赖人的经验和主观意识，提取到的特征法乏瘁何诓蛊搭坍但开的不同对分类性能影响很大，甚至提取的特征的顺序也会影响最后的分类性能。同时，图像预处理的好坏也会影响到提取的特征。
Ⅳ 如何用visio画卷积神经网络图。图形类似下图所示
大概试了一下用visio绘制这个图，除了最左面的变形图片外其余基本可以实现（那个图可以考虑用专其它图像处理软属件比如Photoshop生成后插入visio），visio中主要用到的图形可以在更多形状-常规-具有透视效果的块中找到块图形，拖入绘图区后拉动透视角度调节的小红点进行调整直到合适为止，其余的块可以按住ctrl+鼠标左键进行拉动复制，然后再进行大小、位置仔细调整就可以了，大致绘出图形示例如下图所示：
Ⅳ 怎样用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
Ⅵ cnn卷积神经网络用什么语言来写pascial
200+
这个是hinton matlab代码的C++改写版. convnetjs - Star,SAE，首选的肯定是LIBSVM这个库;RBM#47. DeepLearn Toolbox - Star，包括了CNN;C++SVM方面,Java。
2。
下面主要一些DeepLearning的GitHub项目吧;SdA#47:2200+
实现了卷积神经网络，还实现了Rasmussen的共轭梯度Conjugate Gradient算法,DBN,C/CRBM/CDBN#47：Python。
3,CAE等主流模型，实现的模型有DBN#47，可以用来做分类，语言是Python;LR等，从算法与实现上都比较全:800+
实现了深度学习网络. rbm-mnist - Star，应该是应用最广的机器学习库了，强化学习等. Deep Learning(yusugomo) - Star,Scala:1000+
Matlab实现中最热的库存，提供了5种语言的实现。
5;dA#47:500+
这是同名书的配套代码。
4. Neural-Networks-And-Deep-Learning - Star！
1，回归
Ⅶ 前馈神经网络、BP神经网络、卷积神经网络的区别与联系
一、计算方法不同
1、前馈神经网络：一种最简单的神经网络，各神经元分层排列。每个神经元只与前一层的神经元相连。接收前一层的输出，并输出给下一层．各层间没有反馈。
2、BP神经网络：是一种按照误差逆向传播算法训练的多层前馈神经网络。
3、卷积神经网络：包含卷积计算且具有深度结构的前馈神经网络。
二、用途不同
1、前馈神经网络：主要应用包括感知器网络、BP网络和RBF网络。
2、BP神经网络：
（1）函数逼近：用输入向量和相应的输出向量训练一个网络逼近一个函数；
（2）模式识别：用一个待定的输出向量将它与输入向量联系起来；
（3）分类：把输入向量所定义的合适方式进行分类；
（4）数据压缩：减少输出向量维数以便于传输或存储。
3、卷积神经网络：可应用于图像识别、物体识别等计算机视觉、自然语言处理、物理学和遥感科学等领域。
联系：
BP神经网络和卷积神经网络都属于前馈神经网络，三者都属于人工神经网络。因此，三者原理和结构相同。
三、作用不同
1、前馈神经网络：结构简单，应用广泛，能够以任意精度逼近任意连续函数及平方可积函数．而且可以精确实现任意有限训练样本集。
2、BP神经网络：具有很强的非线性映射能力和柔性的网络结构。网络的中间层数、各层的神经元个数可根据具体情况任意设定，并且随着结构的差异其性能也有所不同。
3、卷积神经网络：具有表征学习能力，能够按其阶层结构对输入信息进行平移不变分类。
(7)卷积神经网络模型扩展阅读：
1、BP神经网络优劣势
BP神经网络无论在网络理论还是在性能方面已比较成熟。其突出优点就是具有很强的非线性映射能力和柔性的网络结构。网络的中间层数、各层的神经元个数可根据具体情况任意设定，并且随着结构的差异其性能也有所不同。但是BP神经网络也存在以下的一些主要缺陷。
①学习速度慢，即使是一个简单的问题，一般也需要几百次甚至上千次的学习才能收敛。
②容易陷入局部极小值。
③网络层数、神经元个数的选择没有相应的理论指导。
④网络推广能力有限。
2、人工神经网络的特点和优越性，主要表现在以下三个方面
①具有自学习功能。例如实现图像识别时，只在先把许多不同的图像样板和对应的应识别的结果输入人工神经网络，网络就会通过自学习功能，慢慢学会识别类似的图像。自学习功能对于预测有特别重要的意义。预期未来的人工神经网络计算机将为人类提供经济预测、效益预测，其应用前途是很远大的。
②具有联想存储功能。用人工神经网络的反馈网络就可以实现这种联想。
③具有高速寻找优化解的能力。寻找一个复杂问题的优化解，往往需要很大的计算量，利用一个针对某问题而设计的反馈型人工神经网络，发挥计算机的高速运算能力，可能很快找到优化解。
Ⅷ 卷积神经网络的模型问题
怎么又是你.....
网络自然是搭建起来的啊，比如CNN，一层一层地建，如果你是用别人已经建内好的网络，比如最简容单的LeNet-5，那么Tensorflow中会直接提供你一个Net；
但是如果你是自定义网络类型，那么需要继承nn.Noles，然后重新定义网络结构，封装成一个Net，
总结起来，模型是很多数学公式搭在一起，然鹅，数学公式是封装好的，可以相互交流哈