ZenML per veicoli elettrici dai dati alle previsioni di efficienza

ZenML per veicoli elettrici dalla raccolta dei dati alle previsioni di efficienza

Introduzione

Hai mai pensato che ci potrebbe essere un sistema in cui possiamo prevedere l’efficienza dei veicoli elettrici e che gli utenti possano utilizzare facilmente questo sistema? Nel mondo dei veicoli elettrici, possiamo prevedere l’efficienza dei veicoli elettrici con estrema precisione. Questo concetto è ora entrato nel mondo reale, siamo estremamente grati a Zenml e MLflow. In questo progetto, esploreremo in dettaglio la tecnologia e vedremo come combinare la scienza dei dati, il machine learning e MLOps crea questa tecnologia in modo magnifico, e vedrai come utilizziamo ZenML per i veicoli elettrici.

Obiettivi di Apprendimento

In questo articolo, impareremo:

  • Conoscere cos’è Zenml e come utilizzarlo in un flusso di lavoro di apprendimento automatico end-to-end.
  • Comprendere il ruolo di MLflow nella creazione di un tracker di esperimenti per i modelli di apprendimento automatico.
  • Esplorare il processo di distribuzione dei modelli di apprendimento automatico e come configurare un servizio di previsione.
  • Scoprire come creare un’app Streamlit user-friendly per interagire con le previsioni dei modelli di apprendimento automatico.

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

Comprensione dell’Efficienza dei Veicoli Elettrici

  • L’efficienza dei veicoli elettrici (EV) si riferisce a quanto efficacemente un EV può convertire l’energia elettrica dalla sua batteria in un’autonomia di guida. Di solito viene misurata in miglia per kWh (chilowattora).
  • Fattori come l’efficienza del motore e della batteria, il peso, l’aerodinamica e i carichi ausiliari influenzano l’efficienza dei VE. Quindi è chiaro che se ottimizziamo queste aree, possiamo migliorare l’efficienza del nostro veicolo elettrico. Per i consumatori, scegliere un VE con maggiore efficienza comporta un’esperienza di guida migliore.
  • In questo progetto, costruiremo un flusso di lavoro di apprendimento automatico end-to-end per prevedere l’efficienza dei veicoli elettrici utilizzando dati reali sui VE. Prevedere con precisione l’efficienza può guidare i produttori di VE nell’ottimizzazione dei progetti.
  • Useremo ZenML, un framework MLOps, per automatizzare il flusso di lavoro di addestramento, valutazione e distribuzione dei modelli di apprendimento automatico. ZenML offre funzionalità per il tracciamento dei metadati, la gestione degli artefatti e la riproducibilità dei modelli nelle fasi del ciclo di vita dell’apprendimento automatico.

Raccolta dei Dati

Per questo progetto, inizieremo a raccogliere i dati da Kaggle. Kaggle è una piattaforma online che offre molti dataset per progetti di data science e machine learning. Puoi raccogliere dati da qualsiasi fonte desideri. Raccogliendo questo dataset, possiamo effettuare le nostre previsioni sul nostro modello. Ecco il mio repository GitHub dove puoi trovare tutti i file o i modelli – https://github.com/Dhrubaraj-Roy/Predicting-Electric-Vehicle-Efficiency.git

Problema

I veicoli elettrici efficienti sono il futuro, ma prevedere con precisione la loro autonomia è molto difficile.

Soluzione

Il nostro progetto combina scienza dei dati e MLOps per creare un modello preciso per la previsione dell’efficienza dei veicoli elettrici, a beneficio dei consumatori e dei produttori.

Configurazione di un Ambiente Virtuale

Perché vogliamo configurare un Ambiente Virtuale?

Ci aiuta a rendere il nostro progetto unico e senza conflitti con altri progetti nel nostro sistema.

Creazione di un Ambiente Virtuale

  • Per Windows:
python -m venv myenv#poi per l'attivazionemyenv\Scripts\activate
  • Per Linux/macOS:
python3 -m venv myenv#poi per l'attivazionesource myenv/bin/activate

Ci aiuta a mantenere pulito il nostro ambiente.

Lavorare sul Progetto

