Dans ce tutoriel, vous apprendrez à utiliser Remodelage numérique () pour remodeler les tableaux NumPy sans modifier les données d'origine.

Lorsque vous travaillez avec des tableaux Numpy, vous souhaiterez souvent remodeler un tableau existant en un tableau de dimensions différentes. Cela peut être particulièrement utile lorsque vous transformez des données en plusieurs étapes.

Et NumPy reshape() vous aide à le faire facilement. Au cours des prochaines minutes, vous apprendrez la syntaxe à utiliser reshape(), et également remodeler les tableaux à différentes dimensions.

What is Reshaping in NumPy Arrays?

Lorsque vous travaillez avec des tableaux NumPy, vous souhaiterez peut-être d'abord créer un tableau de nombres à une dimension. Et puis remodelez-le en un tableau avec la dimension souhaitée.

Ceci est particulièrement utile lorsque les dimensions du nouveau tableau ne sont pas connues initialement ou sont déduites lors de l'exécution. Ou il peut également être possible qu'une certaine étape de traitement de données nécessite que l'entrée ait une forme spécifique.

Voici où remodeler vient dans maniable.

Par exemple, considérons l'illustration suivante. Nous avons un vecteur - un tableau unidimensionnel de 6 éléments. Et nous pouvons le remodeler en tableaux de formes 2 × 3, 3 × 2, 6 × 1, etc.

numpy-reshape

▶️ Pour suivre les exemples de ce tutoriel, vous devez avoir installé Python et NumPy. Si vous n'avez pas encore NumPy, consultez notre Guide d'installation de NumPy.

Vous pouvez maintenant continuer et importer NumPy sous l'alias np, en exécutant: import numpy as np.

Continuons à apprendre la syntaxe dans la section suivante.

Syntax of NumPy reshape()

Voici la syntaxe pour utiliser NumPy reshape() :

np.reshape(arr, newshape, order = 'C'|'F'|'A')
  • arr est n'importe quel objet de tableau NumPy valide. Ici, c'est le tableau à remodeler.
  • nouvelle forme est la forme du nouveau tableau. Il peut s'agir d'un entier ou d'un tuple.
  • Quand nouvelle forme est un entier, le tableau renvoyé est unidimensionnel.
  • le numéro de commande fait référence à l'ordre dans lequel vous souhaitez lire les éléments du tableau à remodeler.
  • La valeur par défaut est 'C', ce qui signifie que les éléments du tableau d'origine seront lus dans un ordre d'indexation de type C (en commençant par 0)
  • 'F' signifie indexation de type Fortran (commençant par 1). Et 'UNE' lit les éléments dans un ordre de type C ou Fortran en fonction de la disposition de la mémoire du tableau arr.

Alors qu'est-ce que np.reshape() revenir?

Il renvoie un vue remodelée du tableau d'origine si possible. Sinon, il renvoie un copie du tableau.

Dans la ligne ci-dessus, nous avons mentionné que NumPy reshape() essaierait de retourner un vue dès que possible. Sinon, il renvoie un copie. Commençons par discuter des différences entre une vue et une copie.

Afficher ou copier des tableaux NumPy

Comme son nom l'indique, copie est une copie du tableau d'origine. Et toute modification apportée à la copie sera pas touché le tableau d'origine.

D'autre part, vue fait simplement référence à la vue remodelée du tableau d'origine. Cela signifie que toute modification apportée à la vue affectera également le tableau d'origine et vice versa.

Use NumPy reshape() to Reshape 1D Array to 2D Arrays

# 1. Commençons par créer l'exemple de tableau en utilisant np.arrange().

Nous avons besoin d'un tableau de 12 nombres, de 1 à 12, appelé arr1. Comme la fonction NumPy arange() exclut le point de terminaison par défaut, définissez la valeur d'arrêt sur 13.

Utilisons maintenant la syntaxe ci-dessus et remodelons arr1 avec 12 éléments dans un tableau 2D de forme (4,3). Appelons ça arr2 avec 4 lignes et 3 colonnes.

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)

Jetons un coup d'œil aux tableaux d'origine et remodelés.

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

Au lieu de passer le tableau en argument np.reshape(), vous pouvez également appeler le .reshape() méthode sur le tableau d'origine.

Tu peux courir dir(arr1), et il listera toutes les méthodes et attributs possibles que vous pouvez utiliser sur l'objet tableau arr1.

dir(arr1)

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

Dans la cellule de code ci-dessus, vous pouvez voir que .reshape() est une méthode valide à utiliser sur le tableau NumPy existant arr1.

