Pytorch-学习记录-1-Tensor

1. 张量 (Tensor):

数学中指的是多维数组；

torch.Tensor

data: 被封装的 Tensor
dtype: 张量的数据类型
shape: 张量的形状
device: 张量所在的设备，GPU/CPU
requires_grad: 指示是否需要计算梯度
grad: data 的梯度
grad_fn: 创建 Tensor 的 Function，是自动求导的关键
is_leaf: 指示是否是叶子结点 (叶子结点指的是用户创建的节点，比如 y=(x+w)*(w+1)中，x和w就是叶子结点【可以用计算图来清楚地表示该过程】)

2. 创建张量:

2.1 直接创建:

2.1.1 从 data 创建 tensor

data: 可以是 list, numpy
dtype: 数据类型，默认与data一致
device: 所在设备
requires_grad: 是否需要梯度
pin_memory: 是否存于锁页内存

# 创建方法
torch.tensor(data,dtype=None,device=None,requires_grad=False,pin_memory=False
)

2.1.2 从 numpy 创建 tensor

用torch.from_numpy()创建的tensor与原始的ndarray共享内存，修改其中一个，另一个也会变。

# 创建方法
torch.from_numpy(ndarray)

# 举例
import torch
import numpy as np# 直接创建
## torch.tensor()
arr = np.ones((3,3))
t = torch.tensor(arr, dtype=torch.float32, device="mps") # 把张量放到 GPU 上 (mac M1)print(t.dtype)
print(t)## torch.from_numpy()
arr = np.array([[1,2,3],[4,5,6]])
t = torch.from_numpy(arr)
print(t.dtype)
print(t)

torch.float32
tensor([[1., 1., 1.],[1., 1., 1.],[1., 1., 1.]], device='mps:0')
torch.int64
tensor([[1, 2, 3],[4, 5, 6]])

2.2 根据数值进行创建:

2.2.1 torch.zeros()

创建全0张量

size: 张量的形状
out: 输出的张量 (暂时可以不考虑)
layout:内存中布局形式，有 strided (通常情况下使用), sparse_coo (读取稀疏矩阵会用到)
device: 所在设备
requires_grad: 是否需要梯度

# 创建方法
torch.zeros(*size,out=None,dtype=None,layout=torch.strided,device=False,requires_grad=False
)

2.2.2 torch.zeros_lisk()

根据 input 形状创建全0张量

input: 创建与 input 同形状的张量；
dtype: 数据类型；
layout: 内存中的布局形式；

# 创建方法
torch.zeros_like(input,dtype=None,layout=None,device=None,requires_grad=False
)

2.2.3 torch.ones() 和 torch.ones_like()

创建全1张量

2.2.4 torch.full()和torch.full_like()

创建自定义数值的张量

size: 张量形状
fill_value: 张量的值

2.2.5 torch.arange()

根据数列创建等差1维张量，[start, end)

start: 起始值
end: 结束值
step: 数列公差，默认为1

2.2.6torch.linspace()

创建均分的1维张量，[start, end]

start: 起始值
end: 结束值
step: 数列长度

2.2.7torch.logspace()

创建对数均分的1D张量

start: 起始值
end: 结束值
steps: 数列长度
base: 对数函数的底，默认为10

# 创建方法
torch.logspace(start,end,steps=100,base=10.0,out=None,dtype=None,layout=torch.strided,deivce=None,requires_grad=False
)

2.2.8 torch.eye()

创建单位对角矩阵 (2D张量)

n: 矩阵行数
m: 矩阵列数

# 创建方法
torch.eye(n,m=None,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False
)

# 举例
t = torch.zeros((3,3))
print(t.dtype)
print(t)t = torch.full((3,3),2) # 创建3x3的全2张量
print(t)t = torch.arange(2, 8, 2)
print(t)t = torch.linspace(2, 10, 5)
print(t)

