Fonction reshape de NumPy

Introduction

La fonction reshape() de la bibliothèque NumPy vous permet de modifier la forme d'un tableau sans altérer ses données. Cette fonction puissante vous aide à réorganiser les éléments d'un tableau en différentes dimensions en fonction de vos besoins spécifiques. Que vous ayez besoin de convertir un tableau unidimensionnel en une matrice ou de créer un tableau multidimensionnel pour le traitement des données, la fonction reshape() offre une solution flexible.

Dans ce lab (atelier), nous explorerons les applications pratiques de la fonction reshape(), comprendrons sa syntaxe et apprendrons à l'utiliser efficacement avec différents paramètres.

Prise en main de NumPy et création de tableaux

Avant de pouvoir redimensionner des tableaux, nous devons comprendre ce que sont les tableaux NumPy et comment les créer. NumPy (Numerical Python) est une bibliothèque puissante qui prend en charge les grands tableaux et matrices multidimensionnelles, ainsi qu'une collection de fonctions mathématiques pour opérer sur ces tableaux.

Commençons par créer un nouveau fichier Python dans le WebIDE. Cliquez sur l'icône "Explorer" dans la barre latérale de gauche, puis sur le bouton "New File". Nommez votre fichier numpy_reshape.py.

Maintenant, importons la bibliothèque NumPy et créons un tableau de base :

import numpy as np

## Crée un simple tableau 1D en utilisant np.arange() qui génère une séquence de nombres
original_array = np.arange(12)
print("Original 1D array:")
print(original_array)
print("Shape of the original array:", original_array.shape)
print("Dimensions of the original array:", original_array.ndim)

Ouvrez le terminal dans le WebIDE et exécutez votre script :

python3 numpy_reshape.py

Vous devriez voir une sortie similaire à ceci :

Original 1D array:
[ 0  1  2  3  4  5  6  7  8  9 10 11]
Shape of the original array: (12,)
Dimensions of the original array: 1

Comprenons ce qui se passe ici :

• np.arange(12) crée un tableau unidimensionnel avec des valeurs de 0 à 11
• array.shape nous indique les dimensions du tableau (12 éléments dans une seule dimension)
• array.ndim nous indique le nombre de dimensions (1 dans ce cas)

Redimensionnement de base - Conversion de tableaux 1D en tableaux 2D

Maintenant que nous comprenons les bases des tableaux NumPy, explorons la fonction reshape(). Cette fonction nous permet de modifier la forme d'un tableau sans changer ses données.

Ouvrez votre fichier numpy_reshape.py et ajoutez le code suivant :

import numpy as np

## Crée un simple tableau 1D
original_array = np.arange(12)
print("Original 1D array:")
print(original_array)
print("Shape of the original array:", original_array.shape)
print("Dimensions of the original array:", original_array.ndim)
print("-" * 50)  ## Ligne de séparation

## Redimensionne le tableau en un tableau 2D avec 3 lignes et 4 colonnes
reshaped_3x4 = np.reshape(original_array, (3, 4))
print("Reshaped array (3x4):")
print(reshaped_3x4)
print("Shape of the reshaped array:", reshaped_3x4.shape)
print("Dimensions of the reshaped array:", reshaped_3x4.ndim)
print("-" * 50)  ## Ligne de séparation

## Redimensionne le tableau en un tableau 2D avec 4 lignes et 3 colonnes
reshaped_4x3 = np.reshape(original_array, (4, 3))
print("Reshaped array (4x3):")
print(reshaped_4x3)
print("Shape of the reshaped array:", reshaped_4x3.shape)
print("Dimensions of the reshaped array:", reshaped_4x3.ndim)

Exécutez votre script dans le terminal :

python3 numpy_reshape.py

Vous devriez voir une sortie montrant comment le tableau original a été redimensionné en différentes structures 2D.

Comprenons ce qui se passe :

1. Nous avons d'abord créé un tableau 1D avec 12 éléments
2. Nous l'avons redimensionné en une matrice 3×4 (3 lignes, 4 colonnes)
3. Nous l'avons ensuite redimensionné en une matrice 4×3 (4 lignes, 3 colonnes)

Dans les deux cas, le nombre total d'éléments reste le même (12), mais l'organisation change. La fonction reshape() exige que la nouvelle forme soit compatible avec la taille du tableau original. Cela signifie que le produit des dimensions de la nouvelle forme doit être égal au nombre total d'éléments dans le tableau original.

Redimensionnement avancé - Création de tableaux 3D

Passons maintenant au redimensionnement plus avancé en créant des tableaux tridimensionnels. Les tableaux 3D sont essentiellement des tableaux de tableaux 2D et sont utiles pour représenter des volumes, des séries temporelles d'images ou d'autres structures de données complexes.

Ajoutez le code suivant à votre fichier numpy_reshape.py :

import numpy as np

## Crée un simple tableau 1D
original_array = np.arange(24)
print("Original 1D array:")
print(original_array)
print("Shape of the original array:", original_array.shape)
print("-" * 50)  ## Ligne de séparation

## Redimensionne en un tableau 3D de dimensions 2x3x4
## Cela crée 2 blocs, chacun avec 3 lignes et 4 colonnes
reshaped_3d = np.reshape(original_array, (2, 3, 4))
print("Reshaped 3D array (2x3x4):")
print(reshaped_3d)
print("Shape of the 3D array:", reshaped_3d.shape)
print("Dimensions of the 3D array:", reshaped_3d.ndim)
print("-" * 50)  ## Ligne de séparation

