Início / coding / Perguntas / 79274376
Accepted
Abhishek Jain
Asked: 2024-12-12 16:52:10 +0800 CST

Fatie uma matriz numpy 2D usando outra matriz 2D

  • 772

Eu tenho um array 2D de (4,5) e outro array 2D de formato (4,2). O segundo array contém os índices inicial e final que eu preciso filtrar do primeiro array, ou seja, eu quero fatiar o primeiro array usando o segundo array.

np.random.seed(0)
a = np.random.randint(0,999,(4,5))
a
array([[684, 559, 629, 192, 835],
       [763, 707, 359,   9, 723],
       [277, 754, 804, 599,  70],
       [472, 600, 396, 314, 705]])

idx = np.array([[2,4],
                [0,3],
                [2,3],
                [1,3]
               ])

Saída esperada - pode ser qualquer um dos dois formatos a seguir. A única razão para preenchimento com zeros é que arrays 2d de comprimento variável não são suportados.

[[629, 192, 835, 0, 0],
 [763, 707, 359, 9, 0],
 [804, 599, 0, 0, 0],
 [600, 396, 314, 0, 0]
]

[[0, 0, 629, 192, 835],
 [763, 707, 359, 9, 0],
 [0, 0, 804, 599, 0],
 [0, 600, 396, 314, 0]
]
python

4 respostas

  1. Best Answer

    Outra solução possível, que utiliza:

    • np.arangepara criar um intervalo de índices de colunas com base no número de colunas em a.

    • Uma máscara booleana mé criada usando operações lógicas para verificar se cada índice de coluna cai dentro do intervalo especificado por idx. O np.newaxisé usado para alinhar dimensões para transmissão.

    • np.whereé usado para criar a_mask, onde os elementos em asão substituídos por 0 se o valor correspondente em mfor False.

    • np.argsorté usado para obter os índices que classificariam cada linha de m(negado) em ordem crescente.

    • np.take_along_axisé usado para reorganizar os elementos com a_maskbase nos índices classificados.

    cols = np.arange(a.shape[1])
m = (cols >= idx[:, 0, np.newaxis]) & (cols <= idx[:, 1, np.newaxis])

a_mask = np.where(m, a, 0)
sort_idx = np.argsort(~m, axis=1)
np.take_along_axis(a_mask, sort_idx, axis=1)

    NB: Observe que a_maskcontém a versão não classificada da solução (essa é essencialmente a abordagem seguida por @mozway).

    Saída:

    array([[629, 192, 835,   0,   0],
       [763, 707, 359,   9,   0],
       [804, 599,   0,   0,   0],
       [600, 396, 314,   0,   0]])

# a_mask
array([[  0,   0, 629, 192, 835],
       [763, 707, 359,   9,   0],
       [  0,   0, 804, 599,   0],
       [  0, 600, 396, 314,   0]])
    • 4

  2. Use transmissão e numpy.arangepara calcular uma máscara, depois aplique numpy.wherepara selecionar os Truevalores de ae 0caso contrário:

    i = np.arange(a.shape[1])[None]

out = np.where((i >= idx[:, [0]]) & (i <= idx[:, [1]]), a, 0)

    Saída:

    array([[  0,   0, 629, 192, 835],
       [763, 707, 359,   9,   0],
       [  0,   0, 804, 599,   0],
       [  0, 600, 396, 314,   0]])

    Intermediários:

    # i
array([[0, 1, 2, 3, 4]])

# (i >= idx[:, [0]]) & (i <= idx[:, [1]])
array([[False, False,  True,  True,  True],
       [ True,  True,  True,  True, False],
       [False, False,  True,  True, False],
       [False,  True,  True,  True, False]])

    Se você quiser a primeira saída com os valores à esquerda, que é um pouco mais longa, você pode calcular os índices para preencher uma matriz de zeros_like:

    # like above
i = np.arange(a.shape[1])[None] # array([[0, 1, 2, 3, 4]]),
m = (i >= idx[:, [0]]) & (i <= idx[:, [1]])

# prepare output with 0s
out = np.zeros_like(a)

# get row indices
r, _ = np.where(m) # r: array([0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3]),

# compute column indices
_, cnt = np.unique(r, return_counts=True) # cnt: array([3, 4, 2, 3])
c = np.arange(cnt.sum()) - np.repeat(np.r_[0, cnt[:-1]].cumsum(), cnt)
# c: array([0, 1, 2, 0, 1, 2, 3, 0, 1, 0, 1, 2])

# fill with valid values
out[r, c] = a[m]

    Saída:

    array([[629, 192, 835,   0,   0],
       [763, 707, 359,   9,   0],
       [804, 599,   0,   0,   0],
       [600, 396, 314,   0,   0]])
    • 2

  3. Explicação dada como comentários dentro do código:

    import numpy as np

# Input arrays
np.random.seed(0)
a = np.random.randint(0, 999, (4, 5))
idx = np.array([[2, 4],
                [0, 3],
                [2, 3],
                [1, 3]])

# Prepare the output array with zeros
output_padded_start = np.zeros_like(a)
output_padded_end = np.zeros_like(a)

# Slice and place the values
for i in range(a.shape[0]):
    start, end = idx[i]
    sliced_values = a[i, start:end + 1]
    output_padded_start[i, :len(sliced_values)] = sliced_values  # Padding with zeros at the end
    output_padded_end[i, -len(sliced_values):] = sliced_values  # Padding with zeros at the start


print("Padded at the end:")
print(output_padded_start)
print("\nPadded at the start:")
print(output_padded_end)


# Output
Padded at the end:
[[629 192 835   0   0]
 [763 707 359   9   0]
 [804 599   0   0   0]
 [600 396 314   0   0]]

Padded at the start:
[[  0   0 629 192 835]
 [763 707 359   9   0]
 [  0   0 804 599   0]
 [  0 600 396 314   0]]
    • 0

  4. Provavelmente você pode tentar

    v = np.arange(a.shape[1])
a*list(map(lambda x: np.isin(v, range(x[0],x[1]+1)), idx))

    o que dá

    [[  0   0 629 192 835]
 [763 707 359   9   0]
 [  0   0 804 599   0]
 [  0 600 396 314   0]]
    • 0

relate perguntas