Dans ce tutoriel, vous apprendrez à utiliser NumPy reshape() pour remodeler les tableaux NumPy sans modifier les données d’origine.

Lorsque vous travaillez avec des tableaux Numpy, vous pouvez souvent vouloir 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.

NumPy reshape() vous permet de le faire facilement. Au cours des prochaines minutes, vous apprendrez la syntaxe d’utilisation de reshape(), ainsi que le remodelage des tableaux en différentes dimensions.

Qu’est-ce que le remodelage dans les tableaux NumPy ?

Lorsque vous travaillez avec des tableaux NumPy, vous pouvez d’abord créer un tableau de nombres à une dimension. Vous pouvez ensuite le remodeler pour obtenir un tableau de la dimension souhaitée.

Ceci est particulièrement utile lorsque les dimensions du nouveau tableau ne sont pas connues au départ ou sont déduites au cours de l’exécution. Il se peut également qu’une certaine étape du traitement des données exige que l’entrée ait une forme spécifique.

C’est là que le remodelage s’avère utile.

Par exemple, considérez l’illustration suivante. Nous disposons d’un vecteur, un tableau unidimensionnel de 6 éléments. 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 importer NumPy sous l’alias np, en exécutant : import numpy as np.

Nous allons maintenant apprendre la syntaxe de NumPy dans la section suivante.

Syntaxe de NumPy reshape()

Voici la syntaxe pour utiliser NumPy reshape() : 

np.reshape(arr, newshape, order = 'C'|'F'|'A')
  • arr est n’importe quel objet tableau NumPy valide. Ici, c’est le tableau à remodeler.
  • newshape est la forme du nouveau tableau. Il peut s’agir d’un entier ou d’un tuple.
  • Lorsque newshape est un entier, le tableau retourné est unidimensionnel.
  • order 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 original seront lus dans un ordre d’indexation de type C (commençant par 0)
  • f’ correspond à un indexage de type Fortran (commençant par 1). Et ‘A’ lit les éléments dans un ordre C ou Fortran, en fonction de la disposition de la mémoire du tableau arr.

Que retourne donc np.reshape()?

Il renvoie une vue remodelée du tableau original si possible. Sinon, il renvoie une copie du tableau.

Dans la ligne ci-dessus, nous avons mentionné que NumPy reshape() essaierait de renvoyer une vue si possible. Dans le cas contraire, elle renvoie une copie. Voyons maintenant les différences entre une vue et une copie.

Vue ou copie de tableaux NumPy

Comme son nom l’indique, la copie est une copie du tableau original. Et toute modification apportée à la copie n’affectera pas le tableau d’origine.

D’autre part, la vue se réfère simplement à une vue remodelée du tableau d’origine. Cela signifie que toute modification apportée à la vue affectera également le tableau original et vice versa.

Utilisez NumPy reshape() pour remodeler un tableau 1D en tableau 2D

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

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

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

import numpy as np

arr1 = np.arange(1,13)
print("Tableau original, avant remodelage:\N")
print(arr1)

# Remodeler le tableau
arr2 = np.reshape(arr1,(4,3))
print("Tableau remodelé :")
print(arr2)

Regardons les tableaux originaux et remodelés.

Tableau original, avant remodelage :

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

Tableau remodelé :
[[ 1 2 3]
 [ 4 5 6]
 [ 7 8 9]
 [10 11 12]]

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

Vous pouvez lancer dir(arr1), qui vous donnera la liste de toutes les méthodes et attributs possibles que vous pouvez utiliser sur l’objet tableau arr1. 

dir(arr1)

# Output 
[
...
...
'reshape' (remodelage)
...
..
]

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

▶️ Vous pouvez donc également utiliser la syntaxe simplifiée suivante pour remodeler les tableaux NumPy.

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

# où :

# d0, d1,...,dn sont les dimensions du tableau remodelé

# d0 * d1 * ...* dn = N, le nombre d'éléments dans le tableau

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

#2. Essayons de remodeler notre vecteur de 12 éléments en un tableau de 12 x 1. 

import numpy as np

arr1 = np.arange(1,13)
print("Tableau original, avant remodelage:\N")
print(arr1)

# Remodeler le tableau
arr3 = arr1.reshape(12,1)
print("Tableau remodelé :")
print(arr3)

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

Tableau original, avant remodelage :

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

Tableau remodelé :
[[ 1]
 [ 2]
 [ 3]
 [ 4]
 [ 5]
 [ 6]
 [ 7]
 [ 8]
 [ 9]
 [10]
 [11]
 [12]]

❔ Alors, comment vérifier si nous avons obtenu une copie ou une vue ?

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

  • Si le tableau est une copie, l’attribut base sera None.
  • Si le tableau est une vue, l’attribut base sera le tableau original.

