精华内容
下载资源
问答
  • tensorflow转Pytorch的笔记(gather的用法,待补充...) https://blog.csdn.net/CHNguoshiwushuang/article/details/80721675 tensorflow的mnist改写成pytorch ...

     

    从tensorflow转Pytorch的笔记(gather的用法,待补充...)

     

    https://blog.csdn.net/CHNguoshiwushuang/article/details/80721675  

    tensorflow的mnist改写成pytorch

    https://blog.csdn.net/victoriaw/article/details/72354307 PyTorch之示例——MNIST

    https://blog.csdn.net/caichao08/article/details/78997033 

    神经网络的pytorch实现-基于MNIST数据集

    https://blog.csdn.net/sparta_117/article/details/66965760 使用Tensorflow和MNIST识别自己手写的数字

    从tensorflow转过来学习Pytorch,对比一下二者的不同:

    PyTorch vs TensorFlow,哪个更适合你

    为什么要转Pytorch?

    • 更加灵活(使用tensorflow能够找到很多别人的代码,使用Pytorch更加容易实现自己的想法),支持Python化(也就是说基本可以当numpy使用)
    • 速度更快
    • 代码简洁容易上手(0.4版本后没有 Variable之类的定义,只有一个tensor的定义,参数requires_grad=True可以自动求微分,替代Variable)

    细节上一些发现

    1. 以下划线结束的函数是inplace操作,会修改自身的值。

       tensorA.add_(tensorB)  # 会改变tensorA的值
      
    2. tensor和numpy很方便互转且内存共享。

       numpyA = tensorA.numpy()  # Tensor -> Numpy
       tensorA  = torch.from_numpy(numpyA) # Numpy -> Tensor
      
    3. 只有一个元素的tensor 可以调用tensor.item()直接取元素值。

    4. tensor.backward()反向传播之后,tensor.grad梯度值是累加的,在使用反向传播之前使用zero_grad()把梯度清0。

    5. view()有两个作用,一是改变tensor的shape,二是让新tensor和原tensor共享内存,相当于深拷贝detach(),而普通的=赋值方法不会共享内存。

    6. resize()是另一种可用来调整size的方法,但与view()不同,如果新维度超过了原维度,会自动分配新的内存空间。

    7. 增删维度,None类似于np.newaxis()

       tensor.unsqueeze(n) # 在第n个维度上增加1个维度
       tensor.squeeze(n) # 在第n个维度上压缩
       tensor.squeeze(1)  # 压缩所有维数为1的维度
      
    8. contiguous()为tensor分配整块的内存,有些tensor并不是占用一整块内存,而是由不同的数据块组成,而tensor的view()操作依赖于内存是整块的。

    9. gather() ??? ???

    10. 非叶子节点的梯度计算完之后即被清空,可以使用autograd.gradhook方法获取非叶子节点的值

    常用的库

    1. 神经网络
    torch.nn
    nn.Module
    nn.functional 
    
    nn.Sequential
    展开全文
  • Tensorflow转Pytorch实战(1)

    千次阅读 2019-04-02 19:36:33
    近期任务,把论文中用Tensorflow实现的源码转换成Pytorch,菜鸡开始好好撸代码惹。。。 最开始进入Tensorflow中文社区和Pytorch中文社区过了一遍,发现没有特别能记住什么,还是看些基础的例子,然后动手实践起来,...

    近期任务,把论文中用Tensorflow实现的源码转换成Pytorch,菜鸡开始好好撸代码惹。。。
    最开始进入Tensorflow中文社区和Pytorch中文社区过了一遍,发现没有特别能记住什么,还是看些基础的例子,然后动手实践起来,期间推荐看相关框架的英文tutorials查阅(可以看看常用词和提高英语,是吧)

    Tensorflow英文教程:Tensorflow tutorials
    Tensorflow中文教程:Tensorflow 中文
    Pytorch英文教程: Pytorch tutorials
    Pytorch中文教程:Pytorch 中文

    首先做的是搭建CNN

    1、Tensorflow搭建CNN:

    #coding=UTF-8
    #step 1 导入Tensorflow
    import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    
    
    #step 2 加载数据集mnist
    mnist = input_data.read_data_sets('MNIST_data/',one_hot=True)
    x = tf.placeholder(tf.float32,[None,784])
    y_ = tf.placeholder(tf.float32,[None,10])
    
    #step 3 为了代码整洁,定义weight和bias的初始化封装成函数
    #通常使用少量的噪声初始化权值以打破对称性,并防止梯度为0
    def weight_variable(shape):
        initial = tf.truncated_normal(shape,stddev=0.1)
        return tf.Variable(initial)
    def bias_variable(shape):
        initial = tf.constant(0.1,shape=shape)
        return tf.Variable(initial)
    
    #step4 定义卷积层和maxpooling
    #为了代码整洁,将卷积层和maxpooling封装起来
    def conv2d(x,w):
        return tf.nn.conv2d(x,w,strides=[1,1,1,1],padding='SAME')
    def max_pool_2x2(x):
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
    
    #step5 reshape image数据
    x_image = tf.reshape(x,[-1,28,28,1])
    
    #step6 搭建第一个卷积层
    #使用32个5x5的filter,然后通过maxpooling
    W_conv1 = weight_variable([5,5,1,32])
    b_conv1 = bias_variable([32])
    h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1)+b_conv1)
    h_pool1 = max_pool_2x2(h_conv1)
    
    #step7 搭建第二个卷积层
    #使用64个5x5的filter
    W_conv2 = weight_variable([5,5,32,64])
    b_conv2 = bias_variable([64])
    h_conv2 = tf.nn.relu(conv2d(h_pool1,W_conv2)+b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)
    
    #step8 构建全连接层
    #需要将上一层的输出展开成1d的神经层
    W_fc1 = weight_variable([7*7*64,1024])
    b_fc1 = bias_variable([1024])
    h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1)+b_fc1)
    
    #step9 添加Dropout
    #加入Dropout层,可以防止过拟合问题,这里使用了一个Placeholder,控制在训练和测试时候是否使用Dropout层
    keep_prob = tf.placeholder(tf.float32)
    h_fc1_dropout = tf.nn.dropout(h_fc1,keep_prob)
    
    #step10 输入层  输出一个线性结果
    W_fc2 = weight_variable([1024,10])
    b_fc2 = bias_variable([10])
    y_conv = tf.matmul(h_fc1_dropout,W_fc2)+b_fc2
    
    #step11 训练和评估
    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_,
                                                                           logits=y_conv))
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(y_,1),tf.argmax(y_conv,1)),tf.float32))
    
    with tf.Session() as sess:
        writer = tf.summary.FileWriter('logs/', sess.graph)
        tf.global_variables_initializer().run()
        for i in range(3000):
            batch  = mnist.train.next_batch(50)
            if i%100 == 0:
                train_accuracy = accuracy.eval(feed_dict = {x:batch[0],
                                                            y_:batch[1],
                                                            keep_prob:1.})
                print('steo {},the train accuracy {}'.format(i,train_accuracy))
            train_step.run(feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})
        test_accuracy = accuracy.eval(feed_dict = {x:mnist.test.images,y_:mnist.test.labels,
                                                   keep_prob:1.})
        print('the test accuracy :{}'.format(test_accuracy))
        saver = tf.train.Saver()
        path = saver.save(sess,'./results/mnist_deep.ckpt')
        print('save path:{}'.format(path))
    

    2、Pytorch搭建CNN:

    #coding=UTF-8
    #导入需要的包
    import torch
    import torch.nn as nn
    import torchvision.datasets as normal_datasets
    import torchvision.transforms as transforms
    from torch.autograd import Variable
    import matplotlib.pyplot as plt
    #超参
    EPOCH = 1
    BATCH_SIZE = 100
    LR = 0.001
    
    #将数据处理成Variable,如果有GPU,可以转换成cuda形式
    def get_variable(x):
        x = Variable(x)
        return x.cuda() if torch.cuda.is_available() else x
    
    #从torchvision.datasets中加载一些常用的数据集
    train_dataset = normal_datasets.MNIST(
        root='./mnist/',
        train=True,
        transform=transforms.ToTensor(),
        download=True
    )
    #绘制图
    print(train_dataset.train_data.size())
    print(train_dataset.train_labels.size())
    plt.imshow(train_dataset.train_data[0].numpy(),cmap='gray')
    plt.title('%i' % train_dataset.train_labels[0])
    plt.show()
    
    #建立数据加载器和batch
    test_datatest = normal_datasets.MNIST(
        root='./mnist/',
        train=True,
        transform=transforms.ToTensor(),
    )
    
    #处理数据,使用DataLoader进行batch训练
    train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                               batch_size=BATCH_SIZE,
                                               shuffle=True)
    
    test_loader = torch.utils.data.DataLoader(dataset=test_datatest,
                                              batch_size=BATCH_SIZE,
                                              shuffle=False)
    
    #建立计算图模型
    class CNN(nn.Module):
        def __init__(self):
            super(CNN, self).__init__()
            #使用序列工具快速构建
            self.conv1 = nn.Sequential(
                nn.Conv2d(1,16,kernel_size=5,padding=2),
                nn.BatchNorm2d(16),
                nn.ReLU(),
                nn.MaxPool2d(2)
            )
    
            self.conv2 = nn.Sequential(
                nn.Conv2d(16,32,kernel_size=5,padding=2),
                nn.BatchNorm2d(32),
                nn.ReLU(),
                nn.MaxPool2d(2)
            )
            self.fc = nn.Linear(7*7*32,10)
    
        def forward(self,x):
            out = self.conv1(x)
            out = self.conv2(out)
            out = out.view(out.size(0),-1)
            out = self.fc(out)
            return out
    
    cnn = CNN()
    print(cnn)
    
    if torch.cuda.is_available():
        cnn = cnn.cuda()
    
    #定义优化器和损失(选择损失函数和优化方法)
    loss_func = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(cnn.parameters(),lr=LR)
    
    #进行batch训练
    for epoch in range(EPOCH):
        for i,(images,labels) in enumerate(train_loader):
            images = get_variable(images)
            labels = get_variable(labels)
            # 输入训练数据
            outputs = cnn(images)
            #计算误差
            loss = loss_func(outputs,labels)
            # 清空上一次的梯度
            optimizer.zero_grad()
            # 误差反向传递
            loss.backward()
            # 优化器参数更新
            optimizer.step()
    
            if(i+1)%100 ==0:
                print('Epoch [%d/%d], Iter [%d/%d] Loss: %.4f'
                      % (epoch + 1, EPOCH, i + 1, len(train_dataset) //BATCH_SIZE, loss.data[0]))
    
        #测试模型
        cnn.eval()
        correct = 0
        total = 0
        for images,labels in test_loader:
            images = get_variable(images)
            labels = get_variable(labels)
    
            outputs = cnn(images)
            _,predicted = torch.max(outputs.data,1)
            total += labels.size(0)
            correct += (predicted == labels.data).sum()
    
        #print('测试准确率: %d%d' %(100*correct/total))
        print(' 测试 准确率: %d %%' % (100 * correct / total))
        #保存训练模型
        torch.save(cnn.state_dict(),'cnn.pkl')
    
    展开全文
  • tensorflow转过来学习Pytorch,对比一下二者的不同: PyTorch vs TensorFlow,哪个更适合你 为什么要转Pytorch? 更加灵活(使用tensorflow能够找到很多别人的代码,使用Pytorch更加容易实现自己的想法),支持...

    从tensorflow转过来学习Pytorch,对比一下二者的不同:

    PyTorch vs TensorFlow,哪个更适合你

    为什么要转Pytorch?

    更加灵活(使用tensorflow能够找到很多别人的代码,使用Pytorch更加容易实现自己的想法),支持Python化(也就是说基本可以当numpy使用)
    速度更快
    代码简洁容易上手(0.4版本后没有 Variable之类的定义,只有一个tensor的定义,参数requires_grad=True可以自动求微分,替代Variable)
    细节上一些发现

    1.以下划线结束的函数是inplace操作,会修改自身的值。

     tensorA.add_(tensorB)  # 会改变tensorA的值
    

      

    2.tensor和numpy很方便互转且内存共享。

     numpyA = tensorA.numpy()  # Tensor -> Numpy
     tensorA  = torch.from_numpy(numpyA) # Numpy -> Tensor
    

      

    3.只有一个元素的tensor 可以调用tensor.item()直接取元素值。

    4.tensor.backward()反向传播之后,tensor.grad梯度值是累加的,在使用反向传播之前使用zero_grad()把梯度清0。

    5.view()有两个作用,一是改变tensor的shape,二是让新tensor和原tensor共享内存,相当于深拷贝detach(),而普通的=赋值方法不会共享内存。

    6.resize()是另一种可用来调整size的方法,但与view()不同,如果新维度超过了原维度,会自动分配新的内存空间。

    7.增删维度,None类似于np.newaxis()

     tensor.unsqueeze(n) # 在第n个维度上增加1个维度
     tensor.squeeze(n) # 在第n个维度上压缩
     tensor.squeeze(1)  # 压缩所有维数为1的维度
    

      

    8.contiguous()为tensor分配整块的内存,有些tensor并不是占用一整块内存,而是由不同的数据块组成,而tensor的view()操作依赖于内存是整块的。

    9.gather() ??? ???

    10.非叶子节点的梯度计算完之后即被清空,可以使用autograd.grad或hook方法获取非叶子节点的值

    常用的库

    神经网络

    torch.nn
    nn.Module
    nn.functional 
    
    nn.Sequential
    

      


    原文:https://blog.csdn.net/qq_37717661/article/details/85790401

    转载于:https://www.cnblogs.com/qbdj/p/11024580.html

    展开全文
  • tensorflow中地这个语言实现了图片地resize,采用双线性插值地方法,对应pytorch中语言为: import torch.nn.functional as F x=tensor x = nn.functional.interpolate(x, scale_factor=8, mode='bilinear', align_...
    tf.image.resize_bilinear(
        images,
        size,
        align_corners=False,
        name=None
    )
    

    images:Tensor,4维的并且具有形状[batch, height, width, channels].
    size:2个元素(new_height, new_width)的1维int32张量,用来表示图像的新大小.
    align_corners:可选的bool,默认为False;如果为True,则输入和输出张量的4个角像素的中心对齐,并且保留角落像素处的值.
    name:操作的名称(可选).
    tensorflow中地这个语言实现了图片地resize,采用双线性插值地方法,对应pytorch中语言为:

    import torch.nn.functional as F
    x=tensor
    x = nn.functional.interpolate(x, scale_factor=8, mode='bilinear', align_corners=False) 
    

    input (Tensor) – the input tensor
    size (int or Tuple[int] or Tuple[int, int] or Tuple[int, int, int]) – output spatial size.
    mode (str) – algorithm used for upsampling: ‘nearest’ | ‘linear’ | ‘bilinear’ | ‘bicubic’ |‘trilinear’ | ‘area’. Default: ‘nearest’

    展开全文
  • 蠕虫/ tensorflow-pytorch-cuda
  • caffe、tensorflowpytorch协议特点。caffe、TensorflowPytorch卷积填充方式差异、通道顺序差异、使用方式差异;TensorflowPytorch运行机制差异、分布式训练差异、可视化差异、生产部署差异
  • TensorflowPytorch的函数转换 1)http://www.xyu.ink/1785.html 2)https://www.cnblogs.com/wanghui-garcia/p/10775859.html 3)https://www.cnpython.com/qa/353210 仅供学习记录,如侵必删
  • Tensorflow是广泛使用的实现机器学习以及其它涉及大量数学运算的算法库之一。这篇文章主要介绍了Tensorflowpytorch安装(windows安装),需要的朋友可以参考下
  • tensorflowpytorch模型之间转换

    千次阅读 2021-01-13 11:07:11
    参考链接:... 一. tensorflow模型转pytorch模型 import tensorflow as tf import deepdish as dd import argparse import os import numpy as np def tr(v): # tensorflow weights to pytorch weights
  • 关关于于windows下下Tensorflow和和pytorch安安装装教教程程 Tensorflow是广泛使用的实现机器学习以及其它涉及大量数学运算的算法库之一这篇文章主要介绍了Tensorflowpytorch 装 windows 装,需要的朋友可以参考下...
  • anaconda 安装tensorflowpytorch下载anaconda开始安装tensorflow安装pytorch 下载anaconda 清华镜像源(https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/),下载最新的就可以,无脑安装,有个地方需注意...
  • tensorflow+pytorch安装

    2021-05-26 11:00:22
    想配置一个tensorflow+pytorch的环境,辛辛苦苦把tf配置好了结果pytorch又用不了了,真是按下葫芦起了瓢。 安装版本如下: tensorflow-gpu 2.4.1 pytorch 1.7.1 torchvision 0.8.2 torchaudio 0.7.2 cudatoolkit ...
  • C++调用TensorflowPytorch模型

    千次阅读 2019-07-04 14:39:39
    C++调用TensorflowPytorch模型 本文主要介绍在Tensorflowpytorch下使用C++调用Python端训练的模型,进行预测. 本机配置及开发环境 Ubuntu 16.04  RTX 2080Ti Tensorflow 1.14.0  python 3.5  ...
  • 3090显卡安装tensorflow/pytorch一 3090显卡驱动二 安装CUDA11.0三 安装cuDNN四 安装anaconda五 安装tensorflow/pytorch六 安装gdal 我的系统是Ubuntu18.04,这个教程对所有Ubuntu系统都适用,只是要安装正确的显卡...
  • Tensorflow 对比pytorch

    2021-01-27 16:10:10
    1、python x = 0.0 y = 1.0 for iteration in range(50)... tensorflowpytorch对比 """ import tensorflow as tf import keras.backend as K # 设置自增长 config = tf.ConfigProto() config.gpu_options.allow_gr
  • TensorFlowPyTorch

    千次阅读 2020-10-31 16:46:08
    TensorFlowPyTorch对比计算图分布式训练生产部署比较 参考链接: https://zhuanlan.zhihu.com/p/80733307 https://blog.csdn.net/qq_37388085/article/details/102559532 计算图 计算图是一种将计算描述成有向无环...
  • 关于TensorflowPytorch怎么使用GPU加速 关于tensorflowpytorch怎么使用gpu加速,作为一名深度学习的爱好者,总要使用gpu加速程序计算,我在使用这些框架时遇到的一些坑,给大家推荐一下使用gpu加速的方法,帮助...
  • NN框架:Caffe,TensorFlowPyTorch:Caffe介绍、TensorFlow介绍、PyTorch介绍和各种对比优缺点,其他框架
  • TensorFlow or PyTorch

    2020-01-06 11:05:10
    既然你已经读到了这篇文章...你可能查询浏览了各种各样的深度学习的框架和库,但是其中有两个比较突出,他们是两个最流行的深度学习库:TensorFlowPyTorch。你没有办法指出这两个库有什么本质的不同,不用担心!...
  • 基于TensorFlowPyTorch的深度学习框架对比分析.pdf
  • 在这里分别介绍TensorFlowPyTorch的一种方法。 tf.train.exponential_decay() TensorFlow提供了指数衰减法 tf.train.exponential_decay(learning_rate, global_step=global_step, decay_steps=100,decay_rate=0.99...
  • 相信有了这份表格对比,tensorflowpytorch的基本移植转换,应该是手到擒来。 名称 tensorflow pytorch 二维卷积 tf.nn.conv2d(input_x, w, strides=[1, 1, 1, 1], padding='SAME') torch.nn.Conv2d...
  • CV tensorflowpytorch 报错大全Tensorflow1. AttributeError: module 'tensorflow' has no attribute 'placeholder'Pytorch Tensorflow 1. AttributeError: module ‘tensorflow’ has no attribute ‘placeholder...
  • TensorFlowPyTorch各版本对应的CUDA、cuDNN关系

    千次阅读 多人点赞 2021-01-04 16:59:10
    TensorFlowPyTorch各版本对应的CUDA、cuDNN关系(截止2021年1月4日)TensorFowLinuxmacOSWindowsPyTorchCPUGPU 因为之前tensorflowpytorch配环境在cuda上吃过很多亏,主要是版本不匹配造成的,所以自行整理了...
  • anaconda+tensorflow/pytorch最简单安装方法 如果自己之前或别人已经配置好一个tensorflow/pytorch环境,可直接将其envs文件中的环境拷入自己anaconda/envs包中,亲测没问题。 例如下图有两个环境pt和tf1,可直接...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,693
精华内容 15,077
关键字:

tensorflow转pytorch