Prédiction du taux de rotation des employés à l’aide de ZenML et Streamlit

Prédire le taux de rotation des employés avec ZenML et Streamlit

Introduction

Êtes-vous responsable des ressources humaines ? Vous vous demandez si les employés de votre équipe vont continuer à travailler ou s’ils envisagent de quitter l’organisation. Pas de soucis ! Pas besoin d’être astrologue pour prédire cela. Grâce à la puissance de la science des données, nous pouvons le prédire avec précision. Commençons notre merveilleux voyage sur le taux d’attrition des employés avec un outil simple mais puissant de MLOps appelé ZenML et streamlit. Commençons notre voyage.

Objectifs d’apprentissage

Dans cet article, nous apprendrons :

  • Qu’est-ce que ZenML ? Pourquoi et comment l’utiliser ?
  • Pourquoi utiliser MLflow et comment l’intégrer avec ZenML ?
  • L’importance d’utiliser un pipeline de déploiement
  • L’implémentation du projet de taux d’attrition des employés et la réalisation de prédictions

Cet article a été publié dans le cadre du Data Science Blogathon.

Mise en œuvre du projet

Énoncé du problème : Prédire si un employé quittera une organisation ou non en se basant sur plusieurs facteurs tels que l’âge, le revenu, les performances, etc.

Solution : Construire un modèle de régression logistique pour prédire le taux d’attrition d’un employé

Ensemble de données : IBM HR Analytics Employee Attrition & Performance

[Source] : https://www.kaggle.com/datasets/pavansubhasht/ibm-hr-analytics-attrition-dataset

Avant de voir l’implémentation de notre projet, regardons d’abord pourquoi nous utilisons ZenML ici.

Pourquoi ZenML ?

ZenML est un outil d’orchestration simple et puissant pour la gestion des opérations de machine learning (MLOps) utilisé pour créer des pipelines d’apprentissage automatique, mettre en cache les étapes du pipeline et économiser des ressources computationnelles. ZenML offre également une intégration avec plusieurs outils de ML, ce qui en fait l’un des meilleurs outils pour créer des pipelines de ML. Nous pouvons suivre les étapes de notre modèle, les métriques d’évaluation, visualiser nos pipelines sur des tableaux de bord, et bien plus encore.

Dans ce projet, nous allons mettre en œuvre un pipeline traditionnel qui utilise ZenML, et nous allons intégrer MLflow avec ZenML pour suivre les expériences. Nous allons également mettre en place un pipeline de déploiement continu en utilisant l’intégration de MLflow avec ZenML, qui va importer et nettoyer les données, entraîner le modèle et redéployer le modèle lorsque les prédictions atteignent certains critères d’évaluation minimum. Grâce à ce pipeline, nous pouvons nous assurer que si un nouveau modèle donne de meilleurs résultats que la valeur seuil de prédiction du modèle précédent, le serveur de déploiement MLFlow sera mis à jour avec le nouveau modèle au lieu de l’ancien modèle.

Termes courants de ZenML

  • Pipelines : Séquence d’étapes dans notre projet.
  • Composants : Blocs de construction ou une fonction particulière dans notre pipeline MLOps.
  • Stacks : Collection de composants en local/cloud.
  • Artifacts : Données d’entrée et de sortie d’une étape, dans notre projet, qui sont stockées dans un magasin d’artifacts.
  • Magasin d’artifacts : Espace de stockage pour stocker et suivre les versions de nos artifacts.
  • Materializers : Composants qui définissent comment les artifacts sont stockés et récupérés à partir du magasin d’artifacts.
  • Flavors : Solutions pour des outils et des cas d’utilisation spécifiques.
  • Serveur ZenML : Déploiement pour exécuter les composants de la pile à distance.

Prérequis et commandes de base ZenML

  • Activez votre environnement virtuel:
#créer un environnement virtuelpython3 -m venv venv#Activer votre environnement virtuel dans vos dossiers de projetsource venv/bin/activate
  • Commandes ZenML:

Toutes les commandes de base ZenML avec leurs fonctionnalités sont indiquées ci-dessous:

