切片具有多个y1：y2，x1：x2的numpy数组的多个帧

问题描述

我有一个多帧（numple_frames）的numpy数组，我想用不同的y1，y2，x1，x2对每个帧的高度和宽度进行切片，以在每个帧中绘制一个正方形“ 1”。 （slice_yyxx）是一个numpy数组，每帧包含一个y1，y2，x1，x2数组。

slice_yyxx = np.array(slice_yyxx).astype(int)
nbr_frame = slice_yyxx.shape[0]

multiple_frames = np.zeros(shape=(nbr_frame,target_shape[0],target_shape[1],target_shape[2]))
print(multiple_frames.shape)
# (5,384,640,1)

print(slice_yyxx)
# Value ok

print(slice_yyxx.shape)
# (5,4)
# Then 5 array of coord like [y1,y2,x1,x2] for slice each frames

print(slice_yyxx.dtype)
# np.int64

multiple_frames[:,slice_yyxx[:,0]:slice_yyxx[:,1],2]:slice_yyxx[:,3]] = 1
# ERROR: TypeError: only integer scalar arrays can be converted to a scalar index

解决方法

这里真正的问题是如何将任意切片转换为可以在多个维度上使用而不会循环的对象。我认为，诀窍是使用花式索引，arange和repeat的巧妙组合。

目标是创建一个与每个维度相对应的行和列索引数组。让我们以一个简单的可视化案例为例：3帧3x3矩阵集，其中我们希望将左上和右下2x2子数组分配给前两个帧，并将整个对象分配给最后一帧：

multi_array = np.zeros((3,3,3))
slice_rrcc = np.array([[0,2,2],[1,1,3],[0,3]])

让我们提出与每个索引匹配的索引以及大小和形状：

nframes = slice_rrcc.shape[0]                       # 3
nrows = np.diff(slice_rrcc[:,:2],axis=1).ravel()  # [2,3]
ncols = np.diff(slice_rrcc[:,2:],3]
sizes = nrows * ncols                               # [4,4,9]

我们需要以下精美索引才能进行分配：

frame_index = np.array([0,2])
row_index   = np.array([0,2])
col_index   = np.array([0,2])

如果我们可以获得数组frame_index，row_index和col_index，则可以如下设置每个段的数据：

multi_array[frame_index,row_index,col_index] = 1

frame_index索引很容易获得：

frame_index = np.repeat(np.arange(nframes),sizes)

row_index需要做更多的工作。您需要为每个单独的帧生成一组nrows索引，并重复ncols次。您可以通过生成连续范围并使用减法在每帧重新开始计数来实现此目的：

row_range = np.arange(nrows.sum())
row_offsets = np.zeros_like(row_range)
row_offsets[np.cumsum(nrows[:-1])] = nrows[:-1]
row_index = row_range - np.cumsum(row_offsets) + np.repeat(slice_rrcc[:,0],nrows)
segments = np.repeat(ncols,nrows)
row_index = np.repeat(row_index,segments)

col_index仍然不那么琐碎。您需要为具有正确偏移量的每一行生成一个序列，并针对每一行然后针对每一帧以大块重复该序列。该方法类似于row_index的方法，但有一个额外的花式索引可以使订单正确：

col_index_index = np.arange(sizes.sum())
col_index_resets = np.cumsum(segments[:-1])
col_index_offsets = np.zeros_like(col_index_index)
col_index_offsets[col_index_resets] = segments[:-1]
col_index_offsets[np.cumsum(sizes[:-1])] -= ncols[:-1]
col_index_index -= np.cumsum(col_index_offsets)