Con il nostro ambiente pronto, dobbiamo installare Zenml. Ora, cos’è Zenml? Zenml è un framework per la gestione delle operazioni di machine learning (MLOps) per gestire flussi di lavoro di apprendimento automatico end-to-end. Abbiamo scelto Zenml per l’efficiente gestione dei flussi di lavoro di apprendimento automatico. Pertanto, è necessario installare il server Zenml.

Usa questo comando nel tuo terminale per installare il server Zenml –

 pip install ‘zenml[server]’

Questo non è tutto; dopo aver installato il server Zenml, dobbiamo creare il repository Zenml, per creare il repository Zenml –

zenml init

Perché usiamo `zenml init`: `zenml init` viene utilizzato per inizializzare un repository ZenML, creando la struttura necessaria per gestire pipeline di apprendimento automatico ed esperimenti in modo efficace.

Installazione dei requisiti

Per soddisfare le dipendenze del progetto, abbiamo utilizzato un file ‘requirements.txt’. In questo file, dovresti avere tutte queste dipendenze.

catboost==1.0.4joblib==1.1.0lightgbm==3.3.2optuna==2.10.0streamlit==1.8.1xgboost==1.5.2markupsafe==1.1.1zenml==0.35.1

Organizzazione del progetto

Quando si lavora su un progetto di data science, è importante organizzare tutto in modo adeguato. Permettimi di spiegarti come teniamo strutturato il nostro progetto:

Creazione delle cartelle

Organizziamo il nostro progetto in cartelle. Ci sono alcune cartelle che dobbiamo creare.

  •  Cartella Modello: Prima di tutto, dobbiamo creare una cartella per il modello. Contiene file essenziali per i nostri modelli di apprendimento automatico. All’interno di questa cartella, abbiamo alcuni file come ‘data_cleaning.py’, ‘evaluation.py’ e ‘model_dev.py’. Questi file sono come diversi strumenti che ci aiutano durante tutto il progetto.
  •  Cartella Steps: Questa cartella serve come centro di controllo per il nostro progetto. All’interno della cartella ‘Steps’, abbiamo file essenziali per varie fasi del nostro processo di data science. Quindi, dobbiamo creare alcuni file nella cartella ‘steps’, come Ingest_data.py. Questo file ci aiuta con l’input dei dati, come raccogliere materiali per il tuo progetto. Poi, Cleaning_data.py. È come la parte del tuo progetto in cui pulisci e prepari i materiali per il lavoro principale. Model_train.py: Questo file è dove addestriamo il nostro modello di apprendimento automatico, come modellare i materiali nel prodotto finale. Evaluation.py: Questo file evaluation.py valuta il nostro modello, dove verifichiamo come si comporta il nostro prodotto finale.

Cartella Pipeline

Qui assembliamo la nostra pipeline, simile a una linea di produzione per il tuo progetto. All’interno della cartella ‘Pipelines’, ‘Training_pipeline.py’ funge da macchina di produzione principale. In questo file, abbiamo importato ‘Ingest_data.py’ e la classe ‘ingest_df’ per preparare i dati, pulirli, addestrare il modello e valutarne le prestazioni. Per eseguire l’intero progetto, utilizza ‘run_pipeline.py’, simile a premere il pulsante di avvio sulla linea di produzione con il comando:

python run_pipeline.py

Qui puoi vedere la struttura dei file del progetto-

Questa struttura ci aiuta a eseguire il nostro progetto senza problemi, proprio come uno spazio di lavoro ben strutturato ti aiuta a creare un progetto in modo efficace.

3. Configurazione della pipeline

Source: zenml

Dopo aver organizzato il progetto e configurato la pipeline, il passo successivo è eseguire la pipeline. Ora, potresti chiederti: cos’è una pipeline? Una pipeline è un insieme di passaggi automatizzati che semplificano la distribuzione, il monitoraggio e la gestione dei modelli di apprendimento automatico dallo sviluppo alla produzione. Questo viene fatto eseguendo il comando ‘zenml up’, che funge da interruttore di accensione per la tua linea di produzione. Assicura che tutti i passaggi definiti nel progetto di data science vengano eseguiti nella sequenza corretta, avviando l’intero flusso di lavoro, dall’ingestione e pulizia dei dati all’addestramento e alla valutazione del modello.

