当先锋百科网

首页 1 2 3 4 5 6 7

深度学习之TensorFlow实战9

在这里插入图片描述

只有敲出来的代码才是自己的，现在我们进行实战：

使用之前已介绍的相关TensorFlow相关知识点，实现以下三个功能(变量更新)

  1. 实现一个累加器，并且每一步均输出累加器的结果值。
  2. 编写一段代码，实现动态的更新变量的维度数目
  3. 实现一个求解阶乘的代码
# -- encoding:utf-8 --
"""
Create by ibf on 2021/8/5
"""

import tensorflow as tf

# # 1. 定义常量矩阵a和矩阵b
# # name属性只是给定这个操作一个名称而已
# a = tf.constant([[1, 2], [3, 4]], dtype=tf.int32, name='a')
# print(type(a))
# b = tf.constant([5, 6, 7, 8], dtype=tf.int32, shape=[2, 2], name='b')
#
# # 2. 以a和b作为输入，进行矩阵的乘法操作
# c = tf.matmul(a, b, name='matmul')
# print(type(c))
#
# # 3. 以a和c作为输入，进行矩阵的相加操作
# g = tf.add(a, c, name='add')
# print(type(g))
# print(g)
#
# # 4. 添加减法
# h = tf.subtract(b, a, name='b-a')
# l = tf.matmul(h, c)
# r = tf.add(g, l)
#
# print("变量a是否在默认图中:{}".format(a.graph is tf.get_default_graph()))

# # 使用新的构建的图
# graph = tf.Graph()
# with graph.as_default():
#     # 此时在这个代码块中，使用的就是新的定义的图graph(相当于把默认图换成了graph)
#     d = tf.constant(5.0, name='d')
#     print("变量d是否在新图graph中:{}".format(d.graph is graph))
#
# with tf.Graph().as_default() as g2:
#     e = tf.constant(6.0)
#     print("变量e是否在新图g2中：{}".format(e.graph is g2))
#
# # 这段代码是错误的用法，记住：不能使用两个图中的变量进行操作，只能对同一个图中的变量对象（张量）进行操作(op)
# # f = tf.add(d, e)


# 会话构建&启动(默认情况下（不给定Session的graph参数的情况下），创建的Session属于默认的图)
# sess = tf.Session()
# print(sess)
#
# # 调用sess的run方法来执行矩阵的乘法，得到c的结果值（所以将c作为参数传递进去）
# # 不需要考虑图中间的运算，在运行的时候只需要关注最终结果对应的对象以及所需要的输入数据值
# # 只需要传递进去所需要得到的结果对象，会自动的根据图中的依赖关系触发所有相关的OP操作的执行
# # 如果op之间没有依赖关系，tensorflow底层会并行的执行op(有资源) --> 自动进行
# # 如果传递的fetches是一个列表，那么返回值是一个list集合
# # fetches：表示获取那个op操作的结果值
# result = sess.run(fetches=[r, c])
# print("type:{}, value:\n{}".format(type(result), result))
#
# # 会话关闭
# sess.close()
#
# # 当一个会话关闭后，不能再使用了，所以下面两行代码错误
# # result2 = sess.run(c)
# # print(result2)
#
# # 使用with语句块，会在with语句块执行完成后，自动的关闭session
# with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess2:
#     print(sess2)
#     # 获取张量c的结果： 通过Session的run方法获取
#     print("sess2 run:{}".format(sess2.run(c)))
#     # 获取张量r的结果：通过张量对象的eval方法获取，和Session的run方法一致
#     print("c eval:{}".format(r.eval()))
#
# # 交互式会话构建
# sess3 = tf.InteractiveSession()
# print(r.eval())

# # 1. 定义一个变量，必须给定初始值(图的构建，没有运行)
# a = tf.Variable(initial_value=3.0, dtype=tf.float32)
#
# # 2. 定义一个张量
# b = tf.constant(value=2.0, dtype=tf.float32)
# c = tf.add(a, b)
#
# # 3. 进行初始化操作（推荐：使用全局所有变量初始化API）
# # 相当于在图中加入一个初始化全局变量的操作
# init_op = tf.global_variables_initializer()
# print(type(init_op))
#
# # 3. 图的运行
# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     # 运行init op进行变量初始化，一定要放到所有运行操作之前
#     sess.run(init_op)
#     # init_op.run() # 这行代码也是初始化运行操作，但是要求明确给定当前代码块对应的默认session(tf.get_default_session())是哪个，底层使用默认session来运行
#     # 获取操作的结果
#     print("result:{}".format(sess.run(c)))
#     print("result:{}".format(c.eval()))

