据他们说tensorflow的MNIST手写字识别,tensorflow卷积神经网络

近日大家曾有篇小说中提到过有关用tensorflow磨炼手写282八像素点的数字的识别,在那篇小说中大家把手写数字图像间接碾压成了3个7八4列的多少开始展览分辨,但实质上,那些图像是282捌长宽结构的,我们此番运用CNN卷积神经互连网来实行辨认。

CNN(Convolutional Neural Networks)
卷积神经互连网不难讲正是把多个图片的数据传递给CNN,原涂层是由WranglerGB组成,然后CNN把它的薄厚加厚,长度宽度变小,每做一层都那样被拉开,最终形成三个分类器

根据tensorflow的MNIST手写字识别(一)–白话卷积神经网络模型

听他们说tensorflow的MNIST手写数字识别(2)–入门篇

基于tensorflow的MNIST手写数字识别(叁)–神经网络篇

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

卷积神经互联网本身的知情是某些模仿了人眼的效益。
大家在看一个图像时不是2个像素点1个像素点去分辨的,大家的双眼天然地有所大局观,大家看出有些图像时自动地会把在那之中的底细部分给聚合起来实行鉴定识别,相反,借使大家用个放大镜看到里面包车型地铁一壹像素点时反而不知底那是吗东西了。

美高梅开户网址 1

1、卷积

享受1篇小说面向普通开发者的机械学习入门,作者@狸小华

故而卷积神经互联网就把各种像素点的图像实行一定程度上的模糊化,而怎么进行模糊化呢?它是透过增选一小片的区域范围,把那小片中的图像数据减少其长度宽度,但扩张此中度值。然后开展某种计算,最后达到多少类似模糊化图像的目的,但那么些模糊化的图像中反而可以比较便于辨认出相应的界线及形状。

在 CNN 中有多少个重大的概念:

2、池化

前言

前不久在物色那上头有关的文化,本着整理巩固,分享促进的旺盛。所以有了那篇博文。

须求小心的是,本文受众:对机械学习感兴趣,且愿意花点时间攻读的行使(业务)程序员

自己本意是硬着头皮简单,易于通晓,飞快上手,长时间能跑出去东西,那样子才能正向激励我们的学习欲望。

听大人说上述原则,需求您已经有早晚的支付经历,卑不足道的数学能力,以及擅长搜索引擎的觉悟。开发环境搭建

切切实实我们能够到网上寻找相关的理论知识,那里不细讲,只在意于怎样在tensorflow中落到实处CNN的效果。

  1. stride
  2. padding
  3. pooling

3、全连接

支付环境搭建

首先,小编愿意您是Linux系用户,假使您是巨硬党,装一个VirtualBox吧,然后再装个ubuntu,由于我们只是入个门,对质量供给不高的。

据他们说tensorflow的MNIST手写字识别,tensorflow卷积神经网络。机器学习相关的框架也很多,小编那边选用了Keras,后端选择的Tensorflow
。那么自然的,会用到python来支付,未有python经验也莫慌,影响并相当小。

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

