PyTorch语法

1.张量的创建

import torch
a=[1,2,3.]
print(type(a))

b=torch.tensor(a)
print(b)
print(type(b))
print(b.dtype)

import numpy as np
c=np.random.normal((2,3))
d=torch.tensor(c)
print(d)

e=torch.ones_like(d)
print(e)
f=torch.zeros_like(d)
print(f)
g=torch.rand_like(d)
print(g)

print(torch.rand((2,2)))
print(torch.randn([2,2]))
print(torch.rand([2,2,]).dtype)

h=torch.rand([2,2,])
print(h.dtype)
print(h.shape)
print(h.device)
print(torch.is_tensor(h))

i=torch.tensor(0)
print(torch.is_nonzero(i))
print('-'*34)
print(torch.numel(h))
print(torch.zeros([5,5]))
a=torch.zeros([5,5],dtype=torch.int32)
print(a)
print(torch.zeros([5,5]).dtype)
print(torch.ones_like(a))
print('-'*34)
print(torch.arange(5))
print(torch.arange(0,5,2))
print(torch.range(0,5))
print(torch.range(0,2).dtype)
print(torch.arange(0,5).dtype)
for i in torch.arange(5):
    print('epoch:',i)
print(torch.eye(3))
print(torch.ones_like(a)*5)
print(torch.full([2,2],2))
print(torch.full_like(a,2))

a=torch.rand([3,2,])
print(a)
b=torch.rand([3,2,])
print(b)
print(torch.cat([a,b],dim=0))

2.张量的运算API(1)

import torch
b=torch.rand([3,2])
print(b)
c,d=torch.chunk(b,chunks=2,dim=1)
print(c)
print(d)
print(torch.reshape(torch.reshape(b,[2,3]),[-1]))
print('-'*34)
src = torch.tensor([[1,2],
                    [3,4],
                    [5,6]])

index = torch.tensor([[0,2],
                      [1,0],
                      [2,1]])

'''out = torch.zeros_like(src)
out.scatter_(dim=0, index=index, src=src)
#src [i][j] 这个数，要搬到 out 的 第 index [i][j] 行、第 j 列
print(out)
'''
a=torch.arange(10).reshape(5,2)
#print(a)
#print(torch.split(a,[1,4]))

'''
print(a.shape)
print(torch.squeeze(torch.reshape(a,[1,1,5,2]),dim=0).shape)
'''
b=torch.rand(5,2)
print(torch.stack([a,b],dim=0).shape)    #torch.Size([2, 5, 2])
print(torch.stack([a,b],dim=1).shape)    #torch.Size([5, 2, 2])
print(torch.cat([a,b],dim=0).shape)      #torch.Size([10, 2])
print(torch.cat([a,b],dim=1).shape)     #torch.Size([5, 4])

3.张量的运算API(2)

import torch
a=torch.rand([3,2])
print(a)
#print(torch.take(a,torch.tensor([0,2,4])))
'''
print(torch.tile(a,dims=[1,2]))
print(torch.tile(a,dims=[2,1]))
'''
'''
print(torch.transpose(a,0,1))
print('-'*34)
print(torch.unbind(a,dim=0))
print(torch.unbind(a,dim=1))
print('-'*34)
print(torch.unsqueeze(a,dim=0).shape)
print(torch.unsqueeze(a,dim=1).shape)
print(torch.unsqueeze(a,dim=-1).shape)
'''
b=torch.zeros_like(a)
print(torch.where(a>0.5,a,b))

4.dataset的基本代码实现

from torch.utils.data import Dataset
from PIL import Image
import os
class MyDataset(Dataset):
    def __init__(self,root_dir,label_dir):
        self.root_dir=root_dir
        self.label_dir=label_dir
        self.path=os.path.join(self.root_dir,self.label_dir)
        self.img_path=os.listdir(self.path)


    def __getitem__(self,index):
       img_name=self.img_path[index]
       img_item_path=os.path.join(self.root_dir,self.label_dir,img_name)
       img=Image.open(img_item_path)
       label=self.label_dir
       return img,label

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

