重复，但以可变大小的块以numpy格式

如何解决重复，但以可变大小的块以numpy格式

我有一个数组，该数组是不同块的串联：

a = np.array([0,1,2,10,11,20,21,22,23])
#             >     <  >    <  >            <
chunks = np.array([3,4])
repeats = np.array([1,3,2])

在上面的示例中，以新的十年开始的每个细分都是一个单独的“块”，我想重复一遍。每个块的大小和重复次数是已知的。我无法进行重塑，后跟kron或repeat，因为块的大小不同。

我想要的结果是

np.array([0,23,23])
# repeats:>  1  <  >         3          <  >              2             <

这很容易循环执行：

in_offset = np.r_[0,np.cumsum(chunks[:-1])]
out_offset = np.r_[0,np.cumsum(chunks[:-1] * repeats[:-1])]
output = np.zeros((chunks * repeats).sum(),dtype=a.dtype)
for c in range(len(chunks)):
    for r in range(repeats[c]):
        for i in range(chunks[c]):
            output[out_offset[c] + r * chunks[c] + i] = a[in_offset[c] + i]

这导致以下矢量化：

regions = chunks * repeats
index = np.arange(regions.sum())

segments = np.repeat(chunks,repeats)
resets = np.cumsum(segments[:-1])
offsets = np.zeros_like(index)
offsets[resets] = segments[:-1]
offsets[np.cumsum(regions[:-1])] -= chunks[:-1]

index -= np.cumsum(offsets)

output = a[index]

有没有更有效的方法来矢量化此问题？只是我们很清楚，我不是在要求代码审查。我对这些函数调用如何协同工作感到满意。我想知道是否可以使用完全不同的（更有效的）函数调用组合来达到相同的结果。

这个问题的灵感来自my answer至this question。

解决方法

（与其他答案相比）执行任务的另一种 numpythonic 方法是：

result = np.concatenate([ np.tile(tbl,rpt) for tbl,rpt in
    zip(np.split(a,np.cumsum(chunks[:-1])),repeats) ])

结果是：

array([ 0,1,2,10,11,20,21,22,23,23])

,

对于那些属于范围数组的块，我们可以直接在输入数组上工作，从而避免了最后的索引步骤，这应该可以改善-

# https://stackoverflow.com/a/47126435/ @Divakar
def create_ranges(starts,ends,l):
    clens = l.cumsum()
    ids = np.ones(clens[-1],dtype=int)
    ids[0] = starts[0]
    ids[clens[:-1]] = starts[1:] - ends[:-1]+1
    out = ids.cumsum()
    return out

s = np.r_[0,chunks.cumsum()]
starts = a[np.repeat(s[:-1],repeats)]
l = np.repeat(chunks,repeats)
ends = starts+l
out = create_ranges(starts,l)

,

比其他答案更能解决此问题的“ numpythonic ”方法是-

np.concatenate(np.repeat(np.split(a,np.cumsum(chunks))[:-1],repeats))

array([ 0,23])

注意，没有明确的for循环。

（np.split有一个隐式循环，如@Divakar指出的那样。）

---

编辑：基准（MacBook Pro 13）-

正如@Mad Physicist在他的帖子中指出的那样，Divakar的解决方案可以更好地扩展到更大的阵列，大块和重复。

,

出于参考目的，我在这里对工作解决方案进行了基准测试。

def MadPhysicist1(a,chunks,repeats):
    in_offset = np.r_[0,np.cumsum(chunks[:-1])]
    out_offset = np.r_[0,np.cumsum(chunks[:-1] * repeats[:-1])]
    output = np.zeros((chunks * repeats).sum(),dtype=a.dtype)
    for c in range(len(chunks)):
        for r in range(repeats[c]):
            for i in range(chunks[c]):
                output[out_offset[c] + r * chunks[c] + i] = a[in_offset[c] + i]
    return output

def MadPhysicist2(a,repeats):
    regions = chunks * repeats
    index = np.arange(regions.sum())

    segments = np.repeat(chunks,repeats)
    resets = np.cumsum(segments[:-1])
    offsets = np.zeros_like(index)
    offsets[resets] = segments[:-1]
    offsets[np.cumsum(regions[:-1])] -= chunks[:-1]

    index -= np.cumsum(offsets)

    output = a[index]
    return output

def create_ranges(starts,dtype=int)
    ids[0] = starts[0]
    ids[clens[:-1]] = starts[1:] - ends[:-1]+1
    out = ids.cumsum()
    return out

def Divakar(a,repeats):
    s = np.r_[0,chunks.cumsum()]
    starts = a[np.repeat(s[:-1],repeats)]
    l = np.repeat(chunks,repeats)
    ends = starts+l
    return create_ranges(starts,l)

def Valdi_Bo(a,repeats):
    return np.concatenate([np.tile(tbl,rpt in
                           zip(np.split(a,repeats)])

def AkshaySehgal(a,repeats):
    return np.concatenate(np.repeat(np.split(a,repeats))

我研究了三种输入大小的时序：〜100，〜1000和〜10k元素：

np.random.seed(0xA)
chunksA = np.random.randint(1,size=20)   # ~100 elements
repeatsA = np.random.randint(1,size=20)
arrA = np.random.randint(100,size=chunksA.sum())

np.random.seed(0xB)
chunksB = np.random.randint(1,100,size=20)  # ~1000 elements
repeatsB = np.random.randint(1,size=20)
arrB = np.random.randint(100,size=chunksB.sum())

np.random.seed(0xC)
chunksC = np.random.randint(1,size=200)  # ~10000 elements
repeatsC = np.random.randint(1,size=200)
arrC = np.random.randint(100,size=chunksC.sum())

以下是一些结果：

|               |    A    |    B    |    C    |
+---------------+---------+---------+---------+
| MadPhysicist1 | 1.92 ms |   16 ms |  159 ms |
| MadPhysicist2 | 85.5 µs |  153 µs |  744 µs |
| Divakar       | 75.9 µs | 95.9 µs |  312 µs |
| Valdi_Bo      |  370 µs |  369 µs |  3.4 ms |
| AkshaySehgal  |  163 µs |  165 µs | 1.24 ms |

,

    for rep,num in zip(repeats,chunks):
        res.extend(list(range(num))*rep)

[0,3,3]