Manipuler des vecteurs et des matrices

En bref

Résumé de l’article

Les vecteurs et les matrices sont des structures de données fondamentales en informatique, particulièrement utiles pour représenter des données multidimensionnelles. Ici, nous nous concentrons sur leur usage pour l’apprentissage automatique.

À retenir

• Les bibliothèques comme NumPy en Python facilitent la manipulation efficace des vecteurs et des matrices.
• Au lieu d’utiliser des boucles pour les opérations sur les tableaux, on peut tirer parti des opérations vectorisées offertes par NumPy.
• Comprendre comment indexer, découper et manipuler des tableaux est crucial pour le traitement des données en apprentissage automatique.

Introduction à Numpy

Le machine learning implique la manipulation de données sous forme de tableaux. Les tableaux sont des ensembles de nombres (souvent des nombres à virgule flottante ou des entiers), et peuvent être aussi simples qu’un seul nombre (un singleton), ou un vecteur de longueur $N$, ou une matrice $N \times M$, ou plus généralement un tenseur (par exemple, un tableau $N \times M\times P$ serait appelé un tenseur avec trois modes).

En Python, la bibliothèque la plus couramment utilisée pour manipuler des tableaux est NumPy. NumPy fournit une structure de données appelée ndarray (tableau N-dimensionnel) qui permet de stocker et de manipuler efficacement des tableaux de données.

Tutoriel Numpy : génération de données synthétiques

Ce tutoriel se fait en deux étapes :

• Pour vous familiariser avec les fonctions de numpy, nous donnons ci-dessous une liste de concepts nécessaires et de fonctions qui peuvent être utilisées. Consultez la documentation numpy en utilisant votre IDE ou en ligne pour voir les paramètres détaillés et les sorties de ces fonctions.
• Nous montrons ensuite comment générer des données synthétiques et les visualiser avec Matplotlib

Concepts et fonctions de Numpy

Dans tout les exemples suivants, nous supposons que vous avez importé numpy comme suit :

import numpy as np

Création de tableaux

Il est très simple de créer des tableaux avec Numpy et de vérifier leurs tailles. Les fonctions suivantes sont particulièrement utiles :

• Création de tableaux à partir de liste avec np.array()

# Creating a 1D array from a list
array_1d = np.array([1, 2, 3, 4, 5])
print("1D Array:", array_1d)
# Creating a 2D array (list of lists)
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("2D Array:\n", array_2d)

• Création de tableaux de constantes avec np.zeros(), np.ones()

# Creating a 1D array of zeros
zeros_1d = np.zeros(5)
print("1D Array of zeros:", zeros_1d)
# Creating a 2D array of zeros
zeros_2d = np.zeros((3, 4))  # 3 rows, 4 columns
print("2D Array of zeros:\n", zeros_2d)
# Creating a 2D array of ones
ones_2d = np.ones((2, 3))  # 2 rows, 3 columns (a 2 by 3 matrix)
print("2D Array of ones:\n", ones_2d)
# Creating a 3D array of ones
ones_3d = np.ones((4, 2, 3))  # a 4 by 2 by 3 tensor
print("3D Array of ones:\n", ones_3d)

• Création de valeurs ordonnées avec np.arange(), ou une plage de valeurs avec np.linspace()

# Creating an array with values from 0 to 9
arange_array = np.arange(10)
print("Array with arange:", arange_array)
# Creating an array with 5 values evenly spaced between 0 and 1
linspace_array = np.linspace(0, 1, 5)
print("Array with linspace:", linspace_array)

array = np.array([[1, 2, 3], [4, 5, 6]])
print("Shape of the array:", array.shape)  # Output: (2, 3)

Génération de données aléatoires

Numpy fournit plusieurs fonctions pour générer des tableaux de nombres aléatoires, ce qui est souvent utile pour créer des données synthétiques. Les fonctions np.random.normal(), np.random.uniform(), np.random.randint() sont les plus couramment utilisées.

# Generating an array of 5 random numbers from a normal distribution
normal_array = np.random.normal(loc=0.0, scale=1.0, size=5)
print("Random numbers from normal distribution:", normal_array)

Consultez la documentation de ces trois fonctions pour comprendre quelle est la différence entre elles et comment les utiliser.

En particulier, np.random.normal() est très utile pour générer des données synthétiques qui suivent une distribution normale (gaussienne), ce qui est souvent le cas dans de nombreux problèmes d’apprentissage automatique. Le paramètre loc spécifie la moyenne de la distribution, scale spécifie l’écart type, et size spécifie la forme du tableau à générer. Voici un exemple de génération d’un tableau 2D de données aléatoires suivant une distribution normale :

#Generating a 2D array of shape (3, 4) with random numbers from a normal distribution
random_2d_array = np.random.normal(loc=0.0, scale=1.0, size=(3, 4))
print("2D Array of random numbers from normal distribution:\n", random_2d_array)

Opérations de base sur les tableaux

