ZenML para Vehículos Eléctricos De los datos a las predicciones de eficiencia

ZenML para Vehículos Eléctricos De los datos a las predicciones de eficiencia

Introducción

¿Alguna vez has pensado que existiría un sistema en el que pudiéramos predecir la eficiencia de los vehículos eléctricos y que los usuarios puedan utilizar ese sistema fácilmente? En el mundo de los vehículos eléctricos, podemos predecir la eficiencia de los vehículos eléctricos con una precisión extrema. Este concepto ahora se ha convertido en realidad, estamos extremadamente agradecidos por Zenml y MLflow. En este proyecto, exploraremos la inmersión técnica en profundidad y veremos cómo combinar la ciencia de datos, el aprendizaje automático y MLOps crea esta tecnología de manera hermosa, y verás cómo utilizamos ZenML para vehículos eléctricos.

Objetivos de aprendizaje

En este artículo, aprenderemos:

• Aprender qué es Zenml y cómo se utiliza en una tubería de aprendizaje automático de principio a fin.
• Comprender el papel de MLFlow en la creación de un rastreador de experimentos para modelos de aprendizaje automático.
• Explorar el proceso de implementación de modelos de aprendizaje automático y cómo configurar un servicio de predicción.
• Descubrir cómo crear una aplicación Streamlit fácil de usar para interactuar con las predicciones del modelo de aprendizaje automático.

Este artículo se publicó como parte del Blogatón de Ciencia de Datos.

• ¿Vale la pena la inteligencia artificial generativa considerando su huella ambiental?
• ChatGPT Plus Desata Emocionantes Nuevas Funciones para Entusiastas de los Datos
• Investigadores de Stanford y UT Austin proponen Aprendizaje de Preferencia Contrastiva (APC) un método sencillo de Aprendizaje por Reforzamiento (RL) que no necesita RL y funciona con MDPs arbitrarios y datos fuera de política.

Comprendiendo la eficiencia de los vehículos eléctricos

• La eficiencia de los vehículos eléctricos (VE) se refiere a cómo un VE puede convertir eficientemente la energía eléctrica de su batería en autonomía de conducción. Normalmente se mide en millas por kWh (kilovatio hora).
• Factores como la eficiencia del motor y la batería, el peso, la aerodinámica y las cargas auxiliares afectan la eficiencia de los VE. Por lo tanto, está claro que si optimizamos esas áreas, podemos mejorar la eficiencia de nuestros VE. Para los consumidores, elegir un VE con mayor eficiencia resulta en una mejor experiencia de conducción.
• En este proyecto, construiremos una tubería de aprendizaje automático de principio a fin para predecir la eficiencia de los vehículos eléctricos utilizando datos reales de VE del mundo real. Predecir la eficiencia de manera precisa puede guiar a los fabricantes de VE en la optimización de los diseños.
• Utilizaremos ZenML, un marco de trabajo de MLOps, para automatizar el flujo de trabajo de entrenamiento, evaluación e implementación de modelos de aprendizaje automático. ZenML ofrece capacidades de seguimiento de metadatos, gestión de artefactos y reproducibilidad de modelos en todas las etapas del ciclo de vida de ML.

Recopilación de datos

Para este proyecto, comenzaremos a recopilar los datos de Kaggle. Kaggle es una plataforma en línea que ofrece muchos conjuntos de datos para proyectos de ciencia de datos y aprendizaje automático. Puedes recopilar datos de cualquier lugar que desee. Al recopilar este conjunto de datos, podemos realizar nuestra predicción en nuestro modelo. Aquí está mi repositorio de GitHub donde puedes encontrar todos los archivos o plantillas: https://github.com/Dhrubaraj-Roy/Predicting-Electric-Vehicle-Efficiency.git

Declaración del problema

Los vehículos eléctricos eficientes son el futuro, pero predecir su autonomía de manera precisa es muy difícil.

Solución

Nuestro proyecto combina la ciencia de datos y MLOps para crear un modelo preciso para predecir la eficiencia de los vehículos eléctricos, beneficiando a los consumidores y fabricantes.