Pulizia dei dati

Nella cartella ‘Modello’, troverai un file chiamato ‘data_cleaning’, questo file si occupa della pulizia dei dati. All’interno di questo file, scoprirai – Pulizia delle colonne: Una sezione dedicata all’individuazione e alla rimozione delle colonne non necessarie dal dataset, rendendolo più ordinato e più facile trovare ciò di cui hai bisogno. Classe DataDevideStretegy: Questa classe ci aiuta a pianificare come dividere i nostri dati in modo efficace. È come pianificare come organizzare i materiali per il progetto.

  class DataDivideStrategy(DataStrategy):    """    Strategia di divisione dei dati che divide i dati in dati di addestramento e dati di test.    """    def handle_data(self, data: pd.DataFrame) -> Union[pd.DataFrame, pd.Series]:        """        Divide i dati in dati di addestramento e dati di test.        """        try:            # Assumendo che "Efficiency" sia la tua variabile target            # Separando le caratteristiche (X) e il target (y) dal dataset            X = data.drop("Efficiency", axis=1)            y = data["Efficiency"]            # Dividere i dati in set di addestramento e di test con una divisione 80-20            X_train, X_test, y_train, y_test = train_test_split(                X, y, test_size=0.2, random_state=42            )            # Restituire i dataset divisi            return X_train, X_test, y_train, y_test        except Exception as e:            # Registra un messaggio di errore se si verifica un'eccezione            logging.error("Errore nella divisione dei dati in dati di addestramento e dati di test.".format(e))            raise e
  • Prende un dataset e lo divide in dati di addestramento e di test (divisone 80-20), restituendo i dataset divisi. Se si verificano errori durante questo processo, registra un messaggio di errore.
  • Classe DataCleaning: La classe ‘DataCleaning’ è un insieme di regole e metodi per assicurare che i nostri dati siano nella miglior forma possibile. Metodo Handle_data: Questo metodo è come uno strumento versatile che ci consente di gestire e manipolare i dati in modi diversi, assicurandoci che siano pronti per i prossimi passi del progetto.
  • La nostra classe principale è Data Cleaning, che è DataPreProcessStrategy. In questa classe, puliamo i nostri dati.

Ora passiamo alla cartella ‘Steps’. All’interno, c’è un file chiamato ‘clean_data.py’. Questo file è dedicato alla pulizia dei dati. Ecco cosa succede qui:

  • Importiamo ‘DataCleaning’, ‘DataDivideStrategy’ e ‘DataPreProcesStretegy’ da ‘data_cleaning’. È come prendere gli strumenti giusti e i materiali dalla tua cassetta degli attrezzi per continuare a lavorare sul tuo progetto in modo efficace.
import loggingfrom typing importTupleimport pandas as pdfrom model.data_cleaning import DataCleaning, DataDivideStrategy, DataPreProcessStrategyfrom zenml import stepfrom typing_extensions import Annotated@stepdefclean_df(data: pd.DataFrame) -> Tuple[    Annotated[pd.DataFrame, 'X_train'],    Annotated[pd.DataFrame, 'X_test'],    Annotated[pd.Series, 'y_train'],    Annotated[pd.Series, 'y_test'],]:    """    Classe di pulizia dei dati che preelabora i dati e li divide in dati di addestramento e di test.    Args:        data: pd.DataFrame    """    try:        preprocess_strategy = DataPreProcessStrategy()        data_cleaning = DataCleaning(data, preprocess_strategy)        preprocessed_data = data_cleaning.handle_data()        divide_strategy = DataDivideStrategy()        data_cleaning = DataCleaning(preprocessed_data, divide_strategy)        X_train, X_test, y_train, y_test = data_cleaning.handle_data()        logging.info(f"Pulizia dati completata")        return X_train, X_test, y_train, y_test     except Exception as e:         logging.error(e)        raise e
  1. Prima di tutto, importa le librerie e i moduli necessari, inclusi logging, pandas e varie strategie di pulizia dati.
  2. Il decoratore @step segna una funzione come un passo in un flusso di lavoro di apprendimento automatico. Questo passo prende un DataFrame, lo pre-elabora e lo divide in dati di addestramento e di test.
  3. In tale passo, si utilizzano strategie di pulizia e divisione dei dati, registrando il processo e restituendo i dati divisi nei tipi di dati specificati. Ad esempio, i nostri X_train e X_test sono DataFrame e y_test e y_train sono Series.

