Eu tenho três matrizes numpy e preciso formar o produto cartesiano entre elas. As dimensões das matrizes não são fixas; portanto, eles podem assumir valores diferentes; um exemplo pode ser A = (10000, 50), B = (40, 50), C = (10000,50).

Em seguida, realizo algum processamento (como a + b-c) Abaixo está a função que estou usando para o produto.

def cartesian_2d(arrays, out=None):

    arrays = [np.asarray(x) for x in arrays]
    dtype = arrays[0].dtype

    n = np.prod([x.shape[0] for x in arrays])
    if out is None:
        out = np.empty([n, len(arrays), arrays[0].shape[1]], dtype=dtype)

    m = n // arrays[0].shape[0]
    out[:, 0] = np.repeat(arrays[0], m, axis=0)
    if arrays[1:]:
        cartesian_2d(arrays[1:], out=out[0:m, 1:, :])
        for j in range(1, arrays[0].shape[0]):
            out[j * m:(j + 1) * m, 1:] = out[0:m, 1:]
    return out

a = [[ 0, -0.02], [1, -0.15]]
b = [[0, 0.03]]

result = cartesian_2d([a,b,a])

// array([[[ 0.  , -0.02],
    [ 0.  ,  0.03],
    [ 0.  , -0.02]],

   [[ 0.  , -0.02],
    [ 0.  ,  0.03],
    [ 1.  , -0.15]],

   [[ 1.  , -0.15],
    [ 0.  ,  0.03],
    [ 0.  , -0.02]],

   [[ 1.  , -0.15],
    [ 0.  ,  0.03],  
    [ 1.  , -0.15]]])

A saída é a mesma que comitertools.product. No entanto, estou usando minha função personalizada para aproveitar as operações vetorizadas numpy, que estão funcionando bem em comparação com itertools.product no meu caso.

Depois disso, eu faço

result[:, 0, :] + result[:, 1, :] - result[:, 2, :]

//array([[ 0.  ,  0.03],
       [-1.  ,  0.16],
       [ 1.  , -0.1 ],
       [ 0.  ,  0.03]])

Portanto, este é o resultado final esperado.

A função funciona como esperado, desde que minha matriz caiba na memória. Mas meu caso de usuário exige que eu trabalhe com grandes dados e recebo um MemoryError na linhanp.empty() como não é possível alocar, a memória é necessária. Atualmente, estou trabalhando com cerca de 20 GB de dados e isso pode aumentar no futuro.

Essas matrizes representam vetores e terão que ser armazenadas emfloat, então não posso usarint. Além disso, eles são matrizes densas, portanto, usandosparse não é uma opção.

Usarei essas matrizes para processamento adicional e, idealmente, não gostaria de armazená-las em arquivos nesta fase. assimmemmap / h5py formato pode não ajudar, embora não tenha certeza disso.

Se houver outras maneiras de formar este produto, tudo bem também.

Como tenho certeza de que existem aplicativos com conjuntos de dados bem maiores do que isso, espero que alguém já tenha encontrado esses problemas antes e gostaria de saber como lidar com esse problema. Por favor ajude.