Orchestrer les workflows d'apprentissage automatique basés sur Ray à l'aide d'Amazon SageMaker | Services Web Amazon

L'apprentissage automatique (ML) devient de plus en plus complexe à mesure que les clients tentent de résoudre des problèmes de plus en plus complexes. Cette complexité conduit souvent à la nécessité d'un ML distribué, dans lequel plusieurs machines sont utilisées pour entraîner un seul modèle. Bien que cela permette la parallélisation des tâches sur plusieurs nœuds, ce qui entraîne des temps de formation accélérés, une évolutivité améliorée et des performances améliorées, l'utilisation efficace du matériel distribué présente des défis importants. Les data scientists doivent relever des défis tels que le partitionnement des données, l'équilibrage de charge, la tolérance aux pannes et l'évolutivité. Les ingénieurs ML doivent gérer manuellement la parallélisation, la planification, les erreurs et les tentatives, ce qui nécessite un code d'infrastructure complexe.

Dans cet article, nous discutons des avantages de l'utilisation Ray ainsi que Amazon Sage Maker pour le ML distribué, et fournissez un guide étape par étape sur la façon d'utiliser ces frameworks pour créer et déployer un workflow de ML évolutif.

Ray, un framework informatique distribué open source, fournit un cadre flexible pour la formation distribuée et le service de modèles ML. Il résume les détails du système distribué de bas niveau grâce à des bibliothèques simples et évolutives pour les tâches de ML courantes telles que le prétraitement des données, la formation distribuée, le réglage des hyperparamètres, l'apprentissage par renforcement et la diffusion de modèles.

SageMaker est un service entièrement géré pour la création, la formation et le déploiement de modèles ML. Ray s'intègre de manière transparente aux fonctionnalités de SageMaker pour créer et déployer des charges de travail de ML complexes, à la fois efficaces et fiables. La combinaison de Ray et de SageMaker offre des fonctionnalités de bout en bout pour les flux de travail de ML évolutifs et présente les fonctionnalités suivantes :

• Les acteurs distribués et les constructions de parallélisme dans Ray simplifient le développement d'applications distribuées.
• Ray AI Runtime (AIR) réduit les frictions liées au passage du développement à la production. Avec Ray et AIR, le même code Python peut évoluer de manière transparente d'un ordinateur portable à un grand cluster.
• L'infrastructure gérée de SageMaker et les fonctionnalités telles que les tâches de traitement, les tâches de formation et les tâches de réglage des hyperparamètres peuvent utiliser les bibliothèques Ray en dessous pour l'informatique distribuée.
• Expériences Amazon SageMaker permet d'itérer et de suivre rapidement les essais.
• Magasin de fonctionnalités Amazon SageMaker fournit un référentiel évolutif pour stocker, récupérer et partager des fonctionnalités de ML pour la formation de modèles.
• Les modèles entraînés peuvent être stockés, versionnés et suivis dans Registre de modèles Amazon SageMaker pour la gouvernance et la gestion.

• Pipelines Amazon SageMaker permet d'orchestrer le cycle de vie du ML de bout en bout, depuis la préparation des données et la formation jusqu'au déploiement de modèles sous forme de flux de travail automatisés.

Vue d'ensemble de la solution

Cet article se concentre sur les avantages de l'utilisation conjointe de Ray et SageMaker. Nous avons mis en place un workflow ML de bout en bout basé sur Ray, orchestré à l'aide de SageMaker Pipelines. Le flux de travail comprend l'ingestion parallèle de données dans le magasin de fonctionnalités à l'aide d'acteurs Ray, le prétraitement des données avec Ray Data, la formation de modèles et le réglage des hyperparamètres à grande échelle à l'aide de Ray Train et des tâches de réglage de l'optimisation des hyperparamètres (HPO), et enfin l'évaluation du modèle et l'enregistrement du modèle dans un registre des modèles.

