详解TensorFlow2实现前向传播

tf.math.reduce_min(
    input_tensor, axis=None, keepdims=False, name=None
)

tf.math.reduce_max(
    input_tensor, axis=None, keepdims=False, name=None
)

@staticmethod
from_tensor_slices(
    tensors
)

iter(object[, sentinel])

list = [1, 2, 3]
i = iter(list)
print(next(i))
print(next(i))
print(next(i))

tf.random.truncated_normal(
    shape, mean=0.0, stddev=1.0, dtype=tf.dtypes.float32, seed=None, name=None
)

tf.one_hot(
    indices, depth, on_value=None, off_value=None, axis=None, dtype=None, name=None
)

tf.compat.v1.assign_sub(
    ref, value, use_locking=None, name=None
)

import Tensorflow as tf

# 定义超参数
batch_size = 256  # 一次训练的样本数目
learning_rate = 0.001  # 学习率
iteration_num = 20  # 迭代次数

# 读取mnist数据集
(x, y), _ = tf.keras.datasets.mnist.load_data()  # 读取训练集的特征值和目标值
print(x[:5])  # 调试输出前5个图
print(y[:5])  # 调试输出前5个目标值数字
print(x.shape)  # (60000, 28, 28) 单通道
print(y.shape)  # (60000,)

# 转换成常量tensor
x = tf.convert_to_tensor(x, dtype=tf.float32) / 255  # 转换为0~1的形式
y = tf.convert_to_tensor(y, dtype=tf.int32)  # 转换为整数形式

# 调试输出范围
print(tf.reduce_min(x), tf.reduce_max(x))  # 0~1
print(tf.reduce_min(y), tf.reduce_max(y))  # 0~9

# 分割数据集
train_db = tf.data.Dataset.from_tensor_slices((x, y)).batch(batch_size)  # 256为一个batch
train_iter = iter(train_db)  # 生成迭代对象

# 定义权重和bias [256, 784] => [256, 256] => [256, 128] => [128, 10]
w1 = tf.Variable(tf.random.truncated_normal([784, 256], stddev=0.1))  # 标准差为0.1的截断正态分布
b1 = tf.Variable(tf.zeros([256]))  # 初始化为0

w2 = tf.Variable(tf.random.truncated_normal([256, 128], stddev=0.1))  # 标准差为0.1的截断正态分布
b2 = tf.Variable(tf.zeros([128]))  # 初始化为0

w3 = tf.Variable(tf.random.truncated_normal([128, 10], stddev=0.1))  # 标准差为0.1的截断正态分布
b3 = tf.Variable(tf.zeros([10]))  # 初始化为0

def train(epoch):  # 训练
    for step, (x, y) in enumerate(train_db):  # 每一批样本遍历
        # 把x平铺 [256, 28, 28] => [256, 784]
        x = tf.reshape(x, [-1, 784])

        with tf.GradientTape() as tape:  # 自动求解
            # 第一个隐层 [256, 784] => [256, 256]
            # [256, 784]@[784, 256] + [256] => [256, 256] + [256] => [256, 256] + [256, 256] (广播机制)
            h1 = x @ w1 + tf.broadcast_to(b1, [x.shape[0], 256])
            h1 = tf.nn.relu(h1)  # relu激活

            # 第二个隐层 [256, 256] => [256, 128]
            h2 = h1 @ w2 + b2
            h2 = tf.nn.relu(h2)  # relu激活

            # 输出层 [256, 128] => [128, 10]
            out = h2 @ w3 + b3

            # 计算损失MSE(Mean Square Error)
            y_onehot = tf.one_hot(y, depth=10)  # 转换成one_hot编码
            loss = tf.square(y_onehot - out)  # 计算总误差
            loss = tf.reduce_mean(loss)  # 计算平均误差MSE


        # 计算梯度
        grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])

        # 更新权重
        w1.assign_sub(learning_rate * grads[0])  # 自减梯度*学习率
        b1.assign_sub(learning_rate * grads[1])  # 自减梯度*学习率
        w2.assign_sub(learning_rate * grads[2])  # 自减梯度*学习率
        b2.assign_sub(learning_rate * grads[3])  # 自减梯度*学习率
        w3.assign_sub(learning_rate * grads[4])  # 自减梯度*学习率
        b3.assign_sub(learning_rate * grads[5])  # 自减梯度*学习率

        if step % 100 == 0:  # 每运行100个批次, 输出一次
            print("epoch:", epoch, "step:", step, "loss:", float(loss))

