白话卷积神经互连网模型,tensorflow卷积神经互连网

眼下大家曾有篇文章中涉嫌过有关用tensorflow陶冶手写2八2八像素点的数字的辨识,在那篇文章中大家把手写数字图像直接碾压成了1个78四列的数目开始展览分辨,但实在,这么些图像是2八2八长宽结构的,大家此番运用CNN卷积神经网络来拓展识别。

CNN(Convolutional Neural Networks)
卷积神经网络简单讲就是把二个图纸的数量传递给CNN,原涂层是由HavalGB组成,然后CNN把它的厚度加厚,长度宽度变小,每做1层都如此被拉开,最终形成一个分类器

基于tensorflow的MNIST手写字识别(壹)–白话卷积神经网络模型

依据tensorflow的MNIST手写数字识别(二)–入门篇

依照tensorflow的MNIST手写数字识别(三)–神经网络篇

转发:作者:地球的外星人君
链接:
来源:知乎
小说权归作者全体。商业转发请联系小编得到授权,非商业转发请表明出处。

卷积神经互联网自个儿的知道是局地模仿了人眼的功力。
大家在看五个图像时不是一个像素点叁个像素点去辨其余,我们的肉眼天然地有所大局观,大家看看某些图像时自动地会把个中的底细部分给聚合起来进行分辨,相反,假设大家用个放大镜看到里面包车型大巴相继像素点时反而不清楚那是什么东西了。

亚洲必赢官网 1

1、卷积

分享一篇小说面向普通开发者的机器学习入门,作者@狸小华

因而卷积神经互联网就把种种像素点的图像举办一定程度上的模糊化,而怎么进行模糊化呢?它是由此增选一小片的区域范围,把那小片中的图像数据减弱其长度宽度,但净增在那之中度值。然后开始展览某种计算,最后达成多少类似模糊化图像的目标,但以此模糊化的图像中反而能够比较易于辨别出相应的疆界及形状。

在 CNN 中有几个重点的定义:

2、池化

前言

近些年在查找那上面有关的学识,本着整理巩固,分享促进的动感。所以有了那篇博文。

急需小心的是,本文受众:对机械学习感兴趣,且愿意花点时间学习的利用(业务)程序员

自己本意是拼命叁郎简单,易于精晓,火速上手,长时间能跑出来东西,那样子才能正向激励大家的就学欲望。

依照上述原则,供给您早已有一定的支付经历,卑不足道的数学能力,以及擅长搜索引擎的觉醒。开发环境搭建

切切实实大家能够到网上寻找相关的理论知识,那里不细讲,只在意于怎么样在tensorflow中落到实处CNN的法力。

  1. stride
  2. padding
  3. pooling

3、全连接

支出环境搭建

第一,笔者梦想你是Linux系用户,借使您是巨硬党,装2个VirtualBox吧,然后再装个ubuntu,由于咱们只是入个门,对品质须求不高的。

机械学习有关的框架也很多,小编那里选用了Keras,后端选取的Tensorflow白话卷积神经互连网模型,tensorflow卷积神经互连网。
。那么自然的,会用到python来支付,未有python经验也莫慌,影响并十分的小。

一.ubuntu自带python 笔者就不介绍怎么设置了吗?

先安装pip(-dev
笔者用的python二.⑦,后文统1)打开你的终极,输入那一个:(笔者提议更换下apt-get为国内镜像,安装完pip后也转移为国内镜像啊)

sudo apt-get install python-pip python

2.安装tensorflow和keras,matplotlib

仍旧打开终端,输入输入

mac端:

亚洲必赢官网,source activate ml_env27

>>conda install -c menpo menpoproject
>>pip install --upgrade tensorflow (use tensorflow-gpu if you want GPU support)
>>pip install -Iv keras==1.2.2 (make sure you install version 1.2.2)
>>conda install scikit-image h5py bidict psutil imageio
安装好依赖环境

python 测试

Python

import tensorflow as tf
hello = tf.constant('Hello, TensorFlow!')
sess = tf.Session()
print(sess.run(hello))

exit()

3.以后就用anconda配置好的环境配合pycharm来进行试验。

亚洲必赢官网 2

一些理论知识:

事先在tensorflow分类-【老鱼学tensorflow】中早已用一般的神经网络举办过手写数字的辨认,大家在那多少个程序的底蕴上来进行,那篇文章的地址为:

stride,正是每跨多少步抽取音信。每一块抽取壹有的音信,长度宽度就收缩,可是厚度扩充。抽取的顺序小块儿,再把它们统1起来,就改为一个减少后的立方体。

四、梯度下跌法

卷积神经互连网CNN浅析

自身提议你先把CNN当作3个黑盒子,不要关切为啥,只关切结果。

此间借用了1个分辨X和o的例子来此地看原稿,就是历次给您一张图,你供给判定它是还是不是包括”X”大概”O”。并且只要必须双方选其一,不是”X”正是”O”。

亚洲必赢官网 3