Un des intérêts principaux de l’utilisation de Numpy est la possibilité d’effectuer des opérations mathématiques efficaces avec les tableaux. Par exemple, pour additioner deux tableaux array1 et array2, au lieu d’utiliser une boucle for que l’on appliquerait sur les lignes ou les colonnes, on peut simplement écrire array1 + array2.

Les opérateurs mathématiques de base (+, -, *, /) sont surchargés pour fonctionner de manière élémentaire sur les tableaux Numpy, mais cela ne fonctionnera que si les tableaux ont la même forme (ou sont compatibles via le broadcasting).

D’autres fonctions importantes incluent :

• Addition np.sum() ou moyenne np.mean() des éléments d’un tableau. En particulier, vous pouvez spécifier l’axe (axis) le long duquel effectuer l’opération.
• Produit matriciel avec np.dot(A,B) de deux matrices A et B de tailles respectives (m, n) et (n, p), équivalent à écrire A@B.
• Transposition d’une matrice avec la méthode .T (par exemple, A.T).
• Calcul de la racine carrée avec np.sqrt(). L’axe d’application peut également être spécifié.

En apprentissage automatique, il est courant de calculer des distances ou des normes entre des vecteurs. La fonction np.linalg.norm() calcule la norme d’un vecteur ou la distance entre deux vecteurs. Par exemple, pour calculer la distance euclidienne entre deux vecteurs a et b, vous pouvez utiliser np.linalg.norm(a - b).

Accéder à des éléments spécifiques ou des parties d’un tableau

Un des aspects les plus puissants de Numpy est la capacité à indexer et découper des tableaux de manière efficace. Voici quelques techniques courantes :

• Accéder au premier élément d’un tableau : array[0].
• Accéder à un élément spécifique dans une matrice 2D : array[row, col]. (attention, l’indexation commence à 0).
• Accéder à une sous-partie d’un tableau (découpage, ou slicing) : array[start:end] pour un tableau 1D, ou array[row_start:row_end, col_start:col_end] pour un tableau 2D.
• Utilisation de conditions pour filtrer les éléments d’un tableau :
  • array[array > 0] renvoie tous les éléments positifs du tableau.
  • array[(array > 0) & (array < 10)] renvoie tous les éléments compris entre 0 et 10.

Duplication ou répétition de tableaux ou de leurs éléments

Parfois, il est utile de dupliquer ou de répéter des tableaux ou leurs éléments. Voici quelques fonctions utiles pour cela :

• np.tile(array, reps) : Répète le tableau array selon les dimensions spécifiées par reps.
• np.repeat(array, repeats, axis=None) : Répète les éléments du tableau array selon le nombre spécifié par repeats. L’argument axis permet de spécifier l’axe le long duquel effectuer la répétition.

Quelques exemples :

# Using np.tile to repeat a 1D array
array_1d = np.array([1, 2, 3])
tiled_array = np.tile(array_1d, 3)  # Repeat the array 3 times
print("Tiled Array:", tiled_array)
# Using np.repeat to repeat elements of a 1D array
repeated_array = np.repeat(array_1d, 2)  # Repeat each element 2 times
print("Repeated Array:", repeated_array)

Application : Génération et visualisation de données synthétiques

Utilisons les concepts et fonctions décrits ci-dessus pour générer un ensemble de données synthétiques. Par exemple, on peut créer un ensemble de points 2D répartis autour de plusieurs centres (clusters) en utilisant des distributions normales. Voici un exemple de code pour générer des données synthétiques, et les visualiser avec Matplotlib :

import numpy as np
import matplotlib.pyplot as plt
# Parameters
num_clusters = 3
points_per_cluster = 100
cluster_centers = np.array([[2, 2], [8, 3], [3, 6]])
# Generate synthetic data
data = []
for center in cluster_centers:
    points = np.random.normal(loc=center, scale=0.5, size=(points_per_cluster, 2))
    data.append(points)
data = np.vstack(data)
# Visualize the data
plt.scatter(data[:, 0], data[:, 1], alpha=0.6)
plt.title('Synthetic Data with Clusters')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

Ce code génère trois clusters de points 2D autour des centres spécifiés et les visualise à l’aide d’un nuage de points. Vous pouvez ajuster les paramètres tels que le nombre de clusters, le nombre de points par cluster, et l’écart type pour voir comment cela affecte la distribution des données.

La fonction scatter permet également de colorer les points avec l’argument c, par exemple en fournissant un vecteur d’entiers correspondant à des étiquettes de chacun des points.

labels = np.repeat(np.arange(num_clusters), points_per_cluster)
plt.scatter(data[:, 0], data[:, 1], c=labels, alpha=0.6, cmap='viridis')

Conclusion

Dans ce tutoriel, nous avons exploré les bases de la manipulation des vecteurs et des matrices en utilisant la bibliothèque Numpy en Python. Nous avons vu comment créer des tableaux, effectuer des opérations mathématiques, et accéder à des éléments spécifiques. Enfin, nous avons appliqué ces concepts pour générer des données synthétiques, une compétence essentielle en apprentissage automatique. N’hésitez pas à expérimenter davantage avec Numpy pour renforcer votre compréhension et vos compétences en manipulation de données!