Introduction to PyTorch

What are Tensors?

import torch
import numpy as np

# 初始化一个tensor
# data = [[1, 2, 3], [4, 5, 6]]
# print(data)
# x_data = torch.tensor(data) #使用torch.tensor(list)进行初始化为张量tensor
# print(x_data)


# 从numpy转化为tensor
# np_array = np.array(data)
# print(np_array)
# x_np = torch.from_numpy(np_array) #可以直接将numpy型数组初始化为tensor,使用torch.from_numpy()
# print(x_np)


# 传入现有tensor，传出新的tensor
# x_ones = torch.ones_like(x_data) #使用torch.ones_like(tensor)来创建一个所有元素都为1的tensor
# print(x_ones)
# x_rand = torch.rand_like(x_data, dtype = torch.float)#使用torch.rand_like(tensor,dtype=torch.float)创建所有元素为随机的tensor
# print(x_rand)


# 上述为传入tensor来创建相应tensor,下面为直接通过shape创建相应tensor
# shape = (2, 3)
# rand_tensor = torch.rand(shape)
# ones_tensor = torch.ones(shape)
# zeros_tensor = torch.zeros(shape)
# print(f"Random Tensor:\n{rand_tensor}\n")
# print(f"Ones Tensor:\n {ones_tensor} \n")
# print(f"Zeros Tensor:\n{zeros_tensor} \n")


# Tensor的属性
# tensor = torch.rand(3, 4)
# print(tensor.shape)
# print(tensor.dtype)
# print(tensor.device)


# Tensor的操作
'''
有超过100个张量操作，包括算术，线性代数，矩阵操作(转置，索引，切片)。为了抽样和审查这里的全面描述。
这些操作都可以在GPU上运行(速度通常比CPU快)。
cpu最多16核。核心是进行实际计算的单位。每个核心按顺序处理任务(一次处理一个任务)。
GPU有1000个核心。GPU核心以并行处理的方式处理计算。任务被划分并在不同的核心中处理。这使得gpu在大多数情况下都比cpu快。gpu处理大数据比处理小数据更好。GPU通常用于图形或神经网络的高强度计算(我们将在稍后的神经网络单元中看到更多)。
PyTorch可以使用Nvidia CUDA库来利用

默认情况下，CPU上创建了张量。
张量也可以计算到GPU上——要做到这一点，你需要使用.to方法移动它们(在检查GPU可用性之后)。
请记住，跨设备复制大张量在时间和内存方面是非常昂贵的!
'''
# if torch.cuda.is_available():
#     tensor = tensor.to('cuda')
# print(torch.cuda.is_available())


# pytorch为类numpy的索引和切分
# tensor = torch.ones(4, 4)
# print('First row: ', tensor[0])
# print('First column: ', tensor[:, 0])
# print('Last column:', tensor[..., -1])
# tensor[:, 1] = 0
# print(tensor)


# 连接运算
'''
你可以用torch.cat()。将一个张量序列沿给定的维级联起来。torch.stack()是另一个张量连接选项，它与torch.cat略有不同
cat 对应 concatenate
'''
# tensor = torch.rand(5, 3)
# print(tensor)
# t1 = torch.cat([tensor,tensor,tensor], dim=1)#dim=1为横向
# t2 = torch.cat([tensor, tensor, tensor]) #默认dim为0，纵向
# t3 = torch.stack([tensor, tensor, tensor]) #比cat多一个维度
# print(t1)
# print(t2)
# print(t3)


# 算数运算
# 矩阵乘法(数学)
tensor = torch.tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])
# y1 = tensor @ tensor.T #tensor.T与tensor.t()一致，都是取tensor的转置
# y2 = tensor.matmul(tensor.T)
# y3 = torch.rand_like(tensor)
# torch.matmul(tensor, tensor.T, out = y3)
# print(y1)
# print(y2)
# print(y3)#y1 y2 y3结果一致
# 矩阵点乘
# z1 = tensor * tensor
# z2 = tensor.mul(tensor)
# z3 = torch.rand_like(tensor)
# torch.mul(tensor, tensor, out = z3)
# print(z1)
# print(z2)
# print(z3)


