Guide du débutant sur l’apprentissage automatique avec Python

Image par auteur

Prédire l’avenir n’est pas magique ; c’est une IA.

Alors que nous sommes à l’aube de la révolution de l’IA, Python nous permet d’y participer.

Dans celui-ci, nous découvrirons comment utiliser Python et le Machine Learning pour faire des prédictions.

Nous commencerons par de vrais fondamentaux et irons au point où nous appliquerons des algorithmes aux données pour faire une prédiction. Commençons!

Qu’est-ce que l’apprentissage automatique ?

L’apprentissage automatique est un moyen de donner à l’ordinateur la capacité de faire des prédictions. C’est trop populaire maintenant ; vous l’utilisez probablement quotidiennement sans vous en rendre compte. Voici quelques technologies qui bénéficient du Machine Learning :

• Voitures autonomes
• Système de détection de visage
• Système de recommandation de films Netflix

Mais parfois, l’IA, l’apprentissage automatique et l’apprentissage profond ne peuvent pas être bien distingués.
Voici un grand schéma qui représente le mieux ces termes.

Classer l’apprentissage automatique en tant que débutant

Les algorithmes de Machine Learning peuvent être regroupés en utilisant deux méthodes différentes. L’une de ces méthodes consiste à déterminer si une « étiquette » est associée aux points de données. Dans ce contexte, une « étiquette » fait référence à l’attribut ou à la caractéristique spécifique des points de données que vous souhaitez prédire.

S’il y a une étiquette, votre algorithme est classé comme algorithme supervisé ; sinon, c’est un algorithme non supervisé.

Une autre méthode pour classer les algorithmes d’apprentissage automatique consiste à classer l’algorithme. Si vous faites cela, les algorithmes d’apprentissage automatique peuvent être regroupés comme suit :

Comme Sci-kit Learn l’a fait, ici.

Source des images : scikit-learn.org

Qu’est-ce que Sci-kit Learn ?

Sci-kit learn est la bibliothèque d’apprentissage automatique la plus célèbre en Python ; nous l’utiliserons dans cet article. En utilisant Sci-kit Learn, vous éviterez de définir des algorithmes à partir de zéro et utiliserez les fonctions intégrées de Sci-kit Learn, ce qui facilitera votre façon de créer un apprentissage automatique.

Dans cet article, nous allons créer un modèle d’apprentissage automatique en utilisant différents algorithmes de régression du sci-kit Learn. Expliquons d’abord la régression.

Qu’est-ce que la régression ?

La régression est un algorithme d’apprentissage automatique qui fait des prédictions sur la valeur continue. Voici quelques exemples concrets de régression,

Maintenant, avant d’appliquer les modèles de régression, voyons trois algorithmes de régression différents avec des explications simples :

• La régression linéaire multiple: Prédit à l’aide d’une combinaison linéaire de plusieurs variables prédictives.
• Régresseur d’arbre de décision: Crée un modèle de décision arborescent pour prédire la valeur d’une variable cible en fonction de plusieurs fonctionnalités d’entrée.
• Régression du vecteur de support: Trouve la ligne la mieux ajustée (ou l’hyperplan dans des dimensions supérieures) avec le nombre maximum de points dans une certaine distance.

Avant d’appliquer l’apprentissage automatique, vous devez suivre des étapes spécifiques. Parfois, ces étapes peuvent différer ; cependant, la plupart du temps, ils incluent :

• Exploration et analyse des données
• Manipulation de données
• Répartition train-test
• Création d’un modèle ML
• Visualisation de données

Dans celui-ci, utilisons un projet de données de notre plateforme pour prédire le prix ici.

Exploration et analyse des données

En Python, nous avons plusieurs fonctions. En les utilisant, vous pourrez vous familiariser avec les données que vous utilisez.

Mais avant tout, vous devez charger les bibliothèques avec ces fonctions.

import pandas as pd
import sklearn
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn import svm
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
from sklearn.metrics import mean_squared_error

Excellent, chargeons nos données et explorons-les un peu

data = pd.read_csv('path')