Configurar un entorno virtual

¿Por qué queremos configurar un entorno virtual?

Esto nos ayuda a destacar en nuestro proyecto y evitar conflictos con otros proyectos en nuestro sistema.

Creación de un entorno virtual

• Para Windows:

python -m venv myenv# luego, para activar myenv\Scripts\activate

• Para Linux/macOS:

python3 -m venv myenv# luego, para activarsource myenv/bin/activate

Esto nos ayuda a mantener nuestro entorno limpio.

Trabajando en el proyecto

Con nuestro entorno listo, debemos instalar Zenml. Ahora, ¿qué es Zenml? Zenml es un marco de operaciones de aprendizaje automático (MLOps) para gestionar tuberías de aprendizaje automático de principio a fin. Elegimos Zenml debido a la eficiente gestión de las tuberías de aprendizaje automático. Por lo tanto, necesitas instalar el servidor de Zenml.

Utiliza este comando en tu terminal para instalar el servidor Zenml –

 pip install ‘zenml[server]’

Esto no es el final; después de instalar el servidor Zenml, necesitamos crear el repositorio Zenml, para crear el repositorio Zenml –

zenml init

¿Por qué utilizamos ‘zenml init’? ‘zenml init’ se utiliza para inicializar un repositorio ZenML, creando la estructura necesaria para gestionar tuberías y experimentos de aprendizaje automático de manera efectiva.

Instalación de requisitos

Para satisfacer las dependencias del proyecto, utilizamos un archivo ‘requirements.txt’. En este archivo, debes tener esas dependencias.

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

Organizando el proyecto

Cuando trabajamos en un proyecto de ciencia de datos, debemos organizar todo correctamente. Permíteme explicar cómo mantenemos las cosas estructuradas en nuestro proyecto:

Creando carpetas

Organizamos nuestro proyecto en carpetas. Hay algunas carpetas que debemos crear.

• Carpeta del modelo: Primero, debemos crear una carpeta del modelo. Contiene archivos esenciales para nuestros modelos de aprendizaje automático. Dentro de esta carpeta, tenemos algunos archivos como ‘data_cleaning.py’, ‘evaluation.py’ y ‘model_dev.py’. Estos archivos son como diferentes herramientas que nos ayudan durante todo el proyecto.
• Carpeta de pasos: Esta carpeta sirve como centro de control para nuestro proyecto. Dentro de la carpeta ‘Pasos’, tenemos archivos esenciales para diversas etapas de nuestro proceso de ciencia de datos. Luego, debemos crear algunos archivos en la carpeta de pasos, como ‘Ingest_data.py’. Este archivo nos ayuda con la entrada de datos, al igual que recolectar materiales para tu proyecto. A continuación, ‘Cleaning_data.py’. Es como la parte de tu proyecto donde limpias y preparas los materiales para el trabajo principal. ‘Model_train.py’: En este archivo entrenamos nuestro modelo de aprendizaje automático, al igual que dar forma a tus materiales para obtener el producto final. ‘Evaluation.py’: Este archivo evalúa nuestro modelo, donde verificamos qué tan bien se desempeña nuestro producto final.

Carpeta de tuberías

Aquí es donde ensamblamos nuestra tubería, similar a configurar una línea de producción para tu proyecto. En la carpeta ‘Tuberías’, ‘Training_pipeline.py’ actúa como la máquina de producción principal. En este archivo, importamos ‘Ingest_data.py’ y la clase ‘ingest_df’ para preparar los datos, limpiarlos, entrenar el modelo y evaluar su rendimiento. Para ejecutar todo el proyecto, utiliza ‘run_pipeline.py’, similar a presionar el botón de inicio en tu línea de producción con el siguiente comando:

python run_pipeline.py

Aquí puedes ver la estructura de archivos del proyecto-

Esta estructura nos ayuda a ejecutar nuestro proyecto sin problemas, al igual que un espacio de trabajo bien estructurado te ayuda a crear un proyecto de manera efectiva.

3. Configuración de la tubería

