白话卷积神经网络模型,tensorflow卷积神经网络

By admin in 4858.com on 2019年3月29日

眼前大家曾有篇小说中涉及过关于用tensorflow磨炼手写2828像素点的数字的分辨,在那篇小说中大家把手写数字图像直接碾压成了三个784列的数额实行辨别,但事实上,那几个图像是2828长宽结构的,大家本次运用CNN卷积神经网络来开展辨认。

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

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

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

白话卷积神经网络模型,tensorflow卷积神经网络。基于tensorflow的MNIST手写数字识别(三)–神经互连网篇

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

卷积神经网络本身的掌握是一对模仿了人眼的作用。
小编们在看2个图像时不是一个像素点1个像素点去分辨的,大家的眼眸天然地有着大局观,大家来看有个别图像时自动地会把内部的细节部分给聚合起来举行甄别,相反,如若大家用个放大镜看到里边的逐一像素点时反而不知底那是啥东西了。

4858.com 1

1、卷积

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

故此卷积神经网络就把每一个像素点的图像举办自然水平上的模糊化,而怎么开始展览模糊化呢?它是由此增选一小片的区域限制,把那小片中的图像数据裁减其长度宽度,但净增在那之中度值。然后开始展览某种总结,最后达成多少类似模糊化图像的指标,但以此模糊化的图像中反而可以相比易于辨别出相应的界线及形状。

在 CNN 中有多少个重点的定义:

2、池化

前言

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

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

我本意是拼命三郎简单,易于通晓,飞快上手,短期能跑出去东西,这样子才能正向激励大家的上学欲望。

依据上述原则,须要您曾经有肯定的花费经历,卑不足道的数学能力,以及擅长搜索引擎的觉悟。开发条件搭建

具体我们能够到网上查找相关的理论知识,那里不细讲,只注意于怎样在tensorflow中贯彻
CNN的效率。

  1. stride
  2. padding
  3. pooling

3、全连接

支付环境搭建

先是,小编盼望您是Linux系用户,倘若你是巨硬党,装三个VirtualBox吧,然后再装个ubuntu,由于大家只是入个门,对质量必要不高的。

机械学习有关的框架也很多,我那里选拔了Keras,后端采纳的Tensorflow
。那么自然的,会用到python来开发,没有python经验也莫慌,影响并非常小。

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