先安装pip(-dev
本身用的python2.七,后文统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,就是每跨多少步抽取新闻。每一块抽取一有个别新闻,长度宽度就缩短,不过厚度扩展。抽取的一一小块儿,再把它们统一起来,就改成四个精减后的立方体。

四、梯度下跌法

卷积神经网络CNN浅析

自家建议您先把CNN当作1个黑盒子,不要关切为啥,只关怀结果。

这里借用了2个分辨X和o的例子来此处看原稿,正是每一次给你一张图,你须求判定它是还是不是包蕴”X”或许”O”。并且只要必须两方选其1,不是”X”便是”O”。

美高梅开户网址 3

上边看一下CNN是怎么辨识输入的图像是x依旧o,若是急需你来编制程序分辨图像是x依然o,你会如何做?

只怕你第一时间就想到了1壹像素点比较。然则,如若图片稍微有点变化呢?像是上边那些x,它不是标准的x,我们得以辨认它是x,

唯独对于电脑而言,它就只是几个2维矩阵,每个像素点比较肯定是尤其的。

美高梅开户网址 4

CNN就是用来缓解那类难题的,它不在意具体每一个点的像素,而是通过一种叫卷积的招数,去提取图片的表征。

什么样是特色?
特色正是我们用来区分两种输入是或不是一律类的分辨点,像是那一个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而言,第三步就是提取特征,卷积正是领取估量特征的神奇手段。而笔者辈不须求钦赐特征,任凭它和谐去预计,就如上海教室,

我们只须要告诉它,大家喜欢右侧的,不希罕左边的,然后它就去质疑,区分喜不喜欢的表征是黑丝,依旧奶子呢?

美高梅开户网址 6

假设,大家地点那一个事例,CNN对于X的估算特征如上,现在要经过那一个特点来分类。

总结机对于图像的体会是在矩阵上的,每一张图纸有rgb二维矩阵(不考虑反射率)所以,一张图片,

相应是3x中度x宽度的矩阵。而我们以此例子就只有黑白,所以能够大约标记壹为白,-1为黑。是个九x玖的二维矩阵。

美高梅开户网址 7

我们把地方的八个特色作为卷积核(大家那里是一旦已经陶冶好了CNN,练习提议的特征就是地点多个,大家能够通过那八个特点去分类
X ),去和输入的图像做卷积(特征的同盟)。

 

美高梅开户网址 8

 

美高梅开户网址 9

 

美高梅开户网址 10

 

美高梅开户网址 11

 

美高梅开户网址 12

看完上边的,猜想你也能见到特征是什么样去相称输入的,那就是二个卷积的历程,具体的卷积总括进度如下(只展现部分):

美高梅开户网址 13

 

美高梅开户网址 14

 

美高梅开户网址 15

 

美高梅开户网址 16

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

美高梅开户网址 17

任何一些也是千篇壹律的盘算

美高梅开户网址 18

 

美高梅开户网址 19

最后,大家整张图用卷积核总结实现后:

美高梅开户网址 20

几性意况都一个钱打二1五个结达成后:

美高梅开户网址 21

不断地重新着上述进度,将卷积核(特征)和图中每1块实行卷积操作。最终咱们会取得三个新的二维数组。

中间的值,越接近为1意味着对应地点的相称度高,越是接近-一,表示对应地点与特点的反面更相配,而值接近0的象征对应地方并未有怎么关系。

以上便是大家的卷积层,通过特色卷积,输出一个新的矩阵给下壹层。

累加须要的函数

pooling,正是当跨步相比较大的时候,它会挂壹漏万一些关键的音讯,为了缓解那样的题材,就拉长一层叫pooling,事先把那几个不可或缺的消息囤积起来,然后再变成压缩后的层

此次就是用最简便的措施给大家讲解这几个概念,因为具体的各个舆论网上都有,连推导都有,所以本文首要正是给大家做个铺垫,如有错误请指正,互相学习共同进步。

池化层

在图像经过上述的卷积层后,获得了1个新的矩阵,而矩阵的高低,则在于卷积核的高低,和边缘的填充格局,同理可得,在那一个XXOO的例子中,大家获取了柒x柒的矩阵。池化正是减掉图像尺寸和像素关联性的操作,只保留我们感兴趣(对于分类有含义)的音讯。

常用的正是2×2的最大池。

美高梅开户网址 22

 

美高梅开户网址 23

 

美高梅开户网址 24

 

美高梅开户网址 25

看完上面的图,你应当了然池化是怎么操作了。

一般说来状态下,大家应用的都以二x二的最大池,便是在二x2的界定内,取最大值。因为最大池化(max-pooling)保留了每二个小块内的最大值,所以它也正是保留了那一块最好的卓绝结果(因为值越接近1象征分外越好)。那也就代表它不会实际关怀窗口内到底是哪2个地方匹配了,而只关怀是或不是有某些地点相称上了。

那也就能够看到,CNN可以察觉图像中是或不是具有某种特征,而不用在意到底在哪儿具有那种特点。那也就能够辅助缓解以前提到的处理器逐壹像素匹配的刻板做法。

美高梅开户网址 26

如出1辙的操作之后,我们就输出了二个四x四的矩阵。

生成权重变量

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

采纳tensorflow搭建CNN,也便是卷积神经互连网是一件很简短的作业,笔者依据官方教程中应用MNIST手写数字识别为例实行代码,整个程序也基本与法定例程1致,不过在可比便于吸引的地点进入了诠释,有早晚的机械学习只怕卷积神经互连网制式的人都应当能够飞快理解到代码的意思。

二、卷积神经网络讲解

全连接层

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

美高梅开户网址 27

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

美高梅开户网址 28

然后再把全连接层连接到输出层。从前我们就说过,那里的数值,越接近壹意味着关联度越大,然后咱们依据那么些关联度,分辨到底是O还是X.

美高梅开户网址 29

 

美高梅开户网址 30

看上海教室(圈圈里面包车型大巴多少个首要消息点),这里有个新的图像丢进大家的CNN了,依据卷积>池化>卷积>池化>全连接的步子,大家得到了新的全连接数据,然后去跟我们的正儿八经比对,得出相似度,可以见到,相似度是X的为0.玖贰所以,大家以为这么些输入是X。

3个主干的卷积神经网络正是那样子的。回想一下,它的构造:

美高梅开户网址 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}) 

