Using Python's Built-in Modules

1. Qu'est-ce qu'un Module ?

Imaginez que vous construisiez une maison. Vous pourriez fabriquer chaque brique, chaque vis et chaque tuile vous-même, mais ce serait incroyablement long et fastidieux. Il est bien plus efficace d'utiliser des briques, des vis et des tuiles fabriquées par des spécialistes. En Python, les modules sont ces composants préfabriqués.

Un module est simplement un fichier Python (avec une extension .py) qui contient des fonctions, des classes et des variables que vous pouvez utiliser dans vos propres programmes. Python est fourni avec une vaste collection de modules appelée la Bibliothèque Standard, qui offre des outils pour une multitude de tâches.

Pour utiliser un module, nous devons l'importer. La meilleure pratique consiste à placer toutes vos instructions import au début de votre script.

2. Les Différentes Façons d'Importer

Il existe plusieurs syntaxes pour importer des modules, chacune avec ses avantages et ses inconvénients. Comprenons-les en utilisant le module math.

Pour résumer, voici les méthodes d'importation que vous rencontrerez :

• import math : C'est la méthode la plus sûre et la plus recommandée. Elle importe tout le module et vous devez utiliser le nom du module comme préfixe pour accéder à ses fonctions (ex: math.sqrt(16)). Cela évite les conflits de noms.

• from math import sqrt, pi : Importe uniquement les fonctions sqrt et la constante pi dans votre espace de noms actuel. Vous pouvez alors les appeler directement (ex: sqrt(16)). C'est pratique, mais peut prêter à confusion si vous importez des fonctions du même nom depuis différents modules.

• import numpy as np : C'est une pratique extrêmement courante, surtout dans le domaine du machine learning. On importe le module numpy et on lui donne un alias plus court, np. On l'utilisera ensuite comme np.array().

• from math import * : À éviter. Cette méthode importe toutes les fonctions et variables du module dans votre espace de noms, ce qui peut écraser vos propres variables sans avertissement et rendre le code très difficile à lire (d'où vient cette fonction ?).

Explorer le contenu d'un module

Comment savoir ce qu'un module contient ? La fonction intégrée dir() est votre amie.

import math




# Affiche une liste de tous les noms (fonctions, constantes, etc.) dans le module math
print(dir(math)) 

Cela vous donnera une liste complète, vous permettant d'explorer les capacités d'un module.

3. Le Module math

Étant donné votre formation universitaire en mathématiques, le module math vous semblera familier. Il fournit des fonctions pour les opérations mathématiques de base.

Voici quelques fonctions du module math qui sont particulièrement pertinentes pour le machine learning :

• math.sqrt(x): Calcule la racine carrée de x.
• math.exp(x): Calcule $e^x$, la fonction exponentielle. Fondamentale dans les fonctions d'activation comme le softmax ou la sigmoïde.
• math.log(x): Calcule le logarithme naturel de x. Utilisé dans de nombreuses fonctions de coût.
• math.pow(x, y): Calcule $x^y$.
• math.floor(x) et math.ceil(x): Arrondissent x à l'entier inférieur ou supérieur le plus proche.
• math.pi et math.e: Constantes pour $\pi$ et $e$.

import math




# Calcul de l'activation sigmoïde pour une valeur x
# C'est une fonction que vous retrouverez en régression logistique et dans les réseaux de neurones.
def sigmoid(x):
    return 1 / (1 + math.exp(-x))

valeur = 0.5
activation = sigmoid(valeur)

print(f"La valeur de la fonction sigmoïde pour x={valeur} est : {activation}")

4. Le Module random

Le hasard joue un rôle central en machine learning : pour initialiser les poids d'un réseau de neurones, pour mélanger les données avant l'entraînement, ou pour sélectionner des échantillons aléatoires. Le module random est votre outil pour toutes ces tâches.

Hasard et Reproductibilité : la Graine (Seed)

Un point crucial à comprendre est que les ordinateurs génèrent des nombres pseudo-aléatoires. Ils suivent un algorithme déterministe qui produit une séquence de nombres qui semble aléatoire. Cet algorithme commence avec une valeur initiale appelée graine (seed). Si vous utilisez la même graine, vous obtiendrez toujours la même séquence de nombres "aléatoires".

Pourquoi est-ce si important ? En machine learning, fixer la graine (random.seed(42) par exemple) garantit que vos expériences sont reproductibles. N'importe qui pourra relancer votre code et obtenir exactement les mêmes résultats, ce qui est fondamental pour la recherche et le débogage.

Fonctions clés du module random

Le module random offre une panoplie de fonctions.

Pour une démonstration pratique et complète, la vidéo suivante est excellente.

5. Exercices Pratiques

Mettons ces nouvelles connaissances en action.

Exercice 1 : Calcul de la Distance Euclidienne
La distance euclidienne entre deux points dans un plan est une mesure fondamentale, utilisée par exemple dans l'algorithme des K plus proches voisins (K-Nearest Neighbors).
Créez une fonction calculer_distance(point1, point2) qui :

1. Prend en entrée deux points, où chaque point est un tuple de deux nombres (par exemple, (x1, y1)).
2. Utilise le module math pour calculer la distance euclidienne : $\sqrt{(x_2-x_1{)}^2+(y_2-y_1{)}^2}$.
3. Retourne la distance calculée.

Testez votre fonction avec les points (1, 2) et (4, 6). Le résultat devrait être 5.0.

Exercice 2 : Simulation d'un Partage de Données (Train/Test Split)
En machine learning, on sépare presque toujours nos données en un ensemble d'entraînement (train set) et un ensemble de test (test set).
Écrivez un script qui :

1. Crée une liste représentant un jeu de données, par exemple donnees = list(range(1, 21)) (nombres de 1 à 20).
2. Utilise random.seed(42) pour rendre le mélange reproductible.
3. Mélange la liste donnees en utilisant random.shuffle().
4. Crée une liste train_set contenant les premiers 80% des données mélangées.
5. Crée une liste test_set contenant les 20% restants.
6. Affiche les deux ensembles.

Solutions

Solution de l'exercice 1 :

import math

def calculer_distance(point1, point2):
    """Calcule la distance euclidienne entre deux points."""
    x1, y1 = point1
    x2, y2 = point2
    



    # math.pow(base, exposant) calcule base à la puissance exposant
    distance = math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2))
    return distance




