NumPy reshape (): Como remodelar matrizes NumPy em Python

Neste tutorial, você aprenderá como usar NumPy remodelar () para remodelar matrizes NumPy sem alterar os dados originais.

Ao trabalhar com matrizes Numpy, muitas vezes você pode querer remodelar uma matriz existente em uma matriz de dimensões diferentes. Isso pode ser particularmente útil quando você transforma dados em várias etapas.

E NumPy reshape() ajuda você a fazer isso facilmente. Nos próximos minutos, você aprenderá a sintaxe a ser usada reshape()e também remodelar matrizes para diferentes dimensões.

O que é remodelar em matrizes NumPy?

Ao trabalhar com matrizes NumPy, você pode primeiro criar uma matriz unidimensional de números. E, em seguida, remodele-o para uma matriz com a dimensão desejada.

Isso é particularmente útil quando as dimensões da nova matriz não são conhecidas inicialmente ou são inferidas durante a execução. Ou também pode ser possível que uma determinada etapa de processamento de dados exija que a entrada tenha uma forma específica.

aqui é onde remodelando vem a calhar.

Por exemplo, considere a seguinte ilustração. Temos um vetor – uma matriz unidimensional de 6 elementos. E podemos remodelá-lo em matrizes de formas 2 × 3, 3 × 2, 6 × 1 e assim por diante.

▶️ Para acompanhar os exemplos deste tutorial, você precisa ter o Python e o NumPy instalados. Se você ainda não tem o NumPy, confira nosso Guia de instalação do NumPy .

Agora você pode ir em frente e importar NumPy sob o alias npCorrendo: import numpy as np.

Vamos aprender a sintaxe na próxima seção.

Sintaxe do NumPy reshape()

Aqui está a sintaxe para usar NumPy reshape():

  np.reshape(arr, newshape, order = 'C'|'F'|'A')

• arr é qualquer objeto de matriz NumPy válido. Aqui, é o array a ser remodelado.
• nova forma é a forma da nova matriz. Pode ser um número inteiro ou uma tupla.
• Quando nova forma é um número inteiro, a matriz retornada é unidimensional.
• ordem refere-se à ordem na qual você gostaria de ler os elementos da matriz a serem remodelados.
• o valor padrão é ‘C’, o que significa que os elementos da matriz original serão lidos em uma ordem de indexação semelhante a C (começando com 0)
• ‘F’ significa indexação semelhante a Fortran (começando com 1). E ‘A’ lê os elementos em ordem semelhante a C ou semelhante a Fortran, dependendo do layout de memória da matriz arr.

Então o que faz np.reshape() retornar?

Ele retorna um visão remodelada da matriz original, se possível. Caso contrário, ele retorna um cópia de da matriz.

Na linha acima, mencionamos que NumPy reshape() tentaria devolver um visualizar quando possível. Caso contrário, ele retorna um cópia de. Vamos discutir as diferenças entre uma exibição e uma cópia.

Visualização vs. cópia de matrizes NumPy

Como o nome sugere, cópia de é uma cópia da matriz original. E quaisquer alterações feitas na cópia serão não afeta a matriz original.

Por outro lado, visualizar refere-se simplesmente à visão remodelada da matriz original. Isso significa que qualquer alteração feita na exibição também afetará o array original e vice-versa.

Use NumPy reshape () para remodelar matriz 1D para matrizes 2D

#1. Vamos começar criando a matriz de amostra usando np.arange() .

Precisamos de um array de 12 números, de 1 a 12, chamado arr1. Como a função NumPy arange() exclui o endpoint por padrão, defina o valor de parada como 13.

Agora vamos usar a sintaxe acima e remodelar arr1 com 12 elementos em uma matriz 2D de forma (4,3). Vamos chamar isso arr2 com 4 linhas e 3 colunas.

  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)

Vamos dar uma olhada nos arrays originais e remodelados.

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

Em vez de passar o array como um argumento np.reshape()você também pode ligar para .reshape() método na matriz original.

Você pode correr dir(arr1)e listará todos os métodos e atributos possíveis que você pode usar no objeto array arr1.

  dir(arr1)

# Output 
(
...
...
'reshape'
...
..
)