#Installer zenmlpip install zenml#pour lancer le serveur et le tableau de bord zenml localementpip install "zenml[server]"#pour voir la version de zenml:zenml version#Pour initialiser un nouveau dépôtzenml init#pour exécuter le tableau de bord localement:zenml up#pour connaître l'état de nos pipelines zenmlzenml show

Ces commandes sont nécessaires pour travailler avec ZenML.

Intégration de MLflow avec ZenML

Nous utilisons mlflow comme traqueur d’expériences, pour suivre notre modèle, les artefacts, les valeurs d’hyperparamètres.Nous enregistrons ici le composant stack, le traqueur d’expériences, le déploiement de modèles:

#Intégration de mlflow avec ZenMLzenml integration install mlflow -y#Enregistrer le traqueur d'expérienceszenml experiment-tracker register mlflow_tracker_employee --flavor=mlflow#Enregistrer le déploiement du modèlezenml model-deployer register mlflow_employee --flavor=mlflow#Enregistrer le stackzenml stack register mlflow_stack_employee -a default -o default -d mlflow_employee -e mlflow_tracker_employee --set

Liste des piles ZenML

Structure du projet

employee-attrition-prediction/          # Répertoire du projet├── data/                               │   └── HR-Employee-Attrition.csv       # Fichier de jeu de données│├── pipelines/                          │   ├── deployment_pipeline.py          # Pipeline de déploiement│   ├── training_pipeline.py            # Pipeline de formation│   └── utils.py                        │├── src/                                # Code source│   ├── data_cleaning.py                # Nettoyage des données et prétraitement│   ├── evaluation.py                   # Évaluation du modèle│   └── model_dev.py                    # Développement du modèle│                 ├── steps/                              # fichiers de code pour les étapes ZenML│   ├── ingest_data.py                  # Ingestion de données│   ├── clean_data.py                   # Nettoyage des données et prétraitement│   ├── model_train.py                  # Entraîner le modèle│   ├── evaluation.py                   # Évaluation du modèle│   └── config.py                       │├── streamlit_app.py                    # Application web Streamlit│├── run_deployment.py                   # Code pour exécuter le déploiement et le pipeline de prédiction├── run_pipeline.py                     # Code pour exécuter le pipeline de formation│├── requirements.txt                    # Liste des packages requis par le projet├── README.md                           # Documentation du projet└── .zen/                               # Répertoire ZenML (créé automatiquement après l'initialisation de ZenML)

Ingestion des données

Nous ingérons d’abord les données du jeu de données HR-Employee-Attrition-Rate à partir du dossier de données.

import pandas as pdfrom zenml import stepclass IngestData:    def get_data(self) -> pd.DataFrame:        df = pd.read_csv("./data/HR-Employee-Attrition.csv")        return df@stepdef ingest_data() -> pd.DataFrame:    ingest_data = IngestData()    df = ingest_data.get_data()    return df    

@step est un décorateur utilisé pour faire de la fonction ingest_data() une étape du pipeline.

Analyse exploratoire des données

#Comprendre les donnéesdf.info()# Voir à quoi ressemble les donnéesdf.describe()# Vérifier les données exemplesdf.head()#Vérifie les valeurs nullesdf.isnull.sum()#Vérifie le pourcentage de personnes qui sont restées et ont quitté l'entreprisedf['Attrition'].value_counts()df_left = df[df['Attrition'] == "Yes"]df_stayed = df[df['Attrition'] == "No"]percentage_departed=df_left.shape[0]*100/df.shape[0]percentage_stayed=df_stayed.shape[0]*100/df.shape[0]print(f"Le pourcentage de personnes ayant quitté l'entreprise est de:{percentage_departed}")print(f"Le pourcentage de personnes ayant resté dans l'entreprise est de:{percentage_stayed}")#Analyser les différences entre les caractéristiques des personnes qui sont restées et celles qui ont quitté l'entreprisedf_left.describe()df_stayed.describe()

Sortie

.

Observations

  • Les employés qui ont quitté leur emploi ont travaillé moins d’années dans l’entreprise.
  • Les employés qui ont quitté l’entreprise étaient plus jeunes que ceux qui sont restés.
  • Les employés qui ont quitté ont un lieu de travail plus éloigné de leur domicile que ceux qui sont restés.

