Cómo remodelar matrices NumPy en Python

En este tutorial, aprenderá a usar NumPy remodelar() para remodelar matrices NumPy sin cambiar los datos originales.

Cuando trabaje con arreglos Numpy, a menudo querrá remodelar un arreglo existente en un arreglo de diferentes dimensiones. Esto puede ser particularmente útil cuando transforma datos en varios pasos.

Y NumPy remodelar() te ayuda a hacerlo fácilmente. En los próximos minutos, aprenderá la sintaxis para usar remodelar() y también remodelar arreglos a diferentes dimensiones.

¿Qué es remodelar en NumPy Arrays?

Cuando trabaje con matrices NumPy, es posible que primero desee crear una matriz de números unidimensional. Y luego remodelarlo en una matriz con la dimensión deseada.

Esto es particularmente útil cuando las dimensiones de la nueva matriz no se conocen inicialmente o se infieren durante la ejecución. O también puede ser posible que un determinado paso de procesamiento de datos requiera que la entrada tenga una forma específica.

Aquí es donde la remodelación es útil.

Por ejemplo, considere la siguiente ilustración. Tenemos un vector: una matriz unidimensional de 6 elementos. Y podemos remodelarlo en arreglos de formas 2×3, 3×2, 6×1, y así sucesivamente.

▶️ Para seguir los ejemplos de este tutorial, debe tener Python y NumPy instalados. Si aún no tiene NumPy, consulte nuestra guía de instalación de NumPy.

Ahora puede continuar e importar NumPy bajo el alias np, ejecutando: import numpy as np.

Procedamos a aprender la sintaxis en la siguiente sección.

Sintaxis de NumPy reformar()

Esta es la sintaxis para usar NumPy remodelar():

np.reshape(arr, newshape, order="C"|'F'|'A')
  • arr es cualquier objeto de matriz NumPy válido. Aquí, es la matriz que se va a remodelar.
  • newshape es la forma de la nueva matriz. Puede ser un número entero o una tupla.
  • Cuando newshape es un número entero, la matriz devuelta es unidimensional.
  • order se refiere al orden en el que le gustaría leer los elementos de la matriz que se van a remodelar.
  • El valor predeterminado es ‘C’, lo que significa que los elementos de la matriz original se leerán en un orden de indexación similar a C (comenzando con 0)
  • ‘F’ significa indexación similar a Fortran (comenzando con 1). Y ‘A’ lee los elementos en orden similar a C o similar a Fortran, según el diseño de memoria de la matriz arr.

Entonces, ¿qué devuelve np.reshape()?

Devuelve una vista remodelada de la matriz original si es posible. De lo contrario, devuelve una copia de la matriz.

En la línea anterior, mencionamos que NumPy reshape() intentaría devolver una vista siempre que fuera posible. De lo contrario, devuelve una copia. Procedamos a discutir las diferencias entre una vista y una copia.

Ver vs. Copiar matrices NumPy

Como sugiere el nombre, la copia es una copia de la matriz original. Y cualquier cambio realizado en la copia no afectará la matriz original.

Por otro lado, la vista simplemente se refiere a la vista remodelada de la matriz original. Esto significa que cualquier cambio realizado en la vista también afectará a la matriz original y viceversa.

Use NumPy remodelar () para remodelar una matriz 1D a matrices 2D

#1. Comencemos creando la matriz de muestra usando np.naranja().

Necesitamos una matriz de 12 números, del 1 al 12, llamada arr1. Como la función NumPy arange() excluye el punto final de forma predeterminada, establezca el valor de parada en 13.

Ahora usemos la sintaxis anterior y remodelemos arr1 con 12 elementos en una matriz 2D de forma (4,3). Llamemos a este arr2 con 4 filas y 3 columnas.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr2 = np.reshape(arr1,(4,3))
print("nReshaped array:")
print(arr2)

Echemos un vistazo a las matrices originales y remodeladas.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

En lugar de pasar la matriz como argumento np.reshape(), también puede llamar al método .reshape() en la matriz original.

Puede ejecutar dir(arr1) y enumerará todos los métodos y atributos posibles que puede usar en el objeto de matriz arr1.

dir(arr1)

# Output 
[
...
...
'reshape'
...
..
]

En la celda de código anterior, puede ver que .reshape() es un método válido para usar en la matriz NumPy arr1 existente.

▶️ Entonces, también puede usar la siguiente sintaxis simplificada para remodelar matrices NumPy.

arr.reshape(d0,d1,...,dn)

# where:

# d0, d1,..,dn are the dimensions of the reshaped array

# d0 * d1 * ...* dn = N, the number of elements in arr

Para el resto de este tutorial, usemos esta sintaxis en nuestros ejemplos.

#2. Intentemos remodelar nuestro vector de 12 elementos en una matriz de 12 x 1.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr3 = arr1.reshape(12,1)
print("nReshaped array:")
print(arr3)

En el resultado a continuación, puede ver que la matriz se ha reformado según sea necesario.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[ 1]
 [ 2]
 [ 3]
 [ 4]
 [ 5]
 [ 6]
 [ 7]
 [ 8]
 [ 9]
 [10]
 [11]
 [12]]

❔ Entonces, ¿cómo comprobamos si hemos obtenido una copia o una vista?

Para verificar esto, puede llamar al atributo base en la matriz devuelta.

  • Si la matriz es una copia, el atributo base será Ninguno.
  • Si la matriz es una vista, el atributo base será la matriz original.

Verifiquemos esto rápidamente.