上面看一下CNN是怎么分辨输入的图像是x依然o,假设急需您来编制程序分辨图像是x依然o,你会咋办?

只怕您第近日间就想开了逐壹像素点相比。不过,假设图片稍微有点变化吧?像是上面那个x,它不是正规的x,大家得以辨认它是x,

然则对于电脑而言,它就只是二个贰维矩阵,每一种像素点相比较肯定是十分的。

亚洲必赢官网 4

CNN正是用来缓解那类难点的,它不在意具体每种点的像素,而是通过壹种叫卷积的手腕,去提取图片的性子。

哪些是特色?
天性便是大家用来区分两种输入是否1样类的分辨点,像是这么些XXOO的例子,即使要你描述X和O的差距,你会怎么考虑?X是两条线交叉,O是查封的中空的。。。

咱俩来看个小小的的事例,尽管上边两张图,须求分类出尊敬和不爱好两类,那么您会领取什么作为有别于的性状?(手动滑稽)

亚洲必赢官网 5

import tensorflow as tf

# 准备数据
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('D:/todel/python/MNIST_data/', one_hot=True)

def add_layer(inputs, in_size, out_size, activation_function=None):
    """
    添加层
    :param inputs: 输入数据
    :param in_size: 输入数据的列数
    :param out_size: 输出数据的列数
    :param activation_function: 激励函数
    :return:
    """

    # 定义权重,初始时使用随机变量,可以简单理解为在进行梯度下降时的随机初始点,这个随机初始点要比0值好,因为如果是0值的话,反复计算就一直是固定在0中,导致可能下降不到其它位置去。
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    # 偏置shape为1行out_size列
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    # 建立神经网络线性公式:inputs * Weights + biases,我们大脑中的神经元的传递基本上也是类似这样的线性公式,这里的权重就是每个神经元传递某信号的强弱系数,偏置值是指这个神经元的原先所拥有的电位高低值
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if activation_function is None:
        # 如果没有设置激活函数,则直接就把当前信号原封不动地传递出去
        outputs = Wx_plus_b
    else:
        # 如果设置了激活函数,则会由此激活函数来对信号进行传递或抑制
        outputs = activation_function(Wx_plus_b)
    return outputs

# 定义输入数据
xs = tf.placeholder(tf.float32, [None, 28*28])
ys = tf.placeholder(tf.float32, [None, 10]) #10列,就是那个one hot结构的数据

# 定义层,输入为xs,其有28*28列,输出为10列one hot结构的数据,激励函数为softmax,对于one hot类型的数据,一般激励函数就使用softmax
prediction = add_layer(xs, 28*28, 10, activation_function=tf.nn.softmax)

# 定义loss值
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), axis=1))
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)


