土堆教程笔记【PyTorch】

官网：torch — PyTorch 2.6 documentation
Pycharm

解释器

一般搞深度学习都用虚拟情况的解释器，为了满足不同的项目所必要的不同的包的版本。
1. system interpreter表示当地的解释器

也就是你电脑系统里安装的解释器
2. Virtual Environment—Python的虚拟情况

anaconda可以帮我们创建虚拟情况
a. 创建虚拟情况

1. conda create -n name python = 3.8

复制代码

b. 检察系统中已经存在的情况, * 在哪就是当前在哪个情况。

1. conda info --envs

复制代码

c. 激活情况

1. conda activate xxx

复制代码

d. 退出情况

1. conda deactivate

复制代码

3. conda Enviroment

Anaconda内里附带安装的Python解释器

PyTorch下载命令

• 输入 ↓ ，检察cuda版本
  

1. nvcc -V

复制代码

• 建议挑选conda的而不是wheel的命令，conda支持虚拟情况而且能自动办理依靠标题。
  

常见标题

• 高版本的解释器在anaconda3虚拟路径文件夹envs下边。
  
• 不表现In[2]，打开终端，↓
  

1. pip install ipython

复制代码

• jupyter默认只安装在base情况当中，如果base情况没有安装pytorch，那么jupyter是没有办法使用pytorch的。
  

方案1：在base情况里安装pytorch
方案2：在pytorch情况里安装jupyter

