Mlops mit ZENML -Projekt verstehen

Die KI -Revolution liegt auf uns, aber zwischen diesem Chaos wird eine sehr kritische Frage von den meisten von uns übersehen - wie können wir diese anspruchsvollen KI -Systeme beibehalten? Hier kommen maschinelles Lernen (MLOPS) ins Spiel. In diesem Blog werden wir die Bedeutung von MLOPS mit Zenml, einem Open-Source-Mlops-Framework, verstehen, indem wir ein End-to-End-Projekt erstellen.

Dieser Artikel wurde als Teil des Data Science -Blogathon veröffentlicht.

Inhaltsverzeichnis

• Was ist Mlops?
• Was ist Zenml? Pipelines
• Häufig gestellte Fragen
Was ist Mlops?
mlops ermächtigt maschinelles Lerningenieure, den Prozess eines ML -Modelllebenszyklus zu optimieren. Das Produktion von maschinellem Lernen ist schwierig. Der Lebenszyklus für maschinelles Lernen besteht aus vielen komplexen Komponenten wie Dateneraufnahme, Datenvorbereitung, Modelltraining, Modellabstimmung, Modellbereitstellung, Modellüberwachung, Erklärung und vielem mehr. MLOPS automatisiert jeden Schritt des Prozesses über robuste Pipelines, um manuelle Fehler zu reduzieren. Es ist eine kollaborative Praxis, Ihre KI -Infrastruktur mit minimalen manuellen Anstrengungen und maximal effizienten Vorgängen zu erleichtern. Stellen Sie sich Mlops als DevOps für die KI -Industrie mit einigen Gewürzen vor.
Was ist Zenml?
Zenml ist ein Open-Source-MLOPS-Framework, das die Entwicklung, Bereitstellung und Verwaltung von Workflows für maschinelles Lernen vereinfacht. Durch die Nutzung des Prinzips von MLOPS integriert es sich nahtlos in verschiedene Tools und Infrastrukturen, die dem Benutzer einen modularen Ansatz bieten, um ihre KI -Workflows unter einem einzigen Arbeitsplatz zu erhalten. ZENML bietet Funktionen wie Auto-Logs, Meta-Data-Tracker, Modell-Tracker, Experiment-Tracker, Artefaktstore und einfache Python-Dekorateure für Kernlogik ohne komplexe Konfigurationen.
Mlops mit praktischem Projekt verstehen

Jetzt werden wir verstehen, wie MLOPS mit Hilfe eines End-to-End-Simple-und dennoch-Datenwissenschaftsprojekts für die Produktionsnote implementiert wird. In diesem Projekt werden wir ein maschinelles Lernmodell erstellen und bereitstellen, um den Kundenlebensdauerwert (CLTV) eines Kunden vorherzusagen. CLTV ist eine wichtige Metrik, die von Unternehmen verwendet wird, um zu sehen, wie viel sie langfristig von einem Kunden profitieren oder von einem Kunden profitieren. Mit dieser Metrik kann ein Unternehmen den Kunden weiter ausgeben oder nicht für gezielte Anzeigen usw.

Beginnen wir mit der Implementierung des Projekts im nächsten Abschnitt.

Anfangskonfigurationen

Lassen Sie uns jetzt direkt in die Projektkonfigurationen einsteigen. Zunächst müssen wir den Online -Einzelhandelsdatensatz von UCI Machine Learning Repository herunterladen. ZENML wird unter Windows nicht unterstützt, daher müssen wir entweder Linux (WSL in Windows) oder macOS verwenden. Als nächstes laden Sie die Anforderungen herunter.txt. Gehen wir nun für einige Konfigurationen zum Terminal fort.

# Make sure you have Python 3.10 or above installed
python --version

# Make a new Python environment using any method
python3.10 -m venv myenv 

# Activate the environment
source myenv/bin/activate

# Install the requirements from the provided source above
pip install -r requirements.txt

