tensorflow 基本用法(线性模型为例)

代码如下

# https://blog.csdn.net/geyunfei_/article/details/78782804
import tensorflow as tf
import numpy as np

# 整型常量,即0阶Tensor
t0 = tf.constant(3, dtype=tf.int32)

# 浮点数的一维数组,即1阶Tensor
t1 = tf.constant([3., 4.1, 5.2], dtype=tf.float32)

# 字符串的 2*2数组,即2阶 Tensor
t2 = tf.constant([['apple', 'orange'], ['potato', 'tomato']], dtype=tf.string)

# 2*3*1数组,即3阶张量,数据类型为整型
t3 = tf.constant([[[5], [6], [7]], [[4], [3], [2]]])

# print只能打印属性定义
print(t0, '\n', t1, '\n', t2, '\n', t3)

sess = tf.Session()
print(sess.run(t3))

print(' -----------------构建计算图--------------')
node1 = tf.constant(3.2)
node2 = tf.constant(4.2)
add = node1 + node2
print(add)
print(sess.run(add))

print('------------------占位符-----------------')
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
add = a + b
print(a, b, add)
print(sess.run(add, {a: 3, b: 5.5}))
print(sess.run(add, {a: [.1, 2], b: [5, .5]}))

add_triple = add * 3
print(sess.run(add_triple, {a: 2, b: 2.5}))

print('-----使用 TensorFlow 实现模型-- y=w*x+b -------')
# 创建变量w,b节点,并设置初始值   原始数据为 x: [1, 2, 3, 6, 8], y: [4.8, 8.5, 10.4, 21.0, 25.3]   即当x=1时，y=5
w = tf.Variable([.1], dtype=tf.float32)
b = tf.Variable([-.1], dtype=tf.float32)
# 创建x节点,用来输入实验室中的输入数据
x = tf.placeholder(tf.float32)
# 创建线性模型
linear_model = w * x + b
# 创建y节点，用来输入实验中得到的输出数据，用于损失模型计算
y = tf.placeholder(tf.float32)
# 创建损失模型
loss = tf.reduce_sum(tf.square(linear_model - y))
# 初始化变量
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
print(sess.run(w))
# 用w和b的设置初始值0.1和-0.1运行模型
print(sess.run(linear_model, {x: [1, 2, 3, 6, 8]}))  # --> 与实际输出相差很大
# 计算损失值
print(sess.run(loss, {x: [1, 2, 3, 6, 8], y: [4.8, 8.5, 10.4, 21.0, 25.3]}))  # --> 损失值也很大 1223.0499

# 用tf.assign对w和b重新赋值
fixw = tf.assign(w, [2.])
fixb = tf.assign(b, [1.])
sess.run([fixw, fixb])
print(sess.run(loss, {x: [1, 2, 3, 6, 8], y: [4.8, 8.5, 10.4, 21.0, 25.3]}))  # ---> 159.93999
# TensorFlow 提供了训练模型的方法，自动帮我们找到使损失值最小的W和b

print('---------- 训练模型 (初级)------------------')
# 创建一个梯度下降优化器， 学习率为0.001
optimizer = tf.train.GradientDescentOptimizer(0.001)
train = optimizer.minimize(loss)

# 用数组保持训练数据
x_train = [1, 2, 3, 6, 8]
y_train = [4.8, 8.5, 10.4, 21.0, 25.3]
# 训练10000次
for i in range(10000):
    sess.run(train, {x: x_train, y: y_train})
# 训练后的结果
print('W: %s b: %s loss: %s' % (sess.run(w), sess.run(
    b), sess.run(loss, {x: x_train, y: y_train})))

print('------------------------高级训练模型---------------')
# 运行训练循环
# 运行评估循环
# 管理训练数据集
# 优模型是否会一直是最优的？
# 我们需要通过一些新的实验数据来评估(evaluation)模型的泛化性能(generalization performance)，
# 如果新的实验数据应用到到这个模型中损失值越小，那么这个模型的泛化性能就越好，反之就越差。

# 创建一个特征向量列表,该特征列表里只有一个特征向量
# 该特征向量为实数向量,只有一个元素的数组,且该元素名称为x
# 我们还可以创建其他更加复杂的特征列表
feature_columns = [tf.feature_column.numeric_column('x', shape=[1])]

# 创建一个LinearRegressor训练器,并传入特征向量列表
estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns)

# 保持训练用的数据
x_train = np.array([1., 2., 3., 6., 8.])
y_train = np.array([4.8, 8.5, 10.4, 21.0, 25.3])

# 保存评估用的数据
x_eavl = np.array([2., 5., 7., 9.])
y_eavl = np.array([7.6, 17.2, 23.6, 28.8])