• 装库时报错Caused by SSLError(SSLZeroReturnError(6, 'TLS/SSL connection has been closed (EOF)
  

把代理关了。

• 导入PIL时报错找不到模块
  

1. module = self._system_import(name, *args, **kwargs)
2. ImportError: DLL load failed while importing _imaging: 找不到指定的模块。

复制代码

办理方法：卸载了pywin32包

• 报错
  

1. LooseVersion = distutils.version.LooseVersion AttributeError: module 'distutils' has no attribute 'version'

复制代码

办理方法：注释掉控制台init方法的4-7和第10行。

• 页面太小标题
  

修改固态盘的页面巨细，最小值是内存的1.5倍，最大值是内存的3倍。

• 调用tensorboard不表现图像
  

低沉tensorboard版本

1. pip install tensorboard==2.12.0

复制代码

• 在调用pillow的add_image方法时报错
  

1. image = image.resize((scaled_width, scaled_height), Image.ANTIALIAS)
2. AttributeError: module 'PIL.Image' has no attribute 'ANTIALIAS'

复制代码

新版本pillow（10.0.0之后）Image.ANTIALIAS 被移除了，取而代之的是Image.LANCZOS or Image.Resampling.LANCZOS，干系描述可以可以在pillow的releasenotes中查到。点进去报错的文件，ANTIALIAS改成LANCZOS就可以了。
在 Jupyter Notebook 中切换/使用 conda 虚拟情况

服务器上配置有多个 conda 虚拟情况，在使用jupyter notebook时必要使用其中的一个情况，但是其默认还是使用 base 情况。Jupyter 在一个名为 kernel 的单独进程中运行用户的代码。kernel 可以是不同的 Python 安装在不同的 conda 情况或虚拟情况。
方法1：使用 nb_conda_kernels 添加所有情况（推荐）

1. conda activate my-conda-env    # this is the environment for your project and code
2. conda install ipykernel
3. conda deactivate
5. conda activate base      # could be also some other environment
6. conda install nb_conda_kernels
7. jupyter notebook

复制代码

注意：这里的 conda install nb_conda_kernels 是在 base 情况下操作的。
安装好后，打开 jupyter notebook 就会表现所有的 conda 情况啦，点击随意切换。
方法2：为 conda 情况创建特别内核

1. conda create -n my-conda-env    # creates new virtual env
2. conda activate my-conda-env     # activate environment in terminal
3. conda install ipykernel      # install Python kernel in new conda env
4. ipython kernel install --user --name=my-conda-env-kernel  # configure Jupyter to use Python kernel
5. jupyter notebook      # run jupyter from system

复制代码

只有 Python 内核会在 conda 情况中运行，系统中的 Jupyter 或不同的 conda 情况将被使用——它没有安装在 conda 情况中。通过调用ipython kernel install将 jupyter 配置为使用 conda 情况作为内核.
windows/mac/linux jupyter notebook 切换默认情况
方法3：在 conda 情况中运行 Jupyter 服务器和内核

1. conda create -n my-conda-env   # creates new virtual env
2. conda activate my-conda-env    # activate environment in terminal
3. conda install jupyter     # install jupyter + notebook
4. jupyter notebook       # start server + kernel

复制代码

这种方法就是为每一个 conda 情况 都安装 jupyter。
Jupyter 将完全安装在 conda 情况中。不同版本的 Jupyter 可用于不同的 conda 情况，但此选项可能有点矫枉过正。
在情况中包含内核就充足了，内核是运行代码的封装 Python 的组件。Jupyter notebook 的别的部门可以被视为编辑器或检察器，并且没有须要为每个情况单独安装它并将其包含在每个 env.yml 文件中。
常用函数

• 检察当前路径的包
  

1. dir(torch)

复制代码

• 检察方法的资助文档
  

1. help(torch.cuda.is_available())  / 还有一种方式获取官方文档信息：xxxx ??

复制代码

跳到句首

1. shift+enter

复制代码

数据加载

DataSet抽象类

提供一种方式去获取数据及其label。
DataLoader类

torch.utils.data.DataLoader是一个迭代器，方便我们去多线程地读取数据，并且可以实现batchsize以及
shuffle 的读取等。为后边的网络提供不同的数据情势。

• 如何获取每一个数据及其label
  
• 告诉我们统共有多少数据
  

神经网络经常必要对一个数据迭代多次，只有知道当前有多少个数据，进行练习时才知道要练习多少次，才气把整个数据集迭代完。

1. from torch.utils.data import  Dataset
2. import os
3. #读取图片
4. from PIL import Image
5. class MyDataset(Dataset):
6. #加载磁盘图片到内存
7. #路径分成两部分是因为后续还要用蜜蜂的，拼接方便
8.     def __init__(self,root_dir,label_dir):
9.         self.root_dir = root_dir
10.         self.label_dir = label_dir
11.         self.path = os.path.join(self.root_dir,self.label_dir)
12.         #而得到每一张图片的地址
13.         self.img_path = os.listdir(self.path)
15.     def __getitem__(self, idx):
16.         img_name = self.img_path[idx]
17.         img_item_path = os.path.join(self.root_dir,self.label_dir,img_name)
18.         #读取图片
19.         img = Image.open(img_item_path)
20.         label = self.label_dir
21.         return img,label
22.     def __len__(self):
23.         return len(self.img_path)
24. root_dir = "dataset/train"
25. label_dir = "ants"
26. ants_dataset = MyDataset(root_dir,label_dir)
27. bees_dataset = MyDataset(root_dir,label_dir)
28. ants_dataset[0]

复制代码

TensorBoard（PyTorch1.1之后）

demo

1. from torch.utils.tensorboard import SummaryWriter
3. #日志的所在地址
4. writer = SummaryWriter("D:\PythonProject\Introduction\logs")
6. #第一个参数相当于表头，绘图
7. for i in range(100):
8.     writer.add_scalar('y=x',3 * i, i)
10. writer.close()

复制代码

检察logs

在控制台输入

1. tensorboard --logdir=logs

复制代码

指定端口，防止当别人也在访问时跟别人冲突

1. tensorboard --logdir=logs --port=6007

复制代码

注意：如果出现拟合，那么可以删掉logs下边的文件，重新运行。
添加图像

通过打印发现，此范例不得当当作tensorboard的添加图片的输入范例。

1. PyDev console: using IPython 8.12.2
2. Python 3.8.20 (default, Oct  3 2024, 15:19:54) [MSC v.1929 64 bit (AMD64)] on win32
3. img_path = "dataset/train/ants/0013035.jpg"
4. from PIL import Image
5. img = Image.open(img_path)
6. print(type(img))
7. <class 'PIL.JpegImagePlugin.JpegImageFile'>

复制代码

so，使用Opencv读取图片，得到numpy范例图片数据
使用numpy.array(),对PIL图片进行转换。
Transforms单张图片

输入图像到transforms.py，它像一个工具箱，把一些数据范例转化为tensor（神经网络 的专用数据范例，包装了很多神经网络必要的参数），或者resize.

1. from torch.utils.tensorboard import SummaryWriter
2. from torchvision import transforms
3. from PIL import Image
4. #通过transform.Totensor解决俩问题
5. #1. transform应该如何使用
6. #2. 为什么需要一个Tensor的数据类型
7. img_path = "dataset/train/ants/0013035.jpg"
8. img = Image.open(img_path)
10. writer = SummaryWriter('logs')
12. tensor_trans = transforms.ToTensor()
13. tensor_img = tensor_trans(img)
14. # print(tensor_img)
15. # print(img)
16. writer.add_image("Tensor_img", tensor_img, 3)
17. writer.close()

复制代码

图片不表现的把logs下其他的文件删掉，关掉终端打开再重新运行。
归一化----加速收敛

正则化是防止过拟合
让不同的特征在数值上保持一致，制止某些特征对模型的影响过大，从而更好地学习到数据当中的模式和关系。归一化之后，均值为0，标准差为1.

__call__介绍,把对象当函数用。

1. class Person:
2.     def __call__(self, name):
3.         print("__call__"+"Hello"+name)
5.     def hello(self,name):
6.         print("hello"+name)
7. #__xxx__这种都是内置函数，可以对其进行重写
8. person = Person()
9. #__call__可以直接使用对象里加参数，而不用.的方式。
10. person("zhangsan")
11. person.hello("lisi")

复制代码

忽略巨细写匹配：

settings ----> 搜索case------>Generral下的Code Completion------->取勾Match case
Compose()的用法

Compose()中的参数必要是一个列表，Python中，列表的情势为[xx,xx,xx,xx,...]
在Compose()中，数据必要是transforms范例，以是，Compose(transsforms参数1，transsforms参数2，...)
用于将多个数据预处置惩罚操作组合成一个整体的变换，具体而言，按列表次序进行转换。巨细，裁剪，翻转，归一化等。

1. from torch.utils.tensorboard import SummaryWriter
2. from torchvision import transforms
3. from PIL import Image
4. #通过transform.Totensor解决俩问题
5. #1. transform应该如何使用
6. #2. 为什么需要一个Tensor的数据类型
7. img_path = "dataset/train/ants/0013035.jpg"
8. img = Image.open(img_path)
10. writer = SummaryWriter('logs')
12. tensor_trans = transforms.ToTensor()
13. tensor_img = tensor_trans(img)
14. # print(tensor_img)
15. # print(img)
16. #writer.add_image("Tensor_img", tensor_img, 3)
18. print(tensor_img[0][0][0])
19. #Normalize,归一化，提供三个均值，三个标准差
20. tensor_norm = transforms.Normalize([0.5,0.5,0.5], [0.5,0.5,0.5])
21. #把图片归一化
22. img_norm = tensor_norm(tensor_img)
23. print(img_norm[0][0][0])
24. writer.add_image("Normalize", img_norm,2)
26. #Resize
27. print(img.size)
28. tran_resize = transforms.Resize((512,512))
29. #img PIL -> resize -> img_resize PIL
30. #这个方法需要传入PIL类型的img
31. img_resize = tran_resize(img)
32. # img_resize PIL -> toTensor ->img_resize tensor
33. img_resize = tensor_trans(img_resize)
34. writer.add_image("Resize", img_resize,0)
35. print(img_resize)
37. #Compose
38. trans_resize_2 = transforms.Resize(512)
39. trans_compose = transforms.Compose([trans_resize_2 , tensor_trans])
40. trans_resize_2 = trans_compose(img)
41. writer.add_image("Resize2", trans_resize_2,1)
43. #RandomCrop，随机裁剪
44. trans_random = transforms.RandomCrop((512,512))
45. trans_compose_2 = transforms.Compose([trans_random , tensor_trans])
46. #循环的目的是为了展示随机效果
47. for i in range(10):
48.     img_crop = trans_compose_2(img)
49.     writer.add_image("RandomCrop", img_crop,i)
50. writer.close()

复制代码

torchvision中的数据集的使用

单纯加载数据集CIFAR10 torchvision.datasets — Torchvision master documentation

1. import torchvision
3. train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True)
5. test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True)
6. #打印的是target，就是标签
7. print(test_set[0])
8. print(test_set.classes)
9. img , target = test_set[0]
10. print(img)
11. print(target)
12. print(test_set.classes[target])
13. #对于PIL数据集直接调用这个方法就可以展示图片了
14. img.show()

