Tensorflow入门

TensorFlow简介

含义

Tensorflow是Goolgle开源的第二代用于数字计算的软件库，起初是为了研究机器学习和深度神经网络开发的。定义上可以理解为tensorflow是一个深度学习框架，里面有完整的数据流向和处理机制，同时封装了大量高效可用的算法和神经网络搭建方面的函数，可以在此基础上进行深度学习的开发和研究

其他深度学习框架

Teano、torch、keras、caffe、mxnet、cntk

• kears是theano框架和tensorflow前段的一个组合，构建模型的API调用方式逐渐成为主流，多个框架都对其提供了调用语法的支持
• caffe起初是一个强大的图像分类框架，提供很多预训练模型
• mxnet也是主流框架之一

模型和框架的意义

标准的模型结构分为输入、中间节点和输出，用户定义输入、中间运算流程和输出获得方式；框架TensorFlow的作用就是将这三者连通起来并按照学习规则进行运算。TensorFlow将中间节点和节点间的运算关系（OPS）定义在内部的一个图上，通过一个会话（session）记性图中ops的具体运算

• 图是静态的，只是将各个中间节点的关系搭建在一起
  节点中定义运算关系，比如加减乘除，节点连接路径上是网络参数（学习参数）
• 会话是动态的，启动后数据流向图中，按照图定义的关系运算，并将最终的结果流出
• TensorFlow分离了计算的定义和执行

数据的正向和反向传播是TensorFlow框架实现的内容，我们需要做的是定义网络架构、loss函数、优化方法和学习中的超参数

安装

基本环境已经安装完全，不详细说明，只记录觉得有用的知识点

1. 安装tensorflow-gpu版本后还需要安装CUDA和CuDNN，需要特别注意版本对应

TensorFlow 简单模型应用

搭建模型步骤

正向搭建模型

定义input、output和网络参数（W/b）

# 输入输出
X = tf.placeholder(float)
# 模型参数，定义为变量
W = tf.Variable(tf.random_normal([1]), name="weight")
# 前向结构
z = tf.multiply(x,  W) + b

反向搭建模型

反向传播，目的是根据真实值和预测值的差距反向调整网络参数以减少两者差距，不断迭代，使得模型预测值与真实值越来越接近。反向传播需要定义loss（差距的度量）和优化器（一般是梯度下降）

# 定义loss
loss = tf.reduce_mean(tf.square(Y - z))
learning_rate = 0.01
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

模型训练

下面贴出整个流程的代码

简单函数拟合

import numpy as np
import tensorflow as tf
import os
import matplotlib.pyplot as plt
train_x = np.linspace(-1, 1, 100)
train_y = 2 * train_x + np.random.randn(len(train_x)) * 0.3
# 输入 gt
X = tf.placeholder(float)
Y = tf.placeholder(float)
# 网络参数
W = tf.Variable(tf.random_normal([1]), name="weight")
b = tf.Variable(tf.zeros([1]), name="bias")
# 网络结构 输出
z = tf.multiply(X, W) + b
# loss定义
loss = tf.reduce_mean(tf.square(Y - z))

# 优化器定义
learning_rate = 0.001
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

# 模型训练
# 启动session 初始化
# 定义训练参数 epoch和batch size，进入训练循环
plotdata, output = [], []
with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    for epoch in range(20):
        for (x, y) in zip(train_x, train_y):
            sess.run(optimizer, feed_dict={X: x, Y:y})
        loss_epoch = sess.run(loss, feed_dict={X: x, Y:y})
        print("epoch {} loss {:.3f} W {} b {}".format(epoch, loss_epoch, sess.run(W), sess.run(b)))
        plotdata.append([epoch, loss_epoch])
    output = sess.run(z, feed_dict={X: train_x, Y: train_y})
plotdata = np.array(plotdata)
# 模型预测
plt.subplot(211)
plt.plot(train_x, train_y, 'ro', label='origin')
plt.plot(train_x, output, label='fn')
plt.subplot(212)
plt.plot(plotdata[:,0], plotdata[:,1], label='loss')
plt.legend()
plt.savefig("tmp.jpg")

mnist分类

import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import matplotlib.pyplot as plt
import os
import cv2
# 准备数据，测试集和训练集
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
print("输入数据 ", mnist.train.images, mnist.train.images.shape)
print("validation ", mnist.validation.images.shape, mnist.test.images.shape)
import pylab
im = mnist.train.images[1]
im = im.reshape(-1, 28) * 256
cv2.imwrite("train.png", im)

X = tf.placeholder(tf.float32, [None, 784])
Y = tf.placeholder(tf.float32, [None, 10])
# 定义网络参数
W = tf.Variable(tf.random_normal(([784, 10])))
b = tf.Variable(tf.zeros(10))
y = tf.matmul(X, W) + b
pred = tf.nn.softmax(y)
# 定义 loss
cost = -tf.reduce_mean(tf.reduce_sum(Y * tf.log(pred), axis=1))

# 定义优化器
learning_rate = 0.01
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(Y, axis=1), tf.argmax(pred, axis=1)), dtype=float), axis=0)
# 训练参数
total_epoch = 50
batch_size = 32
display_step = 1
train_len = mnist.train.images.shape[0]
saver = tf.train.Saver()
model_path = "log/name.model.ckpt"
sess = tf.Session()
sess.run(tf.global_variables_initializer())
total_loss = 0
save_sep = 10
for epoch in range(total_epoch):
    total_batch = int(train_len / batch_size)
    total_loss = 0
    for i in range(total_batch):
        left, right = i, min((i+1)*batch_size, train_len)
        train_x, train_y = mnist.train.images[left:right], mnist.train.labels[left:right]
        _, loss = sess.run([optimizer, cost], feed_dict={X: train_x, Y: train_y})
        total_loss += loss / (right - left)
    if epoch % display_step == 0:
        print("epoch: {} loss: {:.4}".format( epoch, total_loss))
    if epoch % save_sep ==0:
        save_path = saver.save(sess, model_path.replace('name', str(epoch)))
        print("model saved in ", save_path)
sess.close()

TensorFlow开发步骤

基本流程

1. 定义tensorflow的输入输出
   输入节点一般通过占位符定义，也可以直接定义（使用较少）
2. 定义tensorflow的网络参数的变量
   一般使用直接定义（tf,Variable）和字典定义
3. 定义网络结构或映射函数（运算）
4. 定义损失函数， 定义优化器（优化函数、优化目标）
5. 初始化所有变量
6. 定义训练参数
7. 模型训练，迭代更新参数得到最优解
8. 模型预测 & 模型使用

TensorFlow 编程基础

Tensor是张量数据，Flow是流，是基于数据流图的计算，Tensorflow是张量数据通过数据流图从图的一端六道另一端的计算过程，其运行机制是定义和运算相分离，操作层面上可以分为模型定义和模型运行两个
模型可以类比函数，输入输出分别是输入数据（实参）和输出结果，学习参数是待确定函数参数变量，占位符是待传入实参的形参
session与图的交互过程定义了两种数据流向机制：

• 注入机制（feed）：通过占位符向模型中传入数据
• 取回机制（fetch）：从模型中取出数据