北大Tensorflow2.0（一）

• 视频：【北京大学】Tensorflow2.0
  在线源码：https://github.com/jlff/tf2_notes
  【参考】【北京大学】Tensorflow2.0搭建一个神经网络入门

Tf2.0第一讲

课程基础：
1、python基础知识视频
Python编程从入门到实践
python初级入门精讲
2、python数据分析
3、tensorflow

1、损失函数

1)y=w*x+b
w—线上权重；b——偏置项
全连接神经网络：y与x有关系
前向传播：带入x、w、b数据直接求出y
w、b是随机产生的，输出的结果不准确——引入损失函数
2）损失函数（loss function）：预测值（y）与标准答案（y_）的差距

• 目的：找到一组参数b和w，使得损失函数最小
• 梯度：函数对各个参数求偏导后的向量，函数梯度下降方向是函数减小方向。
  -== 梯度下降法==：沿着损失函数梯度下降方向，寻找损失函数的最小值，得到参数的方法（公式见pp第一讲p12，其中lr是超参数。：链接：https://pan.baidu.com/s/1uOoZxFwXNpqr-bH8kESuKA
  提取码：fmpc ）

`

2、反向传播、优化器、学习率

• 反向传播：从后向前，逐层求损失函数的对每层神经元参数的偏导数，迭代更新所有参数。
  训练模型数据，在所有参数上用梯度下降，使NN模型再训练数据上的损失函数最小。
  反向传播训练方法：以减小loss值为优化目标，分别有3种不同的方法可以使用——梯度下降、momentum优化器、adam优化器等

在TensorFlow中代码表示分别如下：

train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

train_step=tf.train.MomentumOptimizer(learning_rate, momentum).minimize(loss)

train_step=tf.train.AdamOptimizer(learning_rate).minimize(loss)

lr：学习率 决定参数每次更新的幅度

• 学习率：梯度下降的速度，当过小，收敛过慢，过大时，梯度可能会在最小值附近来回震荡，甚至无法收敛。

这个引用块拿来解释下这三种优化方法：（这里是搬运自网上的，等会再总结下）

• tf.train.GradientDescentOptimizer()
  使用随机梯度下降算法，使参数沿着梯度的反方向，即总损失减小的方向移动，实现更新参数。

• tf.train.MomentumOptimizer()
  在更新参数时，利用了超参数，实现更新参数。

• tf.train.AdamOptimizer()
  是利用自适应学习率的优化算法，Adam 算法和随机梯度下降算法不同。随机梯度下降算法保持单一的学习率更新所有的参数，学习率在训练过程中并不会改变。而 Adam 算法通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率。 学习率：决定每次参数更新的幅度。
  优化器中都需要一个叫做学习率的参数，使用时，如果学习率选择过大会出现震荡不收敛的情况，如果学习率选择过小，会出现收敛速度慢的情况。我们可以选个比较小的值填入，比如0.01、0.001。

版权声明：本文为CSDN博主「Enigmalgia」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_39104294/article/details/85091093

如何导入项目

打开pycharm→file→new project→命名为AL→确认环境D:\Anaconda3\envs\tensorflow\p3.7→create，no，this widows→右击项目选择show in E→把需要的文件夹和源码copy到AL文件夹下
test.py

import tensorflow as tf

w = tf.Variable(tf.constant(5, dtype=tf.float32))
lr = 0.2
epoch = 40

for epoch in range(epoch):  # for epoch 定义顶层循环，表示对数据集循环epoch次，此例数据集数据仅有1个w,初始化时候constant赋值为5，循环100次迭代。
    with tf.GradientTape() as tape:  # with结构到grads框起了梯度的计算过程。
        loss = tf.square(w + 1)
    grads = tape.gradient(loss, w)  # .gradient函数告知谁对谁求导

    w.assign_sub(lr * grads)  # .assign_sub 对变量做自减 即：w -= lr*grads 即 w = w - lr*grads
    print("After %s epoch,w is %f,loss is %f" % (epoch, w.numpy(), loss))

# lr初始值：0.2   请自改学习率  0.001  0.999 看收敛过程
# 最终目的：找到 loss 最小 即 w = -1 的最优参数w

2、Tensorflow基础知识

1、tf.constant(张量内容 ,dtype = 数据类型（可选）)

import tensorflow as tf
#一维张量，两个元素
a = tf.constant([1,5],dtype = tf.int64)
print(a)
print(a.dtype)
print(a.shape)
#输出shape = (2,)一个逗号表示一维张量，两个元素

2、转换成tensor格式

inport tensorflow as tf
import numpy as np
a = np.arange(0,5)
b = tf.convert_to_tensor(a,dtype = tf.int64)
print(a)
print(b)

3、tf.nn.softmax使得输出符合概率分布
独热码tf.one_hot(待转换数据，depth=几分类):独热编码，在分类问题中，常用独热码做标签
w.assign_sub(w是自减的内容)
用tf.Variable定义变量w可为训练（可自更新）
axis=0跨行，每列
索引号就是坐标位置，起点为0.
DataFrame：将数据集变成表格，方便查看

x_data = DataFrame(x_data, columns=['花萼长度', '花萼宽度', '花瓣长度', '花瓣宽度']) # 为表格增加行索引（左侧）和列标签（上方）

4、随机生成符合正态分布的随机数张量

#生成正态分布的随机数，默认均值为0，标准差为1
tf.random.normal(维度，mean = 均值,stddev = 标准差)
#生成截断式正态分布的随机数
tf.random.truncated_normal(维度，mean = 均值，stddev = 标准差)

5、assign_sub
赋值操作，更新参数的值并返回
条用assign_sub前，先用tf.Variable定义变量w可为训练（可自更新）
w.assign_sub(w要自减的内容)

3、神经网络实现鸢尾花分类

（1）准备数据

数据集读入
数据集乱序
生成训练集和测试机
配成特征标签对，每次读入一个batch
（2）搭建网络
定义神经网络中所有可训练参数
（3）参数优化
嵌套循环迭代，with结构可更新参数，显示当前loss
（4）测试效果
计算当前参数前向传播后的准确率，显示当前acc
（5）acc/loss可视化

#鸢尾花数据集读入

从sklearn包datasets读入数据集，语法

from sklearn.datasets import datasets
x_data = datasets.load_iris().data # .data返回iris数据集所有输入特征
y_data = datasets.load_iris().target # .target返回iris数据集所有标签

利用鸢尾花数据集，实现前向传播、反向传播，可视化loss曲线

（1) 数据集读入：
NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库（函数库）

# 导入所需模块
import tensorflow as tf
from sklearn import datasets
from matplotlib import pyplot as plt
import numpy as np
#
# 导入数据，分别为输入特征和标签
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target

(2)数据集乱序：

# 随机打乱数据（因为原始数据是顺序的，顺序不打乱会影响准确率）
# seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样（为方便教学，以保每位同学结果一致）
np.random.seed(116)  # 使用相同的seed，保证输入特征和标签一一对应
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

（3）
116是随机种子值，表示同样的随机种子生成同样的随机值
#将打乱后的数据集分割为训练集和测试集，训练集为前120行，测试集为后30行，训练集测试集一般分割的比例是什么？8/2
掌握：numpy的切片

x_train = x_data[:-30]#最后30个作为测试集
y_train = y_data[:-30]
x_test = x_data[-30:]
y_test = y_data[-30:]

#转换x的数据类型，否则后面矩阵相乘时会因数据类型不一致报错
tf.cast()数据类型转换，不用总是声明变量类型

x_train = tf.cast(x_train, tf.float32)
x_test = tf.cast(x_test, tf.float32)

#from_tensor_slices函数使输入特征和标签值一一对应。（把数据集分批次，每个批次batch组数据）
(4）
配成【输入特征，标签】对，每次喂入一小撮（batch是单位，具体用法是？）

train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

(5)

定义神经网络所以训练参数

#生成神经网络的参数，4个输入特征故，输入层为4个输入节点；因为3分类，故输出层为3个神经元
#用tf.Variable()标记参数可训练
#使用seed使每次生成的随机数相同（方便教学，使大家结果都一致，在现实使用时不写seed）
#生成截断式正态分布的随机数，tf.random.truncated_normal(维度，mean = 均值，stddev = 标准差)

w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))
lr = 0.1  # 超参数，学习率为0.1
#定义两个存数据的空列表
train_loss_results = []  # 将每轮的loss记录在此列表中，为后续画loss曲线提供数据
test_acc = []  # 将每轮的acc记录在此列表中，为后续画acc曲线提供数据
epoch = 500  # 循环500轮
loss_all = 0  # 每轮分4个step，loss_all记录四个step生成的4个loss的和

训练部分

(6) 嵌套循环迭代，with 结构更新参数，显示当前 loss：
部分用两层 for 循环进行更新参数：第一层 for 循环是针对整个数据集进行循环，故用 epoch 表示；第二层 for 循环是针对 batch的，用 step 表示。
在 with 结构中计算前向传播的预测结果 y ，计算损失函数 loss，损失函数 loss分别对参数 w1和参数b1计算偏导数，更新参数 w1和参数b1的值，打印出这一轮 epoch 后的损失函数值。因为训练集有 120 组数据，batch 是 32，每个 step 只能喂入 32 组数据，需要 batch 级别循环 4 次，所以 loss 除以 4，求得
每次 step 迭代的平均 loss。

#前向传播过程计算y

    y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算
   # tf.one_hot独热编码，在分类问题中，常用独热码做标签
   y = tf.nn.softmax(y)  # 使输出y符合概率分布（此操作后与独热码同量级，可相减求loss）

y_ = tf.one_hot(y_train, depth=3) # 将标签值转换为独热码格式，方便计算loss和accuracy

计算总loss

        #损失函数用均分误差函数 loss：==`tf.reduce_mean(tf.square(y_ - y))`

grads = tape.gradient(loss, [w1, b1])：损失函数 loss分别对参数 w1和参数b1计算偏导数

for epoch in range(epoch):  #数据集级别的循环，每个epoch循环一次数据集
    for step, (x_train, y_train) in enumerate(train_db):  #batch级别的循环 ，每个step循环一个batch
        with tf.GradientTape() as tape:  # with结构记录梯度信息
            # 前向传播过程计算y
            y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算
            y = tf.nn.softmax(y)  # 使输出y符合概率分布（此操作后与独热码同量级，可相减求loss）
            y_ = tf.one_hot(y_train, depth=3)  # 将标签值转换为独热码格式，方便计算loss和accuracy
            # 计算总loss
            loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失函数mse = mean(sum(y-out)^2)
            loss_all += loss.numpy()  # 将每个step计算出的loss累加，为后续求loss平均值提供数据，这样计算的loss更准确
        # 计算loss对各个参数的梯度
        grads = tape.gradient(loss, [w1, b1])
        # 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
        w1.assign_sub(lr * grads[0])  # 参数w1自更新
        b1.assign_sub(lr * grads[1])  # 参数b1自更新
        
    # 每个epoch，打印loss信息
    print("Epoch {}, loss: {}".format(epoch, loss_all/4))
    train_loss_results.append(loss_all / 4)  # 将4个step的loss求平均记录在此变量中
    loss_all = 0  # loss_all归零，为记录下一个epoch的loss做准备

(7) 计算当前参数前向传播后的准确率，显示当前准确率 acc：

测试部分

在epoch循环中嵌套了一个（test_db），batch级别的循环
#correct = tf.reduce_sum(correct)是自加1

# total_correct为预测对的样本个数, total_number为测试的总样本数，将这两个变量都初始化为0
total_correct, total_number = 0, 0
for x_test, y_test in test_db: 
    # 使用更新后的参数进行预测
    y = tf.matmul(x_test, w1) + b1 #前向传播预测结果y
    y = tf.nn.softmax(y)#使其符合概率分布
    pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引，即pred值预测的分类#axis=1每行
  
    pred = tf.cast(pred, dtype=y_test.dtype)  # 将pred转换为y_test一样的数据类型，y_是标签
    # 若分类正确，则correct=1，否则为0，将bool型的结果转换为int型
    correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
    # 将每个batch的correct数加起来
    correct = tf.reduce_sum(correct)
    # 将所有batch中的correct数加起来
    total_correct += int(correct)
    # total_number为测试的总样本数，也就是x_test的行数，shape[0]返回变量的行数
    total_number += x_test.shape[0]
# 总的准确率等于total_correct/total_number
acc = total_correct / total_number
test_acc.append(acc)
print("Test_acc:", acc)
print("--------------------------")

绘制 loss 曲线

plt.title(‘Loss Function Curve’) # 图片标题
plt.xlabel(‘Epoch’) # x轴变量名称
plt.ylabel(‘Loss’) # y轴变量名称
plt.plot(train_loss_results, label="$Loss$") # 逐点画出trian_loss_results值并连线，连线图标是Loss
plt.legend() # 画出曲线图标
plt.show() # 画出图像

绘制 Accuracy 曲线

plt.title(‘Acc Curve’) # 图片标题
plt.xlabel(‘Epoch’) # x轴变量名称
plt.ylabel(‘Acc’) # y轴变量名称
plt.plot(test_acc, label="$Accuracy$") # 逐点画出test_acc值并连线，连线图标是Accuracy
plt.legend()
plt.show()