复制代码

对数据集变换

1. import torchvision
2. from torch.utils.tensorboard import SummaryWriter
4. dataset_transform = torchvision.transforms.Compose([
5.     torchvision.transforms.ToTensor(),
6.     #因为图片太小了就只进行这一个变换
7. ])
8. train_set = torchvision.datasets.CIFAR10(root='./data', train=True,transform=dataset_transform, download=True)
10. test_set = torchvision.datasets.CIFAR10(root='./data', train=False,transform=dataset_transform, download=True)
12. print(test_set[0])
13. #输出的是tensor数据类型，那么就可以用tensorboard进行一个显示
14. writer = SummaryWriter(log_dir='p10')
15. for i in range(10):
16.     img, target = test_set[i]
17.     #ctrl+p
18.     #此时img是tensor类型的
19.     writer.add_image("test_set", img, i)
21. writer.close()

复制代码

在终端输入命令

1. tensorboard --logdir="p10"

复制代码

如果下载太慢的话，可以打开数据集函数进去复制连接本身下载，然后放在对应的文件夹下。
DataLoader的使用

加载器，可以批量加载
参数：
num_workers : 使用多少进程去加载，但是可能只能linux用，win可能报错BrokenPipeErrror，默认值为0，代表使用主进程进行加载。
drop_last : 末了的余数图片要不要加载，false就是不舍弃的意思
shuffle : 遍历完一遍以后才会打乱，而且是在每轮练习当中打乱，一个epoch打乱一次
target不是标签，是标签存放的位置，标签列表是classes，真正的标签是classes[target]
batchsize打印：

1. import torch
2. import torchvision
3. from torch.utils.data import DataLoader
5. #准备的测试数据集
6. test_data = torchvision.datasets.CIFAR10(root='./data', train=False, download=False,transform=torchvision.transforms.ToTensor())
7. test_loader = DataLoader(test_data, batch_size=4, shuffle=True,num_workers=0,drop_last=False)
8. #测试数据集中第一张图片
9. img ,target = test_data[0]
11. print(img.shape)
12. print(target)
13. #data是test_loader里的每一个对象，test_loader是可迭代对象
14. for data in test_loader:
15.     imgs , targets = data
16.     print(imgs.shape)
17.     print(targets)
18. #输出的tensor是把每个图片的target融合在一起了。

复制代码

验证shuffle

1. #验证shuffle
2. for epoch in range(2):
3.     step = 0
4.     for data in test_loader:
5.         imgs, targets = data
6.         writer.add_images("Epoch:{}".format(epoch), imgs, step)
7.         step += 1

复制代码

总代码：

1. import torchimport torchvisionfrom torch.utils.data import DataLoaderfrom torch.utils.tensorboard import SummaryWriter#预备的测试数据集test_data = torchvision.datasets.CIFAR10(root='./data', train=False, download=False,transform=torchvision.transforms.ToTensor())test_loader = DataLoader(test_data, batch_size=4, shuffle=True,num_workers=0,drop_last=False)#测试数据集中第一张图片img ,target = test_data[0]print(img.shape)print(target)#data是test_loader里的每一个对象，test_loader是可迭代对象    # print(imgs.shape)    # print(targets)#输出的tensor是把每个图片的target融合在一起了。writer = SummaryWriter(log_dir='./dataloader')step = 0for data in test_loader:    imgs , targets = data    writer.add_images("test_data", imgs, step)    step += 1#验证shuffle
2. for epoch in range(2):
3.     step = 0
4.     for data in test_loader:
5.         imgs, targets = data
6.         writer.add_images("Epoch:{}".format(epoch), imgs, step)
7.         step += 1writer.close()

复制代码

mini-batch

随机梯度降落

nn.Module

关于神经网络的工具，一般在torch.nn里边。神经网络的根本骨架，一般是被继承的父类
conv2常用参数

