Déploiement d'un modèle d'apprentissage automatique en tant qu'application Web à l'aide de Streamlit

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 données/visualisation 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 ainsi 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 de sauvegarder 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 format numérique à l'aide d'un encodage one-hot (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 l'entraînement. 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

Development Step2 - Building the Web App and Integrating the Model

Step2.1 Import Libraries

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

stremlit is a Python library that makes it easy to create and share custom web applications for machine learning and data science projects.
numpy is a fundamental Python library for numerical computing. It provides support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays efficiently.

Step2.2 Retrieve and encode input data

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)

Input values are retrieved from the input form created by Stremlit, and categorical variables are encoded using the same rules as when the model was created. Note that the order of each data must also be the same as when the model was created. If the order is different, an error will occur when executing a forecast using the model.

Step2.3 Load the Model

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

"penguin_classifier_model.pkl" is the file where the previously saved model is stored. This file contains a trained RandomForestClassifier in binary format. Running this code loads the model into clf, allowing you to use it for predictions and evaluations on new data.

Step2.4 Perform prediction

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

clf.predict(input_encoded_df): Uses the trained model to predict the class for the new encoded input data, storing the result in prediction.
clf.predict_proba(input_encoded_df): Calculates the probability for each class, storing the results in prediction_proba.

Sample Code

Step3. Deploy

You can publish your developed application on the Internet by accessing the Stremlit Community Cloud (https://streamlit.io/cloud) and specifying the URL of the GitHub repository.

About Data Set

Artwork by @allison_horst (https://github.com/allisonhorst)

The model is trained using the Palmer Penguins dataset, a widely recognized dataset for practicing machine learning techniques. This dataset provides information on three penguin species (Adelie, Chinstrap, and Gentoo) from the Palmer Archipelago in Antarctica. Key features include:

• Species: The species of the penguin (Adelie, Chinstrap, Gentoo).
• Island: The specific island where the penguin was observed (Biscoe, Dream, Torgersen).
• Bill Length: The length of the penguin's bill (mm).
• Bill Depth: The depth of the penguin's bill (mm).
• Flipper Length: The length of the penguin's flipper (mm).
• Body Mass: The mass of the penguin (g).
• Sex: The sex of the penguin (male or female).

This dataset is sourced from Kaggle, and it can be accessed here. The diversity in features makes it an excellent choice for building a classification model and understanding the importance of each feature in species prediction.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!