第三章 TensorFlow工具库（上）

最新推荐文章于 2024-06-04 07:50:53 发布

xk_005

最新推荐文章于 2024-06-04 07:50:53 发布

阅读量472

点赞数 1

分类专栏：深度学习

本文链接：https://blog.csdn.net/xiaokan_001/article/details/104953124

版权

深度学习专栏收录该内容

20 篇文章 0 订阅

订阅专栏

TensorFlow工具库（上）

01.TensorFlow简介

TensorFlow最初由Google大脑小组开发出来，用于机器学习和深度神经网络方面的研究。
TensorFlow^TM是一个采用数据流图（Data flow graphs），用于数值计算的开源软件库。
架构灵活，可在多种平台上展开计算。例如台式计算机的一个或多个CPU（或GPU）、服务器、移动沈北等等。
通用性很强，可广泛用于其他计算领域

02.张量与计算图

Tensor——张量，flow——流动；计算过程就会张量的流动过程。

2.1张量

张量是各种维度的向量和矩阵的统称。
TensorFlow是一个定义和运行张良计算的框架；在内部，TensorFlow用多维数组来表示张量。
tf.Tensor对象，即张量，定义了计算的一部分，并最终会生成一个值。
一个tf.Tensor对象有以下属性：
- 一种数据类型（比如float32，int32，或是string）
- 一个形状
  TensorFlow神经网络计算数学形式与张量表示：

2.2 TensorFlow变量

外部：

用来表示程序控制的共享和持续状态
tf.Variable描述了一个张量，其值可与通过运行操作来改变
tf.Variable存在于session.run调用的上下文之外
内部：
tf.Variable保存了一个常态的张量，可通过特定的操作读取和修改该张量的值
这种修改对于多个tf.Session都是可见的，因此多个工作线程都能获取tf.Variable相同的值

2.3 计算图

TensorFlow使用数据流图（Data flow-graph）表示计算过程
数据流图是依据各个操作（op）之间的依赖关系生成的
底层的编程模型：
需要先定义数据流图，然后创建一个TensorFlow回话，在多个本地货远程的设备上运行流图的各个部分
TensorFlow = 延迟执行（deferred execution）模型，如图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j9oKEUoZ-1584535355238)(_v_images/20200315194205919_20141.png =973x)]
在TensorFlow中，有两种用于运行计算图（graph）的回话（session）
tf.Session()
tf.InteractivesSession()
Tensorflow session是可以让Tensor真的flow（操作计算）起来
保存变量： 用tf.train.Saver()方法创建一个Saver来管理模型中的所有变量，即保存模型。
恢复变量： tf.train.Saver()对象不仅能将变量保存到快照文件中，他也能恢复变量。注意恢复变量不需要预先初始化

03.TensorFlow low level API搭建模型

3.1 TensorFlow low level API搭建模型

使用TensorFlow low level API会涉及到：
1>TensorFlow程序（TensorFlow计算图，即tf.Graph）
2>tf.Session，运行TensorFlow计算图
3>在底层环境中使用高级的组件（datasets，layers，以及特征列）
4>Premade Estimators

3.2 线性回归模型

# 构建线性回归
# 想想线性回归是不是y=WX+b的形式
pred = tf.add(tf.multiply(X, W), b)
# 计算损失函数
cost = tf.reduce_sum(tf.pow(pred-Y, 2))/(2*n_samples)
# 梯度下降优化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

3.3 多项式回归模型

# 构建多项式回归模型
Y_pred = tf.add(tf.multiply(X, W), b)
#添加高次项
W_2 = tf.Variable(tf.random_normal([1]), name='weight_2')
Y_pred = tf.add(tf.multiply(tf.pow(X, 2), W_2), Y_pred)
W_3 = tf.Variable(tf.random_normal([1]), name='weight_3')
Y_pred = tf.add(tf.multiply(tf.pow(X, 3), W_3), Y_pred)
# 计算损失函数
sample_num = xs.shape[0]
loss = tf.reduce_sum(tf.pow(Y_pred - Y, 2)) / sample_num
# 梯度下降优化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

3.4 逻辑回归

# 构建线性模型
pred = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax就是多分类
# 计算损失函数
cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred), reduction_indices=1))
# 梯度下降优化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# 初始化计算图中的变量（用默认值去赋值）
init = tf.global_variables_initializer()

04.使用TensorFlow low level API完成多层感知器建模

4.1 多层感知器