Nettoyage et Traitement des Données

  • Nettoyage des données: Nous avons supprimé les colonnes indésirables du jeu de données telles que : “EmployeeCount”, “EmployeeNumber”, “StandardHours”, puis nous avons modifié les caractéristiques qui ne contiennent que des valeurs de données entre Oui (ou) Non en binaire 1 (ou) 0.
  • Encodage one-hot: Ensuite, nous avons effectué un encodage one-hot sur les colonnes catégorielles telles que ‘BusinessTravel’, ‘Department’, ‘EducationField’, ‘Gender’, ‘JobRole’, ‘MaritalStatus’.
import pandas as pdclass DataPreProcessStrategy(DataStrategy):    def __init__(self, encodeur=None):        self.encodeur = encodeur    """Cette classe est utilisée pour prétraiter le jeu de données donné"""    def modifier_données(self, données: pd.DataFrame) -> pd.DataFrame:        try:            print("Noms de colonnes avant le prétraitement :", données.columns)  # Ajoutez cette ligne            données = données.drop(["EmployeeCount", "EmployeeNumber", "StandardHours"], axis=1)            if 'Attrition' in données.columns:                print("Colonne Attrition trouvée dans les données.")            else:                print("Colonne Attrition non trouvée dans les données.")            données["Attrition"] = données["Attrition"].apply(lambda x: 1 if x == "Yes" else 0)            données["Over18"] = données["Over18"].apply(lambda x: 1 if x == "Yes" else 0)            données["OverTime"] = données["OverTime"].apply(lambda x: 1 if x == "Yes" else 0)            # Extraire les variables catégorielles            cat = données[['BusinessTravel', 'Department', 'EducationField', 'Gender', 'JobRole', 'MaritalStatus']]            # Effectuer un encodage one-hot sur les variables catégorielles            onehot = OneHotEncoder()            cat_encoded = onehot.fit_transform(cat).toarray()            # Convertir cat_encoded en DataFrame            cat_df = pd.DataFrame(cat_encoded)            # Extraire les variables numériques            numérique = données[['Age', 'Attrition', 'DailyRate', 'DistanceFromHome', 'Education', 'EnvironmentSatisfaction', 'HourlyRate', 'JobInvolvement', 'JobLevel', 'JobSatisfaction', 'MonthlyIncome', 'MonthlyRate', 'NumCompaniesWorked', 'Over18', 'OverTime', 'PercentSalaryHike', 'PerformanceRating', 'RelationshipSatisfaction', 'StockOptionLevel', 'TotalWorkingYears', 'TrainingTimesLastYear', 'WorkLifeBalance', 'YearsAtCompany', 'YearsInCurrentRole', 'YearsSinceLastPromotion', 'YearsWithCurrManager']]            # Concaténer X_cat_df et X_numérique            données = pd.concat([cat_df, numérique], axis=1)            print("Noms de colonnes après le prétraitement :", données.columns)  # Ajoutez cette ligne            print("Données prétraitées :")            print(données.head())            return données        except Exception as e:            logging.error(f"Erreur lors du prétraitement des données : {e}")            raise e            

Résultat

Les données ressemblent à ceci, après avoir effectué le nettoyage et le traitement des données: Vous pouvez voir dans l’image enfin, les données ne contiennent que des données numériques après la fin du codage.

Répartition des données

Nous allons ensuite diviser les ensembles de données d’apprentissage et de test dans un ratio de 80:20.

from sklearn.model_selection import train_test_splitclass StratégieDeDivisionDesDonnées(StratégieDesDonnées):    def handle_data(self, data: pd.DataFrame) -> Union[pd.DataFrame, pd.Series]:        try:            # Vérifier si 'Attrition' est présent dans les données            if 'Attrition' in data.columns:                X = data.drop(['Attrition'], axis=1)                Y = data['Attrition']                X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)                return X_train, X_test, Y_train, Y_test            else:                raise ValueError("La colonne 'Attrition' n'a pas été trouvée dans les données.")        except Exception as e:            logging.error(f"Erreur lors de la manipulation des données : {str(e)}")            raise e            

Formation du modèle

Étant donné qu’il s’agit d’un problème de classification, nous utilisons ici la régression logistique, nous pouvons également utiliser la classification de la forêt aléatoire, le boosting de gradient, etc., des algorithmes de classification.