## Accès aux éléments dans un tableau 3D
print("First block of the 3D array:")
print(reshaped_3d[0])
print("\nSecond block of the 3D array:")
print(reshaped_3d[1])
print("\nElement at position [1,2,3] (second block, third row, fourth column):")
print(reshaped_3d[1, 2, 3])

Exécutez votre script à nouveau :

python3 numpy_reshape.py

La sortie montrera comment un tableau 1D de 24 éléments peut être transformé en une structure 3D. Cette structure peut être visualisée comme 2 blocs, chacun contenant une matrice 3×4.

Comprendre les tableaux 3D :

• La première dimension (2) représente le nombre de "blocs" ou de "couches"
• La deuxième dimension (3) représente le nombre de lignes dans chaque bloc
• La troisième dimension (4) représente le nombre de colonnes dans chaque ligne

Cette structure est particulièrement utile pour le traitement d'images (où chaque "bloc" pourrait être un canal de couleur), les données de séries temporelles (où chaque "bloc" pourrait être un point dans le temps) ou d'autres scénarios nécessitant plusieurs matrices.

Comprendre les paramètres d'ordre dans le redimensionnement

Lors du redimensionnement de tableaux, NumPy propose un paramètre supplémentaire appelé order qui contrôle la manière dont les éléments sont lus dans le tableau original et placés dans le tableau redimensionné. Il existe deux principales conventions d'ordre :

1. Ordre de type C (par ligne - row-major) : C'est le paramètre par défaut dans NumPy, où l'index de l'axe final change le plus rapidement.
2. Ordre de type Fortran (par colonne - column-major) : Là, l'index du premier axe change le plus rapidement.

Explorons ces deux méthodes d'ordre en ajoutant ce code à votre fichier numpy_reshape.py :

import numpy as np

## Crée un tableau 1D
original_array = np.arange(12)
print("Original 1D array:")
print(original_array)
print("-" * 50)  ## Ligne de séparation

## Redimensionne en utilisant l'ordre de type C (par défaut)
c_style = np.reshape(original_array, (3, 4), order='C')
print("Reshaped array with C-style ordering (row-major):")
print(c_style)
print("-" * 50)  ## Ligne de séparation

## Redimensionne en utilisant l'ordre de type Fortran
f_style = np.reshape(original_array, (3, 4), order='F')
print("Reshaped array with Fortran-style ordering (column-major):")
print(f_style)
print("-" * 50)  ## Ligne de séparation

## Syntaxe alternative en utilisant la méthode reshape du tableau
array_method = original_array.reshape(3, 4)
print("Using the array's reshape method:")
print(array_method)
print("-" * 50)  ## Ligne de séparation

## Utilisation de -1 comme dimension (calcul automatique)
auto_dim = original_array.reshape(3, -1)  ## NumPy déterminera que -1 devrait être 4
print("Using automatic dimension calculation with -1:")
print(auto_dim)
print("Shape:", auto_dim.shape)

Exécutez votre script pour voir les différences :

python3 numpy_reshape.py

Points clés à comprendre :

1. Ordre de type C (par ligne - row-major) : Les éléments sont placés ligne par ligne. C'est le paramètre par défaut dans NumPy.
2. Ordre de type Fortran (par colonne - column-major) : Les éléments sont placés colonne par colonne.
3. Syntaxe de la méthode du tableau : Au lieu d'utiliser np.reshape(array, shape), vous pouvez utiliser array.reshape(shape).
4. Calcul automatique de dimension : Utiliser -1 pour l'une des dimensions indique à NumPy de calculer automatiquement cette dimension en fonction de la taille du tableau.

Le paramètre d'ordre est particulièrement important lorsque :

• Vous travaillez avec de très grands tableaux et que la disposition en mémoire a un impact sur les performances.
• Vous interfaciez avec d'autres bibliothèques ou langages qui utilisent un ordre par défaut différent.
• Vous devez garantir la compatibilité avec des algorithmes spécifiques.

Résumé

Dans ce laboratoire (lab), nous avons exploré la fonction polyvalente reshape() de NumPy, qui nous permet de réorganiser les données d'un tableau en différentes dimensions sans modifier les données sous-jacentes. Voici ce que nous avons appris :

1. Redimensionnement de base : Comment transformer des tableaux unidimensionnels en matrices bidimensionnelles avec différentes configurations de lignes et de colonnes.

2. Redimensionnement avancé : Création de tableaux tridimensionnels pour des structures de données plus complexes, utiles pour représenter des volumes, des séries temporelles d'images ou d'autres données multi-dimensionnelles.

3. Paramètres d'ordre : Comprendre la différence entre l'ordre de type C (par ligne - row-major) et l'ordre de type Fortran (par colonne - column-major), et comment ils influencent l'arrangement des éléments dans le tableau redimensionné.

4. Syntaxe alternative : Utilisation à la fois de la fonction np.reshape() et de la méthode .reshape() du tableau pour obtenir les mêmes résultats.

5. Calcul automatique de dimension : Utilisation de -1 comme espace réservé pour permettre à NumPy de calculer automatiquement la dimension appropriée.

La fonction reshape() est un outil fondamental dans la manipulation de données avec NumPy, permettant une réorganisation efficace des données pour diverses applications en science des données, apprentissage automatique (machine learning) et calcul scientifique. Comprendre comment redimensionner correctement les données est essentiel pour préparer les entrées des modèles, visualiser les données multi-dimensionnelles et effectuer des opérations mathématiques complexes sur les tableaux.