def computer_accuracy(v_xs, v_ys):
    """
    计算准确度
    :param v_xs:
    :param v_ys:
    :return:
    """
    # predication是从外部获得的变量
    global prediction
    # 根据小批量输入的值计算预测值
    y_pre = sess.run(prediction, feed_dict={xs:v_xs})
    correct_prediction = tf.equal(tf.argmax(y_pre, 1), tf.argmax(v_ys, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    result = sess.run(accuracy, feed_dict={xs:v_xs, ys:v_ys})
    return result

for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={xs: batch_xs, ys: batch_ys})
    if i % 50 == 0:
        # 每隔50条打印一下预测的准确率
        print(computer_accuracy(mnist.test.images, mnist.test.labels))

padding,抽取的艺术有二种,1种是抽取后的长和宽缩减,另一种是抽取后的长和宽和原来的一模一样。

5、softmax

卷积层

故此对于CNN而言,第3步就是领取特征,卷积正是提取猜想特征的神奇手段。而我们不供给内定特征,任凭它本身去测度,仿佛上航海用体育场所,

大家只供给告诉它,大家喜爱左侧的,不希罕右侧的,然后它就去测度,区分喜不喜欢的特征是黑丝,如故奶子呢?

亚洲必赢官网 6

设若,大家地点这一个事例,CNN对于X的可疑特征如上,以后要由此这个特点来分类。

处理器对于图像的体会是在矩阵上的,每一张图纸有rgb2维矩阵(不思索反射率)所以,一张图片,

相应是三x中度x宽度的矩阵。而小编辈以此例子就唯有黑白,所以能够大约标记一为白,-1为黑。是个玖x九的2维矩阵。

亚洲必赢官网 7

咱俩把地点的八个特征作为卷积核(我们这里是假若已经磨练好了CNN,磨炼建议的特点便是下边四个,大家能够透过那5性境况去分类
X ),去和输入的图像做卷积(特征的优秀)。

 

亚洲必赢官网 8

 

亚洲必赢官网 9

 

亚洲必赢官网 10

 

亚洲必赢官网 11

 

亚洲必赢官网 12

看完上边的,猜测您也能见到特征是如何去匹配输入的,那就是一个卷积的经过,具体的卷积总括进度如下(只展现部分):

亚洲必赢官网 13

 

亚洲必赢官网 14

 

亚洲必赢官网 15

 

亚洲必赢官网 16

把计算出的结果填入新的矩阵

亚洲必赢官网 17

任何1些也是均等的持筹握算

亚洲必赢官网 18

 

亚洲必赢官网 19

末尾,我们整张图用卷积核总计完结后:

亚洲必赢官网 20

四个特征都持筹握算完毕后:

亚洲必赢官网 21

频频地再一次着上述进程,将卷积核(特征)和图中每1块进行卷积操作。最终我们会收获叁个新的贰维数组。

当中的值,越接近为壹象征对应地点的相称度高,越是接近-1,表示对应地点与风味的反面更相配,而值接近0的代表对应地点并未有何样关联。

以上正是大家的卷积层,通过特征卷积,输出二个新的矩阵给下1层。

添加供给的函数

pooling,正是当跨步比较大的时候,它会挂一漏万一些最重要的音讯,为了解决这样的标题,就拉长1层叫pooling,事先把这几个不可或缺的消息囤积起来,然后再变成压缩后的层

本次就是用最简便易行的法门给大家讲解这一个概念,因为具体的种种舆论网上都有,连推导都有,所以本文首要正是给大家做个铺垫,如有错误请指正,相互学习共同升高。

池化层

在图像经过上述的卷积层后,得到了贰个新的矩阵,而矩阵的深浅,则在于卷积核的深浅,和边缘的填充情势,总而言之,在这几个XXOO的例证中,大家得到了7x七的矩阵。池化便是削减图像尺寸和像素关联性的操作,只保留大家感兴趣(对于分类有含义)的新闻。

常用的正是2x贰的最大池。

亚洲必赢官网 22

 

亚洲必赢官网 23

 

亚洲必赢官网 24

 

亚洲必赢官网 25

看完上面的图,你应该明了池化是哪些操作了。

平常状态下,我们应用的都以贰x二的最大池,便是在二x贰的限制内,取最大值。因为最大池化(max-pooling)保留了每三个小块内的最大值,所以它一定于保留了那一块最好的十分结果(因为值越接近壹意味着分外越好)。这也就意味着它不会具体关怀窗口内到底是哪四个地点匹配了,而只关切是否有某些地点相称上了。

这也就能够看出,CNN能够发现图像中是不是具备某种特征,而不用在意到底在哪儿具有那种特点。那也就可见协理缓解在此以前涉嫌的微处理器逐1像素相称的至死不悟做法。

亚洲必赢官网 26

一律的操作之后,大家就输出了二个四x四的矩阵。

生成权重变量

# 生成权重变量
def weight_variable(shape):
    # 产生一个随机变量
    init = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(init)

运用tensorflow搭建CNN,也正是卷积神经网络是一件很简单的政工,作者遵照法定教程中动用MNIST手写数字识别为例进行代码,整个程序也基本与合法例程1致,不过在可比简单迷惑的地点投入了诠释,有自然的机器学习可能卷积神经网络制式的人都应该能够十分的快懂获得代码的意思。

2、卷积神经互连网讲解

全连接层

全连接层一般是为了展平数据,输出最后分类结果前的归1化。
我们把地点获得的四x4矩阵再卷积+池化,获得二x二的矩阵

亚洲必赢官网 27

全连接正是那样子,展开数据,形成壹xn的’条’型矩阵。

亚洲必赢官网 28

然后再把全连接层连接到输出层。此前大家就说过,那里的数值,越接近一意味着关联度越大,然后我们依照这一个关联度,分辨到底是O依然X.

亚洲必赢官网 29

 

亚洲必赢官网 30

看上图(圈圈里面包车型客车多少个相当重要音信点),那里有个新的图像丢进我们的CNN了,依照卷积>池化>卷积>池化>全连接的步骤,大家得到了新的全连接数据,然后去跟大家的行业内部比对,得出相似度,可以见见,相似度是X的为0.九二所以,我们以为这些输入是X。

2在那之中坚的卷积神经互联网正是那样子的。回想一下,它的布局:

亚洲必赢官网 31

Relu是常用的激活函数,所做的劳作正是max(0,x),便是输入大于零,原样输出,小于零输出零,那里就不实行了。

定义bias变量

# 定义bias变量
def bias_variable(shape):
    # bias的初始值比权重值稍微简单点,直接用非0常量定义就可以
    init = tf.constant(0.1, shape=shape)
    return tf.Variable(init)
#encoding=utf-8 
import tensorflow as tf  
import numpy as np  
from tensorflow.examples.tutorials.mnist import input_data  
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)  
def weight_variable(shape): 
  initial = tf.truncated_normal(shape,stddev=0.1) #截断正态分布,此函数原型为尺寸、均值、标准差 
  return tf.Variable(initial) 
def bias_variable(shape): 
  initial = tf.constant(0.1,shape=shape) 
  return tf.Variable(initial) 
def conv2d(x,W): 
  return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME') # strides第0位和第3为一定为1,剩下的是卷积的横向和纵向步长 
