Qual é a maneira mais rápida de mapear nomes de grupos de matrizes numpy para índices?

9

Estou trabalhando com o pointcloud 3D do Lidar. Os pontos são dados por uma matriz numpy que se parece com isso:

points = np.array([[61651921, 416326074, 39805], [61605255, 416360555, 41124], [61664810, 416313743, 39900], [61664837, 416313749, 39910], [61674456, 416316663, 39503], [61651933, 416326074, 39802], [61679969, 416318049, 39500], [61674494, 416316677, 39508], [61651908, 416326079, 39800], [61651908, 416326087, 39802], [61664845, 416313738, 39913], [61674480, 416316668, 39503], [61679996, 416318047, 39510], [61605290, 416360572, 41118], [61605270, 416360565, 41122], [61683939, 416313004, 41052], [61683936, 416313033, 41060], [61679976, 416318044, 39509], [61605279, 416360555, 41109], [61664837, 416313739, 39915], [61674487, 416316666, 39505], [61679961, 416318035, 39503], [61683943, 416313004, 41054], [61683930, 416313042, 41059]])

Gostaria de manter meus dados agrupados em cubos de tamanho, 50*50*50para que cada cubo preserve algum índice hashable e índices numpy do meu pointsconteúdo . Para obter a divisão, atribuo cubes = points \\ 50quais saídas a:

cubes = np.array([[1233038, 8326521, 796], [1232105, 8327211, 822], [1233296, 8326274, 798], [1233296, 8326274, 798], [1233489, 8326333, 790], [1233038, 8326521, 796], [1233599, 8326360, 790], [1233489, 8326333, 790], [1233038, 8326521, 796], [1233038, 8326521, 796], [1233296, 8326274, 798], [1233489, 8326333, 790], [1233599, 8326360, 790], [1232105, 8327211, 822], [1232105, 8327211, 822], [1233678, 8326260, 821], [1233678, 8326260, 821], [1233599, 8326360, 790], [1232105, 8327211, 822], [1233296, 8326274, 798], [1233489, 8326333, 790], [1233599, 8326360, 790], [1233678, 8326260, 821], [1233678, 8326260, 821]])

Minha saída desejada é assim:

{(1232105, 8327211, 822): [1, 13, 14, 18]), 
(1233038, 8326521, 796): [0, 5, 8, 9], 
(1233296, 8326274, 798): [2, 3, 10, 19], 
(1233489, 8326333, 790): [4, 7, 11, 20], 
(1233599, 8326360, 790): [6, 12, 17, 21], 
(1233678, 8326260, 821): [15, 16, 22, 23]}

Meu verdadeiro pointcloud contém até algumas centenas de milhões de pontos 3D. Qual é a maneira mais rápida de fazer esse tipo de agrupamento?

Eu tentei a maioria das várias soluções. Aqui está a comparação do consumo de tempo assumindo que o tamanho dos pontos é de cerca de 20 milhões e o tamanho de cubos distintos é de 1 milhão:

Pandas [tupla (elem) -> matriz np (dtype = int64)]

import pandas as pd
print(pd.DataFrame(cubes).groupby([0,1,2]).indices)
#takes 9sec

Defauldict [elem.tobytes () ou tupla -> lista]

#thanks @abc:
result = defaultdict(list)
for idx, elem in enumerate(cubes):
    result[elem.tobytes()].append(idx) # takes 20.5sec
    # result[elem[0], elem[1], elem[2]].append(idx) #takes 27sec
    # result[tuple(elem)].append(idx) # takes 50sec

numpy_indexed [int -> matriz np]

# thanks @Eelco Hoogendoorn for his library
values = npi.group_by(cubes).split(np.arange(len(cubes)))
result = dict(enumerate(values))
# takes 9.8sec

Pandas + redução de dimensionalidade [int -> matriz np (dtype = int64)]

# thanks @Divakar for showing numexpr library:
import numexpr as ne
def dimensionality_reduction(cubes):
    #cubes = cubes - np.min(cubes, axis=0) #in case some coords are negative 
    cubes = cubes.astype(np.int64)
    s0, s1 = cubes[:,0].max()+1, cubes[:,1].max()+1
    d = {'s0':s0,'s1':s1,'c0':cubes[:,0],'c1':cubes[:,1],'c2':cubes[:,2]}
    c1D = ne.evaluate('c0+c1*s0+c2*s0*s1',d)
    return c1D
cubes = dimensionality_reduction(cubes)
result = pd.DataFrame(cubes).groupby([0]).indices
# takes 2.5 seconds

É possível baixar o cubes.npzarquivo aqui e usar um comando

cubes = np.load('cubes.npz')['array']