# Install the Zenml server
pip install zenml[server] == 0.66.0

# Initialize the Zenml server
zenml init

# Launch the Zenml dashboard
zenml up

Melden Sie sich jetzt einfach mit den Standard -Anmeldeinformationen des ZenML -Dashboards an (kein Passwort erforderlich).

Herzlichen Glückwunsch, Sie haben die Projektkonfigurationen erfolgreich abgeschlossen.

Explorationsdatenanalyse (EDA)

Jetzt ist es Zeit, die Hände mit den Daten schmutzig zu machen. Wir werden ein Ajupyter -Notizbuch für die Analyse unserer Daten erstellen.

Pro Tipp : Machen Sie Ihre eigene Analyse, ohne mir zu folgen.

oder Sie können dieses Notizbuch nur verfolgen, in dem wir verschiedene Datenanalysemethoden erstellt haben, die in unserem Projekt verwendet werden können.

Nehmen wir nun angenommen, Sie haben Ihren Anteil an Datenanalysen durchgeführt, und springen Sie direkt zum würzigen Teil.

Schritte für ZENML als modulare Codierung

definieren

Für die Erhöhung der Modularität und Wiederherstellung unseres Codes wird der @step -Dekorateur von ZenML verwendet, der unseren Code organisiert, um in die Pipelines problemlos zu gelangen, um die Fehlerchancen zu verringern.

In unserem Quellordner schreiben wir für jeden Schritt Methoden, bevor wir diese initialisieren. Wir folgen Systementwurfsmustern für jede unserer Methoden, indem wir eine abstrakte Methode für die Strategien jeder Methode erstellen (Datenaufnahme, Datenreinigung, Feature Engineering usw.)

Beispielcode für Einnahmedaten

Beispiel des Codes für Ingest_data.py

import logging
import pandas as pd
from abc import ABC, abstractmethod

# Setup logging configuration
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

# Abstract Base Class for Data Ingestion Strategy
# ------------------------------------------------
# This class defines a common interface for different data ingestion strategies.
# Subclasses must implement the `ingest` method.
class DataIngestionStrategy(ABC):
    @abstractmethod
    def ingest(self, file_path: str) -> pd.DataFrame:
        """
        Abstract method to ingest data from a file into a DataFrame.

        Parameters:
        file_path (str): The path to the data file to ingest.

        Returns:
        pd.DataFrame: A dataframe containing the ingested data.
        """
        pass
    
# Concrete Strategy for XLSX File Ingestion
# -----------------------------------------
# This strategy handles the ingestion of data from an XLSX file.
class XLSXIngestion(DataIngestionStrategy):
    def __init__(self, sheet_name=0):
        """
        Initializes the XLSXIngestion with optional sheet name.

        Parameters:
        sheet_name (str or int): The sheet name or index to read, default is the first sheet.
        """
        self.sheet_name = sheet_name

    def ingest(self, file_path: str) -> pd.DataFrame:
        """
        Ingests data from an XLSX file into a DataFrame.

        Parameters:
        file_path (str): The path to the XLSX file.

        Returns:
        pd.DataFrame: A dataframe containing the ingested data.
        """
        try:
            logging.info(f"Attempting to read XLSX file: {file_path}")
            df = pd.read_excel(file_path,dtype={'InvoiceNo': str, 'StockCode': str, 'Description':str}, sheet_name=self.sheet_name)
            logging.info(f"Successfully read XLSX file: {file_path}")
            return df
        except FileNotFoundError:
            logging.error(f"File not found: {file_path}")
        except pd.errors.EmptyDataError:
            logging.error(f"File is empty: {file_path}")
        except Exception as e:
            logging.error(f"An error occurred while reading the XLSX file: {e}")
        return pd.DataFrame()