padding ----- 添补，更好的使用边缘信息，如许可以均匀使用数据，默认是不进行添补的。
bias ------ 偏置参数
padding_mode ------- 添补模式，一般默认是0
dilation -------- 空洞卷积
卷积demo，因为nn.Module函数当中内置了call函数，以是把参数放进对象里，会自动调用forward函数。是在call函数里调用的。

1. import torch
2. from torch import nn
4. class MyNet(nn.Module):
5.     def __init__(self):
6.         super().__init__()
8.     def forward(self, input):
9.         output = input + 1
10.         return output
12. my_net = MyNet()
13. x =torch.tensor(1.0)
14. y = my_net(x)
15. print(y)

复制代码

为什么要调解形状，因为我们一开始打印出来发现只有高和宽，不满足conv2d的api要求输入的形状。

1. import torch
3. input = torch.tensor([[1,2,0,3,1],
4.                       [0,1,2,3,1],
5.                       [1,2,1,0,0],
6.                       [5,2,3,1,1],
7.                       [2,1,0,1,1]])
8. kernel = torch.tensor([[1,2,1],
9.                        [0,1,0],
10.                        [2,1,0]])
11. #这个尺寸只有高和宽
12. print(input.shape)
13. #torch.Size([5, 5])
14. print(kernel.shape)
15. #torch.Size([3, 3])

复制代码

pytorch给我们提供了尺寸变换

1. input = torch.reshape(input,(1,1,5,5))
2. kernel = torch.reshape(kernel,(1,1,3,3))

复制代码

变换以后就可以使用卷积进行输入

1. output = F.conv2d(input,kernel,stride=1)
2. output2 = F.conv2d(input,kernel,stride=2)
3. print(output)
4. print(output2)

复制代码

1. import torch
2. import torchvision
3. from torch import nn
4. from torch.utils.data import DataLoader
5. from torch.utils.tensorboard import SummaryWriter
7. dataset = torchvision.datasets.CIFAR10(root='./data', train=False,
8.                                        transform=torchvision.transforms.ToTensor(),
9.                                        download=False)
10. dataloader = DataLoader(dataset, batch_size=64)
12. class MyNet(nn.Module):
13.     def __init__(self):
14.         super(MyNet, self).__init__()
15.         self.conv1 = nn.Conv2d(3, 6, 3)
16.     def forward(self, x):
17.         x = self.conv1(x)
18.         return x
19. my_net = MyNet()
20. writer = SummaryWriter("./logs")
21. #可以打印网络结构
22. #print(my_net)
23. step = 0
24. for data in dataloader:
25.     imgs, targets = data
26.     output = my_net(imgs)
27.     print(output.shape)
28.     print(imgs.shape)
29.     #torch.Size([64, 3, 32, 32])
30.     writer.add_images("input", imgs, step)
31.     #torch.Size([64, 6, 30, 30])
32.     #-1是占位符，会被自动计算那个地方的值是多少
33.     output = torch.reshape(output, (-1,3,30,30))
34.     writer.add_images("output", output, step)
35.     step += 1

复制代码

参数：dilation：空洞卷积，卷积核是隔一个的。

1. import torchimport torch.nn.functional as Finput = torch.tensor([    [1,2,0,3,1],    [0,1,2,3,1],    [1,2,1,0,0],    [5,2,3,1,1],    [2,1,0,1,1]])kernel = torch.tensor([[1,2,1],                       [0,1,0],                       [2,1,0]])print(input.shape)print(kernel.shape)#ctrl+p,提示参数#(卷积核数量，通道数，，)#一个卷积核天生一个通道input = torch.reshape(input,(1,1,5,5))
2. kernel = torch.reshape(kernel,(1,1,3,3))print(input.shape)print(kernel.shape)output = F.conv2d(input,kernel,stride=1)output2 = F.conv2d(input,kernel,stride=2)output3 = F.conv2d(input,kernel,stride=1,padding=1)print(output)print(output2)print(output3)

复制代码

池化层

https://github.com/vdumoulin/conv_arithmetic
空洞卷积表示图↑
ceil_mode ------- 当卷积核卷出去以后，true,保存，false，不保存
卷积：提取特征
池化：降维
demo

1. import torch
2. import torchvision
3. from torch import nn
4. from torch.utils.data import DataLoader
5. from torch.utils.tensorboard import SummaryWriter
7. dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False,
8.                                        transform=torchvision.transforms.ToTensor())
9. dataloader = DataLoader(dataset, batch_size=4)
10. input = torch.tensor([
11.     [1,2,0,3,1],
12.     [0,1,2,3,1],
13.     [1,2,1,0,0],
14.     [5,2,3,1,1],
15.     [2,1,0,1,1]
16. ], dtype=torch.float32)
17. input = torch.reshape(input,(-1,1,5,5))
18. print(input.shape)
19. class MyNet(nn.Module):
20.     def __init__(self):
21.         super(MyNet, self).__init__()
22.         self.maxpool1 = nn.MaxPool2d(kernel_size=3, ceil_mode=True)
23.     def forward(self, x):
24.         output = self.maxpool1(x)
25.         return output
26. mynet = MyNet()
27. #print(mynet(input))
28. writer = SummaryWriter('./logs_maxpool')
29. steps = 0
30. for data in dataloader:
31.     imgs,targets = data
32.     writer.add_images("input", imgs, steps)
33.     output = mynet(imgs)
34.     writer.add_images("output", output, steps)
35.     steps += 1
37. writer.close()

复制代码

非线性激活

