精华内容
下载资源
问答
  • pytorch 使用自动梯度 autograd import torch as t from torch.autograd import Variable a = t.ones(6) b = True x = Variable(a, b) print('a = ', a) print('a = ', type(a)) print('b = ', b) print('b = ', ...

    pytorch 使用自动梯度 autograd

    import torch as t
    from torch.autograd import Variable
    
    a = t.ones(6)
    b = True
    x = Variable(a, b)
    
    print('a = ', a)
    print('a = ', type(a))
    print('b = ', b)
    print('b = ', type(b))
    print('x = ', x)
    print('x = ', type(x))
    
    
    

    结果

    a =  tensor([1., 1., 1., 1., 1., 1.])
    a =  <class 'torch.Tensor'>
    b =  True
    b =  <class 'bool'>
    x =  tensor([1., 1., 1., 1., 1., 1.], requires_grad=True)
    x =  <class 'torch.Tensor'>
    
    Process finished with exit code 0
    
    
    展开全文
  • YDOOK : pytorch 获取当前版本的 怎样获取 pytorch 当前版本号 import torch print(torch.__version__) 输出: 1.6.0 Process finished with exit code 0

    YDOOK : pytorch 获取当前版本的 怎样获取 pytorch 当前版本号

    import torch
    print(torch.__version__)
    
    
    

    输出:

    1.6.0
    
    Process finished with exit code 0
    
    



    展开全文
  • Tensorflow和Pytorch框架之争由来已久,近日人工智能领军企业OpenAI公开表示全面转向Pytorch,并统一自家所有模型的框架标准。 OpenAI高调站队Pytorch   对于深度学习框架的使用,整个人工智能学界主要分为两...

    Tensorflow和Pytorch框架之争由来已久,近日人工智能领军企业OpenAI公开表示全面转向Pytorch,并统一自家所有模型的框架标准。

    OpenAI高调站队Pytorch

      对于深度学习框架的使用,整个人工智能学界主要分为两大阵营,分别是Pytoch和Tensorflow。两大框架一直不相上下。学术界一般用Pytorch,更适合学术研究;而工业界一般用Tensorflow。偏向于工业应用和落地。此次OpenAI高调站队,为Pytorch阵营添了一员猛将,将会使Pytorch在工业界也有一席之地。

    Pytorch的优点

    诚然,相对于Tensorflow,Pytorch在设计之初就非常Pythonic,更容易让初学者上手和学习。其次是API的稳定性。Pytorch的API迭代更加稳定,没有命名混乱的问题。而Tensorflow1.x版本和Tensorflow2.X版本相差很大,特别是API方面,由于Tensorflow融入了Keras,所以基本跟1.x不一样,这就增加了学习和应用的成本,这也是Tensorflow一直让人诟病的地方。

    Pytorch学习

    鉴于Pytorch这个优点,所以本公众号会持续更新Pytorch的相关内容,让你从零开始学Pytorch。欢迎关注!

    展开全文
  • 我在pytorch1.0版本的环境下运行/travis.sh时提示如下错误: ImportError: torch.utils.ffi is deprecated. Please use cpp extensions instead. 请问怎样解决这个问题?</p><p>该提问来源于开源项目&#...
  • 本文将介绍PyTorch的最佳实践和代码风格都是怎样的。 虽然这是一个非官方的 指南,但本文总结了一年多使用 PyTorch 框架的经验,尤其是用它开发深度学习相关工作的最优解决方案。请注意,我们分享的经验大多是从...

     

    PyTorch是最优秀的深度学习框架之一,它简单优雅,非常适合入门。本文将介绍PyTorch的最佳实践和代码风格都是怎样的。

    虽然这是一个非官方的  指南,但本文总结了一年多使用 PyTorch 框架的经验,尤其是用它开发深度学习相关工作的最优解决方案。请注意,我们分享的经验大多是从研究和实践角度出发的。

     

    这是一个开发的项目,欢迎其它读者改进该文档:https://github.com/IgorSusmelj/pytorch-styleguide

     

    本文档主要由三个部分构成:首先,本文会简要清点 Python 中的最好装备。接着,本文会介绍一些使用 PyTorch 的技巧和建议。最后,我们分享了一些使用其它框架的见解和经验,这些框架通常帮助我们改进工作流。

     

    清点 Python 装备

     

    建议使用 Python 3.6 以上版本

     

    根据我们的经验,我们推荐使用 Python 3.6 以上的版本,因为它们具有以下特性,这些特性可以使我们很容易写出简洁的代码:

     

    • 自 Python 3.6 以后支持「typing」模块

    • 自 Python 3.6 以后支持格式化字符串(f string)

     

    Python 风格指南

     

    我们试图遵循 Google 的 Python 编程风格。请参阅 Google 提供的优秀的 python 编码风格指南:

     

    地址:https://github.com/google/styleguide/blob/gh-pages/pyguide.md。

     

    在这里,我们会给出一个最常用命名规范小结:

     

    640?wx_fmt=png

     

    集成开发环境

     

    一般来说,我们建议使用 visual studio 或  这样的集成开发环境。而 VS Code 在相对轻量级的编辑器中提供语法高亮和自动补全功能,PyCharm 则拥有许多用于处理远程集群任务的高级特性。

     

    Jupyter Notebooks VS Python 脚本

     

    一般来说,我们建议使用 Jupyter Notebook 进行初步的探索,或尝试新的模型和代码。如果你想在更大的数据集上训练该模型,就应该使用 Python 脚本,因为在更大的数据集上,复现性更加重要。

     

    我们推荐你采取下面的工作流程:

     

    • 在开始的阶段,使用 Jupyter Notebook

    • 对数据和模型进行探索

    • 在 notebook 的单元中构建你的类/方法

    • 将代码移植到 Python 脚本中

    • 在服务器上训练/部署

     

    640?wx_fmt=png

     

    开发常备库

     

    常用的程序库有:

     

    640?wx_fmt=png

     

    文件组织

     

    不要将所有的层和模型放在同一个文件中。最好的做法是将最终的网络分离到独立的文件(networks.py)中,并将层、损失函数以及各种操作保存在各自的文件中(layers.py,losses.py,ops.py)。最终得到的模型(由一个或多个网络组成)应该用该模型的名称命名(例如,yolov3.py,DCGAN.py),且引用各个模块。

     

    主程序、单独的训练和测试脚本应该只需要导入带有模型名字的 Python 文件。

     

    PyTorch 开发风格与技巧

     

    我们建议将网络分解为更小的可复用的片段。一个 nn.Module 网络包含各种操作或其它构建模块。损失函数也是包含在 nn.Module 内,因此它们可以被直接整合到网络中。

     

    继承 nn.Module 的类必须拥有一个「forward」方法,它实现了各个层或操作的前向传导。

     

    一个 nn.module 可以通过「self.net(input)」处理输入数据。在这里直接使用了对象的「call()」方法将输入数据传递给模块。

     

    output = self.net(input)

     

    PyTorch 环境下的一个简单网络

     

    使用下面的模式可以实现具有单个输入和输出的简单网络:

     

    class ConvBlock(nn.Module):
        def __init__(self):
            super(ConvBlock, self).__init__()
            block = [nn.Conv2d(...)]
            block += [nn.ReLU()]
            block += [nn.BatchNorm2d(...)]
            self.block = nn.Sequential(*block)
    
        def forward(self, x):
            return self.block(x)
    
    class SimpleNetwork(nn.Module):
        def __init__(self, num_resnet_blocks=6):
            super(SimpleNetwork, self).__init__()
            # here we add the individual layers
            layers = [ConvBlock(...)]
            for i in range(num_resnet_blocks):
                layers += [ResBlock(...)]
            self.net = nn.Sequential(*layers)
    
        def forward(self, x):
            return self.net(x)

     

    请注意以下几点:

     

    • 我们复用了简单的循环构建模块(如卷积块 ConvBlocks),它们由相同的循环模式(卷积、、归一化)组成,并装入独立的 nn.Module 中。

    • 我们构建了一个所需要层的列表,并最终使用「nn.Sequential()」将所有层级组合到了一个模型中。我们在 list 对象前使用「*」操作来展开它。

    • 在前向传导过程中,我们直接使用输入数据运行模型。

     

    PyTorch 环境下的简单残差网络

     

    class ResnetBlock(nn.Module):
        def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias):
            super(ResnetBlock, self).__init__()
            self.conv_block = self.build_conv_block(...)
    
        def build_conv_block(self, ...):
            conv_block = []
    
            conv_block += [nn.Conv2d(...),
                           norm_layer(...),
                           nn.ReLU()]
            if use_dropout:
                conv_block += [nn.Dropout(...)]
    
            conv_block += [nn.Conv2d(...),
                           norm_layer(...)]
    
            return nn.Sequential(*conv_block)
    
        def forward(self, x):
            out = x + self.conv_block(x)
            return ou

     

    在这里,ResNet 模块的跳跃连接直接在前向传导过程中实现了,PyTorch 允许在前向传导过程中进行动态操作。

     

    PyTorch 环境下的带多个输出的网络

     

    对于有多个输出的网络(例如使用一个预训练好的 VGG 网络构建感知损失),我们使用以下模式:

     

    class Vgg19(torch.nn.Module):
      def __init__(self, requires_grad=False):
        super(Vgg19, self).__init__()
        vgg_pretrained_features = models.vgg19(pretrained=True).features
        self.slice1 = torch.nn.Sequential()
        self.slice2 = torch.nn.Sequential()
        self.slice3 = torch.nn.Sequential()
    
        for x in range(7):
            self.slice1.add_module(str(x), vgg_pretrained_features[x])
        for x in range(721):
            self.slice2.add_module(str(x), vgg_pretrained_features[x])
        for x in range(2130):
            self.slice3.add_module(str(x), vgg_pretrained_features[x])
        if not requires_grad:
            for param in self.parameters():
                param.requires_grad = False
    
      def forward(self, x):
        h_relu1 = self.slice1(x)
        h_relu2 = self.slice2(h_relu1)        
        h_relu3 = self.slice3(h_relu2)        
        out = [h_relu1, h_relu2, h_relu3]
        return out

     

    请注意以下几点:

     

    • 我们使用由「torchvision」包提供的预训练模型

    • 我们将一个网络切分成三个模块,每个模块由预训练模型中的层组成

    • 我们通过设置「requires_grad = False」来固定网络权重

    • 我们返回一个带有三个模块输出的 list

     

    自定义损失函数

     

    即使 PyTorch 已经具有了大量标准损失函数,你有时也可能需要创建自己的损失函数。为了做到这一点,你需要创建一个独立的「losses.py」文件,并且通过扩展「nn.Module」创建你的自定义损失函数:

     

    class CustomLoss(torch.nn.Module):
    
        def __init__(self):
            super(CustomLoss,self).__init__()
    
        def forward(self,x,y):
            loss = torch.mean((x - y)**2)
            return loss

     

    训练模型的最佳代码结构

     

    对于训练的最佳代码结构,我们需要使用以下两种模式:

     

    • 使用 prefetch_generator 中的 BackgroundGenerator 来加载下一个批量数据

    • 使用 tqdm 监控训练过程,并展示计算效率,这能帮助我们找到数据加载流程中的瓶颈

     

    # import statements
    import torch
    import torch.nn as nn
    from torch.utils import data
    ...
    
    # set flags / seeds
    torch.backends.cudnn.benchmark = True
    np.random.seed(1)
    torch.manual_seed(1)
    torch.cuda.manual_seed(1)
    ...
    
    # Start with main code
    if __name__ == '__main__':
        # argparse for additional flags for experiment
        parser = argparse.ArgumentParser(description="Train a network for ...")
        ...
        opt = parser.parse_args() 
    
        # add code for datasets (we always use train and validation/ test set)
        data_transforms = transforms.Compose([
            transforms.Resize((opt.img_size, opt.img_size)),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            transforms.Normalize((0.50.50.5), (0.50.50.5))
        ])
    
        train_dataset = datasets.ImageFolder(
            root=os.path.join(opt.path_to_data, "train"),
            transform=data_transforms)
        train_data_loader = data.DataLoader(train_dataset, ...)
    
        test_dataset = datasets.ImageFolder(
            root=os.path.join(opt.path_to_data, "test"),
            transform=data_transforms)
        test_data_loader = data.DataLoader(test_dataset ...)
        ...
    
        # instantiate network (which has been imported from *networks.py*)
        net = MyNetwork(...)
        ...
    
        # create losses (criterion in pytorch)
        criterion_L1 = torch.nn.L1Loss()
        ...
    
        # if running on GPU and we want to use cuda move model there
        use_cuda = torch.cuda.is_available()
        if use_cuda:
            net = net.cuda()
            ...
    
        # create optimizers
        optim = torch.optim.Adam(net.parameters(), lr=opt.lr)
        ...
    
        # load checkpoint if needed/ wanted
        start_n_iter = 0
        start_epoch = 0
        if opt.resume:
            ckpt = load_checkpoint(opt.path_to_checkpoint) # custom method for loading last checkpoint
            net.load_state_dict(ckpt['net'])
            start_epoch = ckpt['epoch']
            start_n_iter = ckpt['n_iter']
            optim.load_state_dict(ckpt['optim'])
            print("last checkpoint restored")
            ...
    
        # if we want to run experiment on multiple GPUs we move the models there
        net = torch.nn.DataParallel(net)
        ...
    
        # typically we use tensorboardX to keep track of experiments
        writer = SummaryWriter(...)
    
        # now we start the main loop
        n_iter = start_n_iter
        for epoch in range(start_epoch, opt.epochs):
            # set models to train mode
            net.train()
            ...
    
            # use prefetch_generator and tqdm for iterating through data
            pbar = tqdm(enumerate(BackgroundGenerator(train_data_loader, ...)),
                        total=len(train_data_loader))
            start_time = time.time()
    
            # for loop going through dataset
            for i, data in pbar:
                # data preparation
                img, label = data
                if use_cuda:
                    img = img.cuda()
                    label = label.cuda()
                ...
    
                # It's very good practice to keep track of preparation time and computation time using tqdm to find any issues in your dataloader
                prepare_time = start_time-time.time()
    
                # forward and backward pass
                optim.zero_grad()
                ...
                loss.backward()
                optim.step()
                ...
    
                # udpate tensorboardX
                writer.add_scalar(..., n_iter)
                ...
    
                # compute computation time and *compute_efficiency*
                process_time = start_time-time.time()-prepare_time
                pbar.set_description("Compute efficiency: {:.2f}, epoch: {}/{}:".format(
                    process_time/(process_time+prepare_time), epoch, opt.epochs))
                start_time = time.time()
    
            # maybe do a test pass every x epochs
            if epoch % x == x-1:
                # bring models to evaluation mode
                net.eval()
                ...
                #do some tests
                pbar = tqdm(enumerate(BackgroundGenerator(test_data_loader, ...)),
                        total=len(test_data_loader)) 
                for i, data in pbar:
                    ...
    
                # save checkpoint if needed
                ...

     

    PyTorch 的多 GPU 训练

     

    PyTorch 中有两种使用多 GPU 进行训练的模式。

     

    根据我们的经验,这两种模式都是有效的。然而,第一种方法得到的结果更好、需要的代码更少。由于第二种方法中的 GPU 间的通信更少,似乎具有轻微的性能优势。

     

    对每个网络输入的 batch 进行切分

     

    最常见的一种做法是直接将所有网络的输入切分为不同的批量数据,并分配给各个 GPU。

     

    这样一来,在 1 个 GPU 上运行批量大小为 64 的模型,在 2 个 GPU 上运行时,每个 batch 的大小就变成了 32。这个过程可以使用「nn.DataParallel(model)」包装器自动完成。

     

    将所有网络打包到一个超级网络中,并对输入 batch 进行切分

     

    这种模式不太常用。下面的代码仓库向大家展示了 Nvidia 实现的 pix2pixHD,它有这种方法的实现。

     

    地址:https://github.com/NVIDIA/pix2pixHD

     

    PyTorch 中该做和不该做的

     

    在「nn.Module」的「forward」方法中避免使用 Numpy 代码

     

    Numpy 是在 CPU 上运行的,它比 torch 的代码运行得要慢一些。由于 torch 的开发思路与 numpy 相似,所以大多数  中的函数已经在 PyTorch 中得到了支持。

     

    将「DataLoader」从主程序的代码中分离

     

    载入数据的工作流程应该独立于你的主训练程序代码。PyTorch 使用「background」进程更加高效地载入数据,而不会干扰到主训练进程。

     

    不要在每一步中都记录结果

     

    通常而言,我们要训练我们的模型好几千步。因此,为了减小计算开销,每隔 n 步对损失和其它的计算结果进行记录就足够了。尤其是,在训练过程中将中间结果保存成图像,这种开销是非常大的。

     

    使用命令行参数

     

    使用命令行参数设置代码执行时使用的参数(batch 的大小、学习率等)非常方便。一个简单的实验参数跟踪方法,即直接把从「parse_args」接收到的字典(dict 数据)打印出来:

     

    # saves arguments to config.txt file
    opt = parser.parse_args()with open("config.txt""w") as f:
        f.write(opt.__str__())

     

    如果可能的话,请使用「Use .detach()」从计算图中释放张量

     

    为了实现自动微分,PyTorch 会跟踪所有涉及张量的操作。请使用「.detach()」来防止记录不必要的操作。

     

    使用「.item()」打印出标量张量

     

    你可以直接打印变量。然而,我们建议你使用「variable.detach()」或「variable.item()」。在早期版本的 PyTorch(< 0.4)中,你必须使用「.data」访问变量中的张量值。

     

    使用「call」方法代替「nn.Module」中的「forward」方法

     

    这两种方式并不完全相同,正如下面的 GitHub 问题单所指出的:https://github.com/IgorSusmelj/pytorch-styleguide/issues/3 640?wx_fmt=png

     

    output = self.net.forward(input)
    # they are not equal!
    output = self.net(input)

     

    原文链接:https://github.com/IgorSusmelj/pytorch-styleguide

     

    展开全文
  • PyTorch Image Models Sponsors What's New Introduction Models Features Results Getting Started (Documentation) Train, Validation, Inference Scripts Awesome PyTorch Resources Licenses Citing Sponsors...
  • Pytorch多GPU训练以及怎样在训练的时候做validation参考:MobileFaceNet_Pytorch中的train.py文件
  • import os os.environ["CUDA_VISIBLE_DEVICES"] = "x" import torch # this should be after device selection
  • PyTorch BROADCASTING ...Broadcasting 是指不同大小的两个 array 应该怎样处理的操作。通常情况下,小一点的数组会被 broadcast 到大一点的,这样才能保持大小一致。 两个 Tensors 只有在下列情况下才能进行 br...
  • 在使用pytorch训练数据的时候cuda 显卡总是发挥不到最大性能 这就是你的cpu程序拖住了你的显卡 怎么办 目前我能想到的最好方法就是 使用numba.cuda.jit这样你也不用使用pytorch cuda 直接使用cuda.jit 这样所有的...
  • pytorch模型剪枝

    2020-07-17 16:29:20
    在cifar数据集上做图像分类的训练,并以此演示怎样进行模型剪枝,pytorch版本必须大于1.4.0
  • 目的:将paddlepaddleocr的字符识别模型转换为pytorch的模型 过程:mobilenetv3_small的小模型在转换过程中成功转换了backbone的参数,但是head(两个双向LSTM)转换失败,因为类别数不同,而LSTM中涉及到两个fc层...
  •    第一次写技术相关的博客,想碎碎念一下:工作一年多以来始终用的是caffe,一直想切换成pytorch,但是没有项目跟进,只看了点中文教程,很难从理解怎样从理论到实际应用的过程。半个月前想了想:“种树的最好...
  • pytorch自定义网络结构不进行参数初始化会怎样

    千次阅读 多人点赞 2018-08-14 17:07:15
    答案:不怕不怕,pytorch自己默认有初始化 证据如下: 1) torch.nn.Conv2d的参数初始化 https://pytorch.org/docs/stable/_modules/torch/nn/modules/conv.html#Conv2d Conv2d继承自_ConvNd,在_ConvNd中,可以...
  • Pytorch数据加载

    2021-04-22 00:50:03
    Pytorch数据加载 目录: 数据集类 数据加载器类 pytorch自带数据集 参考资料 使用方法: 1.准备好Dataset实例 ...我们首先来看一下torch.utils.data.Dataset类源码是怎样写的: class Dataset(object): ""
  • 本系列旨在通过阅读官方pytorch代码熟悉神经网络各个框架的实现方式和流程。 【pytorch官方文档学习之九】PyTorch: state_dict 本文是对官方文档What is a state_dict?...但是怎样将神经网络的每一层layer与
  • PyTorch 需要从源码编译,并且必须与安装在系统中的 Intel MPI 进行链接。我们现在就看一下 torch.distributed 的基本用法,以及如何执行它。 # filename 'ptdist.py' import torch import torch.distributed ...
  • Pytorch基本知识! 文章目录一. 数据类型1.1. 如何判断数据的类型?1.2. 标量 ...怎样去表示String呢? 第1种方法:利用One-hot 编码进行表示 [0,1,0,...][0,1,0,...][0,1,0,...] 第2中方法:Embeddin...
  • pytorch数据并行

    2019-08-01 14:43:28
    在这个教程中,我们将学习怎样通过DataParallel在多GPU上实现数据并行。 在pytorch中使用GPUs非常简单,比如可以通过下面语句将模型放入一张GPU中: device = torch.device("cuda:0") model.to(device) 然后,将...
  • 1.pytorch自定义网络结构不进行参数初始化会怎样,参数值是随机的吗? 2.如何自定义参数初始化? 先回答第一个问题 在pytorch中,有自己默认初始化参数方式,所以在你定义好网络结构以后,不进行参数初始化也是...
  • 在上一节从零开始的实现中,我们需要定义模型参数,并使用它们一步步描述模型是怎样计算的。当模型结构变得更复杂时,这些步骤将变得更繁琐。其实,PyTorch提供了大量预定义的层,这使我们只需关注使用哪些层来构造...
  • Grad-CAM.pytorchpytorch 实现Grad-CAM:Visual Explanations from Deep Networks via Gradient-based Localization 和 Grad-CAM++: Improved Visual Explanations for Deep Convolutional Networks 依赖 使用...
  • pytorch优化之量化

    千次阅读 2020-04-20 19:54:28
    思考:pytorch的eager模式,是怎样支持开发模式支持串行执行断点调试,生产模式支持生成可并发执行代码的,可以拉源码调试分析。这里会涉及到图编程模式、编译原理,执行优化等技术。 ...
  • 怎样搭建一个RTX 3090的深度学习工作站 ** 大概描述一下基本情况 GPU 3090 Nvidia Driver 455.23.05 CUDA 11.1.0 Ubuntu20.04 LTS安装(Macbook) Macbook制作Ubuntu启动盘(用Win的话更简单,百度一下下载对应的...
  • Pytorch的基础数据类型

    2019-09-30 01:29:44
    引言 本篇介绍Pytorch的基础数据类型,判断方式以及常用向量 基础数据类型 torch.Tensor是一种包含单一数据类型元素的多维矩阵。 ...目前在1.2版本中有9种...怎样用数字的形式去表示语言(字符串) : NLP ->...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 172
精华内容 68
关键字:

pytorch怎样