#单元素张量
'''
如果你有一个单元素张量，例如，通过将一个张量的所有值聚合为一个值，你可以使用item()将其转换为一个Python数值:
'''
# n维数组，需要n次sum()方可变成单个数值
# agg = tensor.sum()
# print(agg)
# agg_item = agg.item()
# print(agg_item, type(agg_item))

#原地操作
'''注意:就地操作可以节省一些内存，但在计算导数时可能会出现问题，因为会立即丢失历史记录。因此，不鼓励使用它们。
'''
# print(tensor, '\n')
# tensor.add_(5)
# print(tensor)


# # 与NumPy桥接 torch与ndarray共享内存空间
# t = torch.ones(5)
# print(f"t: {t}")
# n = t.numpy()
# print(f"n: {n}")
# # t2 = n.torch()    # 报错
# # print(f"t2: {t2}")# 报错 numpy没有torch对象   torch有numpy对象
# # 张量的变化反映在NumPy数组中。
# t.add_(1)
# print(f"t: {t}")
# print(f"t: {n}")
#numpy的ndarray转化为tensor
# n = np.ones(5)
# t = torch.from_numpy(n)     # np = tensor.numpy(ndarray)   tensor = torch.from_numpy()

Loading and normalizing datasets

'''
# 数据集和数据装载器
'''
处理数据样本的代码可能会变得混乱，难以维护;理想情况下，我们希望数据集代码与模型训练代码解耦，以获得更好的可读性和模块化。
PyTorch提供了两个数据原语:torch.utils.data.DataLoader和torch.utils.data.Dataset，它们允许你使用预加载的数据集以及你自己的数据。
Dataset存储示例及其对应的标签，而DataLoader将一个可迭代对象封装在Dataset周围，以便方便地访问示例。
'''
'''
PyTorch域库提供了许多预加载的示例数据集(如FashionMNIST)，它们子类化torch.utils.data.Dataset并实现特定于特定数据的函数。
你可以在这里找到并使用它们作为原型和基准测试的样本:
图像数据集
文本数据集
音频数据集
'''
# 什么是TorchVision? 答：Torchvision是一个与PyTorch相关联的计算机视觉库
# 它有有效的图像和视频转换工具，一些常用的预训练模型，和一些数据集(torchvision不与PyTorch绑定，你必须单独安装它)。
# 我们将从TorchVision加载Fashion-MNIST数据集。fashionmnist是一个由Zalando的文章图片组成的数据集，包含60,000个训练示例和10,000个测试示例。每个示例包含一个28×28灰度图像和一个来自10个类中的一个的关联标签。
'''
每幅图像高28像素，宽28像素，共784像素
这10个类告诉它是什么类型的图像。例如:t恤/上衣，裤子，套衫，连衣裙，包，踝靴等。
灰度值是0到255之间的值，用于度量黑白图像的强度。强度值从白到黑递增。例如:白色将是0，而黑色将是255
'''
'''
我们用以下参数加载FashionMNIST数据集:
root是存储训练/测试数据的路径，train指定训练或测试数据集，download=True如果在root不可用，则从Internet下载数据。
Transform和target_transform指定特性和标签转换
'''
# 装载一个数据集
import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda
import matplotlib.pyplot as plt

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

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


# 迭代和可视化数据集
'''
我们可以像列表一样手动索引数据集:training_data[index]。
我们使用matplotlib对训练数据中的一些样本进行可视化。
'''
# 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()# 在60000个训练集中随机取一个坐标
#     img, label = training_data[sample_idx] #  训练集中自带两个参数，一个是28x28的数组 一个是label值
#     figure.add_subplot(rows, cols, i) # 在一个画布中添加子图
#     plt.title(labels_map[label]) # 按照数据集的规则的labels_map中，用相应的label值取出具体标签
#     plt.axis("off") # 是否开启每张图片的横纵坐标
#     plt.imshow(img.squeeze(), cmap="gray")# imshow将数组以图片的形式展示出来，cmap为colormap(颜色图谱)
# plt.show()
'''
补充cmap参数：
autumn 红-橙-黄
bone 黑-白，x线
cool 青-洋红
copper 黑-铜
flag 红-白-蓝-黑
gray 黑-白
hot 黑-红-黄-白
hsv hsv颜色空间， 红-黄-绿-青-蓝-洋红-红
inferno 黑-红-黄
jet 蓝-青-黄-红
magma 黑-红-白
pink 黑-粉-白
plasma 绿-红-黄
prism 红-黄-绿-蓝-紫-...-绿模式
spring 洋红-黄
summer 绿-黄
viridis 蓝-绿-黄
winter 蓝-绿
'''


# 为使用dataloader进行培训准备数据
'''
数据集每次检索数据集的特征并标记一个样本。
在训练模型时，我们通常希望“小批量”地传递样本，在每个时期重新洗洗数据以减少模型过拟合，并使用Python的多处理来加速数据检索。
在机器学习中，你需要指定数据集中的特征和标签是什么。特性是输入，标签是输出。我们训练使用特征和训练模型来预测标签。

