精华内容
下载资源
问答
  • pytorch训练自己的任务,是有模板可以写的,下面将整理下训练模型必须会出现的代码。每一步都是接着上一步骤。 文章目录1 导入各种包2 超参数和一些常量的定义,方便以后修改3 数据加载4 实例化数据类5 构建网络6 ...

    用pytorch训练自己的任务,是有模板可以写的,下面将整理下训练模型必须会出现的代码。每一步都是接着上一步骤。

    1 导入各种包

    import torch
    import csv
    import torch.nn as nn
    from torch.utils.data import Dataset
    from torch.utils.data import DataLoader
    from PIL import Image, ImageFile
    import torchvision.transforms as transforms
    from torchvision import models
    import torch.utils.model_zoo as model_zoo
    import torch.nn.functional as F
    import torch.optim as optim
    import os
    

    2 超参数和一些常量的定义,方便以后修改

    label_file_train = r'./train.csv'
    data_dir_train = r'./dataset/train/'
    
    label_file_val = r'.test.csv'
    data_dir_val = r'./dataset/test/'
    
    #设置tensor 网络数据都是在GPU设备上运行
    device = torch.device('cuda')
    classNum = 2
    batch_size = 2
    acc_best = float('inf')
    CKPT_PATH = '*best.pkl' #可不要
    

    3 定义数据集

    class MyDataset(Dataset):
        def __init__(self, data_dir,label_file,transform=None): #保存数据路径
            pass
            
        def __len__(self):
            return len(self.labels)    
    
        def __getitem__(self,index):
            return image,label
    

    4 实例化数据类

    这一步是为了将数据实例化,且用批次读取出来,之后可以直接训练。

    train_dataset = MyDataset(data_dir=data_dir,label_file=label_file,transform=transforms)
    train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
    

    5 构建网络

    class MyNet(nn.Module):
    	def __init__(self, num_class):
    		super(MyNet, self).__init__()
    		pass
    		
        def forward(self, x):
            return x
    

    6 实例化网络

    model = Mynet(classNum).to(device)
    

    7 定义优化器

    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    

    8 损失函数

    criteon = nn.CrossEntropyLoss().to(device)
    

    也可以用自己设计的损失函数:

    Class NewLoss(nn.Module):
        def __init__(self):
            pass
    
        def forward(self,outputs, targets):
            pass
    
    criterion = NewLoss().to(device)
    

    9 加载模型

    如果有训练好的模型,需要加载:

    checkpoints = torch.load(CKPT_PATH)  #是字典型,包含训练次数等
    checkpoint = checkpoints['state_dict']
    step = checkpoints['epoch']   #训练的批次
    model.load_state_dict(checkpoint)
    print("=> loaded checkpoint: %s"%CKPT_PATH)
    

    10 开始训练

    for epoch in range(10):        
        model.train()   #必须要写这句
        for batchidx, (x, label) in enumerate(train_loader):
        	x, label = x.to(device), label.to(device)
            logits = model(x)
            loss = criteon(logits, label)        
            # backprop
            optimizer.zero_grad()  #梯度清0
            loss.backward()   #梯度反传
            optimizer.step()   #保留梯度
        print(epoch, 'loss:', loss.item())
    

    11 验证模型和保存模型

        model.eval()    #这句话也是必须的
        with torch.no_grad():
            total_correct = 0
            total_num = 0
            for x, label in val_loader:
                x, label = x.to(device), label.to(device)
                logits = model(x)
                pred = logits.argmax(dim=1)
                correct = torch.eq(pred, label).float().sum().item()
                total_correct += correct
                total_num += x.size(0)
                print(correct)
            acc = total_correct / total_num
            print(epoch, 'test acc:', acc)
    
            if acc < acc_best:
                acc_best = acc 
                torch.save({'state_dict': model.state_dict(), 'epoch': epoch},'MyNet_'+str(epoch) + '_best.pkl')
                print('Save best statistics done!')
    

    12 可视化步骤

    viz = visdom.Visdom()
    viz.line([0], [-1], win='loss', opts=dict(title='loss'))  #初始化
    viz.line([0], [-1], win='val_acc', opts=dict(title='val_acc'))
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    viz.line([loss.item()], [global_step], win='loss', update='append') #在这里加入loss值
    

    验证集准确率也是一样的:

     viz.line([val_acc],[global_step], win='val_acc',update='append')
    

    12.1 如果用tensorboard,则需要这么写:

    from tensorboardX import SummaryWriter
    writer = SummaryWriter('mytest')
    writer.add_scalar('Loss1', loss, epoch)
    writer.close()
    

    注意:tensorboard保存不能有中文路径,否则会显示不出来

    个人建议还是用Visdom。

    展开全文
  • pytorch训练代码

    2017-11-17 19:11:45
    pytorch训练代码,就是这样啦,应该是实现imagenet的分类器吧
  • pytorch训练MNIST

    千次阅读 2019-08-19 16:11:20
    本文记录了pytorch训练MNIST数据集的过程,通过本文可熟悉pytorch训练的大体操作过程。

    本文记录了pytorch训练MNIST数据集的过程,通过本文可熟悉pytorch训练的大体操作过程。

    一、导入各种模块

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import torch.optim as optim
    from torchvision import datasets, transforms
    

    二、设置超参数

    BATCH_SIZE=512 # 批次大小
    EPOCHS=20 # 总共训练批次
    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 让torch判断是否使用GPU,建议使用GPU环境,因为会快很多
    

    二、下载并读取数据集

    train_loader = torch.utils.data.DataLoader(
            datasets.MNIST('data', train=True, download=True,
                           transform=transforms.Compose([
                               transforms.ToTensor(),
                               transforms.Normalize((0.1307,), (0.3081,))
                           ])),
            batch_size=BATCH_SIZE, shuffle=True)
    
    
    test_loader = torch.utils.data.DataLoader(
            datasets.MNIST('data', train=False, transform=transforms.Compose([
                               transforms.ToTensor(),
                               transforms.Normalize((0.1307,), (0.3081,))
                           ])),
            batch_size=BATCH_SIZE, shuffle=True)
    

    torch.utils.data.DataLoader是PyTorch中数据读取的一个重要接口,只要是用PyTorch来训练模型基本都会用到该接口,该接口主要用来将自定义的数据读取接口的输出或者PyTorch已有的数据读取接口的输入按照batch size封装成Tensor。
    torch.utils.data.DataLoader的重要参数:
    1、dataset,这个是PyTorch已有的数据读取接口(比如torchvision.datasets.ImageFolder(可用于自己的图片数据集的训练))或者自定义的数据接口的输出,该接口是torch.utils.data.Dataset类的对象,或者是继承自torch.utils.data.Dataset类的自定义类的对象。
    2、batch_size,训练批次的大小,根据具体情况设置即可。
    3、shuffle,在封装过程中是否打乱数据集,一般在训练数据中会采用。
    具体见此博客(注:现在版本不需要包装成Variable)

    三、定义卷积神经网络

    class ConvNet(nn.Module):
        def __init__(self):
            super().__init__()
            # 1,28x28
            self.conv1=nn.Conv2d(1 ,10,5) # 24x24
            self.pool = nn.MaxPool2d(2,2) # 12x12
            self.conv2=nn.Conv2d(10,20,3) # 10x10
            self.fc1 = nn.Linear(20*10*10,500)
            self.fc2 = nn.Linear(500,10)
        def forward(self,x):
            in_size = x.size(0)
            out = self.conv1(x) #24
            out = F.relu(out)
            out = self.pool(out)  #12
            out = self.conv2(out) #10
            out = F.relu(out)
            out = out.view(in_size,-1)
            out = self.fc1(out)
            out = F.relu(out)
            out = self.fc2(out)
            out = F.log_softmax(out,dim=1)
            return out
    

    关于定义网络这一部分,详细介绍可以查看我的另一篇博客pytorch中根据神经网络结构确定输入图片尺寸(根据图片尺寸修改神经网络结构)

    四、神经网络的训练与评估

    model = ConvNet().to(DEVICE)
    optimizer = optim.Adam(model.parameters())
    
    def train(model, device, train_loader, optimizer, epoch):
        model.train()
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = data.to(device), target.to(device)
            optimizer.zero_grad()
            output = model(data)
            loss = F.nll_loss(output, target)
            loss.backward()
            optimizer.step()
            if(batch_idx+1)%30 == 0:
                print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                    epoch, batch_idx * len(data), len(train_loader.dataset),
                    100. * batch_idx / len(train_loader), loss.item()))
                    
    def test(model, device, test_loader):
        model.eval()
        test_loss = 0
        correct = 0
        with torch.no_grad():
            for data, target in test_loader:
                data, target = data.to(device), target.to(device)
                output = model(data)
                test_loss += F.nll_loss(output, target, reduction='sum').item() # 将一批的损失相加
                pred = output.max(1, keepdim=True)[1] # 找到概率最大的下标
                correct += pred.eq(target.view_as(pred)).sum().item()
    
        test_loss /= len(test_loader.dataset)
        print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            test_loss, correct, len(test_loader.dataset),
            100. * correct / len(test_loader.dataset)))
    
    
    for epoch in range(1, EPOCHS + 1):
        train(model, DEVICE, train_loader, optimizer, epoch)
        test(model, DEVICE, test_loader)
    
    展开全文
  • 今天小编就为大家分享一篇pytorch训练imagenet分类的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 今天小编就为大家分享一篇Pytorch训练过程出现nan的解决方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 今天小编就为大家分享一篇使用PyTorch训练一个图像分类器实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • pytorch训练cifar100测试单GPU效率代码,用于测试GPU效率,基于开源https://github.com/weiaicunzai/pytorch-cifar100
  • 1. 搭建自己的简单二分类网络,使用pytorch训练和测试; 2. 将pytorch训练的pth模型转换成ONNX,并编码测试; 3. 含训练和测试数据,含训练ok的pth模型和ONNX模型,含完整python和C++实现; 4. 使用方法:首先...
  • 今天小编就为大家分享一篇解决Pytorch训练过程中loss不下降的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • PyTorch训练模型小结

    千次阅读 2019-04-28 11:45:03
    平时用了很多Keras,训练的时候非常方便,直接...PyTorch训练的大体步骤 一个标准的PyTorch模型必须得有一个固定结构的类,结构如下 class TwoLayerNet(torch.nn.Module): def __init__(self, D_in, H, D_out): ...

    平时用了很多Keras,训练的时候非常方便,直接model.fit就可以了。但是PyTorch的训练得自己写,这里小结下PyTorch怎么训练模型。

    PyTorch训练的大体步骤

    一个标准的PyTorch模型必须得有一个固定结构的类,结构如下

    class TwoLayerNet(torch.nn.Module):
        def __init__(self, D_in, H, D_out):
            """
            In the constructor we instantiate two nn.Linear modules and assign them as
            member variables.
            """
            super(TwoLayerNet, self).__init__()
            self.linear1 = torch.nn.Linear(D_in, H)
            self.linear2 = torch.nn.Linear(H, D_out)
    
        def forward(self, x):
            """
            In the forward function we accept a Tensor of input data and we must return
            a Tensor of output data. We can use Modules defined in the constructor as
            well as arbitrary operators on Tensors.
            """
            h_relu = self.linear1(x).clamp(min=0)
            y_pred = self.linear2(h_relu)
            return y_pred
    

    这个固定结构中必须在init里初始化网络结构, 然后必须有forward来进行feed forward网络的前馈。
    下一步,初始化模型的类。

    model = TwoLayerNet(D_in, H, D_out)
    

    下一步就要选择损失函数和优化器了

    # Construct our loss function and an Optimizer. The call to model.parameters()
    # in the SGD constructor will contain the learnable parameters of the two
    # nn.Linear modules which are members of the model.
    criterion = torch.nn.MSELoss(reduction='sum')
    optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)
    

    这些都有了之后我们就可以进行训练了
    先设一个想要训练的Epochs.
    每个epoch首先要获得模型前馈得到的预测值,然后通过目标函数来比较预测和真实值之间的差异。
    在运行优化器之前,要运行一下zero_grad(),它可以清除所有的梯度。
    optimizer.step() 会进行一次优化步骤。

    for t in range(500):
        # Forward pass: Compute predicted y by passing x to the model
        y_pred = model(x)
    
        # Compute and print loss
        loss = criterion(y_pred, y) # 计算损失函数
        print(t, loss.item())
    
        # Zero gradients, perform a backward pass, and update the weights.
        optimizer.zero_grad() # 梯度置零,因为反向传播过程中梯度会累加上一次循环的梯度
        loss.backward() # loss反向传播
        optimizer.step() # 反向传播后参数更新 
    

    如果模型中存在 Dropout 或者 Batch Normalization 层的话 就要使用 model.eval() 把 model变为eval模式, 否则运行的结果会与前一次iteration的结果不一样。
    model.train()把模型变成训练模式,在使用PyTorch进行训练和测试时一定注意要把实例化的model指定train/eval。

    展开全文
  • pytorch训练过程中的内存泄漏 训练到一半总是提示内存已满,bug new Ram 注意自动求梯度的值 特别是loss,不能以张量的形式随便参与运算 1.loss_list.append(loss)

    pytorch训练过程中的内存泄漏

    训练到一半总是提示内存已满,bug new Ram

    注意自动求梯度的值

    特别是loss,不能以张量的形式随便参与运算
    1.loss_list.append(loss)

    展开全文
  • 今天小编就为大家分享一篇解决Pytorch 训练与测试时爆显存(out of memory)的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • SSD-Pytorch训练和测试自己的数据集(新手必看)

    万次阅读 多人点赞 2019-03-24 16:37:26
    2.pytorch环境安装即SSD-pytorch代码下载 3.正常的修改 修改1:config.py 修改2:VOC0712.py 修改3:train.py 修改4:eval.py 修改5:ssd.py 4.遇到的问题和相应的解决办法 问题1: ...
  • 掌握这 17 种方法,用最省力的方式,加速你的 Pytorch 深度学习训练。 近日,Reddit 上一个帖子热度爆表。主题内容是关于怎样加速 PyTorch 训练。原文作者是来自苏黎世联邦理工学院的计算机科学硕士生 LORENZ ...
  • YOLOv4-pytorch训练自己的数据集

    千次阅读 热门讨论 2020-12-17 13:51:24
    YOLOv4-pytorch训练自己的数据集YOLOv4-pytorch介绍环境配置运行环境安装依赖包准备工作Git clone YOLOv4准备数据集下载PascalVOC/MSCOCO 2017数据集准备自己的数据集下载权重文件训练遇到的问题 YOLOv4-pytorch介绍...
  • pytorch训练模型移植至ncnn 第一步是pytorch模型往caffe模型的转换 采用的工具是网路公开的代码,https://github.com/xxradon/PytorchToCaffe,此时会生成prototxt和caffemodel两个新文件。 第二部是往ncnn迁移 ...
  • Pytorch训练表情识别之笑脸识别 一、数据下载 首先是数据下载,话不多说,直接上百度云链接,这是一个只有笑脸和无表情的数据集: 链接:https://pan.baidu.com/s/11K1C6nYfa9bbnsIWsvRGKg 提取码:1tl7 这个链接是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,719
精华内容 27,487
关键字:

pytorch训练