TensorFlow是一个以图(graphs)来表示计算的框架，图中的节点被称之为op (operation 的缩写)。一个 op 获得零或多个张量 (tensors) 执行计算，产生零或多个张量。张量是一个按类型划分的多维数组。
import tensorflow as tf
def func1():
"""
1、使用张量tensor来代表数据
:return:
"""
# 0维张量（标量），维度=0, 形状=()
scalar = tf.constant(5)
# 1维张量（向量），维度=1，形状=(3,)
vector = tf.constant([1, 2, 3])
# 2维张量（矩阵），维度=2，形状=(2,3)
matrix = tf.constant([[1, 2, 3], [4, 5, 6]])
# 3维张量，维度=3，形状=(2,3,4)
tensor = tf.constant([[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
[[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]])
# 获取张量的维度
rank = tf.rank(tensor)
print(rank)
# 获取张量的形状
shape = tf.shape(tensor)
print(shape)
with tf.Session() as sess:
print(sess.run(rank))
print(sess.run(shape))
def func2():
# 变量维持了计算图执行过程中的状态信息
"""
2、使用变量来维护状态
:return:
"""
# 定义变量counter，初始值为0
state = tf.Variable(0, name="counter")
# 定义常量1
one = tf.constant(1)
# add op：用于加法运算
new_value = tf.add(state, one)
# assign op：用于赋值，把new_value（加1操作的运算op）赋值给state，
update = tf.assign(state, new_value) # 也可以写为update = tf.assign(state, tf.add(state,one))
init_op = tf.initialize_all_variables()
with tf.Session() as sess:
# 开启会话后，必须执行变量初始化操作 init_op。 也可以用tf.global_variables_initializer()
sess.run(init_op)
print(sess.run(state))
for _ in range(3):
sess.run(update)
print(sess.run(state))
def func3():
# 刚开始基于 op 建立图的时候一般不需要任何的输入源 (source op)，例如输入常量(Constance)，
# 再将它们传递给其它 op 执行运算。Python 库中的 op 构造函数返回值代表已被组织好的 op 作为输出，
# 这些返回值可以传递给其它 op 构造函数作为输入。
# TensorFlow(Python库)有一个可被op构造函数加入计算结点的默认图(default graph)。对大多数应用来说，这个默认图已经足够用了。
"""
3、使用计算图来搭建神经网络 build computation graph
:return:
"""
# 创建1个1x2的矩阵，constant的返回值就Constant op的输出，该op节点将被添加到默认图形中
matrix1 = tf.constant([[1., 1.]])
# 创建一个2x1的矩阵，constant返回一个op，该op节点将被添加到默认图形中
matrix2 = tf.constant([[2.], [2.]])
# 建一个以matrix1和matrix2作为输入的Matmul操作，matmul的返回值也是一个op，该op节点将被添加到默认图形中
product = tf.matmul(matrix1, matrix2)
# 结果是一个张量，只搭建了运算过程，并没有运算 Tensor("MatMul:0", shape=(1, 1), dtype=float32)
print(product)
return product
def func4():
# 经过func3的搭建，默认图现在拥有三个节点，两个constant() op 和一个matmul() op，
# 为了真正进行矩阵乘法运算得到乘法结果，须在一个会话 (session) 中载入动这个图。
"""
4、使用会话来执行节点运算
:return:
"""
# 要运行matmul-op，调用会话“run（）方法,传递product, 其表示matmul运算的输出，
# op所需的所有输入都由会话自动运行,通常是并行运行的，调用run（product）会导致在图中执行三个操作：两个常量 op 和matmul op
product = func3()
with tf.Session() as sess:
result = sess.run(product)
print("result:", type(result))
# 调整计算，让其fun3的计算图结果转化为list
result = sess.run([product])
print("result:", type(result))
def func5():
# IPython这样的交互式 Python 环境的易用，可以使用InteractiveSession 代替Session类，
# 使用 Tensor.eval()和Operation.run() 方法代替 Session.run()。
# 这样可以避免使用一个变量来持有会话
"""
交互式操作
"""
sess = tf.InteractiveSession()
x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])
x.initializer.run() # 初始化变量“x”，Operation.run() <-- initializer.run()，变量初始化操作代替func2中的 init_op = tf.initialize_all_variables()
sub = tf.subtract(x, a)
print(sub.eval()) # Tensor.eval() <-- sub.eval()，执行节点运算，代替sess.run
sess.close()
def func6():
"""
取回Fetches
:return:
"""
input1 = tf.constant(8.0)
input2 = tf.constant(2.0)
input3 = tf.constant(3.0)
add = tf.add(input2, input3)
mul = tf.multiply(input1, add)
with tf.Session() as sess:
# 可以在使用 Session 对象的 run() 调用执行图时，传入一些 tensor，这些 tensor 会取回结果，取回后还可以加一些操作，比如转成list等
result = sess.run(fetches=mul)
print(result)
# 同时取回多个，fetches也可以省略
result = sess.run([add, mul])
print(result)
def func7():
"""
供给Feeds（占位符placeholder），类似与Java响应式编程中的Supplier、Consumer等
:return:
"""
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.multiply(input1, input2)
with tf.Session() as sess:
# 取回output转转为list
print(sess.run([output], feed_dict={input1: [3.], input2: [2.]}))
def func8():
"""
指定设备
:return:
"""
# TensorFlow 能自动检测并尽可能的充分利用找到的第一个 GPU 进行运算。如果你的设备上有不止一个 GPU
with tf.Session() as sess:
# /cpu:0 -> 计算机的CPU
# /cpu:1 -> 计算机的第1个CPU
# /gpu:2 -> 计算机的第2个GPU
with tf.device("/gpu:288"):
matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.], [2.]])
product = tf.matmul(matrix1, matrix2)
result = sess.run([product])
print(result)
print(type(result))
if __name__ == "__main__":
# func1()
# func2()
# func3()
# func4()
# func5()
# func6()
func7()
数值类型：
tf.float16：半精度浮点数（16 位浮点数）
tf.float32：单精度浮点数（32 位浮点数）
tf.float64：双精度浮点数（64 位浮点数）
tf.int8：8 位有符号整数
tf.int16：16 位有符号整数
tf.int32：32 位有符号整数
tf.int64：64 位有符号整数
tf.uint8：8 位无符号整数
tf.uint16：16 位无符号整数
tf.uint32：32 位无符号整数
tf.uint64：64 位无符号整数
tf.complex64：64 位复数，由两个 32 位浮点数构成（实部和虚部）
tf.complex128：128 位复数，由两个 64 位浮点数构成（实部和虚部）
布尔类型：
tf.bool：布尔类型，表示 True 或 False
字符串类型：
tf.string：字符串类型，用于表示文本数据
其他类型：
tf.variant：多态类型，可以包含任意 TensorFlow 数据类型的元素
其中用于深度学习的：
W、b初始化相关：
tf.random_normal() 生成正态分布随机数
tf.truncated_normal() 生成去掉过大偏离点的正态分布随机数
tf.random_uniform() 生成均匀分布随机数
tf.zeros 表示生成全 0 数组
tf.ones 表示生成全 1 数组
tf.fill 表示生成全定值数组
tf.constant 表示生成直接给定值的数组
损失函数：
loss_mse = tf.reduce_mean(tf.square(y - y_)) 均方差损失函数
tf.nn.sigmoid_cross_entropy_with_logits(logits=z, labels=y) sigmoid交叉熵
tf.nn.softmax_cross_entropy_with_logits(logits=z, labels=y) softmax交叉熵
梯度下降算法：
tf.train.GradientDescentOptimizer() 标准梯度下降
tf.train.MomentumOptimizer() 动量梯度下降
tf.train.AdamOptimizer() Adam梯度下降
一个训练例子：
def func1():
"""
参数初始化
"""
# stddev指定正态分布的标准差
w1 = tf.Variable(tf.random_normal([2, 3], stddev=2, mean=0, seed=1))
w2 = tf.Variable(tf.truncated_normal([2, 3], stddev=2, mean=0, seed=1))
w3 = tf.random_uniform([2, 3], minval=0, maxval=1, dtype=tf.int32, seed=1)
w4 = tf.fill([3, 2], 6)
with tf.Session() as sess:
w6 = sess.run(fetches=w4)
print(w6)
def func2():
"""
前向传播
:return:
"""
# 输入层2xn的矩阵，2个特征，n个样本
X = tf.placeholder(tf.float32, shape=(2, None), name="X")
W1 = tf.Variable(tf.truncated_normal([3, 2], stddev=0.1, seed=1)) # 第一层3个神经元 [[a1],[a2],[a3]]
W2 = tf.Variable(tf.truncated_normal([1, 3], stddev=0.1, seed=1)) # 第二层1个神经元
a = tf.matmul(W1, X)
y = tf.matmul(W2, a)
# 汇总所有待优化变量
init_op = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init_op)
# 4个样本
y = sess.run(y, feed_dict={X: [[1., 2., 4., 5.], [3., 4., 6., 8.]]})
print("the result of y:", str(y))
def func3():
"""
反向传播
:return:
"""
batch_size = 8
seed = 2
rdm = np.random.RandomState(seed)
X = np.float32(rdm.rand(2, 32)).reshape(2, -1) # 2个特征，32个样本
print(X)
# 从X取出一列 判断如果和小于1 给Y赋值1 如果和不小于1 给Y赋值0
Y_ = np.array([[int(x0 * 0.5 + x1 * 0.8)] for (x0, x1) in X.T]).reshape(1, -1)
print(X.shape)
# 定义前向传播
x = tf.placeholder(tf.float32, shape=(2, None))
y_ = tf.placeholder(tf.float32, shape=(1, None))
W1 = tf.Variable(tf.truncated_normal([3, 2], stddev=0.1, seed=1)) # 第一层3个神经元 [[a1],[a2],[a3]]
W2 = tf.Variable(tf.truncated_normal([1, 3], stddev=0.1, seed=1)) # 第二层1个神经元
a = tf.matmul(W1, X)
y = tf.matmul(W2, a)
loss_mse = tf.reduce_mean(tf.square(y - tf.transpose(y_)))
# 定义反向传播，使用标准梯度下降，学习率为0.001，损失函数为loss_me
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss_mse)
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
# 训练3000次
for i in range(300000):
start = (i * batch_size) % 32
end = start + batch_size
sess.run(train_step, feed_dict={x: X[:, start:end], y_: Y_[:, start:end]})
if i % 500 == 0:
total_loss = sess.run(loss_mse, feed_dict={x: X, y_: Y_})
print("After %d iterations, loss_me on all data is %s" % (i, total_loss))
if __name__ == "__main__":
# func1()
# func2()
func3()
一个基于softmax的训练例子
import math
import numpy as np
import h5py
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.python.framework import ops
from tf_utils import load_dataset, random_mini_batches, convert_to_one_hot, predict
np.random.seed(1)
# LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX.
def create_placeholders(n_x, n_y):
"""
:param n_x: 图片向量大小，本例为12288
:param n_y: 类别数量，0-5的数字，为6
"""
X = tf.placeholder(tf.float32, [n_x, None], name="X")
Y = tf.placeholder(tf.float32, [n_y, None], name="Y")
return X, Y
def initialize_parameters():
tf.set_random_seed(1)
W1 = tf.get_variable("W1", [25, 12288], initializer=tf.truncated_normal_initializer(stddev=0.1))
b1 = tf.get_variable("b1", [25, 1], initializer=tf.zeros_initializer())
W2 = tf.get_variable("W2", [12, 25], initializer=tf.truncated_normal_initializer(stddev=0.1))
b2 = tf.get_variable("b2", [12, 1], initializer=tf.zeros_initializer())
W3 = tf.get_variable("W3", [6, 12], initializer=tf.truncated_normal_initializer(stddev=0.1))
b3 = tf.get_variable("b3", [6, 1], initializer=tf.zeros_initializer())
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2,
"W3": W3,
"b3": b3
}
return parameters
def compute_cost(Z3, Y):
# transpose表示转置，故logits相当于Z3.T
logits = tf.transpose(Z3)
labels = tf.transpose(Y)
# reduce_mean表示获取张量中所有元素的平均值
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))
return cost
def forward_propagation(X, parameters):
W1 = parameters['W1']
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
W3 = parameters["W3"]
b3 = parameters["b3"]
Z1 = tf.add(tf.matmul(W1, X), b1)
A1 = tf.nn.relu(Z1)
Z2 = tf.add(tf.matmul(W2, A1), b2)
A2 = tf.nn.relu(Z2)
Z3 = tf.add(tf.matmul(W3, A2), b3)
# tensorflow的一个特性，它会在计算成本函数时顺带把A3给我们计算了，
# 所以前向传播中我们只需要计算Z3就可以了。
return Z3
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.0001, num_epochs=1500, minibatch_size=32, print_cost=True):
# 将计算图返回到默认空状态
ops.reset_default_graph() # 将计算图返回到默认空状态
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape # (n_x特征数量, m样本数)
n_y = Y_train.shape[0]
costs = []
X, Y = create_placeholders(n_x, n_y)
parameters = initialize_parameters()
Z3 = forward_propagation(X, parameters)
cost = compute_cost(Z3, Y)
# 反向传播
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# 定义初始化操作
init = tf.global_variables_initializer()
# 开始一个session
with tf.Session() as sess:
# 初始化操作
sess.run(init)
# 执行epochs指定的训练次数，一个epoch就是完整的向整个数据集学习一次
for epoch in range(num_epochs):
epoch_cost = 0
num_minibatches = int(m / minibatch_size) # 计算有多少个子集
seed = seed + 1
minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
# 这行代码会使整个计算图被执行，从前向传播操作到反向传播操作，最后到参数更新操作
_, minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})
epoch_cost += minibatch_cost / num_minibatches
if print_cost == True and epoch % 100 == 0:
print("Cost after epoch %s: %f" % (epoch, epoch_cost))
if print_cost == True and epoch % 5 == 0:
costs.append(epoch_cost)
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
# 从计算图中获取训练好了的参数
parameters = sess.run(parameters)
print("Parameters have been trained!")
# 计算准确率:选择概率最大的数字作为预测值与真实值进行比较,统计正确的个数再计算准确率
correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("Train Accuracy: ", accuracy.eval({X: X_train, Y: Y_train}))
print("Test Accuracy: ", accuracy.eval({X: X_test, Y: Y_test}))
return parameters
if __name__ == "__main__":
# 扁平化
X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()
X_train_flatten = X_train_orig.reshape(X_train_orig.shape[0], -1).T
X_test_flatten = X_test_orig.reshape(X_test_orig.shape[0], -1).T
# 简单归一化
X_train = X_train_flatten / 255
X_test = X_test_flatten / 255
# One hot 编码
Y_train = convert_to_one_hot(Y_train_orig, 6)
Y_test = convert_to_one_hot(Y_test_orig, 6)
# tf.reset_default_graph()
# with tf.Session() as sess:
# X, Y = create_placeholders(12288, 6)
# parameters = initialize_parameters()
# Z3 = forward_propagation(X, parameters)
# cost = compute_cost(Z3, Y)
# print("cost=" + str(cost))
parameters = model(X_train, Y_train, X_test, Y_test, num_epochs=1)
计算准确率常用方法：
Z[L]为前向传播的最后节点，Y为训练标签
# 计算准确率:选择概率最大的数字作为预测值与真实值进行比较,统计正确的个数再计算准确率
correct_prediction = tf.equal(tf.argmax(Z[L]), tf.argmax(Y))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
另外如果安装的是TensorFlow2.x，要兼容1.x的代码，则需要改一下导包：
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
扫一扫
1105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