def max_pool_2x2(x): 
  return tf.nn.max_pool(x,ksize = [1,2,2,1],strides=[1,2,2,1],padding='SAME')# 参数同上,ksize是池化块的大小 

x = tf.placeholder("float", shape=[None, 784]) 
y_ = tf.placeholder("float", shape=[None, 10]) 

# 图像转化为一个四维张量,第一个参数代表样本数量,-1表示不定,第二三参数代表图像尺寸,最后一个参数代表图像通道数 
x_image = tf.reshape(x,[-1,28,28,1]) 

# 第一层卷积加池化 
w_conv1 = weight_variable([5,5,1,32]) # 第一二参数值得卷积核尺寸大小,即patch,第三个参数是图像通道数,第四个参数是卷积核的数目,代表会出现多少个卷积特征 
b_conv1 = bias_variable([32]) 

h_conv1 = tf.nn.relu(conv2d(x_image,w_conv1)+b_conv1) 
h_pool1 = max_pool_2x2(h_conv1) 

# 第二层卷积加池化  
w_conv2 = weight_variable([5,5,32,64]) # 多通道卷积,卷积出64个特征 
b_conv2 = bias_variable([64]) 

h_conv2 = tf.nn.relu(conv2d(h_pool1,w_conv2)+b_conv2) 
h_pool2 = max_pool_2x2(h_conv2) 

# 原图像尺寸28*28,第一轮图像缩小为14*14,共有32张,第二轮后图像缩小为7*7,共有64张 

w_fc1 = weight_variable([7*7*64,1024]) 
b_fc1 = bias_variable([1024]) 

h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64]) # 展开,第一个参数为样本数量,-1未知 
f_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,w_fc1)+b_fc1) 

# dropout操作,减少过拟合 
keep_prob = tf.placeholder(tf.float32) 
h_fc1_drop = tf.nn.dropout(f_fc1,keep_prob) 

w_fc2 = weight_variable([1024,10]) 
b_fc2 = bias_variable([10]) 
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,w_fc2)+b_fc2) 

cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv)) # 定义交叉熵为loss函数 
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) # 调用优化器优化 
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1)) 
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 

sess = tf.InteractiveSession() 
sess.run(tf.initialize_all_variables()) 
for i in range(2000): 
 batch = mnist.train.next_batch(50) 
 if i%100 == 0: 
  train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1], keep_prob: 1.0}) 
  print "step %d, training accuracy %g"%(i, train_accuracy) 
 train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) 

print "test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images[0:500], y_: mnist.test.labels[0:500], keep_prob: 1.0}) 

二.壹卷积神经互连网效率

CNN达成手写数字识别

感觉,那个mnist的手写数字,跟其他语言的helloworld①样了。大家那里来总结完毕下。首先,我提出您先下载好数据集,keras的下载太慢了(下载地址)。

下载好之后,按上面包车型客车地点放,你也许要先运转下程序,让她自身创建文件夹,不然,你就手动创造吧。

亚洲必赢官网 32

新建个python文件,test.py然后输入上面包车型大巴始末

#coding: utf-8 from keras.datasets import mnist
import matplotlib.pyplot as plt
# 加载数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# 展示下第一张图
plt.imshow(X_train[0], cmap=plt.get_cmap('PuBuGn_r'))
plt.show()

运转后出来张图纸,然后关掉就行,那里只是探访我们加载数据有未有题目。

x_train,x_test是我们的图像矩阵数据,是2八x2捌大大小小,然后有12500条吧好像。然后y_train,y_test都以标签数据,标明那张图表示是数字几。

#coding: utf-8 #Simple CNN import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import Flatten
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils

seed = 7
numpy.random.seed(seed)

#加载数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# reshape to be [samples][channels][width][height] X_train = X_train.reshape(X_train.shape[0],28, 28,1).astype('float32')
X_test = X_test.reshape(X_test.shape[0],28, 28,1).astype('float32')

# normalize inputs from 0-255 to 0-1 X_train = X_train / 255 X_test = X_test / 255 # one hot encode outputs y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1]

# 简单的CNN模型
def baseline_model():
    # create model model = Sequential()
    #卷积层
    model.add(Conv2D(32, (3, 3), padding='valid', input_shape=(28, 28,1), activation='relu')) #池化层
    model.add(MaxPooling2D(pool_size=(2, 2)))
    #卷积
    model.add(Conv2D(15, (3, 3), padding='valid' ,activation='relu')) #池化
    model.add(MaxPooling2D(pool_size=(2, 2)))
    #全连接,然后输出
    model.add(Flatten())
    model.add(Dense(128, activation='relu'))
    model.add(Dense(num_classes, activation='softmax')) # Compile model
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    return model

# build the model model = baseline_model()

# Fit the model
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=128, verbose=2)

 

代码也挺不难,因为keras也是包裹的挺好的了。基本你看懂了前头的就没难题。