Pour nos données, nous utilisons un ensemble de données synthétiques sur le logement qui se compose de huit fonctionnalités (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCHet une DECK) et notre modèle prédira le PRICE de la maison.

Chaque étape du flux de travail ML est divisée en étapes distinctes, avec son propre script qui prend les paramètres d'entrée et de sortie. Dans la section suivante, nous mettons en évidence les extraits de code clés de chaque étape. Le code complet peut être trouvé sur le Dépôt GitHub aws-samples-for-ray.

Pré-requis

Pour utiliser le SDK SageMaker Python et exécuter le code associé à cet article, vous avez besoin des prérequis suivants :

Ingérer des données dans SageMaker Feature Store

La première étape du workflow ML consiste à lire le fichier de données source à partir de Service de stockage simple Amazon (Amazon S3) au format CSV et ingérez-le dans SageMaker Feature Store. SageMaker Feature Store est un référentiel spécialement conçu qui permet aux équipes de créer, partager et gérer facilement des fonctionnalités de ML. Il simplifie la découverte, la réutilisation et le partage des fonctionnalités, conduisant à un développement plus rapide, à une collaboration accrue au sein des équipes clients et à une réduction des coûts.

L'ingestion de fonctionnalités dans le magasin de fonctionnalités comprend les étapes suivantes :

1. Définissez un groupe de fonctionnalités et créez le groupe de fonctionnalités dans le magasin de fonctionnalités.
2. Préparez les données sources pour le magasin de fonctionnalités en ajoutant une heure d'événement et un ID d'enregistrement pour chaque ligne de données.
3. Ingérez les données préparées dans le groupe de fonctionnalités à l'aide du SDK Boto3.

Dans cette section, nous mettons uniquement en évidence l'étape 3, car il s'agit de la partie qui implique le traitement parallèle de la tâche d'ingestion à l'aide de Ray. Vous pouvez consulter le code complet de ce processus dans le GitHub repo.

La ingérer_fonctionnalités La méthode est définie dans une classe appelée Featurestore. Notez que le Featurestore la classe est décorée avec @ray.remote. Cela indique qu'une instance de cette classe est un acteur Ray, une unité de calcul avec état et concurrente au sein de Ray. Il s'agit d'un modèle de programmation qui vous permet de créer des objets distribués qui conservent un état interne et sont accessibles simultanément par plusieurs tâches exécutées sur différents nœuds d'un cluster Ray. Les acteurs fournissent un moyen de gérer et d'encapsuler l'état mutable, ce qui les rend utiles pour créer des applications complexes et avec état dans un environnement distribué. Vous pouvez également spécifier les besoins en ressources des acteurs. Dans ce cas, chaque instance du FeatureStore la classe nécessitera 0.5 processeurs. Voir le code suivant :

@ray.remote(num_cpus=0.5)
class Featurestore: def ingest_features(self,feature_group_name, df, region): """ Ingest features to Feature Store Group Args: feature_group_name (str): Feature Group Name data_path (str): Path to the train/validation/test data in CSV format. """ ...

Vous pouvez interagir avec l'acteur en appelant le remote opérateur. Dans le code suivant, le nombre d'acteurs souhaité est transmis comme argument d'entrée au script. Les données sont ensuite partitionnées en fonction du nombre d'acteurs et transmises aux processus parallèles distants pour être ingérées dans le magasin de fonctionnalités. Tu peux appeler get sur la référence de l'objet pour bloquer l'exécution de la tâche en cours jusqu'à ce que le calcul à distance soit terminé et que le résultat soit disponible. Lorsque le résultat est disponible, ray.get renverra le résultat et l'exécution de la tâche en cours se poursuivra.

import modin.pandas as pd
import ray df = pd.read_csv(s3_path)
data = prepare_df_for_feature_store(df)
# Split into partitions
partitions = [ray.put(part) for part in np.array_split(data, num_actors)]
# Start actors and assign partitions in a loop
actors = [Featurestore.remote() for _ in range(args.num_actors)]
results = [] for actor, partition in zip(actors, input_partitions): results.append(actor.ingest_features.remote( args.feature_group_name, partition, args.region ) ) ray.get(results)