# # 1. 定义变量，常量
# w1 = tf.Variable(tf.random_normal(shape=[10], stddev=0.5, seed=28, dtype=tf.float32), name='w1')
# a = tf.constant(value=2.0, dtype=tf.float32)
# w2 = tf.Variable(w1.initialized_value() * a, name='w2')
#
# # 3. 进行初始化操作（推荐：使用全局所有变量初始化API）
# # 相当于在图中加入一个初始化全局变量的操作
# init_op = tf.global_variables_initializer()
# print(type(init_op))
#
# # 3. 图的运行
# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     # 运行init op进行变量初始化，一定要放到所有运行操作之前
#     sess.run(init_op)
#     # init_op.run() # 这行代码也是初始化运行操作，但是要求明确给定当前代码块对应的默认session(tf.get_default_session())是哪个，底层使用默认session来运行
#     # 获取操作的结果
#     print("result:{}".format(sess.run(w1)))
#     print("result:{}".format(w2.eval()))

# # 构建一个矩阵的乘法，但是矩阵在运行的时候给定
# m1 = tf.placeholder(dtype=tf.float32, shape=[2, 3], name='placeholder_1')
# m2 = tf.placeholder(dtype=tf.float32, shape=[3, 2], name='placeholder_2')
# m3 = tf.matmul(m1, m2)
#
# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     print("result:\n{}".format(
#         sess.run(fetches=m3, feed_dict={m1: [[1, 2, 3], [4, 5, 6]], m2: [[9, 8], [7, 6], [5, 4]]})))
#     print("result:\n{}".format(m3.eval(feed_dict={m1: [[1, 2, 3], [4, 5, 6]], m2: [[9, 8], [7, 6], [5, 4]]})))



# -- encoding:utf-8 --
"""
Create by ibf on 2021/8/5
"""

import tensorflow as tf

# # 需求一
# # 1. 定义一个变量
# x = tf.Variable(1, dtype=tf.int32, name='v_x')
#
# # 2. 变量的更新
# assign_op = tf.assign(ref=x, value=x + 1)
#
# # 3. 变量初始化操作
# x_init_op = tf.global_variables_initializer()
#
# # 3. 运行
# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     # 变量初始化
#     sess.run(x_init_op)
#
#     # 模拟迭代更新累加器
#     for i in range(5):
#         # 执行更新操作
#         sess.run(assign_op)
#         r_x = sess.run(x)
#         print(r_x)

# # 需求二
# # 1. 定义一个不定形状的变量
# x = tf.Variable(
#     initial_value=[],  # 给定一个空值
#     dtype=tf.float32,
#     trainable=False,
#     validate_shape=False  # 设置为True，表示在变量更新的时候，进行shape的检查，默认为True
# )
#
# # 2. 变量更改
# concat = tf.concat([x, [0.0, 0.0]], axis=0)
# assign_op = tf.assign(x, concat, validate_shape=False)
#
# # 3. 变量初始化操作
# x_init_op = tf.global_variables_initializer()
#
# # 3. 运行
# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     # 变量初始化
#     sess.run(x_init_op)
#
#     # 模拟迭代更新累加器
#     for i in range(5):
#         # 执行更新操作
#         sess.run(assign_op)
#         r_x = sess.run(x)
#         print(r_x)

# 需求三
# 1. 定义一个变量
sum = tf.Variable(1, dtype=tf.int32)
# 2. 定义一个占位符
i = tf.placeholder(dtype=tf.int32)

# 3. 更新操作
tmp_sum = sum * i
# tmp_sum = tf.multiply(sum, i)
assign_op = tf.assign(sum, tmp_sum)
with tf.control_dependencies([assign_op]):
    # 如果需要执行这个代码块中的内容，必须先执行control_dependencies中给定的操作/tensor
    sum = tf.Print(sum, data=[sum, sum.read_value()], message='sum:')

