Previsione del tasso di attrito dei dipendenti utilizzando ZenML e Streamlit

Previsione del tasso di attrito dei dipendenti con ZenML e Streamlit

Introduzione

Stai lavorando come HR? Hai difficoltà a prevedere se i dipendenti del tuo team continueranno a lavorare o se stanno considerando di lasciare l’organizzazione. Non preoccuparti! Non devi essere un astrologo per prevederlo, utilizzando il potere della Data Science possiamo prevederlo con precisione. Iniziamo il nostro meraviglioso viaggio sul tasso di attrizione dei dipendenti con un semplice, ma potente strumento MLOps chiamato ZenML e streamlit. Iniziamo il nostro viaggio.

Obiettivi di Apprendimento

In questo articolo impareremo:

Cosa è ZenML? Perché e come usarlo?
Perché usare MLflow e come integrarlo con ZenML?
La necessità di utilizzare un pipeline di sviluppo
Implementazione del progetto di tasso di attrizione dei dipendenti e fare previsioni

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

Implementazione del Progetto

Enunciato del Problema: Prevedere se un dipendente lascerà un’organizzazione o meno basandosi su diversi fattori come l’età, il reddito, le prestazioni, ecc.

Soluzione: Costruire un modello di regressione logistica per prevedere il tasso di attrizione di un dipendente

Dataset: IBM HR Analytics Employee Attrition & Performance

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

Prima di vedere l’implementazione del nostro progetto, vediamo prima perché stiamo usando ZenML.

Perché ZenML?

ZenML è uno strumento di orchestrazione MLOps semplice e potente utilizzato per creare pipeline di ML, memorizzare i passaggi della pipeline nella cache e salvare le risorse computazionali. ZenML offre anche l’integrazione con diverse strumenti di ML, rendendolo uno dei migliori strumenti per creare pipeline di ML. Possiamo tracciare i passaggi del nostro modello, le metriche di valutazione, possiamo visualizzare le nostre pipeline in modo visuale nei dashboard e molto altro.

In questo progetto, implementeremo una pipeline tradizionale che utilizza ZenML e integreremo mlflow con zenml per il tracciamento degli esperimenti. Implementeremo anche una pipeline di rilascio continuo utilizzando l’integrazione di MLflow con ZenML, che ingesta e pulisce i dati, addestra il modello e ridistribuisce il modello quando la previsione soddisfa alcuni criteri minimi di valutazione. Con questa pipeline possiamo assicurarci che se un nuovo modello ha prestazioni migliori rispetto al valore di previsione soglia del modello precedente, il server di distribuzione MLFlow verrà aggiornato con il nuovo modello anziché il vecchio modello.

Termini Comuni di ZenML

Pipelines: Sequenza di passaggi nel nostro progetto.
Componenti: Blocchi di costruzione o funzioni particolari nella nostra pipeline MLOps.
Stacks: Raccolta di componenti in locale/cloud.
Artifacts: Dati di input e output di un passaggio nel nostro progetto, che vengono archiviati nell’archivio degli artifacts.
Archivio degli Artifacts: Spazio di archiviazione per la memorizzazione e il tracciamento delle versioni dei nostri artifacts.
Materializers: Componenti che definiscono come vengono archiviati e recuperati gli artifacts dall’archivio degli artifacts.
Flavors: Soluzioni per strumenti specifici e casi d’uso specifici.
ZenML Server: Distribuzione per l’esecuzione dei componenti dello stack in remoto.

Prerequisiti e Comandi di base di ZenML

Python 3.7 o versione successiva: Ottienilo da qui: https://www.python.org/downloads/

Attiva il tuo Ambiente Virtuale:

#crea un ambiente virtualepython3 -m venv venv#Attiva il tuo ambiente virtuale nelle cartelle del tuo progettosource venv/bin/activate

Comandi ZenML:

Tutti i comandi base di ZenML con le sue funzionalità sono dati di seguito:

#Installa zenmlpip install zenml#per lanciare il server e il pannello di controllo zenml localmentepip install "zenml[server]"#per visualizzare la Versione zenml:zenml version#Per inizializzare un nuovo repositoryzenml init#per eseguire il pannello di controllo zenml localmente:zenml up#per conoscere lo stato delle nostre Pipeline zenmlzenml show

