[Pytorch系列-37]：工具集 - torchvision库详解(数据集、数据预处理、模型)

torchvision.datasets : 几个常用视觉数据集，可以在线下载和离线加载。
torchvision.models : 流行的模型，例如 AlexNet, VGG, ResNet 和 Densenet 以及与训练好的参数。
torchvision.transforms : 常用的图像操作，例如：随机切割，旋转，数据类型转换，图像到tensor ,numpy 数组到tensor , tensor 到图像等。
torchvision.utils : 提供了一组与视频处理相关的函数。

（3）上述工具的关系

第3章 torchvision.datasets 简介

3.1 简介

torchvision.datasets — Torchvision 0.11.0 documentationhttps://pytorch.org/vision/stable/datasets.htmltorchvision.datasets提供了对常见数据集的基本操作。

（1）特定数据集的远程下载和文件读取

例如：

imagenet_data = torchvision.datasets.ImageNet(root='path/to/imagenet_root/')

不同的数据集，其远程下载和文件读取的函数相似
不同的数据集，其远程下载和文件读取的函数参数不同
并非所有数据集都支持远程下载，有时候需要手工下载到本地，然后通过本地文件读取。

（3）本地数据集文件的读取（从文件系统加载到内存对象）

train_data = ImageFolder(root, transform=None, target_transform=None, loader=default_loader)

（3）数据集的批量加载：data_loader

data_loader = torch.utils.data.DataLoader(imagenet_data,
                                          batch_size=4,
                                          shuffle=True,
                                          num_workers=args.nThreads)

3.2 支持的数据集列表

torchvision.datasets

第4章 torchvision.models简介

4.1 简介

torchvision.models — Torchvision 0.11.0 documentationhttps://pytorch.org/vision/stable/models.html

4.2 支持的模型

4.3 构造具有随机权重的模型

（1）概述

你可以通过调用其构造函数来构造具有随机权重的模型。

有了torchvision.models，程序员就不需要自己一层一层地、手工、搭建知名的神经网络，models已经搭建好这些网络模型，程序员直接利用models提供的函数，创建对应的模型对象。

（2）代码示例

import torchvision.models as models

alexnet = models.alexnet()                         # AlexNet
vgg16 = models.vgg16()                             # VGG16
resnet18 = models.resnet18()                       # ResetNet模型
googlenet = models.googlenet()                     # googlenet
inception = models.inception_v3()                  # inception

squeezenet = models.squeezenet1_0()                # 序列网络
densenet = models.densenet161()                    # 稠密网络
shufflenet = models.shufflenet_v2_x1_0()

mobilenet_v2 = models.mobilenet_v2()
mobilenet_v3_large = models.mobilenet_v3_large()
mobilenet_v3_small = models.mobilenet_v3_small()
resnext50_32x4d = models.resnext50_32x4d()
wide_resnet50_2 = models.wide_resnet50_2()
mnasnet = models.mnasnet1_0()

#efficientnet_b0 = models.efficientnet_b0()
#efficientnet_b1 = models.efficientnet_b1()
#efficientnet_b2 = models.efficientnet_b2()
#efficientnet_b3 = models.efficientnet_b3()
#efficientnet_b4 = models.efficientnet_b4()
#efficientnet_b5 = models.efficientnet_b5()
#efficientnet_b6 = models.efficientnet_b6()
#efficientnet_b7 = models.efficientnet_b7()
#regnet_y_400mf = models.regnet_y_400mf()
#regnet_y_800mf = models.regnet_y_800mf()
#regnet_y_1_6gf = models.regnet_y_1_6gf()
#regnet_y_3_2gf = models.regnet_y_3_2gf()
#regnet_y_8gf = models.regnet_y_8gf()
#regnet_y_16gf = models.regnet_y_16gf()
#regnet_y_32gf = models.regnet_y_32gf()
#regnet_x_400mf = models.regnet_x_400mf()
#regnet_x_800mf = models.regnet_x_800mf()
#regnet_x_1_6gf = models.regnet_x_1_6gf()
#regnet_x_3_2gf = models.regnet_x_3_2gf()
#regnet_x_8gf = models.regnet_x_8gf()
#regnet_x_16gf = models.regnet_x_16gf()
#regnet_x_32gf = models.regnet_x_32gf()

（4）模型显示

print(alexnet)

