Machine Learning avec Python

Le Machine Learning (apprentissage automatique) est l’un des domaines les plus passionnants de l’informatique moderne. Python s’est imposé comme le langage de prédilection pour développer des modèles d’IA grâce à son écosystème riche et ses bibliothèques spécialisées.

Qu’est-ce que le Machine Learning ?

Le Machine Learning est une branche de l’intelligence artificielle qui permet aux ordinateurs d’apprendre à partir de données sans être explicitement programmés. Les algorithmes de ML identifient des modèles dans les données et prennent des décisions avec un minimum d’intervention humaine.

Les bibliothèques essentielles

Python offre un écosystème complet pour le Machine Learning :

• NumPy : Calcul numérique et manipulation de tableaux multidimensionnels
• Pandas : Manipulation et analyse de données
• Scikit-learn : Bibliothèque complète pour le ML classique
• TensorFlow : Framework de deep learning développé par Google
• PyTorch : Framework de deep learning flexible et intuitif
• Keras : API de haut niveau pour les réseaux de neurones
• XGBoost : Implémentation optimisée du gradient boosting

Installation de l’environnement

Commencez par configurer votre environnement :

# Créer un environnement virtuel
python -m venv ml-env
source ml-env/bin/activate  # Sur Windows: ml-env\Scripts\activate

# Installer les bibliothèques essentielles
pip install numpy pandas matplotlib scikit-learn tensorflow keras

Types d’apprentissage automatique

Apprentissage supervisé

L’algorithme apprend à partir de données étiquetées :

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Charger et préparer les données
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Créer et entraîner le modèle
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Évaluer le modèle
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print(f"Précision du modèle : {accuracy:.2f}")

Apprentissage non supervisé

L’algorithme identifie des structures dans des données non étiquetées :

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Créer et entraîner le modèle
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X)

# Visualiser les clusters
plt.figure(figsize=(10, 6))
plt.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis')
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], 
            s=300, c='red', marker='X')
plt.title('Clustering K-means')
plt.show()

Apprentissage par renforcement

L’algorithme apprend par essais et erreurs en interagissant avec un environnement :

import gym
import numpy as np

# Créer l'environnement
env = gym.make('CartPole-v1')

# Paramètres
learning_rate = 0.1
discount_factor = 0.99
episodes = 1000
max_steps = 500

# Table Q
q_table = np.zeros([env.observation_space.n, env.action_space.n])

# Boucle d'apprentissage
for episode in range(episodes):
    state = env.reset()
    done = False
    
    for step in range(max_steps):
        # Choisir une action
        action = np.argmax(q_table[state, :])
        
        # Exécuter l'action
        new_state, reward, done, _ = env.step(action)
        
        # Mettre à jour la table Q
        q_table[state, action] = q_table[state, action] + learning_rate * (
            reward + discount_factor * np.max(q_table[new_state, :]) - q_table[state, action])
        
        state = new_state
        
        if done:
            break

Deep Learning avec TensorFlow

Le deep learning utilise des réseaux de neurones profonds pour résoudre des problèmes complexes :

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, Flatten, MaxPooling2D

# Charger les données
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()

# Prétraitement
X_train = X_train.reshape(-1, 28, 28, 1) / 255.0
X_test = X_test.reshape(-1, 28, 28, 1) / 255.0

# Créer le modèle CNN
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Flatten(),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

# Compiler le modèle
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Entraîner le modèle
model.fit(X_train, y_train, epochs=5, validation_data=(X_test, y_test))

# Évaluer le modèle
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"Précision sur les données de test : {test_acc:.4f}")

Traitement du langage naturel (NLP)

Le NLP est un domaine du ML qui traite le langage humain :

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline

# Exemple de données
X = ["J'adore ce film", "Ce film est terrible", "Un excellent film", "Je déteste ce film"]
y = [1, 0, 1, 0]  # 1 = positif, 0 = négatif

# Créer un pipeline
text_clf = Pipeline([
    ('tfidf', TfidfVectorizer()),
    ('clf', MultinomialNB())
])

# Entraîner le modèle
text_clf.fit(X, y)

# Prédire le sentiment
nouvelles_critiques = ["C'était un film incroyable", "Je n'ai pas aimé ce film"]
predictions = text_clf.predict(nouvelles_critiques)
print(predictions)  # [1, 0]

Vision par ordinateur

La vision par ordinateur permet aux machines de “voir” et d’interpréter des images :

import cv2
import numpy as np
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions

# Charger le modèle pré-entraîné
model = MobileNetV2(weights='imagenet')

# Charger et prétraiter l'image
image = cv2.imread('chat.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = cv2.resize(image, (224, 224))
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)

# Prédire la classe
predictions = model.predict(image)
results = decode_predictions(predictions, top=3)[0]

# Afficher les résultats
for i, (imagenet_id, label, score) in enumerate(results):
    print(f"{i+1}: {label} ({score:.2f})")

Bonnes pratiques en Machine Learning

Prétraitement des données

from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer

# Définir les transformations
numeric_features = ['age', 'income', 'credit_score']
categorical_features = ['education', 'marital_status']

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ])

# Créer le pipeline complet
model = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier())
])

# Utiliser le pipeline
model.fit(X_train, y_train)

Validation croisée

from sklearn.model_selection import cross_val_score, KFold

# Définir la validation croisée
cv = KFold(n_splits=5, shuffle=True, random_state=42)

# Évaluer le modèle
scores = cross_val_score(model, X, y, cv=cv, scoring='accuracy')
print(f"Précision moyenne : {scores.mean():.2f} (±{scores.std():.2f})")

Optimisation des hyperparamètres

from sklearn.model_selection import GridSearchCV

# Définir les hyperparamètres à tester
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 5, 10]
}

# Créer le modèle de recherche
grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)

# Trouver les meilleurs hyperparamètres
grid_search.fit(X_train, y_train)
print(f"Meilleurs paramètres : {grid_search.best_params_}")
print(f"Meilleure précision : {grid_search.best_score_:.2f}")

Applications concrètes du Machine Learning

• Systèmes de recommandation : Netflix, Amazon, Spotify
• Reconnaissance d’images : Détection d’objets, reconnaissance faciale
• Traitement du langage naturel : Chatbots, traduction automatique
• Détection de fraudes : Transactions bancaires suspectes
• Diagnostic médical : Détection de maladies sur des images médicales
• Véhicules autonomes : Perception de l’environnement et prise de décision
• Prévision de séries temporelles : Prédiction des cours boursiers, météo

Conclusion

Le Machine Learning avec Python offre des possibilités infinies pour résoudre des problèmes complexes et créer des applications intelligentes. Avec les bonnes bibliothèques et techniques, vous pouvez développer des modèles puissants qui apprennent à partir des données et s’améliorent avec le temps.

Pour aller plus loin, explorez des domaines spécifiques comme le deep learning, le NLP ou la vision par ordinateur, et participez à des compétitions sur des plateformes comme Kaggle pour mettre vos compétences à l’épreuve.