Questi comandi sono necessari per lavorare con ZenML.

Integrazione di MLflow con ZenML

Stiamo utilizzando mlflow come tracciatore sperimentale, per tracciare il nostro modello, artefatti, valori dell’iperparametro. Registriamo il componente stack, il tracciatore di esperimenti, il model-deployer qui:

#Integrate mlflow with ZenMLzenml integration install mlflow -y#Registra il tracciatore di esperimentizenml experiment-tracker register mlflow_tracker_employee --flavor=mlflow#Registrazione del modello deployerzenml model-deployer register mlflow_employee --flavor=mlflow#Registrazione dello stackzenml stack register mlflow_stack_employee -a default -o default -d mlflow_employee -e mlflow_tracker_employee --set

Elenco dello Stack Zenml

Struttura del Progetto

employee-attrition-prediction/          # Directory del progetto├── data/                               │   └── HR-Employee-Attrition.csv       # File del dataset│├── pipelines/                          │   ├── deployment_pipeline.py          # Pipeline di distribuzione│   ├── training_pipeline.py            # Pipeline di addestramento│   └── utils.py                        │├── src/                                # Codice sorgente │   ├── data_cleaning.py                # Pulizia dei dati e preelaborazione│   ├── evaluation.py                   # Valutazione del modello│   └── model_dev.py                    # Sviluppo del modello│                 ├── steps/                              # file di codice per i passaggi ZenML│   ├── ingest_data.py                  # Ingestione dei dati│   ├── clean_data.py                   # Pulizia dei dati e preelaborazione│   ├── model_train.py                  # Addestramento del modello    │   ├── evaluation.py                   # Valutazione del modello│   └── config.py                       │├── streamlit_app.py                    # Applicazione web di Streamlit│├── run_deployment.py                   # Codice per eseguire la pipeline di distribuzione e predizione├── run_pipeline.py                     # Codice per eseguire la pipeline di addestramento│├── requirements.txt                    # Elenco dei pacchetti richiesti dal progetto├── README.md                           # Documentazione del progetto└── .zen/                               # Directory ZenML (creata automaticamente dopo l'inizializzazione di ZenML)

Ingestione dei Dati

Prima di tutto importiamo i dati dal dataset di HR-Employee-Attrition-Rate dalla cartella dei dati.

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 è un decoratore, utilizzato per rendere la funzione ingest_data() come step della pipeline.

Analisi Esplorativa dei Dati

#Comprensione dei dati df.inf0()# Visualizza l'aspetto dei dati df.describe()#Controlla i dati di esempio df.head()#Controlla i valori null df.isnull().sum()#Controlla la percentuale di persone che sono rimaste e che hanno lasciato l'azienda:df['Attrition'].value_counts()df_left = df[df['Attrition'] == "Yes"]df_stayed = df[df['Attrition'] == "No"]left_percentage=df_left.shape[0]*100/df.shape[0]stayed_percentage=df_stayed.shape[0]*100/df.shape[0]print(f"La percentuale di persone che hanno lasciato l'azienda è:{left_percentage}")print(f"La percentuale di persone che sono rimaste nell'azienda è:{stayed_percentage}")#Analizza le differenze nelle caratteristiche tra le persone che sono rimaste e quelle che hanno lasciato l'azienda df_left.describe()df_stayed.describe()

Output

Osservazioni

I dipendenti che hanno lasciato il lavoro hanno lavorato per meno anni in azienda.
I dipendenti che hanno lasciato l’azienda erano più giovani rispetto ai dipendenti che sono rimasti.
I dipendenti che hanno lasciato hanno l’ufficio a una distanza maggiore da casa rispetto a quelli che sono rimasti.

Pulizia e Elaborazione dei Dati

Pulizia dei Dati: Abbiamo rimosso le colonne indesiderate nel dataset come: “EmployeeCount”, “EmployeeNumber”, “StandardHours”, poi abbiamo cambiato le caratteristiche che hanno solo valori di dati tra Sì (o) No in binario 1 (o) 0.
Encoding One Hot: Successivamente, abbiamo eseguito l’encoding one-hot sulle colonne categoriche come ‘BusinessTravel’, ‘Department’, ‘EducationField’, ‘Gender’, ‘JobRole’, ‘MaritalStatus’.

