精华内容
下载资源
问答
  • pytorch contiguous

    2019-09-10 19:44:08
    contiguous:view只能用在contiguous的variable上。 如果在view之前用了transpose, permute等,需要用contiguous()来返回一个contiguous copy。 一种可能的解释是: 有些tensor并不是占用一整块内存,而是由不同的...

    contiguous:view只能用在contiguous的variable上。
    如果在view之前用了transpose, permute等,需要用contiguous()来返回一个contiguous copy。
    一种可能的解释是:
    有些tensor并不是占用一整块内存,而是由不同的数据块组成,而tensor的view()操作依赖于内存是整块的,这时只需要执行contiguous()这个函数,把tensor变成在内存中连续分布的形式。
    判断是否contiguous用torch.Tensor.is_contiguous()函数

    x = x.transpose(3, 2).contiguous()
    return x.view(x.size(0), -1)

    展开全文
  • Contiguous Array

    2020-06-13 07:10:01
    Given a binary array, find the maximum length of a contiguous subarray with equal number of 0 and 1. Example 1: Input: [0,1] Output: 2 Explanation: [0, 1] is the longest contiguous subarray with ...

    Given a binary array, find the maximum length of a contiguous subarray with equal number of 0 and 1.

    Example 1:

    Input: [0,1]
    Output: 2
    Explanation: [0, 1] is the longest contiguous subarray with equal number of 0 and 1.
    

    Example 2:

    Input: [0,1,0]
    Output: 2
    Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.
    
    

    Note: The length of the given binary array will not exceed 50,000.

    思路:遇见0,-1,遇见1,+1,这样跟presum一样,如果cursum重复了,说明中间有相等的0,1,这样就是类似于two sum的解法,扫描一遍就可以了。注意,还没又开始的时候,要put(0,-1) ,  It means that, before we loop this array, the sum is 0 in initial, and because we haven't starting loop, so the index = -1. 也就是[0,1] 这种情况,如果没有 (0,-1),那么就计算出len = 2,也就是还没进行loop的时候,index = -1;这样好进行index的计算;

    class Solution {
        public int findMaxLength(int[] nums) {
            if(nums == null || nums.length == 0) {
                return 0;
            }
            //      cursum,   index
            HashMap<Integer, Integer> sumToIndex = new HashMap<>();
            sumToIndex.put(0, -1);
            int maxlen = 0;
            int cursum = 0;
            for(int i = 0; i < nums.length; i++) {
                cursum += nums[i] == 0 ? -1 : 1;
                if(sumToIndex.containsKey(cursum)) {
                    maxlen = Math.max(maxlen, i - sumToIndex.get(cursum));
                } else {
                    sumToIndex.put(cursum, i);
                }   
            }
            return maxlen;
        }
    }

     

    展开全文
  • Pytorch之contiguous

    2020-08-10 08:27:35
    contiguous() tensor变量调用contiguous()函数会使tensor变量在内存中的存储变得连续。 contiguous():view只能用在contiguous的variable上。如果在view之前用了transpose, permute等,需要用contiguous()来返回一个...

    contiguous()

    tensor变量调用contiguous()函数会使tensor变量在内存中的存储变得连续。

    contiguous()view只能用在contiguous的variable上。如果在view之前用了transpose, permute等,需要用contiguous()来返回一个contiguous copy。

    一种可能的解释是:
    有些tensor并不是占用一整块内存,而是由不同的数据块组成,而tensor的view()操作依赖于内存是整块的,这时只需要执行contiguous()这个函数,把tensor变成在内存中连续分布的形式。

    is_contiguous

    判断是否contiguous用torch.Tensor.is_contiguous()函数。

    import torch
    x = torch.ones(10, 10)
    x.is_contiguous()  # True
    x.transpose(0, 1).is_contiguous()  # False
    x.transpose(0, 1).contiguous().is_contiguous()  # True
    

    在pytorch的最新版本0.4版本中,增加了torch.reshape(), 这与 numpy.reshape 的功能类似。它大致相当于 tensor.contiguous().view()

    # 有些操作会让张量存储结构扭曲,直接使用view会失败,可以用reshape方法
    
    matrix26 = torch.arange(0,12).view(2,6)
    print(matrix26)
    print(matrix26.shape)   # torch.Size([2, 6])
    
    # 转置操作让张量存储结构扭曲
    matrix62 = matrix26.t()
    print(matrix62.is_contiguous())   # False
    
    # 这时候尝试使用view
    matrix34 = matrix62.view(3,4) #error!
    
    ## 结果
    RuntimeError: view size is not compatible with input tensor's size and stride (at least one dimension spans across two contiguous subspaces). Use .reshape(...) instead.
    
    
    
    # 所以需要用下面的的reshape
    matrix34 = matrix62.reshape(3,4) #等价于matrix34 = matrix62.contiguous().view(3,4)
    print(matrix34)
    

    参考:https://blog.csdn.net/qq_37385726/article/details/81811254

    展开全文
  • non-contiguous

    2020-12-08 22:54:39
    <div><p>I have run the env_install step by step, ... This error may appear if you passed in a non-contiguous input. <p>Can you help me? Thanks!</p><p>该提问来源于开源项目:lightaime/sgas</p></div>
  • 今天小编就为大家分享一篇Pytorch之contiguous的用法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • PyTorch中的contiguous

    2021-01-15 09:37:13
    本文讲解了pytorch中contiguous的含义、定义、实现,以及contiguous存在的原因,非contiguous时的解决办法。并对比了numpy中的contiguouscontiguous本身是形容词,表示连续的,关于contiguous,PyTorch 提供了is...

    本文讲解了pytorch中contiguous的含义、定义、实现,以及contiguous存在的原因,非contiguous时的解决办法。并对比了numpy中的contiguous。


    contiguous 本身是形容词表示连续的关于 contiguous,PyTorch 提供了is_contiguouscontiguous(形容词动用)两个方法 ,分别用于判定Tensor是否是 contiguous 的,以及保证Tensor是contiguous的。

    PyTorch中的is_contiguous是什么含义?

    is_contiguous直观的解释是Tensor底层一维数组元素的存储顺序与Tensor按行优先一维展开的元素顺序是否一致

    Tensor多维数组底层实现是使用一块连续内存的1维数组(行优先顺序存储,下文描述),Tensor在元信息里保存了多维数组的形状,在访问元素时,通过多维度索引转化成1维数组相对于数组起始位置的偏移量即可找到对应的数据。某些Tensor操作(如transpose、permute、narrow、expand)与原Tensor是共享内存中的数据,不会改变底层数组的存储,但原来在语义上相邻、内存里也相邻的元素在执行这样的操作后,在语义上相邻,但在内存不相邻,即不连续了(is not contiguous)。

    如果想要变得连续使用contiguous方法,如果Tensor不是连续的,则会重新开辟一块内存空间保证数据是在内存中是连续的,如果Tensor是连续的,则contiguous无操作。

    行优先

    行是指多维数组一维展开的方式,对应的是列优先。C/C++中使用的是行优先方式(row major),Matlab、Fortran使用的是列优先方式(column major),PyTorch中Tensor底层实现是C,也是使用行优先顺序。举例说明如下:

    >>> t = torch.arange(12).reshape(3,4)
    >>> t
    tensor([[ 0,  1,  2,  3],
            [ 4,  5,  6,  7],
            [ 8,  9, 10, 11]])

    二维数组 t 如图1:

    图1. 3X4矩阵行优先存储逻辑结构

     

    数组 t 在内存中实际以一维数组形式存储,通过 flatten 方法查看 t 的一维展开形式,实际存储形式与一维展开一致,如图2,

    >>> t.flatten()
    tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

     

    图2. 3X4矩阵行优先存储物理结构

    而列优先的存储逻辑结构如图3。

    图3. 3X4矩阵列优先存储逻辑结构

    使用列优先存储时,一维数组中元素顺序如图4:

    图4. 3X4矩阵列优先存储物理结构

     

    说明:图1、图2、图3、图4来自:What is the difference between contiguous and non-contiguous arrays?

    图1、图2、图3、图4 中颜色相同的数据表示在同一行,不论是行优先顺序、或是列优先顺序,如果要访问矩阵中的下一个元素都是通过偏移来实现,这个偏移量称为步长(stride[1])。在行优先的存储方式下,访问行中相邻元素物理结构需要偏移1个位置,在列优先存储方式下偏移3个位置。

    为什么需要 contiguous ?

    1. torch.view等方法操作需要连续的Tensor。

    transpose、permute 操作虽然没有修改底层一维数组,但是新建了一份Tensor元信息,并在新的元信息中的 重新指定 stride。torch.view 方法约定了不修改数组本身,只是使用新的形状查看数据。如果我们在 transpose、permute 操作后执行 view,Pytorch 会抛出以下错误:

    invalid argument 2: view size is not compatible with input tensor's size and stride (at least one dimension 
    spans across two contiguous subspaces). Call .contiguous() before .view(). 
    at /Users/soumith/b101_2/2019_02_08/wheel_build_dirs/wheel_3.6/pytorch/aten/src/TH/generic/THTensor.cpp:213

    为什么 view 方法要求Tensor是连续的[2]?考虑以下操作,

    >>>t = torch.arange(12).reshape(3,4)
    >>>t
    tensor([[ 0,  1,  2,  3],
            [ 4,  5,  6,  7],
            [ 8,  9, 10, 11]])
    >>>t.stride()
    (4, 1)
    >>>t2 = t.transpose(0,1)
    >>>t2
    tensor([[ 0,  4,  8],
            [ 1,  5,  9],
            [ 2,  6, 10],
            [ 3,  7, 11]])
    >>>t2.stride()
    (1, 4)
    >>>t.data_ptr() == t2.data_ptr() # 底层数据是同一个一维数组
    True
    >>>t.is_contiguous(),t2.is_contiguous() # t连续,t2不连续
    (True, False)

    t2 与 t 引用同一份底层数据 a,如下:

    [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]

    ,两者仅是stride、shape不同。如果执行 t2.view(-1) ,期望返回以下数据 b(但实际会报错):

    [ 0,  4,  8,  1,  5,  9,  2,  6, 10,  3,  7, 11]

    在 a 的基础上使用一个新的 stride 无法直接得到 b ,需要先使用 t2 的 stride (1, 4) 转换到 t2 的结构,再基于 t2 的结构使用 stride (1,) 转换为形状为 (12,)的 b 。但这不是view工作的方式view 仅在底层数组上使用指定的形状进行变形,即使 view 不报错,它返回的数据是:

    [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]

    这是不满足预期的。使用contiguous方法后返回新Tensor t3,重新开辟了一块内存,并使用照 t2 的按行优先一维展开的顺序存储底层数据。

    >>>t3 = t2.contiguous()
    >>>t3
    tensor([[ 0,  4,  8],
            [ 1,  5,  9],
            [ 2,  6, 10],
            [ 3,  7, 11]])
    >>>t3.data_ptr() == t2.data_ptr() # 底层数据不是同一个一维数组
    False

    可以发现 t与t2 底层数据指针一致,t3 与 t2 底层数据指针不一致,说明确实重新开辟了内存空间。

    为什么不在view 方法中默认调用contiguous方法?

    因为历史上view方法已经约定了共享底层数据内存,返回的Tensor底层数据不会使用新的内存,如果在view中调用了contiguous方法,则可能在返回Tensor底层数据中使用了新的内存,这样打破了之前的约定,破坏了对之前的代码兼容性。为了解决用户使用便捷性问题,PyTorch在0.4版本以后提供了reshape方法,实现了类似于 tensor.contigous().view(*args)的功能,如果不关心底层数据是否使用了新的内存,则使用reshape方法更方便。 [3]

    2. 出于性能考虑

    连续的Tensor,语义上相邻的元素,在内存中也是连续的,访问相邻元素是矩阵运算中经常用到的操作,语义和内存顺序的一致性是缓存友好的(What is a “cache-friendly” code?[4]),在内存中连续的数据可以(但不一定)被高速缓存预取,以提升CPU获取操作数据的速度。transpose、permute 后使用 contiguous 方法则会重新开辟一块内存空间保证数据是在逻辑顺序和内存中是一致的,连续内存布局减少了CPU对对内存的请求次数(访问内存比访问寄存器慢100倍[5]),相当于空间换时间。


    PyTorch中判读张量是否连续的实现

    PyTorch中通过调用 is_contiguous 方法判断 tensor 是否连续,底层实现为 TH 库中THTensor.isContiguous 方法,为方便加上一些调试信息,翻译为 Python 代码如下:

    def isContiguous(tensor):
        """
        判断tensor是否连续    
        :param torch.Tensor tensor: 
        :return: bool
        """
    
        z = 1
        d = tensor.dim() - 1
        size = tensor.size()
        stride = tensor.stride()
        print("stride={} size={}".format(stride, size))
        while d >= 0:
            if size[d] != 1:
                if stride[d] == z:
                    print("dim {} stride is {}, next stride should be {} x {}".format(d, stride[d], z, size[d]))
                    z *= size[d]                
                else:
                    print("dim {} is not contiguous. stride is {}, but expected {}".format(d, stride[d], z))
                    return False
            d -= 1
        return True

    判定上文中 t、t2 是否连续的输出如下:

    >>>isContiguous(t)
    stride=(4, 1) size=torch.Size([3, 4])
    dim 1 stride is 1, next stride should be 1 x 4
    dim 0 stride is 4, next stride should be 4 x 3
    
    True
    >>>isContiguous(t2)
    stride=(1, 4) size=torch.Size([4, 3])
    dim 1 is not contiguous. stride is 4, but expected 1
    
    False

    从 isContiguous 实现可以看出,最后1维的 stride 必须为1(逻辑步长),这是合理的,最后1维即逻辑结构上最内层数组,其相邻元素间隔位数为1,按行优先顺序排列时,最内层数组相邻元素间隔应该为1。

    参考

    1. ^访问相邻元素所需要跳过的位数或字节数 https://stackoverflow.com/questions/53097952/how-to-understand-numpy-strides-for-layman?answertab=active#tab-top
    2. ^Munging PyTorch's tensor shape from (C, B, H) to (B, C*H) https://stackoverflow.com/a/53940813/11452297
    3. ^view() after transpose() raises non contiguous error #764 https://github.com/pytorch/pytorch/issues/764#issuecomment-317845141
    4. ^What is a “cache-friendly” code? https://stackoverflow.com/a/16699282
    5. ^计算机缓存Cache以及Cache Line详解 https://zhuanlan.zhihu.com/p/37749443
    6. ^Tensor.view方法对连续的描述 https://pytorch.org/docs/stable/tensors.html#torch.Tensor.view
    7. ^行优先布局的stride https://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html#internal-memory-layout-of-an-ndarray
    展开全文
  • pytorc中的contiguous

    2020-08-19 15:20:57
    本文讲解了pytorch中contiguous的含义、定义、实现,以及contiguous存在的原因,非contiguous时的解决办法。并对比了numpy中的contiguouscontiguous 本身是形容词,表示连续的,关于 contiguous,PyTorch 提供了...
  • pytorch中contiguous()

    万次阅读 多人点赞 2018-04-29 15:15:18
    contiguous:view只能用在contiguous的variable上。如果在view之前用了transpose, permute等,需要用contiguous()来返回一个contiguous copy。 一种可能的解释是: 有些tensor并不是占用一整块内存,而是由不同的...
  • python——Contiguous用法

    千次阅读 2019-04-18 17:47:01
    x.is_contiguous()——判断tensor是否连续 x.contiguous()——把tensor变成在内存中连续分布的形式 需要变成连续分布的情况: contiguous:view只能用在contiguous的variable上。如果在view之前用了transpose, ...
  • <div><p>Summary: If a tensor is non-contiguous, make a contiguous version and save a copy. <p>Differential Revision: D19156522</p><p>该提问来源于开源项目:pytorch/glow</p></div>
  • Non-contiguous subsets

    2020-12-08 19:52:04
    <div><p>It would be very useful to be able to subset non-contiguous elements from matrices and vectors. For example, taking the 1,3, and 9 elements of a vector or the 2,4, and 7 columns of a matrix. ...
  • hatch edges not contiguous

    2020-12-01 17:06:12
    <div><p>the check about contiguous hatch path points appears to fail very often. Until now I've ignored them as they are not fatal, but it might be something that should be looked into? <p>This is...
  • Make numpy array contiguous

    2020-12-02 08:29:50
    t contiguous; this pull request makes it so, so it will work with the compiled predictor. <p>I think the best long term solution for prediction data issues like this is to use the existing sklearn ...
  • transpose、contiguous、view a = torch.randn(2,3) #随机产生的2*3的tensor,内存是连续的,所以打印出“真” if a.is_contiguous(): print("真") else: print("假") a = a.transpose(0,1)#经过transpose,维度...
  • 525. Contiguous Array

    2020-10-25 23:03:50
    Given a binary array, find the maximum length of a contiguous subarray with equal number of 0 and 1. Example 1: Input: [0,1] Output: 2 Explanation: [0, 1] is the longest contiguous subarray with ...
  • pytorch contiguous的使用

    2019-03-17 15:44:10
    pytorch contiguous的使用 contiguous一般与transpose,permute,view搭配使用 即使用transpose或permute进行维度变换后,调用contiguous,然后方可使用view对维度进行变形。 具体原因我还没搞清,看到网上有两种...
  • Tensor.contiguous()

    2020-10-21 13:31:05
    这里写自定义目录标题欢迎使用Markdown编辑器Tensor.contiguous() 欢迎使用Markdown编辑器 在看SSD的代码实现,里面出现了l(x).permute(0, 2, 3, 1).contiguous())这样的用法。首先查了Tensor.permute(),用作更换...
  • Pytorch之contiguous函数

    2020-02-19 23:31:20
    contiguous()->Tensor返回一个内存连续的有相同数据的tensor,如果原tensor内存连续,则返回原tensor。 pytorch contiguous一般与transpose,permute,view搭配使用:使用transpose或pe...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,198
精华内容 2,479
关键字:

contiguous