Después de organizar el proyecto y configurar la tubería, el siguiente paso es ejecutar la tubería. Ahora, es posible que tengas una pregunta: ¿qué es una tubería? Una tubería es un conjunto de pasos automatizados que simplifican la implementación, el monitoreo y la administración de modelos de aprendizaje automático desde el desarrollo hasta la producción. Esto se logra ejecutando el comando ‘zenml up’, que actúa como el interruptor de encendido para tu línea de producción. Asegura que todos los pasos definidos en tu proyecto de ciencia de datos se ejecuten en la secuencia correcta, iniciando todo el flujo de trabajo, desde la ingestión y limpieza de datos hasta el entrenamiento y evaluación del modelo.

Limpieza de datos

En la carpeta ‘Modelo’, encontrarás un archivo llamado ‘data_cleaning’, este archivo es responsable de la limpieza de datos. Dentro de este archivo, descubrirás: Limpieza de columnas: una sección dedicada a identificar y eliminar columnas innecesarias del conjunto de datos, haciéndolo más ordenado y más fácil de encontrar lo que necesitas. Clase DataDivideStretegy: Esta clase nos ayuda a planificar cómo dividir nuestros datos de manera efectiva. Es como planificar cómo organizar tus materiales para tu proyecto.

class DataDivideStrategy(DataStrategy):    """    Estrategia de división de datos que divide los datos en datos de entrenamiento y prueba.    """    def handle_data(self, data: pd.DataFrame) -> Union[pd.DataFrame, pd.Series]:        """        Divide los datos en datos de entrenamiento y prueba.        """        try:            # Suponiendo que "Efficiency" es tu variable objetivo            # Separación de las características (X) y el objetivo (y) del conjunto de datos            X = data.drop("Efficiency", axis=1)            y = data["Efficiency"]            # Dividir los datos en conjuntos de entrenamiento y prueba con una división 80-20            X_train, X_test, y_train, y_test = train_test_split(                X, y, test_size=0.2, random_state=42            )            # Devolver los conjuntos de datos divididos            return X_train, X_test, y_train, y_test        except Exception as e:            # Registrar un mensaje de error si ocurre alguna excepción            logging.error("Error en la división de datos en datos de entrenamiento y prueba.".format(e))            raise e

• Toma un conjunto de datos y lo separa en datos de entrenamiento y prueba (división 80-20), devolviendo los conjuntos de datos divididos. Si ocurren errores durante este proceso, registra un mensaje de error.
• Clase DataCleaning: La clase ‘DataCleaning’ es un conjunto de reglas y métodos para asegurarnos de que nuestros datos estén en la mejor forma posible. Método ‘handle_data’: Este método es como una herramienta versátil que nos permite gestionar y manipular datos de diferentes maneras, asegurándonos de que estén listos para los siguientes pasos de nuestro proyecto.
• Nuestra clase principal es la Limpieza de Datos, que es la Estrategia de Preprocesamiento de Datos. En esta clase, limpiamos nuestros datos.

Ahora pasamos a la carpeta ‘Steps’. Dentro, hay un archivo llamado ‘clean_data.py’. Este archivo está dedicado a la limpieza de datos. Aquí es lo que sucede:

• Importamos ‘DataCleaning’, ‘DataDevideStretegy’ y ‘DataPreProcesStretegy’ de ‘data_cleaning’. Esto es como obtener las herramientas y materiales adecuados de tu caja de herramientas para continuar trabajando en tu proyecto de manera efectiva.

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'],]:    """    Clase de limpieza de datos que preprocesa los datos y los divide en datos de entrenamiento y prueba.    Args:        data: pd.DataFrame    """    try:        strategy_preproceso = DataPreProcessStrategy()        data_cleaning = DataCleaning(data, strategy_preproceso)        datos_preprocesados = data_cleaning.handle_data()        strategy_division = DataDivideStrategy()        data_cleaning = DataCleaning(datos_preprocesados, strategy_division)        X_train, X_test, y_train, y_test = data_cleaning.handle_data()        logging.info(f"Limpieza de datos completa")        return X_train, X_test, y_train, y_test     except Exception as e:         logging.error(e)        raise e