import pandas as pdclass DataPreProcessStrategy(DataStrategy):    def __init__(self, encoder=None):        self.encoder = encoder    """Questa classe viene utilizzata per preprocessare il dataset fornito"""    def handle_data(self, data: pd.DataFrame) -> pd.DataFrame:        try:            print("Nomi delle colonne prima della pre-elaborazione:", data.columns)  # Aggiungi questa riga            data = data.drop(["EmployeeCount", "EmployeeNumber", "StandardHours"], axis=1)            if 'Attrition' in data.columns:                print("Colonna Attrition trovata nei dati.")            else:                print("Colonna Attrition non trovata nei dati.")            data["Attrition"] = data["Attrition"].apply(lambda x: 1 if x == "Yes" else 0)            data["Over18"] = data["Over18"].apply(lambda x: 1 if x == "Yes" else 0)            data["OverTime"] = data["OverTime"].apply(lambda x: 1 if x == "Yes" else 0)            # Estrarre variabili categoriche            cat = data[['BusinessTravel', 'Department', 'EducationField', 'Gender', 'JobRole', 'MaritalStatus']]            # Esegui l'encoding one-hot sulle variabili categoriche            onehot = OneHotEncoder()            cat_encoded = onehot.fit_transform(cat).toarray()                                    # Convertire cat_encoded in DataFrame            cat_df = pd.DataFrame(cat_encoded)            # Estrarre variabili numeriche            numerical = data[['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']]            # Concatenare cat_df e numerical            data = pd.concat([cat_df, numerical], axis=1)            print("Nomi delle colonne dopo la pre-elaborazione:", data.columns)  # Aggiungi questa riga            print("Dati pre-elaborati:")            print(data.head())            return data        except Exception as e:            logging.error(f"Errore nella pre-elaborazione dei dati: {e}")            raise e

Output

I dati si presentano così, dopo che tutte le operazioni di pulizia e di elaborazione dei dati sono state completate: alla fine, nell’immagine si può vedere che i dati sono composti solo da dati numerici dopo che la codifica è stata completata.

Divisione dei dati

Successivamente divideremo i dataset di addestramento e di test nel rapporto 80:20.

from sklearn.model_selection import train_test_splitclass StrategiaDiDivisioneDeiDati(StrategiaDeiDati):    def gestisci_dati(self, dati: pd.DataFrame) -> Union[pd.DataFrame, pd.Series]:        try:            # Verificare se 'Attrition' è presente nei dati            if 'Attrition' in dati.columns:                X = dati.drop(['Attrition'], axis=1)                Y = dati['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("Colonna 'Attrition' non trovata nei dati.")        except Exception as e:            logging.error(f"Errore nella gestione dei dati: {str(e)}")            raise e

Addestramento del modello

Poiché è un problema di classificazione, qui utilizziamo la regressione logistica, ma possiamo anche utilizzare algoritmi di classificazione come Random Forest Classifier, Gradient Boosting, ecc.

from zenml import pipeline@training_pipelinedef training_pipeline(percorsi_dati: str):    df = intrada_dati(percorsi_dati)    X_train, X_test, y_train, y_test = pulisci_e_dividi_dati(df)    model = definisci_modello()  # Definisci il tuo modello di apprendimento automatico    modello_addestrato = addestra_modello(modello, X_train, y_train)    metriche_valutazione = valuta_modello(modello_addestrato, X_test, y_test)

Qui, il decoratore @training_pipeline viene utilizzato per definire la funzione training_pipeline() come un pipeline in ZenML.

Valutazione

Per i problemi di classificazione binaria, utilizziamo metriche di valutazione come: accuratezza, precisione, punteggio F1, curva ROC-AUC, ecc. Importiamo classification_report dalla libreria scikit-learn per calcolare le metriche di valutazione e restituirne il report di classificazione. Codice:

import loggingimport numpy as npfrom sklearn.metrics import classification_reportclass ClassificationReport:    @staticmethod    def calcola_punteggi(y_veri: np.ndarray, y_pred: np.ndarray):        try:            logging.info("Calcola il report di classificazione")            report = classification_report(y_veri, y_pred, output_dict=True)            logging.info(f"Report di classificazione:\n{report}")            return report        except Exception as e:            logging.error(f"Errore nel calcolo del report di classificazione: {e}")            raise e