Préparer les données pour la formation, la validation et les tests

Dans cette étape, nous utilisons Ray Dataset pour diviser, transformer et mettre à l'échelle efficacement notre ensemble de données en vue de l'apprentissage automatique. Ray Dataset fournit un moyen standard de charger des données distribuées dans Ray, prenant en charge divers systèmes de stockage et formats de fichiers. Il dispose d'API pour les opérations courantes de prétraitement des données ML telles que les transformations parallèles, le brassage, le regroupement et les agrégations. Ray Dataset gère également les opérations nécessitant une configuration avec état et une accélération GPU. Il s'intègre facilement à d'autres bibliothèques de traitement de données telles que Spark, Pandas, NumPy, etc., ainsi qu'à des frameworks ML tels que TensorFlow et PyTorch. Cela permet de créer des pipelines de données de bout en bout et des flux de travail ML au-dessus de Ray. L’objectif est de faciliter le traitement distribué des données et le ML pour les praticiens et les chercheurs.

Examinons les sections des scripts qui effectuent ce prétraitement des données. Nous commençons par charger les données depuis le feature store :

def load_dataset(feature_group_name, region): """ Loads the data as a ray dataset from the offline featurestore S3 location Args: feature_group_name (str): name of the feature group Returns: ds (ray.data.dataset): Ray dataset the contains the requested dat from the feature store """ session = sagemaker.Session(boto3.Session(region_name=region)) fs_group = FeatureGroup( name=feature_group_name, sagemaker_session=session ) fs_data_loc = fs_group.describe().get("OfflineStoreConfig").get("S3StorageConfig").get("ResolvedOutputS3Uri") # Drop columns added by the feature store # Since these are not related to the ML problem at hand cols_to_drop = ["record_id", "event_time","write_time", "api_invocation_time", "is_deleted", "year", "month", "day", "hour"] ds = ray.data.read_parquet(fs_data_loc) ds = ds.drop_columns(cols_to_drop) print(f"{fs_data_loc} count is {ds.count()}") return ds

Nous divisons et mettons ensuite à l'échelle les données en utilisant les abstractions de niveau supérieur disponibles dans le ray.data bibliothèque:

def split_dataset(dataset, train_size, val_size, test_size, random_state=None): """ Split dataset into train, validation and test samples Args: dataset (ray.data.Dataset): input data train_size (float): ratio of data to use as training dataset val_size (float): ratio of data to use as validation dataset test_size (float): ratio of data to use as test dataset random_state (int): Pass an int for reproducible output across multiple function calls. Returns: train_set (ray.data.Dataset): train dataset val_set (ray.data.Dataset): validation dataset test_set (ray.data.Dataset): test dataset """ # Shuffle this dataset with a fixed random seed. shuffled_ds = dataset.random_shuffle(seed=random_state) # Split the data into train, validation and test datasets train_set, val_set, test_set = shuffled_ds.split_proportionately([train_size, val_size]) return train_set, val_set, test_set def scale_dataset(train_set, val_set, test_set, target_col): """ Fit StandardScaler to train_set and apply it to val_set and test_set Args: train_set (ray.data.Dataset): train dataset val_set (ray.data.Dataset): validation dataset test_set (ray.data.Dataset): test dataset target_col (str): target col Returns: train_transformed (ray.data.Dataset): train data scaled val_transformed (ray.data.Dataset): val data scaled test_transformed (ray.data.Dataset): test data scaled """ tranform_cols = dataset.columns() # Remove the target columns from being scaled tranform_cols.remove(target_col) # set up a standard scaler standard_scaler = StandardScaler(tranform_cols) # fit scaler to training dataset print("Fitting scaling to training data and transforming dataset...") train_set_transformed = standard_scaler.fit_transform(train_set) # apply scaler to validation and test datasets print("Transforming validation and test datasets...") val_set_transformed = standard_scaler.transform(val_set) test_set_transformed = standard_scaler.transform(test_set) return train_set_transformed, val_set_transformed, test_set_transformed

