'''import numpy as np
# 1.采样数据
data = [] # 保存样本集的列表
for i in range(100): # 循环采样100个点
x = np.random.uniform(-10.,10.) # 随机采样输入x
# 采样高斯噪声
eps = np.random.normal(0.,0.01)
# 得到模型输出
y = 1.477*x + 0.089 + eps
data.append([x,y]) # 保存样本点
data = np.array(data) # 转换为2DNumpy数组
# 2.计算误差
def mse(b, w, points):
# 根据当前的w,b参数计算均方差损失
totalError = 0
for i in range(0,len(points)): # 环所有迭代点
x = points[i, 0] # 得i号点的输入x
y = points[i, 1] # 得i号点的输出y
#计算差的平方，并累加
totalError += (y - (w*x + b)) ** 2
# 将累加的误差求平均，得到均方差
return totalError/float(len(points))
# 3.计算梯度
def step_grdient(b_current, w_current, points, lr):
# 计算误差函数所在点上的导数，并更新w,b
b_gradient = 0
w_gradient = 0
M = float(len(points)) # 总样本数
for i in range(0, len(points)):
x = points[i, 0]
y = points[i, 1]
# 误差函数对b的导数：grad_b = 2(wx+b-y)，参考式（2.3）
b_gradient += (2/M)*((w_current* x + b_current)-y)
# 误差函数对w的导数：grad_b = 2(wx+b-y)* x，参考式（2.2）
w_gradient += (2/M)*x*((w_current *x + b_current) - y)
# 根据梯度下降算法更新w',b',其中lr为学习率
new_b = b_current - (lr * b_gradient)
new_w = w_current - (lr * w_gradient)
return[new_b, new_w]
# 4.梯度更新
def gradient_descent(points, starting_b, starting_w, lr, num_iterations):
# 循环更新w,b多次
b = starting_b # b的初始值
w = starting_w # w的初始值
# 根据梯度下降算法更新多次
for step in range(num_iterations):
# 计算梯度并更新一次
[b,w] = step_gradient(b,w, np.array(points),lr)
loss = mse(b,w,points) # 计算当前的均方差，用于监控训练进度
if step % 50 == 0: # 打印误差和实时的w，b值
print(f"iteration:{step}, loss:{loss}, w:{w}, b:{b}")
return [b,w] # 返回最后一次的w,b
# 主训练函数实现如下：
def main():
# 加载训练集数据，这些数据是通过真实模拟添加观测误差采样得到的
lr = 0.01 # 学习率
initial_b = 0 # 初始化b为0
initial_w = 0 # 初始化w为0
num_iterations = 1000
# 训练优化1000次，返回最优w*，b*和训练Loss的下降过程
[b,w] = gradient_descent(data, initial_b, initial_w, lr, num_iterations)
loss = mse(b,w,data) # 计算最优数值解w,b的均方差
print(f'Final loss:{loss},w:{w},b:{b}')'''
# one-hot编码
'''import tensorflow as tf # 导入TF库
y = tf.constant([0,1,2,3,4])
y = tf.one_hot(y,depth=10)
print(y)'''
import os
import tensorflow as tf # 导入TF库
from tensorflow import keras # 导入TF子库keras
from tensorflow.keras import layers, optimizers, datasets # 导入TF子库
(x,y), (x_val, y_val) = datasets.mnist.load_data() # 加载MNIST数据集
x = 2*tf.convert_to_tensor(x, dtype=tf.float32)/255.-1 # 转换为浮点张量，并缩放到-1~1
y = tf.convert_to_tensor(y, dtype=tf.int32) # 转换为整型张量
y = tf.one_hot(y, depth=10)
print(x.shape, y.shape)
train_dataset = tf.data.Dataset.from_tensor_slices((x, y)) # 构建数据集对象
train_dataset = train_dataset.batch(512) # 批量训练
# 创建一层网络，设置输出节点数为258，激活函数类型为ReLU
layers.Dense(256, activation = 'relu')
# 利用Sequential 容器封装3个网络层，前网络层的输出默认作为下一层的输入
model = keras.Sequential([ # 3个非线性层的嵌套模型
layers.Dense(256,activation='relu'), # 隐藏层1
layers.Dense(128,activation='relu'), # 隐藏层2
layers.Dense(10)]) # 输出层，输出节点数为10
with tf.GradientTape() as tape: # 构建梯度记录环境
# 打平操作，[b,28,28]=>[b,10]
out = model(x)
# [b]=>[b,10]
y_onehot = tf.one_hot(y,depth=10)
# 计算差的平方和[b,10]
loss = tf.square(out-y_onehot)
# 计算每个样本的平均误差，[b]
loss = tf.reduce_sum(loss)/x.shape[0]
# Step3 计算参数的梯度w1, w2, w3, b1, b2, b3
grads = tape.gradient(loss,model.trainable_variables)
# 自动计算梯度
grads = tape.gradient(loss, model.trainable_variables)
# w' = w-lr*grad,更新网格参数
optimizer.apply_gradients(zip(grads,model.trainable_variables))
# 每层的张量都需要被优化，故使用Variable类型，并使用截断的正态分布初始化权值张量
# 偏置向量初始化为0即可
# 第一层的参数
w1 = tf.Variable(tf.random.truncated_normal([784,256], stddev=0.1))
b1 = tf.Variable(tf.zeros([256]))
# 第二层的参数
w2 = tf.Variable(tf.random.truncated_normal([256,128], stddev=0.1))
b2 = tf.Variable(tf.zeros([128]))
# 第三层参数
w3 = tf.Variable(tf.random.truncated_normal([128,10], stddev=0.1))
b3 = tf.Variable(tf.zeros([10]))
# 改变视图，[b,28,28]=>[b,28*28]
x = tf.reshape(x,[-1,28*28])
# 第一层计算，[b,784]@[784,256]+[256]=>[b,256]+[256]=>[b,256]+[b,256]
h1 = x@w1 + tf.broadcast_to(b1,[x.shape[0],256])
h1 = tf.nn.relu(h1) # 通过激活函数
# 第二层计算，[b,256]=>[b,128]
h2 = h1@w2 +b2
h2 = tf.nn.relu(h2)
# 输出计算层，[b,128]=>[b,10]
out = h2@w3 + b3
# 计算网络输出与标签之间的方差，mse = mean(sum(y-out)^2)
# [b,10]
loss = tf.square(y_onehot - out)
# 误差标量，mean:scalar
loss = tf.reduce_mean(loss)
# 自动梯度，需要求梯度的 张量有[w1,b1,w2,b2,w3,b3]
grads = tape.gradient(loss[w1,b1,w2,b2,w3,b3])
# 梯度更新，assign_sub将当前值减去参数值，原地更新
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])