Report di classificazione:

Per visualizzare la dashboard di training_pipeline, è necessario eseguire 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")

che restituirà l’URL della dashboard di monitoraggio, che appare come segue: “URL della dashboard: http://127.0.0.1:8237/workspaces/default/pipelines/6e7941f4-cf74-4e30-b3e3-ff4428b823d2/runs/2274fc18-aba1-4536-aaee-9d2ed7d26323/dag“. Puoi fare clic sull’URL e visualizzare la tua fantastica pipeline di addestramento nella dashboard di ZenML. Qui, l’intera immagine della pipeline viene divisa in diverse parti per vederla più chiaramente in dettaglio.

Complessivamente, il training_pipeline appare così nel dashboard, come mostrato di seguito:

Implementazione del modello

Trigger di implementazione

class ConfigurazioneTriggerImp(BaseParameters):    min_accuracy: float = 0.5

In questa classe ConfigurazioneTriggerImp, impostiamo un parametro di accuratezza minima, che specifica quale dovrebbe essere la nostra accuratezza minima del modello.

Configurazione del trigger di implementazione

@step(enable_cache=False)def trigger_implementazione(    accuratezza: float,    config: ConfigurazioneTriggerImp,):    return accuratezza > config.min_accuracy

Qui, questa funzione trigger_implementazione() viene utilizzata per implementare il modello solo quando supera l’accuratezza minima. Nel prossimo paragrafo, parleremo del motivo per cui abbiamo utilizzato la caching qui.

Pipeline continua di implementazione

@pipeline(enable_cache=False, settings={"docker":docker_settings})def pipeline_continua_implementazione(   percorso_dati: str,   #percorso_dati="C:/Users/user/Desktop/machine learning/Project/zenml Pipeline/Customer_Satisfaction_project/data/olist_customers_dataset.csv",   accuratezza_minima:float=0.0,   workers: int=1,   timeout: int=DEFAULT_SERVICE_START_STOP_TIMEOUT,):       df=acquisisci_dati()   # Pulisci i dati e suddividili in set di addestramento/test   X_train,X_test,Y_train,Y_test=pulisci_df(df)   modello=addestra_modello(X_train,X_test,Y_train,Y_test)   metriche_valutazione=valuta_modello(modello,X_test,Y_test)   decisione_implementazione=trigger_implementazione(metriche_valutazione)       mlflow_step_deployer(      modello=modello,      decisione_implementazione=decisione_implementazione,      workers=workers,      timeout=timeout,    )

In questa pipeline_continua_implementazione(), acquisiamo i dati, puliamo i dati, addestriamo il nostro modello, lo valutiamo e lo implementiamo solo se supera la condizione del trigger_implementazione(), in modo da garantire che il nuovo modello che stiamo per implementare venga eseguito solo se la sua accuratezza di previsione supera l’accuratezza di previsione del modello precedente, ovvero il valore soglia. Questo è come funziona la pipeline_continua_implementazione().

Caching fa riferimento alla memorizzazione dell’output dei passaggi eseguiti in precedenza nella pipeline. Gli output vengono memorizzati nell’archivio degli artifact. Utilizziamo la caché nel parametro della pipeline per indicare che non ci sono modifiche nei risultati delle esecuzioni precedenti e nell’esecuzione corrente, in modo che zenML riutilizzi l’output dell’esecuzione precedente. L’abilitazione della caché velocizza il processo di esecuzione della pipeline e salva le risorse computazionali. Tuttavia, a volte, in situazioni in cui dobbiamo eseguire pipeline in cui ci saranno modifiche dinamiche nei dati di input, nei parametri e nell’output, come nel caso della nostra pipeline_continua_implementazione(), è bene disabilitare la caché. Quindi, qui è stato scritto enable_cache=False.

Pipeline di inferenza

Utilizziamo la pipeline di inferenza per effettuare previsioni sui nuovi dati, in base al modello implementato. Vediamo come abbiamo utilizzato questa pipeline nel nostro progetto.

pipeline_inferenza()

@pipeline(enable_cache=False,settings={"docker":docker_settings})def pipeline_inferenza(nome_pipeline: str, nome_passaggio_pipeline:str):   dati=importatore_dinamico()   #print("Forma dei dati per l'inferenza:", dati.shape)  # Stampa la forma dei dati per l'inferenza   servizio=caricatore_servizio_previsione(      nome_pipeline=nome_pipeline,      nome_passaggio_pipeline=nome_passaggio_pipeline,      esecuzione=False,      )   previsione=previsione(servizio=servizio,dati=dati)   return previsione

Qui, la funzione inference_pipeline() funziona nell’ordine seguente:

dynamic_importer()– Prima, la funzione dynamic_importer() carica i nuovi dati e li prepara.
prediction_service_loader()– La funzione prediction_service_loader() carica il modello implementato, in base ai parametri nome del pipeline e nome del passaggio.
predictor()– Successivamente, predictor() viene utilizzata per prevedere i nuovi dati basandosi sul modello implementato.

Vediamo ora ciascuna di queste funzioni nel dettaglio:

dynamic_importer()

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

In questa funzione, viene richiamata get_data_for_test() nel file utils.py, che carica i nuovi dati, li elabora e restituisce i dati stessi.

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"Nessun servizio di implementazione di MLFlow trovato per il pipeline {pipeline_name}, il passaggio {pipeline_step_name}, il modello {model_name} e il pipeline per il modello {model_name} in esecuzione al momento"      )

