pytorch学习笔记

哔哩哔哩小土堆视频

dataset

from torch.utils.data import Dataset
class MyData(Dataset):
#这个类继承Dataset，在init中可以做获取数据的操作，必须要有两个方法
#getitem(self,idx)返回对应idx的数据和标签
#len(self)返回数据集的长度

### 一次作业中用的Dataset
class MyData(Dataset):
    def __init__(self, para_path, time_path):
        self.para_path = para_path
        self.time_path = time_path
        self.raw_para=torch.Tensor(np.load(self.para_path))
        
        self.raw_time = torch.from_numpy(
            np.load(self.time_path).astype(np.float64))

    def __getitem__(self, idx):
        para = self.raw_para[idx]
        time = self.raw_time[idx]

        return para, time

    def __len__(self):
        return self.raw_time.shape[0]

torchvision自带很多dataset

import torchvision
test_set=torchvision.datasets.CIFAR10(root='./data',train=False,transform=tran,download=True)
#这行是获取CIFAR10的测试数据集，root为保存路径，download为是否下载(一般都为True，路径中如果有就会校验，没有进行下载)，train为True下载训练集False下载测试集，transform为对数据做的预处理操作(后面的transform会详细介绍都有哪些预处理操作)

dataloader

from torch.utils.data import DataLoader
test_loader=DataLoader(dataset=test_set,batch_size=64,shuffle=True,num_workers=0,drop_last=False)
#将dataset的数据封装成batch_size大小的数据，为可迭代数据，64代表每个包中有64个数据和标签，shuffle代表取数据时候是否打乱，num_workers多线程(Windows下偶尔会抽风)，drop_last为最后一点数据不足batch_size时候是否丢弃
for i in test_loader:
	imgs,targets=i

Tensorboard

from torch.utils.tensorboard import SummaryWriter

from torch.utils.tensorboard import SummaryWriter
writer=SummaryWriter('logs')

##add_scalar的使用，添加标量数据到board中
# 第一个为对应图标的名称，第二个是Y轴，第三个为X轴
for i in range(100):
    writer.add_scalar('y=x',i,i)
    
# add_image的使用，添加图片到board中
img_PIL=Image.open(img_path)
img_array=np.array(img_PIL)
# 第一个为对应图标的名称，第二个是图片array，第三个为图片序号，第四个转换格式
writer.add_image('test',img_array,1,dataformats='HWC')
#可以从dataloader中批量添加图片到board中
for i in test_loader:
	imgs,targets=i
	writer.add_images('test_data',imgs,step)
	step+=1

# add_graph的使用，添加模型到board中
#test为对应的模型，input为输入
writer.add_graph(test,input)


#关闭writer
writer.close()

tensorborad --logdir=logs
–port=指定特定端口
然后会出现一个url，点击即可

Transform

**from torchvision import transforms **

from torchvision import transforms 
#首先要创建transform的工具对象，具体的工具
# ToTensor对象的创建，转换为Tensor格式
tool=transforms.ToTensor()
#调用call，使用工具
result=tool(img)

# Normalize将tensor图片进行标准化，输入：均值、标准差
trans_norm=transforms.Normalize([1,3,5],[3,2,15])
img_norm=trans_norm(result)
#output[channel] = (input[channel] - mean[channel]) / std[channel] 

#Resize改变大小
#最新的resize已经可以传入tensor了
trans_resize=transforms.Resize([512,512])
img_resize=trans_resize(img)
#只输入一个尺寸的话，会进行等比缩放
trans_resize=transforms.Resize(999)

#使用compose进行方法顺序组合，resize、totensor
#参数为列表，列表为各种Transform的工具代码里面就是循环调用列表，每次的输出当下一次的输入
img_res=transforms.Compose([trans_resize,totensor])

神经网络的骨架

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

    def forward(self,input):
        return self.conv1(input)
#所有神经网络的骨架，都要继承这个类
#在init中创建各种层，在forward中进行调用层

常用函数

Conv2d

conv2d input(minibatch,in_channels,iH,iW)
diliation 空洞卷积

参数：in_channels，out_channels，kernel_size，stride，padding

pool

池化层的stride默认为kernel_size

不能处理整型，tensor需要dtype转换为float

最大池化的作用，减少数据量

imprt torch.nn as nn
self.maxpool1=nn.MaxPool2d(kernel_size=3,ceil_mode=False)

nn.Relu

nn.Sigmoid

nn.Linear

(in_size,out_size)

flatten

nn.Flatten(),
torch.flatten(imgs).reshape((1,-1))

dropout

x = F.dropout(x, p=0.8)

nn.BatchNorm2d

(维度)
对对应长度的维度进行正则化，
如果第3维大小维5，输入5，就对第三维进行正则化

损失函数、反向传播、优化器

MSELoss 均方误差
CrossEntropyLoss 交叉熵误差函数

这里会对y进行一个one-hot编码，[1]变成[0,1,0]
result = nn.CrossEntropyLoss()(input, y)

构造优化器：放入模型参数，学习率

optimizer = torch.optim.SGD(test.parameters(), lr=0.01)

optimizer.step()：通过上面得到的梯度，进行梯度下降
optimizer.zero_grad(): 梯度清零

import torch.optim as optim

# 构造优化器
optimizer = torch.optim.SGD(test.parameters(), lr=0.01)
for epoch in range(20):
    running_loss = 0.
    for data in dataloader:
        imgs, labels = data
        outputs = test(imgs)
        result_loss = loss(outputs, labels)
        optimizer.zero_grad()
    # 调用backward进行反向传播求导
        result_loss.backward()
    # 调用优化器进行梯度下降
        optimizer.step()
        running_loss += result_loss
    print(running_loss)

模型的保存和加载

torch.save(vgg16, './vgg16_method1.pth')

# 保存模型，保存参数（字典）
torch.save(vgg16.state_dict(),'./vgg16_method2.pth')

# 加载模型
model=torch.load('./vgg16_method1.pth')
model.load_state_dict(torch.load('vgg16_method2.pth'))

使用GPu训练

# 第一种
# 模型、数据、损失函数、标注，使用.cuda即可
if torch.cuda.is_available():
  test=test.cuda(),loss_fn=loss_fn.cuda(),imgs=imgs.cuda(),targets=targets.cuda()

# 第二种

device = torch.device('cuda')
test=test.to(device)  device=torch.device('cuda')