NumPy

NumPy est la bibliothèque fondamentale de Python pour le calcul numérique. Elle est utilisée dans toute la data science et le machine learning.Pandas, Scikit-learn ou TensorFlow reposent sur NumPy.

Qu’est-ce que NumPy ?

NumPy signifie Numerical Python. Son objet central est le ndarray (N-dimensional array). C’est un tableau à plusieurs dimensions :

• 1D → vecteur
• 2D → matrice
• 3D ou plus → tenseur

👉 Exemple mathématique :

Un tableau [1, 2, 3] représente le vecteur (1, 2, 3) ∈ ℝ³.
Un tableau [[1, 2], [3, 4]] représente la matrice :

$$\left[\begin{array}{cc}1& 2\\ 3& 4\end{array}\right]$$

Dans un contexte de machine learning :

• les features sont souvent stockées sous forme de matrices
• les paramètres du modèle sont des vecteurs
• les données d’entrée et sorties sont des tableaux NumPy

Pourquoi utiliser NumPy ?

1. Performance

NumPy est une bibliothèque écrite en C et optimisée pour le calcul numérique.
Les opérations sont réalisées en interne par du code compilé, ce qui les rend beaucoup plus rapides que les boucles Python classiques.

👉 Exemple :

Additionner deux tableaux NumPy de grande taille est bien plus efficace que parcourir des listes Python avec une boucle for.
C’est cette efficacité qui a fait de NumPy le socle de toutes les bibliothèques de data science (Pandas, Scikit-learn, TensorFlow…).

2. Le Broadcasting

Le broadcasting est l’une des fonctionnalités les plus puissantes de NumPy.
Il permet d’appliquer automatiquement une opération entre deux tableaux de dimensions différentes, sans avoir à écrire de boucles explicites.

Concrètement, NumPy "étend" (ou diffuse) le plus petit tableau pour qu’il ait la même forme que le plus grand, et applique ensuite l’opération élément par élément.

👉 Exemple : scalaire & vecteur

import numpy as np

a = np.array([1, 2, 3, 4])
b = 5

print(a + b)  # [6 7 8 9]

Ici, le scalaire 5 est diffusé automatiquement en [5, 5, 5, 5].
Résultat : chaque élément du vecteur a est additionné à 5.

👉 Exemple : matrice et vecteur

A = np.array([[1, 2, 3],
              [4, 5, 6]])
B = np.array([10, 20, 30])

print(A + B)

Résultat attendu :

$$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]+\left[\begin{array}{ccc}10& 20& 30\end{array}\right]=\left[\begin{array}{ccc}11& 22& 33\\ 14& 25& 36\end{array}\right]$$

Ici, le vecteur B est diffusé sur chaque ligne de A.

Pourquoi c’est utile ?

• Évite d’écrire des boucles manuelles.
• Code plus clair et plus lisible.
• Calculs optimisés en C, donc très rapides.

➡️ Le broadcasting est l’une des raisons majeures pour lesquelles NumPy remplace les listes Python en Data Science

3. Fonctions intégrées

NumPy ne se limite pas aux tableaux. Il propose un grand nombre de fonctions mathématiques prêtes à l’emploi :

• Algèbre linéaire : produit matriciel, inverse, déterminant, valeurs propres
• Statistiques : moyenne, écart-type, variance, quantiles
• Fonctions mathématiques : exponentielle, logarithme, trigonométrie
• Génération aléatoire : échantillonnage pseudo-aléatoire & distributions uniforme, normale, binomiale

Ces fonctionnalités couvrent la majorité des besoins en calcul scientifique et évitent de réécrire des algorithmes de base.

NumPy & Machine Learning

Dans un algorithme de machine learning :

• les données sont stockées dans des tableaux NumPy
• les calculs de perte sont des opérations vectorisées
• la descente de gradient repose sur l’algèbre linéaire
• les performances dépendent directement de NumPy

Comprendre NumPy, c’est comprendre ce qui se passe réellement lorsqu’un modèle est entraîné.

Les bases de NumPy

Le fichier suivant contient les principales opérations NumPy utilisées en Data Science :

• création de tableaux
• opérations vectorisées
• statistiques de base
• manipulation de matrices
• génération de données

principales opérations NumPy

"""
========================
NumPy Basics
========================
"""

import numpy as np

# -----------------------------
# 1️⃣ Créer des tableaux simples
# -----------------------------