In questa funzione prediction_service_loader () viene caricato il servizio di implementazione in base al modello implementato e ai parametri specificati. Un servizio di implementazione è un ambiente di runtime in cui il modello implementato è pronto ad accettare richieste di inferenza per effettuare previsioni sui nuovi dati. La riga existing_services=mlflow_model_deployer_component.find_model_server() cerca eventuali servizi di implementazione esistenti disponibili in base ai parametri specificati, come nome della pipeline e nome del passaggio della pipeline. Se non ci sono servizi di implementazione esistenti significa che la pipeline di implementazione non è ancora stata eseguita o ci sono problemi con la pipeline di implementazione, quindi viene generato un Runtime Error.

predictor()

@stepdef predictor(    service: MLFlowDeploymentService,    data: str,) -> np.ndarray:        """Esegue una richiesta di inferenza su un servizio di previsione"""    service.start(timeout=21)  # dovrebbe essere una NOP se già avviato    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,"Età","RetribuzioneGiornaliera","DistanzaDaCasa","Istruzione","SoddisfazioneAmbiente","RetribuzioneOraria","CoinvolgimentoLavorativo","LivelloLavoro","SoddisfazioneLavoro","RedditoMensile","RetribuzioneMensile","NumeroAziendeLavorate","Sopra18","Straordinari","AumentoPercentualeRetribuzione","ValutazionePerformance","SoddisfazioneRelazione","LivelloOpzioniAzionarie","AnniLavoroComplessivi","NumeroCorsiAnnoPrecedente","EquilibrioVitaLavoro","AnniNellAzienda","AnniNelRuoloAttuale","AnniUltimaPromozione","AnniConManagerAttuale",    ]    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

Dopo aver ottenuto il modello implementato e i nuovi dati, possiamo utilizzare la funzione predictor() per effettuare le previsioni.

Per avere una visualizzazione continua della pipeline di implementazione e di inferenza, è necessario eseguire il file run_deployment.py, dove verranno definite le configurazioni per l’implementazione e la previsione.

@click.option(    "--config",    type=click.Choice([DEPLOY, PREDICT, DEPLOY_AND_PREDICT]),    default=DEPLOY_AND_PREDICT,    help="Opzionalmente è possibile scegliere di eseguire solo la pipeline di implementazione per addestrare e implementare un modello ('deploy'), o solo una previsione sul modello implementato ('predict'). Per impostazione predefinita, entrambi verranno eseguiti ('deploy_and_predict').",)

Qui possiamo eseguire sia il flusso di lavoro continuo che il flusso di lavoro di inferenza, seguendo questi comandi,

# Il flusso di lavoro continuo
python run_deployment.py
 
# Per visualizzare il flusso di lavoro di inferenza (cioè effettuare il deploy e la previsione)
python run_deployment.py --config predict

Dopo aver eseguito i comandi, puoi vedere l’URL del cruscotto di zenML, come segue:

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

