PyTorch学习笔记——PyTorch模块和基础实战_pytorch pywt.dwt2

---

前言

提示：pytorch学习记录：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、pytorch基础知识

2.1、张量

Scalar
Vector
Matrix
Tensor
张量Tensor可以是高维的，pytorch运算的基本单元，基础数据定义和运算，在pytorch中支持GPU运算，自动求导等操作。

代码演示

import torch
# tensor(data, *, dtype=None, device=None, requires_grad=False, pin_mimory=False)
?torch.tesnor

# 创建tensor，用dtype指定类型,注意类型要匹配
a = torch.tensor(1.0, dtype=torch.float)
b = torch.tensor(1, dtype=torch.long)
c = torch.tensor(1.0, dtype=torch.int8)

# 使用指定类型函数随机初始化指定大小的tensor
d = torch.FloatTensor(2, 3)
e = torch.IntTensor(2) # 默认是int32
f = torch.IntTensor([1, 2, 3, 4])  # 对于python已经定义号的数据结构可以直接转换

# tensor和numpy array 之间的相互转换

g = np.array([[1, 2, 3], [4, 5, 6]])
h = torch.tensor(g)
i = h.numpy()

# 常见的构造Tensor的函数

k = torch.rand(1, 2)  # 随机
l = torch.ones(2, 3)
m = torch.zeros(2, 3)
n = torch.arrange(0, 10, 2)  # [0, 10)

# 查看tensor的维度信息
k.shape
k.size()

# tensor的运算

o = torch.add(k, l)

# tensor的索引方式
o[:, 1]
o[0, :]

# 改变tensor形状的神器：view

o.view(3, 2)
o.view(-1, 2)  # -1自动推导出大小

# tensor的广播机制（使用时需要注意这个特性）
p = torch.arange(1, 3).view(1, 2)
q = torch.arange(1, 4).view(3, 1)
p + q   # 如果未对齐，将自动对齐
# 1 x 2
# 3 x 1
# 3 x 2

# 扩展&压缩tensor的维度: squeeze unsqueeze
o  # 2 x 3
r = o.unsqueeze(1)  # 在第二个维度扩展
r  # 2 x 1 x 3
# 只有维度等于1才能压缩
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

2.2自动求导

PyTorch实现模拟训练

• 输入数据，正向传播
• 同时创建计算图
• 计算损失函数
• 损失函数反向传播
• 更新模型参数

Tensor数据结构是实现自动求导的基础

自动求导——数学基础

• 多元函数求导的雅可比矩阵
  
• 复合函数求导的链式法则
  若h(x) = f(g(x)),则d(h)/dx = d(f(x))/d(g(x)) * d(g(x))/dx

代码展示

### 第二部分:自动求导示例
这里将通过一个简单的函数y = x1 + 2 * x2

import torch

x1 = torch.tensor(1.0, requires_grad=True)
x2 = torch.tensor(2.0, requires_grad=True)
y = x1 + 2 * x2

y

# 首先查看每个变量是否需要求导
print(x1.requires_grad)
print(x2.requires_grad)
print(y.requires_grad)

# 查看每个变量导数大小，此时因为还没有反向传播，因此导数不存在
print(x1.grad.data)
print(x2.grad.data)
print(y.grad.data)

x1

## 反向传播后看导数的大小
y = x1 + 2 * x2
y.backward()
print(x1.grad.data)
print(x2.grad.data)

# 导数是会累积的，重复运行相同命令，grad会增加
y = x1 + 2 * x2
y.backward()
print(x1.grad.data)
print(x2.grad.data)

# 所以每次计算前需要清除当前导数值避免累积，这一功能可以通过pytorch的optimizer实现，后续会将

# 尝试，如果不允许求导，会出现什么情况?
x1 = torch.tensor(1.0, requires_grad=False)
x2 = torch.tensor(2.0, requires_grad=False)
y = x1 + 2 * x2
y.backward()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

2.3并行计算

• 能计算——显存占用
• 算得快——计算速度
• 效果好——大batch提升训练效果

怎么并行？——CUDA

• 在Pytorch中，CUDA更多的指用GPU进行计算(而不是CPU)

并行计算的方法

• 网络结构分布到不同的设备中
• 同一层任务分布到不同数据中
• 不同数据分布到不同的设备中

2.3并行计算——扩展

• cuDNN与CUDA
  • cuDNN是用于深度神经网络的加速库
  • cuDNN基于CUDA完成深度学习的加速

二、Pytorch模块和基础实践

2.1神经网络学习机制

• 数据预处理
• 模型设计
• 损失函数和优化方案设计
• 前向传播
• 反向传播
• 更新参数

2.2深度学习在实现上的特殊性

