TensorFlow – 常用函数和第一个Demo

Contents

1 常用函数和类型
2 一个demo
3 模型的保存和载入
- 3.1 模型的保存
- 3.2 模型的加载
4 相关链接

常用函数和类型

张量（Tensor）

　　可以用多维数组来理解，它有维度（shape）和类型（dtype）两个属性。类型的常用取值有 tf.float32、tf.int32 等。

常量

# 常量初始化以后就不能更改了，下面是一个一维的常量(有三个元素)，其中1.表示1.0
t1 = tf.constant([1., 2., 3.], dtype=tf.float32)

# 常量初始化以后就不能更改了，下面是一个一维的常量(有三个元素)，其中1.表示1.0

t1 = tf.constant([1., 2., 3.], dtype=tf.float32)

变量

# 变量用来表示模型的参数，会随着训练不断变化
t2 = tf.Variable([.1], dtype=tf.float32)
"""
注意区分tf.Variable([10,10])和tf.zeros([10,10])：
前者表示2个整数10和10(形状为2)，后者表示10×10的二维张量(形状为10×10，值全部为0)
"""
w = tf.Variable(tf.zeros([10,10]))  # w一般用来表示权重
b = tf.Variable(tf.zeros([10])) # b一般用来表示-阈值

# 变量用来表示模型的参数，会随着训练不断变化

t2 = tf.Variable([.1], dtype=tf.float32)

"""

注意区分tf.Variable([10,10])和tf.zeros([10,10])：

前者表示2个整数10和10(形状为2)，后者表示10×10的二维张量(形状为10×10，值全部为0)

"""

w = tf.Variable(tf.zeros([10,10])) # w一般用来表示权重

b = tf.Variable(tf.zeros([10])) # b一般用来表示-阈值

占位符（placeholder）

# 占位符用来接收数据集的输入，就像空的托盘一样，每次把一个batch的训练数据放在上面
# 我们一般用x变量来表示接收样本的输入，None表示该维度不是固定的，因为一个batch可以接受不固定数量的训练样本
x = tf.placeholder(tf.float32,[None, 500])
# 这里用y_变量来表示正确的标签，而用y变量表示网络计算得到的估计值，y和y_之间的差距就称之为loss
y_ = tf.placeholder(tf.float32,[None, 10])

# 占位符用来接收数据集的输入，就像空的托盘一样，每次把一个batch的训练数据放在上面

# 我们一般用x变量来表示接收样本的输入，None表示该维度不是固定的，因为一个batch可以接受不固定数量的训练样本

x = tf.placeholder(tf.float32,[None, 500])

# 这里用y_变量来表示正确的标签，而用y变量表示网络计算得到的估计值，y和y_之间的差距就称之为loss

y_ = tf.placeholder(tf.float32,[None, 10])

张量的输出

# 使用print来输出张量的shape和dtype信息
print(t2)
# 使用sess.run（需要先初始化session）来运行并输出张量的数据，feed_dict用来给占位符填充数据，keep_prob表示每个连接有多大概率被去除，一般训练时取0.5-0.75（用来防止过拟合），测试时取1
sess.run([optimizer, loss], feed_dict={x: batch_x, y_: batch_y, keep_prob: 0.75})

# 使用print来输出张量的shape和dtype信息

print(t2)

# 使用sess.run（需要先初始化session）来运行并输出张量的数据，feed_dict用来给占位符填充数据，keep_prob表示每个连接有多大概率被去除，一般训练时取0.5-0.75（用来防止过拟合），测试时取1

sess.run([optimizer, loss], feed_dict={x: batch_x, y_: batch_y, keep_prob: 0.75})

常用张量运算

tf.reshape()

# 保持原来的数据不变，改变张量的shape，调用该函数必须保证调整后的每个维度都是整数
x_image = tf.reshape(x, [-1, 4, 10]) # -1表示该维度会自动调整，如原来是80维的向量就会变成2*4*10

# 保持原来的数据不变，改变张量的shape，调用该函数必须保证调整后的每个维度都是整数

x_image = tf.reshape(x, [-1, 4, 10]) # -1表示该维度会自动调整，如原来是80维的向量就会变成2*4*10

tf.cast()

# 用来做类型转换，保持数据不变，改变张量的dtype tf.cast(correct_pred, tf.float32)

1
2
3

# 用来做类型转换，保持数据不变，改变张量的dtype
tf.cast(correct_pred, tf.float32)

tf.argmax()

# 返回最大数值的下标，第二个参数表示在第几个维度中找，一般用来找到概率中最大的一个
max_idx_l = tf.argmax(tf.reshape(y_, [-1, 4, CHAR_SET_LEN]), 2) # 在CHAR_SET_LEN中找数值最大的返回其下标