▶️ Ainsi, vous pouvez également utiliser la syntaxe simplifiée suivante pour remodeler les tableaux 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

Pour la suite de ce tutoriel, utilisons cette syntaxe dans nos exemples.

# 2. Essayons de remodeler notre vecteur à 12 éléments en un tableau 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)

Dans la sortie ci-dessous, vous pouvez voir que le tableau a été remodelé selon les besoins.

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

❔ Alors, comment vérifier si on a obtenu une copie ou une vue ?

Pour vérifier cela, vous pouvez appeler le base attribut sur le tableau retourné.

  • Si le tableau est une copie, le base l'attribut sera None.
  • Si le tableau est une vue, le base L'attribut sera le tableau d'origine.

Vérifions cela rapidement.

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

Comme vous pouvez le voir, base attribut de arr3 renvoie le tableau d'origine. Cela signifie que nous avons reçu un vue du tableau d'origine.

# 3. Maintenant, essayons de remodeler le vecteur dans un autre tableau 2 x 6 valide.

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)

Et voici la sortie:

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

Dans la section suivante, remodelons arr1 dans un tableau 3D.

Use NumPy reshape() to Reshape 1D Array to 3D Arrays

Remodeler arr1 à un tableau 3D, fixons les dimensions souhaitées à (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)

Nous avons maintenant créé un tableau 3D avec les mêmes 12 éléments que le tableau d'origine 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]]]

How to Debug Value Errors During Reshaping

Si vous vous souvenez de la syntaxe, le remodelage n'est valide que lorsque le produit des dimensions est égal au nombre d'éléments du tableau.

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)

Ici, vous essayez de remodeler un tableau de 12 éléments en un tableau 4 × 4 avec 16 éléments. L'interpréteur renvoie une erreur de valeur, comme indiqué ci-dessous.

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)

Pour éviter de telles erreurs, vous pouvez utiliser -1 pour déduire automatiquement la forme de l'une des cotes, en fonction du nombre total d'éléments.

Par exemple, si vous connaissez n - 1 dimensions à l'avance, vous pouvez utiliser -1 pour déduire la n-ième dimension dans le tableau remodelé.

Si vous avez un tableau de 24 éléments et que vous souhaitez le remodeler en un tableau 3D. Supposons que vous ayez besoin de 3 lignes et 4 colonnes. Vous pouvez transmettre la valeur de -1 le long de la troisième dimension.

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

Lorsque vous examinez la forme du tableau de formes, vous pouvez voir que le tableau remodelé a une forme de 2 le long de la troisième dimension.

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)

Ceci est particulièrement utile pour aplatir un tableau. Et vous apprendrez cela dans la section suivante.

Use NumPy reshape() to Flatten an Array

Il y a des moments où vous auriez besoin de revenir de tableaux à N dimensions à un tableau aplati. Supposons que vous vouliez aplatir une image en un long vecteur de pixels.

Codez un exemple simple en suivant les étapes suivantes :

  • Générer un tableau d'images en niveaux de gris 3 x 3, img_arr— avec des pixels compris entre 0 et 255.
  • Ensuite, aplatissez ceci img_arr et imprimez le tableau aplati, flat_arr.
  • Imprimez également les formes de img_arr et flat_arr vérifier.
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}")

Voici la sortie.

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

Dans la cellule de code ci-dessus, vous pouvez voir que flat_arr est un vecteur 1D de valeurs de pixels avec 9 éléments.

Résumé👩‍🏫

Il est temps de revoir rapidement ce que nous avons appris.

  • Utilisez np.reshape(arr, nouvelle forme) remodeler arr dans la forme spécifiée dans nouvelle forme. nouvelle forme est un tuple spécifiant les dimensions du tableau remodelé.
  • Sinon, utilisez arr.reshape(d0, d1, …, dn) remodeler arr être en forme d0 x d1 x … x dn
  • Vérifier si d0 * d1 * …* dn = N, le nombre d'éléments dans le tableau d'origine, pour éviter les erreurs de valeur lors du remodelage.
  • Utilisez -1 pour au plus une dimension dans la nouvelle forme si vous souhaitez que la dimension soit automatiquement déduite.
  • Enfin, vous pouvez utiliser arr.reshape(-1) pour aplatir le tableau.

Maintenant que vous savez utiliser NumPy reshape(), découvrez comment le NumPy linspace() fonctionne fonctionne.

Vous pouvez essayer les exemples de code dans Carnet Jupyter si tu veux. Si vous recherchez d'autres environnements de développement, consultez notre guide sur Alternatives à Jupyter.