1. Primero, importa bibliotecas y módulos necesarios, incluyendo logging, pandas y varias estrategias de limpieza de datos.
2. El decorador @step marca una función como un paso en un pipeline de aprendizaje automático. Este paso toma un DataFrame, lo preprocesa y lo divide en datos de entrenamiento y prueba.
3. En ese paso, se utilizan estrategias de limpieza y división de datos, registrando el proceso y devolviendo los datos divididos en los tipos de datos especificados. Por ejemplo, X_train y X_test son DataFrame, y y_train y y_test son Series.

Crear un Modelo de Regresión Lineal Sencillo

Ahora, hablemos de crear el modelo_dev en la carpeta de modelos. En este archivo, principalmente trabajamos en la construcción del modelo de aprendizaje automático.

• Modelo de Regresión Lineal Simple: En este archivo, creamos un modelo de regresión lineal simple. Nuestro objetivo principal es centrarnos en MLOps, no en la construcción de un modelo complejo. Es como construir un prototipo básico de tu proyecto MLOps.

Este enfoque estructurado garantiza que tengamos un proceso de limpieza de datos limpio y organizado, y que el desarrollo de nuestro modelo siga un plan claro, manteniendo el enfoque en la eficiencia de MLOps en lugar de construir un modelo complejo. En el futuro, actualizaremos nuestro modelo.

import loggingfrom abc import ABC, abstractmethodimport pandas as pdfrom sklearn.linear_model import LinearRegressionfrom typing importDictimport optuna  # Importar la biblioteca optuna# Resto de tu código...classModelo(ABC):    """    Clase base abstracta para todos los modelos.    """    @abstractmethoddeftrain(self, X_train, y_train):        """        Entrena el modelo con los datos proporcionados.        Args:            x_train: Datos de entrenamiento            y_train: Datos objetivo        """passclassModeloRegresionLineal(Modelo):    """    Modelo de Regresión Lineal que implementa la interfaz Modelo.    """deftrain(self, X_train, y_train, **kwargs):        try:            reg = LinearRegression(**kwargs)  # Crea un modelo de regresión lineal            reg.fit(X_train, y_train)  # Ajusta el modelo a los datos de entrenamiento            logging.info('Entrenamiento completo')              # Registra un mensaje indicando que el entrenamiento está completoreturn reg              # Devuelve el modelo entrenadoexcept Exception as e:            logging.error("error al entrenar el modelo: {}".format(e))              # Registra un mensaje de error si ocurre una excepciónraise e              # Lanza la excepción para su posterior manejo

Mejoras en ‘model_train.py’ para el Desarrollo del Modelo

En el archivo ‘model_train.py’, hacemos varias incorporaciones importantes a nuestro proyecto:

Importar el Modelo de Regresión Lineal: Importamos ‘ModeloRegresionLineal’ de ‘model.mode_dev.’ Nos ha ayudado a construir nuestro proyecto. Nuestro archivo ‘model_train.py’ está configurado para funcionar con este tipo específico de modelo de aprendizaje automático.

def train_model(    X_train: pd.DataFrame,    X_test: pd.DataFrame,    y_train: pd.Series,    y_test: pd.Series,    config: ModeloNombreConfig,) -> RegressorMixin:    """    Entrena un modelo de regresión según la configuración especificada.    Args:        X_train (pd.DataFrame): Características de los datos de entrenamiento.        X_test (pd.DataFrame): Características de los datos de prueba.        y_train (pd.Series): Datos objetivo de entrenamiento.        y_test (pd.Series): Datos objetivo de prueba.        config (ModeloNombreConfig): Configuración del modelo.    Returns:        RegressorMixin: Modelo de regresión entrenado.    """    try:        model = None        # Verifica el modelo especificado en la configuración        if config.model_name == "regresion_lineal":            # Habilita el registro automático en MLflow            autolog()            # Crea una instancia del ModeloRegresionLineal            model = ModeloRegresionLineal()            # Entrena el modelo con los datos de entrenamiento            modelo_entrenado = model.train(X_train, y_train)            # Devuelve el modelo entrenado            return modelo_entrenado        else:            # Lanza un error si el nombre del modelo no está soportado            raise ValueError("Nombre de modelo no soportado")    except Exception as e:        # Registra y lanza cualquier excepción que ocurra durante el entrenamiento del modelo        logging.error(f"Error al entrenar el modelo: {e}")        raise e

