威尼斯人线上娱乐

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

13 4月 , 2019  

面前大家曾有篇小说中提到过关于用tensorflow陶冶手写2捌2八像素点的数字的甄别,在那篇小说中咱们把手写数字图像直接碾压成了叁个7八四列的多寡开始展览辨认,但实质上,那几个图像是2捌2八长宽结构的,大家此次运用CNN卷积神经互联网来进展鉴定区别。

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

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

遵照tensorflow的MNIST手写数字识别(2)–入门篇

白话卷积神经互联网模型,tensorflow卷积神经互连网。遵照tensorflow的MNIST手写数字识别(叁)–神经互连网篇

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

卷积神经互联网自个儿的精晓是有的模仿了人眼的法力。
我们在看3个图像时不是一个像素点八个像素点去辨其余,咱们的眼睛天然地拥有大局观,大家看到有个别图像时自动地会把里面包车型地铁细节部分给聚合起来实行辨认,相反,假诺大家用个放大镜看到在那之中的依次像素点时反而不通晓那是啥东西了。

威尼斯人线上娱乐 1

1、卷积

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

所以卷积神经互联网就把各种像素点的图像举办自然水平上的模糊化,而怎么开始展览模糊化呢?它是透过采用一小片的区域限定,把那小片中的图像数据缩短其长度宽度,但净增当中度值。然后进行某种总括,最后完毕多少类似模糊化图像的指标,但以此模糊化的图像中反而能够比较易于辨别出相应的境界及形状。

在 CNN 中有多少个相当重要的定义:

2、池化

前言

如今在寻觅那地方有关的文化,本着整理巩固,分享促进的动感。所以有了那篇博文。

必要专注的是,本文受众:对机器学习感兴趣,且愿意花点时间攻读的采取(业务)程序员

自己本意是竭尽不难,易于精晓,急速上手,长期能跑出来东西,那样子才能正向激励我们的学习欲望。

依据上述标准,要求您曾经有早晚的开销经历,卑不足道的数学能力,以及擅长搜索引擎的感悟。开发条件搭建

切切实实大家可以到网上寻找相关的理论知识,那里不细讲,只在意于怎么着在tensorflow中落到实处CNN的意义。

  1. stride
  2. padding
  3. pooling

3、全连接

开发条件搭建

第2,小编愿意您是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来进行试验。

威尼斯人线上娱乐 2

一些理论知识:

前边在tensorflow分类-【老鱼学tensorflow】中早已用1般的神经网络实行过手写数字的鉴定分别,大家在丰富程序的基本功上来拓展,那篇小说的地方为:

stride,就是每跨多少步抽取信息。每一块抽取1部分音信,长宽就减弱,可是厚度增添。抽取的次第小块儿,再把它们统壹起来,就改成1个压缩后的立方体。

四、梯度下落法

卷积神经网络CNN浅析

小编建议你先把CNN当作多个黑盒子,不要关注为何,只关切结果。

那里借用了2个分辨X和o的例子来那里看原稿,正是每一趟给您一张图,你须要看清它是否包涵”X”或然”O”。并且只要必须双方选其①,不是”X”正是”O”。

威尼斯人线上娱乐 3

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

或者你第近来间就悟出了逐条像素点比较。但是,假诺图片稍微有点变化吧?像是下边这么些x,它不是正规的x,我们得以分辨它是x,

唯独对于电脑而言,它就只是1个2维矩阵,各个像素点比较肯定是不行的。

威尼斯人线上娱乐 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而言,第贰步就是领取特征,卷积就是领取猜度特征的神奇手段。而小编辈不供给钦点特征,任凭它和谐去估量,就像是上海体育场面,

俺们只需要报告它,大家喜爱左侧的,不喜欢左边的,然后它就去估摸,区分喜不喜欢的特点是黑丝,照旧奶子呢?

威尼斯人线上娱乐 6

只要,大家地方那么些例子,CNN对于X的疑惑特征如上,今后要透过那一个特色来分类。

微型总计机对于图像的体会是在矩阵上的,每一张图纸有rgb二维矩阵(不思考发光度)所以,一张图片,

应该是三x高度x宽度的矩阵。而作者辈以此例子就唯有黑白,所以能够大约标记一为白,-一为黑。是个九x9的二维矩阵。

威尼斯人线上娱乐 7

