Introduction

Un modèle d'apprentissage automatique est essentiellement un ensemble de règles ou de mécanismes utilisés pour faire des prédictions ou trouver des modèles dans les données. Pour faire simple (et sans crainte de simplification excessive), une courbe de tendance calculée selon la méthode des moindres carrés dans Excel est aussi un modèle. Cependant, les modèles utilisés dans les applications réelles ne sont pas si simples : ils impliquent souvent des équations et des algorithmes plus complexes, et pas seulement des équations simples.

Dans cet article, je vais commencer par créer un modèle d'apprentissage automatique très simple et le publier sous la forme d'une application Web très simple pour avoir une idée du processus.

Ici, je me concentrerai uniquement sur le processus, pas sur le modèle ML lui-même. J'utiliserai également Streamlit et Streamlit Community Cloud pour publier facilement des applications Web Python.

TL;DR :

Grâce à scikit-learn, une bibliothèque Python populaire pour l'apprentissage automatique, vous pouvez rapidement entraîner des données et créer un modèle avec seulement quelques lignes de code pour des tâches simples. Le modèle peut ensuite être enregistré sous forme de fichier réutilisable avec joblib. Ce modèle enregistré peut être importé/chargé comme une bibliothèque Python classique dans une application Web, permettant à l'application de faire des prédictions à l'aide du modèle entraîné !

URL de l'application : https://yh-machine-learning.streamlit.app/
GitHub : https://github.com/yoshan0921/yh-machine-learning.git

Pile technologique

• Python
• Streamlit : pour créer l'interface de l'application Web.
• scikit-learn : pour charger et utiliser le modèle Random Forest pré-entraîné.
• NumPy & Pandas : pour la manipulation et le traitement des données.
• Matplotlib & Seaborn : pour générer des visualisations.

Ce que j'ai fait

Cette application vous permet d'examiner les prédictions faites par un modèle de forêt aléatoire formé sur l'ensemble de données Palmer Penguins. (Voir la fin de cet article pour plus de détails sur les données d'entraînement.)

Plus précisément, le modèle prédit les espèces de manchots en fonction de diverses caractéristiques, notamment l'espèce, l'île, la longueur du bec, la longueur des nageoires, la taille du corps et le sexe. Les utilisateurs peuvent naviguer dans l'application pour voir comment différentes fonctionnalités affectent les prédictions du modèle.

• Écran de prédiction
  

• Écran de visualisation/données d'apprentissage
  

Étape de développement 1 - Création du modèle

Étape 1.1 Importer des bibliothèques

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import joblib

pandas est une bibliothèque Python spécialisée dans la manipulation et l'analyse de données. Il prend en charge le chargement, le prétraitement et la structuration des données à l'aide de DataFrames, préparant les données pour les modèles d'apprentissage automatique.
sklearn est une bibliothèque Python complète pour l'apprentissage automatique qui fournit des outils de formation et d'évaluation. Dans cet article, je vais construire un modèle en utilisant une méthode d'apprentissage appelée Random Forest.
joblib est une bibliothèque Python qui permet d'enregistrer et de charger des objets Python, comme des modèles d'apprentissage automatique, de manière très efficace.

Étape 1.2 Lire les données

df = pd.read_csv("./dataset/penguins_cleaned.csv")
X_raw = df.drop("species", axis=1)
y_raw = df.species

Chargez l'ensemble de données (données d'entraînement) et séparez-le en fonctionnalités (X) et variables cibles (y).

Étape 1.3 Encoder les variables de catégorie

encode = ["island", "sex"]
X_encoded = pd.get_dummies(X_raw, columns=encode)

target_mapper = {"Adelie": 0, "Chinstrap": 1, "Gentoo": 2}
y_encoded = y_raw.apply(lambda x: target_mapper[x])

Les variables catégorielles sont converties en un format numérique à l'aide d'un encodage à chaud (X_encoded). Par exemple, si « île » contient les catégories « Biscoe », « Dream » et « Torgersen », une nouvelle colonne est créée pour chacune (island_Biscoe, island_Dream, island_Torgersen). La même chose est faite pour le sexe. Si les données d'origine sont « Biscoe », la colonne island_Biscoe sera définie sur 1 et les autres sur 0.
L'espèce variable cible est mappée à des valeurs numériques (y_encoded).

Étape 1.4 Diviser l'ensemble de données

x_train, x_test, y_train, y_test = train_test_split(
    X_encoded, y_encoded, test_size=0.3, random_state=1
)

Pour évaluer un modèle, il est nécessaire de mesurer les performances du modèle sur des données non utilisées pour la formation. Le format 7:3 est largement utilisé comme pratique générale dans l'apprentissage automatique.

