【笔记】PyTorch快速入门：数据准备工作

PyTorch快速入门

Tensors

Tensors贯穿PyTorch始终

和多维数组很相似，一个特点是可以硬件加速

Tensors的初始化

有很多方式

• 直接给值

  data = [[1,2],[3,4]]
  x_data = torch.tensor(data)
  

• 从NumPy数组转来

  np_arr = np.array(data)
  x_np = torch.from_numpy(np_array)
  

• 从另一个Tensor

  x_ones = torch.ones_like(x_data)
  

• 赋01或随机值

  shape = (2,3,)
  rand_tensor = torch.rand(shape)
  ones_tensor = torch.ones(shape)
  zeros_tensor = torch.zeros(shape)
  

Tensors的属性

tensor = torch.rand(3,4)
print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")

shape维度，dtype元素类型，device运行设备(cpu/gpu)

Tensors的操作

使用GPU的方法

if torch.cuda_is_available():
  tensor = tensor.to("cuda")

各种操作

• 索引和切片

  tensor = torch.ones(4,4)
  print(tensor[0]) 		#第一行（0开始）
  print(tensor[;,0])		#第一列（0开始）
  print(tensor[...,-1])		#最后一列
  

• 连接

  t1 = torch.cat([tensor,tensor],dim=1)
  #沿着第一维的方向拼接
  

• 矩阵乘法

  三种办法，类似于运算符重载、成员函数和非成员函数

  y1 = tensor @ tensor
  y2 = tensor.matmul(tensor.T)
  y3 = torch.rand_like(tensor)
  torch.matmul(tensor,tensor.T,out=y3)
  

• 点乘

  类似，也是三种办法

  z1 = tensor * tensor
  z2 = tensor.mul(tensor)
  z3 = torch.rand_like(tensor)
  torch.mul(tensor,tensor,out=z3)
  

• 单元素tensor求值

  agg = tensor.sum()
  agg_item = agg.item()
  print(agg_item,type(agg_item))
  

• In-place 操作

  就是会改变成员内容的成员函数，以下划线结尾

  tensor.add_(5) #每个元素都+5
  

  节约内存，但是会丢失计算前的值，不推荐使用。

和NumPy的联系

• Tensor转NumPy数组

  t = torch.ones(5)
  n = t.numpy()
  

  注意，这个写法类似引用，没有新建内存，二者修改同步

• NumPy数组转tensor

  n = np.ones(5)
  t = torch.from_numpy(n)
  

  同样是引用，一个的修改会对另一个有影响

数据集和数据加载器

处理数据的代码通常很杂乱，难以维护，我们希望这部分代码和主代码分离。

加载数据集

以FasnionMNIST为例，我们需要四个参数

• root是路径

• Train区分训练集还是测试集

• download表示如果root找不到，就从网上下载

• transform表明数据的转换方式

import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plt

training_data = datasets.FansionMNIST(
	root = "data",
  train = True,
  download = True,
  transform = ToTensor()
)

test_data = datasets.FansionMNIST(
	root = "data",
  train = False,
  download = True,
  transform = ToTensor()
)

标号和可视化

labels_map = {
    0: "T-Shirt",
    1: "Trouser",
    2: "Pullover",
    3: "Dress",
    4: "Coat",
    5: "Sandal",
    6: "Shirt",
    7: "Sneaker",
    8: "Bag",
    9: "Ankle Boot",
}
figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
    sample_idx = torch.randint(len(training_data), size=(1,)).item()
    img, label = training_data[sample_idx]
    figure.add_subplot(rows, cols, i)
    plt.title(labels_map[label])
    plt.axis("off")
    plt.imshow(img.squeeze(), cmap="gray")
plt.show()

自己创建数据集类

必须实现三个函数__init__,__len__,__getitem__

import os
import pandas as pd
from torchvision.io import read_image

class CustomImageDataset(Dataset):
    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
        self.img_labels = pd.read_csv(annotations_file)
        self.img_dir = img_dir
        self.transform = transform
        self.target_transform = target_transform

    def __len__(self):
        return len(self.img_labels)

    def __getitem__(self, idx):
        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
        image = read_image(img_path)
        label = self.img_labels.iloc[idx, 1]
        if self.transform:
            image = self.transform(image)
        if self.target_transform:
            label = self.target_transform(label)
        return image, label

__init__类似于构造函数

__len__求数据个数

__getitem__按下标找数据和标签，类似重载[]

用DataLoaders准备数据用于训练

DataLoaders主要做3件事，将数据划分为小batches，随机打乱数据，和多核处理。

from torch.utils.data import DataLoader
train_dataloader = DataLoader(training_data,batch_size = 64,shuffle=True)
test_dataloader = DataLoader(test_data,batch_size = 64,shuffle=True)

用DataLoader进行迭代训练

# 展示图像和标签
train_features, train_labels = next(iter(train_dataloader))
print(f"Feature batch shape: {train_features.size()}")
print(f"Labels batch shape: {train_labels.size()}")
img = train_features[0].squeeze()
label = train_labels[0]
plt.imshow(img, cmap="gray")
plt.show()
print(f"Label: {label}")

Transforms

让数据变形成需要的形式

transform指定feature的变形

target_transform指定标签的变形

比如，需要数据从PIL Image变成Tensors，标签从整数变成one-hot encoded tensors

import torch
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda

ds = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
    target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))
)

这里用了两个技术，ToTensor()和Lambda表达式

ToTensor()将PIL images或者NumPy数组转化成FloatTensor，每个像素的灰度转化到[0,1]范围内

Lambda类似C++里的Lambda表达式，我们需要将整数转化为 one-hot encoded tensor，就先创建一个长度为数据标签类型的全0的Tensor，然后用scatter_()把第y个值改为1。注意到，scatter的index接受的参数也是Tensor，可见Tensor的广泛使用。