精华内容
下载资源
问答
  • Pytorch 张量维度

    万次阅读 2019-06-21 17:35:52
    Tensor类的成员函数dim()可以返回张量维度,shape属性与成员函数size()返回张量的具体维度分量,如下代码定义了一个两行三列的张量: f = torch.randn(2, 3) print(f.dim()) print(f.size()) print(f.shape) ...

    Tensor类的成员函数dim()可以返回张量的维度,shape属性与成员函数size()返回张量的具体维度分量,如下代码定义了一个两行三列的张量:

    f = torch.randn(2, 3)
    print(f.dim())
    print(f.size())
    print(f.shape)

    输出结果:

    2
    torch.Size([2, 3])
    torch.Size([2, 3])

    dim=0的标量

    维度为0的Tensor为标量,标量一般用在Loss这种地方。如下代码定义了一个标量:

    import torch
    
    a = torch.tensor(1.6)  # dimension为0就是标量了
    print(a, a.type())
    
    # 一些检验维度的方法
    print(a.dim())
    print(a.shape, a.size())
    print(len(a.shape), len(a.size()))
    
    

    输出结果:

    tensor(1.6000) torch.FloatTensor
    0
    torch.Size([]) torch.Size([])
    0 0

    定义标量的方式很简单,只要在tensor函数中传入一个标量初始化的值即可,注意是具体的数据。

    注意:

    Pytorch中的torch.tensor()是一个函数,函数的原形如下:

    torch.tensor(data, dtype=None, device=None, requires_grad=False)

    其中data可以是:list、tuple、NumPy ndarray、scalar和其他类型。torch.tensor会从data中的数据部分做拷贝(而不是直接引用),根据原始数据类型生成相应的torch.LongTensor、torch.FloatTensor和torch.DoubleTensor。

    而torch.Tensor()是Pytorch中的一个类,是默认张量类型torch.FloatTensor()的别名。

    Tensor与tensor的区别,具体可参考https://blog.csdn.net/tfcy694/article/details/85338745

    注意一点,torch.tensor()参数接收的是具体的数据,而torch.Tensor()参数既可以接收数据也可以接收维度分量也就是shape。

    dim=1的张量

    dim=1的Tensor一般用在Bais这种地方,或者神经网络线性层的输入Linear Input,例如MINST数据集的一张图片用shape=[784]的Tensor来表示。

    dim=1相当于只有一个维度,但是这个维度上可以有多个分量(就像一维数组一样),一维的张量实现方法有很多,下面是三种实现:

    import torch
    import numpy as np
    
    
    def printMsg(k):
    	"""输出Tensor的信息,维度,shape"""
    	print(k, k.dim(), k.size(), k.shape)
    
    
    # 1.通过torch.tensor(), 参数传入一个list构造dim=1的Tensor
    a = torch.tensor([1.1])
    printMsg(a)
    b = torch.tensor([1.1, 2.2])
    printMsg(b)
    
    print("-" * 20)
    
    # 2.通过torch.Tensor(), 随机构造dim=1的Tensor
    # 这里传入的是shape=1,有1个元素
    c = torch.FloatTensor(1)
    printMsg(c)
    # 这里传入的是shape=2,有2个元素
    d = torch.FloatTensor(2)
    printMsg(d)
    
    print("-" * 20)
    
    # 3.从numpy构造dim=1的Tensor
    e = np.ones(2)
    print(e)
    e = torch.from_numpy(e)
    printMsg(e)

    输出结果:

    tensor([1.1000]) 1 torch.Size([1]) torch.Size([1])
    tensor([1.1000, 2.2000]) 1 torch.Size([2]) torch.Size([2])
    --------------------
    tensor([1.5056e-38]) 1 torch.Size([1]) torch.Size([1])
    tensor([0., 0.]) 1 torch.Size([2]) torch.Size([2])
    --------------------
    [1. 1.]
    tensor([1., 1.], dtype=torch.float64) 1 torch.Size([2]) torch.Size([2])

     

    dim=2的张量

    dim=2的张量一般用在带有batch的Linear Input,例如MNIST数据集的k张图片如果放再一个Tensor里,那么shape=[k,784]。

    如下示例:

    import torch
    
    # dim=2,shape=[2,3],随机生成Tensor
    a = torch.FloatTensor(2, 3)
    
    print(a.shape)
    print(a.shape[0])
    print(a.shape[1])
    
    print(a.size())
    print(a.size(0))
    print(a.size(1))

    输出结果:

    torch.Size([2, 3])
    2
    3
    torch.Size([2, 3])
    2
    3

    从上面可以看出,可以取到Tensor每一维度的分量 。

    dim=3的张量

    dim=3的张量很适合用于RNN和NLP,如20句话,每句话10个单词,每个单词用100个分量的向量表示,得到的Tensor就是shape=[20,10,100]。

    示例代码:

    import torch
    
    # dim=3,shape=[1,2,3],随机取0~1之间的数
    a = torch.rand(1, 2, 3)
    print(a)
    print(a.dim())
    print(a.shape)
    print(a.size())
    
    b = a[0]  # 在第一个维度上取,得到的就是shape=[2,3]的dim=2的Tensor
    print(b.dim())
    print(b.shape)
    print(b.size())
    
    # 将torch.Size()转换为python列表的形式
    list(a.shape)

     输出结果:

    tensor([[[0.3503, 0.2163, 0.7880],
             [0.0933, 0.0372, 0.9077]]])
    3
    torch.Size([1, 2, 3])
    torch.Size([1, 2, 3])
    2
    torch.Size([2, 3])
    torch.Size([2, 3])
    [1, 2, 3]

    dim=4的张量

    dim=4的张量适合用于CNN表示图像,例如100张MNIST手写数据集的灰度图(通道数为1,如果是RGB图像通道数就是3),每张图高=28像素,宽=28像素,所以这个Tensor的shape=[100,1,28,28],也就是一个batch的数据维度:[batch_size,channel,height,width] 。

    如下构建一个shape=[2, 3, 28, 28]的Tensor:

    import torch
    
    a = torch.rand(2, 3, 28, 28)
    print(a)
    print(a.shape)

    输出结果:

    tensor([[[[0.0788, 0.1869, 0.2921,  ..., 0.0653, 0.3229, 0.1024],
              [0.5636, 0.4804, 0.6982,  ..., 0.3832, 0.9984, 0.5522],
              [0.5650, 0.8758, 0.2636,  ..., 0.5024, 0.5592, 0.2962],
              ...,
              [0.6311, 0.8914, 0.1481,  ..., 0.9255, 0.4388, 0.6771],
              [0.1691, 0.6803, 0.0111,  ..., 0.8962, 0.4907, 0.7369],
              [0.7360, 0.3643, 0.9757,  ..., 0.6954, 0.5979, 0.2019]],
    
             [[0.1387, 0.1379, 0.7730,  ..., 0.3476, 0.6346, 0.5387],
              [0.2940, 0.2296, 0.5864,  ..., 0.0558, 0.4093, 0.4563],
              [0.1498, 0.1705, 0.4542,  ..., 0.0370, 0.5867, 0.4178],
              ...,
              [0.6814, 0.3024, 0.8031,  ..., 0.0425, 0.4695, 0.3253],
              [0.5721, 0.9202, 0.1709,  ..., 0.7571, 0.6944, 0.7455],
              [0.4426, 0.3546, 0.9652,  ..., 0.2672, 0.0161, 0.3755]],
    
             [[0.1455, 0.2020, 0.2242,  ..., 0.5136, 0.5918, 0.9750],
              [0.1039, 0.1641, 0.1945,  ..., 0.1314, 0.6887, 0.2439],
              [0.0275, 0.1987, 0.5682,  ..., 0.0732, 0.7392, 0.8445],
              ...,
              [0.0180, 0.7265, 0.0541,  ..., 0.0939, 0.4592, 0.7898],
              [0.2253, 0.2115, 0.6485,  ..., 0.0314, 0.0185, 0.5788],
              [0.4660, 0.9765, 0.1458,  ..., 0.3520, 0.7162, 0.4895]]],
    
    
            [[[0.3837, 0.1531, 0.9617,  ..., 0.3220, 0.3959, 0.6391],
              [0.4072, 0.0711, 0.5841,  ..., 0.9417, 0.5799, 0.9794],
              [0.0307, 0.1862, 0.0766,  ..., 0.8336, 0.6978, 0.4468],
              ...,
              [0.8934, 0.0480, 0.9964,  ..., 0.8817, 0.3746, 0.6780],
              [0.7201, 0.5030, 0.2582,  ..., 0.9542, 0.8955, 0.0750],
              [0.5892, 0.8647, 0.3251,  ..., 0.5489, 0.5575, 0.3004]],
    
             [[0.0630, 0.1473, 0.7858,  ..., 0.3695, 0.2419, 0.4843],
              [0.7736, 0.6974, 0.8900,  ..., 0.3137, 0.4747, 0.9298],
              [0.8021, 0.3490, 0.8568,  ..., 0.5600, 0.2382, 0.0054],
              ...,
              [0.4725, 0.7952, 0.5935,  ..., 0.3612, 0.9396, 0.2763],
              [0.3715, 0.8464, 0.0258,  ..., 0.2218, 0.0808, 0.9323],
              [0.2634, 0.8852, 0.7021,  ..., 0.4925, 0.6998, 0.0013]],
    
             [[0.7005, 0.2593, 0.1891,  ..., 0.2242, 0.9181, 0.4466],
              [0.2316, 0.1313, 0.6365,  ..., 0.2096, 0.4597, 0.0361],
              [0.2662, 0.8333, 0.4361,  ..., 0.5952, 0.0086, 0.8168],
              ...,
              [0.0641, 0.5702, 0.9628,  ..., 0.0303, 0.9381, 0.9755],
              [0.6629, 0.5515, 0.5912,  ..., 0.5070, 0.1345, 0.2626],
              [0.6316, 0.1251, 0.1719,  ..., 0.6973, 0.2206, 0.2461]]]])
    torch.Size([2, 3, 28, 28])
    

    计算Tensor中元素的数目

    示例代码:

    import torch
    
    a = torch.rand(10, 1, 28, 28)
    print(a.numel())  # number of element 10*1*28*28=7840

    输出结果:

    7840

     

    展开全文
  • Pytorch张量维度操作

    2020-05-28 23:54:55
    目录张量维度扩充torch.cat(seq,dim=0,out=None)torch.Tensor.expand(*sizes)张量压缩(删除是1的维度)torch.squeeze(input, dim=None, out=None)重复张量torch.Tensor.repeat(*sizes)缩小张量torch.Tensor.narrow...

    张量维度扩充

    torch.cat(seq,dim=0,out=None)

    torch.cat()是将张量序列在维度dim上进行拼接操作。
    参数说明

    • seq (sequence of Tensors) - Python序列或相同类型的张量序列
    • dim (int, optional) - 沿着此维度连接张量
    • out (Tensor, optional) - 输出参数

    例子:

    import torch 
    x = torch.randn(1,2)
    print(x)
    print(x.size())
    # dim = 0
    y = torch.cat((x,x),0)
    print(y)
    print(y.size())
    # dim = 1
    z = torch.cat((x,x),1)
    print(z)
    print(z.size())
    

    tensor([[-1.0672, -0.0664]])
    torch.Size([1, 2])
    tensor([[-1.0672, -0.0664],
    [-1.0672, -0.0664]])
    torch.Size([2, 2])
    tensor([[-1.0672, -0.0664, -1.0672, -0.0664]])
    torch.Size([1, 4])

    torch.Tensor.expand(*sizes)

    返回张量的一个新视图,可以将张量的单个维度扩大为更大的尺寸。
    张量也可以扩大为更高维,新增加的维度将附在前面。 扩大张量不需要分配新内存,仅仅是新建一个张量的视图。任意一个一维张量在不分配新内存情况下都可以扩展为任意的维度。
    传入-1则意味着维度扩大不涉及这个维度。
    参数:
    sizes (torch.Size or int…) – 想要扩展的目标维度
    例子:

    import torch
    x = torch.randn(3)
    print(x)
    print(x.size())
    y = x.expand(3,4)
    print(y)
    print(y.size())
    

    这样使用,会报错的,
    RuntimeError: The expanded size of the tensor (4) must match the existing size (3) at non-singleton dimension 1. Target sizes: [3, 4]. Tensor sizes: [3]
    因为默认的是向前拓展维度,所以拓展的最后一个维度必须是3,如果想要向后拓展,可以先增加x的一个维度,操作如下:

    import torch
    x = torch.randn(3)
    print(x)
    print(x.size())
    y = x.unsqueeze(1).expand(3,4)
    print(y)
    print(y.size())
    

    tensor([0.8265, 0.5117, 0.8278])
    torch.Size([3])
    tensor([[0.8265, 0.8265, 0.8265, 0.8265],
    [0.5117, 0.5117, 0.5117, 0.5117],
    [0.8278, 0.8278, 0.8278, 0.8278]])
    torch.Size([3, 4])

    张量压缩(删除是1的维度)

    torch.squeeze(input, dim=None, out=None)

    除去输入张量input中数值为1的维度,并返回新的张量。如果输入张量的形状为Ax1xBx1xC,那么输出张量的形状为AxBxC。

    当通过dim参数指定维度时,维度压缩操作只会在指定的维度上进行。如果输入向量的形状为Ax1xB,squeeze(input, 0)会保持张量的维度不变,只有在执行squeeze(input, 1)时,输入张量的形状会被压缩至AxB。
    如果一个张量只有1个维度,那么它不会受到上述方法的影响。
    输出的张量与原张量共享内存,如果改变其中的一个,另一个也会改变。
    参数:
    input (Tensor) – 输入张量
    dim (int, optional) – 如果给定,则只会在给定维度压缩
    out (Tensor, optional) – 输出张量
    例子:

    import torch
    x = torch.randn((2,1,3,1,4))
    print(x)
    print(x.size())
    # 删除所有的为1的维度
    y = torch.squeeze(x)
    print('删除所有的为1的维度')
    print(y)
    print(y.size())
    # 在第0维上压缩,实际上不变
    y = torch.squeeze(x, 0)
    print('在第0维上压缩,实际上不变')
    print(y)
    print(y.size())
    # 在第1维上压缩
    y = torch.squeeze(x, 1)
    print('在第1维上压缩')
    print(y)
    print(y.size())
    

    tensor([[[[[ 1.0232, -0.0252, -0.1088, -1.8738]],
    [[-1.5453, 0.1855, -1.1249, 1.4581]],
    [[ 0.5415, -0.3716, 0.2359, 0.9390]]]],
    [[[[-0.8668, 0.5324, 0.7221, 0.6134]],
    [[-0.4285, 0.5667, 0.5340, -0.6971]],
    [[ 1.8294, 0.0185, -0.2730, 0.0775]]]]])
    torch.Size([2, 1, 3, 1, 4])
    删除所有的为1的维度
    tensor([[[ 1.0232, -0.0252, -0.1088, -1.8738],
    [-1.5453, 0.1855, -1.1249, 1.4581],
    [ 0.5415, -0.3716, 0.2359, 0.9390]],
    [[-0.8668, 0.5324, 0.7221, 0.6134],
    [-0.4285, 0.5667, 0.5340, -0.6971],
    [ 1.8294, 0.0185, -0.2730, 0.0775]]])
    torch.Size([2, 3, 4])
    在第0维上压缩,实际上不变
    tensor([[[[[ 1.0232, -0.0252, -0.1088, -1.8738]],
    [[-1.5453, 0.1855, -1.1249, 1.4581]],
    [[ 0.5415, -0.3716, 0.2359, 0.9390]]]],
    [[[[-0.8668, 0.5324, 0.7221, 0.6134]],
    [[-0.4285, 0.5667, 0.5340, -0.6971]],
    [[ 1.8294, 0.0185, -0.2730, 0.0775]]]]])
    torch.Size([2, 1, 3, 1, 4])
    在第1维上压缩
    tensor([[[[ 1.0232, -0.0252, -0.1088, -1.8738]],
    [[-1.5453, 0.1855, -1.1249, 1.4581]],
    [[ 0.5415, -0.3716, 0.2359, 0.9390]]],
    [[[-0.8668, 0.5324, 0.7221, 0.6134]],
    [[-0.4285, 0.5667, 0.5340, -0.6971]],
    [[ 1.8294, 0.0185, -0.2730, 0.0775]]]])
    torch.Size([2, 3, 1, 4])

    重复张量

    torch.Tensor.repeat(*sizes)

    沿着指定的维度重复张量。不同于expand()方法,本函数复制的是张量中的数据。
    参数:
    size (torch.size ot int…) - 沿着每一维重复的次数
    例子:

    import torch
    x = torch.randn((2))
    print(x)
    print(x.size())
    # 行方向复制3倍,列方向复制4倍,整体复制
    y = x.repeat(3,4)
    print(y)
    print(y.size())
    

    tensor([ 1.4610, -0.1669])
    torch.Size([2])
    tensor([[ 1.4610, -0.1669, 1.4610, -0.1669, 1.4610, -0.1669, 1.4610, -0.1669],
    [ 1.4610, -0.1669, 1.4610, -0.1669, 1.4610, -0.1669, 1.4610, -0.1669],
    [ 1.4610, -0.1669, 1.4610, -0.1669, 1.4610, -0.1669, 1.4610, -0.1669]])
    torch.Size([3, 8])

    torch.Tensor.unfold(dim, size, step)
    返回一个新的张量,其中元素复制于有原张量在dim维度上的数据,复制重复size次,复制时的步进值为step。
    参数:
    dim (int) - 目标维度
    size (int) - 复制重复的次数(展开维度)
    step (int) - 步长
    例子:

    import torch
    x = torch.randn((5))
    print(x)
    print(x.size())
    # 复制第0维上的数据,复制2次,复制的步长为1
    y = x.unfold(0,2,1)
    print(y)
    print(y.size())
    

    tensor([ 0.0283, 0.1335, -1.2315, -0.8102, 1.2055])
    torch.Size([5])
    tensor([[ 0.0283, 0.1335],
    [ 0.1335, -1.2315],
    [-1.2315, -0.8102],
    [-0.8102, 1.2055]])
    torch.Size([4, 2])

    缩小张量

    torch.Tensor.narrow(dimension, start, length)

    返回一个经过缩小后的张量,多余的元素删除。操作的维度由dimension指定。缩小范围是从start开始到start+length。执行本方法的张量与返回的张量共享相同的底层内存。
    参数:
    dimension (int) – 要进行缩小的维度
    start (int) – 维度索引的起始位
    length (int) – 保留车长度
    例子:

    import torch
    x = torch.randn((3,3))
    print(x)
    print(x.size())
    # 在维度0上缩小,从0开始,数两个
    y = x.narrow(0,0,2)
    print('*******')
    print(y)
    print(y.size())
    # 在维度0上缩小,从1开始,数两个
    y = x.narrow(0,1,2)
    print('*******')
    print(y)
    print(y.size())
    # 在维度1上缩小,从0开始,数两个
    y = x.narrow(1,0,2)
    print('*******')
    print(y)
    print(y.size())
    

    tensor([[ 0.6879, -0.9074, -0.8069],
    [-1.4223, 0.7848, -1.0517],
    [-0.8015, 0.5503, 1.1616]])
    torch.Size([3, 3])


    tensor([[ 0.6879, -0.9074, -0.8069],
    [-1.4223, 0.7848, -1.0517]])
    torch.Size([2, 3])


    tensor([[-1.4223, 0.7848, -1.0517],
    [-0.8015, 0.5503, 1.1616]])
    torch.Size([2, 3])


    tensor([[ 0.6879, -0.9074],
    [-1.4223, 0.7848],
    [-0.8015, 0.5503]])
    torch.Size([3, 2])

    张量变形

    torch.Tensor.view(*args)

    返回一个有相同数据但是不同形状的新的向量。
    返回的装两必须与原张量有相同的数据和相同的元素个数,但是可以有不同的尺寸。
    参数:
    args (torch.Size or int…) - 理想的指定尺寸
    例子:

    import torch
    x = torch.randn((3,4))
    print(x)
    print(x.size())
    # 改变形状,按行扫描
    y = x.view(2,6)
    print('*******')
    print(y)
    print(y.size())
    

    tensor([[ 0.2112, 1.5160, 1.8517, -0.1830],
    [-0.5600, -0.5484, -0.0596, -0.0722],
    [ 0.3125, -0.4918, -1.5547, 0.3193]])
    torch.Size([3, 4])


    tensor([[ 0.2112, 1.5160, 1.8517, -0.1830, -0.5600, -0.5484],
    [-0.0596, -0.0722, 0.3125, -0.4918, -1.5547, 0.3193]])
    torch.Size([2, 6])

    重设张量尺寸

    torch.Tensor.resize_(*sizes)

    将张量的尺寸调整为指定的大小。如果元素个数比当前的内存大小大,就将底层存储大小调整为与新元素数目一致的大小。
    如果元素个数比当前内存小,则底层存储不会被改变。原来张量中被保存下来的元素将保持不变,但新内存将不会被初始化。
    参数:
    sizes (torch.Size or int…) - 需要调整的大小
    例子:

    import torch
    x = torch.randn((3,4))
    print(x)
    print(x.size())
    
    y = x.resize_(3,3)
    print('*******')
    print(y)
    print(y.size())
    
    y = x.resize_(4,4)
    print('*******')
    print(y)
    print(y.size())
    

    tensor([[ 0.2470, -0.7461, 0.3314, 0.1723],
    [-0.3906, -0.3396, -2.2285, 1.7582],
    [-0.9763, 1.9427, 0.3674, 1.3971]])
    torch.Size([3, 4])


    tensor([[ 0.2470, -0.7461, 0.3314],
    [ 0.1723, -0.3906, -0.3396],
    [-2.2285, 1.7582, -0.9763]])
    torch.Size([3, 3])


    tensor([[ 2.4695e-01, -7.4609e-01, 3.3135e-01, 1.7228e-01],
    [-3.9056e-01, -3.3962e-01, -2.2285e+00, 1.7582e+00],
    [-9.7632e-01, 1.9427e+00, 3.6742e-01, 1.3971e+00],
    [ 0.0000e+00, 4.2246e-39, 0.0000e+00, 0.0000e+00]])
    torch.Size([4, 4])

    调换张量的维度

    torch.Tensor.permute(*dims)

    将执行本方法的张量的维度换位。
    参数:
    dim (int) - 指定换位顺序
    例子:

    import torch
    x = torch.randn((1,2,3))
    print(x)
    print(x.size())
    
    y = x.permute(2,0,1)
    print('*******')
    print(y)
    print(y.size())
    

    tensor([[[ 0.3598, 0.9950, 0.0607],
    [-0.6146, 0.4286, 1.9699]]])
    torch.Size([1, 2, 3])


    tensor([[[ 0.3598, -0.6146]],
    [[ 0.9950, 0.4286]],
    [[ 0.0607, 1.9699]]])
    torch.Size([3, 1, 2])

    查看张量单个元素的字节数

    torch.Tensor.element_size()

    查看某类型张量单个元素的字节数。
    例子:

    import torch
    x = torch.randn((1,2,3))
    print(x.element_size())
    

    4

    原文链接:https://zhuanlan.zhihu.com/p/31495102

    展开全文
  • 对于pytorch张量,有一个比较常用的操作就是沿着某个方向对张量做扩增和对张量进行压缩,这两种情况与张量的大小等于1的维度有关,对于一个张量来说,可以任意添加一个维度,该维度的大小为,而不改变张量的数据,...

    1,张量的扩增和压缩

    对于pytorch张量,有一个比较常用的操作就是沿着某个方向对张量做扩增和对张量进行压缩,这两种情况与张量的大小等于1的维度有关,对于一个张量来说,可以任意添加一个维度,该维度的大小为,而不改变张量的数据,因为张量的大小等于所有维度大小的乘积,那些为1的维度不改变张量的大小。具体见下面代码:

    import torch
    
    a = torch.rand(3, 4) # 随机生成一个3*4的张量
    print(a)
    print(a.shape)
    
    b = a.unsqueeze(-1) # 扩增最后一个维度,生成3*4*1的张量
    print(b)
    print(b.shape)
    
    c = a.unsqueeze(-1).unsqueeze(-1) # 继续扩增最后一个维度,生成3*4*1*1的张量
    print(c)
    print(c.shape)
    
    d = torch.rand(1,3,4,1) # 随机生成一个1*3*4*1的张量,其中有两个维度大小为1
    print(d)
    e = d.squeeze()  # 压缩所有大小为1的维度,成为了3*4的张量
    print(e)
    

    2,张量的广播

    在张量的运算中会碰到一种情况,即两个不同维度张量之间做四则运算,且两个张量某些维度相等。显然,如果按照张量的四则运算的定义,两个不同维度的张量不能进行四则运算。为了能够让它们进行计算,首先需要把维度数目比较小的张量扩增到和维度数目比较大的张量一致。具体见下面代码:

    d1 = torch.randn(3, 4, 5)  # 定义3*4*5的张量1
    print(d1)
    d2 = torch.randn(3, 5)  # 定义3*5的张量2
    print(d2)
    d2 = d2.unsqueeze(1)  # 扩增第一个维度,将张量2的形状变为3*1*5
    print(d2)
    d3 = d1 + d2  # 广播求和,最后结果为3*4*5的张量,相当于是将d2沿着第二个维度复制4次,使之成为3*4*5的张量,这样与d1就能进行元素一一对应的计算
    print(d3)
    

    Done!!!

    展开全文
  • view函数和reshape是一样的 ... 以上是维度增加和减少的用法。 下面是维度扩展: a=torch.rand(1,32,1,1) a.expand(4,32,14,14).shape 得到 ([4,32,14,14]) a.expand(-1,32,-1,-1).shape 得到 ([1,32,1,1])...

    view函数和reshape是一样的 

     

     

     unsqueeze的用法 ,目前感觉用的的概率不大。不会改变数据内容,会改变方括号的包含,读取的方式变了

    同理,压缩的用法相对更好理解一些。 以上是维度增加和减少的用法。

    下面是维度扩展:

    a=torch.rand(1,32,1,1)

    a.expand(4,32,14,14).shape       得到 ([4,32,14,14])

    a.expand(-1,32,-1,-1).shape       得到 ([1,32,1,1])     ,写-1的位置可以是不变,也可以是自适应

     

    repeat函数是将当前维度内容进行复制,In[77]  4,1,32,32指的是复制的次数 

    维度交换:

    transpose一次只能交换两个维度 

    permute可以一次性将四个维度都安排新的顺序

     

    展开全文
  • 张量的操作确实有技巧,pytorch中提供了一些相关的操作,在编程的时候很有用。 涉及的方法见下面的目录: 目录一、拼接张量1、torch.cat()2、torch.stack()二、扩大张量1、torch.Tensor.expand()三、压缩张量1、...
  • 涉及到的方法有: 拼接torch.cat() 扩展torch.Tensor.expand() 压缩torch.squeeze(); torch.Tensor.narrow() 重复torch.Tensor.repeat(); torch.Tensor.unfold() 变形torch.Tensor.view...置换维度torch.Tensor.per...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,171
精华内容 2,868
关键字:

pytorch张量维度