# Tableau de 10 zéros
zeros = np.zeros(10)
print("1️⃣ Tableau de zéros :")
print(zeros)
print()

# Tableau de 10 uns
ones = np.ones(10)
print("2️⃣ Tableau de uns :")
print(ones)
print()

# Tableau rempli de 5
fives = np.ones(10) * 5
print("3️⃣ Tableau rempli de 5 :")
print(fives)
print()

# -----------------------------
# 2️⃣ Suites de nombres
# -----------------------------

# Nombres entiers de 10 à 50
integers_10_50 = np.arange(10, 51)
print("4️⃣ Nombres de 10 à 50 :")
print(integers_10_50)
print()

# Entiers pairs de 10 à 50
even_10_50 = np.arange(10, 51, 2)
print("5️⃣ Entiers pairs de 10 à 50 :")
print(even_10_50)
print()

# Suite de nombres de 0 à 9
sequence = np.arange(0, 10)
print("6️⃣ Suite de 0 à 9 :")
print(sequence)
print()

# Valeurs linéairement espacées entre 0 et 1
linspace = np.linspace(0, 1, 5)
print("7️⃣ Valeurs espacées entre 0 et 1 :")
print(linspace)
print()

# -----------------------------
# 3️⃣ Matrices et identité
# -----------------------------

# Matrice 3x3 avec valeurs 0 à 8
matrix_3x3 = np.arange(9).reshape(3, 3)
print("8️⃣ Matrice 3x3 de 0 à 8 :")
print(matrix_3x3)
print()

# Matrice identité 3x3
identity_3x3 = np.eye(3)
print("9️⃣ Matrice identité 3x3 :")
print(identity_3x3)
print()

# -----------------------------
# 4️⃣ Nombres aléatoires
# -----------------------------

# Nombre aléatoire entre 0 et 1
rand_number = np.random.rand(1)
print("🔟 Nombre aléatoire entre 0 et 1 :")
print(rand_number)
print()

# Tableau de 25 nombres aléatoires (distribution normale)
rand_normal = np.random.randn(25)
print("1️⃣1️⃣ Tableau de 25 nombres aléatoires (normale) :")
print(rand_normal)
print()

# -----------------------------
# 5️⃣ Matrices avancées
# -----------------------------

# Matrice 10x10 avec valeurs 0.01 à 1.00
matrix_10x10 = np.arange(1, 101).reshape(10, 10) / 100
print("1️⃣2️⃣ Matrice 10x10 de 0.01 à 1 :")
print(matrix_10x10)
print()

# 20 points linéaires entre 0 et 1
linspace_20 = np.linspace(0, 1, 20)
print("1️⃣3️⃣ 20 points linéaires entre 0 et 1 :")
print(linspace_20)
print()

# -----------------------------
# 6️⃣ Indexation et sélection
# -----------------------------

mat = np.arange(1, 26).reshape(5, 5)
print("1️⃣4️⃣ Matrice 5x5 de 1 à 25 :")
print(mat)
print()

print("1️⃣5️⃣ Sélection des lignes 3 à 5 et colonnes 2 à 5 :")
print(mat[2:, 1:])
print()

print("1️⃣6️⃣ Valeur de la ligne 4, colonne 5 :")
print(mat[3, 4])
print()

print("1️⃣7️⃣ Colonnes 2 de la ligne 1 à 3 :")
print(mat[:3, 1:2])
print()

print("1️⃣8️⃣ Ligne 5 complète :")
print(mat[4, :])
print()

print("1️⃣9️⃣ Lignes 4 à 5 complètes :")
print(mat[3:5, :])
print()

# -----------------------------
# 7️⃣ Opérations NumPy
# -----------------------------

# Somme de toutes les valeurs
total_sum = mat.sum()
print("2️⃣0️⃣ Somme totale de mat :", total_sum)

# Écart type
std_mat = mat.std()
print("2️⃣1️⃣ Écart type :", std_mat)

# Somme par colonne
col_sum = mat.sum(axis=0)
print("2️⃣2️⃣ Somme par colonne :", col_sum)
print()

# -----------------------------
# 8️⃣ Seed pour nombres aléatoires reproductibles
# -----------------------------
np.random.seed(101)
reproducible_random = np.random.rand(5)
print("2️⃣3️⃣ Exemples de nombres aléatoires reproductibles :")
print(reproducible_random)