# 返回最大数值的下标，第二个参数表示在第几个维度中找，一般用来找到概率中最大的一个

max_idx_l = tf.argmax(tf.reshape(y_, [-1, 4, CHAR_SET_LEN]), 2) # 在CHAR_SET_LEN中找数值最大的返回其下标

tf.equal()

# 对比两个矩阵或者向量的相等的元素，如果是相等的那就返回True，反正返回False，返回的值的矩阵维度和A是一样的
tf.equal(A, B)

# 对比两个矩阵或者向量的相等的元素，如果是相等的那就返回True，反正返回False，返回的值的矩阵维度和A是一样的

tf.equal(A, B)

tf.reduce_mean()

# 在某个维度上求平均值，如果不设置维度，则求所有数据的平均值
tf.reduce_mean(x) # 求x所有数据的平均值（只返回一个结果）
tf.reduce_mean(x, 0) # 求x在0维上的平均值

# 在某个维度上求平均值，如果不设置维度，则求所有数据的平均值

tf.reduce_mean(x) # 求x所有数据的平均值（只返回一个结果）

tf.reduce_mean(x, 0) # 求x在0维上的平均值

tf.reduce_sum()

# 在某个维度上求和，如果不设置维度，则求所有数据的和
tf.reduce_mean(x) # 求x所有数据的和（只返回一个结果）
tf.reduce_mean(x, 0) # 求x在0维上的和

# 在某个维度上求和，如果不设置维度，则求所有数据的和

tf.reduce_mean(x) # 求x所有数据的和（只返回一个结果）

tf.reduce_mean(x, 0) # 求x在0维上的和

随机数

tf.random_normal()

# 生成一些随机数，这些随机数会服从均值（mean）为0，标准差（stddev）为1的正态分布。当然你也可以自己指定均值和标准差。
t = tf.random_normal([5, 3],mean=0.5) 生成5*3个随机数

# 生成一些随机数，这些随机数会服从均值（mean）为0，标准差（stddev）为1的正态分布。当然你也可以自己指定均值和标准差。

t = tf.random_normal([5, 3],mean=0.5) 生成5*3个随机数

激活函数

tf.nn.relu()

# 计算线性整流函数值 # x<0 时，y=0， x>=0 时,y=x y = tf.nn.relu(x)

1
2
3
4

# 计算线性整流函数值
# x<0 时，y=0， x>=0 时,y=x
y = tf.nn.relu(x)
tf.sigmod()

# 计算sigmod函数值 # y = 1 / (1 + exp(-x)) # tf.sigmod(0.) 值为0.5 y = tf.sigmod(x)

1
2
3
4
5

# 计算sigmod函数值
# y = 1 / (1 + exp(-x))
# tf.sigmod(0.) 值为0.5
y = tf.sigmod(x)
tf.nn.softmax()

# 将概率使用softmax函数归一化， # softmax[i, j] = exp(logits[i, j]) / sum(exp(logits[i])) y = tf.nn.softmax(x)

1
2
3
4

# 将概率使用softmax函数归一化，
# softmax[i, j] = exp(logits[i, j]) / sum(exp(logits[i]))
y = tf.nn.softmax(x)

loss函数

softmax_cross_entropy_with_logits()

# softmax交叉熵损失 loss = tf.nn.softmax_cross_entropy_with_logits(logits=y, labels=y_)

1
2
3

# softmax交叉熵损失
loss = tf.nn.softmax_cross_entropy_with_logits(logits=y, labels=y_)
sigmoid_cross_entropy_with_logits()

# sigmod交叉熵损失 loss = tf.nn.tf.nn.sigmoid_cross_entropy_with_logits(logits=y, labels=y_)

1
2
3

# sigmod交叉熵损失
loss = tf.nn.tf.nn.sigmoid_cross_entropy_with_logits(logits=y, labels=y_)

优化器

GradientDescentOptimizer()

# 梯度下降优化器 optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(loss)

1
2
3

# 梯度下降优化器
optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
AdamOptimizer()

# 自适应矩估计优化器 optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)

1
2
3

# 自适应矩估计优化器
optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)

硬件设置

动态分配GPU显存

config = tf.ConfigProto(allow_soft_placement=True) config.gpu_options.allow_growth=True sess = tf.Session(config=config)

1
2
3
4

config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth=True
sess = tf.Session(config=config)

一个demo

# MNIST数据集训练

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

in_units = 784 # 输入层神经元数目
h_units = 300 # 隐藏层神经元数目
out_units = 10 # 输出层神经元数目

# 图片输入
x = tf.placeholder(tf.float32, [None, in_units])
w_1 = tf.Variable(tf.truncated_normal([in_units, h_units], stddev=0.1)) # 权重1
b_1 = tf.Variable(tf.zeros([h_units])) # 偏移1

