TensorFlow的实战（详细代码）

1 TensorFlow基础

　　1.1 TensorFlow概要

TensorFlow使用数据流式图规划计算流程，它可以将计算映射到不同的硬件和操作系统平台。

　　1.2 TensorFlow编程模型简介

TensorFlow中的计算可表示为一个有向图(计算图)，其中每个运算操作为一个节点，每个节点可有任意多个输入和输出；
在计算图的边中流动(flow)的数据被称为张量(tensor)，tensor在计算图中flow，故命名为TensorFlow；
Session是用户使用TensorFlow的交互式接口，可通过Session的Extend方法添加新的节点和边；
反复执行计算图时一般的tensor不会被持续保留，Variable中的数据tensor会被保存。

2 TensorFlow和其他深度学习框架的对比

3 TensorFlow第一步

　　3.1 TensorFlow的编译及安装

　　3.2 TensorFlow实现Softmax Regression识别手写数字

载入MNIST数据集

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
mnist = input_data.read_data_sets("Mnist_data/", one_hot=True)

创建placeholder用以输入数据

x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 784])
#None代表不限条数的输入

给模型中的weights和biases创建Variable对象，以存储模型参数(其他的tensor将不保存)
```
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
```

构建计算公式
```
y = softmax(Wx + b)
```

定义Loss，确定优化器

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

初始化变量，执行计算

tf.global_variables_initializer().run()

for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    train_step.run({x: batch_xs, y_: batch_ys})

4 TensorFlow实现自编码器及多层感知机

　　4.1 自编码器简介

自编码器，即可以使用自身的高阶特征编码自己；
特征的稀疏表达：使用少量的基本特征组合拼装得到更高层抽象的特征；
为防止简单的映射，加入几种限制：1. 让中间隐含层节点数量小于输入、输出节点数量，相当于降维 2. 给输入数据加入噪声

　　4.2 TensorFlow实现自编码器

用到xavier参数初始化方法

def xavier_init(fan_in, fan_out, constant = 1):
    low = - constant * np.sqrt(6.0 / (fan_in + fan_out))
    high = constant * np.sqrt(6.0 / (fan_in + fan_out))
    return tf.random_uniform((fan_in, fan_out),
                                            minval=;ow, maxval=high,
                                            dtype=tf.float32)

参数初始化函数_initial_weights（创建一个名为all_weights的字典dict，将w1、b1、w2、b2全部存入其中）

def _initialize_weights(self):
    all_weights = dict()
    all_weights['w1'] = tf.Variable(xavier_init(self.n_input, self.n_hidden))
    all_weights['b1'] = tf.Variable(tf.zeros([self.n_hidden], dtype=tf.float32))
    all_weights['w2'] = tf.Variable(xavier_init([self.n_hidden,
                                                 self.n_input], dtype=tf.float32))
    all_weights['b2'] = tf.Variable(tf.zeros([self.n_input],
                                              dtype=tf.float32))
    return all_weights

　　4.3 多层感知机简介

Dropout是在训练时将神经网络某一层的输出节点数据随机丢弃一部分(训练时小于1,预测时等于1),这等于创造出了很多新的随机样本,也算是一种bagging
Dropout是在训练时将神经网络某一层的输出节点数据随机丢弃一部分(训练时小于1,预测时等于1),这等于创造出了很多新的随机样本,也算是一种bagging

　　　　1. 单侧抑制

　　　　2. 相对宽阔的兴奋边界

　　　　3. 稀疏激活性

　　4.4 TensorFlow实现多层感知机

ReLU层的权重可以用截断正态分布进行初始化,偏置可以用一些小的非零值来初始化以避免dead neuron.Sigmoid层的权重和偏置则都初始化为0即可
使用ReLU作为隐藏层,并添加dropout,就实现了多层感知机

5 TensorFlow实现卷积神经网络

　　5.1 卷积神经网络简介

CNN最初是为解决图像识别问题设计，现在也可用于时间序列信号如音频、文本；
CNN要点：局部连接、权值共享、池化层降采样

　　　　1. 局部连接和权值共享降低了参数量，减轻过拟合

　　　　2. 池化层降采样进一步降低输出参数量

只要卷积核数量足够多，能提取出各种方向的边或各种形态的点，就可以让采卷积层抽象出有效而丰富的高阶特征；
CNN参数量只与卷积核尺寸和个数有关

