deep_thoughts

1.tensor

tensor就是一个n维的数组。

import torch
import  numpy as np
data = [[1, 2],[3, 4]]
print(type(data))#<class 'list'>
x_data = torch.tensor(data)
print(type(x_data))#<class 'torch.Tensor'>
print(x_data.dtype)#torch.int64
np_array = np.array(data)
x_np = torch.from_numpy(np_array)#将np数组转换成为tensor张量
x_ones = torch.ones_like(x_data)#张量结构和x_data相同，但是里面的元素全部变成了0
x_rand = torch.rand_like(x_data, dtype=torch.float)#张量结构和x_data相同，但是里面的元素全部变成了随机数
rand_tensor = torch.rand((3,3))#()表示的是元组 (tuple),元组是一个不可变的有序数据集合，可以使用索引来访问元素，但不能修改元素。
print(rand_tensor)
rand_tensor = torch.rand([4,4])#[]表示的是列表 (list),列表是一个有序的数据集合，可以使用索引来访问元素，并且可以修改列表中的元素。
print(rand_tensor)
#但是torch.rand函数中不可以使用{}集合来表示shape传递参数.集合 (set) 是一个无序的不重复数据集合，不能使用索引来访问元素，并且可以进行集合运算（并集，交集等）


tensor = torch.rand(3,4)
print(f"Shape of tensor: {tensor.shape}")#Shape of tensor: torch.Size([3, 4])
print(f"Datatype of tensor: {tensor.dtype}")#Datatype of tensor: torch.float32
print(f"Device tensor is stored on: {tensor.device}")#Device tensor is stored on: cpu.看张量是在哪个设备上创建的
if torch.cuda.is_available():
    tensor = tensor.to("cuda")#如果安装了cuda环境，将张量移动到gpu上去执行。

torch.set_default_dtype(torch.float64)#将张量的元素类型设置为64为浮点型
torch.arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) 
torch.arange(1, 2.5, 0.5)#tensor([ 1.0000,  1.5000,  2.0000])#区间是左闭右开
torch.range(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
torch.range(1, 4)#tensor([ 1.,  2.,  3.,  4.])去见识左闭右闭
torch.eye(3)#创建2维的张量并且对角线是1
#tensor([[ 1.,  0.,  0.],
        [ 0.,  1.,  0.],
        [ 0.,  0.,  1.]])
torch.full(size, fill_value）#Creates a tensor of size size filled with fill_value.
torch.full((2, 3), 3.141592)
#tensor([[ 3.1416,  3.1416,  3.1416],
        [ 3.1416,  3.1416,  3.1416]])

torch.cat(tensors, dim=0, *, out=None)#张量的拼接
Example:
>>> x = torch.randn(2, 3)
>>> x
tensor([[ 0.6580, -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497]])
>>> torch.cat((x, x, x), 0)
tensor([[ 0.6580, -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497],
        [ 0.6580, -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497],
        [ 0.6580, -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497]])
>>> torch.cat((x, x, x), 1)
tensor([[ 0.6580, -1.0969, -0.4614,  0.6580, -1.0969, -0.4614,  0.6580,
         -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497, -0.1034, -0.5790,  0.1497, -0.1034,
         -0.5790,  0.1497]])

torch.chunk(input, chunks, dim=0) → List of Tensors#从dim维度将张量input分成chunks份

从dim=0维度来进行splite

从dim=1维度来进行splite

torch.gather(input, dim, index, *, sparse_grad=False, out=None) → Tensor
torch.reshape(input, shape) #shape中m和n的乘积要等于input的元素个数
>>> a = torch.arange(4.)
>>> torch.reshape(a, (2, 2))
tensor([[ 0.,  1.],
        [ 2.,  3.]])
>>> b = torch.tensor([[0, 1], [2, 3]])
>>> torch.reshape(b, (-1,))#如果reshape成为一维的，但不知道具体形状，也就是元素的个数，就用-1去代替。 
tensor([ 0,  1,  2,  3])

torch.split(tensor, split_size_or_sections, dim=0)
>>> a = torch.arange(10).reshape(5, 2)
>>> a
tensor([[0, 1],
        [2, 3],
        [4, 5],
        [6, 7],
        [8, 9]])
>>> torch.split(a, 2)//将a从dim=0的维度每2个划分一次
(tensor([[0, 1],
         [2, 3]]),
 tensor([[4, 5],
         [6, 7]]),
 tensor([[8, 9]]))
>>> torch.split(a, [1, 4])//将a从dim=0的维度按照列表进行划分成两个块，分别是1行和4行。
(tensor([[0, 1]]),
 tensor([[2, 3],
         [4, 5],
         [6, 7],
         [8, 9]]))

torch.squeeze(input, dim=None) → Tensor

将大小为1的维度直接移除掉，毕竟当某个维度的大小是1时，并没有新增额外的元素。

torch.stack(tensors, dim=0, *, out=None) → Tensor

cat是直接连起来，但是stack是堆叠起来，维度肯定是会扩充的。

 2.Dataset和DataLoader

自定义的dataset必须实现__init__, __len__, and __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):#transform是对image进行预处理，而target_transform是对标签进行预处理
        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):#基于一个索引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

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)