【torch】机器学习库

文章概览

常用词典

1 2	std: 标准差 eps: 防止除零可取1e-8

torch

PyTorch documentation — PyTorch 2.0 documentation

.permute(2, 0, 1)：改变维度位置

.transpose(1, 2)：改变维度位置

.unsqueeze(0)：去除空余维度 torch.squeeze(tensor) 是同样的效果

.expand(b, 2, h, w)：用重复填充

.view(B, N, -1)：resize（纯纯拉直按顺序拼）

.contiguous(): 深拷贝

生成

1
2
3

# 生成随机数
torch.rand([2, 3])	# 生成shape为2, 3的随机矩阵
torch.arange(0, 10, 1)	# 生成一维等间隔张量

运算

1	# 点乘 @ 对应位置相乘 *

模块

# 自己模型的结构
class yourModel(nn.Module):
        def __init__(self):
        super(yourModel, self).__init__()

常用函数

`torch.optim.Adam(model.parameters(), lr=3e-4)`

生成优化器optimizer

params (iterable) – 待优化参数，一般用model.parameters()，其中model是待优化模型
lr (float, 可选) – 学习率（默认：1e-3）
betas (Tuple[float, float], 可选) – 用于计算梯度以及梯度平方的运行平均值的系数（默认：0.9，0.999）（不懂）
eps (float, 可选) – 防止零作为分母报错（默认：1e-8）
weight_decay (float, 可选) – 权重衰减（L2惩罚）（默认: 0）（UDL中用1e-8）

`torch.nn.Dropout(p=0.1, inplace=False)`

dropout防止过拟合，随机元素置零。

数据要相应放大为 $\frac{1}{1-p}$ 倍

p - 元素归零的占比
inplace - 是否补充0元素

函数字典

nn.functional

embedding编码
类似于按索引找列表的值，编码矩阵存储不同特征，输入是特征的索引，输出特征向量
1
F.embedding(input, embedding_matrix) # 返回embedding_matrix中input对应的特征向量

nn.MSELoss

损失函数，均方误差

nn.Conv2d

nn.Conv2d(in_channel, out_channel,kernel_size=2,stride=2)

常用 nn.Conv2d(3,3,kernel_size=2,stride=2) 把图像缩小2倍

nn.Upsample

nn.Upsample(scale_factor=4, mode='nearest') 上采样4倍

nn.AdaptiveAvgPool2d

nn.AdaptiveAvgPool2d(1) 输出图像大小为1，也可设为指定长宽

设置型函数

# 设置种子，保证可复现
SEED = 1
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
torch.cuda.manual_seed_all(SEED)

# 设置显存使用，不过只会让你训练可用空间被限制，不会限制速度
torch.cuda.set_per_process_memory_fraction(0.4, device=0)

常用运算单元

模型框架

# 归一化
class Norm(nn.Module):
    def __init__(self, shape):
        super().__init__()

        # create two learnable parameters to calibrate normalisation
        self.alpha = nn.Parameter(torch.ones(shape))
        self.bias = nn.Parameter(torch.zeros(shape))

        self.eps = 1e-8

    def forward(self, x):
        norm_x = self.alpha * (x - x.mean(dim=-1)) / (x.std(dim=-1) + self.eps) + self.bias
        return norm_x

训练框架

for epoch in range(epochs):
    model.train()
    for i in range(batch_num):
        # batch数据
        gt = gt_all[i * batch_size:(i + 1) * batch_size]
       	ms = ms_all[i * batch_size:(i + 1) * batch_size]
        pan = pan_all[i * batch_size:(i + 1) * batch_size]
        
        # 核心框架
        optimizer.zero_grad()
        out = model(ms, pan)
        loss = criterion(out, gt)
        loss.backward()
        optimizer.step()

	# 输出log
	print('Epoch: {}/{} training loss: {:.7f}'.format(epoch, epochs, loss.item()))

	# 保存模型
	if epoch % ckpt == 0:
		model_out_path = 'Weights' + '/' + "{}.pth".format(epoch)
		torch.save(model.state_dict(), model_out_path)

优化器和损失函数

import torch.nn as nn
import torch.optim as optim

criterion = nn.MSELoss().cuda()
optimizer = optim.Adam(model.parameters(), lr=lr)

基础和超参数框架

import torch

SEED = 1
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
torch.cuda.manual_seed_all(SEED)

# ============= HYPER PARAMS ==========#
lr = 1e-5  # 学习率
epochs = 1500  # 450
ckpt = 2

多想多做，发篇一作