Creare un modello di regressione lineare semplice

Ora, parliamo di creazione del model_dev nella cartella modello. In questo file, lavoriamo principalmente sulla costruzione del modello di apprendimento automatico.

  • Modello di regressione lineare semplice: In questo file, creiamo un modello di regressione lineare semplice. Il nostro obiettivo principale è concentrarci su MLOps, non sulla costruzione di un modello complesso. È come costruire un prototipo di base del tuo progetto MLOps.

Questo approccio strutturato assicura che abbiamo un processo di pulizia dei dati pulito e organizzato, e lo sviluppo del nostro modello segue una chiara traccia, mantenendo l’attenzione sull’efficienza di MLOps anziché sulla costruzione di un modello intricato. In futuro, aggiorneremo il nostro modello.

import loggingfrom abc import ABC, abstractmethodimport pandas as pdfrom sklearn.linear_model import LinearRegressionfrom typing importDictimport optuna  # Importiamo la libreria optuna# Resto del tuo codice...classModel(ABC):    """    Classe astratta di base per tutti i modelli.    """    @abstractmethoddeftrain(self, X_train, y_train):        """        Addestra il modello sui dati forniti.        Args:            x_train: Dati di addestramento            y_train: Dati di target        """passclassLinearRegressionModel(Model):    """    Modello di regressione lineare che implementa l'interfaccia Model.    """deftrain(self, X_train, y_train, **kwargs):        try:            reg = LinearRegression(**kwargs)  # Crea un modello di regressione lineare            reg.fit(X_train, y_train)  # Addestra il modello ai dati di addestramento            logging.info('Addestramento completo')              # Registra un messaggio che indica l'addestramento completoreturn reg              # Restituisce il modello addestratoexcept Exception as e:            logging.error("errore nell'addestramento del modello: {}".format(e))              # Registra un messaggio di errore se si verifica un'eccezioneraise e              # Solleva l'eccezione per una gestione ulteriore

Miglioramenti in ‘model_train.py’ per lo Sviluppo del Modello

Nel file ‘model_train.py’, apportiamo diversi importanti aggiornamenti al nostro progetto:

Importazione del Modello di Regressione Lineare: Importiamo ‘LinearRegressionModel’ da ‘model.mode_dev.’ Ci ha aiutato a costruire il nostro progetto. Il nostro file ‘model_train.py’ è configurato per funzionare con questo particolare tipo di modello di machine learning.

def train_model(    X_train: pd.DataFrame,    X_test: pd.DataFrame,    y_train: pd.Series,    y_test: pd.Series,    config: ModelNameConfig,) -> RegressorMixin:    """    Addestra un modello di regressione sulla base della configurazione specificata.    Args:        X_train (pd.DataFrame): Variabili di input per l'addestramento.        X_test (pd.DataFrame): Variabili di input per il testing.        y_train (pd.Series): Target per l'addestramento.        y_test (pd.Series): Target per il testing.        config (ModelNameConfig): Configurazione del modello.    Returns:        RegressorMixin: Modello di regressione addestrato.    """    try:        model = None        # Verifica il modello specificato nella configurazione        if config.model_name == "linear_regression":            # Abilita l'autologging di MLflow            autolog()            # Crea un'istanza di LinearRegressionModel            model = LinearRegressionModel()            # Addestra il modello sui dati di addestramento            trained_model = model.train(X_train, y_train)            # Restituisce il modello addestrato            return trained_model        else:            # Solleva un errore se il nome del modello non è supportato            raise ValueError("Nome del modello non supportato")    except Exception as e:        # Registra e solleva eventuali eccezioni che si verificano durante l'addestramento del modello        logging.error(f"Errore nell'addestramento del modello: {e}")        raise e