Na célula de código acima, você pode ver que .reshape() é um método válido para usar na matriz NumPy existente arr1.

▶️ Portanto, você também pode usar a seguinte sintaxe simplificada para remodelar matrizes 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

No restante deste tutorial, vamos usar essa sintaxe em nossos exemplos.

#2. Vamos tentar remodelar nosso vetor de 12 elementos em uma 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)

Na saída abaixo, você pode ver que a matriz foi reformulada conforme necessário.

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

❔ Então, como verificamos se obtivemos uma cópia ou uma visualização?

Para verificar isso, você pode ligar para o base atributo na matriz retornada.

• Se a matriz for uma cópia, o base atributo será None.
• Se o array for uma view, o base atributo será a matriz original.

Vamos verificar isso rapidamente.

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

Como você pode ver, base atributo de arr3 retorna a matriz original. Isso significa que recebemos um visualizar da matriz original.

#3. Agora, vamos tentar remodelar o vetor em outra 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)

E aqui está a saída:

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

Na próxima seção, vamos reformular arr1 em uma matriz 3D.

Use NumPy reshape () para remodelar matriz 1D para matrizes 3D

para remodelar arr1 para uma matriz 3D, vamos definir as dimensões desejadas para (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)

Agora criamos um array 3D com os mesmos 12 elementos do array 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)))

Como depurar erros de valor durante a reformulação

Se você se lembra da sintaxe, a remodelação só é válida quando o produto das dimensões é igual ao número de elementos no array.

  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)

Aqui, você está tentando remodelar uma matriz de 12 elementos em uma matriz 4 × 4 com 16 elementos. O interpretador lança um Value Error, como visto abaixo.

  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 tais erros, você pode usar -1 para inferir automaticamente a forma de uma das dimensões – com base no número total de elementos.

Por exemplo, se você conhece n – 1 dimensões de antemão, pode usar -1 para inferir a n-ésima dimensão na matriz remodelada.

Se você tiver uma matriz de 24 elementos e quiser remodelá-la em uma matriz 3D. Suponha que você precise de 3 linhas e 4 colunas. Você pode passar o valor de -1 ao longo da terceira dimensão.

  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}")

Ao examinar a forma da matriz de formas, você pode ver que a matriz remodelada tem uma forma de 2 ao longo da terceira dimensão.

  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)

Isso é particularmente útil para nivelar uma matriz. E você aprenderá sobre isso na próxima seção.

Use NumPy reshape () para achatar uma matriz

Há momentos em que você precisa voltar de matrizes N-dimensionais para uma matriz achatada. Suponha que você queira achatar uma imagem em um longo vetor de Pixels.

Vamos codificar um exemplo simples usando as seguintes etapas:

• Gere uma matriz de imagem em escala de cinza 3 x 3, img_arr— com Pixels no intervalo de 0 a 255.
• Em seguida, achate isso img_arr e imprimir a matriz achatada, flat_arr.
• Além disso, imprima as formas de img_arr e flat_arr 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}")

Aqui está a saída.

  ((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,)

Na célula de código acima, você pode ver que flat_arr é um vetor 1D de valores de Pixel com 9 elementos.

Resumindo ‍

É hora de revisar rapidamente o que aprendemos.

• Usar np.reshape(arr, newshape) remodelar arr na forma especificada em nova forma. nova forma é uma tupla que especifica as dimensões da matriz remodelada.
• Como alternativa, use arr.reshape(d0, d1, …, dn) remodelar arr estar em forma d0 x d1 x … x dn
• Verifique se d0 * d1 * …* dn = N o número de elementos na matriz original, para evitar erros de valor durante a remodelação.
• Usar -1 para no máximo uma dimensão na nova forma se desejar que a dimensão seja inferida automaticamente.
• Finalmente, você pode usar arr.reshape(-1) para achatar a matriz.

Agora que você sabe como usar NumPy reshape(), aprenda como o NumPy linspace() função funciona.

Você pode experimentar os exemplos de código em Notebook Jupyter se você quiser. Se você está procurando outros ambientes de desenvolvimento, confira nosso guia sobre Alternativas do Jupyter .