Tengo 3 matrices numpy y necesito formar el producto cartesiano entre ellas. Las dimensiones de las matrices no son fijas, por lo que pueden tomar diferentes valores, un ejemplo podría ser A = (10000, 50), B = (40, 50), C = (10000,50).

Luego, realizo algún procesamiento (como a + b-c) A continuación se muestra la función que estoy usando para el producto.

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]]])

La salida es la misma que conitertools.product. Sin embargo, estoy usando mi función personalizada para aprovechar operaciones numpy vectorizadas, que funcionan bien en comparación con itertools.product en mi caso.

Después de esto, lo hago

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

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

Entonces este es el resultado final esperado.

La función funciona como se esperaba, siempre y cuando mi matriz encaje en la memoria. Pero mi caso de uso requiere que trabaje con grandes datos y obtengo un MemoryError en la líneanp.empty() como no puede asignar, se requiere la memoria. Estoy trabajando con datos de alrededor de 20 GB en este momento y esto podría aumentar en el futuro.

Estas matrices representan vectores y deberán almacenarse enfloat, así que no puedo usarint. Además, son matrices densas, por lo que utilizansparse no es una opinión.

Utilizaré estas matrices para un procesamiento posterior e, idealmente, no me gustaría almacenarlas en archivos en esta etapa. Entoncesmemmap / h5py El formato puede no ayudar, aunque no estoy seguro de esto.

Si hay otras formas de formar este producto, también estaría bien.

Como estoy seguro de que hay aplicaciones con conjuntos de datos mucho más grandes que esto, espero que alguien haya encontrado estos problemas antes y quisiera saber cómo manejar este problema. Por favor ayuda.