• 样本量大，通常需要分批加载
• 逐层、模块化搭建网络(卷积层、全连接层、lstm等
• 多样化的损失函数和优化器设计*
• GPU的使用
• 以上各个模块之间的配合

2.3PyTorch深度学习模块

• 将PyTorch完成深度学习的步骤拆解为几个主要模块
• 实际使用根据自身需求修改对应模块即可
• 深度学习 ——>搭积木

2.3.1 基本配置

• 导入必要的packages
  • os, numpy, pandas, torch, torch.nn, torch.optim, torch.utils.data
• 配置训练过程的超参数
  • batch size, learning rate, max_epochs, num_workers
• 配置训练用的硬件设备
  • CPU or GPU, which GPU(s)
• 代码演示

2.3.2 数据读入

• 如何读取格式不定的本地数据：Dataset
  • init, getitem, len
• 如何将数据加载以供模型输入：DataLoader
  • batch_size, num_workers, shuffle, drop_last, pin_memory
• 代码演示

## 读取方式二：使用csv格式的数据，自行构建Dataset类
class FMDataset(Dataset):
    def __init__(self, df, transform=None):
        self.df = df
        self.transform = transform
        self.images = df.iloc[:, 1:].values.astype(np.uint8)
        self.labels = df.iloc[:, 0].values
    
    def __len__(self):
        return len(self.images)
    
    def __getitem__(self, idx):
        image = self.images[idx].reshape(28, 28, 1)
        label = int(self.labels[idx])
        if self.transform is not None:
            image = self.transform(image)
        else:
            image = torch.tensor(image/255, dtype=torch.float)
        label = torch.tensor(label, dtype=torch.long)
        return image, label

train_df = pd.read_csv("D:/人工智能/pytorch/数据集/fashion-mnist_train.csv")
test_df = pd.read_csv("D:/人工智能/pytorch/数据集/fashion-mnist_test.csv")
train_data = FMDataset(train_df, data_transform)
test_data = FMDataset(test_df, data_transform)  
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=num_workers, drop_last=True)  # batch_size每一批读入数据，shuffle打乱数据，num_workers读的时候用多少线程读，drop_last是否丢弃最后不满一个batch的数据, pin_memory锁用内存，运行更快，占用内存
test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=False, num_workers=num_workers)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2.3.3 模型构建

• 神经网络的构造：基于nn.Module

  • init, forward

• 神经网络是通过“层定义 + 层顺序”的方式构建起来的

• 神经网络常见层

  • nn.Conv2d, nn.MaxPool2d, nn.Linear,nn.ReLU,…

• 代码演示

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 32, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3),
            nn.Conv2d(32, 64, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3)
        )
        self.fc = nn.Sequential(
        nn.Linear(64*4*4, 512),
        nn.ReLU(),
        nn.Linear(512, 10))
        
    def forward(self, x):
        x = self.conv(x)
        x = x.view(-1, 64*4*4)
        x = self.fc(x)
        # x = nn.functional.normalize(x)
        return x
    
    
model = Net()
model = model.cuda()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2.3.4 损失函数

• torch.nn提供了多种预定义的损失函数
• 可以自己定义损失函数
• 根据实际需求选用对应的损失函数
• 损失函数常用操作
  • backward()
• 代码演示

criterion = nn.CrossEntropyLoss()
# criterion = nn.CrossEntropyLoss(weight=[1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
1
2

2.3.5 优化器

• torch.optim提供了多种预定义的优化器
• 可以自己定义优化器
• 根据实际需求选用对应的优化器
• 优化器常用操作：
  • step(), zero_grad(), load_state_dict(),…
• 代码演示

2.3.6 训练与评估

• 模型状态设置

  • model.train(), model.eval()

• 训练流程：读取、转换、梯度清零、输入、计算损失、反向传播、参数更新

• 验证流程：读取、转换、输入、计算损失、计算指标

• 代码演示

def train(epoch):
    model.train()
    train_loss = 0
    for data, label in train_loader:
        data, label = data.cuda(), label.cuda()
        optimizer.zero_grad()  # 梯度清零
        output = model(data)
        loss = criterion(output, label)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()*data.size(0)
    train_loss = train_loss/len(train_loader.dataset)
    print("Epoch:{} \tTraining Loss:{:.6f}".format(epoch, train_loss))

def val(epoch):
    model.eval()
    val_loss = 0
    gt_labels = []
    pred_labels = []
    with torch.no_grad():
        for data, label in test_loader:
            data, label = data.cuda(), label.cuda()
            output = model(data)
            preds = torch.argmax(output, 1)
            gt_labels.append(label.cpu().data.numpy())
            pred_labels.append(preds.cpu().data.numpy())
            loss = criterion(output, label)
            val_loss += loss.item()*data.size(0)
    val_loss = val_loss/len(test_loader.dataset)
    gt_labels, pred_labels = np.concatenate(gt_labels), np.concatenate(pred_labels)
    acc = np.sum(gt_labels==pred_labels)/len(pred_labels)
    print('Epoch:{} \tValidation Loss:{:.6f}, Accuracy:{:.6f}'.format(epoch, val_loss, acc))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

三、总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pytorch的使用，而pytorch提供了能使我们快速便捷地训练模型和优化模型的函数和方法。