# Context Class for Data Ingestion
# --------------------------------
# This class uses a DataIngestionStrategy to ingest data from a file.
class DataIngestor:
    def __init__(self, strategy: DataIngestionStrategy):
        """
        Initializes the DataIngestor with a specific data ingestion strategy.

        Parameters:
        strategy (DataIngestionStrategy): The strategy to be used for data ingestion.
        """
        self._strategy = strategy

    def set_strategy(self, strategy: DataIngestionStrategy):
        """
        Sets a new strategy for the DataIngestor.

        Parameters:
        strategy (DataIngestionStrategy): The new strategy to be used for data ingestion.
        """
        logging.info("Switching data ingestion strategy.")
        self._strategy = strategy

    def ingest_data(self, file_path: str) -> pd.DataFrame:
        """
        Executes the data ingestion using the current strategy.

        Parameters:
        file_path (str): The path to the data file to ingest.

        Returns:
        pd.DataFrame: A dataframe containing the ingested data.
        """
        logging.info("Ingesting data using the current strategy.")
        return self._strategy.ingest(file_path)


# Example usage
if __name__ == "__main__":
    # Example file path for XLSX file
    # file_path = "../data/raw/your_data_file.xlsx"

    # XLSX Ingestion Example
    # xlsx_ingestor = DataIngestor(XLSXIngestion(sheet_name=0))
    # df = xlsx_ingestor.ingest_data(file_path)

    # Show the first few rows of the ingested DataFrame if successful
    # if not df.empty:
    #     logging.info("Displaying the first few rows of the ingested data:")
    #     print(df.head())
    pass csv

Wir werden dieses Muster befolgen, um den Rest der Methoden zu erstellen. Sie können die Codes aus dem angegebenen Github -Repository kopieren.

Nachdem alle Methoden geschrieben wurden, ist es an der Zeit, die ZenML -Schritte in unserem Stufenordner zu initialisieren. Jetzt werden alle Methoden, die wir bisher erstellt haben, in den ZenML -Schritten entsprechend verwendet.

Beispielcode der Datenaufnahme

Beispielcode der Data_ingestion_step.py:

import os
import sys
sys.path.append(os.path.dirname(os.path.dirname(__file__)))

import pandas as pd
from src.ingest_data import DataIngestor, XLSXIngestion
from zenml import step

@step
def data_ingestion_step(file_path: str) -> pd.DataFrame:
    """
    Ingests data from an XLSX file into a DataFrame.

    Parameters:
    file_path (str): The path to the XLSX file.

    Returns:
    pd.DataFrame: A dataframe containing the ingested data.
    """
    # Initialize the DataIngestor with an XLSXIngestion strategy
    
    ingestor = DataIngestor(XLSXIngestion())
    
    # Ingest data from the specified file
    
    df = ingestor.ingest_data(file_path)
    
    return df

Wir werden das gleiche Muster wie oben befolgen, um den Rest der ZENML -Schritte in unserem Projekt zu erstellen. Sie können sie von hier aus kopieren.

wow! Herzlichen Glückwunsch zum Erstellen und Lernen eines der wichtigsten Teile von MLOPS. Es ist in Ordnung, ein bisschen überwältigt zu bekommen, da es Ihr erstes Mal ist. Nehmen Sie nicht zu viel Stress, da alles sinnvoll ist, wenn Sie Ihr erstes ML -Modell der Produktionsstufe ausführen.

Gebäude -Pipelines

Es ist Zeit, unsere Pipelines zu bauen. Nein, nicht Wasser oder Öl tragen. Pipelines sind eine Reihe von Schritten, die in einer bestimmten Reihenfolge organisiert sind, um unseren vollständigen Workflow für maschinelles Lernen zu bilden. Der @Pipeline Decorator wird in ZENML verwendet, um eine Pipeline anzugeben, die die oben erstellten Schritte enthält. Dieser Ansatz stellt sicher, dass wir den Ausgang von einem Schritt als Eingabe für den nächsten Schritt verwenden können.

Hier ist unsere Training_Pipeline.py:

# Make sure you have Python 3.10 or above installed
python --version