1. import torch
2. import torchvision
3. from torch.utils.data import DataLoader
4. from torch.utils.tensorboard import SummaryWriter
6. input = torch.tensor([[1,-0.5],
7.                       [-1,3]])
8. output = torch.reshape(input,(-1,1,2,2))
9. print(output)
10. dataset = (torchvision.datasets.CIFAR10(root='./data', train=False, download=False,
11.                                         transform=torchvision.transforms.ToTensor()))
12. dataloader = DataLoader(dataset, batch_size=64)
13. class MyNet(torch.nn.Module):
14.     def __init__(self):
15.         super(MyNet, self).__init__()
16.         self.relu1 = torch.nn.ReLU()
17.         self.sigmoid = torch.nn.Sigmoid()
18.     def forward(self, x):
19.         output = self.sigmoid(x)
20.         return output
21. mynet = MyNet()
22. writer = SummaryWriter('./logs_relu')
23. step = 0
24. for data in dataloader:
25.     imgs,targets = data
26.     writer.add_images("input",imgs,step)
27.     output = mynet(imgs)
28.     writer.add_images("output",imgs,step)
29.     step += 1
30. writer.close()
31. output = mynet(input)
32. print(output)

复制代码

Sequential

让代码看起来更简洁。
demo：对cifar10进行简单分类的神经网络，好像是颠末一次最大池化，尺寸就减半。

已知输入尺寸和输出尺寸，联立两个公式，可以反解出padding。dilation接纳默认的1，就是不进行膨胀。

倒数第二个和倒数第三个，倒数第一个和倒数第二个之间还分别各自有一个线性层。

1. import torch
2. from torch import nn
3. from torch.nn import MaxPool2d, Flatten, Conv2d, Linear
4. from torch.utils.tensorboard import SummaryWriter
7. class MyNet(nn.Module):
8.     def __init__(self):
9.         super(MyNet, self).__init__()
10.         # self.conv1 = nn.Conv2d(3, 32, kernel_size=5,
11.         #                        padding=2)
12.         # self.maxpool1 = nn.MaxPool2d(2)
13.         # self.conv2 = nn.Conv2d(32, 32,5, padding=2)
14.         # self.maxpool2 = nn.MaxPool2d(2)
15.         # self.conv3 = nn.Conv2d(32, 64,5, padding=2)
16.         # self.maxpool3 = MaxPool2d(2)
17.         # self.flatten = Flatten()
18.         # #从图片里看出来的，64*4*4
19.         # self.linear1 = nn.Linear(1024,64)
20.         # self.linear2 = nn.Linear(64,10)
22.         self.model1 = nn.Sequential(
23.             Conv2d(3, 32, kernel_size=5, padding=2),
24.             MaxPool2d(2),
25.             Conv2d(32, 32, kernel_size=5, padding=2),
26.             MaxPool2d(2),
27.             Conv2d(32, 64, kernel_size=5, padding=2),
28.             MaxPool2d(2),
29.             Flatten(),
30.             Linear(1024, 64),
31.             Linear(64,10)
32.         )
34.     def forward(self, x):
35.         x = self.model1(x)
36.         # x = self.conv1(x)
37.         # x = self.maxpool1(x)
38.         # x = self.conv2(x)
39.         # x = self.maxpool2(x)
40.         # x = self.conv3(x)
41.         # x = self.maxpool3(x)
42.         # x = self.flatten(x)
43.         # x = self.linear1(x)
44.         # x = self.linear2(x)
45.         return x
46. my_net = MyNet()
47. print(my_net)
48. input = torch.ones((64, 3, 32, 32))
49. output = my_net(input)
50. print(output.shape)
51. writer = SummaryWriter("./logs_seq")
52. writer.add_graph(my_net, input)
53. writer.close()

复制代码

损失函数

L1Loss

1. import torch
2. from torch.nn import L1Loss
4. inputs = torch.tensor([1,2,3],dtype=torch.float32)
5. targets = torch.tensor([1,2,5],dtype=torch.float32)
7. inputs = torch.reshape(inputs,(1,1,1,3))
8. targets = torch.reshape(targets,(1,1,1,3))
10. loss = L1Loss(reduction='sum')
11. result = loss(inputs,targets)
13. print(result)
14. #2.

复制代码

MSELoss

1. loss_mse = nn.MSELoss()
2. result_mse = loss_mse(result,targets)
3. print(result_mse)
4. #1.3333

复制代码

交织熵

1. x = torch.tensor([0.1,0.2,0.3])
2. y = torch.tensor([1])
3. x = torch.reshape(x,(1,3))
4. loss_cross = nn.CrossEntropyLoss()
5. result_cross = loss_cross(x,y)
6. print(result_cross)
7. #tensor(1.1019)

复制代码

用之前的网络来对数据集进行分类，不外此时的分类是没有意义的，因为还没有颠末练习。

1. import torch
2. import torchvision
3. from torch import nn
4. from torch.nn import MaxPool2d, Flatten, Conv2d, Linear
5. from torch.utils.data import DataLoader
6. from torch.utils.tensorboard import SummaryWriter
8. dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False,
9.                                        transform=torchvision.transforms.ToTensor())
10. dataloader = DataLoader(dataset,batch_size=1)
11. class MyNet(nn.Module):
12.     def __init__(self):
13.         super(MyNet, self).__init__()
14.         self.model1 = nn.Sequential(
15.             Conv2d(3, 32, kernel_size=5, padding=2),
16.             MaxPool2d(2),
17.             Conv2d(32, 32, kernel_size=5, padding=2),
18.             MaxPool2d(2),
19.             Conv2d(32, 64, kernel_size=5, padding=2),
20.             MaxPool2d(2),
21.             Flatten(),
22.             Linear(1024, 64),
23.             Linear(64,10)
24.         )
26.     def forward(self, x):
27.         x = self.model1(x)
28.         return x
30. my_net = MyNet()
31. loss = nn.CrossEntropyLoss()
32. for data in dataloader:
33.     imgs,targets = data
34.     outputs = my_net(imgs)
35.     result_loss = loss(outputs, targets)
36.     print(result_loss)
37.     #tensor(2.2306, grad_fn=<NllLossBackward>)
38. #tensor(2.2557, grad_fn=<NllLossBackward>)
39. #tensor(2.3920, grad_fn=<NllLossBackward>)
40. #......
41.     # print(outputs)
42.     # print(targets)

