Como remodelar matrizes NumPy em Python

Neste tutorial, você aprenderá como usar NumPy reshape() 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 o NumPy reshape() ajuda você a fazer isso facilmente. Nos próximos minutos, você aprenderá a sintaxe para usar reshape() e também remodelar matrizes para diferentes dimensões.

O que é Remodelagem em Arrays 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 do novo array 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 a remodelação vem a calhar.

Por exemplo, considere a ilustração a seguir. 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 possui o NumPy, confira nosso guia de instalação do NumPy.

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

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

Sintaxe de NumPy remodelar ()

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

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

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

Então, o que np.reshape() retorna?

Ele retorna uma exibição reformulada da matriz original, se possível. Caso contrário, ele retorna uma cópia da matriz.

Na linha acima, mencionamos que o NumPy reshape() tentaria retornar uma visão sempre que possível. Caso contrário, ele retorna uma cópia. Vamos continuar a discutir as diferenças entre uma visualização e uma cópia.

Ver vs. cópia de matrizes NumPy

Como o nome sugere, copy é uma cópia do array original. E quaisquer alterações feitas na cópia não afetarão a matriz original.

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

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

#1. Vamos começar criando o array de amostra usando np.arrange().

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 para 13.

Agora vamos usar a sintaxe acima e remodelar arr1 com 12 elementos em uma matriz 2D de forma (4,3). Vamos chamar isso de 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 nas matrizes originais e reformuladas.

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 chamar o método .reshape() no array original.

Você pode executar dir(arr1), e ele 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 no array NumPy arr1 existente.

▶️ 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

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

#2. Vamos tentar remodelar nosso vetor de 12 elementos em um array 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 chamar o atributo base no array retornado.

• Se a matriz for uma cópia, o atributo base será Nenhum.
• Se a matriz for uma exibição, o atributo base 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, o atributo base de arr3 retorna o array original. Isso significa que recebemos uma visão do array original.

#3. Agora, vamos tentar remodelar o vetor em outra matriz 2 x 6 válida.

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 remodelar arr1 em uma matriz 3D.

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

Para remodelar arr1 para um array 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 reformulação é válida apenas quando o produto das dimensões é igual ao número de elementos do 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 um array de 12 elementos em um array 4×4 com 16 elementos. O interpretador lança um erro de valor, 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 esses 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, você pode usar -1 para inferir a n-ésima dimensão na matriz remodelada.

Se você tem uma matriz de 24 elementos e gostaria de 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 no achatamento de 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 arrays N-dimensionais para um array achatado. 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 imagens em tons de cinza 3 x 3, img_arr—com pixels no intervalo de 0 a 255.
• Em seguida, nivele este img_arr e imprima o array nivelado, flat_arr.
• Além disso, imprima as formas de img_arr e 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}")

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.

• Use np.reshape(arr, newshape) para remodelar arr na forma especificada em newshape. newshape é uma tupla que especifica as dimensões da matriz remodelada.
• Alternativamente, use arr.reshape(d0, d1, …, dn) para remodelar arr para ter a 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 reformulação.
• Use -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 o array.

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

Você pode experimentar os exemplos de código no notebook Jupyter, se desejar. Se você estiver procurando por outros ambientes de desenvolvimento, confira nosso guia sobre alternativas ao Jupyter.