keep_prob = tf.placeholder(tf.float32) # drop_out

h = tf.nn.relu(tf.matmul(x, w_1) + b_1) # 隐藏层输出
h_dropout = tf.nn.dropout(h, keep_prob) # 隐藏层drop_out后输出
w_2 = tf.Variable(tf.zeros([h_units, out_units])) # 权重2
b_2 = tf.Variable(tf.zeros(out_units)) # 偏移2

logits = tf.matmul(h_dropout, w_2) + b_2 # 输出层输出
y = tf.nn.softmax(logits) # softmax函数处理（转换成概率）

y_ = tf.placeholder(tf.float32, [None, out_units]) # label的输入

cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=logits)) # 交叉熵损失，相当于 tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

optimizer = tf.train.AdagradOptimizer(0.3).minimize(cross_entropy) # Adagrad优化器，学习率为0.3

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer()) # 初始化全局变量

    correct = tf.equal(tf.arg_max(y, 1), tf.arg_max(y_, 1)) # 正确的矩阵（正确为1 错误为0） 
    accuracy = tf.reduce_mean(tf.cast(correct, tf.float32)) # 正确率

    for i in range(3001):
        xs, ys = mnist.train.next_batch(100) # 每个batch有100张图片数据
        _, loss = sess.run([optimizer, cross_entropy], feed_dict={x: xs, y_: ys, keep_prob: 0.75}) # 训练
        print(i, loss)

    acc = sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}) # 训练完3000个iterators后，计算测试集的准确率
    print('final:%f' % acc)

# MNIST数据集训练

import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

in_units = 784 # 输入层神经元数目

h_units = 300 # 隐藏层神经元数目

out_units = 10 # 输出层神经元数目

# 图片输入

x = tf.placeholder(tf.float32, [None, in_units])

w_1 = tf.Variable(tf.truncated_normal([in_units, h_units], stddev=0.1)) # 权重1

b_1 = tf.Variable(tf.zeros([h_units])) # 偏移1

keep_prob = tf.placeholder(tf.float32) # drop_out

h = tf.nn.relu(tf.matmul(x, w_1) + b_1) # 隐藏层输出

h_dropout = tf.nn.dropout(h, keep_prob) # 隐藏层drop_out后输出

w_2 = tf.Variable(tf.zeros([h_units, out_units])) # 权重2

b_2 = tf.Variable(tf.zeros(out_units)) # 偏移2

logits = tf.matmul(h_dropout, w_2) + b_2 # 输出层输出

y = tf.nn.softmax(logits) # softmax函数处理（转换成概率）

y_ = tf.placeholder(tf.float32, [None, out_units]) # label的输入

cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=logits)) # 交叉熵损失，相当于 tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

optimizer = tf.train.AdagradOptimizer(0.3).minimize(cross_entropy) # Adagrad优化器，学习率为0.3

with tf.Session() as sess:

sess.run(tf.global_variables_initializer()) # 初始化全局变量

correct = tf.equal(tf.arg_max(y, 1), tf.arg_max(y_, 1)) # 正确的矩阵（正确为1 错误为0）

accuracy = tf.reduce_mean(tf.cast(correct, tf.float32)) # 正确率

for i in range(3001):

xs, ys = mnist.train.next_batch(100) # 每个batch有100张图片数据

_, loss = sess.run([optimizer, cross_entropy], feed_dict={x: xs, y_: ys, keep_prob: 0.75}) # 训练

print(i, loss)

acc = sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}) # 训练完3000个iterators后，计算测试集的准确率

print('final:%f' % acc)

模型的保存和载入

模型的保存

tf.add_to_collection('network-output', y) # 如果不加这句话 测试的时候需要y的定义，也就是整个模型的源码
saver = tf.train.Saver()
saver.save(session, 'checkpoint/test')

tf.add_to_collection('network-output', y) # 如果不加这句话测试的时候需要y的定义，也就是整个模型的源码

saver = tf.train.Saver()

saver.save(session, 'checkpoint/test')

模型的加载

saver = tf.train.Saver()
# 有模型的源码
saver.restore(sess, tf.train.latest_checkpoint('checkpoint'))
# 没有模型源码，从meta文件加载
saver = tf.train.import_meta_graph('checkpoint/test.meta')
saver.restore(session, 'checkpoint/test')  # .data文件
y = tf.get_collection('network-output')[0]

saver = tf.train.Saver()

# 有模型的源码

saver.restore(sess, tf.train.latest_checkpoint('checkpoint'))

# 没有模型源码，从meta文件加载

saver = tf.train.import_meta_graph('checkpoint/test.meta')

saver.restore(session, 'checkpoint/test') # .data文件

y = tf.get_collection('network-output')[0]