手刻 Deep Learning -第壹章-PyTorch入门教学-基础概念与再探线性回归

一、前言

本章会需要微分、线性回归与矩阵的基本观念

这次我们要来做 PyTorch 的简单教学，我们先从简单的计算与自动导数（ auto grad / 微分）开始，使用优化器与误差计算，然后使用 PyTorch 做线性回归，还有 PyTorch 于 GPU 显示卡（ CUDA ）的使用范例。

本文的重点是学会 loss function 与 optimizer 使用

文本目录：

为什么选择 PyTorch？
名词与概念介绍导数（partial derivative），优化器（optimizer），损失函数（ loss function ）
自动导数 /Auto grad （手工优化与损失函数的实作）<- 此节很无聊
优化器，损失函数，矩阵与 partial derivative 示例
线性回归与矩阵范例 —Model 概念
GPU 显卡（CUDA）运算范例

本文不讲解如何安装 PyTorch ，且假设读者已经拥有 Numpy 使用经验
如果手边没有环境，可以使用 Google Colab （ Google 已经帮各位安装好许多常用的套件）

二、选择 PyTorch的理由

Machine Learning / Deep Learning 有许多 Framework 可以使用，其中 Keras （Tensorflow）与 PyTorch 本人都有使用经验，但如果想要研究与了解 Deep Learning 如何运作，本人认为最好的方式是使用 PyTorch

一般使用 Keras （Tensorflow）虽然可以快速的建立模型，但是底层原理没有打好基础的人一定会是雾里看花

知其然，知其所以然

PyTorch 使用上很接近 Numpy，另外有强大的数学计算功能，例如：自动微分，自动优化，方便配置到显卡上运算（Nvidia CUDA，而且就本人使用经验来说，安装比 TensorFlow 容易）... 如果知道 PyTorch 这些功能，可以使用在各种数学应用，而且对于 Machine Learning / Deep Learning 底层运作也会更加了如指掌

三、名词与概念介绍导数（partial derivative），优化器（optimizer），损失函数（ loss function ）

其实我们之前的章节，就是在为这些铺路

3.1 损失函数（ loss function ）

这个名词中文看来奇怪，其实他是计算数值差距用的，计算与答案的误差，帮助我们找目标的公式，例如：
我们有 18 元去买 3块钱的苹果，我们只买了 5颗，我们是不是还可以买更多？（ 18–3*5=3，我们剩下 3元，误差就是 3 ）
在线性回归中就是计算和答案的差距，主要用来取得导数

3.2 导数（ partial derivative）

就是微分概念，透过损失函数还可以找出我们要移动的方向和距离

3.3 优化器（ optimizer ）

开始修正我们的数值使用，也有人称优化器，就是依靠导数去调整数值

导数部分其实不用特别关心，他实务上隐藏在 loss function 与 optimizer 之间，但是这三者的组合就是 Machine Learning 中常用的概念
流程就是

误差计算 -> 寻找导数 -> 优化 ->误差计算 -> 寻找导数 -> 优化 ->误差计算 -> 寻找导数 -> 优化 ->误差计算 -> 寻找导数 -> 优化 ->...

四、自动导数 / Auto grad （手工优化与损失函数的实现）

先说此节很无聊，是介绍损失函数与优化器如何运作，但是可以跳到下节没关系

本节承接线性回归概念，一样依照 loss function 与 optimizer 架构

微分在 Machine Learning 中是非常重要的计算，而这种计算已经有公式可循，所以 PyTorch 会自动的帮我们计算（也就是我们之前章节说过，不会算没关系，电脑可以帮我们算），但是概念与原理要懂

这边的 grad 其实就是微积分中的 partial derivative （导数 / 斜率），PyTorch 会帮我们追踪每个变量的导数/斜率，即自动追踪变量的任何变化

现在我们来看最基础的 PyTorch 与 Auto grad 范例：
假设今天在商场买苹果结账，假设苹果 3 元，我们手上有 18 元，纸袋不用钱（这边为了方便范例先忽略），我们要去尽可能的买越多苹果越好
公式如下：

结账总额（Y） = 苹果数量（a） * 苹果单价（X） + 纸袋单价（b）
换成数学公式是 Y = aX + b

Y 是我们手上有的钱，这个我们不能改变
X 是苹果单价，这个我们不能改变
a 是苹果数量，这是我们要找出来的
b 这边因为纸袋0元，所以我们直接省略不看