Questo codice addestra un modello di regressione (ad esempio, regressione lineare) in base a una configurazione scelta. Controlla se il modello selezionato è supportato, utilizza MLflow per il logging, addestra il modello sui dati forniti e restituisce il modello addestrato. Se il modello scelto non è supportato, solleverà un errore.

Metodo ‘Addestra Modello’: Il file ‘model_train.py’ definisce un metodo chiamato ‘train_model’, che restituisce un ‘LinearRegressionModel’.

Importazione di RegressorMixin: Importiamo ‘RegressorMixin’ da sklearn.base. RegressorMixin è una classe in scikit-learn che fornisce un’interfaccia comune per gli stimatori di regressione. sklearn.base fa parte della libreria Scikit-Learn, uno strumento per la costruzione e il lavoro con modelli di machine learning.

Configurazione delle Impostazioni del Modello e Valutazione delle Prestazioni

Crea ‘config.py’ nella cartella ‘Steps’: Nella cartella ‘steps’, creiamo un file chiamato ‘config.py.’ Questo file contiene una classe chiamata ‘ModelNameConfig’. `ModelNameConfig` è una classe nel file ‘config.py’ che serve come guida di configurazione per il tuo modello di machine learning. Specifica varie impostazioni e opzioni per il tuo modello.

# Importa la classe necessaria da ZenML per configurare i parametri del modello
from zenml.steps import BaseParameters

# Definisci una classe chiamata ModelNameConfig che eredita da BaseParameters
class ModelNameConfig(BaseParameters):
    """
    Configurazioni del modello:
    """
    
    # Definisci attributi per la configurazione del modello con valori di default
    model_name: str = "regressione_lineare"  # Nome del modello di apprendimento automatico
    fine_tuning: bool = False  # Flag per abilitare il fine-tuning
  • Ti permette di scegliere il nome del modello e se fare il fine-tuning. Il fine-tuning è come apportare piccole correzioni a un modello di apprendimento automatico già funzionante per migliorare le prestazioni su specifici compiti.
  • Valutazione: Nella cartella ‘src’ o ‘model’, creiamo un file chiamato ‘evaluation.py’. Questo file contiene una classe astratta chiamata ‘evaluation’ e un metodo chiamato ‘calculate_score’. Questi sono gli strumenti che utilizziamo per misurare le prestazioni del nostro modello di apprendimento automatico.
  • Strategie di valutazione: Introduciamo specifiche strategie di valutazione, come l’Errore Quadrato Medio (MSE). Ogni classe di strategia contiene un metodo ‘calculate_score’ per valutare le prestazioni del modello.
  • Implementazione della Valutazione in ‘Steps’: Implementiamo queste strategie di valutazione in ‘evaluation.py’ all’interno della cartella ‘steps’. È come impostare il processo di controllo di qualità nel nostro progetto.

Quantificare le Prestazioni del Modello con il Metodo ‘Evaluate Model’

Metodo ‘Evaluate Model’: In ‘evaluation.py’ all’interno della cartella ‘steps’, creiamo un metodo chiamato ‘evaluate_model’ che restituisce metriche di prestazioni come il punteggio R-quadrato (R2) e l’Errore Quadrato Medio (RMSE).

@step(experiment_tracker=experiment_tracker.name)
def evaluate_model(
    model: RegressorMixin, 
    X_test: pd.DataFrame, 
    y_test: pd.Series
) -> Tuple[Annotated[float, "r2"], Annotated[float, "rmse"]]:
    """
    Valuta le prestazioni di un modello di apprendimento automatico utilizzando diverse metriche e registra i risultati.
    Argomenti:
        model: RegressorMixin - Il modello di apprendimento automatico da valutare.
        X_test: pd.DataFrame - I valori delle caratteristiche del set di dati di test.
        y_test: pd.Series - I valori effettivi dell'obiettivo per il set di dati di test.
    Ritorna:
        Tuple[float, float] - Una tupla contenente il punteggio R2 e l'RMSE.
    """
    try:
        # Effettua previsioni utilizzando il modello
        prediction = model.predict(X_test)
        
        # Calcola l'Errore Quadrato Medio (MSE) utilizzando la classe MSE
        mse_class = MSE()
        mse = mse_class.calculate_score(y_test, prediction)
        mlflow.log_metric("mse", mse)
        
        # Calcola il punteggio R2 utilizzando la classe R2Score
        r2_class = R2()
        r2 = r2_class.calculate_score(y_test, prediction)
        mlflow.log_metric("r2", r2)
        
        # Calcola l'Errore Quadrato Medio (RMSE) utilizzando la classe RMSE
        rmse_class = RMSE()
        rmse = rmse_class.calculate_score(y_test, prediction)
        mlflow.log_metric("rmse", rmse)
        
        return r2, rmse  # Restituisce il punteggio R2 e l'RMSE
    except Exception as e:
        logging.error("errore nella valutazione".format(e))
        raise e