复制代码

反向传播

• 计算现实输出和目标之间的差距
  
• 为我们更新输出提供肯定的依据，方向传播，grad。
  

一开始是没有梯度的，后来运行完37行，

就出现梯度了，有利于反向传播。

优化器

eg:lr是学习速率

1. optimizer = optim.SGD(model.named_parameters(), lr=0.01, momentum=0.9)
2. optimizer = optim.Adam([('layer0', var1), ('layer1', var2)], lr=0.0001)

复制代码

demo

1. import torch
2. import torchvision
3. from torch import nn
4. from torch.nn import MaxPool2d, Flatten, Conv2d, Linear
5. from torch.utils.data import DataLoader
6. from torch.utils.tensorboard import SummaryWriter
8. dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False,
9.                                        transform=torchvision.transforms.ToTensor())
10. dataloader = DataLoader(dataset,batch_size=1)
11. class MyNet(nn.Module):
12.     def __init__(self):
13.         super(MyNet, self).__init__()
14.         self.model1 = nn.Sequential(
15.             Conv2d(3, 32, kernel_size=5, padding=2),
16.             MaxPool2d(2),
17.             Conv2d(32, 32, kernel_size=5, padding=2),
18.             MaxPool2d(2),
19.             Conv2d(32, 64, kernel_size=5, padding=2),
20.             MaxPool2d(2),
21.             Flatten(),
22.             Linear(1024, 64),
23.             Linear(64,10)
24.         )
26.     def forward(self, x):
27.         x = self.model1(x)
28.         return x
31. my_net = MyNet()
32. optim = torch.optim.SGD(my_net.parameters(), lr=0.01)
33. loss = nn.CrossEntropyLoss()
34. for epoch in range(20):
35.     running_loss = 0.0
36.     for data in dataloader:
37.         imgs,targets = data
38.         outputs = my_net(imgs)
39.         result_loss = loss(outputs, targets)
40.         #梯度清零
41.         optim.zero_grad()
42.         #优化器需要每个参数的梯度
43.         result_loss.backward()
44.         #给每个参数进行调优
45.         optim.step()
46.         running_loss += result_loss
47.     print(running_loss)
48. #print(result_loss)

复制代码

现有网络模型的使用以及修改

1. import torchvision.datasets
2. from torch import nn
3. from torchvision import transforms
5. #train_data = torchvision.datasets.ImageNet("./data_image_net",split='train',
6.      #                                      download=True,transform=transforms.ToTensor())
7. vgg16_false = torchvision.models.vgg16(pretrained=False)
8. #打印的是已经预训练好的网络架构，参数都是在训练之后的
9. vgg16_true = torchvision.models.vgg16(pretrained=True)
10. print(vgg16_true)
11. train_data = torchvision.datasets.CIFAR10(root='./data', train=True, download=False
12.                                           ,transform=torchvision.transforms.ToTensor())
13. #把vgg16当一个前置的网络结构
14. vgg16_true.classifier.add_module('add_linear',nn.Linear(1000, 10))
15. print(vgg16_true)
16. vgg16_false.classifier[6]=nn.Linear(4096, 10)

复制代码

网络模型保存

方式1

模型结构+模型参数

1. import torch
2. import torchvision
4. vgg16 = torchvision.models.vgg16(pretrained=False)
5. #保存方式1
6. torch.save(vgg16,"vgg16_method1.pth")

复制代码

加载模型

1. #保存方式1，加载模型
2. model = torch.load("vgg16_method1.pth")
3. print(model)

复制代码

如果是用方式1并且是自定义模型的话，肯定要让访问的代码能够访问到模型定义的地方。
方式2---字范例例

模型参数（官方推荐，好像是如许比较小）

1. #保存方式2
2. torch.save(vgg16.state_dict(),"vgg16_state_dict.pth")

复制代码

加载模型，字典情势打印出来就看不见网络结构了，也可以再恢复成网络结构的。

1. #方式2加载方式
2. #如果你想恢复成网络模型结构
3. vgg16 = torchvision.models.vgg16(pretrained=False)
4. model = torch.load("vgg16_state_dict.pth")
5. print(model)
6. print(vgg16)

复制代码

模型练习

item和本身的区别：

train.py