# Make a new Python environment using any method
python3.10 -m venv myenv 

# Activate the environment
source myenv/bin/activate

# Install the requirements from the provided source above
pip install -r requirements.txt

# Install the Zenml server
pip install zenml[server] == 0.66.0

# Initialize the Zenml server
zenml init

# Launch the Zenml dashboard
zenml up

Jetzt können wir die pipeline.py ausführen, um unser ML -Modell in einem einzigen Klick zu trainieren. Sie können die Pipeline in Ihrem ZENML -Dashboard überprüfen:

Wir können unsere Modelldetails überprüfen und mehrere Modelle trainieren und im MLFlow Dashboard vergleichen, indem wir den folgenden Code im Terminal ausführen.

import logging
import pandas as pd
from abc import ABC, abstractmethod

# Setup logging configuration
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

# Abstract Base Class for Data Ingestion Strategy
# ------------------------------------------------
# This class defines a common interface for different data ingestion strategies.
# Subclasses must implement the `ingest` method.
class DataIngestionStrategy(ABC):
    @abstractmethod
    def ingest(self, file_path: str) -> pd.DataFrame:
        """
        Abstract method to ingest data from a file into a DataFrame.

        Parameters:
        file_path (str): The path to the data file to ingest.

        Returns:
        pd.DataFrame: A dataframe containing the ingested data.
        """
        pass
    
# Concrete Strategy for XLSX File Ingestion
# -----------------------------------------
# This strategy handles the ingestion of data from an XLSX file.
class XLSXIngestion(DataIngestionStrategy):
    def __init__(self, sheet_name=0):
        """
        Initializes the XLSXIngestion with optional sheet name.

        Parameters:
        sheet_name (str or int): The sheet name or index to read, default is the first sheet.
        """
        self.sheet_name = sheet_name

    def ingest(self, file_path: str) -> pd.DataFrame:
        """
        Ingests data from an XLSX file into a DataFrame.

        Parameters:
        file_path (str): The path to the XLSX file.

        Returns:
        pd.DataFrame: A dataframe containing the ingested data.
        """
        try:
            logging.info(f"Attempting to read XLSX file: {file_path}")
            df = pd.read_excel(file_path,dtype={'InvoiceNo': str, 'StockCode': str, 'Description':str}, sheet_name=self.sheet_name)
            logging.info(f"Successfully read XLSX file: {file_path}")
            return df
        except FileNotFoundError:
            logging.error(f"File not found: {file_path}")
        except pd.errors.EmptyDataError:
            logging.error(f"File is empty: {file_path}")
        except Exception as e:
            logging.error(f"An error occurred while reading the XLSX file: {e}")
        return pd.DataFrame()


# Context Class for Data Ingestion
# --------------------------------
# This class uses a DataIngestionStrategy to ingest data from a file.
class DataIngestor:
    def __init__(self, strategy: DataIngestionStrategy):
        """
        Initializes the DataIngestor with a specific data ingestion strategy.

        Parameters:
        strategy (DataIngestionStrategy): The strategy to be used for data ingestion.
        """
        self._strategy = strategy

    def set_strategy(self, strategy: DataIngestionStrategy):
        """
        Sets a new strategy for the DataIngestor.

        Parameters:
        strategy (DataIngestionStrategy): The new strategy to be used for data ingestion.
        """
        logging.info("Switching data ingestion strategy.")
        self._strategy = strategy

    def ingest_data(self, file_path: str) -> pd.DataFrame:
        """
        Executes the data ingestion using the current strategy.

        Parameters:
        file_path (str): The path to the data file to ingest.

        Returns:
        pd.DataFrame: A dataframe containing the ingested data.
        """
        logging.info("Ingesting data using the current strategy.")
        return self._strategy.ingest(file_path)