def run():
    for i in range(iteration_num):  # 迭代20次
        train(i)

import tensorflow as tf

# 定义超参数
batch_size = 256  # 一次训练的样本数目
learning_rate = 0.001  # 学习率
iteration_num = 20  # 迭代次数

# 读取mnist数据集
(x, y), _ = tf.keras.datasets.mnist.load_data()  # 读取训练集的特征值和目标值
print(x[:5])  # 调试输出前5个图
print(y[:5])  # 调试输出前5个目标值数字
print(x.shape)  # (60000, 28, 28) 单通道
print(y.shape)  # (60000,)

# 转换成常量tensor
x = tf.convert_to_tensor(x, dtype=tf.float32) / 255  # 转换为0~1的形式
y = tf.convert_to_tensor(y, dtype=tf.int32)  # 转换为整数形式

# 调试输出范围
print(tf.reduce_min(x), tf.reduce_max(x))  # 0~1
print(tf.reduce_min(y), tf.reduce_max(y))  # 0~9

# 分割数据集
train_db = tf.data.Dataset.from_tensor_slices((x, y)).batch(batch_size)  # 256为一个batch
train_iter = iter(train_db)  # 生成迭代对象

# 定义权重和bias [256, 784] => [256, 256] => [256, 128] => [128, 10]
w1 = tf.Variable(tf.random.truncated_normal([784, 256], stddev=0.1))  # 标准差为0.1的截断正态分布
b1 = tf.Variable(tf.zeros([256]))  # 初始化为0

w2 = tf.Variable(tf.random.truncated_normal([256, 128], stddev=0.1))  # 标准差为0.1的截断正态分布
b2 = tf.Variable(tf.zeros([128]))  # 初始化为0

w3 = tf.Variable(tf.random.truncated_normal([128, 10], stddev=0.1))  # 标准差为0.1的截断正态分布
b3 = tf.Variable(tf.zeros([10]))  # 初始化为0


def train(epoch):  # 训练
    for step, (x, y) in enumerate(train_db):  # 每一批样本遍历
        # 把x平铺 [256, 28, 28] => [256, 784]
        x = tf.reshape(x, [-1, 784])

        with tf.GradientTape() as tape:  # 自动求解
            # 第一个隐层 [256, 784] => [256, 256]
            # [256, 784]@[784, 256] + [256] => [256, 256] + [256] => [256, 256] + [256, 256] (广播机制)
            h1 = x @ w1 + tf.broadcast_to(b1, [x.shape[0], 256])
            h1 = tf.nn.relu(h1)  # relu激活

            # 第二个隐层 [256, 256] => [256, 128]
            h2 = h1 @ w2 + b2
            h2 = tf.nn.relu(h2)  # relu激活

            # 输出层 [256, 128] => [128, 10]
            out = h2 @ w3 + b3

            # 计算损失MSE(Mean Square Error)
            y_onehot = tf.one_hot(y, depth=10)  # 转换成one_hot编码
            loss = tf.square(y_onehot - out)  # 计算总误差
            loss = tf.reduce_mean(loss)  # 计算平均误差MSE


        # 计算梯度
        grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])

        # 更新权重
        w1.assign_sub(learning_rate * grads[0])  # 自减梯度*学习率
        b1.assign_sub(learning_rate * grads[1])  # 自减梯度*学习率
        w2.assign_sub(learning_rate * grads[2])  # 自减梯度*学习率
        b2.assign_sub(learning_rate * grads[3])  # 自减梯度*学习率
        w3.assign_sub(learning_rate * grads[4])  # 自减梯度*学习率
        b3.assign_sub(learning_rate * grads[5])  # 自减梯度*学习率

        if step % 100 == 0:  # 每运行100个批次, 输出一次
            print("epoch:", epoch, "step:", step, "loss:", float(loss))


def run():
    for i in range(iteration_num):  # 迭代20次
        train(i)


if __name__ == "__main__":
    run()