1. import torch
2. import torchvision
3. from model import *
5. train_data = torchvision.datasets.CIFAR10(root='./data', train=True, download=True,transform=torchvision.transforms.ToTensor())
6. test_data = torchvision.datasets.CIFAR10(root='./data', train=False, download=True,transform=torchvision.transforms.ToTensor())
8. train_data_size = len(train_data)
9. test_data_size = len(test_data)
10. print("训练数据集的长度是：{}".format(train_data_size))
11. print("测试数据集的长度为：{}".format(test_data_size))
12. #加载数据集
13. train_dataloader = torch.utils.data.DataLoader(train_data,
14.                                                batch_size=64,
15.                                                )
16. #ctrl+d复制本行到下一行
17. test_dataloader = torch.utils.data.DataLoader(test_data, batch_size=64,)
18. #创建网络模型
19. mynet = MyNet()
20. #损失函数,交叉熵
21. loss_function = torch.nn.CrossEntropyLoss()
22. #优化器
23. optimizer = torch.optim.SGD(mynet.parameters(), lr=0.001, momentum=0.9)
24. #设置训练网络的一些参数
25. #记录训练的次数
26. total_train_step = 0
27. total_test_step = 0
28. epoch = 10
29. for i in range(epoch):
30.     print("第{}轮训练开始".format(i+1))
31.     for data in train_dataloader:
32.         imgs,targets = data
33.         outputs = mynet(imgs)
34.         loss = loss_function(outputs, targets)
36.         optimizer.zero_grad()
37.         loss.backward()
38.         optimizer.step()
39.         total_train_step += 1
40.         print("训练次数：{}，Loss{}".format(total_train_step,loss.item()))

复制代码

model.py

1. import torch
2. from torch import nn
3. from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
4. #搭建神经网络
5. class MyNet(nn.Module):
6.     def __init__(self):
7.         super(MyNet, self).__init__()
8.         self.model1 = nn.Sequential(
9.             Conv2d(3, 32, kernel_size=5, padding=2),
10.             MaxPool2d(2),
11.             Conv2d(32, 32, kernel_size=5, padding=2),
12.             MaxPool2d(2),
13.             Conv2d(32, 64, kernel_size=5, padding=2),
14.             MaxPool2d(2),
15.             Flatten(),
16.             Linear(1024, 64),
17.             Linear(64,10)
18.         )
19.     def forward(self, x):
20.         x = self.model1(x)
21.         return x
22. if __name__ == '__main__':
23.     mynet = MyNet()
24.     #64张图片
25.     input = torch.ones((64,3,32,32))
26.     output = mynet(input)
27.     print(output.shape)

复制代码

test

1. import torch
2. import torchvision
3. from torch.utils.tensorboard import SummaryWriter
5. from model import *
7. train_data = torchvision.datasets.CIFAR10(root='./data', train=True, download=True,transform=torchvision.transforms.ToTensor())
8. test_data = torchvision.datasets.CIFAR10(root='./data', train=False, download=True,transform=torchvision.transforms.ToTensor())
10. train_data_size = len(train_data)
11. test_data_size = len(test_data)
12. print("训练数据集的长度是：{}".format(train_data_size))
13. print("测试数据集的长度为：{}".format(test_data_size))
14. #加载数据集
15. train_dataloader = torch.utils.data.DataLoader(train_data,
16.                                                batch_size=64,
17.                                                )
18. #ctrl+d复制本行到下一行
19. test_dataloader = torch.utils.data.DataLoader(test_data, batch_size=64,)
20. #创建网络模型
21. mynet = MyNet()
22. #损失函数,交叉熵
23. loss_function = torch.nn.CrossEntropyLoss()
24. #优化器
25. optimizer = torch.optim.SGD(mynet.parameters(), lr=0.001, momentum=0.9)
26. #设置训练网络的一些参数
27. #记录训练的次数
28. total_train_step = 0
29. total_test_step = 0
30. epoch = 10
31. writer = SummaryWriter('./logs_train')
32. for i in range(epoch):
33.     print("第{}轮训练开始".format(i+1))
34.     for data in train_dataloader:
35.         imgs,targets = data
36.         outputs = mynet(imgs)
37.         loss = loss_function(outputs, targets)
39.         optimizer.zero_grad()
40.         loss.backward()
41.         optimizer.step()
42.         total_train_step += 1
43.         if total_train_step % 100 == 0:
44.             print("训练次数：{}，Loss{}".format(total_train_step,loss.item()))
45.             writer.add_scalar('train_loss', loss.item(), total_train_step)
46.     #测试步骤开始
47.     total_test_loss = 0
48.     total_accuracy = 0
49.     with torch.no_grad():
50.         for data in test_dataloader:
51.             imgs , targets = data
52.             outputs = mynet(imgs)
53.             loss = loss_function(outputs, targets)
54.             total_test_loss += loss.item() == targets
55.             accurancy = outputs.argmax(1)
56.             total_accuracy+=accurancy
57.     print("整体测试集上的loss：{}".format(total_test_loss))
58.     print("整体测试集上的正确率{}".format(total_accuracy))
59.     writer.add_scalar("test_loss",total_test_loss, total_test_step)
60.     writer.add_scalar("test_accuracy",total_accuracy, total_test_step)
61.     total_test_step+=1
63.     torch.save(mynet,"mynet_{}.pth".format(i))
64.     print("模型已保存")
65. writer.close()

复制代码

规范tips

当网络中有dropout层等东西的时间，可以调用他们
练习之前

1. mynet.train()

复制代码

测试之前

1. mynet.eval()

复制代码

使用GPU练习

思路：在如下几处加入干系代码

• 网络模型
  
• 数据（输入，标注）
  
• 损失函数
  
• .cuda
  

方法1

1. if torch.cuda.is_available():
2.     loss_function = loss_function.cuda()
3. if torch.cuda.is_available():
4.     imgs = imgs.cuda()
5.     targets = targets.cuda()

复制代码

方法2

1. .to(device)
2. Device = torch.device("cpu")
3. Device = torch.device("gpu")
4. #定义训练的设备
5. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
6. #电脑上如果有多张显卡，这样来指定显卡
7. Torch.device("cuda:0")
8. Torch.device("cuda:1")
9. imgs, targets = imgs.to(device), targets.to(device)

复制代码

