Rumah >Peranti teknologi >AI >Memahami MLOPS dengan Projek ZenML

Memahami MLOPS dengan Projek ZenML

Lisa Kudrowasal: 2025-03-08 11:16:09493semak imbas

Revolusi AI ada pada kita, tetapi di antara kekacauan ini, soalan yang sangat kritikal diabaikan oleh kebanyakan kita - bagaimana kita mengekalkan sistem AI yang canggih ini? Di sinilah Operasi Pembelajaran Mesin (MLOPS) dimainkan. Dalam blog ini, kita akan memahami kepentingan MLOPS dengan ZENML, rangka kerja MLOPS sumber terbuka, dengan membina projek akhir-ke-akhir.

Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data

Jadual Kandungan Apa itu Mlops? Pipelines Soalan Lazim

Apa itu mlops?

MLOPS memberi kuasa kepada jurutera pembelajaran mesin untuk menyelaraskan proses kitaran hayat model ML. Pembelajaran mesin pengeluaran adalah sukar. Kitaran hayat pembelajaran mesin terdiri daripada banyak komponen yang kompleks seperti Data ingest, Prep Data, Latihan Model, Penalaan Model, Penggunaan Model, Pemantauan Model, Keterlaluan, dan banyak lagi. MLOPS mengautomasikan setiap langkah proses melalui saluran paip yang mantap untuk mengurangkan kesilapan manual. Ini adalah amalan kerjasama untuk meringankan infrastruktur AI anda dengan usaha manual minimum dan operasi yang cekap maksimum. Fikirkan MLOPS sebagai DevOps untuk industri AI dengan beberapa rempah.
Apa itu zenml?
ZENML adalah rangka kerja MLOPS sumber terbuka yang memudahkan pembangunan, penempatan dan pengurusan alur kerja pembelajaran mesin. Dengan memanfaatkan prinsip MLOPS, ia secara lancar mengintegrasikan dengan pelbagai alat dan infrastruktur yang menawarkan pengguna pendekatan modular untuk mengekalkan aliran kerja AI mereka di bawah satu tempat kerja. ZenML menyediakan ciri-ciri seperti log auto, pelacak meta-data, pelacak model, pelacak eksperimen, kedai artifak dan penghias python mudah untuk logik teras tanpa konfigurasi kompleks.

Konfigurasi awal

Sekarang mari masuk terus ke dalam konfigurasi projek. Pertama, kita perlu memuat turun dataset runcit dalam talian dari UCI Machine Learning Repository. ZenML tidak disokong pada tingkap, jadi sama ada kita perlu menggunakan Linux (WSL di Windows) atau macOS. Seterusnya muat turun keperluan.txt. Sekarang marilah kita meneruskan ke terminal untuk beberapa konfigurasi.

# 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

sekarang hanya log masuk ke papan pemuka ZENML dengan kelayakan log masuk lalai (tiada kata laluan diperlukan).

Tahniah anda telah berjaya menyelesaikan konfigurasi projek.

Analisis Data Exploratory (EDA)

Sekarang masanya untuk mendapatkan tangan kita kotor dengan data. Kami akan membuat buku nota Ajupyter untuk menganalisis data kami.

tip pro : Lakukan analisis anda sendiri tanpa mengikuti saya.

atau anda hanya boleh mengikuti bersama dengan buku nota ini di mana kami telah membuat kaedah analisis data yang berbeza untuk digunakan dalam projek kami.

Sekarang, dengan asumsi anda telah melakukan bahagian analisis data anda, mari melompat terus ke bahagian pedas.

Menentukan langkah -langkah untuk zenml sebagai pengekodan modular

Untuk meningkatkan modularity dan reusablity kod kami, penghias @Step digunakan dari ZenML yang menganjurkan kod kami untuk masuk ke dalam saluran paip yang mudah mengurangkan peluang kesilapan.

Dalam folder sumber kami, kami akan menulis kaedah untuk setiap langkah sebelum memulakannya. Kami kami mengikuti corak reka bentuk sistem untuk setiap kaedah kami dengan mewujudkan kaedah abstrak untuk strategi setiap kaedah (pengambilan data, pembersihan data, kejuruteraan ciri, dan lain -lain)

kod contoh data ingest

sampel kod untuk 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

Kami akan mengikuti corak ini untuk membuat kaedah lain. Anda boleh menyalin kod dari repositori GitHub yang diberikan.

Memahami MLOPS dengan Projek ZenML

Selepas menulis semua kaedah, sudah tiba masanya untuk memulakan langkah ZenML dalam folder Langkah kami. Sekarang semua kaedah yang telah kami buat sehingga sekarang, akan digunakan dalam langkah -langkah Zenml dengan sewajarnya.

Contoh kod pengambilan data

Contoh kod 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

Kami akan mengikuti corak yang sama seperti di atas untuk mewujudkan langkah -langkah ZenML dalam projek kami. Anda boleh menyalinnya dari sini.

wow! Tahniah untuk mewujudkan dan mempelajari salah satu bahagian yang paling penting di MLOPS. Tidak apa -apa untuk mendapatkan sedikit terkejut kerana ia adalah kali pertama anda. Jangan terlalu banyak tekanan kerana segala -galanya akan masuk akal apabila anda akan menjalankan model ML gred pengeluaran pertama anda.

Bangunan saluran paip