para verificar o tempo de desempenho.

mathfux
fonte
Você sempre tem o mesmo número de índices em cada lista do seu resultado?
Mykola Zotko
Sim, é sempre o mesmo: 983234 cubos distintos para todas as soluções acima mencionadas.
mathfux
11
É improvável que uma solução tão simples do Pandas seja derrotada por uma abordagem simples, pois um grande esforço foi gasto para otimizá-la. Uma abordagem baseada em Cython provavelmente poderia abordá-la, mas duvido que superasse.
Norok2
11
@mathfux Você precisa ter a saída final como um dicionário ou seria bom ter os grupos e seus índices como duas saídas?
Divakar
@ norok2 numpy_indexedapenas se aproxima disso também. Eu acho que está certo. pandasAtualmente, uso nos meus processos de classificação.
Mathfux

Respostas:

6

Número constante de índices por grupo

Abordagem # 1

Podemos executar dimensionality-reductionpara reduzir cubesa uma matriz 1D. Isso se baseia em um mapeamento dos dados dos cubos fornecidos em uma grade n-dim para calcular os equivalentes de índice linear, discutidos em detalhes here. Então, com base na singularidade desses índices lineares, podemos separar grupos únicos e seus índices correspondentes. Portanto, seguindo essas estratégias, teríamos uma solução, assim:

N = 4 # number of indices per group
c1D = np.ravel_multi_index(cubes.T, cubes.max(0)+1)
sidx = c1D.argsort()
indices = sidx.reshape(-1,N)
unq_groups = cubes[indices[:,0]]

# If you need in a zipped dictionary format
out = dict(zip(map(tuple,unq_groups), indices))

Alternativa 1: se os valores inteiros em cubesforem muito grandes, convém fazer com dimensionality-reductionque as dimensões com menor extensão sejam escolhidas como os eixos primários. Portanto, nesses casos, podemos modificar a etapa de redução para obter c1D, assim:

s1,s2 = cubes[:,:2].max(0)+1
s = np.r_[s2,1,s1*s2]
c1D = cubes.dot(s)

Abordagem # 2

Em seguida, podemos usar Cython-powered kd-treea pesquisa rápida do vizinho mais próximo para obter os índices vizinhos mais próximos e, portanto, resolver nosso caso da seguinte forma:

from scipy.spatial import cKDTree

idx = cKDTree(cubes).query(cubes, k=N)[1] # N = 4 as discussed earlier
I = idx[:,0].argsort().reshape(-1,N)[:,0]
unq_groups,indices = cubes[I],idx[I]

Caso genérico: número variável de índices por grupo

Vamos estender o método baseado em argsort com algumas divisões para obter a saída desejada, assim:

c1D = np.ravel_multi_index(cubes.T, cubes.max(0)+1)

sidx = c1D.argsort()
c1Ds = c1D[sidx]
split_idx = np.flatnonzero(np.r_[True,c1Ds[:-1]!=c1Ds[1:],True])
grps = cubes[sidx[split_idx[:-1]]]

indices = [sidx[i:j] for (i,j) in zip(split_idx[:-1],split_idx[1:])]
# If needed as dict o/p
out = dict(zip(map(tuple,grps), indices))

Usando versões 1D de grupos de cubescomo chaves

Estenderemos o método listado anteriormente com os grupos de cubescomo chaves para simplificar o processo de criação de dicionário e também torná-lo eficiente, como:

def numpy1(cubes):
    c1D = np.ravel_multi_index(cubes.T, cubes.max(0)+1)        
    sidx = c1D.argsort()
    c1Ds = c1D[sidx]
    mask = np.r_[True,c1Ds[:-1]!=c1Ds[1:],True]
    split_idx = np.flatnonzero(mask)
    indices = [sidx[i:j] for (i,j) in zip(split_idx[:-1],split_idx[1:])]
    out = dict(zip(c1Ds[mask[:-1]],indices))
    return out

Em seguida, usaremos o numbapacote para iterar e chegar à saída final do dicionário hashable. Seguindo em frente, haveria duas soluções - uma que obtém as chaves e os valores separadamente numbae a chamada principal será compactada e convertida em dict, enquanto a outra criará um numba-supportedtipo de dict e, portanto, nenhum trabalho extra exigido pela função de chamada principal .

Assim, teríamos a primeira numbasolução:

from numba import  njit

@njit
def _numba1(sidx, c1D):
    out = []
    n = len(sidx)
    start = 0
    grpID = []
    for i in range(1,n):
        if c1D[sidx[i]]!=c1D[sidx[i-1]]:
            out.append(sidx[start:i])
            grpID.append(c1D[sidx[start]])
            start = i
    out.append(sidx[start:])
    grpID.append(c1D[sidx[start]])
    return grpID,out