1. import torch
2. import torch.nn as nn
3. import torchvision
4. import time
5. from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
6. from torch.utils.tensorboard import SummaryWriter
7. #定义训练的设备
8. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
9. class MyNet(nn.Module):
10.     def __init__(self):
11.         super(MyNet, self).__init__()
12.         self.model1 = nn.Sequential(
13.             Conv2d(3, 32, kernel_size=5, padding=2),
14.             MaxPool2d(2),
15.             Conv2d(32, 32, kernel_size=5, padding=2),
16.             MaxPool2d(2),
17.             Conv2d(32, 64, kernel_size=5, padding=2),
18.             MaxPool2d(2),
19.             Flatten(),
20.             Linear(1024, 64),
21.             Linear(64,10)
22.         )
23.     def forward(self, x):
24.         x = self.model1(x)
25.         return x
26. train_data = torchvision.datasets.CIFAR10(root='./data', train=True, download=True,transform=torchvision.transforms.ToTensor())
27. test_data = torchvision.datasets.CIFAR10(root='./data', train=False, download=True,transform=torchvision.transforms.ToTensor())
29. train_data_size = len(train_data)
30. test_data_size = len(test_data)
31. print("训练数据集的长度是：{}".format(train_data_size))
32. print("测试数据集的长度为：{}".format(test_data_size))
33. #加载数据集
34. train_dataloader = torch.utils.data.DataLoader(train_data,
35.                                                batch_size=64,
36.                                                )
37. #ctrl+d复制本行到下一行
38. test_dataloader = torch.utils.data.DataLoader(test_data, batch_size=64,)
39. #创建网络模型
40. mynet = MyNet()
41. mynet.to(device)
42. #损失函数,交叉熵
43. loss_function = torch.nn.CrossEntropyLoss()
44. loss_function.to(device)
45. # if torch.cuda.is_available():
46. #     loss_function = loss_function.cuda()
47. #优化器
48. optimizer = torch.optim.SGD(mynet.parameters(), lr=0.001, momentum=0.9)
49. #设置训练网络的一些参数
50. #记录训练的次数
51. total_train_step = 0
52. total_test_step = 0
53. epoch = 10
54. writer = SummaryWriter('./logs_train')
55. start_time = time.time()
56. for i in range(epoch):
57.     print("第{}轮训练开始".format(i+1))
58.     for data in train_dataloader:
59.         imgs,targets = data
60.         imgs, targets = imgs.to(device), targets.to(device)
61.         # if torch.cuda.is_available():
62.         #     imgs = imgs.cuda()
63.         #     targets = targets.cuda()
64.         outputs = mynet(imgs)
65.         loss = loss_function(outputs, targets)
67.         optimizer.zero_grad()
68.         loss.backward()
69.         optimizer.step()
70.         total_train_step += 1
71.         if total_train_step % 100 == 0:
72.             end_time = time.time()
73.             print(end_time - start_time)
74.             print("训练次数：{}，Loss{}".format(total_train_step,loss.item()))
75.             writer.add_scalar('train_loss', loss.item(), total_train_step)
76.     #测试步骤开始
77.     total_test_loss = 0
78.     total_accuracy = 0
79.     with torch.no_grad():
80.         for data in test_dataloader:
81.             imgs , targets = data
82.             imgs, targets = imgs.to(device), targets.to(device)
83.             # if torch.cuda.is_available():
84.             #     imgs = imgs.cuda()
85.             #     targets = targets.cuda()
86.             outputs = mynet(imgs)
87.             loss = loss_function(outputs, targets)
88.             total_test_loss += loss.item()
89.             accurancy = (outputs.argmax(1) == targets).sum()
90.             total_accuracy+=accurancy.item()
91.     print("整体测试集上的loss：{}".format(total_test_loss))
92.     print("整体测试集上的正确率{}".format(total_accuracy))
93.     writer.add_scalar("test_loss",total_test_loss, total_test_step)
94.     writer.add_scalar("test_accuracy",total_accuracy, total_test_step)
95.     total_test_step+=1
97.     torch.save(mynet,"mynet_{}.pth".format(i))
98.     print("模型已保存")
99. writer.close()

复制代码

模型验证

使用已经练习好的模型，给它提供输入。
tips:
png图像是4通道，除了rgb以外ia，还有一个透明通道。

1. image = image.convert('RGB')

复制代码

demo

1. import torch
2. import torchvision
3. from PIL import Image
4. from torch import nn
5. from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
8. class MyNet(nn.Module):
9.     def __init__(self):
10.         super(MyNet, self).__init__()
11.         self.model1 = nn.Sequential(
12.             Conv2d(3, 32, kernel_size=5, padding=2),
13.             MaxPool2d(2),
14.             Conv2d(32, 32, kernel_size=5, padding=2),
15.             MaxPool2d(2),
16.             Conv2d(32, 64, kernel_size=5, padding=2),
17.             MaxPool2d(2),
18.             Flatten(),
19.             Linear(1024, 64),
20.             Linear(64,10)
21.         )
22.     def forward(self, x):
23.         x = self.model1(x)
24.         return x
25. image_path = "./images/dog.png"
26. image = Image.open(image_path)
27. print(image)
29. transform = torchvision.transforms.Compose([
30.     torchvision.transforms.Resize((32,32)),
31.     torchvision.transforms.ToTensor()])
32. image = transform(image)
33. print(image.shape)
34. model = torch.load("mynet_9.pth",map_location=torch.device('cpu'))
35. print(model)
36. image = torch.reshape(image, (1,3,32,32))
37. model.eval()
38. with torch.no_grad():
39.     output = model(image)
40. print(output)
41. print(output.argmax(1))

复制代码

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