from zenml import pipeline@training_pipelinedef training_pipeline(data_path: str):    df = ingest_data(data_path)    X_train, X_test, y_train, y_test = clean_and_split_data(df)    model = define_model()  # Définissez votre modèle d'apprentissage automatique    trained_model = train_model(model, X_train, y_train)    evaluation_metrics = evaluate_model(trained_model, X_test, y_test)

Ici, le décorateur @training_pipeline est utilisé pour définir la fonction training_pipeline() en tant que pipeline dans ZenML.

Évaluation

Pour les problèmes de classification binaire, nous utilisons des métriques d’évaluation telles que : précision, rappel, score F1, courbe ROC-AUC, etc. Nous importons classification_report de la bibliothèque scikit-learn, pour calculer les métriques d’évaluation et nous fournir le rapport de classification. Code :

import loggingimport numpy as npfrom sklearn.metrics import classification_reportclass RapportDeClassification:    @staticmethod    def calculate_scores(y_true: np.ndarray, y_pred: np.ndarray):        try:            logging.info("Calcul du rapport de classification")            report = classification_report(y_true, y_pred, output_dict=True)            logging.info(f"Rapport de classification:\n{report}")            return report        except Exception as e:            logging.error(f"Erreur lors du calcul du rapport de classification : {e}")            raise e

Rapport de classification :

Pour voir le tableau de bord du pipeline d’entraînement, nous devons exécuter run_pipelilne.py,

run_pipelilne.py,

from zenml import pipelinefrom pipelines.training_pipeline import train_pipelinefrom zenml.client import Clientimport pandas as pdif __name__ == "__main__":    uri = Client().active_stack.experiment_tracker.get_tracking_uri()    print(uri)    train_pipeline(data_path="./data/HR-Employee-Attrition.csv")

ce qui renverra l’URL du tableau de bord de suivi, qui ressemble à ceci : “URL du tableau de bord : http://127.0.0.1:8237/workspaces/default/pipelines/6e7941f4-cf74-4e30-b3e3-ff4428b823d2/runs/2274fc18-aba1-4536-aaee-9d2ed7d26323/dag“. Vous pouvez cliquer sur l’URL et voir votre incroyable pipeline d’entraînement dans le tableau de bord ZenML. Ici, l’image du pipeline complet est divisée en différentes parties d’image pour le voir plus clairement en détail.

Dans l’ensemble, le pipeline de formation ressemble à ceci sur le tableau de bord, comme indiqué ci-dessous :

Déploiement du modèle

Déclencheur de déploiement

class DeploymentTriggerConfig(BaseParameters):    min_accuracy: float = 0.5

Dans cette classe DeploymentTriggerConfig, nous définissons un paramètre de précision minimale, qui spécifie quelle devrait être la précision minimale de notre modèle.

Configuration du déclencheur de déploiement

@step(enable_cache=False)def deployment_trigger(    accuracy: float,    config: DeploymentTriggerConfig,):    return accuracy > config.min_accuracy

Ici, cette fonction deployment_trigger() est utilisée pour déployer le modèle uniquement lorsqu’il dépasse la précision minimale. Nous expliquerons pourquoi nous avons utilisé la mise en cache dans la prochaine section.

Pipeline de déploiement continu