def numba1(cubes):
    c1D = np.ravel_multi_index(cubes.T, cubes.max(0)+1)
    sidx = c1D.argsort()
    out = dict(zip(*_numba1(sidx, c1D)))
    return out

E segunda numbasolução como:

from numba import types
from numba.typed import Dict

int_array = types.int64[:]

@njit
def _numba2(sidx, c1D):
    n = len(sidx)
    start = 0
    outt = Dict.empty(
        key_type=types.int64,
        value_type=int_array,
    )
    for i in range(1,n):
        if c1D[sidx[i]]!=c1D[sidx[i-1]]:
            outt[c1D[sidx[start]]] = sidx[start:i]
            start = i
    outt[c1D[sidx[start]]] = sidx[start:]
    return outt

def numba2(cubes):
    c1D = np.ravel_multi_index(cubes.T, cubes.max(0)+1)    
    sidx = c1D.argsort()
    out = _numba2(sidx, c1D)
    return out

Tempos com cubes.npzdados -

In [4]: cubes = np.load('cubes.npz')['array']

In [5]: %timeit numpy1(cubes)
   ...: %timeit numba1(cubes)
   ...: %timeit numba2(cubes)
2.38 s ± 14.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
2.13 s ± 25.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
1.8 s ± 5.95 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Alternativa nº 1: podemos acelerar ainda mais com numexprmatrizes grandes para calcular c1D, assim:

import numexpr as ne

s0,s1 = cubes[:,0].max()+1,cubes[:,1].max()+1
d = {'s0':s0,'s1':s1,'c0':cubes[:,0],'c1':cubes[:,1],'c2':cubes[:,2]}
c1D = ne.evaluate('c0+c1*s0+c2*s0*s1',d)

Isso seria aplicável em todos os locais que exigirem c1D.

Divakar
fonte
Muito obrigado pela resposta! Eu não esperava que o uso do cKDTree fosse possível aqui. No entanto, ainda existem alguns problemas com o seu # Approach1. O comprimento da saída é apenas 915791. Eu acho que isso é algum tipo de conflito entre dtypes int32eint64
mathfux
@mathfux Estou assumindo number of indices per group would be a constant numberque reuni os comentários. Isso seria uma suposição segura? Além disso, você está testando cubes.npza saída de 915791?
Divakar
Sim eu quero. Não testei o número de índices por grupo porque a ordem dos nomes dos grupos pode ser diferente. Eu testei o comprimento do dicionário de saída cubes.npzapenas e foi 983234para as outras abordagens que sugeri.
mathfux
11
@mathfux Confira Approach #3 esse caso genérico de número variável de índices.
Divakar
11
@mathfux Sim, essa compensação é necessária geralmente se o mínimo for menor que 0. Boa captura da precisão!
Divakar
5

Você pode apenas iterar e adicionar o índice de cada elemento à lista correspondente.

from collections import defaultdict

res = defaultdict(list)

for idx, elem in enumerate(cubes):
    #res[tuple(elem)].append(idx)
    res[elem.tobytes()].append(idx)

O tempo de execução pode ser aprimorado ainda mais usando tobytes () em vez de converter a chave em uma tupla.

abc
fonte
Estou tentando fazer uma revisão do tempo de desempenho no momento (para 20 milhões de pontos). Parece que minha solução é mais eficiente em termos de tempo, porque a iteração é evitada. Eu concordo, o consumo de memória é enorme.
mathfux
outra proposta res[tuple(elem)].append(idx)levou 50 segundos contra sua edição, res[elem[0], elem[1], elem[2]].append(idx)que levou 30 segundos.
Mathfux
3

Você pode usar o Cython:

%%cython -c-O3 -c-march=native -a
#cython: language_level=3, boundscheck=False, wraparound=False, initializedcheck=False, cdivision=True, infer_types=True

import math
import cython as cy

cimport numpy as cnp


cpdef groupby_index_dict_cy(cnp.int32_t[:, :] arr):
    cdef cy.size_t size = len(arr)
    result = {}
    for i in range(size):
        key = arr[i, 0], arr[i, 1], arr[i, 2]
        if key in result:
            result[key].append(i)
        else:
            result[key] = [i]
    return result

mas não o tornará mais rápido do que o Pandas faz, embora seja o mais rápido depois disso (e talvez o numpy_index solução baseada), e não venha com a penalidade de memória. Uma coleção do que foi proposto até agora está aqui .

Na máquina do OP, o tempo de execução é de aproximadamente 12 segundos.

norok2
fonte
11
Muito obrigado, testarei mais tarde.
mathfux