# 用训练数据创建一个输入模型,用来进行后面的模型训练
# 第一个参数用来做线性回归模型的输入数据
# 第二个参数用来做线性回归模型损失模型的输入
# 第三个参数batch_size表示每批训练数据的个数
# 第四个参数num_epochs为epoch的次数,将训练集的所有数据都训练一遍为1次epoch
# 第五个参数shuffle为取训练数据是顺序还是随机取
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    {'x': x_train}, y_train, batch_size=2, num_epochs=None, shuffle=True
)

# 再用训练数据创建一个输入模型,用来进行后面的模型评估
train_input_fn_2 = tf.estimator.inputs.numpy_input_fn(
    {'x': x_train}, y_train, batch_size=2, num_epochs=1000, shuffle=False
)

# 用评估数据创建一个输入模型,用来进行后面的模型评估
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    {'x': x_eavl}, y_eavl, batch_size=2, num_epochs=1000, shuffle=False
)

# 使用训练数据训练1000次
estimator.train(input_fn=train_input_fn, steps=1000)

# 使用原来训练数据评估一下模型,目的是查看训练结果
train_metrics = estimator.evaluate(input_fn=train_input_fn_2)
print('train metrics: %r' % train_metrics)

# 使用评估数据评估一下模型,目的是验证模型的泛化性能
eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print('eval metrics: %s' % eval_metrics)
# -----评估数据的loss比训练数据还要小，说明我们的模型泛化性能很好

print('----------自定义Estimator模型------------------')


# 定义模型训练函数,同时也定义了特征向量

def model_fn(features, labels, mode):
    # 构建线性模型
    W = tf.get_variable('W', [1], dtype=tf.float64)
    b = tf.get_variable('b', [1], dtype=tf.float64)
    y = W * features['x'] + b
    # 构建损失模型
    loss = tf.reduce_sum(tf.square(y - labels))
    # 训练模型子图
    global_step = tf.train.get_global_step()
    optimizer = tf.train.GradientDescentOptimizer(0.01)
    train = tf.group(optimizer.minimize(loss), tf.assign_add(global_step, 1))
    # 通过EstimatorSpec指定我们的训练子图积极损失模型
    return tf.estimator.EstimatorSpec(
        mode=mode,
        predictions=y,
        loss=loss,
        train_op=train
    )


# 创建自定义的训练模型
estimator = tf.estimator.Estimator(model_fn=model_fn)

# 后面的训练逻辑与使用linearRegressor一样
x_train = np.array([1., 2., 3., 6., 8.])
y_train = np.array([4.8, 8.5, 10.4, 21.0, 25.3])

x_eavl = np.array([2., 5., 7., 9.])
y_eavl = np.array([7.6, 17.2, 23.6, 28.8])

train_input_fn = tf.estimator.inputs.numpy_input_fn(
    {'x': x_train}, y_train, batch_size=2, num_epochs=None, shuffle=True
)

train_input_fn_2 = tf.estimator.inputs.numpy_input_fn(
    {'x': x_train}, y_train, batch_size=2, num_epochs=1000, shuffle=False
)

eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    {'x': x_eavl}, y_eavl, batch_size=2, num_epochs=1000, shuffle=False
)

estimator.train(input_fn=train_input_fn, steps=1000)

train_metrics = estimator.evaluate(input_fn=train_input_fn_2)
print("train metrics: %r" % train_metrics)

eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print('eval metrics: %s' % eval_metrics)

print('-----------TensorBoard 可视化-----------------')
# 创建节点时设置name,方便在图中识别
W = tf.Variable([0], dtype=tf.float32, name='W')
b = tf.Variable([0], dtype=tf.float32, name='b')

x = tf.placeholder(tf.float32, name='x')
y = tf.placeholder(tf.float32, name='y')

# 线性模型
linear_model = W * x + b

# 损失模型隐藏到loss-model模块
with tf.name_scope('loss-model'):
    loss = tf.reduce_sum(tf.square(linear_model) - y)
    # 给损失模型的输出添加scalar,用来观察loss的收敛曲线
    tf.summary.scalar('loss', loss)

optimizer = tf.train.GradientDescentOptimizer(0.001)
train = optimizer.minimize(loss)

x_train = [1, 2, 3, 6, 8]
y_train = [4.8, 8.5, 10.4, 21.0, 25.3]

sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)

# 调用merge_all()，收集所有的操作数据
merged = tf.summary.merge_all()

# 模型运动产生的所有数据保存到 /tem/tensorflow 文件夹供TensorBoard使用
writer = tf.summary.FileWriter('/tem/tensorflow', sess.graph)

# 训练10000次
for i in range(10000):
    # 训练时传入merge
    summary, _ = sess.run([merged, train], {x: x_train, y: y_train})
    writer.add_summary(summary, i)

curr_W, curr_b, curr_loss = sess.run([w, b, loss], {x: x_train, y: y_train})

print('After train W： %s , b %s loss：%s' % (curr_W, curr_b, curr_loss))