Les ensembles de données d'entraînement, de validation et de test traités sont stockés dans Amazon S3 et seront transmis comme paramètres d'entrée aux étapes suivantes.

Effectuer la formation du modèle et l'optimisation des hyperparamètres

Une fois nos données prétraitées et prêtes pour la modélisation, il est temps de former certains modèles de ML et d'affiner leurs hyperparamètres pour maximiser les performances prédictives. Nous utilisons XGBoost-Ray, un backend distribué pour XGBoost construit sur Ray qui permet d'entraîner des modèles XGBoost sur de grands ensembles de données en utilisant plusieurs nœuds et GPU. Il fournit des remplacements simples pour les API de formation et de prédiction de XGBoost tout en gérant les complexités de la gestion des données distribuées et de la formation sous le capot.

Pour permettre la distribution de la formation sur plusieurs nœuds, nous utilisons une classe d'assistance nommée RayHelper. Comme le montre le code suivant, nous utilisons la configuration des ressources de la tâche de formation et choisissons le premier hôte comme nœud principal :

class RayHelper(): def __init__(self, ray_port:str="9339", redis_pass:str="redis_password"): .... self.resource_config = self.get_resource_config() self.head_host = self.resource_config["hosts"][0] self.n_hosts = len(self.resource_config["hosts"])

Nous pouvons utiliser les informations de l'hôte pour décider comment initialiser Ray sur chacune des instances de tâche de formation :

def start_ray(self): head_ip = self._get_ip_from_host() # If the current host is the host choosen as the head node # run `ray start` with specifying the --head flag making this is the head node if self.resource_config["current_host"] == self.head_host: output = subprocess.run(['ray', 'start', '--head', '-vvv', '--port', self.ray_port, '--redis-password', self.redis_pass, '--include-dashboard', 'false'], stdout=subprocess.PIPE) print(output.stdout.decode("utf-8")) ray.init(address="auto", include_dashboard=False) self._wait_for_workers() print("All workers present and accounted for") print(ray.cluster_resources()) else: # If the current host is not the head node, # run `ray start` with specifying ip address as the head_host as the head node time.sleep(10) output = subprocess.run(['ray', 'start', f"--address={head_ip}:{self.ray_port}", '--redis-password', self.redis_pass, "--block"], stdout=subprocess.PIPE) print(output.stdout.decode("utf-8")) sys.exit(0)

Lorsqu'une tâche de formation est démarrée, un cluster Ray peut être initialisé en appelant le start_ray() méthode sur une instance de RayHelper:

if __name__ == '__main__': ray_helper = RayHelper() ray_helper.start_ray() args = read_parameters() sess = sagemaker.Session(boto3.Session(region_name=args.region))

Nous utilisons ensuite le formateur XGBoost de XGBoost-Ray pour la formation :

def train_xgboost(ds_train, ds_val, params, num_workers, target_col = "price") -> Result: """ Creates a XGBoost trainer, train it, and return the result. Args: ds_train (ray.data.dataset): Training dataset ds_val (ray.data.dataset): Validation dataset params (dict): Hyperparameters num_workers (int): number of workers to distribute the training across target_col (str): target column Returns: result (ray.air.result.Result): Result of the training job """ train_set = RayDMatrix(ds_train, 'PRICE') val_set = RayDMatrix(ds_val, 'PRICE') evals_result = {} trainer = train( params=params, dtrain=train_set, evals_result=evals_result, evals=[(val_set, "validation")], verbose_eval=False, num_boost_round=100, ray_params=RayParams(num_actors=num_workers, cpus_per_actor=1), ) output_path=os.path.join(args.model_dir, 'model.xgb') trainer.save_model(output_path) valMAE = evals_result["validation"]["mae"][-1] valRMSE = evals_result["validation"]["rmse"][-1] print('[3] #011validation-mae:{}'.format(valMAE)) print('[4] #011validation-rmse:{}'.format(valRMSE)) local_testing = False try: load_run(sagemaker_session=sess) except: local_testing = True if not local_testing: # Track experiment if using SageMaker Training with load_run(sagemaker_session=sess) as run: run.log_metric('validation-mae', valMAE) run.log_metric('validation-rmse', valRMSE)