AlexNet(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(inplace=True)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(inplace=True)
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(inplace=True)
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(inplace=True)
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
  (classifier): Sequential(
    (0): Dropout(p=0.5, inplace=False)
    (1): Linear(in_features=9216, out_features=4096, bias=True)
    (2): ReLU(inplace=True)
    (3): Dropout(p=0.5, inplace=False)
    (4): Linear(in_features=4096, out_features=4096, bias=True)
    (5): ReLU(inplace=True)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

print(vgg16)

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

4.4 使用预预训练好的模型

（1）概述

我们可以使用 PyTorch 提供的预训练好的模型，通过简单的传递参数给构造函数即可：pretrained=True，如下所示：

当指定了pretrained=True时，构造函数会自动从远程下载预先训练好的模型，即模型的权重值。

每个训练好模型的下载时间与模型权重的大小有关。

预训练好的模型，是由PyTorch torch.utils.model_zoo （模型公园）提供的。

（2）下载模型的存放目录

下载的模型，存放到本机cache目录中，如：C:\Users\Administrator/.cache\torch\hub\checkpoints\alexnet-owt-4df8aa71.pth

也可以通过环境变量：TORCH_MODEL_ZOO指定存放模型的根目录。

详细参考：. torch.utils.model_zoo.load_url()

（3）代码示例

import torchvision.models as models

vgg16 = models.vgg16(pretrained=True)

Downloading: "https://download.pytorch.org/models/vgg16-397923af.pth" to C:\Users\Administrator/.cache\torch\hub\checkpoints\vgg16-397923af.pth
0.1%

（4）部分预训练模型默认的下载地址（从代码中提取）

#Alexnet:
 
model_urls = {
    'alexnet': 'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth',
}

#vggnet:
 
model_urls = {
    'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
    'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
    'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
    'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
    'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
    'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
    'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
    'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth',
}


#Resnet:
 
model_urls = {
    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
}
 
#inception:
 
model_urls = {
    # Inception v3 ported from TensorFlow
    'inception_v3_google': 'https://download.pytorch.org/models/inception_v3_google-1a9a5a14.pth',
}
 

#Densenet:
 
model_urls = {
    'densenet121': 'https://download.pytorch.org/models/densenet121-a639ec97.pth',
    'densenet169': 'https://download.pytorch.org/models/densenet169-b2777c0a.pth',
    'densenet201': 'https://download.pytorch.org/models/densenet201-c1103571.pth',
    'densenet161': 'https://download.pytorch.org/models/densenet161-8d451a50.pth',
}

通过这些地址，程序员可以手工下载。

第5章 torchvision.transforms 图形预处理简介

5.1 简介

torchvision.transforms — Torchvision 0.11.0 documentation

torchvision.transforms是pytorch中的图像预处理包，包含了很多种对图像数据进行变换的函数，这些都是在我们进行图像数据读入步骤中必不可少的。

5.2 常见的预处理

torchvision.transforms.Normalize(mean, std)：

用给定的均值和标准差分别对每个通道的数据进行正则化。

具体来说，给定均值(M1,…,Mn)，给定标准差(S1,…,Sn)，其中n是通道数（一般是3），对每个通道进行如下操作：
output[channel] = (input[channel] - mean[channel]) / std[channel]

比如：原来的tensor是三个维度的，值在[0,1]之间，经过变换之后就到了[-1，1]
计算如下：(（0,1）-0.5）/0.5=(-1,1)

torchvision.transforms.ToTensor ：

把一个取值范围是[0,255]的PIL.Image或者shape为(H,W,C)的numpy.ndarray，转换成形状为[C,H,W]，取值范围是[0,1.0]的torch.FloadTensor

torchvision.transforms.ToPILImage：

将shape为(C,H,W)的Tensor或shape为(H,W,C)的numpy.ndarray转换成PIL.Image，值不变。

PIL(Python Image Library)是PythonWare公司提供了免费的图像处理工具包。

该软件包提供了基本的图像处理功能，如：改变图像大小，旋转图像，图像格式转换，色场空间转换，图像增强，直方图处理，插值和滤波等等。

在PIL中，任何一副图像都是用一个Image对象（不是Pytorch Tensor）表示，而这个类由和它同名的模块导出，因此，要加载一副图像，最简单的形式是这样的：

import Image
img = Image.open(“dip.jpg”)

torchvision.transforms.CenterCrop(size)

将给定的PIL.Image进行中心切割，得到给定的size，size可以是tuple，(target_height, target_width)。size也可以是一个Integer，在这种情况下，切出来的图片的形状是正方形。

torchvision.transforms.RandomCrop(size, padding=0)

切割中心点的位置随机选取。size可以是tuple也可以是Integer。

torchvision.transforms.RandomHorizontalFlip

随机水平翻转给定的PIL.Image,概率为0.5。即：一半的概率翻转，一半的概率不翻转。

torchvision.transforms.RandomSizedCrop(size, interpolation=2)

先将给定的PIL.Image随机切，然后再resize成给定的size大小。

torchvision.transforms.Pad(padding, fill=0)

将给定的PIL.Image的所有边用给定的pad value填充。 padding：要填充多少像素 fill：用什么值填充

其他

5.3 预处理的组合：torchvision.transforms

大多数，我们需要多图片进行多种预处理，这时候就需要用到torchvision.transforms。

torchvision.transforms是pytorch中的图像预处理包，可以把多种对图像数据进行变换的函数进行串联起来，这在我们进行图像数据读入步骤中，一个非常有用的工具。

data_transforms = transforms.Compose([
        transforms.RandomResizedCrop(224),   # 调整尺寸, 或增加或裁剪
        transforms.RandomHorizontalFlip(),   # 翻转
        transforms.ToTensor(),               # 转换成tensor
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) #正则化
    ])

ransforms.Compose(transforms) 方法是将多种变换组合在一起。

上述对data_transforms进行了五种变换：

先对其进行随机大小和随机宽高比的裁剪，
之后resize到指定大小224，
以及对原始图像进行随机的水平翻转；
转换成pytorch的Tensor
正则化

第6章 torchvision.utils简介

6.1 概述

torchvision.utils — Torchvision 0.11.0 documentation

torchvision.utils提供了大量的对图像数据的处理工具，包括制作图像网格、图像保存以及图像外框绘制等。

6.2 在线下载模型的预训练参数

torch.utils.model_zoo — PyTorch 1.10.0 documentationhttps://pytorch.org/docs/stable/model_zoo.html#torch.utils.model_zoo.load_url

代码示例：

state_dict = torch.hub.load_state_dict_from_url('https://s3.amazonaws.com/pytorch/models/resnet18-5c106cde.pth')

作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客

本文网址：https://blog.csdn.net/HiWangWenBing/article/details/121149809