Epoch 1/10 3s - loss: 0.2791 - acc: 0.9203 - val_loss: 0.1420 - val_acc: 0.9579
Epoch 2/10 3s - loss: 0.1122 - acc: 0.9679 - val_loss: 0.0992 - val_acc: 0.9699
Epoch 3/10 3s - loss: 0.0724 - acc: 0.9790 - val_loss: 0.0784 - val_acc: 0.9745
Epoch 4/10 3s - loss: 0.0509 - acc: 0.9853 - val_loss: 0.0774 - val_acc: 0.9773
Epoch 5/10 3s - loss: 0.0366 - acc: 0.9898 - val_loss: 0.0626 - val_acc: 0.9794
Epoch 6/10 3s - loss: 0.0265 - acc: 0.9930 - val_loss: 0.0639 - val_acc: 0.9797
Epoch 7/10 3s - loss: 0.0185 - acc: 0.9956 - val_loss: 0.0611 - val_acc: 0.9811
Epoch 8/10 3s - loss: 0.0150 - acc: 0.9967 - val_loss: 0.0616 - val_acc: 0.9816
Epoch 9/10 4s - loss: 0.0107 - acc: 0.9980 - val_loss: 0.0604 - val_acc: 0.9821
Epoch 10/10 4s - loss: 0.0073 - acc: 0.9988 - val_loss: 0.0611 - val_acc: 0.9819

 

接下来你就能看到那么些输出,acc便是准确率了,看后边的val_acc就行。

 

概念卷积神经网络层

# 定义卷积神经网络层
def conv2d(x, W):
    # strides:结构为[1, x方向上的步长,y方向上的步长, 1],这里x方向上的步长和y方向上的步长都设置为1
    # padding可选值有VALID和SAME,VALID方式会在边界处比原始图片小一点,而SAME方式会在边界处用0来补充,从而保持跟原始图相同的大小
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

在先后中主要性注意那样几点:

我们应该掌握知名的傅里叶变换,即三个波形,能够有例外的正弦函数和余弦函数举办叠加成就,卷积神经网络也是平等,能够认为一张图纸是由各个差别风味的图形叠加而成的,所以它的意义是用来领取一定的特点,举个例证,比如给定一张图纸,然后本身只想提取它的概略,于是就须要卷积神经互连网。

定义pooling

# 为了防止跨步太大丢失掉信息,我们会在中间建立一个pooling,使其跨度减小,但在pooling时跨度可以变大一点,这样在最后的图片生成时可以把大小减小下来但同时又尽可能保存了相关的信息
def max_pool_2x2(x):
    # strides结构依然为:[1, x方向上的步长,y方向上的步长, 1],这里x方向上的步长和y方向上的步长都设置为2,这样在pool时把图像的大小给减小了
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

一、维度难题,由于大家tensorflow基于的是张量那样二个定义,张量其实正是维度扩充的矩阵,因而维度尤其主要,而且维度也是很简单使人吸引的地方。

二.贰卷积神经网络模型

编排主程序部分

二、卷积难点,卷积核不只是2维的,多通道卷积时卷积核便是三维的

如图是闻名海外的LeNet-伍(识别数字的卷积网络),效益和散文在此,那里拿出来只是为着说圣元(Synutra)(Nutrilon)下卷积神经互联网的模子,就好像图中那么,经过反复,卷积,池化(又叫子采集样品),然后全连接,就竣工了。

概念输入数据

# 定义输入数据
xs = tf.placeholder(tf.float32, [None, 28*28])
ys = tf.placeholder(tf.float32, [None, 10]) #10列,就是那个one hot结构的数据
keep_prob = tf.placeholder(tf.float32)
# 为了使用卷积神经网络,我们需要把原始的一维的数据变换成长宽表示的平面图的数据,把xs的形状变成[-1,28,28,1],-1代表先不考虑输入的图片例子多少这个维度,
# 后面的1是channel的数量,因为我们输入的图片是黑白的,因此channel是1,例如如果是RGB图像,那么channel就是3。
x_image = tf.reshape(xs, [-1, 28, 28, 1])

叁、最终举行查验的时候,假诺3遍性加载出富有的验证集,出现了内部存款和储蓄器爆掉的情形,由于是使用的是云端的服务器,大概内部存款和储蓄器小一些,要是内部存款和储蓄器够用能够一向全体加载上看结果

2.3 卷积

概念卷积层一

# 定义卷积层1,以5*5的面积进行扫描,因为黑白图片channel是1所以输入是1,输出是32个高度的值
W_conv1 = weight_variable([5, 5, 1, 32])
# bias的大小是32个长度,因此我们传入它的shape为[32]
b_conv1 = bias_variable([32])
# 定义好了Weight和bias,我们就可以定义卷积神经网络的第一个卷积层h_conv1=conv2d(x_image,W_conv1)+b_conv1,同时我们对h_conv1进行非线性处理,
# 也就是激活函数来处理喽,这里我们用的是tf.nn.relu(修正线性单元)来处理,要注意的是,因为采用了SAME的padding方式,输出图片的大小没有变化依然是28x28,
# 只是厚度变厚了,因此现在的输出大小就变成了28x28x32
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
# 最后我们再进行pooling的处理就ok啦,经过pooling的处理,输出大小就变为了14x14x32
h_pool1 = max_pool_2x2(h_conv1)