Notez que lors de l'instanciation du trainer, Nous passons RayParams, qui prend le nombre d'acteurs et le nombre de CPU par acteur. XGBoost-Ray utilise ces informations pour distribuer la formation sur tous les nœuds attachés au cluster Ray.

Nous créons maintenant un objet estimateur XGBoost basé sur le SDK SageMaker Python et l'utilisons pour le travail HPO.

Orchestrer les étapes précédentes à l'aide de SageMaker Pipelines

Pour créer un workflow ML évolutif et réutilisable de bout en bout, nous devons utiliser un outil CI/CD pour orchestrer les étapes précédentes dans un pipeline. SageMaker Pipelines est directement intégré à SageMaker, au SDK SageMaker Python et à SageMaker Studio. Cette intégration vous permet de créer des flux de travail ML avec un SDK Python facile à utiliser, puis de visualiser et de gérer votre flux de travail à l'aide de SageMaker Studio. Vous pouvez également suivre l'historique de vos données au cours de l'exécution du pipeline et désigner des étapes de mise en cache.

SageMaker Pipelines crée un graphique acyclique dirigé (DAG) qui comprend les étapes nécessaires à la création d'un flux de travail ML. Chaque pipeline est une série d'étapes interconnectées orchestrées par des dépendances de données entre les étapes et peut être paramétrée, vous permettant de fournir des variables d'entrée comme paramètres pour chaque exécution du pipeline. SageMaker Pipelines propose quatre types de paramètres de pipeline : ParameterString, ParameterInteger, ParameterFloatet une ParameterBoolean. Dans cette section, nous paramétrons certaines des variables d'entrée et configurons la configuration de la mise en cache des étapes :

processing_instance_count = ParameterInteger( name='ProcessingInstanceCount', default_value=1
)
feature_group_name = ParameterString( name='FeatureGroupName', default_value='fs-ray-synthetic-housing-data'
)
bucket_prefix = ParameterString( name='Bucket_Prefix', default_value='aws-ray-mlops-workshop/feature-store'
)
rmse_threshold = ParameterFloat(name="RMSEThreshold", default_value=15000.0) train_size = ParameterString( name='TrainSize', default_value="0.6"
)
val_size = ParameterString( name='ValidationSize', default_value="0.2"
)
test_size = ParameterString( name='TestSize', default_value="0.2"
) cache_config = CacheConfig(enable_caching=True, expire_after="PT12H")

Nous définissons deux étapes de traitement : une pour l'ingestion de SageMaker Feature Store, l'autre pour la préparation des données. Cela devrait ressembler beaucoup aux étapes précédentes décrites précédemment. La seule nouvelle ligne de code est la ProcessingStep après la définition des étapes, ce qui nous permet de prendre la configuration de la tâche de traitement et de l'inclure comme étape du pipeline. Nous spécifions en outre la dépendance de l'étape de préparation des données sur l'étape d'ingestion de SageMaker Feature Store. Voir le code suivant :

feature_store_ingestion_step = ProcessingStep( name='FeatureStoreIngestion', step_args=fs_processor_args, cache_config=cache_config
) preprocess_dataset_step = ProcessingStep( name='PreprocessData', step_args=processor_args, cache_config=cache_config
)
preprocess_dataset_step.add_depends_on([feature_store_ingestion_step])

De même, pour construire une étape de formation et de réglage du modèle, nous devons ajouter une définition de TuningStep après le code de l'étape de formation du modèle pour nous permettre d'exécuter le réglage des hyperparamètres SageMaker en tant qu'étape du pipeline :