　　5.2 TensorFlow实现简单的卷积网络

首先载入MNIST数据集

这个CNN会有很多权重和偏置需要创建，因此先定义初始化函数以便后续重复使用

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')

def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

定义输入：x是特征，y_是真实的label

x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [NOne, 10])
x_image = tf.reshape(x, [-1, 28, 28, 1])

第一个卷积层

W_conv1 = weight_variable([5, 5, 1, 32])
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])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

第一个全连接层，后接dropout

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)

keep_prob = tf.placeholder(tf.float32)
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)

定义损失函数cross entropy，优化器使用Adam，学习速率1e-4

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv), reductioin_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

inference完成后，开始训练

tf.global_variables_initializer().run()
for i in range(20000):
    batch = mnist.train.next_batch(50)
    train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

　　5.3 TensorFlow实现进阶的卷积网络

定义初始化weight函数

　　　　1. 这里给weight加一个L2的loss，相当于做了一个L2正则化处理

　　　　2. tf.multiply让L2 loss与wl(weight loss)相乘，即用wl控制L2 loss的大小(tf.mutmul矩阵乘法、tf.multiply点乘）

　　　　3. 使用tf.add_to_collection把weight loss同意存到名为“losses"的列表中（tf.get_colletion("name")获取列表）

def variable_with_weight_loss(shape, stddev, wl):
    var = tf.Variable(tf.truncated_normal(shape, stddev=stddev))
    if wl is not None:
        weight_loss = tf.multiply(tf.nn.l2_loss(var), wl, name='weight_loss')
        tf.add_to_collection('losses', weight_loss)
    return var

第一个卷积层

weight1 = variable_with_weight_loss(shape=[5, 5, 3, 64], stddev=5e-2, wl=0.0)
kernel1 = tf.nn.conv2d(image_input, weight1, [1, 1, 1, 1], padding='SAME')
bias = tf.Variable(tf.constant(0.0, shape[64]))
conv1 = tf.nn.relu(tf.nn.bias_add(kernel1, bias1))
pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME')
norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)

数据增强(Data Augmentation)：对图片进行翻转、随机剪切，制造更多样本

6 TensorFLow实现经典卷积神经网络

　　6.1 TensorFlow实现AlexNet

使用ReLu，在较深的网络中效果好于Sigmoid，解决了Sigmoid在深层网络中梯度弥散问题
使用Dropout，避免模型过拟合
提出LRN
使用CUDA加速训练

数据增强

def inference(images):
    parameters = []
    
    with tf.nn.name_scope('conv1') as scope:
        kernel = tf.Variable(tf.truncated_normal([11, 11, 3, 64], 
                                     dtype=tf.float32, stddev=1e-1), name='weights')
        conv = tf.nn.con2d(images, kernel, [1, 4, 4, 1], padding='SAME')
        biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),
                                     trainable=True, name='biases')
        bias = tf.nn.bias_add(conv, biases)
        conv1 = tf.nn.relu(bias, name=scope)
        print_activation(conv1)
        parameters += [kernel, biases]

        lrn1 = tf.nn.lrn(conv1, 4, bias=1.0, alpha=0.001/9, beta=0.75, name='lrn1')
        pool1 = tf.nn.max_pool(lrn1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
                                            padding='VALID', name='pool1')
        print_activations(pool1)

6.2 TensorFlow实现VGGNet

卷积核都为3x3，池化层都为2x2
3个3x3卷积层串联相当于1个7x7卷积层(感受野相同)，参数为后者55%
使用数据增强

vgg16包含很多层，先创建函数conv_op、fc_op和mpool_op

def conv_op(input_op, name, kh, kw, n_out, dh, dw, p):
    n_in = input_op.get_shape()[-1].value
    
    with tf.name_scope(name) as scope:
        kernel = tf.get_variable(scope+"w", shape=[kh, kw, n_in, n_out], dtype=tf.float32,
                                            initializer=tf.contrib.layers.xavier_initializer_conv2d())
        conv = tf.nn.conv2d(input_op, kernel, (1, dh, dw, 1), padding='SAME')
        bias_init_val = tf.constant(0.0, shape=[n_out], dtype=tf.float32)
        biases = tf.Variable(bias_init_val, trainable=True, name='b')
        z = tf.nn.bias_add(conv, biases)
        activation = tf.nn.relu(z, name=scope)
        p += [kernel, biases]
        return activation

