前方大家曾有篇文章中涉嫌过关于用tensorflow演习手写2八2八像素点的数字的甄别,在那篇小说中大家把手写数字图像直接碾压成了八个7八四列的数据实行识别,但实际,这几个图像是2八2八长度宽度结构的,大家此番使用CNN卷积神经网络来开始展览甄别。

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

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

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

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

转发:我:地球的外星人君
链接:
来源:知乎
文章权归小编全部。商业转发请联系我获得授权,非商业转发请评释出处。

卷积神经互联网自己的接头是有的模仿了人眼的意义。
白话卷积神经网络模型,tensorflow卷积神经互连网。笔者们在看一个图像时不是二个像素点二个像素点去分辨的,大家的眸子天然地具有大局观,我们见到有些图像时自动地会把里面包车型客车细节部分给聚合起来实行甄别,相反,借使大家用个放大镜看到里边的逐条像素点时反而不知底那是什么东西了。

金沙注册送58 1

1、卷积

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

从而卷积神经网络就把各样像素点的图像举行一定水平上的模糊化,而怎么实行模糊化呢?它是经过甄选一小片的区域限定,把这小片中的图像数据收缩其长度宽度,但净增在那之中度值。然后进行某种总括,最后达到多少类似模糊化图像的指标,但那些模糊化的图像中反而可以相比易于辨认出相应的境界及形状。

在 CNN 中有几个首要的概念:

2、池化

前言

不久前在寻觅那地点相关的知识,本着整理巩固,分享促进的神气。所以有了那篇博文。

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

本身本意是拼命叁郎简单,易于驾驭,急速上手,长时间能跑出来东西,那样子才能正向激励大家的学习欲望。

听大人讲上述原则,要求你已经有必然的支付经历,微不足道的数学能力,以及擅长搜索引擎的觉醒。开发条件搭建

现实我们能够到网上搜寻相关的理论知识,那里不细讲,只注意于怎样在tensorflow中达成CNN的效用。

  1. stride
  2. padding
  3. pooling

3、全连接

支付环境搭建

首先,笔者梦想你是Linux系用户,假使您是巨硬党,装多个Virtual博克斯吧,然后再装个ubuntu,由于我们只是入个门,对品质供给不高的。

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

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