Étape 1.5 Former un modèle de forêt aléatoire

clf = RandomForestClassifier()
clf.fit(x_train, y_train)

La méthode d'ajustement est utilisée pour entraîner le modèle.
Le x_train représente les données d'entraînement pour les variables explicatives et le y_train représente les variables cibles.
En appelant cette méthode, le modèle entraîné sur la base des données d'entraînement est stocké dans clf.

Étape 1.6 Enregistrez le modèle

joblib.dump(clf, "penguin_classifier_model.pkl")

joblib.dump() est une fonction permettant de sauvegarder des objets Python au format binaire. En enregistrant le modèle dans ce format, le modèle peut être chargé à partir d'un fichier et utilisé tel quel sans avoir à être à nouveau entraîné.

Exemple de code

Étape de développement 2 - Création de l'application Web et intégration du modèle

Étape 2.1 Importer des bibliothèques

import streamlit as st
import numpy as np
import pandas as pd
import joblib

stremlit est une bibliothèque Python qui facilite la création et le partage d'applications Web personnalisées pour les projets d'apprentissage automatique et de science des données.
numpy est une bibliothèque Python fondamentale pour le calcul numérique. Il prend en charge de grands tableaux et matrices multidimensionnels, ainsi qu'un ensemble de fonctions mathématiques pour fonctionner efficacement sur ces tableaux.

Étape 2.2 Récupérer et encoder les données d'entrée

data = {
    "island": island,
    "bill_length_mm": bill_length_mm,
    "bill_depth_mm": bill_depth_mm,
    "flipper_length_mm": flipper_length_mm,
    "body_mass_g": body_mass_g,
    "sex": sex,
}
input_df = pd.DataFrame(data, index=[0])

encode = ["island", "sex"]
input_encoded_df = pd.get_dummies(input_df, prefix=encode)

Les valeurs d'entrée sont récupérées à partir du formulaire de saisie créé par Stremlit et les variables catégorielles sont codées en utilisant les mêmes règles que lors de la création du modèle. Notez que l'ordre de chaque donnée doit également être le même que lors de la création du modèle. Si l'ordre est différent, une erreur se produira lors de l'exécution d'une prévision à l'aide du modèle.

Étape 2.3 Charger le modèle

clf = joblib.load("penguin_classifier_model.pkl")

"penguin_classifier_model.pkl" est le fichier dans lequel le modèle précédemment enregistré est stocké. Ce fichier contient un RandomForestClassifier formé au format binaire. L'exécution de ce code charge le modèle dans clf, vous permettant de l'utiliser pour des prédictions et des évaluations sur de nouvelles données.

Étape 2.4 Effectuer une prédiction

prediction = clf.predict(input_encoded_df)
prediction_proba = clf.predict_proba(input_encoded_df)

clf.predict(input_encoded_df) : utilise le modèle entraîné pour prédire la classe pour les nouvelles données d'entrée codées, en stockant le résultat dans la prédiction.
clf.predict_proba(input_encoded_df) : calcule la probabilité pour chaque classe, en stockant les résultats dans prédiction_proba.

Exemple de code

Étape 3. Déployer

Vous pouvez publier votre application développée sur Internet en accédant au Stremlit Community Cloud (https://streamlit.io/cloud) et en spécifiant l'URL du référentiel GitHub.

À propos de l'ensemble de données

Oeuvre de @allison_horst (https://github.com/allisonhorst)

Le modèle est entraîné à l'aide de l'ensemble de données Palmer Penguins, un ensemble de données largement reconnu pour la pratique des techniques d'apprentissage automatique. Cet ensemble de données fournit des informations sur trois espèces de manchots (Adélie, à jugulaire et papou) de l'archipel Palmer en Antarctique. Les principales fonctionnalités incluent :

• Espèce : L'espèce du manchot (Adélie, Jugulaire, Gentoo).
• Île : L'île spécifique où le manchot a été observé (Biscoe, Dream, Torgersen).
• Longueur du bec : La longueur du bec du pingouin (mm).
• Profondeur du bec : La profondeur du bec du pingouin (mm).
• Longueur de la nageoire : La longueur de la nageoire du pingouin (mm).
• Masse corporelle : La masse du pingouin (g).
• Sexe : Le sexe du pingouin (mâle ou femelle).

Cet ensemble de données provient de Kaggle et est accessible ici. La diversité des caractéristiques en fait un excellent choix pour créer un modèle de classification et comprendre l'importance de chaque caractéristique dans la prédiction des espèces.