4、这一个程序原始版本迭代次数设置了三千0次,那些次数大致要操练数个小时(在不利用GPU的情况下),这一个次数可以依据须求改变。

2.三.1 卷积的法则

概念卷积层二

# 定义卷积层2
# 扫描的面积还是定义成5*5,输入大小为32,因为卷积层1中输出为32就被设置为这里的输入大小了。输出大小设定为64,也就是变得更高了
W_conv2 = weight_variable([5, 5, 32, 64])
# bias的大小是64个长度,因此我们传入它的shape为[64]
b_conv2 = bias_variable([64])
# 定义好了Weight和bias,我们就可以定义卷积神经网络的第二个卷积层h_conv2=conv2d(h_pool1,W_conv2)+b_conv2,同时我们对h_conv2进行非线性处理,
# 也就是激活函数来处理喽,这里我们用的是tf.nn.relu(修正线性单元)来处理,要注意的是,因为采用了SAME的padding方式,输出图片的大小没有变化依然是在第一层卷集层输出时的14*14,
# 只是厚度变厚了,因此现在的输出大小就变成了14x14x64
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
# 最后我们再进行pooling的处理就ok啦,经过pooling的处理,输出大小就变为了7x7x64
h_pool2 = max_pool_2x2(h_conv2)

如上就是本文的全体内容,希望对我们的就学抱有扶助,也指望大家多多帮助脚本之家。

事实上卷积很好掌握,左侧深紫红的部分的5*5矩阵其实一般正是大家输入的图形的灰度值(可以想像成一张五px*五px的黑白照片,然后把黑白照片上的每二个点转化成矩阵上的每贰个因素),然后上面包车型客车黑褐部分矩阵正是大家的过滤器,用来提取特征,(其实应当叫滤波器或然卷积核),让卷积核在输入矩阵上开始展览从左到右,从上到下滑动,然后每1回滑动,七个矩阵对应地点的成分相乘然后求和,正是右手那些矩阵的1个因素。

概念神经互联网全连接层一

# 定义神经网络全连接层1
# 其形状为h_pool2的输出形状7*7*64,输出为1024个神经元
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
# 把h_pool2的输出的包含长宽平面的信息形状转换成一个维度的数据,相当于变平的操作:[n_samples, 7, 7, 64] => [n_samples, 7*7*64]
h_pool1_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool1_flat, W_fc1) + b_fc1)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

您恐怕感兴趣的小说:

  • 详解tensorflow磨练本身的数目集实现CNN图像分类
  • python
    tensorflow基于cnn实现手写数字识别

2.叁.2 滑动的大幅度-stride

概念神经互联网全连接层二

# 定义神经网络全连接层2
# 其输入为全连接层1的输出1024,输出为0-9数字的one hot格式,因此为10列
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

上边那张图片从左到右,每趟滑动的时候只移动一格,可是其实它1遍滑动多格,那就是小幅

定义loss值

# 定义loss值
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), axis=1))
# 对于比较庞大的系统可以用AdamOptimizer比较好一点
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
# train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

二.三.三 卷积的界限处理-padding

执行

sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)

for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={xs: batch_xs, ys: batch_ys, keep_prob: 0.5})
    if i % 50 == 0:
        # 每隔50条打印一下预测的准确率
        print(computer_accuracy(mnist.test.images, mnist.test.labels))

如上海图书馆所示,卷积后的矩阵唯有叁*三,比原来的图片要小了,因为边界未有了,所以要思索这些界限的题材,网上说卷积的边界处理有二种办法:

任何代码

import tensorflow as tf

def add_layer(inputs, in_size, out_size, activation_function=None):
    """
    添加层
    :param inputs: 输入数据
    :param in_size: 输入数据的列数
    :param out_size: 输出数据的列数
    :param activation_function: 激励函数
    :return:
    """

    # 定义权重,初始时使用随机变量,可以简单理解为在进行梯度下降时的随机初始点,这个随机初始点要比0值好,因为如果是0值的话,反复计算就一直是固定在0中,导致可能下降不到其它位置去。
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    # 偏置shape为1行out_size列
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    # 建立神经网络线性公式:inputs * Weights + biases,我们大脑中的神经元的传递基本上也是类似这样的线性公式,这里的权重就是每个神经元传递某信号的强弱系数,偏置值是指这个神经元的原先所拥有的电位高低值
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if activation_function is None:
        # 如果没有设置激活函数,则直接就把当前信号原封不动地传递出去
        outputs = Wx_plus_b
    else:
        # 如果设置了激活函数,则会由此激活函数来对信号进行传递或抑制
        outputs = activation_function(Wx_plus_b)
    return outputs

