La révolution de l'IA est à nos portes, mais entre ce chaos, une question très critique est négligé par la plupart d'entre nous - comment maintenons-nous ces systèmes d'IA sophistiqués? C’est là que les opérations d’apprentissage automatique (MLOPS) entrent en jeu. Dans ce blog, nous comprendrons l'importance des Mlops avec ZenML, un cadre MOPLOP open source, en créant un projet de bout en bout.
Cet article a été publié dans le cadre du Data Science Blogathon.
MLOPS permet aux ingénieurs d'apprentissage automatique à rationaliser le processus d'un cycle de vie du modèle ML. Le production d'apprentissage automatique est difficile. Le cycle de vie de l'apprentissage automatique se compose de nombreux composants complexes tels que l'ingestion de données, la préparation des données, la formation du modèle, le réglage du modèle, le déploiement du modèle, la surveillance du modèle, l'explication et bien plus encore. MLOPS automatise chaque étape du processus via des pipelines robustes pour réduire les erreurs manuelles. Il s'agit d'une pratique collaborative pour faciliter votre infrastructure d'IA avec un minimum d'efforts manuels et des opérations maximales efficaces. Considérez les Mlops comme les DevOps pour l'industrie de l'IA avec certaines épices.
ZENML est un cadre MOLPS open source qui simplifie le développement, le déploiement et la gestion des flux de travail d'apprentissage automatique. En exploitant le principe des MLOPS, il s'intègre de manière transparente à divers outils et infrastructures qui offre à l'utilisateur une approche modulaire pour maintenir leurs flux de travail d'IA sous un seul lieu de travail. ZenML fournit des fonctionnalités telles que les logicales automatiques, le tracker Meta-Data, le tracker de modèle, le tracker d'expérience, le magasin d'artefact et les décorateurs de python simples pour la logique de base sans configurations complexes.
Maintenant, nous comprendrons comment MOPLS est mis en œuvre à l'aide d'un projet de science des données de qualité et de production de bout en bout. Dans ce projet, nous créerons et déploierons un modèle d'apprentissage automatique pour prédire la valeur du client (CLTV) d'un client. CLTV est une métrique clé utilisée par les entreprises pour voir dans quelle mesure elles profiteront ou la perte d'un client à long terme. En utilisant cette métrique, une entreprise peut choisir de dépenser ou non pour le client pour les annonces ciblées, etc.
Permet de commencer à implémenter le projet dans la section suivante.
Permet désormais de passer directement aux configurations du projet. Tout d'abord, nous devons télécharger l'ensemble de données de vente au détail en ligne à partir du référentiel d'apprentissage automatique UCI. ZENML n'est pas pris en charge sur Windows, donc nous devons utiliser Linux (WSL dans Windows) ou MacOS. Téléchargez ensuite les exigences.txt. Passons maintenant au terminal pour quelques configurations.
# 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
Maintenant, connectez-vous simplement dans le tableau de bord ZENML avec les informations d'identification de connexion par défaut (aucun mot de passe requis).
Félicitations, vous avez terminé avec succès les configurations du projet.
Il est maintenant temps de nous salir les mains avec les données. Nous allons créer un cahier ajupyter pour analyser nos données.
pro adoptif : Faites votre propre analyse sans me suivre.
ou vous pouvez simplement suivre ce cahier où nous avons créé différentes méthodes d'analyse de données à utiliser dans notre projet.
Maintenant, en supposant que vous avez effectué votre part d'analyse des données, sautons directement à la partie épicée.
Pour l'augmentation de la modularité et de la réusable de notre code, le décorateur @Step est utilisé à partir de zenml qui organise notre code pour passer dans les pipelines sans tracas en réduisant les chances d'erreur.
Dans notre dossier source, nous écrivons des méthodes pour chaque étape avant de les initialiser. Nous suivons les modèles de conception du système pour chacune de nos méthodes en créant une méthode abstraite pour les stratégies de chaque méthode (ingestion de données, nettoyage des données, ingénierie des fonctionnalités, etc.)
Échantillon du code pour 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 csvNous suivrons ce modèle pour créer le reste des méthodes. Vous pouvez copier les codes du référentiel GitHub donné.
Après avoir écrit toutes les méthodes, il est temps d'initialiser les étapes zenml dans notre dossier de pas. Maintenant, toutes les méthodes que nous avons créées jusqu'à présent seront utilisées dans les étapes zenml en conséquence.
Exemple de code du 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 dfNous suivrons le même modèle que ci-dessus pour la création du reste des étapes zenml de notre projet. Vous pouvez les copier à partir d'ici.
wow! Félicitations pour la création et l'apprentissage de l'une des parties les plus importantes des MOPL. Il est normal de devenir un peu dépassé car c'est votre première fois. Ne prenez pas trop de stress car tout aura du sens lorsque vous exécuterez votre premier modèle ML de grade de production.
Il est temps de construire nos pipelines. Non, ne pas transporter de l'eau ou de l'huile. Les pipelines sont des séries d'étapes organisées dans un ordre spécifique pour former notre flux de travail d'apprentissage automatique complet. Le décorateur @pipeline est utilisé dans ZENML pour spécifier un pipeline qui contiendra les étapes que nous avons créées ci-dessus. Cette approche garantit que nous pouvons utiliser la sortie d'une étape comme entrée pour l'étape suivante.
voici notre formation_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
Maintenant, nous pouvons exécuter le Training_Pipeline.py pour former notre modèle ML en un seul clic. Vous pouvez vérifier le pipeline dans votre tableau de bord Zenml:
Nous pouvons vérifier les détails de notre modèle et former plusieurs modèles et les comparer dans le tableau de bord MLFlow en exécutant le code suivant dans le 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 csvEnsuite, nous créerons le déploiement_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 dfAlors que nous exécutons le pipeline de déploiement, nous aurons une vue comme celle-ci dans notre tableau de bord Zenml:
Félicitations Vous avez déployé le meilleur modèle en utilisant mlflow et zenml dans votre instance locale.
Notre prochaine étape consiste à créer une application Flask qui projetera notre modèle à l'utilisateur final. Pour cela, nous devons créer une app.py et un index.html dans le dossier Modèles. Suivez le code ci-dessous pour créer l'application.py:
#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()Pour créer le fichier index.html, suivez les codes ci-dessous:
mlflow ui
votre app.py devrait ressembler à ceci après l'exécution:
Maintenant, la dernière étape consiste à commettre ces modifications dans votre référentiel GitHub et à déployer le modèle en ligne sur n'importe quel serveur cloud, pour ce projet, nous déploierons l'App.py sur un serveur de rendu gratuit et vous pouvez aussi le faire.
allez sur rendu.com et connectez votre référentiel GitHub du projet à rendre.
c'est tout. Vous avez réussi à créer votre premier projet MOLPS. J'espère que vous l'avez apprécié!
MLOPS est devenu une pratique indispensable dans la gestion des complexités des flux de travail d'apprentissage automatique, de l'ingestion de données au déploiement du modèle. En tirant parti de ZenML, un cadre MOLPS open-source, nous avons rationalisé le processus de construction, de formation et de déploiement d'un modèle ML de qualité de production pour la prédiction de la valeur à vie du client (CLTV). Grâce à un codage modulaire, à des pipelines robustes et à des intégrations transparentes, nous avons démontré comment créer efficacement un projet de bout en bout. Comme les entreprises comptent de plus en plus sur des solutions dirigés par l'IA, des cadres comme les équipes ZENML permettent de maintenir l'évolutivité, la reproductibilité et les performances avec une intervention manuelle minimale.
Q2. À quoi sert Zenml? a. ZENML est un cadre MOLPS open-source qui simplifie le développement, le déploiement et la gestion des flux de travail d'apprentissage automatique avec du code modulaire et réutilisable.
Q3. Puis-je utiliser Zenml sur Windows? a. ZENML n'est pas directement pris en charge sous Windows mais peut être utilisé avec WSL (sous-système Windows pour Linux).
Q4. Quel est le but des pipelines en zenml? a. Les pipelines du ZENML définissent une séquence d'étapes, garantissant un flux de travail structuré et réutilisable pour les projets d'apprentissage automatique.
Q5. Comment l'application Flask s'intègre-t-elle au modèle ML? a. L'application FLASK sert d'interface utilisateur, permettant aux utilisateurs finaux de saisir des données et de recevoir des prédictions du modèle ML déployé.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
