【小土堆】Pytorch学习日记

Pytorch & cuda

import torch

torch.cuda.is_available()

dir(torch)

help(torch.relu)

tensorboard

from torch.utils.tensorboard import SummaryWriter
from PIL import  Image
import numpy as np
writer = SummaryWriter('logs')

img_PIL=Image.open("F:\\bp.jpg")
img=np.array(img_PIL)

writer.add_image('bp',img,2,dataformats='HWC')

writer.close()

transforms

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
import cv2

img=Image.open('images/nan.jpg')


 cv_img=cv2.imread(img)

writer=SummaryWriter('logs')

tensor_transform=transforms.ToTensor()
tensor_img=tensor_transform(img)

writer.add_image('nan',tensor_img,1)
writer.close()

from PIL import Image
from torchvision import transforms
from torch.utils.tensorboard import SummaryWriter

img=Image.open('images/nan.jpg')

trans_tensor=transforms.ToTensor()
trans_img=trans_tensor(img)

trans_norm=transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
trans_norm_img=trans_norm(trans_img)



writer=SummaryWriter('logs')
writer.add_image('yunan',trans_norm_img,1)
writer.close()

Data

dataset

Dataset 类是 PyTorch 中 torch.utils.data.dataset 模块的一个抽象类，它用于定义一个数据集的基本结构。在深度学习项目中，数据集通常包含大量的样本数据，这些数据需要以特定的方式组织和加载，以便于模型训练或验证。Dataset 类为开发者提供了一个接口，使其能够自定义数据集的加载逻辑。

以下是 Dataset 类的主要要点解释：

1. 抽象类：Dataset 是一个抽象类，这意味着它不能直接实例化，需要通过继承并覆盖其抽象方法来创建具体的数据集类。
2. 方法要求：
   ○ getitem(self, index): 必须由子类重写的方法，它接受一个索引（index）作为输入，返回数据集中对应索引位置的样本。这里的索引可以是整数，也可以是任意类型的键，具体取决于数据集的设计。
   ○ len(self): 可选重写的方法，返回数据集的大小。很多 Sampler 和 DataLoader 会用到这个方法来决定数据加载的范围。
3. 自定义Sampler：如果数据集的索引是非整数型，例如使用字符串或其他类型的键作为索引，那么需要提供一个自定义的 Sampler 来配合 DataLoader 正确地加载数据。
4. 其他方法：
   ○ add(self, other): 返回两个数据集的串联（Concatenation），即一个新的数据集，包含两个数据集的所有样本。
   ○ getattr(self, attribute_name): 提供了一种方式来获取数据集对象的属性。
5. Class methods：
   ○ register_datapipe_as_function() 和 register_function() 方法看起来用于注册特定的功能或数据管道，这些方法通常用于扩展或定制数据集的行为。
6. Data descriptors：
   ○ dict 和 weakref 是 Python 内置的描述符，分别用于存储实例变量和弱引用列表。
7. Generic Type Information：
   Dataset 类采用了 Python 的类型提示（Typing），其中 Dataset[T_co] 表示 Dataset 是一个泛型类，T_co 表示类型变量，代表数据集元素的数据类型，这里的 _co 后缀表示类型变量是协变的（covariant）。这意味着子类可以使用与父类相同或更具体的类型。

总之，torch.utils.data.Dataset 类为开发者提供了一个构建自定义数据集的基础框架，使得数据加载和处理过程更加灵活和模块化。通过继承并实现必要的方法，开发者可以轻松构建适合自己数据集的数据加载器。

dataloader

import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

train_data=torchvision.datasets.CIFAR10(root='./dataset',train=True,transform=torchvision.transforms.ToTensor(),download=True)
test_data=torchvision.datasets.CIFAR10(root='./dataset',train=False,transform=torchvision.transforms.ToTensor(),download=True)

test_loader=DataLoader(test_data,batch_size=64,shuffle=True,num_workers=0,drop_last=False)

img,target=test_data[0]
# print(img.shape,target)
# print(test_loader)
step=0

writer=SummaryWriter('dataloader_logs')
for data in test_loader:
    imgs,targets=data
    writer.add_images('test_dataloader1',imgs,step)
    step+=1
writer.close()

神经网络（neural network）

learn_nn_module

import torch
from torch import nn
class Module(nn.Module):
    def __init__(self) -> None:
        super().__init__()

    def forward(self,input):
        output=input+1
        return output

yu=Module()
x=torch.tensor(1.0)
output=yu(x)
print((output))

这段代码是基于PyTorch库创建了一个简单的神经网络模块。具体解释如下：

1. 首先，通过import torch导入PyTorch库，它是Python中用于构建和训练神经网络的主要库。
2. from torch import nn 导入PyTorch的神经网络模块（nn），这个模块包含了大量构建和操作神经网络所需的类和功能。
3. 定义了一个名为Module的类，继承自nn.Module。在PyTorch中，所有神经网络模型都需要继承自nn.Module，因为它提供了模型的基本结构和方法，如参数初始化、前向传播（forward pass）等。

class Module(nn.Module):
    def __init__(self) -> None:
        super().__init__()

这里的__init__方法是类的构造函数，super().init()用于调用父类（在这里是nn.Module）的构造函数进行必要的初始化。

4. 定义了forward方法，这是神经网络模型中执行前向传播的核心部分。在这个例子中，forward方法非常简单，仅仅是将输入input加1然后返回结果。

 def forward(self, input):
        output = input + 1
        return output

5. 创建Module类的实例yu。

yu = Module()

6. 创建一个PyTorch张量x，赋值为1.0。

x = torch.tensor(1.0)

7. 将张量x作为输入传递给yu实例，并执行前向传播计算。

output = yu(x)

8. 输出经过Module处理后的结果。由于我们的forward函数只是简单地将输入加1，所以输出将是2.0。

print(output)

总结起来，这段代码实现了一个极其简单的神经网络模块，它的功能相当于一个恒等映射加上1的操作。在实际应用中，forward函数通常会包含更复杂的数学运算和层叠的神经网络层。

learn_nn_conv

import torch
import torch.nn.functional as F
input = 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]])
input = torch.reshape(input, (1, 1, 5, 5))
kernel = torch.reshape(kernel, (1, 1, 3, 3))

output=F.conv2d(input,kernel,stride=1)
print(output)

output2=F.conv2d(input,kernel,stride=2)
print((output2))

output3=F.conv2d(input,kernel,stride=1,padding=1)
print(output3)