Goditi le visualizzazioni del tuo flusso di lavoro nel cruscotto:

Flusso di lavoro continuo

Il flusso di lavoro continuo (dall’acquisizione dei dati all’aspetto del flusso di lavoro di mlflow_model_deployer_step), ha questo aspetto:

Flusso di lavoro di inferenza

Costruzione di un’applicazione Streamlit

Streamlit è un incredibile framework open-source basato su Python, utilizzato per creare UI, possiamo utilizzare Streamlit per creare rapidamente app web, senza dover conoscere lo sviluppo backend o frontend. Per prima cosa, dobbiamo installare Streamlit nel nostro PC. I comandi per installare ed eseguire il server web locale di Streamlit nel nostro sistema locale sono i seguenti:

# Installa Streamlit nel nostro PC locale
pip install streamlit
 
# Per eseguire il server web locale di Streamlit
streamlit run streamlit_app.py

Codice:

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
 
# Definisci una variabile globale per tenere traccia dello stato del servizio
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)  # Avvia il servizio
    service_started = True
    return service
 
def stop_service(service):
    global service_started
    service.stop()  # Arresta il servizio
    service_started = False
 
def main():
    st.title("Predizione Abbandono Dipendenti")
    
    age = st.sidebar.slider("Età", 18, 65, 30)
    monthly_income = st.sidebar.slider("Reddito mensile", 0, 20000, 5000)
    total_working_years = st.sidebar.slider("Anni totali di lavoro", 0, 40, 10)
    years_in_current_role = st.sidebar.slider("Anni nel ruolo attuale", 0, 20, 5)
    years_since_last_promotion = st.sidebar.slider("Anni dall'ultima promozione", 0, 15, 2)
    
    if st.button("Prevedi"):
        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à di abbandono dipendenti prevista (0 - 1): {:.2f}".format(pred[0]))
        
        # Arresta il servizio dopo la previsione
        if service_started:
            stop_service(service)
 
if __name__ == "__main__":
    main()

Qui abbiamo creato un’app web streamlit, chiamata “Previsione dell’abbandono dei dipendenti”, in cui gli utenti possono inserire dati come l’età, il reddito mensile, ecc., per effettuare la previsione. Quando l’utente clicca il pulsante “Prevedi”, i dati inseriti vengono inviati al modello implementato, la previsione viene fatta e mostrata all’utente. Questo è come funziona la nostra app streamlit. Quando eseguiamo il file streamlit_app.py, otteniamo l’URL di rete come questo,

Cliccando l’URL di rete, possiamo vedere l’incredibile interfaccia utente di Streamlit, utilizzata per effettuare previsioni.

Puoi visualizzare tutti i tuoi stack, componenti utilizzati, il numero di pipeline eseguite nel pannello di controllo di ZenML per rendere il tuo percorso di MLOps più facile.

Pannello di controllo di ZenML:

Stack:

Componenti:

Numero di pipeline:

Numero di esecuzioni:

Conclusione

Abbiamo costruito con successo un progetto MLOps di previsione del tasso di attrizione dei dipendenti dall’inizio alla fine. Abbiamo acquisito i dati, li abbiamo puliti, addestrato il modello, valutato il modello, avviato la distribuzione, distribuito il modello, previsto il modello ottenendo nuovi dati, cercato servizi di modello esistenti e, se presenti, previsto i dati, ottenuto gli input dell’utente dall’app web Streamlit e fatto previsioni, il che aiuterà il dipartimento delle risorse umane a prendere decisioni basate sui dati.

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

Punti chiave

ZenML agisce come uno strumento di orchestratura potente, con l’integrazione di altri strumenti di ML.
Il flusso di lavoro di distribuzione continua si assicura che solo i migliori modelli vengano distribuiti, aiutando a prevedere con alta precisione.
La memorizzazione nella cache ci aiuta a risparmiare risorse e la registrazione ci aiuta a tracciare la pipeline, facilitando il debug e il tracciamento degli errori.
I pannelli di controllo ci aiutano a avere una visione chiara del flusso di lavoro della pipeline di ML.

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e sono utilizzati a discrezione dell’autore.

attrition,blogathon,caching,Dashboard,Deployment,ML,MLflow,Prediction,project