定义：多层感知器（Multilayer Perceptron，MLP）是一种前向结构的人工神经网络，映射一组输入向量到一组输出向量。
优势：克服了感知器不能对线性不可分数据进行识别的弱点。

4.2 多层感知器建模流程

在这里插入图片描述

4.3 代码详解

# 构建多层感知器
def multilayer_perceptron(x, weights, biases):
    # 第1个隐层，使用relu激活函数
    layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'], name='fc_1')
    layer_1 = tf.nn.relu(layer_1, name='relu_1')
    # 第2个隐层，使用relu激活函数
    layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'], name='fc_2')
    layer_2 = tf.nn.relu(layer_2, name='relu_2')
    # 输出层
    out_layer = tf.add(tf.matmul(layer_2, weights['out']), biases['out'], name='fc_3')
    return out_layer

05.用tensorflow low level API构建CNN/LSTM模型

代码详解

5.1 CNN

卷积神经网络是一种在计算机视觉当中广泛应用的神经网络，其特殊的网络结构，包含卷积层、池化层等，能在共享参数的同时保证对图像特征的高效抽取。经典的卷积神经网络结构如下。
在这里插入图片描述
以MNIST 手写数字识别为背景，构建CNN，下面为模型主要代码：

# 构建模型

# 定义卷积层运算(卷积层+激活层)
def conv2d(x, W, b, strides=1):
    x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
    x = tf.nn.bias_add(x, b)
    return tf.nn.relu(x)

# 定义池化层运算
def maxpool2d(x, k=2):
    return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
                          padding='SAME')

# 构建卷积神经网络模型
def conv_net(x, weights, biases, dropout):
    # 原本MNIST数据输入是784维度向量
    # 调整成 宽*高*通道数 的标准图片输入格式
    # 总共是4个维度[Batch Size, Height, Width, Channel]，其中第一个维度-1表示暂时不确定一个batch多少张
    x = tf.reshape(x, shape=[-1, 28, 28, 1])

    # 卷积层
    conv1 = conv2d(x, weights['wc1'], biases['bc1'])
    # 池化层
    conv1 = maxpool2d(conv1, k=2)

    # 卷积层
    conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
    # 池化层
    conv2 = maxpool2d(conv2, k=2)

    # 全连接层，需要先把数据展开成一维向量，再接全连接
    fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
    fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
    fc1 = tf.nn.relu(fc1)
    # 随机失活层
    fc1 = tf.nn.dropout(fc1, dropout)

    # 最终预估结果
    out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
    return out

# 计算损失与优化
# 构建卷积神经网络预估结果
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# 定义损失与优化器
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
    logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)


# 评估模型
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# 初始化变量
init = tf.global_variables_initializer()

5.2 RNN

循环神经网络或RNN是一类用于处理序列数据的神经网络，典型的时间序列数据场景是文本，RNN在自然语言处理中发挥着很大的作用。循环神经网络会对序列的每个时间点数据处理，典型结构如下。
在这里插入图片描述
循环神经网络中最常用到的两个变种结构为LSTM和GRU，它们在对数据计算的cell结构上做了一些调整，分别如下：

模型主要代码：
1>构建模型

def RNN(x, weights, biases):

    # RNN是时间序列型网络结构，我们需要按照它的形式去组织数据
    # 我们把数据组织成这样的形式: (batch_size, timesteps, n_input)
    # 也就是说一批样本batch_size个样本，总共会以timesteps个长度为n_input的向量形式送入

    # 为了得到timesteps个(batch_size, n_input)形态的输入
    x = tf.unstack(x, timesteps, 1)

    # 定义RNN中单个cell的格式
    lstm_cell = rnn.BasicLSTMCell(num_hidden, forget_bias=1.0)

    # 用cell串成LSTM网络
    outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32)

    # 结果要通过全连接层
    return tf.matmul(outputs[-1], weights['out']) + biases['out']

# 构建RNN网络进行预估
logits = RNN(X, weights, biases)
prediction = tf.nn.softmax(logits)

# 定义损失计算方法与优化器
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
    logits=logits, labels=Y))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# 评估模型
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# 初始化变量
init = tf.global_variables_initializer()

06.TensorBoard可视化与模型状态评估

6.1 TensorBoard可视化

Tensorboard是一个非常好用的可视化工具，可以配合tensorflow一起去完成神经网络训练，在网络训练过程中，可以实时对训练中间状态进行可视化观察。
TensorBoard优势：