x = torch.tensor([3.0])  # 蘋果單價
y = torch.tensor([18.0]) # 我們的預算
a = torch.tensor([1.0], requires_grad=True)  # 追蹤導數
print('grad:', a.grad)
loss = y - (a * x)  # loss function ( 中文稱 損失函數 )
loss.backward()
print('grad:', a.grad)

解说：

torch.tensor：就是建立一个 Tensor （类似于 np.array ）
requires_grad=True 我们有需要追踪的变量才要加上这个参数，不用追踪的不用，例如这个范例中我们只希望 a 改变，不要去动其他数值，所以只有 a 有 requires_grad=True

4.1 损失函数（ loss function）

实务上是让他越接近 0 越好，我们后面会套用 PyTorch 内建的 function ，就不用每次的手工打造

上面代码中，loss就是差价公式，概念就是Y= ax + b，但是我们的目标是要把钱花光光，所以loss要越趋近于0越好
所以数学上就成了Y-（ax + b） = 0是我们的目标
loss.backward（）就是和 PyTorch 说开始反向追踪

这是 print 出来的结果

# grad: None
# grad: tensor([-3.])

可以看到我们 print（'grad：'， a.grad），在 loss.backward 之前是没有数值的
但是之后冒出一个 -3，这个 -3 就是 partial derivative （会微积分的人可以算看看），然后我们可以靠这个数值去调整 a 的值，如下

4.2 优化器

PyTorch 有内建好的优化器，但是我们这边为了演示原理，一样手工计算（下节我们会使用内建的）
下面代码是我们开始进行线性回归优化（计算 100 次）

for _ in range(100):
    a.grad.zero_()
    loss = y - (a * x)
    loss.backward()
    with torch.no_grad():
        a -= a.grad * 0.01 * loss

解说：

每一次的 backward ，a 的 grad 都会相加，所以我们要先做归零
（就像是实验室仪器每次都要先归零校正）
loss 与 loss.backward 上面已经解说过，用来反向追踪导数
with torch.no_grad（）：这部分概念很重要，前面提过 PyTorch 会自动追踪 a 的任何计算，所以我们手动调整 a 一定要和 PyTorch 说，不要追踪我们的手动调整

我們看看跑 100 次迴歸的結果

損失函跑 100 次的變化

print('a:', a)
print('loss:', (y - (a * x)))
print('result:', (a * x))
# a: 5.999598503112793
# loss: 0.0012054443359375
# result: 17.998794555664062

可以看到 a 趋近于 6，误差（loss ）趋近于 0
表示我们真的可以用 18 块钱去买 6 颗苹果 3元的苹果

五、优化器，损失函数，矩阵与 partial derivative 示例

这边我们要用 PyTorch 内建的 loss function 与 optimizer 来做计算，会方便很多，而且可以做更多复杂的问题

本文的重点是学会 loss function 与 optimizer 使用

直接看代码（一样是苹果 3元范例）

x = torch.tensor([3.0])
y = torch.tensor([18.0])
a = torch.tensor([1.0], requires_grad=True)
loss_func = torch.nn.MSELoss()
optimizer = torch.optim.SGD([a], lr=0.01)
for _ in range(100):
    optimizer.zero_grad()
    loss = loss_func(y, a * x)
    loss.backward()
    optimizer.step()

解说：

loss_func 就是损失函数，我们这边使用 torch.nn.MSELoss
他其实是计算均方误差，loss function 有很多种，我们日后有机会再介绍，但是这边要知道很多情况下的数值比较其实用 MSELoss 就很好用了
细节：https://pytorch.org/docs/stable/nn.html#loss-functions
optimizer 就是优化器
torch.optim.SGD（[a]， lr=0.01）这边是我们使用 SGD ，一样优化器有很多种，我们这边为了简单示范先用 SGD
-> [a] 是我们和优化器说照顾好我们的 a 变量
-> lr 是学习率，数值都是小于 1，实际看场合调整，我们这边 0.01 是为了快速示范
细节： torch.optim — PyTorch 2.0 documentation
optimizer.zero_grad 是为了归零调整，因为每次 backward 都会增加 grad 的数值（就像是实验室每次做实验都要归零调整，不然上个用户的操作会干扰实验结果）
loss.backward（）做反向传导，就是找出导数
optimizer.step 告诉优化器做优化，他会自动帮我们调整 a 的数值

        我们测试一下矩阵概念的计算
        假设一样是 18 元的预算，三个种不同的苹果
        售价分别是 3 元， 5 元， 6 元，这样可以买几颗？

我们只要修改一下数值

x = torch.tensor([3.0, 5.0, 6.0,])   # 不同種蘋果售價
y = torch.tensor([18.0, 18.0, 18.0]) # 我們的預算
a = torch.tensor([1.0, 1.0, 1.0], requires_grad=True) # 先假設都只能買一顆