torch.float32
tensor([[0., 0., 0.],[0., 0., 0.],[0., 0., 0.]])
tensor([[2, 2, 2],[2, 2, 2],[2, 2, 2]])
tensor([2, 4, 6])
tensor([ 2.,  4.,  6.,  8., 10.])

2.3 根据概率分布创建张量:

2.3.1 torch.normal()

生成正态分布（高斯分布）

四种模式：


mean	标量	std	标量
mean	标量	std	张量
mean	张量	std	标量
mean	张量	std	张量

# 张量
torch.normal(mean,std,out=None
)# 标量
torch.normal(mean,std,size,out=None
)

2.3.2 torch.randn(), torch.randn_like()

生成标准正态分布

torch.randn(*size, ## 张量形状out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False
)

2.3.3 torch.rand(), torch.rand_like()

在[0,1)区间上生成均匀分布

torch.rand(*size, ## 张量形状out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False
)

2.3.4 torch.randint(), torch.randint_like()

在 [low, high) 区间上生成整数均匀分布

torch.randint(low,high,size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False
)

2.3.5 torch.randperm()

生成0到n-1的随机排列

n: 张量长度

torch.randperm(n,out=None,dtype=torch.int64,layout=torch.strided,device=None,requires_grad=False
)

2.3.6torch.bernoulli()

以 input 为概率，生成伯努利分布(0-1分布，两点分布)

torch.bernoulli(input,*,generator=None,out=None
)

3. 张量的操作：

张量的操作：拼接、切分、索引和变换：

1. 拼接：

1.1 torch.cat()

将张量按维度 dim 进行拼接 (不回扩张张量维度)

torch.cat(tensors, ## 张量序列dim, ## 要拼接的维度out=None
)

1.2 torch.stack()

在新创建的维度 dim 上进行拼接 (会扩张张量的维度)

torch.stack(tensors, ## 张量序列dim=0, ## 要拼接的维度out=None
)

import torcht = torch.ones((2,3))# torch.cat()
t1 = torch.cat([t,t], dim=0) ## 按照 dim=0 对t进行拼接，得到(4,3)# torch.stack()
t2 = torch.stack([t,t], dim=0) ## 按照 dim=0 对t进行拼接，得到(2,2,3)，会在dim=0创建一个新维度print("t1 shape: ", t1.shape)
print("t2 shape: ", t2.shape)

t1 shape:  torch.Size([4, 3])
t2 shape:  torch.Size([2, 2, 3])

2. 切分

2.1 torch.chunk()

将张量按照维度 dim 进行平均切分，返回张量列表 (如果不能整除，最后一份张量小于其他张量)

torch.chunk(input, ## 要切分的张量chunks, ## 要切分的份数dim=0 ## 要切分的维度
)

2.2 torch.split()

将张量按照维度 dim 进行切分，返回张量列表

torch.split(tensor, ## 要切分的张量split_size_of_sections, ## 为 int 时，表示每一份的长度；为 list 时，按 list 元素切分dim=0 ## 要切分的维度
)

t1 = torch.ones((2,5))# torch.chunk()
list_of_tensors = torch.chunk(t1, dim=1, chunks=2) ## 5不能被2整除，所以最后一个张量形状小雨前面的张量
for idx, t in enumerate(list_of_tensors):print("order {}, shape is {}".format(idx+1, t.shape))# torch.split()
list_of_tensors = torch.split(t1, [2,1,2], dim=1)
for idx, t in enumerate(list_of_tensors):print("order {}, shape is {}".format(idx+1, t.shape))

order 1, shape is torch.Size([2, 3])
order 2, shape is torch.Size([2, 2])
order 1, shape is torch.Size([2, 2])
order 2, shape is torch.Size([2, 1])
order 3, shape is torch.Size([2, 2])

3. 索引

3.1 torch.index_select()

在维度 dim 上，按照 index 索引数据，返回依index索引数据拼接的张量 (先索引，再拼接)

torch.index_select(input, ## 要索引的张量dim, ## 要索引的维度index, ## 要索引数据的序号，数据类型必须是 torch.longout=None
)