root_dir='dataset'
ants_label_dir='ants'
bees_label_dir='bees'
ants_dataset=MyDataset(root_dir,ants_label_dir)
bees_dataset=MyDataset(root_dir,bees_label_dir)

dataset=ants_dataset+bees_dataset

5.如何用 SummaryWriter 记录图像和标量

import numpy
numpy.bool8 = bool

from torch.utils.tensorboard import SummaryWriter
import numpy as np
from PIL import Image

writer=SummaryWriter('logs')
image_path='dataset/ants/0013035.jpg'
img_PIL=Image.open(image_path)
img_array=np.array(img_PIL)
print(type(img_array))
print(img_array.shape)

writer.add_image("test",img_array,1,dataformats='HWC')
#y=2x
for i in range(100):
    writer.add_scalar('y=2x', 2*i, i)

writer.close()

6.使用transforms.ToTensor()将PIL图像转换为Tensor

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
img_path="dataset/ants/0013035.jpg"
img_PIL=Image.open(img_path)

writer=SummaryWriter('logs')

#1.使用transforms.ToTensor()将PIL图像转换为Tensor
transform=transforms.ToTensor()
img_tensor=transform(img_PIL)

writer.add_image('Tensor_img',img_tensor)
writer.close()

7.transform的常见图像预处理操作

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

img=Image.open("dataset/1E6B8C5DB9722D99D028F39265867A60.png")
print(img)
writer=SummaryWriter('logs')

# ToTensor
trans_totensor=transforms.ToTensor()
img_tensor=trans_totensor(img)
writer.add_image('ToTensor',img_tensor)

# Normalize
'''
将输入张量 img_tensor 的每个通道减去均值 mean，再除以标准差 std。
公式：output = (input - mean) / std'''
print(img_tensor[0][0][0])
transform_norm=transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])
img_norm=transform_norm(img_tensor)
print(img_norm[0][0][0])
writer.add_image('Normalize',img_norm,2)

#Resize
print(img.size)
#将输入图像 img（PIL 格式）缩放到 512×512 像素，得到 img_resize（依然是 PIL 图像）
transform_resize=transforms.Resize((512,512))
#img.PIL->resize->img_resize PIL
img_resize=transform_resize(img)
#img_resize PIL->to_tensor->img_resize_tensor Tensor
img_resize=trans_totensor(img_resize)
writer.add_image('Resize',img_resize,0)
print(img_resize)

#Compose
#Resize(512) 表示将图像的短边缩放到 512 像素，长边等比例缩放（保持宽高比）。
transforms_resize_2=transforms.Resize(512)
#PIL->PIL->Tensor
transform_compose=transforms.Compose([transform_resize,trans_totensor])
#先执行 transform_resize（对输入图像做尺寸调整），再执行 trans_totensor（将 PIL 图像转为 PyTorch 张量）
img_resize_2=transform_compose(img)
writer.add_image('Compose',img_resize_2,1)

#RandomCrop
#从同一张原始图像中随机裁剪出 10 个不同的 256×256 子图，并将它们全部转换为 PyTorch 张量。
transform_randomcrop=transforms.RandomCrop(256)
trans_compose_2=transforms.Compose([transform_randomcrop,trans_totensor])
#组合两个操作：先随机裁剪，再将裁剪后的 PIL 图像转换为张量（形状 (C, 256, 256)，值域 [0,1]）
for i in range(10):
    img_crop=trans_compose_2(img)
    writer.add_image('RandomCrop',img_crop,i)

writer.close()

8.transform与dataset的结合

import torchvision
from torch.utils.tensorboard import SummaryWriter

dataset_transform=torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])
train_set=torchvision.datasets.CIFAR10(root='./data', train=True, transform=dataset_transform, download=True)
test_set=torchvision.datasets.CIFAR10(root='./data', train=False, transform=dataset_transform, download=True)
'''
print(train_set[0])
print(train_set.classes)

img,target=train_set[0]
print(img)
print(target)
print(train_set.classes[target])
img.show()
'''
#print(test_set[0])
writer=SummaryWriter('p10')
for i in range(10):
    img,target=test_set[i]
    writer.add_image('test_set',img,i)

writer.close()

9.dataloader

import torchvision

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