可绘制图计算过程的定量指标，以及显示图的额外数据
可使得TensorBoard程序更易于理解、调试和优化

6.2 代码详解

将需要在Tensorboard中做可视化的参数，summary一下，注意summary时要分清标量还是矢量，标量用scalar，而矢量用histogram。

# 构建模型
def multilayer_perceptron(x, weights, biases):
    # WX+b再通过非线性变换
    layer_1 = tf.add(tf.matmul(x, weights['w1']), biases['b1'])
    layer_1 = tf.nn.relu(layer_1)
    # 为了在Tensorboard中做可视化，summary一下
    tf.summary.histogram("relu1", layer_1)
    # WX+b再通过非线性变换
    layer_2 = tf.add(tf.matmul(layer_1, weights['w2']), biases['b2'])
    layer_2 = tf.nn.relu(layer_2)
    # 为了在Tensorboard中做可视化，再次summary一下
    tf.summary.histogram("relu2", layer_2)
    # 全连接层
    out_layer = tf.add(tf.matmul(layer_2, weights['w3']), biases['b3'])
    return out_layer

把不同的op分到不同scope里，这样可视化会更清晰。

    # 计算损失与优化
    # 把不同的op分到不同scope里，这样可视化会更清晰
with tf.name_scope('Model'):
    # 构建多层感知器
    pred = multilayer_perceptron(x, weights, biases)

with tf.name_scope('Loss'):
    # Softmax交叉熵损失
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))

with tf.name_scope('SGD'):
    # 梯度下降
    optimizer = tf.train.GradientDescentOptimizer(learning_rate)
    # gradient/梯度
    grads = tf.gradients(loss, tf.trainable_variables())
    grads = list(zip(grads, tf.trainable_variables()))
    apply_grads = optimizer.apply_gradients(grads_and_vars=grads)

with tf.name_scope('Accuracy'):
    # 准确率
    acc = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
    acc = tf.reduce_mean(tf.cast(acc, tf.float32))

init = tf.global_variables_initializer()

# 构建loss的summary（是一个标量，用scalar）
tf.summary.scalar("loss", loss)
# 构建accuracy的summary（是一个标量，用scalar）
tf.summary.scalar("accuracy", acc)
# 构建变量的summary（用histogram）
for var in tf.trainable_variables():
    tf.summary.histogram(var.name, var)
# 构建gradient的summary（用histogram）
for grad, var in grads:
    tf.summary.histogram(var.name + '/gradient', grad)

# 注意这一步，Merge所有的summaries
merged_summary_op = tf.summary.merge_all()

利用tf.summary.FileWriter()要把log写出去，以便Tensorboard可视化

   # 在session中开始训练
with tf.Session() as sess:

    # 初始化所有变量
    sess.run(init)

    # 要把log写出去，以便Tensorboard可视化
    summary_writer = tf.summary.FileWriter(logs_path,
                                            graph=tf.get_default_graph())

    # 训练的迭代过程
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(mnist.train.num_examples/batch_size)
        # 遍历所有batches
        for i in range(total_batch):
            batch_xs, batch_ys = mnist.train.next_batch(batch_size)
            _, c, summary = sess.run([apply_grads, loss, merged_summary_op],
                                     feed_dict={x: batch_xs, y: batch_ys})
            # 每一轮写入日志
            summary_writer.add_summary(summary, epoch * total_batch + i)
            # 计算平均损失
            avg_cost += c / total_batch
        # 打印中间结果展示
        if (epoch+1) % display_step == 0:
            print("第%04d轮" % (epoch+1), "当前损失为", "{:.9f}".format(avg_cost))

    print("训练完成！")

    # 测试集准确率
    print("准确率:", acc.eval({x: mnist.test.images, y: mnist.test.labels}))

    print("Run the command line:\n" \
          "--> tensorboard --logdir=/tmp/tensorflow_logs " \
          "\nThen open http://0.0.0.0:6006/ into your web browser")

可视化图：
在这里插入图片描述

xk_005

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
第三章 TensorFlow工具库（上）

TensorFlow工具库（上）01.TensorFlow简介TensorFlow最初由Google大脑小组开发出来，用于机器学习和深度神经网络方面的研究。TensorFlowTM是一个采用数据流图（Data flow graphs），用于数值计算的开源软件库。架构灵活，可在多种平台上展开计算。例如台式计算机的一个或多个CPU（或GPU）、服务器、移动沈北等等。通用性很强，可广泛用于其...
复制链接

扫一扫