Saisissez le chemin du fichier dans votre répertoire. Python dispose de trois fonctions qui vous aideront à explorer les données. Appliquons-les un par un et voyons le résultat.

Voici le code pour voir les cinq premières lignes de notre ensemble de données.

Voici le résultat.

Examinons maintenant notre deuxième fonction : afficher les informations sur notre colonne d’ensembles de données.

Voici le résultat.

RangeIndex: 10000 entries, 0 to 9999
Data columns (total 8 columns):
  #     Column     Non-Null  Count   Dtype
- - -   - - - -    - - - - - - - -   - - - -
  0     loc1       10000 non-null     object
  1     loc2       10000 non-null     object
  2     para1      10000 non-null     int64
  3     dow        10000 non-null     object
  4     para2      10000 non-null     int64
  5     para3      10000 non-null     float64
  6     para4      10000 non-null     float64
  7     price      10000 non-null     float64
 dtypes:   float64(3),   int64(2),   object(3)
 memory  usage:  625.1+ KB

Voici la dernière fonction, qui résumera statistiquement nos données. Voici le code.

Voici le résultat.

Vous connaissez désormais mieux nos données. En apprentissage automatique, toutes vos variables prédictives, c’est-à-dire les colonnes que vous comptez utiliser pour effectuer une prédiction, doivent être numériques.

Dans la section suivante, nous nous en assurerons.

Données Manipulation

Maintenant, nous savons tous que nous devrions convertir la colonne « dow » en nombres, mais avant cela, vérifions si d’autres colonnes sont constituées de nombres uniquement pour le bien de nos modèles d’apprentissage automatique.

Nous avons deux colonnes suspectes, loc1 et loc2, car, comme vous pouvez le voir dans le résultat de la fonction info(), nous n’avons que deux colonnes qui sont des types de données d’objet, qui peuvent inclure des valeurs numériques et de chaîne.

Utilisons ce code pour vérifier ;

data["loc1"].value_counts()

Voici le résultat.

loc1
2	1607
0	1486
1	1223
7	1081
3	945
5	846
4	773
8	727
9	690
6	620
S	  1
T	  1
Name:  count,  dtype:  int64

Désormais, en utilisant le code suivant, vous pouvez éliminer ces lignes.

data = data[(data["loc1"] != "S") & (data["loc1"] != "T")]

Cependant, nous devons nous assurer que l’autre colonne, loc2, ne contient pas de valeurs de chaîne. Utilisons le code suivant pour nous assurer que toutes les valeurs sont numériques.

data["loc2"] = pd.to_numeric(data["loc2"], errors="coerce")
data["loc1"] = pd.to_numeric(data["loc1"], errors="coerce")
data.dropna(inplace=True)

À la fin du code ci-dessus, nous utilisons la fonction dropna() car la fonction de conversion des pandas convertira « na » en valeurs non numériques.

Excellent. Nous pouvons résoudre ce problème ; convertissons les colonnes des jours de la semaine en nombres. Voici le code pour faire cela ;

# Assuming data is already loaded and 'dow' column contains day names
# Map 'dow' to numeric codes
days_of_week = {'Mon': 1, 'Tue': 2, 'Wed': 3, 'Thu': 4, 'Fri': 5, 'Sat': 6, 'Sun': 7}
data['dow'] = data['dow'].map(days_of_week)

# Invert the days_of_week dictionary
week_days = {v: k for k, v in days_of_week.items()}

# Convert dummy variable columns to integer type
dow_dummies = pd.get_dummies(data['dow']).rename(columns=week_days).astype(int)

# Drop the original 'dow' column
data.drop('dow', axis=1, inplace=True)

# Concatenate the dummy variables
data = pd.concat([data, dow_dummies], axis=1)

data.head()

Dans ce code, nous définissons les jours de la semaine en définissant un numéro pour chaque jour dans le dictionnaire, puis en changeant simplement les noms des jours avec ces numéros. Voici le résultat.

Maintenant, nous y sommes presque.

Répartition Train-Test

Avant d’appliquer un modèle d’apprentissage automatique, vous devez diviser vos données en ensembles de formation et de test. Cela vous permet d’évaluer objectivement l’efficacité de votre modèle en l’entraînant sur l’ensemble d’entraînement, puis en évaluant ses performances sur l’ensemble de test, ce que le modèle n’a jamais vu auparavant.