3.2 torch.masked_select()

按照 mask 中的 True 进行索引，返回一维张量

torch.masked_select(input,mask, ## 与 input 同形状的布尔类型张量out=None
)

# torch_index_select()
t = torch.randint(0,9,size=(3,3))
idx = torch.tensor([0,2],dtype=torch.long)
t_select = torch.index_select(t, dim=1, index=idx)
print(t)
print(t_select)# torch.masked_select()
mask = t.ge(5) ## 表示张量中 >= 5的元素；ge()表示大于等于；gt()表示大于；le()表示小于等于；lt()表示小于
t_select = torch.masked_select(t, mask=mask)
print(t)
print(mask)
print(t_select)

tensor([[3, 8, 1],[6, 0, 0],[7, 6, 8]])
tensor([[3, 1],[6, 0],[7, 8]])
tensor([[3, 8, 1],[6, 0, 0],[7, 6, 8]])
tensor([[False,  True, False],[ True, False, False],[ True,  True,  True]])
tensor([8, 6, 7, 6, 8])

4. 变换

4.1 torch.reshape()

变换张量形状 (张量在内存中是连续时，新张量与input共享数据内存)

torch.reshape(input,shape ## 新张量的形状
)

4.2 torch.transpose()

交换张量的两个维度

torch.transpose(input,dim0,dim1
)

4.3 torch.t()

2维张量转置

torch.t(input)

4.4 torch.squeeze()

压缩长度为1的维度

torch.squeeze(input,dim=None, ## 若 dim=None，则移除所有长度为1的轴；若指定维度而且维度长度为1，则可以移除该维度out=None
)

4.5 torch.unsqueeze()

根据 dim 扩展维度

torch.unsqueeze(input,dim,out=None
)

## torch.reshapet = torch.randperm(8)
t_reshape = torch.reshape(t, (2,4)) ## 如果是 (-1,2,2)，那么-1表示的是：不需要关心-1处的维度是多少，根据后两个维度进行计算得到(比如：这里就是 8/2/2 = 2，即-1处的维度是2)print(t.shape)
print(t_reshape.shape)## torch.transpose()
t = torch.rand((2,3,4))
t_transpose = torch.transpose(t, dim0=1, dim1=2) ## 把第1维和第2维进行交换
print(t.shape)
print(t_transpose.shape)## torch.squeeze()
t = torch.rand((1,2,3,1))
t_squeeze = torch.squeeze(t)
t_squeeze_0 = torch.squeeze(t,dim=0)
t_squeeze_1 = torch.squeeze(t,dim=1)
print(t_squeeze.shape)
print(t_squeeze_0.shape)
print(t_squeeze_1.shape)## torch.unsqueeze()
t = torch.rand((2,3))
t_unsqueeze = torch.unsqueeze(t, dim=2)
print(t_unsqueeze.shape)

torch.Size([8])
torch.Size([2, 4])
torch.Size([2, 3, 4])
torch.Size([2, 4, 3])
torch.Size([2, 3])
torch.Size([2, 3, 1])
torch.Size([1, 2, 3, 1])
torch.Size([2, 3, 1])

3.2 张量的数学运算：

加减乘除

torch.add()
torch.addcdiv()
torch.addcmul()
torch.sub()
torch.div()
torch.mul()

重点: torch.add()和torch.addcmul()

torch.add(): 逐元素计算 input + alpha x other

torch.add(input, ## 第一个张量alpha=1, ## 乘项因子 (alpha x other + input)other, ## 第二个张量out=None
)

torch.addcmul()

out = input + value x tensor1 x tensor2

torch.addcmul(input,value=1.tensor1,tensor2,out=None
)

对数、指数、幂函数

torch.log(input, out=None)
torch.log10(input, out=None)
torch.log2(input, out=None)
torch.exp(input, out=None)
torch.pow()

三角函数

