Forma eficiente de calcular las restas diagonales sin bucles en numpy.

30 Jul, 2023 Programación 0

Tengo la siguiente matriz de numpy en 2D:

array([[5, 2, 6],
       [4, 5, 6],
       [7, 12, 3]])

Tengo una ecuación (de gradiente) que utiliza las diagonales para realizar un cálculo como el siguiente:

(array[i , j] - array[i + 1, j + 1]) **2 + (array[i+1 , j] - array[i, j + 1]) **2

La ecuación es muy simple. Toma cada submatriz 2×2, resta las diagonales, las eleva al cuadrado y luego suma cada resultado. En el ejemplo utilizado anteriormente, para la primera submatriz 2×2, la ecuación resultaría en:

(5 - 5) ^ 2 + (4 - 2) ^ 2 = 4

Este valor sería el primer elemento de una nueva matriz de numpy. Y el resto de los elementos se poblarian de la misma manera, pasando a la siguiente submatriz 2×2.

La primera solución obvia a esto es utilizar un bucle anidado for sobre todas las filas y columnas. Pero ¿hay alguna forma más eficiente de hacerlo utilizando numpy (u otras bibliotecas) para evitar los bucles for? O si no se pueden evitar directamente los bucles for, ¿se puede hacer el cálculo más eficiente para matrices 2D más grandes?

import numpy as np # array de entrada arr = np.array([[5, 2, 6], [4, 5, 6], [7, 12, 3]]) # obtener la forma del array n_filas, n_columnas = arr.shape # crear un array para almacenar los resultados resultado = np.zeros((n_filas - 1, n_columnas - 1)) # calcular los gradientes para cada submatriz 2x2 utilizando el corte de arrays resultado = (arr[:-1, :-1] - arr[1:, 1:]) ** 2 + (arr[1:, :-1] - arr[:-1, 1:]) ** 2 print(resultado)

Answer

davy.ai

July 30, 2023 at 12:08 am
Sí, hay una manera más eficiente de realizar este cálculo utilizando numpy. Podemos utilizar el corte de arrays y la vectorización para evitar los bucles for anidados.

Aquí hay una posible solución usando numpy y el corte de arrays:
```
import numpy as np

# array de entrada
arr = np.array([[5, 2, 6],
                [4, 5, 6],
                [7, 12, 3]])

# obtener la forma del array
n_filas, n_columnas = arr.shape

# crear un array para almacenar los resultados
resultado = np.zeros((n_filas - 1, n_columnas - 1))

# calcular los gradientes para cada submatriz 2x2 utilizando el corte de arrays
resultado = (arr[:-1, :-1] - arr[1:, 1:]) ** 2 + (arr[1:, :-1] - arr[:-1, 1:]) ** 2

print(resultado)
```
Este código primero obtiene la forma del array de entrada utilizando el atributo shape. Luego crea un array numpy lleno de ceros con forma (n_filas - 1, n_columnas - 1) para almacenar los resultados.

Utilizando el corte de arrays, luego calculamos los gradientes para cada submatriz 2×2 arr[i:i+2, j:j+2] utilizando la ecuación proporcionada. Las submatrices se obtienen cortando el array original de diferentes maneras – por ejemplo, arr[:-1, :-1] nos da todos los elementos excepto la última fila y la última columna. Luego utilizamos operaciones elemento a elemento y broadcasting para calcular los gradientes para todas las submatrices de una vez.

Este enfoque es más eficiente que utilizar bucles for anidados, especialmente para arrays 2D grandes, ya que utiliza las operaciones vectorizadas optimizadas de numpy.

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

Forma eficiente de calcular las restas diagonales sin bucles en numpy.

Answer

davy.ai