深度学习5

一、模型生存与加载

 1、序列化方式

        生存方式：torch.save(model, "model.pkl")
        打开方式：model = torch.load("model.pkl", map_location="cpu")

1. ​
2. import torch
3. import torch.nn as nn
6. class MyModle(nn.Module):
7.     def __init__(self, input_size, output_size):
8.         super(MyModle, self).__init__()
9.         self.fc1 = nn.Linear(input_size, 128)
10.         self.fc2 = nn.Linear(128, 64)
11.         self.fc3 = nn.Linear(64, output_size)
13.     def forward(self, x):
14.         x = self.fc1(x)
15.         x = self.fc2(x)
16.         output = self.fc3(x)
17.         return output
19. model = MyModle(input_size=128, output_size=32)
20. # 序列化方式保存模型对象
21. torch.save(model, "model.pkl")
24. # 注意设备问题
25. model = torch.load("model.pkl", map_location="cpu")
26. print(model)
28. ​

复制代码

2、生存模型参数

        设置需要生存的模型参数：
   save_dict = {
          "init_params": {
              "input_size": 128,  # 输入特性数
              "output_size": 32,  # 输出特性数
          },
          "accuracy": 0.99,  # 模型正确率
          "model_state_dict": model.state_dict(),
          "optimizer_state_dict": optimizer.state_dict(),
      }
  
生存模型参数：torch.save(save_dict, "名称.pth")，一般使用 pth 作为后缀
创建新模型时调用生存的模型参数：
加载模型参数：torch.load("名称.pth")
input_size =  save_dict["init_params"]["input_size"]

1. import torch
2. import torch.nn as nn
3. import torch.optim as optim
5. class MyModle(nn.Module):
6.     def __init__(self, input_size, output_size):
7.         super(MyModle, self).__init__()
8.         self.fc1 = nn.Linear(input_size, 128)
9.         self.fc2 = nn.Linear(128, 64)
10.         self.fc3 = nn.Linear(64, output_size)
12.     def forward(self, x):
13.         x = self.fc1(x)
14.         x = self.fc2(x)
15.         output = self.fc3(x)
16.         return output
18. save_dict = torch.load("模型参数保存名称.pth")
19. model = MyModle(
20.     input_size=save_dict["init_params"]["input_size"],
21.     output_size=save_dict["init_params"]["output_size"],
22. )
23. # 初始化模型参数
24. model.load_state_dict(save_dict["model_state_dict"])
25. optimizer = optim.SGD(model.parameters(), lr=0.01)
26. # 初始化优化器参数
27. optimizer.load_state_dict(save_dict["optimizer_state_dict"])
28. # 打印模型信息
29. print(save_dict["accuracy"])
30. print(model)

复制代码

二、数据增强

        具体参考官方文档：Illustration of transforms — Torchvision 0.20 documentation
1、官方代码-主体

1. import matplotlib.pyplot as plt
2. import numpy as np
3. import torch
4. from PIL import Image
6. plt.rcParams["savefig.bbox"] = "tight"
7. torch.manual_seed(0)
9. orig_img = Image.open("../../data/1.png")
11. def plot(imgs, title, with_orig=True, row_title=None, **imshow_kwargs):
12.     if not isinstance(imgs[0], list):
13.         # Make a 2d grid even if there's just 1 row
14.         imgs = [imgs]
16.     num_rows = len(imgs)
17.     num_cols = len(imgs[0]) + with_orig
18.     fig, axs = plt.subplots(nrows=num_rows, ncols=num_cols, squeeze=False)
19.     plt.title(title)
21.     for row_idx, row in enumerate(imgs):
22.         row = [orig_img] + row if with_orig else row
23.         for col_idx, img in enumerate(row):
24.             ax = axs[row_idx, col_idx]
25.             ax.imshow(np.asarray(img), **imshow_kwargs)
26.             ax.set(xticklabels=[], yticklabels=[], xticks=[], yticks=[])
28.     if with_orig:
29.         axs[0, 0].set(title="Original image")
30.         axs[0, 0].title.set_size(8)
31.     if row_title is not None:
32.         for row_idx in range(num_rows):
33.             axs[row_idx, 0].set(ylabel=row_title[row_idx])
35.     plt.tight_layout()
37.     plt.show()