def computer_accuracy(v_xs, v_ys):
    """
    计算准确度
    :param v_xs:
    :param v_ys:
    :return:
    """
    # predication是从外部获得的变量
    global prediction
    # 根据小批量输入的值计算预测值
    y_pre = sess.run(prediction, feed_dict={xs:v_xs, keep_prob: 1})
    correct_prediction = tf.equal(tf.argmax(y_pre, 1), tf.argmax(v_ys, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    result = sess.run(accuracy, feed_dict={xs:v_xs, ys:v_ys, keep_prob: 1})
    return result


# 生成权重变量
def weight_variable(shape):
    # 产生一个随机变量
    init = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(init)

# 定义bias变量
def bias_variable(shape):
    # bias的初始值比权重值稍微简单点,直接用非0常量定义就可以
    init = tf.constant(0.1, shape=shape)
    return tf.Variable(init)

# 定义卷积神经网络层
def conv2d(x, W):
    # strides:结构为[1, x方向上的步长,y方向上的步长, 1],这里x方向上的步长和y方向上的步长都设置为1
    # padding可选值有VALID和SAME,VALID方式会在边界处比原始图片小一点,而SAME方式会在边界处用0来补充,从而保持跟原始图相同的大小
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

# 为了防止跨步太大丢失掉信息,我们会在中间建立一个pooling,使其跨度减小,但在pooling时跨度可以变大一点,这样在最后的图片生成时可以把大小减小下来但同时又尽可能保存了相关的信息
def max_pool_2x2(x):
    # strides结构依然为:[1, x方向上的步长,y方向上的步长, 1],这里x方向上的步长和y方向上的步长都设置为2,这样在pool时把图像的大小给减小了
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')


# 准备数据
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('D:/todel/python/MNIST_data/', one_hot=True)


# 定义输入数据
xs = tf.placeholder(tf.float32, [None, 28*28])
ys = tf.placeholder(tf.float32, [None, 10]) #10列,就是那个one hot结构的数据
keep_prob = tf.placeholder(tf.float32)
# 为了使用卷积神经网络,我们需要把原始的一维的数据变换成长宽表示的平面图的数据,把xs的形状变成[-1,28,28,1],-1代表先不考虑输入的图片例子多少这个维度,
# 后面的1是channel的数量,因为我们输入的图片是黑白的,因此channel是1,例如如果是RGB图像,那么channel就是3。
x_image = tf.reshape(xs, [-1, 28, 28, 1])

# 定义卷积层1,以5*5的面积进行扫描,因为黑白图片channel是1所以输入是1,输出是32个高度的值
W_conv1 = weight_variable([5, 5, 1, 32])
# bias的大小是32个长度,因此我们传入它的shape为[32]
b_conv1 = bias_variable([32])
# 定义好了Weight和bias,我们就可以定义卷积神经网络的第一个卷积层h_conv1=conv2d(x_image,W_conv1)+b_conv1,同时我们对h_conv1进行非线性处理,
# 也就是激活函数来处理喽,这里我们用的是tf.nn.relu(修正线性单元)来处理,要注意的是,因为采用了SAME的padding方式,输出图片的大小没有变化依然是28x28,
# 只是厚度变厚了,因此现在的输出大小就变成了28x28x32
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
# 最后我们再进行pooling的处理就ok啦,经过pooling的处理,输出大小就变为了14x14x32
h_pool1 = max_pool_2x2(h_conv1)

# 定义卷积层2
# 扫描的面积还是定义成5*5,输入大小为32,因为卷积层1中输出为32就被设置为这里的输入大小了。输出大小设定为64,也就是变得更高了
W_conv2 = weight_variable([5, 5, 32, 64])
# bias的大小是64个长度,因此我们传入它的shape为[64]
b_conv2 = bias_variable([64])
# 定义好了Weight和bias,我们就可以定义卷积神经网络的第二个卷积层h_conv2=conv2d(h_pool1,W_conv2)+b_conv2,同时我们对h_conv2进行非线性处理,
# 也就是激活函数来处理喽,这里我们用的是tf.nn.relu(修正线性单元)来处理,要注意的是,因为采用了SAME的padding方式,输出图片的大小没有变化依然是在第一层卷集层输出时的14*14,
# 只是厚度变厚了,因此现在的输出大小就变成了14x14x64
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
# 最后我们再进行pooling的处理就ok啦,经过pooling的处理,输出大小就变为了7x7x64
h_pool2 = max_pool_2x2(h_conv2)

# 定义神经网络全连接层1
# 其形状为h_pool2的输出形状7*7*64,输出为1024个神经元
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
# 把h_pool2的输出的包含长宽平面的信息形状转换成一个维度的数据,相当于变平的操作:[n_samples, 7, 7, 64] => [n_samples, 7*7*64]
h_pool1_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool1_flat, W_fc1) + b_fc1)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

# 定义神经网络全连接层2
# 其输入为全连接层1的输出1024,输出为0-9数字的one hot格式,因此为10列
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