test_data=torchvision.datasets.CIFAR10(root="./data", train=False, transform=torchvision.transforms.ToTensor())

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

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

writer=SummaryWriter(log_dir="./dataloader")
for epoch in range(2):
    step=0
    for data in test_dataloader:
        imgs, targets=data
        #print(imgs.shape)
        #print(targets)

        writer.add_images("Epoch: {}".format(epoch), imgs, step)
        step+=1
writer.close()

10.神经网络的基本骨架

import torch
from torch import nn


class MyModule(nn.Module):
    def __init__(self):
        super().__init__()
    def forward(self,input):
        output=input+1
        return output

mynodule=MyModule()
x=torch.tensor(1.0)
y=mynodule(x)
print(y)

11.卷积操作

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))

print(input.shape)
print(kernel.shape)

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)

12.神经网络——卷积层

import  torch
import  torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from urllib3.filepost import writer

dataset=torchvision.datasets.CIFAR10("./data",train=False,transform=torchvision.transforms.ToTensor(),download=True)

dataloader=DataLoader(dataset,batch_size=64)

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1=torch.nn.Conv2d(3,6,kernel_size=3,stride=1,padding=0)
    def forward(self,x):
        x=self.conv1(x)
        return x

net=Net()

writer=SummaryWriter("logs")
step=0
for data in dataloader:
    imgs,targets=data
    output=net(imgs)
    print(imgs.shape)
    print(output.shape)
    #torch.Size([64, 3, 32, 32])
    writer.add_images("input",imgs,step)
    #torch.Size([64, 6, 30, 30])->torch.Size([xx, 3, 30, 30])
    
    output=torch.reshape(output,(-1,3,30,30))
    writer.add_images("output",output,step)
    
    step+=1

13.神经网络——最大池化

import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from urllib3.filepost import writer

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]
])
dataset=torchvision.datasets.CIFAR10("../data",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader=DataLoader(dataset,batch_size=64)


class MaxPool(torch.nn.Module):
    def __init__(self):
        super(MaxPool, self).__init__()
        self.pool=torch.nn.MaxPool2d(kernel_size=3,ceil_mode=False)
    def forward(self,x):
        x=self.pool(x)
        return x
model=MaxPool()
writer=SummaryWriter('logs')

step=0
for data in dataloader:
    imgs,targets=data
    writer.add_image("input",imgs,step)
    output=model(imgs)
    writer.add_image("output",output,step)
    step+=1
writer.close()

14.神经网络——非线性激活

import torch
import torchvision
from torch import nn
from torch.nn import Sigmoid, ReLU
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

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

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

class Relu(torch.nn.Module):
    def __init__(self):
        super(Relu, self).__init__()
        self.relu=ReLU()
        self.sigmoid1=Sigmoid()

    def forward(self,input):
        output=self.sigmoid1(input)
        return output
model=Relu()
writer=SummaryWriter('logs')
step=0
for data in dataloader:
    imgs,targets=data
    writer.add_images("input",imgs,global_step= step)
    output=model(imgs)
    writer.add_images("output",output,global_step=step)
    step+=1
writer.close()

15.神经网络——线性层

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

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

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.linear=torch.nn.Linear(196608,10)
    def forward(self,input):
        output=self.linear(input)
        return output
net=Net()

for data in dataloader:
    imgs,targets=data
    print(imgs.shape)
    output=torch.flatten(imgs)
    print(output.shape)
    output=net(output)
    print(output.shape)

线性层负责对输入进行可学习的加权组合与维度变换，是网络表达能力的“骨架”；而非线性层负责引入弯曲能力，二者相辅相成，缺一不可。
DataLoader(dataset,batch_size=64) #

class Net(torch.nn.Module):
def init(self):
super(Net, self).init()
self.linear=torch.nn.Linear(196608,10)
def forward(self,input):
output=self.linear(input)
return output
net=Net()

for data in dataloader:
imgs,targets=data
print(imgs.shape)
output=torch.flatten(imgs)
print(output.shape)
output=net(output)
print(output.shape)

**线性层负责对输入进行可学习的加权组合与维度变换，是网络表达能力的“骨架”；而非线性层负责引入弯曲能力，二者相辅相成，缺一不可。**