torch.abs(input, out=None)
torch.acos(input, out=None)
torch.cosh(input, out=None)
torch.cos(input, out=None)
torch.asin(input, out=None)
torch.atan(input, out=None)
torch.atan2(input, other=None, out=None)

4. 计算图与动态图

1. 计算图

计算图是用来描述运算的有向无环图，包括两个主要元素：节点和边。节点表示数据（比如向量、矩阵、张量）；边表示运算（比如加减乘除卷积等）。

叶子结点：指的是由用户创建的节点，其他非叶子结点都是由叶子结点通过直接或间接的运算得到的。（之所以会有叶子结点的概念，是因为梯度反向传播结束后，只有叶子结点的梯度会被保留，非叶子结点的梯度会被从内存中释放掉。可以通过.is_leaf()方法查看是否为叶子结点）。

如果想要使用非叶子结点的梯度，实现方法是在计算梯度之后，用.retain_grad()方法保存非叶子结点的梯度。

grad_fn: 记录创建该张量(非叶子结点)时所用的方法，比如 y=a*b，那么 y.grad_fn = <MulBackward0>

2. 动态图

计算图可以根据搭建方式的不同，分为：动态图 (运算与搭建同时进行，灵活，易调节，比如 pytorch) 和静态图 (先搭建，后运算，高效，不灵活，比如 tensorflow)。

5. 自动求导系统 `autograd`

1. `torch.autograd.backward`

自动计算图中各个结点的梯度

torch.autograd.backward(tensors, ## 用于求导的张量（比如 loss）grad_tensors=None, ## 多梯度权重retain_grap=None, ## 保存计算图create_graph=False ## 创建导数的计算图，同于高阶求导
)

2. `torch.autograd.grad`

求取梯度

torch.autograd.grad(outputs, ## 用于求导的张量 (比如 loss)inputs, ## 需要梯度的张量grad_outputs=None, ## 多梯度权重 retain_graph=None, ## 保存计算图create_graph=False ## 创建导数计算图，用于高阶求导
)

3. Pytorch 自动求导系统中有3个需要注意的点：

梯度不自动清零 (手动清零 .grad.zero_())；

依赖于叶子结点结点，requires_grad 默认为 True；

叶子结点不可执行 in-place，即叶子结点不能执行原位操作；

4. 机器学习模型的5个训练步骤：

数据, 模型, 损失函数, 优化器, 迭代训练

6. DataLoader 与 Dataset

数据数据收集数据划分数据读取DataLoaderSampler: 生成索引Dataset: 根据索引读取样本特征以及标签数据预处理

1. `torch.utils.data.DataLoader`

DataLoader(dataset, ## Dataset类，决定数据从哪里读取以及如何读取batch_size=1, ## 批量大小shuffle=False, ## 每个 epoch 是否打乱顺序sampler=None,batch_sampler=None,num_workers=0, ## 是否多进程读取数据collate_fn=None,pin_memory=False,drop_last=False, ## 当样本数不能被 batchsize 整除时，是否舍弃最后一批数据timeout=0,worker_init_fn=None,multiprocessing_context=None
)

2. `torch.utils.data.Dataset`

Dataset抽象类，所有自定义的Dataset都需要继承它，并且需要复写 __getitem__()方法；getitem：接收一个索引，返回一个样本。

class Dataset(object):def __getitem__(self, index):raise NotImplementedErrordef __add__(self, other):return ConcatDataset([self, other])

Example: 猫狗图片分类 (“./example_week1_Cat_Dog_classification/”)

1. 参考代码：https://github.com/JansonYuan/Pytorch-Camp/

2. 猫狗数据集下载：https://www.kaggle.com/datasets/samuelcortinhas/cats-and-dogs-image-classification，但是将其中Test随机分成相等的两份，一份作为验证集，一份作为测试集（尽管测试集没有用到）。

3. 代码在 “./example_week1_Cat_Dog_classification/” 目录下。

4. 结果讨论：

4.1 作者原来的代码的结果：