# Example usage
if __name__ == "__main__":
    # Example file path for XLSX file
    # file_path = "../data/raw/your_data_file.xlsx"

    # XLSX Ingestion Example
    # xlsx_ingestor = DataIngestor(XLSXIngestion(sheet_name=0))
    # df = xlsx_ingestor.ingest_data(file_path)

    # Show the first few rows of the ingested DataFrame if successful
    # if not df.empty:
    #     logging.info("Displaying the first few rows of the ingested data:")
    #     print(df.head())
    pass csv

Erstellen von Bereitstellungspipeline

Als nächstes erstellen wir die bereitgestellt.py.py

import os
import sys
sys.path.append(os.path.dirname(os.path.dirname(__file__)))

import pandas as pd
from src.ingest_data import DataIngestor, XLSXIngestion
from zenml import step

@step
def data_ingestion_step(file_path: str) -> pd.DataFrame:
    """
    Ingests data from an XLSX file into a DataFrame.

    Parameters:
    file_path (str): The path to the XLSX file.

    Returns:
    pd.DataFrame: A dataframe containing the ingested data.
    """
    # Initialize the DataIngestor with an XLSXIngestion strategy
    
    ingestor = DataIngestor(XLSXIngestion())
    
    # Ingest data from the specified file
    
    df = ingestor.ingest_data(file_path)
    
    return df

Wenn wir die Bereitstellungspipeline ausführen, erhalten wir in unserem ZENML -Dashboard eine solche Ansicht:

Herzlichen Glückwunsch, Sie haben das beste Modell mit MLFlow und ZenML in Ihrer lokalen Instanz bereitgestellt.

Flask -App erstellen

Unser nächster Schritt ist es, eine Flask-App zu erstellen, die unser Modell dem Endbenutzer projiziert. Dafür müssen wir im Vorlagenordner eine App.py und einen index.html erstellen. Befolgen Sie den folgenden Code, um die App.py zu erstellen:

#import csvimport os
import sys
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from steps.data_ingestion_step import data_ingestion_step
from steps.handling_missing_values_step import handling_missing_values_step
from steps.dropping_columns_step import dropping_columns_step
from steps.detecting_outliers_step import detecting_outliers_step
from steps.feature_engineering_step import feature_engineering_step
from steps.data_splitting_step import data_splitting_step
from steps.model_building_step import model_building_step
from steps.model_evaluating_step import model_evaluating_step
from steps.data_resampling_step import data_resampling_step
from zenml import Model, pipeline


@pipeline(model=Model(name='CLTV_Prediction'))
def training_pipeline():
    """
    Defines the complete training pipeline for CLTV Prediction.
    Steps:
    1. Data ingestion
    2. Handling missing values
    3. Dropping unnecessary columns
    4. Detecting and handling outliers
    5. Feature engineering
    6. Splitting data into train and test sets
    7. Resampling the training data
    8. Model training
    9. Model evaluation
    """
    # Step 1: Data ingestion
    raw_data = data_ingestion_step(file_path='data/Online_Retail.xlsx')

    # Step 2: Drop unnecessary columns
    columns_to_drop = ["Country", "Description", "InvoiceNo", "StockCode"]
    refined_data = dropping_columns_step(raw_data, columns_to_drop)

    # Step 3: Detect and handle outliers
    outlier_free_data = detecting_outliers_step(refined_data)

    # Step 4: Feature engineering
    features_data = feature_engineering_step(outlier_free_data)
    
    # Step 5: Handle missing values
    cleaned_data = handling_missing_values_step(features_data)
    
    # Step 6: Data splitting
    train_features, test_features, train_target, test_target = data_splitting_step(cleaned_data,"CLTV")

    # Step 7: Data resampling
    train_features_resampled, train_target_resampled = data_resampling_step(train_features, train_target)

    # Step 8: Model training
    trained_model = model_building_step(train_features_resampled, train_target_resampled)

    # Step 9: Model evaluation
    evaluation_metrics = model_evaluating_step(trained_model, test_features, test_target)

    # Return evaluation metrics
    return evaluation_metrics