Este código entrena un modelo de regresión (por ejemplo, regresión lineal) basado en una configuración seleccionada. Verifica si el modelo seleccionado está soportado, utiliza MLflow para el registro, entrena el modelo con los datos proporcionados y devuelve el modelo entrenado. Si el modelo seleccionado no está soportado, lanzará un error.

Método ‘Train Model’: El archivo ‘model_train.py’ define un método llamado ‘train_model’, que devuelve un ‘ModeloRegresionLineal’.

Importar RegressorMixin: Importamos ‘RegressorMixin’ de sklearn.base. RegressorMixin es una clase en scikit-learn que proporciona una interfaz común para estimadores de regresión. sklearn.base es parte de la biblioteca Scikit-Learn, una herramienta para construir y trabajar con modelos de aprendizaje automático.

Configuración de la Configuración del Modelo y Evaluación del Rendimiento

Crear ‘config.py’ en la carpeta ‘Pasos’: En la carpeta ‘pasos’, creamos un archivo llamado ‘config.py’. Este archivo contiene una clase llamada ‘ModeloNombreConfig’. ‘ModeloNombreConfig’ es una clase en el archivo ‘config.py’ que sirve como guía de configuración para tu modelo de aprendizaje automático. Especifica distintas configuraciones y opciones para tu modelo.

# Importar la clase necesaria de ZenML para configurar los parámetros del modelo
from zenml.steps import BaseParameters

# Definir una clase llamada ModelNameConfig que hereda de BaseParameters
class ModelNameConfig(BaseParameters):
    """Configuraciones del modelo"""
    
    # Definir atributos para la configuración del modelo con valores predeterminados
    model_name: str = "linear_regression"  # Nombre del modelo de aprendizaje automático
    fine_tuning: bool = False  # Bandera para habilitar el ajuste fino

• Te permite elegir el nombre del modelo y si hacer ajuste fino. El ajuste fino es como hacer pequeñas mejoras a un modelo de aprendizaje automático que ya funciona bien para obtener un mejor rendimiento en tareas específicas.
• Evaluación: En la carpeta ‘src’ o ‘model’, creamos un archivo llamado ‘evaluation.py’. Este archivo contiene una clase abstracta llamada ‘evaluation’ y un método llamado ‘calculate_score’. Estas son las herramientas que utilizamos para medir qué tan bien funciona nuestro modelo de aprendizaje automático.
• Estrategias de Evaluación: Introducimos estrategias de evaluación específicas, como el Error Cuadrado Medio (MSE, por sus siglas en inglés). Cada clase de estrategia contiene un método ‘calculate_score’ para evaluar el rendimiento del modelo.
• Implementación de Evaluación en ‘Steps’: Implementamos estas estrategias de evaluación en ‘evaluation.py’ dentro de la carpeta ‘steps’. Esto es como configurar el proceso de control de calidad en nuestro proyecto.

Cuantificar el Rendimiento del Modelo con el Método ‘Evaluar Modelo’

Método ‘Evaluar Modelo’: En ‘evaluation.py’ dentro de la carpeta ‘steps’, creamos un método llamado ‘evaluate_model’ que devuelve métricas de rendimiento como el puntaje R-cuadrado (R2) y el Error Cuadrático Medio (RMSE, por sus siglas en inglés).