X = data.drop('price', axis=1)  # Assuming 'price' is the target variable
y = data['price']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Création d’un modèle d’apprentissage automatique

Maintenant, tout est prêt. À ce stade, nous appliquerons simultanément les algorithmes suivants.

• La régression linéaire multiple
• Régression de l’arbre de décision
• Régression du vecteur de support

Si vous êtes débutant, ce code peut paraître compliqué, mais rassurez-vous, il ne l’est pas. Dans le code, nous attribuons d’abord les noms de modèles et leurs fonctions correspondantes de scikit-learn au dictionnaire du modèle.

Ensuite, nous créons un dictionnaire vide appelé résultats pour stocker ces résultats. Dans la première boucle, nous appliquons simultanément tous les modèles d’apprentissage automatique et les évaluons à l’aide de métriques telles que R^2 et MSE, qui évaluent les performances des algorithmes.

Dans la boucle finale, nous imprimons les résultats que nous avons enregistrés. Voici le code

# Initialize the models
models = {
    "Multiple Linear Regression": LinearRegression(),
    "Decision Tree Regression": DecisionTreeRegressor(random_state=42),
    "Support Vector Regression": SVR()
}

# Dictionary to store the results
results = {}

# Fit the models and evaluate
for name, model in models.items():
    model.fit(X_train, y_train)  # Train the model
    y_pred = model.predict(X_test)  # Predict on the test set
    
    # Calculate performance metrics
    mse = mean_squared_error(y_test, y_pred)
    r2 = r2_score(y_test, y_pred)
    
    # Store results
    results[name] = {'MSE': mse, 'R^2 Score': r2}

# Print the results
for model_name, metrics in results.items():
    print(f"{model_name} - MSE: {metrics['MSE']}, R^2 Score: {metrics['R^2 Score']}")

Voici le résultat.

Multiple Linear Regression - MSE: 35143.23011545407, R^2 Score: 0.5825954700994046
Decision Tree Regression - MSE: 44552.00644904675, R^2 Score: 0.4708451884787034
Support Vector Regression - MSE: 73965.02477382126, R^2 Score: 0.12149975134965318

Visualisation de données

Pour mieux voir les résultats, visualisons le résultat.

Voici le code dans lequel nous calculons d’abord le RMSE (racine carrée de MSE) et visualisons le résultat.

import matplotlib.pyplot as plt
from math import sqrt

# Calculate RMSE for each model from the stored MSE and prepare for plotting
rmse_values = [sqrt(metrics['MSE']) for metrics in results.values()]
model_names = list(results.keys())

# Create a horizontal bar graph for RMSE
plt.figure(figsize=(10, 5))
plt.barh(model_names, rmse_values, color="skyblue")
plt.xlabel('Root Mean Squared Error (RMSE)')
plt.title('Comparison of RMSE Across Regression Models')
plt.show()

Voici le résultat.

Projets de données

Avant de conclure, voici quelques projets de données à démarrer.

De plus, si vous souhaitez réaliser des projets de données sur des ensembles de données intéressants, voici quelques ensembles de données qui pourraient vous intéresser :

Conclusion

Nos résultats pourraient être meilleurs car il existe trop d’étapes pour améliorer l’efficacité du modèle, mais nous avons pris un bon départ ici. Vérifier Document officiel de Sci-kit Learn pour voir ce que vous pouvez faire de plus.

Bien sûr, après avoir appris, vous devez réaliser des projets de données à plusieurs reprises pour améliorer vos capacités et apprendre quelques choses supplémentaires.

Nate Rosidi est un data scientist et en stratégie produit. Il est également professeur adjoint enseignant l’analyse et est le fondateur de StrataScratch, une plateforme qui aide les data scientists à préparer leurs entretiens avec de vraies questions d’entretien posées par les grandes entreprises. Nate écrit sur les dernières tendances du marché des carrières, donne des conseils d’entretien, partage des projets de science des données et couvre tout ce qui concerne SQL.