Vérifions-le rapidement.

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

Comme vous pouvez le voir, l’attribut base de arr3 renvoie le tableau original. Cela signifie que nous avons reçu une vue du tableau original.

#3. Essayons maintenant de transformer le vecteur en un autre tableau 2 x 6 valide.

import numpy as np

arr1 = np.arange(1,13)
print("Tableau original, avant remodelage:\N")
print(arr1)

# Remodeler le tableau
arr4 = arr1.reshape(2,6)
print("Tableau remodelé :")
print(arr4)

Et voici le résultat :

Tableau original, avant remodelage :

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

Tableau remodelé :
[[ 1 2 3 4 5 6]
 [ 7 8 9 10 11 12]]

Dans la section suivante, nous allons remodeler arr1 en un tableau 3D.

Utilisez NumPy reshape() pour remodeler un tableau 1D en tableau 3D

Pour transformer arr1 en un tableau 3D, fixons les dimensions souhaitées à (1, 4, 3). 

import numpy as np

arr1 = np.arange(1,13)
print("Tableau original, avant remodelage:\N")
print(arr1)

# Remodelage du tableau
arr3D = arr1.reshape(1,4,3)
print("Tableau remodelé :")
print(arr3D)

Nous avons maintenant créé un tableau 3D avec les mêmes 12 éléments que le tableau original arr1.

Tableau original, avant remodelage :

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

Tableau remodelé :
[[[ 1 2 3]
  [ 4 5 6]
  [ 7 8 9]
  [10 11 12]]]

Comment déboguer les erreurs de valeur pendant la mise en forme

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("Tableau original, avant remodelage:\N")
print(arr1)

# Remodeler le tableau
arr2D = arr1.reshape(4,4)
print("Tableau remodelé :")
print(arr2D)

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

Tableau original, avant remodelage :

[ 1 2 3 4 5 6 7 8 9 10 11 12]
-----------------------------------------------------------
Erreur de valeur      
Traceback (dernier appel le plus récent)
<ipython-input-11-63552bcc8c37> dans <module>()
      6 
      7 # Reshape array
---->
 8 arr2 = arr1.reshape(4,4)
      9 print("\nTableau remodelé :")
     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 dimensions 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 disposez d’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 de 4 colonnes. Vous pouvez passer la valeur -1 pour la troisième dimension.

import numpy as np

arr1 = np.arange(1,25)
print("Tableau original, avant remodelage:\N")
print(arr1)

# Remodeler le tableau
arr_res = arr1.reshape(4,3,-1)
print("Tableau remodelé :")
print(arr_res)
print(f "Forme de 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.

Tableau original, avant remodelage :

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

Tableau remodelé :
[[[ 1 2]
  [ 3 4]
  [ 5 6]]

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

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

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

Cette fonction est particulièrement utile pour aplatir un tableau. Vous en apprendrez plus à ce sujet dans la section suivante.

Utiliser NumPy reshape() pour aplatir un tableau

Il arrive que vous ayez besoin de revenir d’un tableau à N dimensions à un tableau aplati. Supposons que vous souhaitiez aplatir une image en un long vecteur de pixels.

Codons un exemple simple en suivant les étapes suivantes :

  • Créez un tableau d’images en niveaux de gris de 3 x 3, img_arr, dont lespixels sont compris entre 0 et 255.
  • Ensuite, aplatissez ce tableau img_arr et imprimez le tableau aplati, flat_arr.
  • Imprimez également les formes de img_arr et de flat_arr pour les vérifier.
img_arr = np.random.randint(0, 255, (3,3))
print(img_arr)
print(f "Forme de img_arr : {img_arr.shape}")
flat_arr = img_arr.reshape(-1)
print(flat_arr)
print(f "Forme de flat_arr : {flat_arr.shape}")

Voici le résultat. 

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

[195 145 77 63 193 223 215 43 36]
Forme de 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.

Additionner Up👩‍🏫

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

  • Utilisez np.reshape(arr, newshape) pour redonner à arr la forme spécifiée dans newshape. newshape est un tuple spécifiant les dimensions du tableau remodelé.
  • Vous pouvez également utiliser arr.reshape(d0, d1, …, dn) pour redonner à arr la forme d0 x d1 x … x dn
  • Vérifiez que d0 * d1 * …* dn = N, le nombre d’éléments dans le tableau original, pour éviter les erreurs de valeur pendant le 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 comment utiliser NumPy reshape(), apprenez comment fonctionne la fonction NumPy linspace().

Vous pouvez essayer les exemples de code dans le carnet Jupyter si vous le souhaitez. Si vous recherchez d’autres environnements de développement, consultez notre guide sur les alternatives à Jupyter.