二.1卷积神经互联网效能

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')

在程序中最首要注意那样几点:

我们应该掌握著名的傅里叶变换,即八个波形,能够有两样的正弦函数和余弦函数进行叠加成就,卷积神经互联网也是壹模1样,可以认为一张图纸是由各个差别特点的图样叠加而成的,所以它的成效是用来提取一定的表征,举个例证,比如给定一张图片,然后自个儿只想提取它的概貌,于是就需要卷积神经互连网。

定义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-伍(识别数字的卷积互联网),成效和舆论在此,这里拿出来只是为了证实一下卷积神经网络的模子,如同图中那样,经过一再,卷积,池化(又叫子采集样品),然后全连接,就完工了。

概念输入数据

# 定义输入数据
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的场地下),那么些次数能够依照供给改变。

贰.3.一 卷积的规律

概念卷积层二

# 定义卷积层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*五矩阵其实壹般正是大家输入的图样的灰度值(能够设想成一张5px*5px的黑白照片,然后把黑白照片上的每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完毕手写数字识别

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

概念神经互连网全连接层2

# 定义神经网络全连接层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)

上边那张图片从左到右,每一回滑动的时候只移动一格,可是事实上它2回滑动多格,这正是上涨幅度

定义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)

贰.叁.3 卷积的界限处理-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、丢掉边界,也正是就按动手那多少个裁减的矩阵来。

贰、复制边界,相当于把左手的最外层原封不动地复制过去

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

matlab中conv二这一个“padding”参数可以设为八个值FULL,SAME,VALID

tensorflow中conv二d的”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方式

二.3.四 卷积与神经互连网

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

2.4 池化

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

2.5 全连接

左边的是未有未有拓展卷积的全连接,倘诺图片是1000*一千的,然后用1M的神经细胞去感知,最终索要10^十个权值作为参数,左边是透过卷积过的,每种圆点是三个神经元,因而只是用叁个卷积核的话,其实假如十0*十^陆,数量级就大大裁减,而且因为提取的正是所需的特色,所以在增长速度陶冶进程的时候对结果并不会产生过大的震慑,甚至更为精确。

二.六 梯度下跌法

或是过几人会问,这么些卷积核是怎么得出来的吧,其实它是被各样磨炼集中磨炼练出来的,利用梯度下落法使得大家的参数到达最优解。

梯度下跌法可以那样子精晓,要是大家正在下山,要使得下山的门径达到最短,于是大家每走一步事先就判断一下六街三市从哪个方向跨出这一步会最短,不过学过算法的人应当都知道,有个问题就是,我们脚下走的这一步是日前任务最短的,然则真的从山顶到山脚最短路径大概并不经过这一步。也正是说那是个部分最优解,而不是全局最优解,大家获得的门径并不一定是最短的,不过也丰硕优异,原因即使,得到最优解费时吃力,性价比并不高。那二个知识点依然建议咱们伙去看一下加州理工科Andrew Ng的《机器学习》,然后就能领悟地点所说的权值参数要少的意思了。

2.7最后 softmax

softmax是分类用的,说平昔一点正是归1化,因为这些店最佳跟例子结合起来,所以临时不多说,感兴趣的能够去网上找,也得以关怀后面包车型客车体系小说。

三、总结

实质上呼吸系统感染觉讲的并不深切,由此还是期待各位能团结去仔细切磋一下,那里给各位壹些基础呢,读起杂文和数学公式来会更轻松一些。

肆、参考文章

神经网络介绍

技术向:一文读懂卷积神经网络CNN

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

卷积神经网络(CNN)

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

数量挖掘连串(10)——卷积神经互连网算法的三个兑现(转)

Matlab/DeepLearnToolbox

Deep Learning故事集笔记之(4)CNN卷积神经互连网推导和完毕

Deep Learning散文笔记之(伍)CNN卷积神经互联网代码通晓

斯坦福  池化

CNN神经网络层次分析

深度学习笔记一(卷积神经网络)

CNN公式推导

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

残差与引用误差的界别

反向传导算法

图像卷积与滤波的局地知识点

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

卷积神经互联网(lenet)

激活函数的效劳

神经网络入门第贰有的

神经互连网入门第2片段

卷积神经互联网全面剖析

Deep learning:四拾一(Dropout不难明白)

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

深度卷积网络CNN与图像语义分割

MATLAB conv二卷积的贯彻

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图