python - 高效地从数组中获取批量元素 - Python

Question

我是 Python 和 Numpy 的新手。

我有这个输入:

[1、2、3、4、5、6、7、8、9、10、11、12、13、14、15]

我想得到这个输出:

[
  [
    [[ 1  2  3], [ 7  8  9]],
    [[ 2  3  4], [ 8  9 10]]
  ],

  [
    [[ 4  5  6], [10 11 12]],
    [[ 5  6  7], [11 12 13]]
  ]
]

该数组具有以下形状:(n_batches，2，batch_size，seq_length)。在下面的代码中您可以看到这些参数的含义。

我使用for循环来完成它。注意，以下代码来自here :

def get_batches(int_text, batch_size, seq_length):
    """
    Return batches of input and target
    :param int_text: Text with the words replaced by their ids
    :param batch_size: The size of batch
    :param seq_length: The length of sequence
    :return: Batches as a Numpy array
    """
    # TODO: Implement Function    
    n_batches = int(len(int_text) / batch_size / seq_length)    
    batches = np.zeros(shape = (n_batches, 2, batch_size, seq_length), dtype = np.int32)
    index = 0
    for batch_index in range(n_batches):  
        one_batch = np.zeros(shape = (2, batch_size, seq_length), dtype = np.int32)
        one_batch_seq = np.zeros(shape = (batch_size, seq_length), dtype = np.int32)
        one_batch_tar = np.zeros(shape = (batch_size, seq_length), dtype = np.int32)
        for n in range(batch_size):
            index = batch_index * seq_length + n * n_batches * seq_length            
            seq = np.array([int_text[index:index+seq_length]])
            tar = np.array([int_text[index+1:index+seq_length+1]])
            one_batch_seq[n] = seq;
            one_batch_tar[n] = tar;
            #print(seq)
            #if(one_batch_seq.size == 0):
            #    one_batch_seq = seq
            #else:
            #    one_batch_seq = np.concatenate((one_batch_seq, seq))
            #if(one_batch_tar.size == 0):
            #    one_batch_tar = tar
            #else:
            #    one_batch_tar = np.concatenate((one_batch_tar, tar))    
        one_batch[0] = one_batch_seq
        one_batch[1] = one_batch_tar
        batches[batch_index] = one_batch

    return batches

代码解释:

我必须获取可以使用该输入执行多少个批处理 (int_text)。我得到值 n_batches 就知道了。如果您无法用足够的数据填充最后一批，请删除最后一批。

然后，我创建一个形状为 (n_batches, 2, batch_size, seq_length) 的数组。然后，循环。

但有人告诉我，我可以在没有循环的情况下仅使用 Numpy 来做到这一点。我不知道该怎么做。我想，我可以通过 reshape 来做到这一点，但我不确定。

如何在不使用 for 循环的情况下获得该输出？

Answer 1

这是一个 super 高效的，带有 NumPy strides -

def get_batches_strided(a, batch_size, seq_length):
    n_batches = int(len(a) / batch_size / seq_length)   
    shp = (n_batches, 2, batch_size, seq_length)

    n = a.strides[0]
    s = np.lib.stride_tricks.as_strided
    strides=(shp[3]*n,n,shp[0]*shp[3]*n,n)
    out = s(a, shp, strides=strides)
    return out

这将是输入数组的 View ，因此不会占用更多的内存空间，这也是它提高效率的地方。

此外，由于我们正在使用 views 以及基于 strides 的方法，如果形状/步幅如此列出，则将超出为输入数组分配的内存，我们需要小心它的输入参数。

运行示例来验证各种输入参数 -

In [306]: a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])

# List of values to select batch_size, seq_length to form different combinations
# of inputs to be fed to the two proposed approaches for tesing
In [308]: r = [2,3,4]

In [309]: [np.allclose(get_batches(a,m,n), get_batches_strided(a,m,n)) \
                                                    for m in r for n in r]
Out[309]: [True, True, True, True, True, True, True, True, True] # All checked out

性能改进一瞥 -

In [320]: a = np.arange(1,2001)

In [321]: %timeit get_batches(a, 3,2)
100 loops, best of 3: 2.87 ms per loop

In [322]: %timeit get_batches_strided(a, 3,2)
100000 loops, best of 3: 5.07 µs per loop

如果我们需要一份副本，价格不会太高 -

In [323]: %timeit get_batches_strided(a, 3,2).copy()
100000 loops, best of 3: 15.4 µs per loop

<小时/>

回顾工作流程以决定进展

使用np.lib.stride_tricks.as_strided，只有两个关键参数 - 形状和步幅。形状还可以，因为我们可以从疯狂的版本中得到它。取得进展是很棘手的，在做出决定时需要进行大量的试验和错误。

让我尝试回放一下，以帮助那些尝试学习/使用strides的人。

输入是:

a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])

获取步幅长度并为步幅函数指定一个较短的名称:

n = a.strides[0]
s = np.lib.stride_tricks.as_strided

测试了具有各种跨步组合的跨步方法，下面列出了每个输入对的成功方法 -

#get_batches(a, 2, 2) # case1
#s(a, (3,2,2,2), strides=(2*n,1*n,6*n,n)) # worked

#get_batches(a, 2, 3) # case2
#s(a, (2,2,2,3), strides=(3*n,1*n,6*n,n)) # worked

#get_batches(a, 3,4) # case3
#s(a, (1,2,3,4), strides=(4*n,1*n,4*n,n)) # worked

#get_batches(a, 3,2) # case4
#s(a, (2,2,3,2), strides=(2*n,1*n,4*n,n)) # worked

接下来的工作是寻找模式，经过几次查看后，它变得显而易见:

#strides=(shp[3]*n,n,shp[0]*shp[3]*n,n), where shp is the input shape tuple