arr3.base
# Output
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

Como puede ver, el atributo base de arr3 devuelve la matriz original. Esto significa que hemos recibido una vista de la matriz original.

#3. Ahora, intentemos remodelar el vector en otra matriz válida de 2 x 6.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr4 = arr1.reshape(2,6)
print("nReshaped array:")
print(arr4)

Y aquí está la salida:

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]]

En la siguiente sección, transformemos arr1 en una matriz 3D.

Use NumPy remodelar () para remodelar una matriz 1D a matrices 3D

Para remodelar arr1 a una matriz 3D, establezcamos las dimensiones deseadas en (1, 4, 3).

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr3D = arr1.reshape(1,4,3)
print("nReshaped array:")
print(arr3D)

Ahora hemos creado una matriz 3D con los mismos 12 elementos que la matriz original arr1.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Reshaped array:
[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]
  [10 11 12]]]

Cómo depurar errores de valor durante la remodelación

Si recuerda la sintaxis, la remodelación es válida solo cuando el producto de las dimensiones es igual al número de elementos en la matriz.

import numpy as np

arr1 = np.arange(1,13)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr2D = arr1.reshape(4,4)
print("nReshaped array:")
print(arr2D)

Aquí, está tratando de remodelar una matriz de 12 elementos en una matriz de 4 × 4 con 16 elementos. El intérprete arroja un error de valor, como se ve a continuación.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12]
-----------------------------------------------------------
ValueError                                
Traceback (most recent call last)
<ipython-input-11-63552bcc8c37> in <module>()
      6 
      7 # Reshape array
----> 8 arr2 = arr1.reshape(4,4)
      9 print("nReshaped array:")
     10 print(arr2)

ValueError: cannot reshape array of size 12 into shape (4,4)

Para evitar tales errores, puede usar -1 para inferir automáticamente la forma de una de las dimensiones, en función del número total de elementos.

Por ejemplo, si conoce n – 1 dimensiones de antemano, puede usar -1 para inferir la n-ésima dimensión en la matriz reformada.

Si tiene una matriz de 24 elementos y le gustaría remodelarla en una matriz 3D. Suponga que necesita 3 filas y 4 columnas. Puede pasar el valor de -1 a lo largo de la tercera dimensión.

import numpy as np

arr1 = np.arange(1,25)
print("Original array, before reshaping:n")
print(arr1)

# Reshape array
arr_res = arr1.reshape(4,3,-1)
print("nReshaped array:")
print(arr_res)
print(f"Shape of arr_res:{arr_res.shape}")

Cuando examina la forma de la matriz de formas, puede ver que la matriz remodelada tiene una forma de 2 a lo largo de la tercera dimensión.

Original array, before reshaping:

[ 1  2  3  4  5  6  7  8  9 10 11 12 
13 14 15 16 17 18 19 20 21 22 23 24]

Reshaped array:
[[[ 1  2]
  [ 3  4]
  [ 5  6]]

 [[ 7  8]
  [ 9 10]
  [11 12]]

 [[13 14]
  [15 16]
  [17 18]]

 [[19 20]
  [21 22]
  [23 24]]]
Shape of arr_res:(4, 3, 2)

Esto es particularmente útil para aplanar una matriz. Y aprenderá sobre eso en la siguiente sección.

Use NumPy remodelar () para aplanar una matriz

Hay momentos en los que necesitaría volver de matrices N-dimensionales a una matriz aplanada. Suponga que desea aplanar una imagen en un vector largo de píxeles.

Vamos a codificar un ejemplo simple usando los siguientes pasos:

  • Genere una matriz de imágenes en escala de grises de 3 x 3, img_arr, con píxeles en el rango de 0 a 255.
  • A continuación, aplane este img_arr e imprima la matriz aplanada, flat_arr.
  • Además, imprima las formas de img_arr y flat_arr para verificar.
img_arr = np.random.randint(0, 255, (3,3))
print(img_arr)
print(f"Shape of img_arr: {img_arr.shape}")
flat_arr = img_arr.reshape(-1)
print(flat_arr)
print(f"Shape of flat_arr: {flat_arr.shape}")

Aquí está la salida.

[[195 145  77]
 [ 63 193 223]
 [215  43  36]]
Shape of img_arr: (3, 3)

[195 145  77  63 193 223 215  43  36]
Shape of flat_arr: (9,)

En la celda de código anterior, puede ver que flat_arr es un vector 1D de valores de píxeles con 9 elementos.

Resumiendo👩‍🏫

Es hora de repasar rápidamente lo que hemos aprendido.

  • Use np.reshape(arr, newshape) para remodelar arr en la forma especificada en newshape. newshape es una tupla que especifica las dimensiones de la matriz remodelada.
  • Alternativamente, use arr.reshape(d0, d1, …, dn) para remodelar arr para que tenga la forma d0 x d1 x … x dn
  • Compruebe si d0 * d1 * …* dn = N, el número de elementos en la matriz original, para evitar errores de valor durante la remodelación.
  • Use -1 como máximo para una dimensión en la nueva forma si desea que la dimensión se infiera automáticamente.
  • Finalmente, puede usar arr.reshape(-1) para aplanar la matriz.

Ahora que sabe cómo usar NumPy remodelar(), aprenda cómo funciona la función NumPy linspace().

Si lo desea, puede probar los ejemplos de código en Jupyter Notebook. Si está buscando otros entornos de desarrollo, consulte nuestra guía sobre las alternativas de Jupyter.

x