# 定义loss值
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), axis=1))
# 对于比较庞大的系统可以用AdamOptimizer比较好一点
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
# train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)

for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={xs: batch_xs, ys: batch_ys, keep_prob: 0.5})
    if i % 50 == 0:
        # 每隔50条打印一下预测的准确率
        print(computer_accuracy(mnist.test.images, mnist.test.labels))

输出为:

0.0853
0.7785
0.8835
0.9084
0.9241
0.9316
0.9412
0.9463
0.9485
0.951
0.9561
0.9578
0.9599
0.9611
0.964
0.9644
0.966
0.9673
0.9687
0.9685

本次用卷积神经网络把结果进步了不少。

1、丢掉边界,也便是就按出手那多少个缩短的矩阵来。

2、复制边界,也便是把左手的最外层纹丝不动地复制过去

可是在看matlab代码和tensorflow代码的时候发现并不是那么粗略的业务。

matlab中conv2那几个“padding”参数能够设为两个值FULL,SAME,VALID

tensorflow中conv2d的”padding”参数能够设为七个值SAME,VALID

它们对边界是如此处理的,对输入的矩阵,包裹n层0,然后再依据地方所说的卷积方法举办卷积,这些n怎么求呢,

FULL:edge_row = kernel_row – 1;   edge_cols = kernel_cols – 1;

SAME:edge_row = (kernel_row – 1) / 2;edge_cols = (kernel_cols – 1) / 2;

VALID:edge_row = edge_cols = 0;

edge_row正是边的行数,kernel_row正是卷积核的行数,所以地点讲的实际上正是VALID格局

贰.三.4 卷积与神经网络

右下角就是卷积的数学公式,矩阵的应和成分相乘求和,然后加上三个偏置值

2.4 池化

池化分为二种,一种是最大池化,在当选区域中找最大的值作为抽样后的值,另1种是平均值池化,把选中的区域中的平均值作为抽样后的值,那样做的,原因是为了前边全连接的时候减弱连接数

2.5 全连接

左边的是绝非未有实行卷积的全连接,假使图片是一千*一千的,然后用1M的神经细胞去感知,最终索要10^13个权值作为参数,左边是透过卷积过的,各个圆点是3个神经元,因而只是用八个卷积核的话,其实如若100*10^6,数量级就大大收缩,而且因为提取的正是所需的表征,所以在马不解鞍磨练进程的时候对结果并不会时有发生过大的震慑,甚至更准确。

2.陆 梯度下落法

也许过几人会问,那几个卷积核是怎么得出去的呢,其实它是被各个磨炼集中陶冶练出来的,利用梯度降低法使得大家的参数到达最优解。

梯度下落法能够那样子掌握,假设大家正在下山,要使得下山的路子达到最短,于是我们每走一步事先就判断一下四方从哪些方向跨出这一步会最短,但是学过算法的人相应都理解,有个难题不怕,大家近年来走的这一步是方今地点最短的,不过真正从山头到山下最短路径或许并不经过这一步。也正是说那是个部分最优解,而不是大局最优解,大家获取的途径并不一定是最短的,可是也丰富优良,原因就算,得到最优解费时困难,性价比并不高。那二个知识点依旧提议大家伙去看一下耶路撒冷希伯来Andrew Ng的《机器学习》,然后就能明了地点所说的权值参数要少的意义了。

2.7最后 softmax

softmax是分类用的,说一贯一点便是归①化,因为那么些店最棒跟例子结合起来,所以最近不多说,感兴趣的能够去网上找,也足以关怀前面包车型客车泛滥成灾小说。

三、总结

实在感觉讲的并不深远,由此依旧愿意各位能本人去仔细研究一下,那里给各位一些基础呢,读起诗歌和数学公式来会更自在1些。

四、参考作品

神经互联网介绍

技巧向:一文读懂卷积神经互联网CNN

深度学习(卷积神经互联网)1些题材总计

卷积神经网络(CNN)

Deep Learning模型之:CNN卷积神经互联网(1)深度解析CNN

数码挖掘体系(10)——卷积神经网络算法的3个贯彻(转)

Matlab/DeepLearnToolbox

Deep Learning散文笔记之(4)CNN卷积神经互连网推导和促成

Deep Learning杂谈笔记之(五)CNN卷积神经网络代码精晓

斯坦福  池化

CNN神经网络层次分析

纵深学习笔记1(卷积神经互联网)

CNN公式推导

前向型神经网络之BPNN(附源码)

残差与固有误差的区别

反向传导算法

图像卷积与滤波的一部分知识点

CNN卷积神经网络原理简介+代码详解

卷积神经网络(lenet)

激活函数的效率

神经互联网入门第①局部

神经网络入门第1部分

卷积神经互连网健全剖析

Deep learning:四101(Dropout不难精通)

DeepLearning (6) 学习笔记整理:神经网络以及卷积神经网络

纵深卷积互连网CNN与图像语义分割

MATLAB conv二卷积的达成

网站地图xml地图