先安装pip(-dev
自作者用的python二.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来进行试验。

金沙注册送58 2

一些理论知识:

此前在tensorflow分类-【老鱼学tensorflow】中已经用一般的神经网络实行过手写数字的鉴定识别,大家在那一个程序的底蕴上来拓展,那篇文章的地点为:

stride,正是每跨多少步抽取新闻。每1块抽取壹有个别消息,长度宽度就减少,可是厚度扩大。抽取的逐条小块儿,再把它们统一起来,就成为一个削减后的立方体。

4、梯度下落法

卷积神经网络CNN浅析

自个儿建议你先把CNN当作2个黑盒子,不要关注为啥,只关切结果。

那边借用了多少个分辨X和o的事例来此处看原稿,正是历次给你一张图,你须要看清它是还是不是带有”X”可能”O”。并且只要必须双方选其一,不是”X”正是”O”。

金沙注册送58 3

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

可能您第暂时间就想开了一1像素点比较。不过,如若图片稍微有点变化吗?像是上边这么些x,它不是明媒正娶的x,大家能够辨别它是x,

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

金沙注册送58 4

CNN便是用来缓解这类难题的,它不在意具体每种点的像素,而是经过一种叫卷积的招数,去领取图片的特性。

何以是特色?
特点正是我们用来区分三种输入是还是不是同等类的分辨点,像是那么些XXOO的例子,假设要你描述X和O的区分,你会怎么思量?X是两条线交叉,O是查封的空心的。。。

咱俩来看个小小的的例子,假使上边两张图,要求分类出爱慕和不爱好两类,那么你会提取什么作为有别于的特色?(手动滑稽)

金沙注册送58 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而言,第三步正是领取特征,卷积正是提取估算特征的神奇手段。而大家不需求钦命特征,任凭它自个儿去疑心,就好像上海体育地方,

作者们只供给报告它,咱们喜爱左侧的,不喜欢左边的,然后它就去猜想,区分喜不喜欢的特征是黑丝,依旧奶子呢?

金沙注册送58 6

1旦,大家地点那几个事例,CNN对于X的质疑特征如上,未来要因而这个特征来分类。

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

应当是3x中度x宽度的矩阵。而大家那么些事例就唯有黑白,所以可以简简单单标记壹为白,-壹为黑。是个九x9的二维矩阵。

金沙注册送58 7

我们把上边的多少个特点作为卷积核(大家那边是只要已经陶冶好了CNN,操练提议的性状正是上边八个,大家得以经过那八性子状去分类
X ),去和输入的图像做卷积(特征的匹配)。

 

金沙注册送58 8

 

金沙注册送58 9

 

金沙注册送58 10

 

金沙注册送58 11

 

金沙注册送58 12

看完上边的,预计你也能见到特征是怎样去匹配输入的,那就是多少个卷积的历程,具体的卷积总括进程如下(只显示部分):

金沙注册送58 13

 

金沙注册送58 14

 

金沙注册送58 15

 

金沙注册送58 16

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

金沙注册送58 17

任何部分也是壹律的盘算

金沙注册送58 18

 

金沙注册送58 19

最后,大家整张图用卷积核计算实现后:

金沙注册送58 20

四个特色都盘算实现后:

金沙注册送58 21

连发地重复着上述进程,将卷积核(特征)和图中每1块进行卷积操作。末了大家会获得二个新的贰维数组。

里面包车型大巴值,越接近为1意味着对应地方的相配度高,越是接近-1,表示对应地点与特点的反面更相称,而值接近0的表示对应地点并未有何样关联。

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

丰硕需要的函数

pooling,正是当跨步比较大的时候,它会挂壹漏万一些重中之重的音讯,为了缓解那样的题材,就增进一层叫pooling,事先把这一个不可缺少的新闻存款和储蓄起来,然后再变成压缩后的层

本次正是用最简单易行的主意给大家讲解这么些概念,因为实际的各类舆论网上都有,连推导都有,所以本文重要正是给大家做个铺垫,如有错误请指正,彼此学习共同进步。

池化层

在图像经过以上的卷积层后,获得了二个新的矩阵,而矩阵的尺寸,则取决于卷积核的深浅,和边缘的填写情势,同理可得,在那几个XXOO的事例中,我们取得了柒x7的矩阵。池化就是压缩图像尺寸和像素关联性的操作,只保留咱们感兴趣(对于分类有含义)的消息。

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

金沙注册送58 22

 

金沙注册送58 23

 

金沙注册送58 24

 

金沙注册送58 25

看完下边包车型地铁图,你应有明了池化是什么操作了。

常备情状下,大家使用的都是二x二的最大池,正是在二x贰的限定内,取最大值。因为最大池化(max-pooling)保留了每2个小块内的最大值,所以它也就是保留了那壹块最棒的相当结果(因为值越接近壹象征十分越好)。那也就表示它不会切实关心窗口内到底是哪一个地方相称了,而只关切是或不是有某些地点相配上了。

那也就可见看出,CNN能够察觉图像中是或不是拥有某种特征,而不用在意到底在哪个地方具有那种特征。那也就可见辅助缓解以前提到的电脑逐1像素相配的愚笨做法。

金沙注册送58 26

无差异于的操作之后,大家就输出了一个四x四的矩阵。

生成权重变量

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

选用tensorflow搭建CNN,也正是卷积神经网络是1件很简短的事务,笔者依照官方教程中应用MNIST手写数字识别为例进行代码,整个程序也基本与法定例程壹致,可是在相比便于吸引的地点进入了诠释,有必然的机械学习也许卷积神经互联网制式的人都应当能够便捷精通到代码的含义。

贰、卷积神经网络讲解

全连接层

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

金沙注册送58 27

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

金沙注册送58 28

接下来再把全连接层连接到输出层。在此之前大家就说过,那里的数值,越接近一表示关联度越大,然后大家根据这一个关联度,分辨到底是O照旧X.

金沙注册送58 29

 

金沙注册送58 30

看上海教室(圈圈里面包车型客车多少个基本点消息点),那里有个新的图像丢进大家的CNN了,遵照卷积>池化>卷积>池化>全连接的步子,大家取得了新的全连接数据,然后去跟大家的行业内部比对,得出相似度,能够看来,相似度是X的为0.九贰所以,我们认为这几个输入是X。

一个主干的卷积神经互联网正是这样子的。回看一下,它的布局:

金沙注册送58 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的下载太慢了(下载地址)。

下载好之后,按上边包车型地铁职位放,你只怕要先运维下程序,让他本人创设文件夹,不然,你就手动创建吧。

金沙注册送58 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')

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

世家应该明了知名的傅里叶变换,即3个波形,能够有例外的正弦函数和余弦函数实行叠加成就,卷积神经互联网也是千篇壹律,能够认为一张图片是由种种分裂特色的图纸叠加而成的,所以它的功用是用来提取一定的特点,举个例证,比如给定一张图片,然后小编只想提取它的差不离,于是就必要卷积神经网络。

定义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基于的是张量那样二个定义,张量其实正是维度扩张的矩阵,因而维度特别重大,而且维度也是很不难使人吸引的地方。

二.二卷积神经网络模型

编辑主程序部分

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

如图是远近闻明的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])

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、这些顺序原始版本迭代次数设置了20000次,那几个次数大约要练习数个钟头(在不接纳GPU的情况下),这些次数能够依照供给更改。