col_range = np.arange(ncols.sum())
col_offsets = np.zeros_like(col_range)
col_offsets[np.cumsum(ncols[:-1])] = ncols[:-1]
col_index = col_range - np.cumsum(col_offsets) + np.repeat(slice_rrcc[:,ncols)
col_index = col_index[col_index_index]

使用此公式，您甚至可以加倍为每个帧指定一个不同的值。如果要在我的示例中将values = [1,3]分配给框架，只需

multi_array[frame_index,col_index] = np.repeat(values,sizes)

我们将看看是否有更有效的方法来做到这一点。我问的一部分是here。

基准

在{10，100，1000}中对nframes的循环和我的矢量化解决方案在multi_array中对{100,1000,10000}的宽度和高度的比较：

def set_slices_loop(arr,slice_rrcc):
    for a,s in zip(arr,slice_rrcc):
        a[s[0]:s[1],s[2]:s[3]] = 1

np.random.seed(0xABCDEF)
for nframes in [10,100,1000]:
    for dim in [10,32,100]:
        print(f'Size = {nframes}x{dim}x{dim}')
        arr = np.zeros((nframes,dim,dim),dtype=int)
        slice = np.zeros((nframes,4),dtype=int)
        slice[:,::2] = np.random.randint(0,dim - 1,size=(nframes,2))
        slice[:,1::2] = np.random.randint(slice[:,::2] + 1,2))
        %timeit set_slices_loop(arr,slice)
        arr[:] = 0
        %timeit set_slices(arr,slice)

结果非常支持循环，唯一例外的是非常多的帧和较小的帧大小。使用循环，大多数“正常”情况的速度要快一个数量级：

循环

        |          Dimension          |
        |   100   |   1000  |  10000  |
--------+---------+---------+---------+
F    10 | 33.8 µs | 35.8 µs | 43.4 µs |
r  -----+---------+---------+---------+
a   100 |  310 µs |  331 µs |  401 µs |
m  -----+---------+---------+---------+
e  1000 | 3.09 ms | 3.31 ms | 4.27 ms |
--------+---------+---------+---------+

矢量化

        |          Dimension          |
        |   100   |   1000  |  10000  |
--------+---------+---------+---------+
F    10 |  225 µs |  266 µs |  545 µs |
r  -----+---------+---------+---------+
a   100 |  312 µs |  627 µs | 4.11 ms |
m  -----+---------+---------+---------+
e  1000 | 1.07 ms | 4.63 ms | 48.5 ms |
--------+---------+---------+---------+

TL; DR

可以做，但不推荐：

def set_slices(arr,slice_rrcc,value):
    nframes = slice_rrcc.shape[0]
    nrows = np.diff(slice_rrcc[:,axis=1).ravel()
    ncols = np.diff(slice_rrcc[:,axis=1).ravel()
    sizes = nrows * ncols

    segments = np.repeat(ncols,nrows)

    frame_index = np.repeat(np.arange(nframes),sizes)

    row_range = np.arange(nrows.sum())
    row_offsets = np.zeros_like(row_range)
    row_offsets[np.cumsum(nrows[:-1])] = nrows[:-1]
    row_index = row_range - np.cumsum(row_offsets) + np.repeat(slice_rrcc[:,nrows)
    row_index = np.repeat(row_index,segments)

    col_index_index = np.arange(sizes.sum())
    col_index_resets = np.cumsum(segments[:-1])
    col_index_offsets = np.zeros_like(col_index_index)
    col_index_offsets[col_index_resets] = segments[:-1]
    col_index_offsets[np.cumsum(sizes[:-1])] -= ncols[:-1]
    col_index_index -= np.cumsum(col_index_offsets)

    col_range = np.arange(ncols.sum())
    col_offsets = np.zeros_like(col_range)
    col_offsets[np.cumsum(ncols[:-1])] = ncols[:-1]
    col_index = col_range - np.cumsum(col_offsets) + np.repeat(slice_rrcc[:,ncols)
    col_index = col_index[col_index_index]

    if values.size == 1:
        arr[frame_index,col_index] = value
    else:
        arr[frame_index,sizes)

,

这是使用benchit程序包（打包在一起的很少有基准测试工具；免责声明：我是它的作者）对基准测试解决方案进行基准测试的帖子。

我们正在使用set_slices和arr[frame_index,col_index] = 1从@Mad Physicist的解决方案中对set_slices_loop进行基准测试，而无需进行任何更改即可获得运行时(sec)。

np.random.seed(0xABCDEF)
in_ = {}
for nframes in [10,100]:
        arr = np.zeros((nframes,2))
        in_[(nframes,dim)] = [arr,slice] 
    
import benchit
funcs = [set_slices,set_slices_loop]
t = benchit.timings(funcs,in_,input_name=['NumFrames','Dim'],multivar=True)
t.plot(sp_argID=1,logx=True,save='timings.png')