精华内容
下载资源
问答
  • Pytorch入门教程

    2019-04-08 15:53:46
    2017年出的Pytorch新手教程,整合了近年来深度学习的案例,step by step,从浅入深,帮你开始深度学习之旅。
  • PyTorch入门教程

    2021-03-04 16:21:44
    PyTorch教程 1.PyTorch与其他框架的对比 PyTorch:动态计算图Dynamic Computation Graph; TensorFlow:静态计算图Static Computation Graph。 PyTorch代码通俗易懂,非常接近Python原生代码。 2.什么是PyTorch...

    PyTorch教程

    1.PyTorch与其他框架的对比

    PyTorch:动态计算图Dynamic Computation Graph;

    TensorFlow:静态计算图Static Computation Graph。

    PyTorch代码通俗易懂,非常接近Python原生代码。

    2.什么是PyTorch?

    类似于Numpy,但是它可以使用GPU;

    可以用它定义深度学习模型,可以灵活地进行深度学习模型的训练和使用。

    3.PyTorch代码训练

    3.1构造一个未初始化的5×3矩阵

    >>> import torch

    >>> x=torch.empty(5,3)

    >>> x

    tensor([[9.1834e-41, 0.0000e+00, 0.0000e+00],

            [0.0000e+00, 0.0000e+00, 0.0000e+00],

            [0.0000e+00, 0.0000e+00, 0.0000e+00],

            [0.0000e+00, 5.9415e-43, 0.0000e+00],

            [0.0000e+00, 0.0000e+00, 0.0000e+00]])

    3.2构造一个随机初始化的矩阵

    >>> torch.rand(5,3)

    tensor([[0.2936, 0.7109, 0.6839],

            [0.9778, 0.2583, 0.6170],

            [0.9016, 0.3895, 0.2596],

            [0.0357, 0.9415, 0.0640],

            [0.9949, 0.1010, 0.8019]])

    3.3构建一个全部为0,类型为long的矩阵

    >>> x=torch.zeros(5,3,dtype=torch.long)

    >>> x

    tensor([[0, 0, 0],

            [0, 0, 0],

            [0, 0, 0],

            [0, 0, 0],

            [0, 0, 0]])

    >>> x.dtype

    torch.int64

    3.4从数据直接构建tensor

    >>> x=torch.tensor([5.5,3])

    >>> x

    tensor([5.5000, 3.0000])

     

    3.5也可以从一个已有的tensor构件一个tensor,这些方法会重用原来tensor的特征,例如,数据类型,除非提供新的数据。

    >>> x=x.new_ones(5,3)

    >>> x

    tensor([[1., 1., 1.],

            [1., 1., 1.],

            [1., 1., 1.],

            [1., 1., 1.],

            [1., 1., 1.]])

    >>> x=x.new_ones(5,3,dtype=torch.double)

    >>> x

    tensor([[1., 1., 1.],

            [1., 1., 1.],

            [1., 1., 1.],

            [1., 1., 1.],

            [1., 1., 1.]], dtype=torch.float64)

    >>> x=torch.randn_like(x,dtype=torch.float)

    >>> x

    tensor([[ 1.0381,  0.1043,  1.5760],

            [-0.6895,  0.3802,  1.3165],

            [ 0.5803,  0.8689, -0.7618],

            [-0.9795,  0.5561, -0.3179],

            [-0.7121,  1.0454, -0.6295]])

    3.6得到tensor的形状

    >>> x.shape

    torch.Size([5, 3])

    3.7运算

    3.7.1加法

    >>> y=torch.rand(5,3)

    >>> y

    tensor([[0.0149, 0.7933, 0.0335],

            [0.7218, 0.8258, 0.4340],

            [0.7336, 0.6049, 0.3085],

            [0.1247, 0.2118, 0.9186],

            [0.0502, 0.6861, 0.9377]])

    >>> x

    tensor([[ 1.0381,  0.1043,  1.5760],

            [-0.6895,  0.3802,  1.3165],

            [ 0.5803,  0.8689, -0.7618],

            [-0.9795,  0.5561, -0.3179],

            [-0.7121,  1.0454, -0.6295]])

    >>> x+y

    tensor([[ 1.0530,  0.8976,  1.6095],

            [ 0.0323,  1.2060,  1.7505],

            [ 1.3138,  1.4738, -0.4533],

            [-0.8549,  0.7679,  0.6007],

            [-0.6619,  1.7315,  0.3082]])

    另一种加法的写法

    >>> torch.add(x,y)

    tensor([[ 1.0530,  0.8976,  1.6095],

            [ 0.0323,  1.2060,  1.7505],

            [ 1.3138,  1.4738, -0.4533],

            [-0.8549,  0.7679,  0.6007],

            [-0.6619,  1.7315,  0.3082]])

    加法:把输出作为一个变量

    >>> result=torch.empty(5,3)

    >>> torch.add(x,y,out=result)

    tensor([[ 1.0530,  0.8976,  1.6095],

            [ 0.0323,  1.2060,  1.7505],

            [ 1.3138,  1.4738, -0.4533],

            [-0.8549,  0.7679,  0.6007],

            [-0.6619,  1.7315,  0.3082]])

    In-place加法

    >>> y.add_(x)

    tensor([[ 1.0530,  0.8976,  1.6095],

            [ 0.0323,  1.2060,  1.7505],

            [ 1.3138,  1.4738, -0.4533],

            [-0.8549,  0.7679,  0.6007],

            [-0.6619,  1.7315,  0.3082]])

    3.8各种类似NumPy的indexing都可以在PyTorch tensor上面使用。

    >>> x[1:,1:]

    tensor([[ 0.3802,  1.3165],

            [ 0.8689, -0.7618],

            [ 0.5561, -0.3179],

            [ 1.0454, -0.6295]])

    3.9Resizing:如果希望resize/reshape一个tensor,可以使用torch.view

     

    >>> x=torch.randn(4,4)

    >>> x

    tensor([[ 2.6453, -1.1685, -0.0857,  1.1225],

            [ 0.1149,  0.2192,  0.9528, -0.2612],

            [-0.8304, -0.5425,  0.3017, -1.3451],

            [ 0.5863,  1.0294,  0.0201,  0.4943]])

    >>> y=x.view(16)

    >>> y

    tensor([ 2.6453, -1.1685, -0.0857,  1.1225,  0.1149,  0.2192,  0.9528, -0.2612,

            -0.8304, -0.5425,  0.3017, -1.3451,  0.5863,  1.0294,  0.0201,  0.4943])

    >>> z=x.view(2,-1)

    >>> z

    tensor([[ 2.6453, -1.1685, -0.0857,  1.1225,  0.1149,  0.2192,  0.9528, -0.2612],

            [-0.8304, -0.5425,  0.3017, -1.3451,  0.5863,  1.0294,  0.0201,  0.4943]])

    如果只有一个元素的tensor,使用.item()方法可以把里面的value变成Python数值

    >>> x=torch.randn(1)

    >>> x

    tensor([-1.5002])

    >>> x.item()

    -1.500231146812439

    >>> z.transpose(1,0)

    tensor([[ 2.6453, -0.8304],

            [-1.1685, -0.5425],

            [-0.0857,  0.3017],

            [ 1.1225, -1.3451],

            [ 0.1149,  0.5863],

            [ 0.2192,  1.0294],

            [ 0.9528,  0.0201],

            [-0.2612,  0.4943]])

    查看PyTorch文件网址:https://pytorch.org/docs/stable/torch.html

    4.Numpy和Tensor之间的转化

    在Torch Tensor和Numpy array之间相互转化非常容易。

    Torch Tensor和Numpy array会共享内存,所以改变其中一项也会改变另一项。

    把Torch Tensor转变成Numpy Array

    >>> a=torch.ones(5)

    >>> a

    tensor([1., 1., 1., 1., 1.])

    >>> b=a.numpy()

    >>> b

    array([1., 1., 1., 1., 1.], dtype=float32)

    改变Numpy array里面的值。

    >>> b[1]=2

    >>> b

    array([1., 2., 1., 1., 1.], dtype=float32)

    >>> a

    tensor([1., 2., 1., 1., 1.])

    把NUmpy Array转变成Torch Tensor

    >>> import numpy as np

    >>> a=np.ones(5)

    >>> b=torch.from_numpy(a)

    >>> np.add(a,1,out=a)

    array([2., 2., 2., 2., 2.])

    >>> b

    tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

    5.热身:用Numpy实现两层神经网络

    一个全连接ReLU神经网络,一个隐藏层,没有bias。用来从x预测y,使用L2Loss。

    ·h=W1X+b1

    ·a=max(0,h)

    ·yhat=w2a+b2

    这一实现完全使用Numpy来计算钱箱神经网络,loss,和反向传播。

    ·forward pass

    ·loss

    ·backward pass

    Numpy ndarray是一个普通的n维array,他不知道任何关于深度学习或者梯度(gradient)的知识,也不知道计算图(computation graph),只是一种用来计算数学运算的数据结构。

    import numpy as np

    N,D_in,H,D_out=64,1000,100,10#N是数据集个数,D_in是输入数据维数,H是中间神经元的维数,D_out是输出神经元的维数

    #随机创建一些训练数据

    x=np.random.randn(N,D_in)

    y=np.random.randn(N,D_out)

     

    w1=np.random.randn(D_in,H)

    w2=np.random.randn(H,D_out)

     

    learning_rate=1e-6

    for it in range(500):

    #Forward pass

    h=x.dot(w1)#N*H

    h_relu=np.maximum(h,0)#N*H

    y_pred=h_relu.dot(w2)#N*D_out

     

    #compute loss

    loss=np.square(y_pred-y).sum()

    print(it,loss)

     

    #backward pass

    #compute the gradient

    grad_y_pred=2.0*(y_pred-y)

    grad_w2=h_relu.T.dot(grad_y_pred)

    grad_h_relu=grad_y_pred.dot(w2.T)

    grad_h=grad_h_relu.copy()

    grad_h[h<0]=0

    grad_w1=x.T.dot(grad_h)

     

    #update weights of w1 and w2

    w1=learning_rate*grad_w1

    w2=learning_rate*grad_w2

     

     

    展开全文
  • pytorch基础教程

    2021-01-07 01:02:59
    基础部分 基本数据类型 Data type 常用的有torch.FloatTensor, torch.DoubleTensor, torch.IntTensor, torch.ByteTensor, torch.LongTensor。 如何标注string呢? 在pytorch中使用One-hot(独热编码)来表示string...
  • pytorch入门教程

    千次阅读 2018-07-21 17:17:13
    pytorch与tensorflow区别 https://yq.aliyun.com/articles/183473 pytorch安装 进入官网:https://pytorch.org/ 根据配置可以生成相应的安装命令,运行之后,会安装torch和torchvision这两个库。 torch 是主...

    pytorch与tensorflow区别

    https://yq.aliyun.com/articles/183473

    pytorch安装

    进入官网:https://pytorch.org/
    根据配置可以生成相应的安装命令,运行之后,会安装torchtorchvision这两个库。 torch 是主模块, 用来搭建神经网络; torchvision 是辅模块, 有数据库, 还有一些已经训练好的神经网络可以直接使用 , 比如 (VGG, AlexNet, ResNet)

    Tensor的创建和操作

    参考:http://pytorch-cn.readthedocs.io/zh/latest/package_references/Tensor/
    pytorch与numpy
    pytorch相当于神经网络中的numpy库,pytorch与numpy具有很好的兼容性,pytorch中的tensor与numpy中的array能自由转换。

    numpy_data = np.arange(4).reshape(2, 2)
    torch_data = torch.from_numpy(numpy_data)
    tensor2array = torch_data.numpy()

    通过torch.Tensor创建张量
    张量tensor可以从Python的list或序列构建:

    >>> torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
    tensor([[ 1.,  2.,  3.],
            [ 4.,  5.,  6.]])

    空张量tensor可以通过规定其大小来构建:

    >>> torch.IntTensor(2, 4).zero_()
    tensor([[ 0,  0,  0,  0],
            [ 0,  0,  0,  0]], dtype=torch.int32)

    以用python的索引和切片来获取和修改一个张量tensor中的内容:

    >>> x = torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
    >>> x[1][2]
    tensor(6.)
    >>> print(x[1][2])
    tensor(6.)
    >>> type(x[1][2])
    <class 'torch.Tensor'>
    >>> x[0][1]=100
    >>> x
    tensor([[   1.,  100.,    3.],
            [   4.,    5.,    6.]])

    tensor函数操作
    改变tensor的函数操作会用一个下划线后缀来标示。比如,torch.FloatTensor.abs_()会在原地计算绝对值,并返回改变后的tensor,而tensor.FloatTensor.abs()将会在一个新的tensor中计算结果。
    常用操作:
    tensor的加法:

    • torch.add(input, value, out=None)
      对输入张量input逐元素加上标量值value,并返回结果到一个新的张量out
    >>> a = torch.randn(4)
    >>> a
    tensor([ 0.1280, -0.1634, -0.5978,  0.4619])
    >>> torch.add(a, 20)
    tensor([ 20.1280,  19.8366,  19.4022,  20.4619])
    • torch.add(input, value=1, other, out=None)
      other 张量的每个元素乘以一个标量值value,并加到input 张量上。返回结果到输出张量out
    >>> a = torch.randn(2,2)
    >>> a
    tensor([[-1.5407, -2.6222],
            [-0.4579, -0.9512]])
    >>> b = torch.randn(2, 2)
    >>> b
    tensor([[ 0.1718,  0.4251],
            [-0.6100,  1.3532]])
    >>> torch.add(a, 10, b)
    tensor([[  0.1777,   1.6285],
            [ -6.5576,  12.5812]])

    tensor的乘法

    • torch.mul(input, value, out=None)
      用标量值value乘以输入input的每个元素,并返回一个新的结果张量
    >>> a
    tensor([-0.4965, -0.1719, -0.9845])
    >>> torch.mul(a, 100)
    tensor([-49.6475, -17.1865, -98.4483])
    • torch.mul(input, other, out=None)
      两个张量input,other按元素位置进行相乘,并返回到输出张量
    >>> a
    tensor([[ 1,  2],
            [ 3,  4]], dtype=torch.int32)
    >>> b = torch.IntTensor([[1,1],[1,1]])
    >>> torch.mul(a, b)
    tensor([[ 1,  2],
            [ 3,  4]], dtype=torch.int32)

    矩阵相乘:
    - torch.mm(mat1, mat2, out=None) → Tensor
    对矩阵mat1和mat2进行相乘。 如果mat1 是一个n×m 张量,mat2 是一个 m×p 张量,将会输出一个 n×p 张量out。

    >>> torch.mm(a, b)
    tensor([[ 3,  3],
            [ 7,  7]], dtype=torch.int32)

    变量的定义和误差反向传播

    由于autograd只支持标量值的反向求导(即:y是标量),梯度的大小总是和数据的大小匹配。使用requires_grad=True属性来确定用于更新梯度的变量。

    import torch
    
    # requires_grad=True表明该张量为变量,需要更新梯度
    x = torch.tensor([[1.,2.],[3.,4.]], requires_grad=True)
    # 求梯度的函数的输出结果只能是标量
    # 否则出现grad can be implicitly created only for scalar outputs的错误
    # 例如y=x*x是不对的,因为此时的输出结果为多维的tensor
    y = torch.mean(x*x)
    
    y.backward()
    print(y)    # tensor(7.5000)
    
    print(x.grad.numpy())  # 输出梯度
    '''
    [[0.5 1. ]
     [1.5 2. ]]
    '''
    
    
    # 转为numpy格式,
    # 包含梯度运算的张量不能直接转为numpy的array
    '''将计算图中的tensor转为numpy的方法'''
    # 使用data属性访问原始的tensor,返回的tensor依旧指向x
    print(x.data.numpy())
    
    # 会用detach方法从计算图中分离出一个新的张量
    print(x.detach().numpy())
    '''
    [[ 1.  2.]
     [ 3.  4.]]
    '''
    
    展开全文
  • pytorch 入门教程

    2020-04-29 14:51:26
    http://pytorchchina.com/2018/12/25/training-a-classifier/
    展开全文
  • Pytorch 入门教程

    2019-08-07 15:56:55
    一、定义/初始化张量Define tensors ...PyTorch中定义tensor,就跟numpy定义矩阵、向量差不多,例如定义一个5×3的tensor,每一项都是0的张量:x = torch.zeros(5,3) 如果想查看某个tensor的形状的话...

    一、定义/初始化张量Define tensors

    tensor,即“张量”。实际上跟numpy数组、向量、矩阵的格式基本一样。但是是专门针对GPU来设计的,可以运行在GPU上来加快计算效率。

    PyTorch中定义tensor,就跟numpy定义矩阵、向量差不多,例如定义一个5×3的tensor,每一项都是0的张量:
    x = torch.zeros(5,3)

    如果想查看某个tensor的形状的话,使用:
    z.size(),或者z.shape,但是前者更常用。

    下面列举一些常用的定义tensor的方法:

    常数初始化:

    • torch.empty(size)返回形状为size的空tensor
    • torch.zeros(size)全部是0的tensor
    • torch.zeros_like(input)返回跟input的tensor一个size的全零tensor
    • torch.ones(size)全部是1的tensor
    • torch.ones_like(input)返回跟input的tensor一个size的全一tensor
    • torch.arange(start=0, end, step=1)返回一个从start到end的序列,可以只输入一个end参数,就跟python的range()一样了。实际上PyTorch也有range(),但是这个要被废掉了,替换成arange了
    • torch.full(size, fill_value)这个有时候比较方便,把fill_value这个数字变成size形状的张量

    随机抽样(随机初始化):

    • torch.rand(size) [0,1)内的均匀分布随机数
    • torch.rand_like(input)返回跟input的tensor一样size的0-1随机数
    • torch.randn(size)返回标准正太分布N(0,1)的随机数
    • torch.normal(mean, std, out=None)正态分布。这里注意,mean和std都是tensor,返回的形状由mean和std的形状决定,一般要求两者形状一样。如果,mean缺失,则默认为均值0,如果std缺失,则默认标准差为1.

    更多的随机抽样方法,参见链接:
    https://pytorch.org/docs/stable/torch.html#random-sampling


    二、基本操作、运算 Basic operations

    1.tensor的切片、合并、变形、抽取操作

    (Indexing, Slicing, Joining, Mutating)

    这里我就简单总结一些重要的tensor基本操作:

    • torch.cat(seq, dim=0, out=None),把一堆tensor丢进去,按照dim指定的维度拼接、堆叠在一起.
      比如:
    In [70]: x = torch.tensor([[1,2,3]])
    In [71]: x
    Out[71]: tensor([[1, 2, 3]])
    
     #按第0维度堆叠,对于矩阵,相当于“竖着”堆
    In [72]: print(torch.cat((x,x,x),0))
    tensor([[1, 2, 3],
            [1, 2, 3],
            [1, 2, 3]])
    
     #按第1维度堆叠,对于矩阵,相当于“横着”拼
    In [73]: print(torch.cat((x,x,x),1)) 
    tensor([[1, 2, 3, 1, 2, 3, 1, 2, 3]])
    
    • torch.chunk(tensor, chunks, dim=0)把tensor切成块,数量由chunks指定。
      例如:
    In [74]: a = torch.arange(10)
    In [75]: a
    Out[75]: tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    
    In [76]: torch.chunk(a,4)
    Out[76]: (tensor([0, 1, 2]), tensor([3, 4, 5]), tensor([6, 7, 8]), tensor([9]))
    
    • 切块还有torch.split(tensor, split_size_or_sections, dim=0)具体区别大家自行查阅文档
    • 按index选择:torch.index_select(input, dim, index, out=None)
    • 按mask选择:torch.masked_select(input, mask, out=None)
    • 经常会使用的“压扁”函数:torch.squeeze(input),压缩成1维。注意,压缩后的tensor和原来的tensor共享地址
    • 改变形状:torch.reshape(input, shape)以及tensor.view(shape).前者是把tensor作为函数的输入,后者是任何tensor的函数。实际上,二者的返回值,都只是让我们从另一种视角看某个tensor,所以不会改变本来的形状,除非你把结果又赋值给原来的tensor。下面给一个例子对比二者的用法:
    In [82]: a
    Out[82]: tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    
    # 单纯的调用view函数:
    In [83]: a.view(2,5)
    Out[83]:
    tensor([[0, 1, 2, 3, 4],
            [5, 6, 7, 8, 9]])
    
    # a的形状并不会变化
    In [84]: print(a) 
    tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    
    # 试试reshape函数:
    In [86]: torch.reshape(a,[5,2])
    Out[86]:
    tensor([[0, 1],
            [2, 3],
            [4, 5],
            [6, 7],
            [8, 9]])
    
    # a的形状依然不会变化:
    In [87]: a
    Out[87]: tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    

    要想让a的形状变化,比如把结果赋值给a,比如a = a.view(2,5)

    还有好多有意思的操作,自己去发掘吧:
    https://pytorch.org/docs/stable/torch.html#indexing-slicing-joining-mutating-ops

    2.基本数学操作

    • 加法直接加:x+y
      或者用torch.add(x,y).
      实际上,.add()可以接受三个参数:torch.add(input, value, out=None)
      out怎么用呢?一般,如果直接torch.add(x,y),那么x,y本身都不会变化的。但是如果设置out=x,那么x就变变成加和后的值。

    特别的,若想进行in-place操作,就比方说y加上x,y的值就改变了,就可以用y.add_(x)这样y就直接被改变了。Torch里面所有带"_"的操作,都是in-place的。例如x.copy_(y)

    • 乘法:torch.mul(input, other, out=None)用input乘以other
    • 除法:torch.div(input, other, out=None)用input除以other
    • 指数:torch.pow(input, exponent, out=None)
    • 开根号:torch.sqrt(input, out=None)
    • 四舍五入到整数:torch.round(input, out=None)
    • argmax函数torch.argmax(input, dim=None, keepdim=False)返回指定维度最大值的序号,dim给定的定义是:the demention to reduce.也就是把dim这个维度的,变成这个维度的最大值的index。例如:

      argmax

    • sigmoid函数:torch.sigmoid(input, out=None)
    • tanh函数:torch.tanh(input, out=None)
    • torch.abs(input, out=None)取绝对值
    • torch.ceil(input, out=None)向上取整,等于向下取整+1
    • torch.clamp(input, min, max, out=None)刀削函数,把输入数据规范在min-max区间,超过范围的用min、max代替

    太多了,基本上,numpy里面有的数学函数这里都有,能想到的的基本都有。所以更详细的内容,还是去查看文档吧哈哈:
    https://pytorch.org/docs/stable/torch.html#math-operations

    三、Torch Tensor与Numpy的互相转换

    • Tensor-->Numpy
      直接用.numpy()即可。但是注意,转换后,numpy的变量和原来的tensor会共用底层内存地址,所以如果原来的tensor改变了,numpy变量也会随之改变。参见下面的例子:
    In [11]: a = torch.ones(2,4)
    In [12]: a
    Out[12]:
    tensor([[1., 1., 1., 1.],
            [1., 1., 1., 1.]])
    
    In [13]: b = a.numpy()
    In [14]: b
    Out[14]:
    array([[1., 1., 1., 1.],
           [1., 1., 1., 1.]], dtype=float32)
    
    In [15]: a.add_(1)
    Out[15]:
    tensor([[2., 2., 2., 2.],
            [2., 2., 2., 2.]])
    
    In [16]: b
    Out[16]:
    array([[2., 2., 2., 2.],
           [2., 2., 2., 2.]], dtype=float32)
    
    • Numpy-->Tensor
      torch.from_numpy()来转换。参见下面例子:
    import numpy as np
    a = np.ones(5)
    b = torch.from_numpy(a)
    np.add(a, 1, out=a)
    print(a)
    print(b)
    

    输出:

    [2. 2. 2. 2. 2.]
    tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
    

    同样,两者会共用内存地址。

    好啦,本篇就这么些了,快去练习一下吧!
    参考链接:
    PyTorch文档:https://pytorch.org/docs/torch


    链接:https://www.jianshu.com/p/7dbfc7076e5a
     

    展开全文
  • Pytorch 入门教程(二)Pytorch 入门教程(一)1. 张量Tensor2. Pytorch中创建张量3. Pytorch中tensor的常用方法4. tensor的数据类型5. tensor的其他操作 Pytorch 入门教程(一) 请参考:【超详细】Pytorch 入门...
  • Pytorch入门教程(一)基础

    千次阅读 2017-11-15 19:37:56
    Pytorch入门教程Pytorch基础这一部分主要介绍Pytorch的处理对象以及操作。Pytorch的两个操作对象 Tensor 首先介绍最基本的操作单元Tensor。Tensor就是张量的英文,表示多维的矩阵,比如一维就是向量,二维就是一般的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,227
精华内容 4,090
关键字:

pytorch入门教程