numpy-如何删除尾随的N * 8个零

Question

我有1d数组，我需要删除所有8个零的尾随块。

[0,1,1,0,1,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0]
->
[0,1,1,0,1,0,0,0]

a.shape[0] % 8 == 0始终如此，因此不用担心。

有更好的方法吗？

import numpy as np
P = 8
arr1 = np.random.randint(2,size=np.random.randint(5,10) * P)
arr2 = np.random.randint(1,size=np.random.randint(5,10) * P)
arr = np.concatenate((arr1, arr2))

indexes = []
arr = np.flip(arr).reshape(arr.shape[0] // P, P)

for i, f in enumerate(arr):
    if (f == 0).all():
        indexes.append(i)
    else:
        break

arr = np.delete(arr, indexes, axis=0)
arr = np.flip(arr.reshape(arr.shape[0] * P))

Answer 1

您可以通过使用视图和np.argmax获得最后一个非零元素来做到这一点而无需分配更多空间：

index = arr.size - np.argmax(arr[::-1])

四舍五入到最接近的八倍很容易：

index = np.ceil(index / 8) * 8

现在砍掉其余部分：

arr = arr[:index]

或者作为单线：

arr = arr[:(arr.size - np.argmax(arr[::-1])) / 8) * 8]

此版本的时间为O(n)，空间为O(1)，因为它对所有内容（包括输出）都使用相同的缓冲区。

这还有一个优势，即使没有尾随零也可以正常工作。使用argmax确实依赖于所有相同的元素。如果不是这种情况，则需要首先计算一个掩码，例如与arr.astype(bool)。

如果要使用原始方法，也可以将其向量化，尽管会增加一些开销：

view = arr.reshape(-1, 8)
mask = view.any(axis = 1)
index = view.shape[0] - np.argmax(mask[::-1])
arr = arr[:index * 8]

Answer 2

有一个numpy函数，几乎可以完成您想要的np.trim_zeros。我们可以使用它：

import numpy as np

def trim_mod(a, m=8):
    t = np.trim_zeros(a, 'b')
    return a[:len(a)-(len(a)-len(t))//m*m]

def test(a, t, m=8):
    assert (len(a) - len(t)) % m == 0
    assert len(t) < m or np.any(t[-m:])
    assert not np.any(a[len(t):])

for _ in range(1000):
    a = (np.random.random(np.random.randint(10, 100000))<0.002).astype(int)
    m = np.random.randint(4, 20)
    t = trim_mod(a, m)
    test(a, t, m)

print("Looks correct")

打印：

Looks correct

似乎尾随零的数量呈线性比例：

但是绝对感觉很慢（每个试验的单位是毫秒），因此，np.trim_zeros仅仅是一个python循环。

图片代码：

from timeit import timeit

A = (np.random.random(1000000)<0.02).astype(int)
m = 8
T = []
for last in range(1, 1000, 9):
    A[-last:] = 0
    A[-last] = 1
    T.append(timeit(lambda: trim_mod(A, m), number=100)*10)

import pylab
pylab.plot(range(1, 1000, 9), T)
pylab.show()

Answer 3

低级方法：

import numba
@numba.njit
def trim8(a):
    n=a.size-1
    while n>=0 and a[n]==0 : n-=1
    c= (n//8+1)*8
    return a[:c]

一些测试：

In [194]: A[-1]=1  # best case

In [196]: %timeit trim_mod(A,8)
5.7 µs ± 323 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [197]: %timeit trim8(A)
714 ns ± 33.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [198]: %timeit A[:(A.size - np.argmax(A[::-1]) // 8) * 8]
4.83 ms ± 479 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [202]: A[:]=0 #worst case

In [203]: %timeit trim_mod(A,8)
2.5 s ± 49.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [204]: %timeit trim8(A)
1.14 ms ± 71.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [205]: %timeit A[:(A.size - np.argmax(A[::-1]) // 8) * 8]
5.5 ms ± 950 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

它具有trim_zeros之类的短路机制，但速度更快。