复制代码

2、固定转换

2.1、pad 边缘添补

        就是在照片四周添加黑色框区域
   padded_imgs = [v2.Pad(padding=padding)(orig_img) for padding in (3, 10, 30, 50)]
plot([orig_img] + padded_imgs, "v2.Pad")
  2.2、resize 巨细调解

   resized_imgs = [v2.Resize(size=size)(orig_img) for size in (30, 50, 100, orig_img.size)]
plot([orig_img] + resized_imgs, "v2.Resize")
   2.3、center crop 中央裁剪

   center_crops = [
    v2.CenterCrop(size=size)(orig_img) for size in (30, 50, 100, orig_img.size)
]
plot([orig_img] + center_crops, "v2.CenterCrop")
  2.4、five crop 周边裁剪

   (top_left, top_right, bottom_left, bottom_right, center) = v2.FiveCrop(size=(100, 100))(
    orig_img
)
plot(
    [orig_img] + [top_left, top_right, bottom_left, bottom_right, center], "v2.FiveCrop"
)
  3、随机转换

3.1、RandomRotation 随机旋转

   rotater = v2.RandomRotation(degrees=(0, 180)) # 随机从0-180获取一个数值
rotated_imgs = [rotater(orig_img) for _ in range(4)] # 根据随机数值得到角度转变
plot([orig_img] + rotated_imgs)
  3.2、RandomAffine  随机仿射

   affine_transfomer = v2.RandomAffine(degrees=(30, 70), translate=(0.1, 0.3), scale=(0.5, 0.75))
affine_imgs = [affine_transfomer(orig_img) for _ in range(4)]
plot([orig_img] + affine_imgs)
  4、数据增强整合

1. from PIL import Image
2. from pathlib import Path
3. import matplotlib.pyplot as plt
4. import numpy as np
5. import torch
6. from torchvision import transforms, datasets, utils
9. def test001():
10.     # 定义数据增强和预处理步骤
11.     transform = transforms.Compose(
12.         [transforms.RandomHorizontalFlip(),  # 随机水平翻转
13.         transforms.RandomRotation(10),  # 随机旋转 ±10 度
14.         transforms.RandomResizedCrop( 32, scale=(0.8, 1.0) ),  # 随机裁剪到 32x32，缩放比例在0.8到1.0之间
15.         transforms.ColorJitter(
16.                 brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1
17.             ),  # 随机调整亮度、对比度、饱和度、色调
18.         transforms.ToTensor(),  # 转换为 Tensor
19.         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),  # 归一化
20.         ]
21.     )
23.     # 加载 CIFAR-10 数据集，并应用数据增强
24.     trainset = datasets.CIFAR10(
25.         root="../../data", train=True, download=True, transform=transform
26.     )
28.     trainloader = torch.utils.data.DataLoader(
29.         trainset, batch_size=4, shuffle=True, num_workers=2
30.     )
32.     # 显示增强后的图像
33.     dataiter = iter(trainloader)
34.     images, labels = next(dataiter)
36.     def imshow(img):
37.         img = img / 2 + 0.5  # 反归一化
38.         npimg = img.numpy()
39.         plt.imshow(np.transpose(npimg, (1, 2, 0)))
40.         plt.show()
42.     imshow(utils.make_grid(images))
44. test001()

复制代码

三、神经网络

1、人工神经元

        吸收多个输入的信息并举行加权求和，使用激活函数处理得到最后效果。

        

人工神经元的设置方法是对比生物神经元的结构：
生物神经元人工神经元细胞核节点 (加权求和 + 激活函数)树突输入轴突带权重的连接突触输出 2、神经网络

        由大量人工神经元按层次结构连接而成的盘算模型，上一层的神经元输出作为下一层神经元的输入，层之间的神经元并无连接。
2.1、结构

        输入层：整个神经网络的第一层，负责吸收外部数据，不做任何盘算。
        隐蔽层：位于神经网络输入层与输出层之间的内容，举行特性提取、转化、盘算等操作，一般为多层神经元组成。
        输出层：吸收隐蔽层的盘算效果，产生预测效果或分类效果
