Pytorch基础

DataSet

from torch.utils.data import Dataset
from PIL import Image
import os

class MyData(Dataset):
    def __init__(self,train_dir,label_dir):
        self.train_dir=train_dir
        self.label_dir=label_dir
        self.train_path=os.listdir(self.train_dir)
        self.label_path=os.listdir(self.label_dir)
    
    def __getitem__(self,idx):
        img_name=self.train_path[idx]
        img_path=os.path.join(self.train_dir,img_name)
        img=Image.open(img_path)
        label_name=self.label_path[idx]
        label_path=os.path.join(label_dir,label_name)
        with open(label_path,'r') as f:
            label=f.read()
        return img,label
    
    def __len__(self):
        return len(self.train_path)

torchvision

import torchvision

train_set = torchvision.datasets.CIFAR10(root="./dataset",train=True,download=True)
test_set=torchvision.datasets.CIFAR10(root="./dataset",train=False,download=True)
print(train_set[0])
img,label=train_set[0]

nn.Module

import torch
from torch import nn

class Module(nn.Module):
    def __init__(self):
        super().__init__()

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

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

卷积

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

dataset=torchvision.datasets.CIFAR10("../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader=DataLoader(dataset,batch_size=64)

class Module(nn.Module):
    def __init__(self):
        super(Module,self).__init__()
        self.conv1=Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)

    def forward(self,x):
        x=self.conv1(x)
        return x

module=Module()
step=1
writer = SummaryWriter("./logs")
for data in dataloader:
    imgs,targets=data
    output=module(imgs)
    # torch.Size([64,3,32,32])
    writer.add_images("input",imgs,step)
    # torch.Size([64,3,32,32]) -> [xxx,3,30,30]

    output=torch.reshape(output,(-1,3,30,30))
    writer.add_images("output",output,step)
    step=step+1

最大池化

import torch
from torch import nn
from torch.nn import MaxPool2d

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]],dtype=torch.float)
input=torch.reshape(input,(-1,1,5,5))

class Module(nn.Module):
    def __init__(self):
        super(Module,self).__init__()
        self.maxpool1=MaxPool2d(kernel_size=3,ceil_mode=True)

    def forward(self,input):
        output=self.maxpool1(input)
        return output

module=Module()
output=module(input)
print(output)

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

dataset=torchvision.datasets.CIFAR10("../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader=DataLoader(dataset,batch_size=64)

class Module(nn.Module):
    def __init__(self):
        super(Module,self).__init__()
        self.maxpool1=MaxPool2d(kernel_size=3,ceil_mode=False)
    def forward(self,input):
        output=self.maxpool1(input)
        return output

module=Module()
writer=SummaryWriter("./logs_maxpool")
step=0
for data in dataloader:
    imgs,targets=data
    writer.add_images("input",imgs,step)
    output=module(imgs)
    writer.add_images("output",output,step)
    step=step+1

非线性激活

ReLU Sigmoid

import torch
from torch import nn
from torch.nn import ReLU

input=torch.tensor([[1,-0.5],
                    [-1,3]])
input=torch.reshape(input,(-1,1,2,2))

class Module(nn.Module):
    def __init__(self):
        super(Module,self).__init__()
        self.relu1=ReLU()
        # self.sigmoid=Sigmoid()
    def forward(self,input):
        output=self.relu1(input)
        return output

module=Module()
output=module(input)
print(output)

实战：Sequential

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.tensorboard import SummaryWriter


class Module(nn.Module):
    def __init__(self):
        super(Module,self).__init__()
        self.conv1=Conv2d(3,32,5,padding=2)
        self.maxpool1=MaxPool2d(2)
        self.conv2=Conv2d(32,32,5,padding=2)
        self.maxpool2=MaxPool2d(2)
        self.conv3=Conv2d(32,64,5,padding=2)
        self.maxpool3=MaxPool2d(2)
        self.flatten=Flatten()
        self.Linear1=Linear(1024,64)
        self.Linear2=Linear(64,10)
    def forward(self,x):
        x=self.conv1(x)
        x=self.maxpool1(x)
        x=self.conv2(x)
        x=self.maxpool2(x)
        x=self.conv3(x)
        x=self.maxpool3(x)
        x=self.flatten(x)
        x=self.Linear1(x)
        x=self.Linear2(x)
        return x

module=Module()
print(module)
input = torch.ones(64,3,32,32)
output=module(input)
print(output.shape)
writer=SummaryWriter("./logs_Seq")
writer.add_graph(module,input)
writer.close()

class Module(nn.Module):
    def __init__(self):
        super(Module,self).__init__()
        self.module1=Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )
    def forward(self,x):
        x=self.module1(x)
        return x

Loss

L1Loss MSELoss

import torch
from torch.nn import L1Loss

inputs=torch.tensor([1,2,3],dtype=torch.float)
targets=torch.tensor([1,2,5],dtype=torch.float)

inputs=torch.reshape(inputs,(1,1,1,3))
targets=torch.reshape(targets,(1,1,1,3))

# reduction="mean"/"sum"
loss=L1Loss()
result=loss(inputs,targets)

print(result)