Questi aggiornamenti in ‘model_train.py’, ‘config.py’ e ‘evaluation.py’ migliorano il nostro progetto introducendo l’addestramento del modello di apprendimento automatico, la configurazione e una valutazione approfondita, garantendo che il nostro progetto soddisfi elevati standard di qualità.

Eseguire la Pipeline

Successivamente, aggiorniamo il file ‘training_pipeline’ per eseguire correttamente la pipeline; ZenML è un framework MLOps open-source progettato per semplificare e standardizzare la gestione del flusso di lavoro del machine learning. Per visualizzare la pipeline, puoi utilizzare il comando ‘zenml up’.

Ora procediamo ad implementare l’Experiment Tracker e distribuire il modello:

  • Importazione di MLflow: Nel file ‘model_train.py’, importiamo ‘mlflow’. MLflow è uno strumento versatile che ci aiuta a gestire il ciclo di vita del modello di apprendimento automatico, tracciare gli esperimenti e mantenere una registrazione dettagliata di ciascun progetto.
  • Experiment Tracker: Ora, potresti avere una domanda: cos’è un Experiment Tracker? Un Experiment Tracker è un sistema per monitorare ed organizzare gli esperimenti, permettendoci di tenere traccia dei progressi del nostro progetto. Nel nostro codice, accediamo all’Experiment Tracker tramite ‘zenml.client’ e ‘mlflow’, garantendo che possiamo gestire efficacemente i nostri esperimenti. Puoi consultare il codice di model_train.py per una migliore comprensione.
  • Autologging con MLflow: Utilizziamo la funzionalità ‘autolog’ di ‘mlflow.sklearn’ per registrare automaticamente vari aspetti delle prestazioni del nostro modello di apprendimento automatico. Questo semplifica il processo di tracciamento degli esperimenti, fornendo preziose informazioni su come il nostro modello sta performando.
  • Registrazione delle Metriche: Registriamo metriche specifiche come l’Errore Quadrato Medio (MSE) utilizzando ‘mlflow.log_metric’ nel nostro file ‘evaluation.py’. Ciò ci permette di monitorare le prestazioni del modello durante il progetto.

Se stai eseguendo lo script ‘run_deployment.py’, è necessario installare alcune integrazioni utilizzando ZenML. Le integrazioni aiutano a collegare il tuo modello all’ambiente di distribuzione, dove puoi distribuire il tuo modello.

Integrazione Zenml

ZenML fornisce integrazione con strumenti MLOps. Esegui il comando seguente per installare l’integrazione di ZenML con MLflow, è un passaggio molto importante:

Per creare questa integrazione, devi utilizzare questo comando:

zenml integration install mlflow -y

Questa integrazione ci aiuta a gestire efficacemente questi esperimenti.

Monitoraggio degli esperimenti

Il monitoraggio degli esperimenti è un aspetto fondamentale di MLOps. Utilizziamo Zenml e MLflow per monitorare, registrare e gestire tutti gli aspetti dei nostri esperimenti di machine learning, facilitando l’esperimentazione efficiente e la riproducibilità.

Registrazione del tracker degli esperimenti:

zenml experiment-tracker register mlflow_tracker --flavor=mlflow

Registrazione del deployer del modello:

zenml model-deployer register mlflow --flavor=mlflow

