Início / coding / Perguntas / 79135714
Accepted
KyroAsks
Asked: 2024-10-29 10:58:04 +0800 CST

A maneira mais rápida de dividir uma matriz 2D em Python em patches no sentido anti-horário

  • 772

Dado um array 2D de tamanho (W,H), por exemplo (3,4). Você pode pensar em cada ponto nesse array 2D como um canto de um patch retangular. Eu quero dividir esse array em seus patches individuais, conforme mostrado no exemplo abaixo. A ordem pela qual essa divisão acontece é linha por linha e para cada patch começamos do pixel superior esquerdo e movemos no sentido anti-horário. Ou seja, o patch 1 é [A[0,0],A[1,0],A[1,1],A[0,1]]. Então o patch dois é [A[0,1],A[1,1],A[1,2],A[0,2]]. O número de patches é (w-1) (h-1) e a saída final é outro array 2D de tamanho ((w-1) ( h-1),4) (por exemplo, (6,4) aqui), onde 6 é o número de patches e 4 são valores de array para os cantos do patch no sentido anti-horário, conforme descrito acima.

Agora minha pergunta é sobre a maneira mais eficiente de produzir esses patches em python usando apenas funções python e numpy.

Muito obrigado.

Posso escrever um loop duplo for que faça o trabalho conforme abaixo, mas estou pensando se existe um algoritmo melhor que possa fornecer um desempenho mais rápido:

import numpy as np
A=np.array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
H=A.shape[0]
W=A.shape[1]
patches=[]
for y in range(H-1):
    for x in range(W-1):
       patches.append([A[0+y,0+x],A[1+y,0+x],A[1+y,1+x],A[0+y,1+x]])


patches =np.array(patches)
print(patches)
python

1 respostas

  1. Best Answer

    Supondo que você cometeu um erro de digitação e quis dizer

    for y in range(H-1):
    for x in range(W-1):

    Então você pode obter o mesmo resultado com:

    # indeces offsets for a counterclockwise 2x2 block
i = np.array([0,1,1,0])
j = np.array([0,0,1,1])

# top corner indeces for the (H-1)x(W-1) 2D array of blocks
h, w = np.meshgrid(np.arange(H-1), np.arange(W-1), indexing='ij')

# turn to a flat 1D array of blocks
h = h.flatten()
w = w.flatten()

# add the ofsets for every block (create extra axis and broadcast)
h = h[:,None]+i
w = w[:,None]+j

# use advanced indexing to "sample at given indeces
A[h,w]

    Comparação (o meu é ~3x mais lento naquele exemplo de brinquedo, mas ~10x mais rápido em matrizes maiores):

    def yours(A):
    H=A.shape[0]
    W=A.shape[1]
    grids=[]
    for y in range(H-1):
        for x in range(W-1):
           grids.append([A[0+y,0+x],A[1+y,0+x],A[1+y,1+x],A[0+y,1+x]])
    grids=np.array(grids)
    return grids
    
def mine(A):
    i = np.array([0,1,1,0])
    j = np.array([0,0,1,1])
    H = A.shape[0]
    W = A.shape[1]
    h, w = np.meshgrid(np.arange(H-1), np.arange(W-1), indexing='ij')
    h = h.flatten()[:,None]+i
    w = w.flatten()[:,None]+j
    return A[h,w]


A = np.arange(30*20).reshape((30,20))    

assert np.all(yours(A) == mine(A))


%timeit yours(A)
# 261 µs ± 229 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

%timeit mine(A)
# 27.4 µs ± 46.4 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
    • 1

relate perguntas