我的Pytorch框架学习三阶段

---

date: 2025-02-20 19:19:40
tags: pytorch

一，数据集类，数据加载器类的使用

1.pytorch中数据加载方法
batch:数据打乱顺序，组成一波一波的数据，批量处理
epoch:拿所有的数据训练一次
2.Dataset基类，数据集类
1.torch.utils.data.Dataset调用
2.有两个重要的方法：
a.getitem(index):能够对实例进行索引
b.len:len(实例)调用实例的__len__方法
3.迭代数据集，使用
torch.utils.data.DataLoader(dataset,batch_size,shuffle)
以下是代码实现过程

import torch
from torch.utils.data import Dataset,DataLoader

class SmsDataset(Dataset):
    def __init__(self):
        self.file_path = "./data/SMSSpamCollection"
        self.lines  = open(self.file_path).readlines()

    def __getitem__(self, index):
        line = self.lines[index].strip()
        label = line.split("\t")[0]
        content = line.split("\t")[1]
        return label,content

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


#使用DataLoader
sms_dataset = SmsDataset()
# print(sms_dataset[0])
dataloader = DataLoader(sms_dataset,batch_size=2,shuffle=True,drop_last=True)

if __name__ == '__main__':
    for idx,(labels,contents) in enumerate(dataloader):
        print(idx)
        print(labels)
        print(contents)
        break
    print(len(sms_dataset))
    print(len(dataloader))

二.数字识别项目的学习

1.大致流程:手写数字识别的思路：
准备数据，通过dataset和DataLoader准备
模型构建
模型训练，模型保存和加载
模型的评估
2.准备Mnist数据
torchvision.transforms.ToTensor
把ndarray转化为tensor
&
PIL中iamge对象对转化为tensor方法
torchvision.transforms.Normlize(mean,str)
&
mean,std的形状和通道数相同
torchvision.transforms.Compose
2.代码实现

#使用pytorch完成手写数字的识别
import os
import torch
from torch.utils.data import DataLoader
from torch.optim import Adam
from mpmath.identification import transforms
from torchvision.datasets import MNIST
from torchvision.transforms import Compose,ToTensor,Normalize
import torch.nn as nn
import torch.nn.functional as F
BATCH_SIZE=128
#1准备数据集
def get_dataloader(train=True):
    transform_fn =Compose([
        ToTensor(),
        Normalize(mean=(0.1307),std=(0.3081,))  #mean和std形状和通道数一样
    ])
    dataset=MNIST(root="./data",train=train,transform=transform_fn)
    data_loader=DataLoader(dataset,batch_size=BATCH_SIZE,shuffle=True)
    return  data_loader

#2,构建模型
class MistMOdel(nn.Module):
    def __init__(self):
        super(MistMOdel,self).__init__()
        self.fc1=nn.Linear(1*28*28,28)
        self.fc2=nn.Linear(28,10)


    def forward(self,input):
        """
        :param input: [batch_size,1,28,28]
        :return:
        """
        x=input.view([input.size(0),1*28*28])#形状修改
        x=self.fcl(x)  #全连接操作
        x=F.relu(x)  #进行激活函数处理，形状不变
        out=self.fc2(x) #输出层
        return out
        return F.log_softmax(out,dim=-1)

model=MistMOdel()

optimizer=Adam(model.parameters(),lr=0.001)
if os.path.exists("./"):
    model.load_state_dict(torch.load("./路径"))
    optimizer.load_state_dict(torch.load("./路径"))

def train(epoch):  #模型的训练

    data_loader=get_dataloader()
    for idx,(inout,traget) in enumerate(data_loader):
        output=model(input)   #调用模型的到预测值
        loss=F.nll_loss(output,traget)
        loss.backward()#反向传播
        optimizer.step()#提督更新
        if idx%100==0:
            print(epoch,idx,loss.item())

        #模型的保存
        if idx%100==0:
            torch.save(model.state_dict(),"./路径")
            torch.save(optimizer.state_dict(), "./路径")

def test():
    test_dataloader=get_dataloader(train=False)
    for idx,(inout,traget) in enumerate(test_dataloader):
        with torch.no_grad:
            output=model(input)
            cur_loss=F.nll_loss(output,traget)


if __name__ ==  '__main__':
    #for i in range(3):#训练3轮
       # train(i)
    loader=get_dataloader(train=False)
    for input,label in loader:
        print(label.siae())

三.循环神经网络的基础了解

RNN:具有短期记忆的网络
1.和普通网络的区别
能够更擅长解决时间序列问题
当前时刻神经元的输入有两个：
当前时刻的输入
前一时刻的输出
2.RNN的常见类别
one-one:图像分类
one-many:图像描述
many-one:文本的分类
many-many:翻译
3.RNN的长依赖：带预测词语的位置比较远，很难影响到当前时间步的输出
4.LSTM:解决长依赖
ell state:细胞状态，存储的是记忆信息
遗忘门：决定什么信息会被忘记
输入门：把信息输入到cell state中
输出门：决定什么信息会被输出