@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"],]:
    """Evaluar el rendimiento de un modelo de aprendizaje automático utilizando diversas métricas y registrar los resultados.
    
    Args:
        model: RegressorMixin - El modelo de aprendizaje automático a evaluar.
        X_test: pd.DataFrame - Los valores de las características del conjunto de pruebas.
        y_test: pd.Series - Los valores reales del objetivo para el conjunto de pruebas.
    
    Returns:
        Tuple[float, float] - Una tupla que contiene el puntaje R2 y el RMSE.
    """
    try:
        # Hacer predicciones utilizando el modelo
        prediction = model.predict(X_test)
        
        # Calcular el Error Cuadrado Medio (MSE) utilizando la clase MSE
        mse_class = MSE()
        mse = mse_class.calculate_score(y_test, prediction)
        mlflow.log_metric("mse", mse)
        
        # Calcular el puntaje R2 utilizando la clase R2Score
        r2_class = R2()
        r2 = r2_class.calculate_score(y_test, prediction)
        mlflow.log_metric("r2", r2)
        
        # Calcular el Error Cuadrático Medio (RMSE) utilizando la clase RMSE
        rmse_class = RMSE()
        rmse = rmse_class.calculate_score(y_test, prediction)
        mlflow.log_metric("rmse", rmse)
        
        return r2, rmse  # Devolver puntaje R2 y RMSE
    
    except Exception as e:
        logging.error("error en la evaluación".format(e))
        raise e

Estas adiciones en ‘model_train.py’, ‘config.py’ y ‘evaluation.py’ mejoran nuestro proyecto al introducir el entrenamiento del modelo de aprendizaje automático, la configuración y una evaluación exhaustiva, asegurando que nuestro proyecto cumpla con estándares de alta calidad.

Ejecutar la Canalización

A continuación, actualizamos el archivo ‘training_pipeline’ para ejecutar la canalización con éxito; ZenML es un marco de trabajo de MLOps de código abierto diseñado para agilizar y estandarizar la gestión del flujo de trabajo de aprendizaje automático. Para ver tu canalización, puedes usar el comando ‘zenml up’.

Ahora, procedemos a implementar el rastreador de experimentos y desplegar el modelo:

• Importar MLflow: En el archivo ‘model_train.py’, importamos ‘mlflow’. MLflow es una herramienta versátil que nos ayuda a gestionar el ciclo de vida del modelo de aprendizaje automático, realizar un seguimiento de los experimentos y mantener un registro detallado de cada proyecto.
• Rastreador de Experimentos: Ahora, es posible que te preguntes: ¿qué es un rastreador de experimentos? Un rastreador de experimentos es un sistema para supervisar y organizar experimentos, lo que nos permite llevar un registro del progreso de nuestro proyecto. En nuestro código, accedemos al rastreador de experimentos a través de ‘zenml.client’ y ‘mlflow’, asegurándonos de que podemos gestionar eficazmente nuestros experimentos. Puedes ver el código de ‘model_train.py’ para comprender mejor.
• Autoregistro con MLflow: Utilizamos la función ‘autolog’ de ‘mlflow.sklearn’ para registrar automáticamente diversos aspectos del rendimiento de nuestro modelo de aprendizaje automático. Esto simplifica el proceso de seguimiento de experimentos, proporcionando información valiosa sobre cómo está funcionando nuestro modelo.
• Registro de Métricas: Registramos métricas específicas como el Error Cuadrado Medio (MSE) utilizando ‘mlflow.log_metric’ en nuestro archivo ‘evaluation.py’. Esto nos permite realizar un seguimiento del rendimiento del modelo durante el proyecto.

Si estás ejecutando el script ‘run_deployment.py’, debes instalar algunas integraciones utilizando ZenML. Ahora, las integraciones ayudan a conectar tu modelo con el entorno de implementación, donde puedes implementar tu modelo.

Integración de Zenml

Zenml proporciona integración con herramientas de MLOps. Al ejecutar el siguiente comando, debemos instalar la integración de Zenml con MLflow, es un paso muy importante:

Para crear esta integración, debes usar este comando:

zenml integration install mlflow -y

Esta integración nos ayuda a gestionar esos experimentos de manera eficiente.

Seguimiento de experimentos

El seguimiento de experimentos es un aspecto crítico de MLOps. Usamos Zenml y MLflow para monitorear, registrar y gestionar todos los aspectos de nuestros experimentos de aprendizaje automático, facilitando experimentación eficiente y reproducibilidad.