大家把上面包车型客车四个特征作为卷积核(我们这边是假若已经磨练好了CNN,锻炼建议的表征就是地点四个,大家得以因而那多个特色去分类
X ),去和输入的图像做卷积(特征的协作)。

 

威尼斯人线上娱乐 8

 

威尼斯人线上娱乐 9

 

威尼斯人线上娱乐 10

 

威尼斯人线上娱乐 11

 

威尼斯人线上娱乐 12

看完上边的,估算你也能收看特征是怎么去相配输入的,那正是贰个卷积的进度,具体的卷积总结进度如下(只显示部分):

威尼斯人线上娱乐 13

 

威尼斯人线上娱乐 14

 

威尼斯人线上娱乐 15

 

威尼斯人线上娱乐 16

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

威尼斯人线上娱乐 17

其余壹些也是1样的盘算

威尼斯人线上娱乐 18

 

威尼斯人线上娱乐 19

最终,我们整张图用卷积核总计完毕后:

威尼斯人线上娱乐 20

四个特色都划算落成后:

威尼斯人线上娱乐 21

持续地再次着上述进程,将卷积核(特征)和图中每1块进行卷积操作。最后我们会拿走一个新的二维数组。

里面的值,越接近为一表示对应地方的相配度高,越是接近-一,表示对应地点与天性的反面更相配,而值接近0的代表对应地点没有怎么关联。

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

丰盛须求的函数

pooling,正是当跨步比较大的时候,它会挂1漏万一些重点的音讯,为了解决那样的标题,就拉长一层叫pooling,事先把这几个不能缺少的消息存款和储蓄起来,然后再变成压缩后的层

本次正是用最简便的艺术给我们讲解那些概念,因为现实的各样舆论网上都有,连推导都有,所以本文首要便是给我们做个铺垫,如有错误请指正,相互学习共同升高。

池化层

在图像经过上述的卷积层后,得到了2个新的矩阵,而矩阵的分寸,则在于卷积核的尺寸,和边缘的填充方式,总而言之,在那个XXOO的例子中,大家收获了柒x7的矩阵。池化正是减掉图像尺寸和像素关联性的操作,只保留我们感兴趣(对于分类有含义)的音讯。

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

威尼斯人线上娱乐 22

 

威尼斯人线上娱乐 23

 

威尼斯人线上娱乐 24

 

威尼斯人线上娱乐 25

看完上边的图,你应有领会池化是怎样操作了。

万般景况下,大家选择的都以贰x②的最大池,便是在2×2的限量内,取最大值。因为最大池化(max-pooling)保留了每一个小块内的最大值,所以它相当于保留了这一块最棒的合营结果(因为值越接近壹意味着1贰分越好)。这也就表示它不会实际关切窗口内到底是哪叁个位置相称了,而只关心是还是不是有有些地点相配上了。

那也就可见看到,CNN能够察觉图像中是还是不是具备某种特征,而不用在意到底在哪儿具有那种特点。那也就能够协理化解在此之前涉嫌的微处理器逐1像素相称的一步一趋做法。

威尼斯人线上娱乐 26

1致的操作之后,大家就输出了三个四x四的矩阵。

生成权重变量

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

使用tensorflow搭建CNN,也正是卷积神经互连网是一件很简单的事体,笔者遵照法定教程中利用MNIST手写数字识别为例进行代码,整个程序也基本与合法例程一致,可是在比较易于吸引的地方投入了诠释,有早晚的机械学习也许卷积神经网络制式的人都应有能够长足明白到代码的意义。

二、卷积神经网络讲解

全连接层

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

威尼斯人线上娱乐 27

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

威尼斯人线上娱乐 28

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

威尼斯人线上娱乐 29

 

威尼斯人线上娱乐 30

看上图(圈圈里面包车型大巴多少个至关心爱戴要音讯点),那里有个新的图像丢进大家的CNN了,依据卷积>池化>卷积>池化>全连接的步骤,大家得到了新的全连接数据,然后去跟我们的标准比对,得出相似度,能够观望,相似度是X的为0.玖二所以,大家觉得那一个输入是X。

一个宗旨的卷积神经互连网即是那样子的。回看一下,它的结构:

威尼斯人线上娱乐 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的下载太慢了(下载地址)。

下载好之后,按下边包车型地铁职位放,你大概要先运维下程序,让她协调创办文件夹,不然,你就手动创制吧。

威尼斯人线上娱乐 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×2八尺寸,然后有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、卷积难题,卷积核不只是2维的,多通道卷积时卷积核就是三个维度的