先安装pip(-dev
本身用的python2.7,后文统一)打开你的巅峰,输入这几个:(作者提出更换下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来进行试验。

4858.com 2

一些理论知识:

事先在tensorflow分类-【老鱼学tensorflow】中已经用一般的神经网络进行过手写数字的识别,我们在10分程序的功底上来开始展览,那篇小说的地点为:

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

四 、梯度下落法

卷积神经网络CNN浅析

本身建议你先把CNN当作3个黑盒子,不要关注为什么,只关注结果。

此处借用了二个分辨X和o的例子来那边看原稿,便是历次给你一张图,你必要看清它是还是不是包括”X”大概”O”。并且只要必须双方选其一,不是”X”就是”O”。

4858.com 3

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

也许你第一时间就想开了逐一像素点相比较。可是,假如图片稍微有点变化吗?像是上面那些x,它不是规范的x,大家得以辨认它是x,

而是对于电脑而言,它就只是一个二维矩阵,各种像素点相比较肯定是不行的。

4858.com 4

CNN即是用来消除那类难点的,它不在意具体每种点的像素,而是经过一种叫卷积的手段,去领取图片的性状。

怎么是特色?
特征就是我们用来区分二种输入是或不是同样类的分辨点,像是那几个XXOO的例证,若是要你描述X和O的界别,你会怎么考虑?X是两条线交叉,O是查封的中空的。。。

我们来看个相当小的事例,借使上边两张图,须要分类出珍贵和不希罕两类,那么您会提取什么作为有别于的特色?(手动滑稽)

4858.com 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,抽取的章程有二种,一种是抽取后的长和宽缩减,另一种是抽取后的长和宽和原来的同等。

5、softmax

卷积层

由此对于CNN而言,第①步正是领取特征,卷积正是领取估计特征的神奇手段。而笔者辈不须求内定特征,任凭它和谐去揣度,就如上海体育地方,

咱俩只须要报告它,大家喜爱右侧的,不喜欢左侧的,然后它就去推测,区分喜不喜欢的特色是黑丝,还是奶子呢?

4858.com 6

比方,大家地方那些例子,CNN对于X的嫌疑特征如上,现在要因而那些特征来分类。

微型总括机对于图像的咀嚼是在矩阵上的,每一张图片有rgb二维矩阵(不考虑折射率)所以,一张图纸,

应当是3x中度x宽度的矩阵。而小编辈以此事例就唯有黑白,所以能够省略标记1为白,-1为黑。是个9×9的二维矩阵。

4858.com 7

大家把地点的四个个性作为卷积核(大家那里是一旦已经磨练好了CNN,操练建议的特点正是地方多少个,大家能够通过那七个特征去分类
X ),去和输入的图像做卷积(特征的格外)。

 

4858.com 8

 

4858.com 9

 

4858.com 10

 

4858.com 11

 

4858.com 12

看完上边的,估量您也能收看特征是哪些去匹配输入的,那就是2个卷积的历程,具体的卷积总括进程如下(只显示部分):

4858.com 13

 

4858.com 14

 

4858.com 15

 

4858.com 16

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

4858.com 17

其余一些也是一样的计量

4858.com 18

 

4858.com 19

说到底,大家整张图用卷积核总计完结后:

4858.com 20

三个特征都一个钱打二拾伍个结完毕后:

4858.com 21

源源不断地再次着上述进程,将卷积核(特征)和图中每一块举办卷积操作。最终大家会获得三个新的二维数组。

里面包车型地铁值,越接近为1表示对应地方的匹配度高,越是接近-1,表示对应地点与特性的反面更匹配,而值接近0的表示对应地方没有何关联。

如上就是大家的卷积层,通过特色卷积,输出1个新的矩阵给下一层。

累加须要的函数

pooling,正是当跨步比较大的时候,它会以蠡测海一些关键的音信,为了消除那样的难题,就增加一层叫pooling,事先把这几个不可或缺的消息存款和储蓄起来,然后再变成压缩后的层

这一次正是用最简单易行的不二法门给大家讲解那一个概念,因为现实的各类舆论网上都有,连推导都有,所以本文首要便是给大家做个铺垫,如有错误请指正,相互学习共同进步。

池化层

在图像经过以上的卷积层后,获得了三个新的矩阵,而矩阵的高低,则在于卷积核的大小,和边缘的填充情势,综上可得,在那一个XXOO的例子中,我们获得了7×7的矩阵。池化正是减少图像尺寸和像素关联性的操作,只保留大家感兴趣(对于分类有含义)的音信。

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

4858.com 22

 

4858.com 23

 

4858.com 24

 

4858.com 25

看完上边包车型客车图,你应该清楚池化是何许操作了。

一般而言情状下,大家应用的都是2×2的最大池,便是在2×2的界定内,取最大值。因为最大池化(max-pooling)保留了每三个小块内的最大值,所以它一定于保留了这一块最棒的合作结果(因为值越接近1意味相当越好)。那也就意味着它不会实际关心窗口内到底是哪四个地方匹配了,而只关怀是否有有些地方匹配上了。

这也就可见见到,CNN能够察觉图像中是否具有某种特征,而不用在意到底在哪里具有那种特征。那也就可见协理消除以前涉嫌的微处理器逐一像素匹配的至死不悟做法。

4858.com 26

平等的操作之后,大家就输出了二个4×4的矩阵。

生成权重变量

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

使用tensorflow搭建CNN,也正是卷积神经互连网是一件相当粗略的作业,小编根据合法教程中采取MNIST手写数字识别为例进行代码,整个程序也基本与合法例程一致,可是在相比较简单迷惑的地点投入了诠释,有肯定的机器学习大概卷积神经互连网制式的人都应当能够火速通晓到代码的含义。

贰 、卷积神经互联网讲解

全连接层

全连接层一般是为着展平数据,输出最后分类结果前的归一化。
我们把上面获得的4×4矩阵再卷积+池化,获得2×2的矩阵

4858.com 27

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

4858.com 28

然后再把全连接层连接到输出层。在此以前大家就说过,那里的数值,越接近1象征关联度越大,然后大家依照那么些关联度,分辨到底是O依然X.

4858.com 29

 

4858.com 30

看上海教室(圈圈里面包车型地铁多少个第3音信点),那里有个新的图像丢进大家的CNN了,依照卷积>池化>卷积>池化>全连接的步骤,我们获取了新的全连接数据,然后去跟我们的标准比对,得出相似度,能够看看,相似度是X的为0.92
所以,大家觉得那个输入是X。

1个为主的卷积神经互连网便是那样子的。回看一下,它的结构:

4858.com 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}) 

2.1卷积神经互联网功效

CNN达成手写数字识别

倍感,那一个mnist的手写数字,跟任何语言的helloworld一样了。大家那里来差不多完成下。首先,笔者建议您先下载好数据集,keras的下载太慢了(下载地址)。

