生成数据集：?tf.data.Dataset.from_tensor_slices(tensor变量)
创建一个数据集，其元素是给定张量的切片
生成迭代器：?next(iter())
next() 返回迭代器的下一个项目，iter()获取可迭代对象的迭代器
# 返回2项数据，图像x_test，目标y_test
db = tf.data.Dataset.from_tensor_slices((x_test,y_test))
# 迭代器得到的第0个元素是图像，第1个元素是目标
next(iter(db))[0].shape # TensorShape([32, 32, 3])
next(iter(db))[1].shape # TensorShape([])
重新洗牌： .shuffle(buffer_size)
将序列的所有元素随机排序，不打散x和y之间的相互对应关系。维持一个buffer_size大小的缓存，每次都会随机在这个缓存区抽取一定数量的数据
调用函数： .map(func)
将func函数作用于dataset中的每一个元素
def preprocess(x,y):
x = tf.cast(x, dtype=tf.float32)/255
y = tf.cast(y, dtype=tf.int32)
y = tf.one_hot(y,depth=10)
return(x,y)
# 对Dataset中的数据进行函数所指定的预处理操作
db2 = db.map(preprocess)
# 生成迭代器
res = next(iter(db2))
# 查看数据
print(res[0].shape,res[1])
生成对列： .batch(batch_size)
tensor队列生成器，作用是按照给定的tensor顺序，把batch_size个tensor推送到文件队列，作为训练一个batch的数据，等待tensor出队执行计算
#（5）.batch 一次读取读取n张图片
db3 = db2.batch(32) # 每次读取32张图片
res = next(iter(db3)) # 生成迭代器，每次取出32张
print(res[0].shape,res[1].shape) #res[0]代表图像数据，res[1]代表目标
# (32, 32, 32, 3) (32, 10)
重复迭代： .repeat(count)
将数据重复count次，相当于我们训练时的epoch
db = tf.data.Dataset.from_tensor_slices((x_test,y_test))
db = db.repeat(2) # 迭代两次
db = db.repeat() # 永远不会退出
实例展示
只需要对训练数据y进行one-hot编码，因为训练集的y要和网络输出结果求损失。网络输出层得到的是每张图片属于每个分类的概率，是一个二维tensor，因此训练集的y也需要是一个二维tensor，才能做比较。而在测试过程中。预测出的结果是一个值，该图片属于哪个，真实值y_test也是一个值，只需要比较两个值是不是相同即可，不需要one-hot编码。
#（1）加载数据集，(x,y)存放训练数据，(x_test,y_test)存放测试数据
(x,y),(x_test,y_test) = datasets.fashion_mnist.load_data()
# 查看数据集信息
print('x-min:',x.min(),' x-max:',x.max(),' x-mean',x.mean())
print('x-shape:',x.shape,'\ny-shape:',y.shape)
print('x_test-shape:',x_test.shape,'\ny_test-shape:',y_test.shape)
print('y[:4]:',y[:4]) # 查看前4个y值
#（2）定义预处理函数
y = tf.one_hot(y,depth=10) # one-hot编码，转换成长度为10的向量，对应索引的值变为1
def processing(x,y):
x = tf.cast(x,tf.float32)/255.0 # x数据改变数据类型，并归一化
y = tf.cast(y,tf.int32) # 对目标y改变数据类型
return(x,y)
#（3）生成训练集的Dataset
ds = tf.data.Dataset.from_tensor_slices((x,y))
# 对训练数据预处理
ds = ds.map(processing)
# 重新洗牌，每次迭代读取100张图片
ds = ds.shuffle(1000).batch(100)
#（4）生成测试集的Dataset
ds_tes = tf.data.Dataset.from_tensor_slices((x_test,y_test))
# 测试数据预处理
ds_tes = ds_tes.map(processing)
# 洗牌、确定batch
ds_tes = ds_tes.shuffle(1000).batch(100)
2. 前向传播
在上一节中我们完成了对训练数据的前向传播操作，接下来加入测试数据从第（9）步开始。
上一节内容：【深度学习】(1) 前向传播，附python完整代码
# 前向传播
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import datasets # 数据集工具
import os # 设置一下输出框打印的内容
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # '2'输出栏只打印error信息，其他乱七八糟的信息不打印
#（1）获取mnist数据集
(x,y),(x_test,y_test) = datasets.mnist.load_data()
#（2）转换成tensor类型，x数据类型一般为float32，y存放的是图片属于哪种具体类型，属于整型
x = tf.convert_to_tensor(x,dtype=tf.float32)/255.0
y = tf.convert_to_tensor(y,dtype=tf.int32)
x_test = tf.convert_to_tensor(x_test,dtype=tf.float32)/255.0
y_test = tf.convert_to_tensor(y_test,dtype=tf.int32)
#（3）查看数据内容
print('shape：',x.shape,y.shape,'\ndtype：',x.dtype,y.dtype) #查看shape和数据类型
print('x的最小值：',tf.reduce_min(x),'\nx的最大值：',tf.reduce_max(x)) #查看x的数据范围
print('y的最小值：',tf.reduce_min(y),'\ny的最大值：',tf.reduce_max(y)) #查看y的数据范围
#（4）预处理
y = tf.one_hot(y,depth=10) # 对训练数据的目标集的数值编码，变为长度为10的向量，对应索引的值变为1
lr = 1e-3 # 指定学习率
#（5）指定一个选取数据的batch，一次取128个数据
train_db = tf.data.Dataset.from_tensor_slices((x,y)).batch(128)
test_db = tf.data.Dataset.from_tensor_slices((x_test,y_test)).batch(128)
#（6）构建网络
# 构建网络，自定义中间层的神经元个数
# [b,784] => [b,256] => [b,128] => [b,10]
# 第一个连接层的权重和偏置，都变成tf.Variable类型，这样tf.GradientTape才能记录梯度信息
w1 = tf.Variable(tf.random.truncated_normal([784,256], stddev=0.1)) # 截断正态分布，标准差调小一点防止梯度爆炸
b1 = tf.Variable(tf.zeros([256])) #维度为[dim_out]
# 第二个连接层的权重和偏置
w2 = tf.Variable(tf.random.truncated_normal([256,128], stddev=0.1)) # 截断正态分布，维度为[dim_in, dim_out]
b2 = tf.Variable(tf.zeros([128])) #维度为[dim_out]
# 第三个连接层的权重和偏置
w3 = tf.Variable(tf.random.truncated_normal([128,10], stddev=0.1)) # 截断正态分布，维度为[dim_in, dim_out]
b3 = tf.Variable(tf.zeros([10])) #维度为[dim_out]
#（7）前向传播运算
for i in range(50): #对整个数据集迭代10次
# 对数据集的所有batch迭代一次
# x为输入的特征项，shape为[128,28,28]，y为分类结果，shape为[128]
for step,(x,y) in enumerate(train_db): # 返回下标和对应的值
# 这里的x的shape为[b,28*28]，从[b,w,h]变成[b,w*h]
x = tf.reshape(x,[-1,28*28]) #对输入特征项的维度变换，-1会自动计算b
with tf.GradientTape() as tape: # 自动求导计算梯度，只会跟踪tf.Variable类型数据
# ==1== 从输入层到隐含层1的计算方法为：h1 = w1 @ x1 + b1
# [b,784] @ [784,256] + [b,256] = [b,256]
h1 = x @ w1 + b1 # 相加时会自动广播，改变b的shape，自动进行tf.broadcast_to(b1,[x.shape[0],256])
# 激活函数，relu函数
h1 = tf.nn.relu(h1)
# ==2== 从隐含层1到隐含层2，[b,256] @ [256,128] + [b,128] = [b,128]
h2 = h1 @ w2 + b2
h2 = tf.nn.relu(h2)
# ==3== 从隐含层2到输出层，[b,128] @ [128,10] + [b,10] = [b,10]
out = h2 @ w3 + b3 # shape为[b,10]
#（8）计算误差，输出值out的shape为[b,10]，onehot编码后真实值y的shape为[b,10]
# 计算均方差 mse = mean(sum((y-out)^2)
loss_square = tf.square(y-out) # shape为[b,10]
loss = tf.reduce_mean(loss_square) # 得到一个标量
# 梯度计算
grads = tape.gradient(loss,[w1,b1,w2,b2,w3,b3])
# 权重更新，lr为学习率，梯度每次下降多少
# 注意：下面的方法，运算返回值是tf.tensor类型，在下一次运算会出现错误
# w1 = w1 - lr * grads[0] # 返回的w1在grad的第0个元素
# 因此需要原地更新函数，保证更新后的数据类型不变tf.Variable
w1.assign_sub(lr * grads[0])
b1.assign_sub(lr * grads[1])
w2.assign_sub(lr * grads[2])
b2.assign_sub(lr * grads[3])
w3.assign_sub(lr * grads[4])
b3.assign_sub(lr * grads[5])
if step % 100 == 0: #每100次显示一次数据
print(f"第{step+1}次迭代，loss为{np.float(loss)}") #loss是tensor变量
# loss为nan，出现梯度爆炸的情况，初始化权重的时候变小一点
#（9）网络测试
# total_correct统计预测对了的个数，total_num统计参与测试的个数
total_correct, total_num = 0, 0
# 对网络测试，test必须要使用当前阶段的权重w和偏置b，测试当前阶段的计算精度
for step,(x,y) in enumerate(test_db):
x = tf.reshape(x,[-1,28*28])
# 对测试数据进行前向传播
# 输入层[b,784] => [b,256] => [b,128] => 输出层[b,10]
h1 = x @ w1 + b1 # 输入特征和第一层权重做内积，结果加上偏置
h1 = tf.nn.relu(h1) # 计算后的结果放入激活函数中计算，得到下一层的输入
# 隐含层1=>隐含层2
h2 = tf.nn.relu(h1 @ w2 + b2) # [b,256] => [b,128]
# 隐含层2=>输出层
out = h2 @ w3 + b3 # [b,128] => 输出层[b,10]
#（10）输出概率计算
# 计算概率，out：shape为[b,10]，属于实数；prob：shape为[b,10]，属于[0,1]之间
# 使用softmax()函数，使实数out映射到[0,1]的范围
prob = tf.nn.softmax(out,axis=1) # out是二维的，在第1个轴上映射，即把某张图片属于某个类的值变成概率
# 概率最大的值所在的位置索引是预测结果，即属于第几个分类
predict = tf.argmax(prob, axis=1,output_type=tf.int32) # 每张图片的概率最大值所在位置，shape[b,10]，10所在的维度
# 测试集的y不需要转换成one-hot，真实值y是一个数值，predict也是一个数值，两两相比较
correct = tf.equal(predict, y) # 比较，返回布尔类型，相同为True，不同为False
correct = tf.cast(correct,dtype=tf.int32) # 将布尔类型转换为int32类型
correct = tf.reduce_sum(correct) # 每次取出的batch中，有多少张图片是预测对的
# 1代表预测对了，0代表预测错了
total_correct += int(correct) # 统计对的个数，correct是tensor类型
total_num += x.shape[0] # 统计一共有多少组参与测试，x.shape=[128,28*28]，x.shape[0]有128张图片
# 数据集整体完成一次迭代后
accuracy = total_correct / total_num # 计算每一轮循环的准确率
print(f'accuracy={accuracy}')
迭代50轮，结果如下。优化方法，在下一节讨论。
第50个循环
第1次迭代，loss为0.04710124433040619
第101次迭代，loss为0.05284833908081055
第201次迭代，loss为0.050228558480739594
第301次迭代，loss为0.052753616124391556
第401次迭代，loss为0.05572255700826645
accuracy=0.7847
|