2.2、全连接神经网络

        每一层的单个神经元都与上一层的所有神经元连接，一般用于图像分类、文本等。

3、参数初始化（权重、偏置）

        权重和偏置：model.weight、model.bias 
        初始化使用 torch.nn.init 库的方法
3.1、固定值初始化--全零化、全1化、常数化

        将参数所有数据变成固定值，一般不消于初始化权重（会粉碎对称性），用于初始化偏置。
torch.nn.init.zeros_(model.weight) ：参数为初始化对象，只能一个tensor。
torch.nn.init.ones_(model.weight) ：参数为初始化对象，只能一个tensor。
torch.nn.init.constant_(model.weight) ：参数1为初始化对象，只能一个tensor；参数2为设置的浮点数。

1. from  torch.nn import Linear
2. import torch.nn
4. model = Linear(4,1)
5. # 参数只有一个，初始化对象，不能一次初始化多个对象
6. torch.nn.init.zeros_(model.weight)
7. torch.nn.init.zeros_(model.bias)
8. print(model.weight,model.bias)
11. torch.nn.init.ones_(model.weight)
12. torch.nn.init.ones_(model.bias)
13. print(model.weight,model.bias)
15. model = Linear(4,1)
16. # 使用叶子节点来初始化为0
17. model.weight.detach().zero_()
18. model.bias.detach().zero_()
19. print(model.weight,model.bias)
21. model = Linear(4,1)
22. # 参数第一个为初始化对象，第二个为设定的浮点数；
23. # 不能一次初始化多个对象
24. torch.nn.init.constant_(model.weight,5.)
25. torch.nn.init.constant_(model.bias,5.)
26. print(model.weight,model.bias)

复制代码

3.2、随机初始化 

        normal_、uniform_：将权重初始化为随机的小值，通常从正态分布或均匀分布中采样；能避免对称性粉碎。

1. from  torch.nn import Linear
2. import torch.nn
4. model = Linear(4,1)
5. # 参数第一个为初始化对象；
6. # 参数2、3为均值和标准差，默认 0，1标准正太分布
7. torch.nn.init.normal_(model.weight)
8. torch.nn.init.normal_(model.bias)
9. print(model.weight,model.bias)
11. # 参数第二个和第三个为下界和上界，默认0-1
12. torch.nn.init.uniform_(model.weight, 0,1)
13. torch.nn.init.uniform_(model.bias)
14. print(model.weight,model.bias)

复制代码

3.3、Xavier 初始化

        对随机初始化添加取值限定。
        

平衡了输入和输出的方差，适合Sigmoid 和 Tanh 激活函数或浅层网络。

1. from  torch.nn import Linear
2. import torch.nn
4. model = Linear(4,1)
5. # 参数第一个为初始化对象；
6. # 第二个参数 gain 是缩放因子
7. torch.nn.init.xavier_normal_(model.weight)
8. print(model.weight)
10. torch.nn.init.xavier_uniform_(model.weight)
11. print(model.weight)
13. """
14. 常见的 gain 值:
15.     线性激活函数：gain = 1.0（默认值）
16.     Sigmoid 激活函数：gain = 1.0
17.     Tanh 激活函数：gain = 5/3（约等于 1.653）
18.     ReLU 激活函数：gain = sqrt(2)（约等于 1.414）
19.     Leaky ReLU 激活函数：gain = sqrt(2 / (1 + negative_slope^2))，其中 negative_slope 是 Leaky ReLU 的负斜率，默认值为 0.01。
20. """

复制代码

3.4、He初始化 （kaiming 初始化 ）

        专门为 ReLU 激活函数设计；权重从以下分布中采样   

，

是当前层的输入神经元数目。

1. from  torch.nn import Linear
2. import torch.nn
4. model = Linear(4,1)
5. # 参数第一个为初始化对象；
6. # a 为负斜率的值（relu负数为0，所以此参数只有在relu衍生的函数有效 leaky_relu）
7. # nonlinearity 默认 leaky_relu
8. # mode 默认 fan-in 使用输入单元数量计算初始化值
10. torch.nn.init.kaiming_normal_(model.weight)
11. print(model.weight)
13. torch.nn.init.kaiming_uniform_(model.weight)
14. print(model.weight)

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。