然后我们跑计算（这里跑 1000 次，让数值精准些）

loss_func = torch.nn.MSELoss()
optimizer = torch.optim.SGD([a], lr=0.01)
for _ in range(1000):
    optimizer.zero_grad()
    loss = loss_func(y, a * x)
    loss.backward()
    optimizer.step()
print('a:', a)
# a: tensor([6.0000, 3.6000, 3.0000], requires_grad=True)

看起来没错，如果只有 18 元，分别去买不同的苹果，我们只能买 6 颗（ 3元）， 3 颗（5元）， 3 颗（6元）

六、线性回归与矩阵范例 —Model 概念

有了上面的概念，现在我们来做更进阶的范例

data -> model -> output

我们将输入数据到输出数据这个过程称为 “Model” ，概念上就是可以当作是一个黑箱，我们把数据丢进去（一般称为 X ），就会产生出预测数据（称为 Y ），例如：

影像分类：照片丢入 model ，然后 model 告诉我们影像的类别
资料预测：过去几天的气象资料（温度、湿度、气压.. . ）丢入 model ，然后得到几天后的预测
语音识别：用户说话的音频丢入 model ，得到文字输出

6.1 准备资料

因为本文是在示范线性回归，我们先不探讨复杂问题，先做最简单的计算，所以这次我们使用 sklearn 来产生假资料练习
（打好基础比较重要）

from sklearn.datasets import make_regression
np_x, np_y = make_regression(n_samples=500, n_features=10)
x = torch.from_numpy(np_x).float()
y = torch.from_numpy(np_y).float()

np_x 是产生出来的测试线性回归数据，有 10 个不同的属性，500 笔数据（可以使用 np_x.shape 看到）
np_y 是产生出来的答案

因为， make_regression 产生出来的是 numpy，他不是 PyTorch 的 Tensor，所以我们要转换一下（ torch.from_numpy（... ）. float() )

6.2 建立我们的 Model

w = torch.randn(10, requires_grad=True)
b = torch.randn(1, requires_grad=True)
optimizer = torch.optim.SGD([w, b], lr=0.01)
def model(x):
    return x @ w + b

解说：

w：就是乱数产生的“权重”，我们会用矩阵计算将 x 的每个特征相乘，记得我们上面产生的数据有 10 个特征吗？所以他是 torch.randn（10），而 requires_grad=True 就是和 PyTorch 说我们要优化这个数值
b：源自于 y=aX + b 公式，这次我们把 b 放进来了
torch.optim.SGD（[w， b]， lr=0.01）就是优化器，和他说明我们要追踪 w 和 b

再来 model function 就是我们这次的主角，基本精神就是 y=aX + b （这边的 a 我们已经改用 w 替代）

6.3 先预测

我们还没有训练我们的 model ，先看直接丢入数据（x）会生出什么

predict_y = model(x)

然后我们可视化一下

plt.figure(figsize=(20, 10))
plt.subplot(1, 2, 1)
plt.plot(y)
plt.plot(predict_y.detach().numpy())
plt.subplot(1, 2, 2)
plt.scatter(y.detach().numpy(), predict_y.detach().numpy())

说明一下，左图是数据范围，理想上两个颜色的线应该会看起来一致; 右图是数据预测与目标数据的分布图，理想上应该要是一条直线（左右到右上），看我们之后训练过的 model 就可以知道差异

6.4 开始训练

直接看程序

loss_func = torch.nn.MSELoss() # 之前提過的 loss function 
history = []   # 紀錄 loss（誤差/損失）的變化
for _ in range(300):   # 訓練 300 次
    predict_y = model(x)
    loss = loss_func(predict_y, y)
    # 優化與 backward 動作，之前介紹過
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    history.append(loss.item())
plt.plot(history)

可以看到 loss 随时间降低，这表示我们的 model 确实有学到东西，再来看看预测结果

predict_y = model(x)
plt.figure(figsize=(20, 10))
plt.subplot(1, 2, 1)
plt.plot(y, label='target')
plt.plot(predict_y.detach().numpy(), label='predict')
plt.legend()
plt.subplot(1, 2, 2)
plt.scatter(y.detach().numpy(), predict_y.detach().numpy())

如上所言，我们输入 x 到 model ，可以得到很好的 y （预测与答案几乎相似）

七、GPU 显卡（CUDA）运算范例