def fc_op(input_op, name, n_out, p):
    n_in = input_op.get_shape()[-1].value

    with tf.name_scope(name) as scope:
        kernel = tf.get_variable(scope+"w", shape=[n_in, n_out], dtype=tf.float32,
                                            initializer=tf.contrib.layers.xavier_initializer())
        biases = tf.Variable(tf.constant(0.1, shape=[n_out], dtype=tf.float32), name='b')
        activation = tf.nn.relu_layer(input_op, kernel, biases, name=scope)
        p += [kernel, biases]
        return activation

def mpool_op(input_op, name, kh, kw, dh, dw):
    return tf.nn.max_pool(input_op, ksize=[1, kh, kw, 1], strides=[1, dh, dw, 1],
                                     padding='SAME', name=name)

完成创建函数，开始构建VGG16网络结构

def inference_op(input_op, keep_prob):
    p = []
    
    conv1_1 = conv_op(input_op, name="conv1_1", kh=3, kw=3, n_out=64, dh=1, dw=1,
                                    p=p)
    conv1_2 = conv_op(conv1_1, name="conv1_2", kh=3,pool1",w=3, n_out=64, dh=1, dw=1,
                                    p=p)
    pool1 = mpool_op(conv1_2, name="pool1", kh=2, kw=2, dw=2, dh=2)
    ...

　　6.3 TensorFlow实现Google Inception Net

Inception V1去除最后的全连接层，用全局平均池化层代替。（模型训练更快且减轻了过拟合）
1x1卷积可以跨通道组织信息，提高网络表达能力，且可以对输出通道升维、降维
1x1卷积的性价比很高，用很小的计算量就能增加一层特征变化和非线性化
1x1卷积可很自然地把相关性很高的、在同一个空间位置但是不同通道的特征连接在一起
靠后的Inception Module中大面积的卷积核占比更多，以捕捉更高阶的抽象特征
用到辅助分类节点(auxiliary classifiers)，在Inception Net中间一层的输出用作分类，并按一个较小权重(0.3)加到最终分类结果中
Inception V2提出了Batch Normalization

定义inception_v3_arg_scope用来生成网络中经常用到的函数的默认参数

def inception_v3_arg_scope(weight_decay=0.00004, stddev=0.1,
                                            batch_norm_var_collectioin='moving_vars'):
    batch_norm_params = {
        'decay': 0.9997,
        'epsilon': 0.001,
        'updates_collections': tf.GraphKeys.UPDATE_OPS,
        'variables_collections': {
            'beta': None,
            'gamma': None,
            'moving_mean': [batch_norm_var_collectioin],
            'moving_variance': [batch_norm_var_collection],
        }
    }
with slim.arg_scope([slim.conv2d, slim.fully_connected],
                                weights_regularizer=slim.l2_regularizer(weight_decay)):
    with slim.arg_scope([slim.conv2d],
                                    weights_initializer=tf.truncated_normal_initializer(stddev=stddev),
                                    activation_fn=tf.nn.relu,
                                    normalizer_fn=slim.batch_norm,
                                    normalizer_params=batch_norm_params) as sc:
        return sc

定义inception_v3_base用来生成Inception V3网络的卷积部分

def inception_v3_base(inputs, scope=None):
    end_points = {}
    with tf.variable_scope(scope, 'InceptionV3', [inputs]):
        #前面的卷积层
        with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
                                        stride=1, padding='VALID'):
            net = slim.conv2d(inputs, 32, [3, 3], stride=2, scope='Conv2d_1a_3x3')
            net = slim.conv2d(net, 32, [3, 3], scope='Conv2d_2a_3x3')
            ...
        #接着是三个Inception
        #inception 1
        with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
                                        stride=1, padding='SAME'):
            
              #inception 1中的第一个inception module
             with tf.variable_scope('Mixed_5b'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 48, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = slim.conv2d(branch_1, 64, [5, 5], scope='Conv2d_0b_5x5')    
            ...

6.4 TensorFlow实现ResNet

ResNet的残差学习单元(Residual Unit)不再学习一个完整的输出H(x),而是学习残差H(x)-x.ResNet有很多支线将输入直接连到后面的层,使得后面的层可以直接学习残差,这种结构被称为shortcut
两层的残差学习单元包含两个相同输出通道数的3x3卷积,三层的残差学习单元则是1x1卷积,3x3卷积,1x1卷积,并且先降维再升维