if __name__ == "__main__":
    # Run the pipeline
    training_pipeline()

Befolgen Sie die folgenden Codes:

, um die Datei index.html zu erstellen:

mlflow ui

Ihre App.py sollte nach der Ausführung so aussehen:

Jetzt besteht der letzte Schritt darin, diese Änderungen in Ihrem Github -Repository zu begehen und das Modell online auf jedem Cloud -Server bereitzustellen. Für dieses Projekt werden wir die App.py auf einem kostenlosen Render -Server bereitstellen, und Sie können dies auch tun.

Gehen Sie zu render.com und verbinden Sie Ihr Github -Repository des Projekts an Rendern.

Das ist es. Sie haben Ihr erstes MLOPS -Projekt erfolgreich erstellt. Hoffe es hat dir gefallen!

Schlussfolgerung

mlops ist zu einer unverzichtbaren Praxis bei der Verwaltung der Komplexität von Workflows für maschinelles Lernen, von der Aufnahme von Daten bis zur Modellierung. Durch die Nutzung von Zenml, einem Open-Source-MLOPS-Framework, haben wir den Prozess der Erstellung, Schulung und Einführung eines ML-Modells für die CLTV (CLTV) für den Kundenlebensdauer (CLTV) optimiert. Durch modulare Codierung, robuste Pipelines und nahtlose Integrationen haben wir gezeigt, wie ein End-to-End-Projekt effizient erstellt werden. Da Unternehmen zunehmend auf KI-gesteuerte Lösungen angewiesen sind, werden Rahmenbedingungen wie ZENML-Teams mit minimalem manuellen Eingreifen die Skalierbarkeit, Reproduzierbarkeit und Leistung aufrechterhalten.

Key Takeaways

• mlops vereinfacht den ML -Lebenszyklus, reduziert Fehler und erhöht die Effizienz durch automatisierte Pipelines.
• ZenML bietet modulare, wiederverwendbare Codierungsstrukturen für die Verwaltung maschineller Lernflows.
• Erstellen einer End-to-End-Pipeline beinhaltet die Definition klarer Schritte, von der Aufnahme von Daten bis zum Einsatz.
• Bereitstellungspipelines und Flask-Apps stellen sicher, dass ML-Modelle produktionsbereit und zugänglich sind.
• Tools wie ZenML und MLFlow ermöglichen eine nahtlose Verfolgung, Überwachung und Optimierung von ML -Projekten.

häufig gestellte Fragen

Q1. Was ist Mlops und warum ist es wichtig?

a. MLOPS (maschinelles Lernen) strationziiert den ML -Lebenszyklus, indem sie Prozesse wie Datenaufnahme, Modelltraining, Bereitstellung und Überwachung, Gewährleistung der Effizienz und Skalierbarkeit automatisieren.

Q2. Wofür wird Zenml verwendet?

a. Zenml ist ein Open-Source-MLOPS-Framework, das die Entwicklung, Bereitstellung und Verwaltung von Workflows für maschinelles Lernen mit modularem und wiederverwendbarem Code vereinfacht.

Q3. Kann ich ZENML unter Windows verwenden?

a. ZENML wird unter Windows nicht direkt unterstützt, kann jedoch mit WSL (Windows -Subsystem für Linux) verwendet werden.

Q4. Was ist der Zweck von Pipelines in Zenml?

a. Pipelines in Zenml definieren eine Sequenz von Schritten und gewährleisten einen strukturierten und wiederverwendbaren Workflow für maschinelle Lernprojekte.

Q5. Wie integriert sich die Flask -App mit dem ML -Modell?

a. Die Flask-App dient als Benutzeroberfläche, sodass Endbenutzer Daten eingeben und Vorhersagen aus dem bereitgestellten ML-Modell empfangen können.

Das obige ist der detaillierte Inhalt vonMlops mit ZENML -Projekt verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!