黄岛做网站哪家好,响应式网站推广,汽车门户网站程序,青岛市黄岛区城市建设局 网站Tensorflow •使用图 (graph) 来表示计算任务. • 在被称之为 会话 (Session) 的上下文 (context) 中执行图. • 使用 tensor 表示数据. • 通过 变量 (Variable) 维护状态. • 使用 feed 和 fetch 可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据 综述 Ten…
Tensorflow •使用图 (graph) 来表示计算任务. • 在被称之为 会话 (Session) 的上下文 (context) 中执行图. • 使用 tensor 表示数据. • 通过 变量 (Variable) 维护状态. • 使用 feed 和 fetch 可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据 综述 TensorFlow 用图来表示计算任务图中的节点被称之为operation缩写成op。一个节点获得 0 个或者多个张量 tensor执行计算产生0个或多个张量。图必须在会话(Session)里被启动会话(Session)将图的op分发到CPU或GPU之类的设备上同时提供执行op的方法这些方法执行后将产生的张量(tensor)返回 节点通常代表数学运算边表示节点之间的某种联系它负责传输多维数据(Tensors)。 概念描述 Tensor
Tensor的意思是张量可以理解为tensorflow中矩阵的表示形式。Tensor的生成方式有很多种最简单的就如
import tensorflow as tf # 在下面所有代码中都去掉了这一行默认已经导入
a tf.zeros(shape[1,2])
不过要注意因为在训练开始前所有的数据都是抽象的概念也就是说此时a只是表示这应该是个1*5的零矩阵而没有实际赋值也没有分配空间所以如果此时print,就会出现如下情况:
print(a)
#Tensor(zeros:0, shape(1, 2), dtypefloat32)
只有在训练过程开始后才能获得a的实际值
sess tf.InteractiveSession()
print(sess.run(a))
#[[ 0. 0.]]
更详细的Tensor 的理解见你真的懂TensorFlow吗Tensor是神马为什么还会Flow? Variable
故名思议是变量的意思。一般用来表示图中的各计算参数包括矩阵向量等。 变量 Variable是维护图执行过程中的状态信息的. 需要它来保持和更新参数值是需要动态调整的。 一个 变量 代表着TensorFlow计算图中的一个值,能够在计算过程中使用,甚至进行修改. 例如我要表示上图中的模型那表达式就是
yRelu(Wxb)
relu是一种激活函数具体可见这里这里W和b是我要用来训练的参数那么此时这两个值就可以用Variable来表示。Variable的初始函数有很多其他选项这里先不提只输入一个Tensor也是可以的
W tf.Variable(tf.zeros(shape[1,2]))
注意此时W一样是一个抽象的概念而且与Tensor不同Variable必须初始化以后才有具体的值。
tensor tf.zeros(shape[1,2])
variable tf.Variable(tensor)
sess tf.InteractiveSession()
# print(sess.run(variable)) # 会报错
sess.run(tf.initialize_all_variables()) # 对variable进行初始化
print(sess.run(variable))
#[[ 0. 0.]]
tf.initialize_all_variables是预先对变量初始化Tensorflow 的变量必须先初始化然后才有值而常值张量是不需要的 placeholder
又叫占位符同样是一个抽象的概念。用于表示输入输出数据的格式。告诉系统这里有一个值/向量/矩阵现在我没法给你具体数值不过我正式运行的时候会补上的例如上式中的x和y。因为没有具体数值所以只要指定尺寸即可
x tf.placeholder(tf.float32,[1, 5],nameinput)
y tf.placeholder(tf.float32,[None, 5],nameinput)上面有两种形式第一种x表示输入是一个[1,5]的横向量。 而第二种形式表示输入是一个[?,5]的矩阵。那么什么情况下会这么用呢?就是需要输入一批[1,5]的数据的时候。比如我有一批共10个数据那我可以表示成[10,5]的矩阵。如果是一批5个那就是[5,5]的矩阵。tensorflow会自动进行批处理
Session
session也就是会话。session是抽象模型的实现者。为什么之前的代码多处要用到session因为模型是抽象的嘛只有实现了模型以后才能够得到具体的值。同样具体的参数训练预测甚至变量的实际值查询都要用到session
# 启动默认图.
sess tf.Session()
# 调用 sess 的 run() 方法, 传入 product 作为该方法的参数
# 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op)
# 向方法表明, 我们希望取回矩阵乘法 op 的输出.
result sess.run(product)# 返回值 result 是一个 numpy ndarray 对象.
print result
# [[ 12.]]# 任务完成, 需要关闭会话以释放资源。
sess.close()Session 对象在使用完后需要关闭以释放资源. 除了显式调用 close 外, 也可以使用 “with” 代码块 来自动完成关闭动作.
with tf.Session() as sess:
result sess.run([product])
print result 交互式使用 在 Python API 中使用一个会话 Session 来 启动图, 并调用 Session.run() 方法执行操作. 为了便于在 IPython 等交互环境使用 TensorFlow需要用 InteractiveSession 代替 Session 类, 使用 Tensor.eval() 和 Operation.run() 方法代替 Session.run()。
使用更加方便的 InteractiveSession 类。通过它,你可以更加灵活地构建你的代码。它能让你在运行 图的时候,插入一些计算图,这些计算图是由某些操作(operations)构成的。这对于工作在交互式环境中的人们来说非常便利,比如使用IPython。如果你没有使用 InteractiveSession ,那么你需要在启动session之前构建整个计算图,然后启动该计算图。
计算 ‘x’ 减去 ‘a’
# 进入一个交互式 TensorFlow 会话.
import tensorflow as tf
sess tf.InteractiveSession()x tf.Variable([1.0, 2.0])
a tf.constant([3.0, 3.0])# 使用初始化器 initializer op 的 run() 方法初始化 x
x.initializer.run()# 增加一个减法 sub op, 从 x 减去 a. 运行减法 op, 输出结果
sub tf.sub(x, a)
print sub.eval()
# [-2. -1.] Tensorflow 调用
with tf.Session() as sess:
with tf.device(/gpu:1):
matrix1 tf.constant([[3., 3.]])
matrix2 tf.constant([[2.],[2.]])
product tf.matmul(matrix1, matrix2)
...
设备用字符串进行标识. 目前支持的设备包括: • “/cpu:0” : 机器的 CPU. • “/gpu:0” : 机器的第一个 GPU, 如果有的话. • “/gpu:1” : 机器的第二个 GPU, 以此类推. 计算图 tensorflow的运行流程主要有2步分别是构造模型和训练
TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段. 在构建阶段, op 的执行步骤 被描述成一个图. 在执行阶段, 使用会话执行执行图中的 op.
模型构建
这里我们使用官方tutorial中的mnist数据集的分类代码公式可以写作
zWxbasoftmax(z)
那么该模型的代码描述为
# 建立抽象模型
x tf.placeholder(tf.float32, [None, 784]) # 输入占位符,None 表示其值大小不定,在这里作为第一个维度值,用以指代batch的大小,意即 x 的数量不定。
y tf.placeholder(tf.float32, [None, 10]) # 输出占位符预期输出
W tf.Variable(tf.zeros([784, 10]))
b tf.Variable(tf.zeros([10]))
a tf.nn.softmax(tf.matmul(x, W) b) # a表示模型的实际输出
# 定义损失函数和训练方法
cross_entropy tf.reduce_mean(-tf.reduce_sum(y * tf.log(a), reduction_indices[1])) # 损失函数为交叉熵#tf.reduce_sum 把minibatch里的每张图片的交叉熵值都加起来了。我们计算的交叉熵是指整个minibatch
的。optimizer tf.train.GradientDescentOptimizer(0.5) # 梯度下降法学习速率为0.5
train optimizer.minimize(cross_entropy) # 训练目标最小化损失函数
可以看到这样以来模型中的所有元素(图结构损失函数下降方法和训练目标)都已经包括在train里面。我们可以把train叫做训练模型。那么我们还需要测试模型
correct_prediction tf.equal(tf.argmax(a, 1), tf.argmax(y, 1))
accuracy tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
上述两行代码tf.argmax表示找到最大值的位置(也就是预测的分类和实际的分类)然后看看他们是否一致是就返回true,不是就返回false,这样得到一个boolean数组。tf.cast将boolean数组转成int数组最后求平均值得到分类的准确率.
实际训练
有了训练模型和测试模型以后我们就可以开始进行实际的训练了
sess tf.InteractiveSession() # 建立交互式会话
tf.initialize_all_variables().run() # 所有变量初始化
for i in range(1000):batch_xs, batch_ys mnist.train.next_batch(100) # 获得一批100个数据train.run({x: batch_xs, y: batch_ys}) # 给训练模型提供输入和输出
print(sess.run(accuracy,feed_dict{x:mnist.test.images,y:mnist.test.labels}))
可以看到在模型搭建完以后我们只要为模型提供输入和输出模型就能够自己进行训练和测试了。中间的求导求梯度反向传播等等繁杂的事情tensorflow都会帮你自动完成。 示例代码 实际操作中还包括了获取数据的代码
A very simple MNIST classifier.
See extensive documentation at
http://tensorflow.org/tutorials/mnist/beginners/index.mdfrom __future__ import absolute_import
from __future__ import division
from __future__ import print_function# Import data
from tensorflow.examples.tutorials.mnist import input_dataimport tensorflow as tfflags tf.app.flags
FLAGS flags.FLAGS
flags.DEFINE_string(data_dir, /tmp/data/, Directory for storing data) # 把数据放在/tmp/data文件夹中mnist input_data.read_data_sets(FLAGS.data_dir, one_hotTrue) # 读取数据集
#标签数据是one-hot vectors。 一个one-hot向量除了某一位的数字是1以外其余各维度数字都是0。# 建立抽象模型
x tf.placeholder(tf.float32, [None, 784]) # 占位符,
#进行模型计算a是预测y 是实际
y tf.placeholder(tf.float32, [None, 10])
W tf.Variable(tf.zeros([784, 10]))
b tf.Variable(tf.zeros([10]))
a tf.nn.softmax(tf.matmul(x, W) b)-------------------------
#输入图像X28(这个数组展开成一个向量,长度是 28x28 784。如何展开这个数组(数字间的顺序)不重要,只要保持各个图片采用相同的方式展开,展平图片的数字数组会丢失图片的二维结构信息。)
#标签数据是one-hot vectors。 一个one-hot向量除了某一位的数字是1以外其余各维度数字都是0。
------------------------------------# 定义损失函数和训练方法
cross_entropy tf.reduce_mean(-tf.reduce_sum(y * tf.log(a), reduction_indices[1])) # 损失函数为交叉熵
optimizer tf.train.GradientDescentOptimizer(0.5) # 梯度下降法学习速率为0.5
train optimizer.minimize(cross_entropy) # 训练目标最小化损失函数#成本函数是“交叉熵”(cross-entropy)。交叉熵产生于信息论里面的信息压缩编码技术,但是它后来演变成为从博弈论到机器学习等其他领域里的重要技术手段.比较粗糙的理解是,交叉熵是用来衡量我们的预测用于描述真相的低效性.
--------------------------
# Test trained model
correct_prediction tf.equal(tf.argmax(a, 1), tf.argmax(y, 1))
accuracy tf.reduce_mean(tf.cast(correct_prediction, tf.float32))#tf.argmax 是一个非常有用的函数,它能给出某个tensor对象在某一维上的其数据最大值所在的索引值。由于标签向量是由0,1组成,因此最大值1所在的索引位置就是类别标签,比如 tf.argmax(y,1) 返回的是模型对于任一输入x预测到的标签值
#tf.equal 来检测我们的预测是否真实标签匹配
---------------------
# Train
sess tf.InteractiveSession() # 建立交互式会话
tf.initialize_all_variables().run()
for i in range(1000):batch_xs, batch_ys mnist.train.next_batch(100)train.run({x: batch_xs, y: batch_ys})
print(sess.run(accuracy,feed_dict{x:mnist.test.images,y:mnist.test.labels}))
执行结果
Extracting /tmp/data/train-images-idx3-ubyte.gz
Extracting /tmp/data/train-labels-idx1-ubyte.gz
Extracting /tmp/data/t10k-images-idx3-ubyte.gz
Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
WARNING:tensorflow:From ipython-input-16-30d57c355fc3:39: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.
Instructions for updating:
Use tf.global_variables_initializer instead.
0.9144
得到的分类准确率在91%左右 使用变量实现一个简单的计数器 # 创建一个变量, 初始化为标量 0. 初始化定义初值
state tf.Variable(0, namecounter)# 创建一个 op, 其作用是使 state 增加 1
one tf.constant(1)
new_value tf.add(state, one)
update tf.assign(state, new_value)# 启动图后, 变量必须先经过初始化 (init) op 初始化,
# 才真正通过Tensorflow的initialize_all_variables对这些变量赋初值
init_op tf.initialize_all_variables()# 启动默认图, 运行 op
with tf.Session() as sess:# 运行 init opsess.run(init_op)# 打印 state 的初始值# 取回操作的输出内容, 可以在使用 Session 对象的 run() 调用 执行图时, # 传入一些 tensor, 这些 tensor 会帮助你取回结果. # 此处只取回了单个节点 state# 也可以在运行一次 op 时一起取回多个 tensor: # result sess.run([mul, intermed])print sess.run(state)# 运行 op, 更新 state, 并打印 statefor _ in range(3):sess.run(update)print sess.run(state)# 输出:# 0
# 1
# 2
# 3
过程就是建图-启动图-运行取值 Deep MNIST for Experts 见脚本 input_data.py
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the License);
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an AS IS BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Functions for downloading and reading MNIST data.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_functionimport gzip
import os
import tempfileimport numpy
from six.moves import urllib
from six.moves import xrange # pylint: disableredefined-builtin
import tensorflow as tf
from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets
#!/usr/bin/env python3
# -*- coding: utf-8 -*- import time
import input_data
import tensorflow as tf
权重初始化
初始化为一个接近0的很小的正数 def weight_variable(shape): initial tf.truncated_normal(shape, stddev0.1) return tf.Variable(initial) def bias_variable(shape): initial tf.constant(0.1, shapeshape) return tf.Variable(initial)
卷积和池化使用卷积步长为1stride size,0边距padding size
池化用简单传统的2x2大小的模板做max pooling def conv2d(x, W): return tf.nn.conv2d(x, W, strides[1,1,1,1], paddingSAME) def max_pool_2x2(x): return tf.nn.max_pool(x, ksize[1,2,2,1], strides[1,2,2,1], paddingSAME) #计算开始时间
start time.clock()
#MNIST数据输入
mnist input_data.read_data_sets(MNIST_data/, one_hotTrue) x tf.placeholder(tf.float32,[None, 784]) #图像输入向量
W tf.Variable(tf.zeros([784,10])) #权重初始化值为全零
b tf.Variable(tf.zeros([10])) #偏置初始化值为全零 #第一层卷积由一个卷积接一个maxpooling完成卷积在每个
#5x5的patch中算出32个特征。
#卷积的权重张量形状是[5, 5, 1, 32]前两个维度是patch的大小
#接着是输入的通道数目最后是输出的通道数目。
#而对于每一个输出通道都有一个对应的偏置量。
W_conv1 weight_variable([5,5,1,32])
b_conv1 bias_variable([32]) 把x变成一个4d向量其第2、第3维对应图片的宽、高最后一维代表图片的颜色通道数(因为是灰度图所以这里的通道数为1如果是rgb彩色图则为3)。 x_image tf.reshape(x, [-1,28,28,1]) #最后一维代表通道数目如果是rgb则为3
#x_image权重向量卷积加上偏置项之后应用ReLU函数之后进行max_polling
h_conv1 tf.nn.relu(conv2d(x_image,W_conv1) b_conv1)
h_pool1 max_pool_2x2(h_conv1) #实现第二层卷积 #每个5x5的patch会得到64个特征
W_conv2 weight_variable([5, 5, 32, 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)
图片尺寸变为7x7加入有1024个神经元的全连接层把池化层输出张量reshape成向量
乘上权重矩阵加上偏置然后进行ReLU W_fc1 weight_variable([7*7*64,1024])
b_fc1 bias_variable([1024]) h_pool2_flat tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) b_fc1) #Dropout 用来防止过拟合 #加在输出层之前训练过程中开启dropout测试过程中关闭
keep_prob tf.placeholder(float)
h_fc1_drop tf.nn.dropout(h_fc1, keep_prob) #输出层, 添加softmax层
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) #训练和评估模型 ADAM优化器来做梯度最速下降,feed_dict 加入参数keep_prob控制dropout比例 y_ tf.placeholder(float, [None,10])
cross_entropy -tf.reduce_sum(y_*tf.log(y_conv)) #计算交叉熵
#使用adam优化器来以0.0001的学习率来进行微调
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.Session()
sess.run(tf.global_variables_initializer()) #开始训练模型循环训练20000次
for i in range(20000): batch mnist.train.next_batch(50) #batch 大小设置为50 if i%100 0: train_accuracy accuracy.eval(sessionsess, feed_dict{x:batch[0], y_:batch[1], keep_prob:1.0}) print(step %d, train_accuracy %g %(i,train_accuracy)) #神经元输出保持不变的概率 keep_prob 为0.5 train_step.run(sessionsess, feed_dict{x:batch[0], y_:batch[1], keep_prob:0.5}) print(test accuracy %g %accuracy.eval(sessionsess, feed_dict{x:mnist.test.images, y_:mnist.test.labels, keep_prob:1.0})) end time.clock()
print(running time is %g s %(end-start))
执行结果
step 0, train_accuracy 0.22
step 100, train_accuracy 0.84
step 200, train_accuracy 0.92
step 300, train_accuracy 0.9
step 400, train_accuracy 0.96
step 500, train_accuracy 0.9
step 600, train_accuracy 1
step 700, train_accuracy 0.96
step 800, train_accuracy 0.92
step 900, train_accuracy 0.98
step 1000, train_accuracy 0.94
step 1100, train_accuracy 0.9
step 1200, train_accuracy 0.96
step 1300, train_accuracy 0.98
step 1400, train_accuracy 0.96
step 1500, train_accuracy 0.98
step 1600, train_accuracy 0.96
step 1700, train_accuracy 1
step 1800, train_accuracy 1
step 1900, train_accuracy 0.98
step 2000, train_accuracy 0.98
step 2100, train_accuracy 0.98
step 2200, train_accuracy 1
step 2300, train_accuracy 0.96
step 2400, train_accuracy 1
step 2500, train_accuracy 0.98
step 2600, train_accuracy 0.98
step 2700, train_accuracy 0.98
step 2800, train_accuracy 0.98
step 2900, train_accuracy 0.96
step 3000, train_accuracy 1
step 3100, train_accuracy 1
step 3200, train_accuracy 0.98
step 3300, train_accuracy 1
step 3400, train_accuracy 0.98
step 3500, train_accuracy 0.96
step 3600, train_accuracy 0.98
step 3700, train_accuracy 0.96
step 3800, train_accuracy 1
step 3900, train_accuracy 1
step 4000, train_accuracy 1
step 4100, train_accuracy 1
step 4200, train_accuracy 0.98
step 4300, train_accuracy 1
step 4400, train_accuracy 1
step 4500, train_accuracy 0.96
step 4600, train_accuracy 1
step 4700, train_accuracy 0.96
step 4800, train_accuracy 0.98
step 4900, train_accuracy 1
step 5000, train_accuracy 1
step 5100, train_accuracy 1
step 5200, train_accuracy 1
step 5300, train_accuracy 0.98
step 5400, train_accuracy 0.98
step 5500, train_accuracy 1
step 5600, train_accuracy 1
step 5700, train_accuracy 0.98
step 5800, train_accuracy 0.98
step 5900, train_accuracy 1
step 6000, train_accuracy 0.98
step 6100, train_accuracy 1
step 6200, train_accuracy 0.98
step 6300, train_accuracy 0.98
step 6400, train_accuracy 1
step 6500, train_accuracy 0.98
step 6600, train_accuracy 0.98
step 6700, train_accuracy 1
step 6800, train_accuracy 1
step 6900, train_accuracy 1
step 7000, train_accuracy 0.98
step 7100, train_accuracy 1
step 7200, train_accuracy 0.96
step 7300, train_accuracy 0.98
step 7400, train_accuracy 0.96
step 7500, train_accuracy 1
step 7600, train_accuracy 1
step 7700, train_accuracy 1
step 7800, train_accuracy 1
step 7900, train_accuracy 1
step 8000, train_accuracy 0.98
step 8100, train_accuracy 1
step 8200, train_accuracy 1
step 8300, train_accuracy 1
step 8400, train_accuracy 0.98
step 8500, train_accuracy 0.94
step 8600, train_accuracy 1
step 8700, train_accuracy 1
step 8800, train_accuracy 1
step 8900, train_accuracy 1
step 9000, train_accuracy 0.98
step 9100, train_accuracy 1
step 9200, train_accuracy 0.98
step 9300, train_accuracy 1
step 9400, train_accuracy 1
step 9500, train_accuracy 1
step 9600, train_accuracy 1
step 9700, train_accuracy 1
step 9800, train_accuracy 1
step 9900, train_accuracy 0.98
step 10000, train_accuracy 1
step 10100, train_accuracy 0.98
step 10200, train_accuracy 1
step 10300, train_accuracy 1
step 10400, train_accuracy 1
step 10500, train_accuracy 1
step 10600, train_accuracy 1
step 10700, train_accuracy 1
step 10800, train_accuracy 1
step 10900, train_accuracy 1
step 11000, train_accuracy 1
step 11100, train_accuracy 1
step 11200, train_accuracy 1
step 11300, train_accuracy 1
step 11400, train_accuracy 0.98
step 11500, train_accuracy 1
step 11600, train_accuracy 1
step 11700, train_accuracy 1
step 11800, train_accuracy 0.98
step 11900, train_accuracy 1
step 12000, train_accuracy 1
step 12100, train_accuracy 1
step 12200, train_accuracy 0.98
step 12300, train_accuracy 1
step 12400, train_accuracy 1
step 12500, train_accuracy 1
step 12600, train_accuracy 1
step 12700, train_accuracy 1
step 12800, train_accuracy 1
step 12900, train_accuracy 1
step 13000, train_accuracy 0.98
step 13100, train_accuracy 1
step 13200, train_accuracy 1
step 13300, train_accuracy 0.98
step 13400, train_accuracy 1
step 13500, train_accuracy 1
step 13600, train_accuracy 1
step 13700, train_accuracy 1
step 13800, train_accuracy 1
step 13900, train_accuracy 1
step 14000, train_accuracy 1
step 14100, train_accuracy 1
step 14200, train_accuracy 1
step 14300, train_accuracy 0.98
step 14400, train_accuracy 1
step 14500, train_accuracy 1
step 14600, train_accuracy 1
step 14700, train_accuracy 1
step 14800, train_accuracy 1
step 14900, train_accuracy 1
step 15000, train_accuracy 1
step 15100, train_accuracy 0.98
step 15200, train_accuracy 1
step 15300, train_accuracy 1
step 15400, train_accuracy 1
step 15500, train_accuracy 1
step 15600, train_accuracy 0.98
step 15700, train_accuracy 1
step 15800, train_accuracy 1
step 15900, train_accuracy 1
step 16000, train_accuracy 1
step 16100, train_accuracy 1
step 16200, train_accuracy 1
step 16300, train_accuracy 0.98
step 16400, train_accuracy 1
step 16500, train_accuracy 1
step 16600, train_accuracy 1
step 16700, train_accuracy 1
step 16800, train_accuracy 1
step 16900, train_accuracy 1
step 17000, train_accuracy 1
step 17100, train_accuracy 1
step 17200, train_accuracy 1
step 17300, train_accuracy 1
step 17400, train_accuracy 1
step 17500, train_accuracy 1
step 17600, train_accuracy 1
step 17700, train_accuracy 1
step 17800, train_accuracy 1
step 17900, train_accuracy 1
step 18000, train_accuracy 1
step 18100, train_accuracy 1
step 18200, train_accuracy 1
step 18300, train_accuracy 0.98
step 18400, train_accuracy 1
step 18500, train_accuracy 1
step 18600, train_accuracy 1
step 18700, train_accuracy 1
step 18800, train_accuracy 1
step 18900, train_accuracy 1
step 19000, train_accuracy 1
step 19100, train_accuracy 1
step 19200, train_accuracy 0.98
step 19300, train_accuracy 1
step 19400, train_accuracy 1
step 19500, train_accuracy 1
step 19600, train_accuracy 1
step 19700, train_accuracy 1
step 19800, train_accuracy 1
step 19900, train_accuracy 1
test accuracy 0.9938
running time is 252.157 s参考文献 tensorflow笔记流程概念和简单代码注释 tensorflow笔记流程概念和简单代码注释 TensorFlow 入门 TensorFlow 训练 MNIST 数据二 MNIST机器学习入门 MNIST For ML Beginners 深入MNIST Deep MNIST for Experts tensorflow/tensorflow/examples/tutorials/mnist/ Tensorflow英文文档 2·MNIST机器学习入门 3·深入MNIST