下载好以往,按下边包车型客车地点放,你可能要先运转下程序,让她本身创建文件夹,不然,你就手动成立吧。

4858.com 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是大家的图像矩阵数据,是28×28大小,然后有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.2卷积神经互连网模型

编辑主程序部分

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

如图是门到户说的LeNet-5(识别数字的卷积互连网),效能和舆论在此,那里拿出来只是为着验证一下卷积神经网络的模子,就好像图中那么,经过再三,卷积,池化(又叫子采集样品),然后全连接,就竣工了。

概念输入数据

# 定义输入数据
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回性加载出富有的验证集,出现了内部存储器爆掉的情状,由于是使用的是云端的服务器,恐怕内部存款和储蓄器小一些,假诺内部存储器够用能够一向全体加载上看结果

2.3 卷积

概念卷积层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)

四 、这一个顺序原始版本迭代次数设置了两千0次,那些次数大概要磨练数个钟头(在不采用GPU的事态下),那个次数可以依据要求更改。

2.3.1 卷积的规律

概念卷积层2

# 定义卷积层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矩阵其实一般正是大家输入的图片的灰度值(能够设想成一张5px*5px的黑白照片,然后把黑白照片上的每一种点转化成矩阵上的每三个成分),然后上面的风骚部分矩阵正是我们的过滤器,用来提取特征,(其实应当叫滤波器可能卷积核),让卷积核在输入矩阵上开始展览从左到右,从上到下滑动,然后每一遍滑动,多个矩阵对应地方的要素相乘然后求和,正是右手那么些矩阵的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.3.2 滑动的增进率-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)

下面那张图片从左到右,每一回滑动的时候只移动一格,然而实际它一遍滑动多格,那正是开间

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

2.3.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))

如上海教室所示,卷积后的矩阵只有3*3,比原先的图片要小了,因为边界没有了,所以要考虑那些界限的题材,网上说卷积的边际处理有三种方法:

全体代码

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

这一次用卷积神经互连网把结果提升了成都百货上千。

壹 、丢掉边界,也正是就按入手那些减弱的矩阵来。

贰 、复制边界,也正是把左手的最外层维持原状地复制过去

而是在看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情势

2.3.4 卷积与神经网络

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

2.4 池化

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

4858.com ,2.5 全连接

左边的是不曾没有进行卷积的全连接,假使图片是一千*一千的,然后用1M的神经细胞去感知,最后索要10^拾一个权值作为参数,右侧是通过卷积过的,每一种圆点是三个神经元,由此只是用1个卷积核的话,其实假设100*10^6,数量级就大大减弱,而且因为提取的就是所需的性状,所以在加紧练习进程的时候对结果并不会生出过大的影响,甚至特别可相信。

2.6 梯度下落法

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

梯度降低法能够那样子掌握,借使大家正在下山,要使得下山的门道达到最短,于是我们每走一步事先就判断一下各处从哪个方向跨出这一步会最短,不过学过算法的人应有都明白,有个难题不怕,大家当前走的这一步是当下地方最短的,不过的确从山上到山脚最短路径只怕并不经过这一步。也便是说那是个部分最优解,而不是全局最优解,大家取得的门道并不一定是最短的,不过也充裕卓越,原因正是,得到最优解费时步履蹒跚,性价比并不高。那贰个知识点仍旧提出我们伙去看一下巴黎综合理工科Andrew Ng的《机器学习》,然后就能领略地点所说的权值参数要少的含义了。

2.7最后 softmax

softmax是分类用的,说一向一点正是归一化,因为那些店最佳跟例子结合起来,所以一时半刻不多说,感兴趣的能够去网上找,也得以关怀前面包车型大巴千家万户小说。

三、总结

其实感觉讲的并不深刻,因而还是盼望各位能团结去仔细斟酌一下,那里给各位一些基础呢,读起杂谈和数学公式来会更轻松局地。

肆 、参考小说

神经网络介绍

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

深度学习(卷积神经网络)一些题材总括

卷积神经网络(CNN)

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

数据挖掘体系(10)——卷积神经互连网算法的多少个完毕(转)

Matlab/DeepLearnToolbox

Deep Learning杂谈笔记之(四)CNN卷积神经互联网推导和促成

Deep Learning故事集笔记之(五)CNN卷积神经互连网代码明白

斯坦福  池化

CNN神经互连网层次分析

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

CNN公式推导

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

残差与误差的界别

反向传导算法

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

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

卷积神经互联网(lenet)

激活函数的成效

神经互连网入门第1有个别

神经网络入门第三有的

卷积神经网络完善剖析

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

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

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

MATLAB conv2卷积的兑现

发表评论

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

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有