贰.三.一 卷积的原理

概念卷积层二

# 定义卷积层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)

上述便是本文的全体内容,希望对大家的学习抱有援助,也冀望大家多多辅助脚本之家。

实在卷积很好通晓,左边灰色的局地的伍*金沙注册送58,5矩阵其实壹般正是我们输入的图片的灰度值(能够设想成一张伍px*5px的黑白照片,然后把黑白照片上的每3个点转化成矩阵上的每二个要素),然后上边的艳情部分矩阵正是我们的过滤器,用来提取特征,(其实应该叫滤波器可能卷积核),让卷积核在输入矩阵上拓展从左到右,从上到下滑动,然后每一趟滑动,三个矩阵对应地点的因素相乘然后求和,便是右手那么些矩阵的三个成分。

概念神经网络全连接层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.叁.贰 滑动的增长幅度-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回滑动多格,这正是开间

定义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格局

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

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

2.4 池化

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

2.5 全连接

左手的是从未有过未有拓展卷积的全连接,假诺图片是1000*1000的,然后用1M的神经细胞去感知,最终索要十^12个权值作为参数,左边是通过卷积过的,每一种圆点是二个神经元,由此只是用2个卷积核的话,其实即便100*拾^陆,数量级就大大收缩,而且因为提取的正是所需的特征,所以在加紧磨炼进度的时候对结果并不会生出过大的影响,甚至更加可信。

贰.陆 梯度下跌法

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

梯度下落法能够那样子精晓,即便大家正在下山,要使得下山的路径达到最短,于是我们每走一步事先就判断一下大街小巷从哪些方向跨出这一步会最短,不过学过算法的人应当都明白,有个难题尽管,大家日前走的这一步是当前岗位最短的,不过真正从山顶到山脚最短路径恐怕并不经过这一步。也正是说那是个部分最优解,而不是全局最优解,我们收获的门路并不一定是最短的,不过也丰硕漂亮,原因就是,获得最优解费时吃力,性价比并不高。那二个知识点照旧提出大家伙去看一下巴黎综合理工州立Andrew Ng的《机器学习》,然后就能知道地点所说的权值参数要少的意思了。

2.7最后 softmax

softmax是分类用的,说一向一点便是归一化,因为这一个店最棒跟例子结合起来,所以近年来不多说,感兴趣的能够去网上找,也能够关切后边的三种文章。

三、总结

实则感觉讲的并不深切,因而照旧期待各位能和谐去仔细商量一下,那里给诸位一些基础呢,读起散文和数学公式来会更自在局地。

4、参考小说

神经网络介绍

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

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

卷积神经互联网(CNN)

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

数码挖掘连串(10)——卷积神经互连网算法的2个落到实处(转)

Matlab/DeepLearnToolbox

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

Deep Learning散文笔记之(5)CNN卷积神经互连网代码领会

斯坦福  池化

CNN神经网络层次分析

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

CNN公式推导

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

残差与基值误差的区别

反向传导算法

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

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

卷积神经网络(lenet)

激活函数的功用

神经互联网入门第2片段

神经互联网入门第叁有个别

卷积神经网络周到剖析

Deep learning:四10一(Dropout简单领会)

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

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

MATLAB conv二卷积的贯彻

相关文章

网站地图xml地图