之前的其他文章提过，显示卡对于矩阵计算非常在行
而 PyTorch 对于使用显卡计算很容易，如果读者是 Nvidia 显卡用户，安装 CUDA 相关套件即可（这部分就不在本文教学范围了），而 AMD 用户，听说有 AMD ROCm 可以使用，不过本人没有使用过也不清楚（本人手上都是老黄牌的显卡）

我们要在 PyTorch 使用 cuda ，先检测一下环境支不支持

torch.cuda.is_available()

看到结果是true，表示应该（可能？或许？大概？）没有问题（因为实际上可能会有 CUDA 版本 / 驱动各种奇怪状况）

再来就是我们把 device 抓出来

device = torch.device('cuda')    # cuda 即 nvidia gpu 計算
#  device = torch.device('cpu')  # 如果想回到 cpu 計算

再来，为了我们要示范GPU和CPU的差异，我们需要更多数据

from sklearn.datasets import make_regression
np_x, np_y = make_regression(n_samples=5000, n_features=5000)
x = torch.from_numpy(np_x).float().to(device)
y = torch.from_numpy(np_y).float().to(device)

为了要让矩阵更大，所以我们这次增加到5000个特征
然后注意上面的to（device）这就是把 PyTorch 的 Tensor 搬移到设备上面（我们已经指定成 cuda ），所以这些资料已经被移动到 GPU 上

只有位在相同的设备的 Tensor 才能互相计算，例如 gpu 只能算 gpu，cpu 只能算 cpu，所以计算之前要 .to（device）到相同设备

现在我们建立 model （这个 model 我们要移动到 GPU 上）

w = torch.randn(5000).to(device)
b = torch.randn(1).to(device)
w.requires_grad=True
b.requires_grad=True
optimizer = torch.optim.SGD([w, b], lr=0.01)
def model(x):
    x = x @ w + b
    return x

一样的 to（device），然后 requires_grad 是因为移动到 GPU 上已经不同于 CPU，所以我们要另外设置要求追踪导数（优化器这些就一样的代码）

再来跑训练

loss_func = torch.nn.MSELoss()
history = []
ts = time.time()
for _ in range(1000):   # 訓練 1000 次
    predict_y = model(x)
    loss = loss_func(predict_y, y)
    # 優化與 backward 動作
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    history.append(loss.item())
print(f'run_time: {time.time()-ts:.5f}')
plt.plot(history)

我們另外加了 time.time 來看執行時間

以下是本人的一些紀錄

AMD 3900X (CPU): 2.8 sec
Nvidia 3090(GPU) : 0.327 sec
Jetson Nano 4GB (CPU): 52.7 sec
Jetson Nano 4GB (GPU):16.47 sec

如果是影像處理(CNN)或是隨 model 複雜度增加，時間差距會更大，另外也看到 GPU 的 RAM 被佔用

这也是为什么 Deep Learning 会需要大内存显卡的原因，当你越多的数据搬移到 GPU 就会需要更多空间

八、结语

本文的重点是学会 loss function 与 optimizer 使用

其实掌握正确的 loss function 与 optimizer，在 model 的设计上就会顺利很多，这个我们日后有机会介绍会看到，另外本文其实很多观念与细节碍于篇幅与时间没有很详细的交代

如果有兴趣的读者可以自行输入代码与试验不同的数值，去发现其中的细节变化，熟悉这些操作与概念对于 Machine Learning / Deep Learning 会很有帮助Seachaos文章来源地址https://uudwc.com/A/XkZg4

手刻 Deep Learning -第壹章-PyTorch入门教学-基础概念与再探线性回归

一、前言

二、选择 PyTorch的理由

三、名词与概念介绍 导数（partial derivative）， 优化器（optimizer）， 损失函数 （ loss function ）

3.1 损失函数 （ loss function ）

3.2 导数（ partial derivative）

3.3 优化器 （ optimizer ）

四、自动导数 / Auto grad （ 手工优化与损失函数的实现）

4.1 损失函数（ loss function）

4.2 优化器

五、优化器， 损失函数， 矩阵与 partial derivative 示例

六、线性回归与矩阵范例 —Model 概念

6.1 准备资料

6.2 建立我们的 Model

6.3 先预测

6.4 开始训练

七、GPU 显卡 （CUDA） 运算范例

八、结语

三、名词与概念介绍导数（partial derivative），优化器（optimizer），损失函数（ loss function ）

3.1 损失函数（ loss function ）

3.3 优化器（ optimizer ）

四、自动导数 / Auto grad （手工优化与损失函数的实现）

五、优化器，损失函数，矩阵与 partial derivative 示例

七、GPU 显卡（CUDA）运算范例