Introduction
Dans ce laboratoire, vous apprendrez les bases de la construction d'un modèle d'apprentissage automatique (machine learning) à l'aide de l'une des bibliothèques Python les plus populaires, scikit-learn. Nous nous concentrerons sur la Régression Linéaire (Linear Regression), un algorithme simple mais puissant utilisé pour prédire une valeur continue, telle qu'un prix ou une température.
Notre objectif est de construire un modèle capable de prédire les prix médians des logements dans les districts de Californie. Nous utiliserons le jeu de données sur le logement en Californie (California housing dataset), qui est inclus de manière pratique avec scikit-learn.
Tout au long de ce laboratoire, vous apprendrez à :
- Charger un jeu de données depuis
scikit-learn. - Préparer et diviser les données pour l'entraînement et le test.
- Créer et entraîner un modèle de Régression Linéaire.
- Utiliser le modèle entraîné pour faire des prédictions.
Vous effectuerez toutes les tâches au sein du WebIDE. Commençons !
Charger le jeu de données du logement en Californie avec datasets.fetch_california_housing()
Dans cette étape, nous allons commencer par charger le jeu de données pour notre modèle. scikit-learn est livré avec plusieurs jeux de données intégrés, qui sont parfaits pour l'apprentissage et la pratique. Nous utiliserons le jeu de données sur le logement en Californie.
Tout d'abord, nous devons créer un script Python. Un fichier nommé main.py a déjà été créé pour vous dans le répertoire ~/project. Vous pouvez le trouver dans l'explorateur de fichiers sur le côté gauche du WebIDE.
Ouvrez main.py et ajoutez le code suivant. Ce code importe les bibliothèques nécessaires (fetch_california_housing de sklearn.datasets et pandas) et charge le jeu de données. Nous utiliserons pandas pour convertir les données en un DataFrame, qui est une structure de données tabulaire facile à visualiser et à manipuler.
Veuillez ajouter le code suivant à main.py :
import pandas as pd
from sklearn.datasets import fetch_california_housing
## Load the California housing dataset
california = fetch_california_housing()
## Create a DataFrame
california_df = pd.DataFrame(california.data, columns=california.feature_names)
california_df['MedHouseVal'] = california.target
## Print the first 5 rows of the DataFrame
print("California Housing Dataset:")
print(california_df.head())
Maintenant, exécutons le script pour voir la sortie. Ouvrez un terminal dans le WebIDE (vous pouvez utiliser le menu "Terminal" -> "New Terminal") et exécutez la commande suivante :
python3 main.py
Vous devriez voir les cinq premières lignes du jeu de données s'afficher dans la console. La colonne MedHouseVal est notre variable cible, représentant la valeur médiane des logements pour les districts de Californie, exprimée en centaines de milliers de dollars (100 000 $).
California Housing Dataset:
MedInc HouseAge AveRooms AveBedrms Population AveOccup Latitude Longitude MedHouseVal
0 8.3252 41.0 6.984127 1.023810 322.0 2.555556 37.88 -122.23 4.526
1 8.3014 21.0 6.238137 0.971880 2401.0 2.109842 37.86 -122.22 3.585
2 7.2574 52.0 8.288136 1.073446 496.0 2.802260 37.85 -122.24 3.521
3 5.6431 52.0 5.817352 1.073059 558.0 2.547945 37.85 -122.25 3.413
4 3.8462 52.0 6.281853 1.081081 565.0 2.181467 37.85 -122.25 3.422
Diviser les données en ensembles d'entraînement et de test à l'aide de train_test_split de sklearn.model_selection
Dans cette étape, nous allons préparer nos données pour le processus d'entraînement. Une partie cruciale de l'apprentissage automatique consiste à évaluer le modèle sur des données qu'il n'a jamais vues auparavant. Pour ce faire, nous divisons notre jeu de données en deux parties : un ensemble d'entraînement (training set) et un ensemble de test (testing set). Le modèle apprendra à partir de l'ensemble d'entraînement, et nous utiliserons l'ensemble de test pour voir ses performances.
Tout d'abord, nous devons séparer nos caractéristiques (les variables d'entrée, X) de notre cible (la valeur que nous voulons prédire, y). Dans notre cas, X sera toutes les colonnes sauf MedHouseVal, et y sera la colonne MedHouseVal.
Ensuite, nous utiliserons la fonction train_test_split de sklearn.model_selection pour effectuer la division.
Ajoutez le code suivant à votre fichier main.py.
from sklearn.model_selection import train_test_split
## Prepare the data
X = california_df.drop('MedHouseVal', axis=1) ## Features (input variables)
y = california_df['MedHouseVal'] ## Target variable (what we want to predict)
## Split the data into training and testing sets
## test_size=0.2: Reserve 20% of data for testing, 80% for training
## random_state=42: Ensures reproducible splits (same result every run)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
## Print the shapes of the new datasets to confirm the split
print("\n--- Data Split ---")
print("X_train shape:", X_train.shape) ## Training features
print("X_test shape:", X_test.shape) ## Test features
print("y_train shape:", y_train.shape) ## Training target values
print("y_test shape:", y_test.shape) ## Test target values
Maintenant, exécutez à nouveau le script depuis le terminal :
python3 main.py
Vous verrez les formes des ensembles d'entraînement et de test nouvellement créés s'afficher sous le DataFrame. Cela confirme que les données ont été correctement divisées.
--- Data Split ---
X_train shape: (16512, 8)
X_test shape: (4128, 8)
y_train shape: (16512,)
y_test shape: (4128,)
Initialiser le modèle LinearRegression à partir de sklearn.linear_model
Dans cette étape, nous allons créer notre modèle de Régression Linéaire. scikit-learn rend cela incroyablement simple. Il suffit d'importer la classe LinearRegression du module sklearn.linear_model, puis d'en créer une instance.
Cette instance est un objet qui contient l'algorithme de régression linéaire. La régression linéaire trouve la droite qui s'ajuste le mieux aux points de données, en utilisant la formule : y = mx + b, où m sont les coefficients (poids) pour chaque caractéristique, et b est l'ordonnée à l'origine (intercept). Ici, nous utilisons les paramètres par défaut qui fonctionnent bien pour la plupart des cas de base.
Figure 1 : Formule de régression linéaire y = mx + b, où m est la pente et b est l'ordonnée à l'origine
Ajoutez le code suivant à votre fichier main.py. Cela importera la classe LinearRegression et créera un objet modèle.
from sklearn.linear_model import LinearRegression
## Initialisation du modèle de Régression Linéaire
model = LinearRegression()
## Affichage du modèle pour confirmer sa création
print("\n--- Modèle Initialisé ---")
print(model)
Exécutez à nouveau votre script main.py depuis le terminal :
python3 main.py
La sortie inclura maintenant une ligne montrant l'objet LinearRegression. Cela confirme que le modèle a été initialisé avec succès.
--- Modèle Initialisé ---
LinearRegression()
Ajuster le modèle avec model.fit(X_train, y_train)
Dans cette étape, nous allons entraîner notre modèle. Ce processus est souvent appelé "ajustement" (fitting) du modèle aux données. Pendant l'ajustement, le modèle apprend les relations entre les caractéristiques (X_train) et la variable cible (y_train). Pour la régression linéaire, cela signifie trouver les coefficients optimaux pour chaque caractéristique afin de prédire au mieux la cible.
Nous utiliserons la méthode fit() de notre objet modèle, en passant nos données d'entraînement comme arguments.
Ajoutez le code suivant à votre fichier main.py.
## Fit (train) the model on the training data
## The fit() method learns the relationship between features (X_train) and target (y_train)
## It calculates optimal coefficients for each feature and the intercept using least squares optimization
model.fit(X_train, y_train)
## After fitting, the model has learned the coefficients and intercept.
## The intercept represents the predicted value when all features are zero
print("\n--- Model Trained ---")
print("Intercept:", model.intercept_)
Maintenant, exécutez le script depuis le terminal :
python3 main.py
Après l'exécution du script, vous verrez une nouvelle section dans la sortie affichant l'ordonnée à l'origine (intercept) du modèle de régression linéaire. L'intercept est la valeur de la prédiction lorsque toutes les valeurs des caractéristiques sont nulles. Voir une valeur numérique ici confirme que le modèle a été entraîné avec succès sur les données.
--- Model Trained ---
Intercept: -37.023277706064185
Prédire sur les données de test avec model.predict(X_test)
Dans cette dernière étape, nous allons utiliser notre modèle entraîné pour faire des prédictions. C'est le but ultime de la construction d'un modèle prédictif. Nous utiliserons les données de test (X_test), que le modèle n'a pas vues pendant l'entraînement, pour évaluer ses performances.
Nous utiliserons la méthode predict() de notre objet modèle entraîné, en passant les caractéristiques de test (X_test) comme argument. La méthode retournera un tableau de valeurs prédites pour la variable cible.
Ajoutez le code suivant à votre fichier main.py.
## Make predictions on the test data
## The predict() method uses the learned coefficients and intercept to calculate predictions
## Formula: prediction = intercept + (coeff1 * feature1) + (coeff2 * feature2) + ...
predictions = model.predict(X_test)
## Print the first 5 predictions (values are in $100,000 units)
print("\n--- Predictions ---")
print(predictions[:5])
Maintenant, exécutez le script complet une dernière fois depuis le terminal :
python3 main.py
La sortie inclura désormais les cinq premières prédictions de prix de maisons pour l'ensemble de test. Ces valeurs sont ce que notre modèle estime être les valeurs médianes des maisons, en se basant sur les caractéristiques de X_test. Vous pouvez comparer conceptuellement ces prédictions aux valeurs réelles de y_test pour évaluer la précision du modèle.
--- Predictions ---
[0.71912284 1.76401657 2.70965883 2.83892593 2.60465725]
Félicitations ! Vous avez construit, entraîné et utilisé avec succès un modèle de régression linéaire avec scikit-learn.
Résumé
Dans ce laboratoire, vous avez complété l'ensemble du flux de travail pour construire un modèle d'apprentissage automatique de base en utilisant scikit-learn.
Vous avez commencé par charger le jeu de données du logement en Californie et l'avez préparé à l'aide de pandas. Ensuite, vous avez appris l'importance de diviser vos données en ensembles d'entraînement et de test, et vous avez effectué cette division à l'aide de train_test_split.
Après cela, vous avez initialisé un modèle LinearRegression, l'avez entraîné sur vos données d'entraînement à l'aide de la méthode fit(), et enfin utilisé le modèle entraîné pour faire des prédictions sur des données de test non vues avec la méthode predict().
Ce laboratoire fournit une base solide en scikit-learn. À partir de là, vous pouvez explorer des sujets plus avancés tels que :
- Évaluation du modèle : Calculer des métriques comme l'Erreur Quadratique Moyenne (MSE) ou le coefficient de détermination (R-squared) pour mesurer la précision du modèle.
- Mise à l'échelle des caractéristiques : Standardiser ou normaliser les caractéristiques pour de meilleures performances.
- Régularisation : Utiliser la régression Ridge ou Lasso pour éviter le surajustement (overfitting).
- Validation croisée : Une évaluation plus robuste utilisant la validation croisée k-fold.
- Autres algorithmes : Essayer Random Forest, Support Vector Machines (SVM) ou Réseaux de Neurones.
Summary
In this lab, you have completed the entire workflow for building a basic machine learning model using scikit-learn.
You started by loading the California housing dataset and preparing it using pandas. Then, you learned the importance of splitting your data into training and testing sets and performed the split using train_test_split.
Following that, you initialized a LinearRegression model, trained it on your training data using the fit() method, used the trained model to make predictions on unseen test data with the predict() method, and finally visualized the results to understand your model's performance.
This lab provides a solid foundation in scikit-learn. From here, you can explore more advanced topics such as:
- Model evaluation: Calculate metrics like Mean Squared Error (MSE) or R-squared to measure model accuracy
- Data visualization: Create more advanced plots like residual plots, feature importance charts, or correlation matrices
- Feature scaling: Standardize or normalize features for better performance
- Regularization: Use Ridge or Lasso regression to prevent overfitting
- Cross-validation: More robust evaluation using k-fold cross-validation
- Other algorithms: Try Random Forest, Support Vector Machines, or Neural Networks
