43期《深入浅出Pytorch》课程 - Task01:PyTorch的安装和基础知识+前置知识打卡

1、Pytorch安装

由于之前使用过Pytorch，所以说不需要再重新下载，直接开始后续的基础知识

2、基础知识

由于之前学习过numpy系列，所以说对于Pytorch的理解会轻松很多。

2.1 张量(Tensor)

①创建tensor

import torch
x = torch.rand(4, 3) 
print(x)
1
2
3

和numpy差不多，随机生成4X3的矩阵

②全0矩阵

x = torch.zeros(4, 3, dtype=torch.long)
print(x)
1
2

和numpy里面的zeros也是一样的

由于之前系统学习过numpy并且参加过一些比赛，于是不在此赘述关于张量部分的知识，和numpy的基础很像，换个包名字就行(具体关于numpy的可以参考此链接https://blog.csdn.net/weixin_42198265/category_11063560.html?spm=1001.2014.3001.5482)

2.2 自动求导

在pytorch中，所有神经网络的核心是 autograd 包
①.backward()

• torch.Tensor 是这个包的核心类。
• 如果设置它的属性 .requires_grad 为 True，那么它将会追踪对于该张量的所有操作。
  -当完成计算后可以通过调用 .backward()，来自动计算所有的梯度。
• 这个张量的所有梯度将会自动累加到.grad属性。

注意：在 y.backward() 时，如果 y 是标量，则不需要为 backward() 传入任何参数；否则，需要传入一个与 y 同形的Tensor

②Function
Tensor 和 Function 互相连接生成了一个无环图 (acyclic graph)，它编码了完整的计算历史。

• 每个张量都有一个.grad_fn属性，该属性引用了创建 Tensor 自身的Function(除非这个张量是用户手动创建的，即这个张量的grad_fn是 None )。

from __future__ import print_function
import torch
# 手动创建张量->grad_fn返回结果是None
x = torch.randn(3,3,requires_grad=True)
print(x.grad_fn)
1
2
3
4
5

③requires_grad
.requires_grad - 默认的是False，如果不打开，就是False；如果打开就会显示True；最后的计算记录可以在.grad_fn中显示。

a = torch.randn(2, 2) # 缺失情况下默认 requires_grad = False
a = ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)
1
2
3
4
5
6
7

2.3 梯度

反向传播：

• 因为 out 是一个标量，因此out.backward()和 out.backward(torch.tensor(1.)) 等价

out.backward() -> 输出导数 d(out)/dx【微积分】

grad在反向传播过程中是累加的(accumulated)，这意味着每一次运行反向传播，梯度都会累加之前的梯度，所以一般在反向传播之前需把梯度清零

# 设置tensor
x = torch.ones(2, 2, requires_grad=True)
y = x**2
z = y * y * 3
out = z.mean()

# 第一次梯度下降
out.backward()
print(x.grad)

# 不归0的梯度下降 - 梯度累加
out2 = x.sum()
out2.backward()
print(x.grad) # 进行累加

# 归0后的梯度下降 - 梯度从0开始
out3 = x.sum()
x.grad.data.zero_() # 将梯度归0
out3.backward()
print(x.grad)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

由于如果是向量，是无法直接计算其梯度的，故而有一种方法是将向量传给 backward，再使用.grad方法。

先确定向量

x = torch.randn(3, requires_grad=True) # 随机得到一个1X3的矩阵
print(x)

y = x * 2 # 将矩阵进行两倍相乘
print(y)
i = 0 # 设置梯度参数-记录次数
while y.data.norm() < 1000:
    y = y * 2
    i = i + 1
print(y)
print(i)

输出:
tensor([ 0.1789, -1.4232, -0.9889], requires_grad=True)
tensor([ 0.3577, -2.8463, -1.9778], grad_fn=<MulBackward0>)
tensor([  183.1484, -1457.3232, -1012.6375], grad_fn=<MulBackward0>)
9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

torch.autograd 不能直接计算完整的雅可比矩阵，但是如果我们只想要雅可比向量积，只需将这个向量作为参数传给 backward

v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
y.backward(v)
print(x.grad)
输入：
tensor([1.0240e+02, 1.0240e+03, 1.0240e-01])

修改梯度参数
v = torch.tensor([0.1, 8.0, 0.00001], dtype=torch.float)
y.backward(v)
print(x.grad)
输出：
tensor([1.0240e+02, 8.1920e+03, 1.0240e-02])
1
2
3
4
5
6
7
8
9
10
11
12

2.4 并行计算

之前李弘毅老师的视频中说过，深度学习再一次爆火的一部分原因是，可以用GPU进行并行运算了，大大减少训练模型时间，但是由于自己电脑配置太低，cuda不太能用，之前试过没有成功。所以说一般使用GPU都在kaggle的平台里。
一周还有30多小时，是在不行还能用算力资源，一小时也比较便宜

对于并行运算，有一个李弘毅老师视频讲过，就类似下方这种（https://blog.csdn.net/weixin_42198265/article/details/126349359）

3、前置知识打卡

对于前置知识这一块，由于之前接触过numpy和pytorch，所以说有些会的就不再记录了。
①!cat demo.py
这种就是可以直接在jupyter中运行py文件
②%timeit
计算时间-评估运行效率

def choose_sort(arr: list) -> list:
    length = len(arr)
    for i in range(length):
        min_idx = i
        for j in range(i, length):
            if arr[j] < arr[min_idx]:
                min_idx = j
        if min_idx != i:
            arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

import random
lst = [random.randint(1, 1000) for i in range(1000)]
%timeit choose_sort(lst)

输出：
32.6 ms ± 575 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

学习文档里面还写了一些对于文件的保存和读取，不过我一般都是用pd.read_csv那些，对于txt文件读取也是用的with open

以上就是task01的全部打卡，希望可以在datawhale的学习中，学的更好！