Explorer les classifieurs SGD de Scikit-Learn

Introduction

Dans ce laboratoire, nous explorerons la descente de gradient stochastique (SGD), qui est un puissant algorithme d'optimisation couramment utilisé en apprentissage automatique pour résoudre des problèmes à grande échelle et creux. Nous apprendrons à utiliser les classes SGDClassifier et SGDRegressor de la bibliothèque scikit-learn pour entraîner des classifieurs linéaires et des régresseurs.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous réglerons rapidement le problème pour vous.

Skills Graph

Importez les bibliothèques nécessaires

Tout d'abord, nous devons importer les bibliothèques nécessaires. Nous utiliserons la bibliothèque scikit-learn pour l'apprentissage automatique et le prétraitement des données.

import numpy as np
from sklearn.datasets import load_iris
from sklearn.linear_model import SGDClassifier, SGDRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, mean_squared_error

Chargez et prétraitez les données

Ensuite, nous allons charger l'ensemble de données iris et le prétraiter en mettant à l'échelle les caractéristiques à l'aide de StandardScaler.

## Chargez l'ensemble de données iris
iris = load_iris()
X, y = iris.data, iris.target

## Mettez à l'échelle les caractéristiques
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

## Divisez les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

Entraînez un classifieur à l'aide de la SGD

Maintenant, nous allons entraîner un classifieur à l'aide de la classe SGDClassifier. Nous utiliserons la fonction de perte log_loss et la pénalité l2.

## Entraînez un classifieur à l'aide de la SGD
clf = SGDClassifier(loss="log_loss", penalty="l2", max_iter=100, random_state=42)
clf.fit(X_train, y_train)

## Faites des prédictions sur l'ensemble de test
y_pred = clf.predict(X_test)

## Évaluez la précision du classifieur
accuracy = accuracy_score(y_test, y_pred)

## Affichez la précision
print("Précision du classifieur :", accuracy)

Entraînez un régresseur à l'aide de la SGD

Ensuite, nous allons entraîner un régresseur à l'aide de la classe SGDRegressor. Nous utiliserons la fonction de perte squared_error et la pénalité l2.

## Entraînez un régresseur à l'aide de la SGD
reg = SGDRegressor(loss="squared_error", penalty="l2", max_iter=100, random_state=42)
reg.fit(X_train, y_train)

## Faites des prédictions sur l'ensemble de test
y_pred = reg.predict(X_test)

## Évaluez l'erreur quadratique moyenne du régresseur
mse = mean_squared_error(y_test, y_pred)

## Affichez l'erreur quadratique moyenne
print("Erreur quadratique moyenne du régresseur :", mse)

Sommaire

Dans ce laboratoire, nous avons appris à utiliser le Gradient Stochastique (SGD en anglais) pour entraîner des classifieurs linéaires et des régresseurs à l'aide de la bibliothèque scikit-learn. Nous avons entraîné un classifieur sur l'ensemble de données iris et mesuré sa précision, et nous avons entraîné un régresseur et mesuré son erreur quadratique moyenne. Le SGD est un algorithme d'optimisation puissant qui peut gérer efficacement les problèmes d'apprentissage automatique à grande échelle et creux.