Registrar el rastreador de experimentos:

zenml experiment-tracker register mlflow_tracker --flavor=mlflow

Registrar el implementador de modelos:

zenml model-deployer register mlflow --flavor=mlflow

Stack:

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

Implementación

La implementación es el último paso en nuestro pipeline y es una parte esencial de nuestro proyecto. Nuestro objetivo no es solo construir el modelo, queremos que nuestro modelo se implemente en internet para que los usuarios puedan usarlo.

Configuración del pipeline de implementación: Tienes un pipeline de implementación definido en un archivo Python llamado ‘deployment_pipeline.py’. Este pipeline gestiona las tareas de implementación.

Disparador de implementación: Hay un paso llamado ‘deployment_trigger’

class DeploymentTriggerConfig(BaseParameters):    min_accuracy = 0 @step(enable_cache=False)def dynamic_importer() -> str:    """Descarga los últimos datos desde una API simulada."""    data = get_data_for_test()    return data

Este código define una clase `DeploymentTriggerConfig` con un parámetro de precisión mínima. En este caso, es cero. También define un paso del pipeline, dynamic_importer, que descarga datos de una API simulada, con el almacenamiento en caché deshabilitado para este paso.

Cargador del servicio de predicción

El paso ‘prediction_service_loader’ recupera el servicio de predicción iniciado por el pipeline de implementación. Se utiliza para gestionar e interactuar con el modelo implementado.

def prediction_service_loader(        pipeline_name: str,    pipeline_step_name: str,    running: bool = True,    model_name: str = "model",) -> MLFlowDeploymentService:    """Obtener el servicio de predicción iniciado por el pipeline de implementación.    Args:        pipeline_name: nombre del pipeline que implementó el servidor de predicción MLflow        step_name: el nombre del paso que implementó el servidor de predicción MLflow        running: cuando se establece esta bandera, el paso solo devuelve un servicio en ejecución        model_name: el nombre del modelo que se ha implementado    """    # obtener el componente de implementación de modelos MLflow             mlflow_model_deployer_component = MLFlowModelDeployer.get_active_model_deployer()        # buscar servicios existentes con el mismo nombre de pipeline, nombre de paso y nombre de modelo    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 se ha implementado ningún servicio de predicción MLflow mediante el "            f"paso {pipeline_step_name} en el pipeline {pipeline_name} "            f"para el modelo '{model_name}' en este momento."        )    return existing_services[0]

Este código define una función `prediction_service_loader` que recupera un servicio de predicción iniciado por un pipeline de implementación.

• Acepta entradas como el nombre del pipeline, el nombre del paso y el nombre del modelo.
• La función verifica la existencia de servicios que coincidan con estos parámetros y devuelve el primero encontrado. Si no se encuentra ninguno, generará un error.

Predictor

El paso del ‘predictor’ ejecuta solicitudes de inferencia contra el servicio de predicción. Procesa los datos entrantes y devuelve predicciones.

@stepdef predictor(    service: MLFlowDeploymentService,    data: str,) -> np.ndarray:    """Ejecuta una solicitud de inferencia contra un servicio de predicción"""    service.start(timeout=10)  # debería ser un NOP si ya se ha iniciado    data = json.loads(data) # Parsea los datos de entrada de una cadena JSON a un diccionario de Python.    data.pop("columns")    data.pop("index")    columns_for_df = [   # Define una lista de nombres de columnas para crear 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) # Convierte la lista JSON en un array NumPy.    prediction = service.predict(data)    return prediction

• Este código define una función llamada `predictor` utilizada para hacer predicciones con un modelo de aprendizaje automático implementado a través de MLFlow. Inicia el servicio, procesa los datos de entrada en formato JSON, los convierte en un array NumPy, y devuelve las predicciones del modelo. La función opera en datos con características específicas relacionadas con un vehículo eléctrico.