@pipeline(enable_cache=False, settings={"docker":docker_settings})def continuous_deployment_pipeline(   data_path: str,   #data_path="C:/Users/user/Desktop/machine learning/Project/zenml Pipeline/Customer_Satisfaction_project/data/olist_customers_dataset.csv",   min_accuracy:float=0.0,   workers: int=1,   timeout: int=DEFAULT_SERVICE_START_STOP_TIMEOUT,):       df=ingest_data()   # Nettoyer les données et les diviser en ensembles d'entraînement/test   X_train,X_test,Y_train,Y_test=clean_df(df)   model=train_model(X_train,X_test,Y_train,Y_test)   evaluation_metrics=evaluate_model(model,X_test,Y_test)   deployment_decision=deployment_trigger(evaluation_metrics)       mlflow_model_deployer_step(      model=model,      deploy_decision=deployment_decision,      workers=workers,      timeout=timeout,    )

Dans ce continuous_deployment_pipeline(), nous allons importer les données, nettoyer les données, entraîner notre modèle, l’évaluer et déployer notre modèle seulement s’il satisfait la condition deployment_trigger(), afin de nous assurer que le nouveau modèle que nous allons déployer s’exécute uniquement si sa précision de prédiction dépasse la précision de prédiction du modèle précédent, qui est la valeur seuil. Voici comment fonctionne le continous_deployment_pipeline().

Le mise en cache fait référence à la mémorisation de la sortie des étapes précédentes exécutées dans le pipeline. Les sorties sont stockées dans le dépôt de ressources. Nous utilisons la mise en cache dans le paramètre du pipeline pour indiquer qu’il n’y a pas de changement dans les sorties entre les exécutions précédentes et l’étape en cours, de sorte que zenML réutilisera la sortie de l’exécution précédente elle-même. L’activation de la mise en cache accélérera le processus d’exécution du pipeline et économisera nos ressources informatiques. Cependant, parfois, dans des situations où nous devons exécuter des pipelines où il y aura des changements dynamiques dans les entrées, les paramètres, les sorties comme notre continuous_deployment_pipeline(), alors désactiver la mise en cache est préférable. Nous avons donc écrit enable_cache=False ici.

Pipeline d’inférence

Nous utilisons le pipeline d’inférence pour effectuer des prédictions sur de nouvelles données, en fonction du modèle déployé. Voyons comment nous avons utilisé ce pipeline dans notre projet.

inference_pipeline()

@pipeline(enable_cache=False,settings={"docker":docker_settings})def inference_pipeline(pipeline_name: str, pipeline_step_name:str):   data=dynamic_importer()   #print("Data Shape for Inference:", data.shape)  # Print the shape of data for inference   service=prediction_service_loader(      pipeline_name=pipeline_name,      pipeline_step_name=pipeline_step_name,      running=False,      )   prediction=predictor(service=service,data=data)   return prediction  

Voici comment fonctionne inference_pipeline() :

  • dynamic_importer()– Tout d’abord, dynamic_importer() charge les nouvelles données et les prépare.
  • prediction_service_loader()– prediction_service_loader() charge le modèle déployé, selon les paramètres du nom de pipeline et du nom d’étape.
  • predictor()-Ensuite, predictor() est utilisé pour prédire les nouvelles données en fonction du modèle déployé.

Examinons maintenant chacune de ces fonctions ci-dessous :

dynamic_importer()

@step(enable_cache=False)def dynamic_importer()->str:   data=get_data_for_test()   return data  

Ici, cela appelle get_data_for_test() dans utils.py, qui charge les nouvelles données, effectue le traitement des données et renvoie les données.

prediction_service_loader()

@step(enable_cache=False)def prediction_service_loader(   pipeline_name: str,   pipeline_step_name: str,   running:bool=True,   model_name: str="model", )->MLFlowDeploymentService:   mlflow_model_deployer_component=MLFlowModelDeployer.get_active_model_deployer()   existing_services=mlflow_model_deployer_component.find_model_server(   pipeline_name=pipeline_name,   pipeline_step_name=pipeline_step_name,   model_name=model_name,   running=running,)   if not existing_services:      raise RuntimeError(         f"No MLFlow deployment service found for pipeline {pipeline_name},step {pipeline_step_name} and model{model_name} and pipeline for the model {model_name} is currently running"      )

Ici, dans cette fonction prediction_service_loader(), nous chargeons le service de déploiement par rapport au modèle déployé en fonction des paramètres. Un service de déploiement est un environnement d’exécution où notre modèle déployé est prêt à accepter des demandes d’inférence pour effectuer des prédictions sur les nouvelles données. La ligne existing_services=mlflow_model_deployer_component.find_model_server() recherche tout service de déploiement existant disponible en fonction des paramètres donnés tels que le nom du pipeline et le nom de l’étape du pipeline. S’il n’y a aucun service existant disponible, cela signifie que le pipeline de déploiement n’a pas encore été exécuté ou qu’il y a un problème avec le pipeline de déploiement, il génère donc une erreur d’exécution.

predictor()

@stepdef predictor(    service: MLFlowDeploymentService,    data: str,) -> np.ndarray:        """Lance une demande d'inférence sur un service de prédiction"""    service.start(timeout=21)  # devrait être un NOP s'il est déjà démarré    data = json.loads(data)    data.pop("columns")    data.pop("index")    columns_for_df = [        0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,"Age","DailyRate","DistanceFromHome","Education","EnvironmentSatisfaction","HourlyRate","JobInvolvement","JobLevel","JobSatisfaction","MonthlyIncome","MonthlyRate","NumCompaniesWorked","Over18","OverTime","PercentSalaryHike","PerformanceRating","RelationshipSatisfaction","StockOptionLevel","TotalWorkingYears","TrainingTimesLastYear","WorkLifeBalance","YearsAtCompany","YearsInCurrentRole","YearsSinceLastPromotion","YearsWithCurrManager",    ]    df = pd.DataFrame(data["data"], columns=columns_for_df)    json_list = json.loads(json.dumps(list(df.T.to_dict().values())))    data = np.array(json_list)    prediction = service.predict(data)    return prediction

Après avoir le modèle déployé et les nouvelles données, nous pouvons utiliser predictor() pour effectuer les prédictions.

Pour voir visuellement le déploiement continu et le pipeline d’inférence, nous devons exécuter run_deployment.py, où les configurations de déploiement et de prédiction seront définies.

@click.option(    "--config",    type=click.Choice([DEPLOY, PREDICT, DEPLOY_AND_PREDICT]),    default=DEPLOY_AND_PREDICT,    help="Optionnellement, vous pouvez choisir d'exécuter uniquement le pipeline de déploiement pour former et déployer un modèle (`deploy`), ou uniquement exécuter une prédiction contre le modèle déployé (`predict`). Par défaut, les deux seront exécutés (`deploy_and_predict`).",)

Voici, nous pouvons exécuter soit le pipeline de déploiement continu soit le pipeline d’inférence en suivant ces commandes,

# Le pipeline de déploiement continu
python run_deployment.py
# Pour voir le pipeline d'inférence (pour le déploiement et la prédiction)
python run_deployment.py --config predict

Après avoir exécuté les commandes, vous pouvez voir l’URL du tableau de bord zenML, comme ceci

URL du tableau de bord : http://127.0.0.1:8237/workspaces/default/pipelines/b437cf1a-971c-4a23-a3b6-c296c1cdf8ca/runs/58826e07-6139-453d-88f9-b3c771bb6695/dag

Profitez de vos visualisations de pipeline dans le tableau de bord :

Pipeline de déploiement continu

Le pipeline de déploiement continu (de l’ingestion des données à l’étape mlflow_model_deployer) ressemble à ceci :

Pipeline d’inférence

Construction d’une application Streamlit

Streamlit est un framework incroyable basé sur Python, utilisé pour créer des interfaces utilisateur. Nous pouvons utiliser Streamlit pour créer rapidement des applications web, sans avoir de connaissances en développement backend ou frontend. Tout d’abord, nous devons installer Streamlit sur notre ordinateur. Les commandes pour installer et exécuter le serveur web local Streamlit sur notre système local sont les suivantes :

# Installer Streamlit sur notre PC local
pip install streamlit
# Pour exécuter le serveur web local Streamlit
streamlit run streamlit_app.py

Code :

import json
import numpy as np
import pandas as pd
import streamlit as st
from PIL import Image
from pipelines.deployment_pipeline import prediction_service_loader
from run_deployment import main

# Définir une variable globale pour suivre l'état du service
service_started = False

def start_service():
    global service_started
    service = prediction_service_loader(
        pipeline_name="continuous_deployment_pipeline",
        pipeline_step_name="mlflow_model_deployer_step",
        running=False,
    )
    service.start(timeout=21)  # Démarrer le service
    service_started = True
    return service

def stop_service(service):
    global service_started
    service.stop()  # Arrêter le service
    service_started = False

def main():
    st.title("Prédiction d'attrition des employés")
    age = st.sidebar.slider("Âge", 18, 65, 30)
    monthly_income = st.sidebar.slider("Revenu mensuel", 0, 20000, 5000)
    total_working_years = st.sidebar.slider("Années de travail totales", 0, 40, 10)
    years_in_current_role = st.sidebar.slider("Années dans le poste actuel", 0, 20, 5)
    years_since_last_promotion = st.sidebar.slider("Années depuis la dernière promotion", 0, 15, 2)
    
    if st.button("Prédire"):
        global service_started
        if not service_started:
            service = start_service()
            
        input_data = {
            "Age": [age],
            "MonthlyIncome": [monthly_income],
            "TotalWorkingYears": [total_working_years],
            "YearsInCurrentRole": [years_in_current_role],
            "YearsSinceLastPromotion": [years_since_last_promotion],
        }
        
        df = pd.DataFrame(input_data)
        json_list = json.loads(json.dumps(list(df.T.to_dict().values())))
        data = np.array(json_list)
        pred = service.predict(data)
        
        st.success("Probabilité d'attrition des employés prédite (0 - 1) : {:.2f}".format(pred[0]))
        
        # Arrêter le service après la prédiction
        if service_started:
            stop_service(service)

if __name__ == "__main__":
    main()

Ici, nous avons créé une application web streamlit, appelée “Prédiction de l’attrition des employés”, dans laquelle les utilisateurs peuvent fournir des inputs tels que l’âge, le revenu mensuel, etc., pour faire la prédiction. Lorsque l’utilisateur clique sur le bouton “Prédire”, les données d’entrée sont envoyées au modèle déployé, la prédiction est effectuée et affichée pour l’utilisateur. C’est ainsi que fonctionne notre application streamlit_app. Lorsque nous exécutons le fichier streamlit_app.py, nous obtenons une URL de réseau comme celle-ci :

En cliquant sur l’URL du réseau, nous pouvons voir l’interface utilisateur incroyable de Streamlit utilisée pour effectuer des prédictions.

Vous pouvez visualiser toutes vos piles, les composants utilisés et le nombre de pipelines exécutés dans le tableau de bord ZenML pour faciliter votre parcours MLOps.

Tableau de bord ZenML :

Piles :

Composants :

Nombre de pipelines :

Nombre de lancements :

Conclusion

Nous avons réussi à construire un projet MLOps de bout en bout pour prédire le taux d’attrition des employés. Nous avons ingéré les données, les avons nettoyées, avons entraîné le modèle, évalué le modèle, déclenché le déploiement, déployé le modèle, prédit le modèle en obtenant les nouvelles données, cherché des services de modèle existants, si présents, puis prédit les données, récupéré les inputs de l’utilisateur à partir de l’application web Streamlit et fait des prédictions, ce qui aidera le service des ressources humaines à prendre des décisions basées sur les données.

Code GitHub : https://github.com/VishalKumar-S/Employee-attrition-rate-MLOps-Project

Points clés

  • ZenML agit comme un puissant outil d’orchestration, en intégrant d’autres outils ML.
  • Le pipeline de déploiement continu fait en sorte que seuls les meilleurs modèles soient déployés, ce qui aide à prédire avec une grande précision.
  • Le caching nous aide à économiser les ressources et le logging nous aide à suivre le pipeline, à déboguer et à suivre les erreurs.
  • Les tableaux de bord nous aident à avoir une vue claire sur le flux de travail du pipeline ML.

Questions fréquemment posées

Les médias présentés dans cet article ne sont pas la propriété d’Analytics Vidhya et sont utilisés à la discrétion de l’auteur.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

AI

Réduire, optimiser maîtriser l'IA générative avec la quantification de modèle

Introduction Dans le paysage en constante évolution de l’intelligence artificielle, l’IA générative est i...

AI

Wild Wild RAG... (Partie 1)

RAG (Retrieval-Augmented Generation) est un cadre d'IA qui améliore la qualité des réponses générées par un modèle li...

AI

Exploration des équations différentielles neuronales en intelligence artificielle générative

Introduction L’IA générative a évolué de manière spectaculaire, englobant de nombreuses techniques pour créer d...

AI

Les branches sont tout ce dont vous avez besoin notre cadre de versionnement ML plein d'opinions

Une approche simple pour le versionnement des projets ML en utilisant les branches Git qui simplifie les flux de trav...

AI

Découvrez TensorRT-LLM une bibliothèque open-source qui accélère et optimise les performances d'inférence sur les derniers LLMs sur les GPU NVIDIA Tensor Core.

Les modèles linguistiques de grande envergure (LLM) d’intelligence artificielle (IA) peuvent générer du texte, ...