# Test de la fonction
p1 = (1, 2)
p2 = (4, 6)
dist = calculer_distance(p1, p2)
print(f"La distance entre {p1} et {p2} est : {dist}")

Solution de l'exercice 2 :

import random




# 1. Créer le jeu de données
donnees = list(range(1, 21))
print(f"Données originales : {donnees}")




# 2. Fixer la graine pour la reproductibilité
random.seed(42)




# 3. Mélanger les données en place
random.shuffle(donnees)
print(f"Données mélangées : {donnees}")




# 4. & 5. Partager les données
taille_split = int(len(donnees) * 0.8) # 80% pour l'entraînement

train_set = donnees[:taille_split]
test_set = donnees[taille_split:]




# 6. Afficher les résultats
print(f"\nEnsemble d'entraînement ({len(train_set)} éléments): {train_set}")
print(f"Ensemble de test ({len(test_set)} éléments): {test_set}")

Conclusion

Félicitations ! Vous venez de débloquer une compétence essentielle en Python. Savoir importer et utiliser des modules vous fait passer du statut de quelqu'un qui écrit des scripts simples à celui de quelqu'un qui peut construire des applications complexes en s'appuyant sur l'écosystème Python.

Points clés à retenir :

• Les modules sont des bibliothèques de code réutilisable.
• La Bibliothèque Standard de Python est incluse par défaut et est très riche.
• La meilleure pratique est d'importer les modules avec import nom_module et de placer les imports en haut du fichier.
• Le module math fournit des fonctions mathématiques essentielles.
• Le module random est crucial pour la simulation, le mélange de données et l'échantillonnage, des tâches omniprésentes en machine learning.
• Utilisez random.seed() pour garantir la reproductibilité de vos expériences.

Dans notre prochaine leçon, nous allons passer à la vitesse supérieure. Bien que les listes Python et le module math soient utiles, ils ne sont pas optimisés pour les calculs numériques à grande échelle. Nous allons donc introduire NumPy, la bibliothèque fondamentale pour le calcul scientifique en Python. Vous verrez comment les tableaux NumPy remplacent les listes pour effectuer des opérations mathématiques sur de grands ensembles de données de manière incroyablement efficace.