Stack:

 zenml stack register mlflow_stack -a default -o default -d mlflow -e mlflow_tracker --set

Deploy

La distribuzione è il passaggio finale nel nostro pipeline ed è una parte essenziale del nostro progetto. Il nostro obiettivo non è solo costruire il modello, vogliamo che il nostro modello venga distribuito su internet in modo che gli utenti possano utilizzarlo.

Configurazione della pipeline di distribuzione: Hai una pipeline di distribuzione definita in un file Python chiamato ‘deployment_pipeline.py’. Questa pipeline gestisce le attività di distribuzione.

Trigger di distribuzione: C’è un passo chiamato ‘deployment_trigger’

class DeploymentTriggerConfig(BaseParameters):    min_accuracy = 0 @step(enable_cache=False)def dynamic_importer() -> str:    """Scarica i dati più recenti da un API fittizio."""    data = get_data_for_test()    return data

Questo codice definisce una classe `DeploymentTriggerConfig` con un parametro di accuratezza minima. In questo caso, è zero. Definisce anche un passo della pipeline, dynamic_importer, che scarica i dati da un API fittizio, con la memorizzazione nella cache disabilitata per questo passo.

Caricamento del servizio di previsione

Il passo ‘prediction_service_loader’ recupera il servizio di previsione avviato dalla pipeline di distribuzione. È utilizzato per gestire e interagire con il modello distribuito.

def prediction_service_loader(        pipeline_name: str,    pipeline_step_name: str,    running: bool = True,    model_name: str = "model",) -> MLFlowDeploymentService:    """Ottieni il servizio di previsione avviato dalla pipeline di distribuzione.    Args:        pipeline_name: nome della pipeline che ha distribuito il server di previsione MLflow        step_name: il nome del passo che ha distribuito il server di previsione MLflow        running: quando questo flag è impostato, il passo restituisce solo un servizio in esecuzione        model_name: il nome del modello distribuito    """    # ottieni il componente stack del deployer del modello MLflow         mlflow_model_deployer_component = MLFlowModelDeployer.get_active_model_deployer()        # recupera i servizi esistenti con lo stesso nome di pipeline, nome di passo e nome di modello    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 previsione MLflow distribuito dal passo "            f"{pipeline_step_name} nella pipeline {pipeline_name} "            f"per il modello '{model_name}' è attualmente in esecuzione."        )    return existing_services[0]

Questo codice definisce una funzione `prediction_service_loader` che recupera un servizio di previsione avviato da una pipeline di distribuzione.

  • Prende in input il nome della pipeline, il nome del passo e il nome del modello.
  • La funzione controlla se esistono servizi corrispondenti a questi parametri e restituisce il primo servizio trovato. Se non vengono trovati, solleverà un errore.

Predictor

Il passaggio dei ‘predittori’ esegue richieste di inferenza sul servizio di previsione. Elabora i dati in ingresso e restituisce le previsioni.

@stepdef predictor(    service: MLFlowDeploymentService,    data: str,) -> np.ndarray:    """Esegui una richiesta di inferenza su un servizio di previsione"""    service.start(timeout=10)  # dovrebbe essere un NOP se già avviato    data = json.loads(data) # Analizza i dati di input da una stringa JSON in un dizionario Python.    data.pop("columns")    data.pop("index")    columns_for_df = [   # Definisci una lista di nomi di colonne per creare un DataFrame.        "Acceleration",        "TopSpeed",        "Range",        "FastChargeSpeed",        "PriceinUK",        "PriceinGermany",    ]    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) # Converti la lista JSON in un array NumPy.    prediction = service.predict(data)    return prediction
  • Codice che definisce una funzione chiamata ‘predictor’ utilizzata per effettuare previsioni con un modello di ML implementato tramite MLFlow. Avvia il servizio, elabora i dati di input in un formato JSON, li converte in un array NumPy e restituisce le previsioni del modello. La funzione opera su dati con caratteristiche specifiche relative a un veicolo elettrico.