如图是家弦户诵的LeNet-伍(识别数字的卷积网络),成效和舆论在此,那里拿出去只是为着表明一(Wissu)下卷积神经网络的模型,就像是图中那么,经过再叁,卷积,池化(又叫子采集样品),然后全连接,就完工了。

概念输入数据

# 定义输入数据
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])

叁、最后举行查看的时候,借使二遍性加载出装有的验证集,出现了内部存款和储蓄器爆掉的状态,由于是选拔的是云端的服务器,只怕内部存款和储蓄器小壹些,借使内部存款和储蓄器够用能够间接全体加载上看结果

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)

4、这么些顺序原始版本迭代次数设置了三千0次,那么些次数差不多要演练数个钟头(在不应用GPU的事态下),那一个次数能够遵从要求更改。

二.3.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矩阵其实1般便是我们输入的图形的灰度值(能够设想成一张5px*5px的黑白照片,然后把黑白照片上的每二个点转化成矩阵上的每三个成分),然后下面的风流部分矩阵正是我们的过滤器,用来领取特征,(其实应当叫滤波器大概卷积核),让卷积核在输入矩阵上开始展览从左到右,从上到下滑动,然后每三次滑动,八个矩阵对应地方的要素相乘然后求和,便是右手那些矩阵的多个元素。

概念神经网络全连接层一

# 定义神经网络全连接层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.二 滑动的增进率-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)

地点那张图纸从左到右,每一趟滑动的时候只移动1格,不过其实它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)

贰.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,比原来的图片要小了,因为边界没有了,所以要思考这一个界限的题材,网上说卷积的边界处理有二种办法:

总体代码

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中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方式

贰.三.4 卷积与神经互联网

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

2.4 池化

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

2.5 全连接

左侧的是未曾未有进展卷积的全连接,假使图片是一千*1000的,然后用1M的神经细胞去感知,最终索要⑩^11个权值作为参数,右侧是透过卷积过的,每一个圆点是一个神经元,因而只是用2个卷积核的话,其实只要十0*十^陆,数量级就大大收缩,而且因为提取的正是所需的特点,所以在加快陶冶进程的时候对结果并不会爆发过大的影响,甚至特别规范。

二.陆 梯度降低法

莫可是几个人会问,那么些卷积核是怎么得出来的呢,其实它是被种种陶冶集中磨练练出来的,利用梯度下落法使得我们的参数到达最优解。

梯度下跌法能够那样子掌握,假若大家正在下山,要使得下山的门径达到最短,于是大家每走一步事先就判断一下四处从哪个方向跨出这一步会最短,然则学过算法的人应当都明白,有个难题即使,我们当下走的这一步是如今岗位最短的,不过真的从山顶到山脚最短路径或者并不经过这一步。也便是说这是个部分最优解,而不是全局最优解,大家收获的门路并不一定是最短的,但是也充足优秀,原因尽管,获得最优解费时吃力,性价比并不高。那1个知识点依旧提出大家伙去看一下印度孟买理工科Andrew Ng的《机器学习》,然后就能知道地点所说的权值参数要少的意思了。

2.7最后 softmax

softmax是分类用的,说一向一点正是归一化,因为那些店最棒跟例子结合起来,所以一时不多说,感兴趣的能够去网上找,也能够关注前面包车型客车多重作品。

三、总结

其实感觉讲的并不深刻,因而还是盼望各位能协调去仔细切磋一下,那里给各位1些基础呢,读起杂文和数学公式来会更轻松一些。

四、参考文章

神经互连网介绍

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

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

卷积神经互联网(CNN)

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

数据挖掘种类(拾)——卷积神经网络算法的三个完毕(转)

Matlab/DeepLearnToolbox

Deep Learning随想笔记之(肆)CNN卷积神经网络推导和兑现

Deep Learning散文笔记之(五)CNN卷积神经网络代码领会

斯坦福  池化

CNN神经网络层次分析

深度学习笔记壹(卷积神经互连网)

CNN公式推导

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

残差与引用误差的区分

反向传导算法

图像卷积与滤波的片段知识点

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

卷积神经网络(lenet)

激活函数的功能

神经互连网入门第壹部分

神经网络入门第三有的

卷积神经网络周全剖析

Deep learning:四101(Dropout简单掌握)

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

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

MATLAB conv二卷积的完结


相关文章

发表评论

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

网站地图xml地图