DataLoader是一个可迭代对象，它用一个简单的API为我们抽象了这种复杂性。使用Dataloader时，需要设置以下参数:
数据:用于训练模型的训练数据;
并利用测试数据评价模型的批大小，
将每批中需要处理的记录数按指标打乱数据的随机样本
'''
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(分别包含batch_size=64个feature和label)。
因为我们指定了shuffle=True，所以在遍历所有批次后，数据将被shuffle(用于对数据加载顺序的细粒度控制)。
'''
# Display image and label.
train_features, train_labels = next(iter(train_dataloader))# iter(dataloader迭代对象)返回下一个迭代对象本身(非索引)
print(f"Feature batch shape: {train_features.size()}")# [64,1,28,28]为64个三维数组([1,28,28])
print(f"Labels batch shape: {train_labels.size()}")# [64]
img = train_features[0].squeeze() # 将train_features的 第一个 图片降一维度 [1,28,28]->[28,28]
# print(img) # 在取数据的时候已经toTensor()了，标准化为[0,1]间数值
label = train_labels[0]
plt.imshow(img, cmap="gray")
plt.show()
print(f"Label: {label}")


# 标准化
'''
归一化是一种常见的数据预处理技术，用于对数据进行缩放或转换，以确保每个特征具有同等的学习贡献。
例如，灰度图像中的每个像素都有一个介于0到255之间的值，这就是特征。
如果一个像素值为17，另一个像素值为197。像素重要性分布会不均匀，因为像素体积越大，学习就会偏离。
规范化改变了数据的范围，而不会扭曲数据与特征之间的区别。这种预处理是为了避免:
预测精度的降低
模型学习难度大
特征数据范围分布不利
'''


# transforms
'''
数据并不总是以训练机器学习算法所需的最终处理形式出现。
我们使用转换来执行数据的一些操作，使其适合于训练。
所有的TorchVision数据集都有两个参数(transform用于修改特性，target_transform用于修改标签)，它们接受包含转换逻辑的可调用对象。
torchvision.Transforms模块提供了几种常用的开箱即用的转换。

FashionMNIST功能是PIL Image（Python Image Library）格式，标签是整数。
对于训练，我们需要特征作为归一化张量，标签作为一热编码张量。
为了做这些变换，我们用to张量和。
'''
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda

ds = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),# toTensor()将PIL图像或NumPy ndarray转换为FloatTensor，并在[0, 1]范围内缩放图像的像素强度值.
    target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))
)
# tensor.scatter(dim, index, src) 在tensor基础上，按照dim方向(默认为0)，按照index坐标将src中的元素移入tensor相应位置中
'''
Lambda转换应用任何用户定义的Lambda函数。
在这里，我们定义了一个函数来将整数转换为一个单热编码张量。
它首先创建一个大小为10的零张量(数据集中标签的数量)，然后调用scatter函数，该函数在索引y上赋值为1。
你也可以使用torch.nn.functional.One_hot作为另一个选项。
'''
'''
A DataSet is designed for retrieval of individual data items while a DataLoader is designed to work with batches of data.
'''