es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Lote de matrices multidimensionales multiplicadas por un lote de escalares (sin bucles)

31 May, 2023 Programación

Tengo un lote, dos datos de matrices multidimensionales (3,3,2) de la siguiente manera:

batch= np.asarray([

          [
           [[1,2,3],
           [3,1,1,],
           [4,9,0,]], 

           [[2,2,2],
           [5,6,7],
           [3,3,3]]
          ],

          [
           [[2,2,2],
           [5,6,7],
           [3,3,3]], 

           [[1,2,3],
           [3,1,1],
           [4,9,0]]
          ]
              ])

Con un correspondiente lote, dos datos, de (1,1,2) de la siguiente manera:

scalers = np.asarray([ 

            [
             [[1]],
             [[2]]

            ],

            [
             [[0]],
             [[3]]  
            ]

                ])

Cada dimensión en el lote debe ser multiplicada por su correspondiente factor de escala en la matriz de factores escalares. Por ejemplo:

la primera dimensión

[[1,2,3],
1 * [3,1,1,],
[4,9,0,]]

la segunda dimensión

2 * [[2,2,2],
[5,6,7],
[3,3,3]]

la última dimensión

3* [[1,2,3],
[3,1,1],
[4,9,0]]

Por lo tanto, el resultado esperado debe ser como el siguiente:

           [
              [
               [[1 2 3],
               [3 1 1 ],
               [4 9 0 ]], 
           [[4 4 4],
           [10 12 14],
           [6 6 6]]
          ],

          [
           [[0 0 0],
           [0 0 0],
           [0 0 0]], 

           [[3 6 9],
           [9 3 3],
           [12 27 0]]
          ]
       ]

Estaba tratando de hacer lo siguiente para evitar cualquier bucle:

batch * scalers

pero parece que no es correcto, me pregunto cómo se puede lograr el comportamiento mencionado anteriormente.

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para obtener la salida deseada, puede utilizar la función de transmisión de broadcast de numpy junto con la multiplicación elemento a elemento. Primero, es necesario reformar el array scalers para que tenga la misma forma que el array batch. Puede hacer esto utilizando la función broadcast_to de numpy:

    scalers = np.broadcast_to(scalers, batch.shape)

    Esto creará un nuevo array con los mismos valores que scalers pero con la misma forma que batch.

    Luego, simplemente puede multiplicar batch y scalers elemento a elemento:

    result = batch * scalers

    Esto le dará la salida esperada:

    array([[[[ 1,  2,  3],
         [ 3,  1,  1],
         [ 4,  9,  0]],

        [[ 4,  4,  4],
         [10, 12, 14],
         [ 6,  6,  6]]],

       [[[ 0,  0,  0],
         [ 0,  0,  0],
         [ 0,  0,  0]],

        [[ 3,  6,  9],
         [ 9,  3,  3],
         [12, 27,  0]]]])

Comments are closed.