在这里插入图片描述

Training:Epoch[000/010] Iteration[010/010] Loss: 0.6204 Acc:60.62%
Valid:	 Epoch[000/010] Iteration[002/002] Loss: 0.4436 Acc:90.00%
Training:Epoch[001/010] Iteration[010/010] Loss: 0.3601 Acc:90.62%
Valid:	 Epoch[001/010] Iteration[002/002] Loss: 0.0461 Acc:100.00%
Training:Epoch[002/010] Iteration[010/010] Loss: 0.0788 Acc:98.12%
Valid:	 Epoch[002/010] Iteration[002/002] Loss: 0.0234 Acc:100.00%
Training:Epoch[003/010] Iteration[010/010] Loss: 0.0208 Acc:99.38%
Valid:	 Epoch[003/010] Iteration[002/002] Loss: 0.0022 Acc:100.00%
Training:Epoch[004/010] Iteration[010/010] Loss: 0.0042 Acc:100.00%
Valid:	 Epoch[004/010] Iteration[002/002] Loss: 0.0018 Acc:100.00%
Training:Epoch[005/010] Iteration[010/010] Loss: 0.0143 Acc:99.38%
Valid:	 Epoch[005/010] Iteration[002/002] Loss: 0.0002 Acc:100.00%
Training:Epoch[006/010] Iteration[010/010] Loss: 0.0220 Acc:98.75%
Valid:	 Epoch[006/010] Iteration[002/002] Loss: 0.0004 Acc:100.00%
Training:Epoch[007/010] Iteration[010/010] Loss: 0.0008 Acc:100.00%
Valid:	 Epoch[007/010] Iteration[002/002] Loss: 0.0013 Acc:100.00%
Training:Epoch[008/010] Iteration[010/010] Loss: 0.0083 Acc:99.38%
Valid:	 Epoch[008/010] Iteration[002/002] Loss: 0.0001 Acc:100.00%
Training:Epoch[009/010] Iteration[010/010] Loss: 0.0049 Acc:100.00%
Valid:	 Epoch[009/010] Iteration[002/002] Loss: 0.0000 Acc:100.00%

4.2 用 “./example_week1_Cat_Dog_classification/train_lenet.py” 代码处理 Pytorch-Camp 的结果和上面的是一致的（代码修改后，与 Pytorch-Camp 提供的代码可以对 RMB 实现同样的分类效果），如下所示：

在这里插入图片描述

Train:   Epoch[000/010] Iteration[010/010] Loss: 0.6204 Acc: 60.62%
Valid:   Epoch[000/010] Iteration[002/002] Loss: 0.4436 Acc: 90.00%
Train:   Epoch[001/010] Iteration[010/010] Loss: 0.3601 Acc: 90.62%
Valid:   Epoch[001/010] Iteration[002/002] Loss: 0.0461 Acc: 100.00%
Train:   Epoch[002/010] Iteration[010/010] Loss: 0.0788 Acc: 98.12%
Valid:   Epoch[002/010] Iteration[002/002] Loss: 0.0234 Acc: 100.00%
Train:   Epoch[003/010] Iteration[010/010] Loss: 0.0208 Acc: 99.38%
Valid:   Epoch[003/010] Iteration[002/002] Loss: 0.0022 Acc: 100.00%
Train:   Epoch[004/010] Iteration[010/010] Loss: 0.0042 Acc: 100.00%
Valid:   Epoch[004/010] Iteration[002/002] Loss: 0.0018 Acc: 100.00%
Train:   Epoch[005/010] Iteration[010/010] Loss: 0.0143 Acc: 99.38%
Valid:   Epoch[005/010] Iteration[002/002] Loss: 0.0002 Acc: 100.00%
Train:   Epoch[006/010] Iteration[010/010] Loss: 0.0220 Acc: 98.75%
Valid:   Epoch[006/010] Iteration[002/002] Loss: 0.0004 Acc: 100.00%
Train:   Epoch[007/010] Iteration[010/010] Loss: 0.0008 Acc: 100.00%
Valid:   Epoch[007/010] Iteration[002/002] Loss: 0.0013 Acc: 100.00%
Train:   Epoch[008/010] Iteration[010/010] Loss: 0.0083 Acc: 99.38%
Valid:   Epoch[008/010] Iteration[002/002] Loss: 0.0001 Acc: 100.00%
Train:   Epoch[009/010] Iteration[010/010] Loss: 0.0049 Acc: 100.00%
Valid:   Epoch[009/010] Iteration[002/002] Loss: 0.0000 Acc: 100.00%

