tensoeflow 教程1、2

tensoeflow 教程1、2

MNIST机器学习入门代码：

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# mnist：minst 数据集
# one_hot:独热编码
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
# x：特征占位符
# [None, 784] ：输入：未知，输出：28(图片长) x 28(图片宽)，每一张图展平成784维的向量
x = tf.placeholder('float', [None, 784])
# W: 设置权重变量
# [784，10]：输入784维的向量 x 乘以 W 输出一个10维的证据值向量 x * W
W = tf.Variable(tf.zeros([784, 10]))
# b:设置偏置变量
# [10]: W * x + b
b = tf.Variable(tf.zeros([10]))
# y: 预测值(概率值)
# softmax：用来分配概率
y = tf.nn.softmax(tf.matmul(x, W) + b)
# y_:标签占位
# [None, 10]:输入：未知，输出：10
y_ = tf.placeholder('float', [None, 10])
# cross_entropy：损失函数(交叉熵)
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
# 自动地使用反向传播算法(backpropagation algorithm),以0.01 的学习速率最小化交叉熵
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
# 初始化所有变量
init = tf.global_variables_initializer()
# "with" 代码块 来自动完成关闭Session 对象以释放资源.
with tf.Session() as sess:
    # 运行初始化
    # session:一个高效的C++后端,来进行计算。
    sess.run(init)
    # 模型循环训练1000次
    for _ in range(1000):
        # 随机抓取训练数据中的100个批处理数据点
        batch_xs, batch_ys = mnist.train.next_batch(100)
        # 用这些数据点作为参数替换之前的占位符来运行train_step
        sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
    # 评估模型效果
    # tf.argmax(y, 1)：任一输入x预测到的标签值
    # tf.argmax(y_, 1)：正确的标签
    # correct_prediction：是否匹配布尔值，正确就是1，错误就是0
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
    # tf.reduce_mean：对correct_prediction取均值
    # accuracy:预测正确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
    # feed_dict：给图喂数据
    # 正确率运行并打印
    print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

深入MNIST代码

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# mnist：minst 数据集
# one_hot:独热编码
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# InteractiveSession: 在运行图的时候，插入一些计算图.
# 如果你没有使用InteractiveSession，那么你需要在启动session之前构建整个计算图，然后启动该计算图。
sess = tf.InteractiveSession()
# x：特征占位符
# [None, 784] ：输入：未知，输出：28(图片宽) x 28(图片高)，每一张图展平成784维的向量
x = tf.placeholder("float",shape=[None, 784])
# y_:实际标签占位符
# [None, 10]:输入：未知，输出：10
y_ = tf.placeholder("float",shape = [None,10])
#===================定义函数==========================================
# 权重函数
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):
  # x: 输入的要做卷积的图片
  # W: 卷积核
  # strides: 卷积时在图像每一维的步长
  # padding: string类型,"SAME"是考虑边界，不足的时候用0 去填充周围，
  #                     "VALID"则不考虑
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
# 池化
def max_pool_2x2(x):
    # ksize：池化窗口的大小，取一个四维向量，一般是[1, height, width, 1]，
    #        因为我们不想在batch和channels上做池化，所以这两个维度设为了1
    # strides：和卷积类似，窗口在每一个维度上滑动的步长，一般也是[1, stride,stride, 1]
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
#====================第1层卷积======================================
# W_conv1: 卷积核
# [5, 5, 1, 32]: 5,5:patch 的大小:宽5，高5
#                  1: patch 输入的通道数目，对应x_image中的1
#                 32: 输出的通道数目
W_conv1 = weight_variable([5, 5, 1, 32])
# b_conv1: 偏置项
#    [32]: 对应卷积核输出通道的偏置量
b_conv1 = bias_variable([32])
# x_image: 输入图像
# [-1,28,28,1]: -1: batch 的数量,参数由 N/28/28/1 决定
#           28,28 : 图像宽28，高28
#                1: 图像通道数是1
x_image = tf.reshape(x, [-1,28,28,1])
# 激活、卷积
h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1)+b_conv1)
# 池化
h_pool1 = max_pool_2x2(h_conv1)
# ====================第2层卷积======================================
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个神经元的全连接层，用于处理整个图片。
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
# 把池化层输出的张量reshape成一些向量
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
# 乘上权重矩阵，加上偏置，然后对其使用ReLU。
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1)+b_fc1)
# =====================dropout层======================================
keep_prob = tf.placeholder("float")
# 用dropout的时候可以不用考虑scale
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
# =====================输出层(softmax层)==============================
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
# y_conv: 预测值(概率值)
# softmax：用来分配概率
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)
# ====================训练和评估模型===================================
# cross_entropy：损失函数(交叉熵)
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
# 自动地使用反向传播算法(backpropagation algorithm),以1e-4 的学习速率最小化交叉熵
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
# tf.argmax(y, 1)：任一输入x预测到的标签值
# tf.argmax(y_, 1)：正确的标签
# correct_prediction：是否匹配布尔值，正确就是1，错误就是0
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
# tf.reduce_mean：对correct_prediction取均值
# accuracy:预测正确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# 运行初始化
sess.run(tf.initialize_all_variables())
# 模型循环训练1000次
for i in range(20000):
    # 随机抓取训练数据中的50 个批处理数据点
    batch = mnist.train.next_batch(50)
    if i%100 == 0:
        # feed_dict：中加入额外的参数
        # keep_prob：来控制dropout比例
        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, y_: mnist.test.labels, keep_prob: 1.0}))

上述代码：W_fc1中的 [7 * 7 * 64, 1024]中的7*7由下列公式得到：
$$h_{out}=\frac{h_{in}-Filter+2Pad}{Stride}+1$$
$$w_{out}=\frac{w_{in}-Filter+2Pad}{Stride}+1$$
$h_{out}$：输出图像的高
$h_{in}$：输入图像的高
Filter：卷积核的高和宽
Pad: 边框的大小w
$w_{out}$：输出图像的宽
$w_{in}$：输入图像的宽