Esecuzione del deployment: Hai uno script, ‘run_deployment.py’, che ti consente di avviare il processo di deployment. Questo script accetta il parametro ‘–config’. Il parametro ‘–config’ viene utilizzato per specificare un file di configurazione o impostazioni per un programma tramite la linea di comando, che può essere impostato su ‘deploy’ per distribuire il modello, ‘predict’ per eseguire previsioni o ‘deploy_and_predict’ per entrambi.

Stato del deployment e interazione: Lo script fornisce anche informazioni sullo stato del server di previsione MLflow, inclusi come avviarlo e arrestarlo. Utilizza MLFlow per il deployment del modello.

Soglia minima di accuratezza: Il parametro ‘min_accuracy’ può essere specificato per impostare una soglia minima di accuratezza per il deployment del modello. Se tale valore viene soddisfatto, il modello verrà distribuito.

Configurazione di Docker: Docker viene utilizzato per gestire l’ambiente di deployment e hai definito impostazioni Docker nel tuo processo di deployment.

Questo processo di deployment sembra essere incentrato sulla distribuzione di modelli di apprendimento automatico ed esecuzione di previsioni in modo controllato e configurabile.

  • Il deployment del nostro modello è semplice come eseguire lo script ‘run_deployment.py’. Utilizza questo:
 python3 run_deployment.py --config deploy

Previsione

Una volta che il nostro modello è stato distribuito, è pronto per le previsioni.

  • Esegui le previsioni: Esegui previsioni utilizzando il seguente comando:
 python3 run_deployment.py --config predict

App Streamlit

L’app Streamlit fornisce un’interfaccia user-friendly per interagire con le previsioni del nostro modello. Streamlit semplifica la creazione di applicazioni web interattive basate su dati scientifici, rendendo facile per gli utenti esplorare e comprendere le previsioni del modello. Di nuovo, puoi trovare il codice su GitHub per l’app Streamlit.

  • Avvia l’app Streamlit con il seguente comando: streamlit run streamlit_app.py

In questo modo, puoi esplorare e interagire con le previsioni del nostro modello.

  • L’app Streamlit rende le previsioni del nostro modello user-friendly e accessibili online; gli utenti possono interagire facilmente e comprendere i risultati. Qui puoi vedere l’immagine di come appare l’app Streamlit sul web:

Conclusione

In questo articolo, ci siamo addentrati in un progetto emozionante che dimostra il potere di MLOps nella previsione dell’efficienza dei veicoli elettrici. Abbiamo appreso di Zenml e MLFlow, che sono fondamentali nella creazione di un flusso di lavoro di machine learning end-to-end. Abbiamo esplorato anche il processo di raccolta dati, la definizione del problema e la soluzione per prevedere in modo accurato l’efficienza dei veicoli elettrici.

Questo progetto evidenzia l’importanza dei veicoli elettrici efficienti e come MLOps possa essere sfruttato per creare modelli precisi per la previsione dell’efficienza. Abbiamo coperto passi essenziali, tra cui l’installazione di un ambiente virtuale, lo sviluppo del modello, la configurazione delle impostazioni del modello e la valutazione delle prestazioni del modello. L’articolo conclude sottolineando l’importanza del tracciamento degli esperimenti, del deployment e dell’interazione degli utenti tramite un’app Streamlit. Con questo progetto, siamo un passo più vicini nel plasmare il futuro dei veicoli elettrici.

Punti chiave

  • Integrazione senza soluzione di continuità: Il progetto “End-to-End Predicting Electric Vehicle Efficiency Pipeline with Zenml” rappresenta un esempio di integrazione senza soluzione di continuità della raccolta dati, addestramento del modello, valutazione e distribuzione. Sottolinea l’immenso potenziale di MLOps nel ridisegnare l’industria dei veicoli elettrici.
  • Progetto GitHub: Per ulteriori esplorazioni, è possibile accedere al progetto su GitHub: Progetto GitHub.
  • Corso MLOps: Per approfondire la comprensione di MLOps, consigliamo di seguire il nostro corso completo: Corso MLOps.
  • Questo progetto illustra il potenziale di MLOps nel ridisegnare l’industria dei veicoli elettrici, fornendo preziose intuizioni e contribuendo a un futuro più verde.

Domande frequenti

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