tuning_step = TuningStep( name="HPTuning", tuner=tuner, inputs={ "train": TrainingInput( s3_data=preprocess_dataset_step.properties.ProcessingOutputConfig.Outputs[ "train" ].S3Output.S3Uri, content_type="text/csv" ), "validation": TrainingInput( s3_data=preprocess_dataset_step.properties.ProcessingOutputConfig.Outputs[ "validation" ].S3Output.S3Uri, content_type="text/csv" ) }, cache_config=cache_config,
)
tuning_step.add_depends_on([preprocess_dataset_step])

Après l'étape de réglage, nous choisissons d'enregistrer le meilleur modèle dans le registre des modèles SageMaker. Pour contrôler la qualité du modèle, nous implémentons une porte de qualité minimale qui compare la meilleure métrique objective du modèle (RMSE) à un seuil défini comme paramètre d'entrée du pipeline. rmse_threshold. Pour effectuer cette évaluation, nous créons une autre étape de traitement pour exécuter un scénario d'évaluation. Le résultat de l'évaluation du modèle sera stocké sous forme de fichier de propriétés. Les fichiers de propriétés sont particulièrement utiles lors de l'analyse des résultats d'une étape de traitement afin de décider comment les autres étapes doivent être exécutées. Voir le code suivant :

# Specify where we'll store the model evaluation results so that other steps can access those results
evaluation_report = PropertyFile( name='EvaluationReport', output_name='evaluation', path='evaluation.json',
) # A ProcessingStep is used to evaluate the performance of a selected model from the HPO step. # In this case, the top performing model is evaluated. evaluation_step = ProcessingStep( name='EvaluateModel', processor=evaluation_processor, inputs=[ ProcessingInput( source=tuning_step.get_top_model_s3_uri( top_k=0, s3_bucket=bucket, prefix=s3_prefix ), destination='/opt/ml/processing/model', ), ProcessingInput( source=preprocess_dataset_step.properties.ProcessingOutputConfig.Outputs['test'].S3Output.S3Uri, destination='/opt/ml/processing/test', ), ], outputs=[ ProcessingOutput( output_name='evaluation', source='/opt/ml/processing/evaluation' ), ], code='./pipeline_scripts/evaluate/script.py', property_files=[evaluation_report],
)

Nous définissons un ModelStep pour enregistrer le meilleur modèle dans le registre de modèles SageMaker dans notre pipeline. Dans le cas où le meilleur modèle ne passe pas notre contrôle de qualité prédéterminé, nous spécifions en outre un FailStep pour afficher un message d'erreur :

register_step = ModelStep( name='RegisterTrainedModel', step_args=model_registry_args
) metrics_fail_step = FailStep( name="RMSEFail", error_message=Join(on=" ", values=["Execution failed due to RMSE >", rmse_threshold]),
)

Ensuite, nous utilisons un ConditionStep pour évaluer si l'étape d'enregistrement du modèle ou l'étape d'échec doit être franchie ensuite dans le pipeline. Dans notre cas, le meilleur modèle sera enregistré si son score RMSE est inférieur au seuil.

# Condition step for evaluating model quality and branching execution
cond_lte = ConditionLessThanOrEqualTo( left=JsonGet( step_name=evaluation_step.name, property_file=evaluation_report, json_path='regression_metrics.rmse.value', ), right=rmse_threshold,
)
condition_step = ConditionStep( name='CheckEvaluation', conditions=[cond_lte], if_steps=[register_step], else_steps=[metrics_fail_step],
)

Enfin, nous orchestrons toutes les étapes définies dans un pipeline :

pipeline_name = 'synthetic-housing-training-sm-pipeline-ray'
step_list = [ feature_store_ingestion_step, preprocess_dataset_step, tuning_step, evaluation_step, condition_step ] training_pipeline = Pipeline( name=pipeline_name, parameters=[ processing_instance_count, feature_group_name, train_size, val_size, test_size, bucket_prefix, rmse_threshold ], steps=step_list
) # Note: If an existing pipeline has the same name it will be overwritten.
training_pipeline.upsert(role_arn=role_arn)