Ejecución de la Implementación: Tienes un script llamado ‘run_deployment.py’ que te permite iniciar el proceso de implementación. Este script toma el parámetro ‘–config’. El parámetro ‘–config’ se utiliza para especificar un archivo de configuración o configuraciones para un programa a través de la línea de comandos, que se puede establecer en ‘deploy’ para implementar el modelo, ‘predict’ para ejecutar predicciones, o ‘deploy_and_predict’ para ambas cosas.

Estado e Interacción de la Implementación: El script también proporciona información sobre el estado del servidor de predicción de MLflow, incluyendo cómo iniciarlo y detenerlo. Utiliza MLFlow para la implementación del modelo.

Umbral Mínimo de Precisión: Se puede especificar el parámetro ‘min_accuracy’ para establecer un umbral mínimo de precisión para la implementación del modelo. Si se cumple ese valor, se implementará el modelo.

Configuración de Docker: Docker se utiliza para gestionar el entorno de implementación, y has definido la configuración de Docker en tu canalización de implementación.

Este proceso de implementación parece centrarse en implementar modelos de aprendizaje automático y ejecutar predicciones de manera controlada y configurable.

• Implementar nuestro modelo es tan sencillo como ejecutar el script ‘run_deployment.py’. Utiliza esto:

 python3 run_deployment.py --config deploy

Predicción

Una vez que nuestro modelo está implementado, está listo para realizar predicciones.

• Ejecutar Predicciones: Ejecuta predicciones utilizando el siguiente comando:

 python3 run_deployment.py --config predict

Aplicación de Streamlit

La aplicación de Streamlit proporciona una interfaz fácil de usar para interactuar con las predicciones de nuestro modelo. Streamlit simplifica la creación de aplicaciones interactivas de ciencia de datos basadas en web, facilitando a los usuarios explorar y comprender las predicciones del modelo. De nuevo, puedes encontrar el código en GitHub para la aplicación de Streamlit.

• Inicia la aplicación de Streamlit con el siguiente comando: streamlit run streamlit_app.py

Con esto, puedes explorar e interactuar con las predicciones de nuestro modelo.

• La aplicación de Streamlit hace que las predicciones de nuestro modelo sean fáciles de usar y accesibles en línea; los usuarios pueden interactuar fácilmente y entender los resultados. Aquí puedes ver una imagen de cómo se ve la aplicación de Streamlit en la web:

Conclusión

En este artículo, nos hemos adentrado en un proyecto emocionante que demuestra el poder de MLOps para predecir la eficiencia de los vehículos eléctricos. Hemos aprendido sobre Zenml y MLFlow, que son fundamentales para crear una tubería de aprendizaje automático de extremo a extremo. También hemos explorado el proceso de recopilación de datos, el planteamiento del problema y la solución para predecir con precisión la eficiencia de los vehículos eléctricos.

Este proyecto resalta la importancia de los vehículos eléctricos eficientes y cómo se puede aprovechar MLOps para crear modelos precisos para pronosticar su eficiencia. Hemos cubierto los pasos esenciales, incluyendo la configuración de un entorno virtual, el desarrollo del modelo, la configuración de los parámetros del modelo y la evaluación del rendimiento del modelo. El artículo concluye destacando la importancia del seguimiento de experimentos, la implementación y la interacción del usuario a través de una aplicación de Streamlit. Con este proyecto, estamos un paso más cerca de moldear el futuro de los vehículos eléctricos.

Conclusiones clave

• Integración perfecta: El proyecto “End-to-End Predicting Electric Vehicle Efficiency Pipeline with Zenml” exemplifica la integración perfecta de la recolección de datos, entrenamiento de modelos, evaluación y despliegue. Destaca el inmenso potencial de MLOps en la transformación de la industria de vehículos eléctricos.
• Proyecto en GitHub: Para explorar más a fondo, puedes acceder al proyecto en GitHub: Proyecto en GitHub.
• Curso de MLOps: Para profundizar tu comprensión de MLOps, recomendamos ver nuestro curso completo: Curso de MLOps.
• Este proyecto demuestra el potencial de MLOps en la transformación de la industria de vehículos eléctricos, brindando ideas valiosas y contribuyendo a un futuro más ecológico.

Preguntas frecuentes

Los medios mostrados en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

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