4.3 将数据换成猫狗数据集之后，结果如下：

在这里插入图片描述

Train:   Epoch[000/010] Iteration[035/035] Loss: 0.7151 Acc: 53.50%
Valid:   Epoch[000/010] Iteration[005/005] Loss: 0.6898 Acc: 51.43%
Train:   Epoch[001/010] Iteration[035/035] Loss: 0.6954 Acc: 50.09%
Valid:   Epoch[001/010] Iteration[005/005] Loss: 0.7321 Acc: 41.43%
Train:   Epoch[002/010] Iteration[035/035] Loss: 0.6885 Acc: 53.86%
Valid:   Epoch[002/010] Iteration[005/005] Loss: 0.6954 Acc: 52.86%
Train:   Epoch[003/010] Iteration[035/035] Loss: 0.6813 Acc: 58.53%
Valid:   Epoch[003/010] Iteration[005/005] Loss: 0.6909 Acc: 55.71%
Train:   Epoch[004/010] Iteration[035/035] Loss: 0.6832 Acc: 57.99%
Valid:   Epoch[004/010] Iteration[005/005] Loss: 0.6749 Acc: 52.86%
Train:   Epoch[005/010] Iteration[035/035] Loss: 0.6838 Acc: 58.35%
Valid:   Epoch[005/010] Iteration[005/005] Loss: 0.6865 Acc: 50.00%
Train:   Epoch[006/010] Iteration[035/035] Loss: 0.6729 Acc: 58.89%
Valid:   Epoch[006/010] Iteration[005/005] Loss: 0.7097 Acc: 57.14%
Train:   Epoch[007/010] Iteration[035/035] Loss: 0.6700 Acc: 61.58%
Valid:   Epoch[007/010] Iteration[005/005] Loss: 0.7361 Acc: 47.14%
Train:   Epoch[008/010] Iteration[035/035] Loss: 0.6721 Acc: 59.07%
Valid:   Epoch[008/010] Iteration[005/005] Loss: 0.7180 Acc: 52.86%
Train:   Epoch[009/010] Iteration[035/035] Loss: 0.6476 Acc: 63.91%
Valid:   Epoch[009/010] Iteration[005/005] Loss: 0.7193 Acc: 57.14%

结论：

1.直接将 Pytorch-Camp 处理 RMB 分类问题时用到的 LeNet模型用于猫狗数据集分类，从结果来看是不合适的，可能需要对 LeNet进行调整（我猜后面可能会学到该如何调整网络结构）。

2.从这个例子中进一步理解了训练一个神经网络的过程：数据、模型、损失函数、优化器、训练，同时也了解了每个过程中所涉及到的一些细节的处理。

3.目前存在的问题就是：和第1点中提到的一样，对于不同的实际问题，该如何构建合理的深度学习网络（有哪些需要微调的地方？为什么在这个地方进行微调、有什么依据？）。

Pytorch 数据预处理模块 —— transforms

因为不搞计算机视觉，所以 transforms 这部分的内容暂时不学习…

torchvision: 计算机视觉工具包；torchvision.transforms: 常用的图像预处理方法；
torchvision.datasets: 常用数据集的dataset实现，比如 MNIST, CIFAR-10, ImageNet等；
torchvision.model: 常用的模型预训练，比如 AlexNet, VGG, ResNet, GoogLeNet等；