# 4. 变量初始化操作
x_init_op = tf.global_variables_initializer()

# 5. 运行
with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
    # 变量初始化
    sess.run(x_init_op)

    # 模拟迭代更新累加器
    for j in range(1, 6):
        # 执行更新操作
        # sess.run(assign_op, feed_dict={i: j})
        # 通过control_dependencies可以指定依赖关系，这样的话，就不用管内部的更新操作了
        r = sess.run(sum, feed_dict={i: j})

    print("5!={}".format(r))

案例：编写一个累加器；定义一个变量x(初值随机给定)，定义一个占位符y，迭代4次，
每个迭代返回xy的值，并且在计算xy乘积前，先对x进行累加操作。并且将这个程序信
息输出到文件以TensorBoard展示。

案例：分别实现模型的保存、提取操作

# -- encoding:utf-8 --
"""
Create by ibf on 2021/8/5
"""

import tensorflow as tf

# with tf.device('/cpu:0'):
#     # 这个代码块中定义的操作，会在tf.device给定的设备上运行
#     # 有一些操作，是不会再GPU上运行的（一定要注意）
#     # 如果按照的tensorflow cpu版本，没法指定运行环境的
#     a = tf.Variable([1, 2, 3], dtype=tf.int32, name='a')
#     b = tf.constant(2, dtype=tf.int32, name='b')
#     c = tf.add(a, b, name='ab')
#
# with tf.device('/gpu:0'):
#     # 这个代码块中定义的操作，会在tf.device给定的设备上运行
#     # 有一些操作，是不会再GPU上运行的（一定要注意）
#     # 如果按照的tensorflow cpu版本，没法指定运行环境的
#     d = tf.Variable([2, 8, 13], dtype=tf.int32, name='d')
#     e = tf.constant(2, dtype=tf.int32, name='e')
#     f = d + e
#
# g = c + f
#
# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     # 初始化
#     tf.global_variables_initializer().run()
#     # 执行结果
#     print(g.eval())

# # 方式一
# def my_func(x):
#     w1 = tf.Variable(tf.random_normal([1]))[0]
#     b1 = tf.Variable(tf.random_normal([1]))[0]
#     r1 = w1 * x + b1
#
#     w2 = tf.Variable(tf.random_normal([1]))[0]
#     b2 = tf.Variable(tf.random_normal([1]))[0]
#     r2 = w2 * r1 + b2
#
#     return r1, w1, b1, r2, w2, b2
#
#
# # 下面两行代码还是属于图的构建
# x = tf.constant(3, dtype=tf.float32)
# r = my_func(x)
#
# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     # 初始化
#     tf.global_variables_initializer().run()
#     # 执行结果
#     print(sess.run(r))

# # 方式二
# def my_func(x):
#     # initializer：初始化器
#     # w = tf.Variable(tf.random_normal([1]), name='w')[0]
#     # b = tf.Variable(tf.random_normal([1]), name='b')[0]
#     w = tf.get_variable(name='w', shape=[1], initializer=tf.random_normal_initializer())[0]
#     b = tf.get_variable(name='b', shape=[1], initializer=tf.random_normal_initializer())[0]
#     r = w * x + b
#
#     return r, w, b
#
#
# def func(x):
#     with tf.variable_scope('op1', reuse=tf.AUTO_REUSE):
#         r1 = my_func(x)
#     with tf.variable_scope('op2', reuse=tf.AUTO_REUSE):
#         r2 = my_func(r1[0])
#     return r1, r2
#
#
# # 下面两行代码还是属于图的构建
# x1 = tf.constant(3, dtype=tf.float32, name='x1')
# x2 = tf.constant(4, dtype=tf.float32, name='x2')
# with tf.variable_scope('func1'):
#     r1 = func(x1)
# with tf.variable_scope('func2'):
#     r2 = func(x2)
#
# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     # 初始化
#     tf.global_variables_initializer().run()
#     # 执行结果
#     print(sess.run([r1, r2]))


# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     with tf.variable_scope('foo', initializer=tf.constant_initializer(4.0)) as foo:
#         v = tf.get_variable("v", [1])
#         w = tf.get_variable("w", [1], initializer=tf.constant_initializer(3.0))
#         with tf.variable_scope('bar'):
#             l = tf.get_variable("l", [1])
#
#             with tf.variable_scope(foo):
#                 h = tf.get_variable('h', [1])
#                 g = v + w + l + h
#
#     with tf.variable_scope('abc'):
#         a = tf.get_variable('a', [1], initializer=tf.constant_initializer(5.0))
#         b = a + g
#
#     sess.run(tf.global_variables_initializer())
#     print("{},{}".format(v.name, v.eval()))
#     print("{},{}".format(w.name, w.eval()))
#     print("{},{}".format(l.name, l.eval()))
#     print("{},{}".format(h.name, h.eval()))
#     print("{},{}".format(g.name, g.eval()))
#     print("{},{}".format(a.name, a.eval()))
#     print("{},{}".format(b.name, b.eval()))


# # 可视化
# with tf.variable_scope("foo"):
#     with tf.device("/cpu:0"):
#         x_init1 = tf.get_variable('init_x', [10], tf.float32, initializer=tf.random_normal_initializer())[0]
#         x = tf.Variable(initial_value=x_init1, name='x')
#         y = tf.placeholder(dtype=tf.float32, name='y')
#         z = x + y
#
#     # update x
#     assign_op = tf.assign(x, x + 1)
#     with tf.control_dependencies([assign_op]):
#         with tf.device('/gpu:0'):
#             out = x * y
#
# with tf.device('/cpu:0'):
#     with tf.variable_scope("bar"):
#         a = tf.constant(3.0) + 4.0
#     w = z * a
#
# # 开始记录信息(需要展示的信息的输出)
# tf.summary.scalar('scalar_init_x', x_init1)
# tf.summary.scalar(name='scalar_x', tensor=x)
# tf.summary.scalar('scalar_y', y)
# tf.summary.scalar('scalar_z', z)
# tf.summary.scalar('scala_w', w)
# tf.summary.scalar('scala_out', out)
#
# with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:
#     # merge all summary
#     merged_summary = tf.summary.merge_all()
#     # 得到输出到文件的对象
#     writer = tf.summary.FileWriter('./result', sess.graph)
#
#     # 初始化
#     sess.run(tf.global_variables_initializer())
#     # print
#     for i in range(1, 5):
#         summary, r_out, r_x, r_w = sess.run([merged_summary, out, x, w], feed_dict={y: i})
#         writer.add_summary(summary, i)
#         print("{},{},{}".format(r_out, r_x, r_w))
#
#     # 关闭操作
#     writer.close()

# # 模型保存
# v1 = tf.Variable(tf.constant(3.0), name='v1')
# v2 = tf.Variable(tf.constant(4.0), name='v2')
# result = v1 + v2
#
# saver = tf.train.Saver()
# with tf.Session() as sess:
#     sess.run(tf.global_variables_initializer())
#     sess.run(result)
#     # 模型保存到model文件夹下，文件前缀为：model.ckpt
#     saver.save(sess, './model/model.ckpt')

# # 模型的提取(完整提取：需要完整恢复保存之前的数据格式)
# v1 = tf.Variable(tf.constant(1.0), name='v1')
# v2 = tf.Variable(tf.constant(4.0), name='v2')
# result = v1 + v2
#
# saver = tf.train.Saver()
# with tf.Session() as sess:
#     # 会从对应的文件夹中加载变量、图等相关信息
#     saver.restore(sess, './model/model.ckpt')
#     print(sess.run([result]))

# # 直接加载图，不需要定义变量了
# saver = tf.train.import_meta_graph('./model/model.ckpt.meta')
#
# with tf.Session() as sess:
#     saver.restore(sess, './model/model.ckpt')
#     print(sess.run(tf.get_default_graph().get_tensor_by_name("add:0")))

# # 模型的提取(给定映射关系)
# a = tf.Variable(tf.constant(1.0), name='a')
# b = tf.Variable(tf.constant(2.0), name='b')
# result = a + b
#
# saver = tf.train.Saver({"v1": a, "v2": b})
# with tf.Session() as sess:
#     # 会从对应的文件夹中加载变量、图等相关信息
#     saver.restore(sess, './model/model.ckpt')
#     print(sess.run([result]))