Masa untuk membina saluran paip kami. Tidak, tidak membawa air atau minyak. Pipelin adalah siri langkah yang dianjurkan dalam susunan khusus untuk membentuk aliran kerja pembelajaran mesin kami yang lengkap. Penghias @pipeline digunakan dalam ZenML untuk menentukan saluran paip yang akan mengandungi langkah -langkah yang kami buat di atas. Pendekatan ini memastikan bahawa kita boleh menggunakan output satu langkah sebagai input untuk langkah seterusnya.

inilah latihan kami_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

Sekarang kita boleh menjalankan latihan_pipeline.py untuk melatih model ML kami dalam satu klik. Anda boleh menyemak saluran paip di papan pemuka zenml anda:

Memahami MLOPS dengan Projek ZenML

Kami boleh menyemak butiran model kami dan juga melatih pelbagai model dan membandingkannya dalam papan pemuka MLFLOW dengan menjalankan kod berikut di terminal.

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

Membuat saluran paip penempatan

Seterusnya kita akan membuat Deployment_Pipeline.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

Semasa kami menjalankan saluran paip penempatan, kami akan mendapat pandangan seperti ini di papan pemuka Zenml kami:

~~Tahniah anda telah menggunakan model terbaik menggunakan MLFlow dan Zenml dalam contoh tempatan anda.~~

Buat App Flask

Langkah seterusnya adalah untuk membuat aplikasi Flask yang akan memproyeksikan model kami kepada pengguna akhir. Untuk itu kita perlu membuat app.py dan index.html dalam folder templat. Ikuti kod di bawah untuk membuat app.py:

Untuk membuat fail index.html, ikuti kod di bawah:

#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()

app.py anda sepatutnya kelihatan seperti ini selepas pelaksanaan:

mlflow ui

Sekarang langkah terakhir adalah untuk melakukan perubahan ini dalam repositori GitHub anda dan menggunakan model dalam talian pada mana -mana pelayan awan, untuk projek ini kami akan menggunakan app.py pada pelayan render percuma dan anda juga boleh melakukannya. Memahami MLOPS dengan Projek ZenML

pergi ke render.com dan sambungkan repositori github projek anda untuk diberikan.

itu sahaja. Anda telah berjaya mencipta projek MLOPS pertama anda. Semoga anda menikmatinya!

Kesimpulan

MLOPS telah menjadi amalan yang sangat diperlukan dalam menguruskan kerumitan aliran kerja pembelajaran mesin, dari pengambilan data untuk penggunaan model. Dengan memanfaatkan ZenML, rangka kerja MLOPS sumber terbuka, kami menyelaraskan proses bangunan, latihan, dan menggunakan model ML gred pengeluaran untuk ramalan nilai hayat pelanggan (CLTV). Melalui pengekodan modular, saluran paip yang mantap, dan integrasi yang lancar, kami menunjukkan cara membuat projek akhir-ke-akhir dengan cekap. Oleh kerana perniagaan semakin bergantung pada penyelesaian yang didorong oleh AI, kerangka seperti ZenML memberi kuasa kepada pasukan untuk mengekalkan skalabilitas, kebolehulangan, dan prestasi dengan campur tangan manual yang minimum.

Takeaways Key

MLOPS memudahkan kitaran hayat ML, mengurangkan kesilapan dan meningkatkan kecekapan melalui saluran paip automatik.
zenml menyediakan struktur pengekodan modular dan boleh diguna semula untuk menguruskan aliran kerja pembelajaran mesin.
Membina saluran paip akhir-ke-akhir melibatkan menentukan langkah-langkah yang jelas, dari pengambilan data untuk penempatan.
saluran paip dan aplikasi flask Pastikan model ML siap dan boleh diakses.
alat seperti zenml dan mlflow membolehkan penjejakan, pemantauan, dan pengoptimuman projek ML yang lancar.

Soalan Lazim

Q1. Apakah mlops, dan mengapa penting?

a. MLOPS (Operasi Pembelajaran Mesin) menyelaraskan kitaran hayat ML dengan mengautomasikan proses seperti pengambilan data, latihan model, penempatan, dan pemantauan, memastikan kecekapan dan skalabiliti.

Q2. Apakah zenml digunakan untuk? ~~a. ZENML adalah rangka kerja MLOPS sumber terbuka yang memudahkan pembangunan, penempatan, dan pengurusan aliran kerja pembelajaran mesin dengan kod modular dan boleh diguna semula.~~

Q3. Bolehkah saya menggunakan zenml pada Windows?

~~a. ZenML tidak disokong secara langsung pada Windows tetapi boleh digunakan dengan WSL (Subsistem Windows untuk Linux). Q4. Apakah tujuan saluran paip di zenml?~~

a. Pipelin dalam Zenml menentukan urutan langkah -langkah, memastikan aliran kerja berstruktur dan boleh diguna semula untuk projek pembelajaran mesin. Q5. Bagaimanakah aplikasi Flask diintegrasikan dengan model ML?

a. Aplikasi Flask berfungsi sebagai antara muka pengguna, yang membolehkan pengguna akhir memasukkan data dan menerima ramalan dari model ML yang digunakan.

Atas ialah kandungan terperinci Memahami MLOPS dengan Projek ZenML. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Python flask html define for Error auto using Interface copy default this input table github windows macos devops linux everything

Kenyataan：

Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn

Artikel sebelumnya：Elon Musk & Sam Altman bertembung lebih daripada $ 500 bilion projek StargateArtikel seterusnya：Elon Musk & Sam Altman bertembung lebih daripada $ 500 bilion projek Stargate

Artikel berkaitan

Lihat lagi