精华内容
下载资源
问答
  • permute将tensor的维度进行转换。 举例: import torch import numpy as np a=np.array([[[1,2,3],[4,5,6]]]) b=torch.tensor(a) print(b) print(b.size()) # ——> torch.Size([1, 2, 3]) c=b.permute(2,0,...
    permute将tensor的维度进行转换。
    
    举例:
    
    import torch
    import numpy as np
    
    a=np.array([[[1,2,3],[4,5,6]]])
    
    b=torch.tensor(a)
    print(b)
    print(b.size()) #  ——>  torch.Size([1, 2, 3])
    
    c=b.permute(2,0,1)
    print(c.size()) #  ——>  torch.Size([3, 1, 2])
    
    print(c)
    
    c = b.view(3,1,2)
    print(c)
    

     

    输出:

    tensor([[[1, 2, 3],
             [4, 5, 6]]], dtype=torch.int32)
    torch.Size([1, 2, 3])
    torch.Size([3, 1, 2])
    tensor([[[1, 4]],

            [[2, 5]],

            [[3, 6]]], dtype=torch.int32)
    tensor([[[1, 2]],

            [[3, 4]],

            [[5, 6]]], dtype=torch.int32)

     

    展开全文
  • torch中应用卷积的时候,我们有时候遇到一些问题。 1.卷积维度合并 // An highlighted block x0 = torch.rand(3, 224, 224) x1 = torch.rand(3, 224, 224) y0 = torch.cat((x0, x1),0).size() print(y0) y1 = ...

    维度转换

    在torch中应用卷积的时候,我们有时候遇到一些问题。在cv领域我们常见的就是用二维卷积将图片中各种特征进行提取,但是目标检测、分割中都没有涉及到时域。但是一旦涉及到提取时域特征的话,下面三种维度转换就会非常有用,我们可以建立更加丰富的网络。我们可以用一维、二维、三维卷积提取到更加丰富的信息,提升我们网络的鲁棒性。

    1.卷积维度合并

    torch中torch.cat()和paddle、tensorflow中concate一样,将目标特征图在不同维度上进行拼接。
    应用场景,当将特征图分块处理之后,我们在需要将特征进行形状还原的时候使用。而torch.add()代表 的尺寸一样的特征图进行内值相加。这种一般用于特征融合的,提取多特征的时候进行特征融合的时候使用。

    // An highlighted block
    x0 = torch.rand(3, 224, 224)
    x1 = torch.rand(3, 224, 224)
    y0 = torch.cat((x0, x1),0).size()
    print(y0)
    y1 = torch.add(x0,x1).size()
    print(y1)
    

    输出结果在这里插入图片描述

    2 维度变换

    尺度对应,当然tensor.view()还有其他用法,具体参考源码
    将特征直接进维度融合,形状不一样,大小一样。

    // An highlighted block
    x0 = torch.rand(3, 224, 224)
    c, h, w = x0.size()
    x0_t0 = x0.view(c * h, w)
    print(x0_t0.size())
    

    输出结果
    在这里插入图片描述

    3 维度转换

    类似于[h,w]转换成[w,h],在建立卷积网络的过程中需要用到不同维度卷积时,我们可以用以下方法进行维度转换来做卷积前的准备工作。

    x0 = torch.rand(3, 224, 224)
    print(x0.size())
    x1 = x0.permute([2,0,1])
    print(x1.size())
    

    输出结果
    在这里插入图片描述
    差点网络补充一点了,用permute函数之后,我们需要用continuous函数进行连接,因为permute函数将原特征进行分裂重组了。
    掌握以上的三个小技巧,我们建立网络就会更加得心应手!

    展开全文
  • 直入主题: 1.torch.view()是先把所有的Tensor()变成一维数据,然后按需(数据的维度)索取。举个例子 如果参数中出现-1值,那么这个位置的...2.torch.permute() 相比之下permute()的理解要稍微复杂一点。 其作...

    直入主题:

    1.torch.view()是先把所有的Tensor()变成一维数据,然后按需(数据的维度)索取。举个例子

    如果参数中出现-1值,那么这个位置的数据就要按照其他位置来判断了。比如上述例子中,

    这个-1的值是4,是由其他位置(这里是2)计算得来的,只要保证数据的数量一致就可以。

    2.torch.permute()

    相比之下permute()的理解要稍微复杂一点。

    其作用是把原来Tensor的维数重置,取用的方式稍微复杂一点。举个例子:

    a是一个1×2×3的Tensor,1是a的第0维,2是a的第1维,3是a的第2维,permute()的作用就是重置这些维数。比如上述例子中就把第0维还是放在第0维,把原来的第2维放到现在的第一维,把原来的第一维放到现在的第二维,也就是我们希望b的维数是1×3×2。

    但其选取数据的方式是,每一个最小的单位抽取一个数据出来,得到满足要求的维数。

    这里和np.random.permutation(x)是不太一样的

    后者只对第一维数据进行打乱,举个例子:

    3.torch.transpose(dim1,dim2)

    此函数的参数有两个,表示交换这两维。举个例子:

    4.numpy.random.permutation(x)

    (以下摘自官方文档numpy.org)

      1)若x是int数据,则返回range(x)随机排列的数列

    2)若x是array数组,那么只打乱第一维数据(以a为例,a原来是3×4的数组,打乱第一维之后结果如下 第二维次序一点没变)

    展开全文
  • torch.Tensor.permute - 数据重排 重新排列维度,不改变维度。 1. torch.Tensor.permute Python method, in torch.Tensor 1.1 permute(*dims) -> Tensor Returns a view of the original tensor with its ...

    torch.Tensor.permute - 数据重排

    重新排列维度,不改变维度。

    1. torch.Tensor.permute

    Python method, in torch.Tensor

    1.1 permute(*dims) -> Tensor

    Returns a view of the original tensor with its dimensions permuted.
    返回其尺寸已排列的原始张量的视图。

    1.2 Parameters

    *dims (int...) - The desired ordering of dimensions.
    期望的维度顺序。

    1.3 Example

    (base) yongqiang@yongqiang:~$ conda env list
    # conda environments:
    #
    base                  *  /home/yongqiang/miniconda3
    pt-1.4_py-3.6            /home/yongqiang/miniconda3/envs/pt-1.4_py-3.6
    
    (base) yongqiang@yongqiang:~$ conda activate pt-1.4_py-3.6
    (pt-1.4_py-3.6) yongqiang@yongqiang:~$ python
    Python 3.6.10 |Anaconda, Inc.| (default, May  8 2020, 02:54:21)
    [GCC 7.3.0] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import torch
    >>> torch.__version__
    '1.4.0'
    >>> exit()
    (pt-1.4_py-3.6) yongqiang@yongqiang:~$
    
    (pt-1.4_py-3.6) yongqiang@yongqiang:~$ python
    Python 3.6.10 |Anaconda, Inc.| (default, May  8 2020, 02:54:21)
    [GCC 7.3.0] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import torch
    >>>
    >>> x = torch.randn(2, 3, 5)
    >>> x
    tensor([[[ 1.0919, -0.5716, -0.2230, -1.3081, -0.5326],
             [-0.8434,  0.9088,  0.7279, -1.3815, -0.4925],
             [-0.4546, -2.3575,  0.4141,  0.4549, -0.2353]],
    
            [[-1.2896, -0.2758, -0.7352,  0.0897, -0.2647],
             [ 1.4542,  0.3866, -1.9141, -1.2314, -0.4329],
             [-0.6978,  0.8083, -1.2807, -1.8151,  0.2868]]])
    >>> x.size()
    torch.Size([2, 3, 5])
    >>>
    >>> y = x.permute(2, 1, 0)
    >>> y
    tensor([[[ 1.0919, -1.2896],
             [-0.8434,  1.4542],
             [-0.4546, -0.6978]],
    
            [[-0.5716, -0.2758],
             [ 0.9088,  0.3866],
             [-2.3575,  0.8083]],
    
            [[-0.2230, -0.7352],
             [ 0.7279, -1.9141],
             [ 0.4141, -1.2807]],
    
            [[-1.3081,  0.0897],
             [-1.3815, -1.2314],
             [ 0.4549, -1.8151]],
    
            [[-0.5326, -0.2647],
             [-0.4925, -0.4329],
             [-0.2353,  0.2868]]])
    >>>
    >>> y.size()
    torch.Size([5, 3, 2])
    >>>
    >>> exit()
    (pt-1.4_py-3.6) yongqiang@yongqiang:~$
    

    2. permute(0, 3, 2, 1)

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # yongqiang cheng
    
    from __future__ import absolute_import
    from __future__ import division
    from __future__ import print_function
    
    import torch
    import numpy as np
    
    np_data = np.array([[[[1, 2, 3],
                          [4, 5, 6],
                          [7, 8, 9],
                          [10, 11, 12]]]])
    
    print("\nnp_data.size():")
    print(np_data.shape)
    
    print("np_data:")
    print(np_data)
    
    src_data = torch.tensor(np_data)
    print("\nsrc_data.size():")
    print(src_data.size())
    
    print("src_data:")
    print(src_data)
    
    dst_data = src_data.permute(0, 3, 2, 1)
    print("\ndst_data.size():")
    print(dst_data.size())
    
    print("dst_data:")
    print(dst_data)
    
    
    /home/yongqiang/miniconda3/envs/pt-1.4_py-3.6/bin/python /home/yongqiang/pycharm_work/yongqiang.py
    
    np_data.size():
    (1, 1, 4, 3)
    np_data:
    [[[[ 1  2  3]
       [ 4  5  6]
       [ 7  8  9]
       [10 11 12]]]]
    
    src_data.size():
    torch.Size([1, 1, 4, 3])
    src_data:
    tensor([[[[ 1,  2,  3],
              [ 4,  5,  6],
              [ 7,  8,  9],
              [10, 11, 12]]]])
    
    dst_data.size():
    torch.Size([1, 3, 4, 1])
    dst_data:
    tensor([[[[ 1],
              [ 4],
              [ 7],
              [10]],
    
             [[ 2],
              [ 5],
              [ 8],
              [11]],
    
             [[ 3],
              [ 6],
              [ 9],
              [12]]]])
    
    Process finished with exit code 0
    

    3. Transpose matrix in C Program

    //======================================================================================================================
    // Transpose matrix in C Program
    // Yongqiang Cheng
    //======================================================================================================================
    
    #include <iostream>
    
    void transpose(const float *input_data, float *output_data, const int row, const int col) {
    
        for (int i = 0; i < row; ++i) {
            const float *ptr_in = input_data + i * col;
            for (int j = 0; j < col; ++j) {
                output_data[j * row + i] = ptr_in[j];
            }
        }
    }
    
    const int len = 3 * 4;
    
    int main() {
        const float input_data[len] = {1, 1, 1, 1,
                                       2, 2, 2, 2,
                                       3, 3, 3, 3};
        float output_data[len] = {0};
    
        std::cout << "The size of array is " << len << ".\n";
    
        int row = 3, col = 4;
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 4; ++j) {
                printf("%f ", input_data[i * 4 + j]);
            }
            printf("\n");
        }
    
        printf("\n");
    
        transpose(input_data, output_data, row, col);
    
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 3; ++j) {
                printf("%f ", output_data[i * 3 + j]);
            }
            printf("\n");
        }
    
        printf("\n");
    
        std::cout << "Hello, World!" << std::endl;
        return 0;
    }
    
    
    /home/yongqiang/CLionProjects/hash_table/cmake-build-debug/hash_table
    The size of array is 12.
    1.000000 1.000000 1.000000 1.000000 
    2.000000 2.000000 2.000000 2.000000 
    3.000000 3.000000 3.000000 3.000000 
    
    1.000000 2.000000 3.000000 
    1.000000 2.000000 3.000000 
    1.000000 2.000000 3.000000 
    1.000000 2.000000 3.000000 
    
    Hello, World!
    
    Process finished with exit code 0
    
    展开全文
  • Tensor.permute(d0,d1,d2,d2) torch.Transpose(Tensor, a,b) 参考PyTorch 高维矩阵转置 Transpose 和 Permute ;这里只讲了 , 其它相关的函数可参考: 【1】一文掌握torch.squeeze() 和torch.unsqueeze()的...
  • 相同点:交换张量的维度 不同点: 参数列表:torch.transpose(dim1,dim2)只能传入两个参数,tensor在这两个维度之间交换 ...内存:torch.transpose(dim1,dim2)得到的张量与原张量共享内存,而torch.tensor.permute(di...
  • tensor.permute(dim1, dim2, dim3, …) permute可以对任意高维矩阵进行转置....x = torch.rand(2,3,4) print("x.shape:", x.shape) x = x.permute(2,1,0) print("x.shape:", x.shape) 输出: x.shape: torc...
  • torch.permute()和np.transpose()

    千次阅读 2019-04-18 19:15:56
    import torch import numpy as np a = np.arange(24).reshape(3,4,2) print('before', a) b = np.transpose(a,(1,0,2)) print('b',b) ...d = c.permute(1,0,2) print('d:',d) out: /usr/bin/py...
  • (1)torch.Tensor.permute(重新排列维度-不能改变维度) (2)torch.Tensor.view(按照原维度-改变维度) (1)torch.Tensor.permute 官网:https://pytorch.org/docs/stable/tensors.html#torch.Tensor.permute ...
  • torch.permute可以进行多个维度的交换,而torch.transpose只能进行两个维度的交换 In [1]: dat = torch.tensor( [[[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]], [[13, 14, 15, 16], [17, 18, 19,
  • 这里要实现 Meta-SR 中的元放大部分中的多维操作,比如:torch.cat,torch.arange,torch.matmul,torch.Transpose,Tensor.view,Tensor.permute 等。 matmul 是多维矩阵乘法,和二维乘法差不多,只不过是多乘几次...
  • torch.transpose()和torch.permute() 两者作用相似,都是用于交换不同维度的内容。但其中torch.transpose()是交换指定的两个维度的内容,permute()则可以一次性交换多个维度。具体情况如code所示: transpose(): 两...
  • 链接: permute(*dims) 链接: T
  • torch.unsqueeze torch.unsqueeze(input, dim, out=None) 返回一个新的张量,对输入的指定位置增加一个维度 例子:https://blog.csdn.net/xiexu911/article/details/80820028 torch.squeeze(input, dim, out=None) ...
  • view只是读数组的方式不同 ...如果在view之前用了transpose,permute等,需要用contiguous()来返回一个contiguous copy。 what is contiguous https://blog.csdn.net/appleml/article/details/80143212?utm_so
  • torch.max() 举例: import torch x = torch.randn(4, 3) print(x) # 沿着行取最大值 max_value, max_idx = torch.max(x, dim=1) # 每一行的最大值 max_value # 每一行最大值的下标 max_idx 结果: tensor...
  • 1 先看看官方中英文doc: torch.Tensor.permute (Python method, in torch.Tensor)1.1 permute(dims)将tensor的维度换位。参数: - __dims__ (int ..*) - 换位顺序例:>>> x = torch.randn(2, 3, 5) >&...
  • 1 先看看官方中英文doc:torch.Tensor.permute (Python method, in torch.Tensor)1.1 permute(dims)将tensor的维度换位。参数: - __dims__ (int ..*) - 换位顺序例:>>> x = torch.randn(2, 3, 5)>>...
  • permute函数

    2020-07-11 14:39:56
    permute(dims) 转载自:https://blog.csdn.net/york1996/article/details/81876886 将tensor的维度换位。 参数:参数是一系列的整数,代表原来张量的维度。比如三维就有0,1,2这些dimension。 例: import torch ...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 251
精华内容 100
关键字:

permutetorch