Le pipeline précédent peut être visualisé et exécuté directement dans SageMaker Studio, ou être exécuté en appelant execution = training_pipeline.start(). La figure suivante illustre le flux du pipeline.

De plus, nous pouvons examiner la lignée des artefacts générés par l'exécution du pipeline.

from sagemaker.lineage.visualizer import LineageTableVisualizer viz = LineageTableVisualizer(sagemaker.session.Session())
for execution_step in reversed(execution.list_steps()): print(execution_step) display(viz.show(pipeline_execution_step=execution_step)) time.sleep(5)

Déployer le modèle

Une fois le meilleur modèle enregistré dans SageMaker Model Registry via une exécution de pipeline, nous déployons le modèle sur un point de terminaison en temps réel en utilisant les capacités de déploiement de modèles entièrement gérées de SageMaker. SageMaker propose d'autres options de déploiement de modèles pour répondre aux besoins de différents cas d'utilisation. Pour plus de détails, reportez-vous à Déployer des modèles pour l'inférence lorsque vous choisissez la bonne option pour votre cas d'utilisation. Commençons par enregistrer le modèle dans le registre des modèles SageMaker :

xgb_regressor_model = ModelPackage( role_arn, model_package_arn=model_package_arn, name=model_name
)

L'état actuel du modèle est PendingApproval. Nous devons définir son statut sur Approved avant le déploiement :

sagemaker_client.update_model_package( ModelPackageArn=xgb_regressor_model.model_package_arn, ModelApprovalStatus='Approved'
) xgb_regressor_model.deploy( initial_instance_count=1, instance_type='ml.m5.xlarge', endpoint_name=endpoint_name
)

Nettoyer

Une fois vos expériences terminées, n'oubliez pas de nettoyer les ressources pour éviter des frais inutiles. Pour nettoyer, supprimez le point de terminaison en temps réel, le groupe de modèles, le pipeline et le groupe de fonctionnalités en appelant les API. Supprimer le point de terminaison, SupprimerModelPackageGroup, Supprimer le pipelineet une SupprimerFeatureGroup, respectivement, et arrêtez toutes les instances de bloc-notes SageMaker Studio.

Conclusion

Cet article présente une procédure pas à pas sur la façon d'utiliser SageMaker Pipelines pour orchestrer les flux de travail ML basés sur Ray. Nous avons également démontré la capacité de SageMaker Pipelines à s'intégrer à des outils ML tiers. Il existe différents services AWS qui prennent en charge les charges de travail Ray de manière évolutive et sécurisée pour garantir l'excellence des performances et l'efficacité opérationnelle. C'est maintenant à votre tour d'explorer ces puissantes fonctionnalités et de commencer à optimiser vos flux de travail d'apprentissage automatique avec Amazon SageMaker Pipelines et Ray. Passez à l'action dès aujourd'hui et libérez tout le potentiel de vos projets ML !

---

À propos de l’auteur

Raju Rangan est architecte de solutions senior chez Amazon Web Services (AWS). Il travaille avec des entités parrainées par le gouvernement, les aidant à créer des solutions d'IA/ML à l'aide d'AWS. Lorsqu'il n'est pas en train de bricoler des solutions cloud, vous le surprendrez à traîner en famille ou à écraser des birdies dans une partie de badminton animée avec des amis.

Xérès Ding est un architecte senior de solutions spécialisées en IA/ML chez Amazon Web Services (AWS). Elle possède une vaste expérience en apprentissage automatique avec un doctorat en informatique. Elle travaille principalement avec des clients du secteur public sur divers défis commerciaux liés à l'IA/ML, les aidant à accélérer leur parcours d'apprentissage automatique sur le cloud AWS. Lorsqu’elle n’aide pas les clients, elle aime les activités de plein air.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• Décalages de bloc. Modernisation de la propriété des compensations environnementales. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/