Orchestra flussi di lavoro di machine learning basati su Ray utilizzando Amazon SageMaker

Ripubblicato da Platone

Seguaci: 0

L'apprendimento automatico (ML) sta diventando sempre più complesso poiché i clienti cercano di risolvere problemi sempre più impegnativi. Questa complessità spesso porta alla necessità di un machine learning distribuito, in cui vengono utilizzate più macchine per addestrare un singolo modello. Sebbene ciò consenta la parallelizzazione delle attività su più nodi, con conseguenti tempi di formazione accelerati, maggiore scalabilità e prestazioni migliorate, esistono sfide significative nell'utilizzo efficace dell'hardware distribuito. I data scientist devono affrontare sfide come il partizionamento dei dati, il bilanciamento del carico, la tolleranza agli errori e la scalabilità. Gli ingegneri ML devono gestire manualmente la parallelizzazione, la pianificazione, gli errori e i nuovi tentativi, richiedendo un codice dell'infrastruttura complesso.

In questo post, discutiamo i vantaggi dell'utilizzo raggio ed Amazon Sage Maker per il machine learning distribuito e fornire una guida passo passo su come utilizzare questi framework per creare e distribuire un flusso di lavoro di machine learning scalabile.

Ray, un framework di elaborazione distribuita open source, fornisce un framework flessibile per la formazione distribuita e la fornitura di modelli ML. Astrae i dettagli del sistema distribuito di basso livello attraverso librerie semplici e scalabili per attività ML comuni come la preelaborazione dei dati, il training distribuito, l'ottimizzazione degli iperparametri, l'apprendimento per rinforzo e il servizio di modelli.

SageMaker è un servizio completamente gestito per la creazione, la formazione e la distribuzione di modelli ML. Ray si integra perfettamente con le funzionalità di SageMaker per creare e distribuire carichi di lavoro ML complessi che siano efficienti e affidabili. La combinazione di Ray e SageMaker fornisce funzionalità end-to-end per flussi di lavoro ML scalabili e presenta le seguenti funzionalità evidenziate:

Gli attori distribuiti e i costrutti di parallelismo in Ray semplificano lo sviluppo di applicazioni distribuite.
Ray AI Runtime (AIR) riduce l'attrito nel passaggio dallo sviluppo alla produzione. Con Ray e AIR, lo stesso codice Python può essere scalato senza problemi da un laptop a un cluster di grandi dimensioni.
L'infrastruttura gestita di SageMaker e funzionalità come processi di elaborazione, processi di formazione e processi di ottimizzazione degli iperparametri possono utilizzare le librerie Ray sottostanti per l'elaborazione distribuita.
Esperimenti Amazon SageMaker consente di ripetere rapidamente e tenere traccia delle prove.
Negozio di funzionalità Amazon SageMaker fornisce un repository scalabile per l'archiviazione, il recupero e la condivisione di funzionalità ML per l'addestramento del modello.
I modelli addestrati possono essere archiviati, sottoposti a controllo della versione e monitorati Registro dei modelli di Amazon SageMaker per la governance e la gestione.

Pipeline di Amazon SageMaker consente di orchestrare il ciclo di vita ML end-to-end dalla preparazione e formazione dei dati alla distribuzione del modello come flussi di lavoro automatizzati.

Panoramica della soluzione

Questo post si concentra sui vantaggi derivanti dall'utilizzo combinato di Ray e SageMaker. Abbiamo configurato un flusso di lavoro ML end-to-end basato su Ray, orchestrato utilizzando SageMaker Pipelines. Il flusso di lavoro include l'inserimento parallelo di dati nell'archivio di funzionalità utilizzando attori Ray, la preelaborazione dei dati con Ray Data, modelli di training e ottimizzazione degli iperparametri su larga scala utilizzando Ray Train e processi di ottimizzazione dell'ottimizzazione degli iperparametri (HPO) e infine la valutazione del modello e la registrazione del modello in un registro dei modelli.

Per i nostri dati, utilizziamo un set di dati sintetico sugli alloggi che consiste di otto funzioni (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCHe DECK) e il nostro modello prevederà il PRICE della casa.

Ogni fase del flusso di lavoro ML è suddivisa in passaggi distinti, con il proprio script che accetta parametri di input e output. Nella sezione successiva, evidenziamo i frammenti di codice chiave di ogni passaggio. Il codice completo è reperibile su repository GitHub aws-samples-for-ray.

Prerequisiti

Per utilizzare SageMaker Python SDK ed eseguire il codice associato a questo post, sono necessari i seguenti prerequisiti:

Importa dati nel Feature Store di SageMaker

Il primo passaggio nel flusso di lavoro ML consiste nel leggere il file di dati di origine Servizio di archiviazione semplice Amazon (Amazon S3) in formato CSV e importalo in SageMaker Feature Store. SageMaker Feature Store è un repository appositamente creato che semplifica la creazione, la condivisione e la gestione delle funzionalità ML da parte dei team. Semplifica l'individuazione, il riutilizzo e la condivisione delle funzionalità, garantendo uno sviluppo più rapido, una maggiore collaborazione all'interno dei team dei clienti e una riduzione dei costi.

L'inserimento di funzionalità nell'archivio funzionalità prevede i seguenti passaggi:

Definire un gruppo di funzionalità e creare il gruppo di funzionalità nell'archivio funzionalità.
Preparare i dati di origine per l'archivio caratteristiche aggiungendo un'ora dell'evento e un ID record per ogni riga di dati.
Inserisci i dati preparati nel gruppo di funzionalità utilizzando l'SDK Boto3.

In questa sezione evidenziamo solo il passaggio 3, poiché questa è la parte che prevede l'elaborazione parallela dell'attività di acquisizione utilizzando Ray. È possibile rivedere il codice completo per questo processo nel file Repository GitHub.

Il ingest_features il metodo è definito all'interno di una classe chiamata Featurestore. Si noti che il Featurestore la classe è decorata con @ray.remote. Ciò indica che un'istanza di questa classe è un attore Ray, un'unità computazionale con stato e simultanea all'interno di Ray. È un modello di programmazione che consente di creare oggetti distribuiti che mantengono uno stato interno e sono accessibili contemporaneamente da più attività in esecuzione su nodi diversi in un cluster Ray. Gli attori forniscono un modo per gestire e incapsulare lo stato mutevole, rendendoli preziosi per la creazione di applicazioni complesse con stato in un ambiente distribuito. Puoi specificare i requisiti di risorse anche negli attori. In questo caso, ogni istanza di FeatureStore la classe richiederà 0.5 CPU. Vedere il seguente codice:

@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. """ ...

Puoi interagire con l'attore chiamando il remote operatore. Nel codice seguente, il numero desiderato di attori viene passato come argomento di input allo script. I dati vengono quindi partizionati in base al numero di attori e passati ai processi paralleli remoti per essere inseriti nell'archivio delle funzionalità. Puoi chiamare get sull'oggetto ref per bloccare l'esecuzione dell'attività corrente fino al completamento del calcolo remoto e alla disponibilità del risultato. Quando il risultato è disponibile, ray.get restituirà il risultato e l'esecuzione dell'attività corrente continuerà.

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)

Preparare i dati per la formazione, la convalida e il test

In questa fase, utilizziamo Ray Dataset per dividere, trasformare e ridimensionare in modo efficiente il nostro set di dati in preparazione all'apprendimento automatico. Ray Dataset fornisce un modo standard per caricare i dati distribuiti in Ray, supportando vari sistemi di archiviazione e formati di file. Dispone di API per operazioni comuni di preelaborazione dei dati ML come trasformazioni parallele, mescolamento, raggruppamento e aggregazioni. Ray Dataset gestisce anche le operazioni che richiedono configurazione stateful e accelerazione GPU. Si integra perfettamente con altre librerie di elaborazione dati come Spark, Pandas, NumPy e altre, nonché con framework ML come TensorFlow e PyTorch. Ciò consente di creare pipeline di dati end-to-end e flussi di lavoro ML su Ray. L’obiettivo è rendere più semplice l’elaborazione distribuita dei dati e il machine learning per professionisti e ricercatori.

Diamo un'occhiata alle sezioni degli script che eseguono questa preelaborazione dei dati. Iniziamo caricando i dati dal 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

Quindi dividiamo e ridimensioniamo i dati utilizzando le astrazioni di livello superiore disponibili da ray.data biblioteca:

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

I set di dati di training, convalida e test elaborati vengono archiviati in Amazon S3 e verranno passati come parametri di input alle fasi successive.

Eseguire l'addestramento del modello e l'ottimizzazione degli iperparametri

Con i nostri dati preelaborati e pronti per la modellazione, è il momento di addestrare alcuni modelli ML e ottimizzare i loro iperparametri per massimizzare le prestazioni predittive. Noi usiamo XGBoost-Ray, un backend distribuito per XGBoost basato su Ray che consente l'addestramento di modelli XGBoost su set di dati di grandi dimensioni utilizzando più nodi e GPU. Fornisce semplici sostituzioni immediate per il training e la previsione delle API di XGBoost, gestendo al tempo stesso le complessità della gestione dei dati distribuiti e della formazione dietro le quinte.

Per consentire la distribuzione della formazione su più nodi, utilizziamo una classe helper denominata RayHelper. Come mostrato nel codice seguente, utilizziamo la configurazione delle risorse del processo di training e scegliamo il primo host come nodo head:

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"])

Possiamo utilizzare le informazioni dell'host per decidere come inizializzare Ray su ciascuna delle istanze di lavoro di formazione:

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)

Quando viene avviato un processo di training, è possibile inizializzare un cluster Ray chiamando il metodo start_ray() metodo su un'istanza di RayHelper:

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

Utilizziamo quindi il trainer XGBoost di XGBoost-Ray per l'allenamento:

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)

Tieni presente che durante l'istanziazione di trainer, noi passiamo RayParams, che prende il numero di attori e il numero di CPU per attore. XGBoost-Ray utilizza queste informazioni per distribuire l'addestramento su tutti i nodi collegati al cluster Ray.

Ora creiamo un oggetto di stima XGBoost basato su SageMaker Python SDK e lo utilizziamo per il lavoro HPO.

Orchestra i passaggi precedenti utilizzando SageMaker Pipelines

Per creare un flusso di lavoro ML scalabile e riutilizzabile end-to-end, dobbiamo utilizzare uno strumento CI/CD per orchestrare i passaggi precedenti in una pipeline. SageMaker Pipelines ha un'integrazione diretta con SageMaker, SageMaker Python SDK e SageMaker Studio. Questa integrazione ti consente di creare flussi di lavoro ML con un SDK Python facile da usare, quindi visualizzare e gestire il flusso di lavoro utilizzando SageMaker Studio. Puoi anche tenere traccia della cronologia dei tuoi dati nell'esecuzione della pipeline e designare i passaggi per la memorizzazione nella cache.

SageMaker Pipelines crea un grafico aciclico diretto (DAG) che include i passaggi necessari per creare un flusso di lavoro ML. Ogni pipeline è una serie di passaggi interconnessi orchestrati da dipendenze di dati tra i passaggi e può essere parametrizzata, consentendo di fornire variabili di input come parametri per ogni esecuzione della pipeline. SageMaker Pipelines ha quattro tipi di parametri della pipeline: ParameterString, ParameterInteger, ParameterFloate ParameterBoolean. In questa sezione parametrizziamo alcune delle variabili di input e impostiamo la configurazione della memorizzazione nella cache:

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")

Definiamo due fasi di elaborazione: una per l'acquisizione di SageMaker Feature Store, l'altra per la preparazione dei dati. Dovrebbe essere molto simile ai passaggi precedenti descritti in precedenza. L'unica nuova riga di codice è the ProcessingStep dopo la definizione dei passaggi, che ci consente di prendere la configurazione del lavoro di elaborazione e includerla come passaggio della pipeline. Specifichiamo ulteriormente la dipendenza della fase di preparazione dei dati dalla fase di acquisizione del Feature Store di SageMaker. Vedere il seguente codice:

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])

Allo stesso modo, per creare una fase di training e ottimizzazione del modello, dobbiamo aggiungere una definizione di TuningStep dopo il codice della fase di training del modello per consentirci di eseguire l'ottimizzazione degli iperparametri SageMaker come fase della 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])

Dopo la fase di ottimizzazione, scegliamo di registrare il modello migliore nel registro dei modelli SageMaker. Per controllare la qualità del modello, implementiamo un gate di qualità minimo che confronta la metrica oggettiva del modello migliore (RMSE) con una soglia definita come parametro di input della pipeline rmse_threshold. Per eseguire questa valutazione, creiamo un'altra fase di elaborazione per eseguire un file copione di valutazione. Il risultato della valutazione del modello verrà archiviato come file delle proprietà. I file delle proprietà sono particolarmente utili quando si analizzano i risultati di una fase di elaborazione per decidere come eseguire le altre fasi. Vedere il seguente codice:

# 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],
)

Definiamo a ModelStep per registrare il modello migliore nel registro dei modelli SageMaker nella nostra pipeline. Nel caso in cui il modello migliore non superi il nostro controllo di qualità predeterminato, specifichiamo inoltre a FailStep per generare un messaggio di errore:

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]),
)

Successivamente, usiamo un file ConditionStep per valutare se la fase di registrazione del modello o quella di fallimento debbano essere eseguite successivamente nella pipeline. Nel nostro caso, il modello migliore verrà registrato se il suo punteggio RMSE è inferiore alla soglia.

# 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],
)

Infine, orchestriamo tutti i passaggi definiti in una 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)

La pipeline precedente può essere visualizzata ed eseguita direttamente in SageMaker Studio oppure eseguita tramite chiamata execution = training_pipeline.start(). La figura seguente illustra il flusso della pipeline.

DAG della pipeline SageMaker

Inoltre, possiamo rivedere la derivazione degli artefatti generati dall'esecuzione della 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)

Distribuire il modello

Dopo che il modello migliore è stato registrato nel registro dei modelli SageMaker tramite un'esecuzione della pipeline, distribuiamo il modello su un endpoint in tempo reale utilizzando le funzionalità di distribuzione del modello completamente gestite di SageMaker. SageMaker dispone di altre opzioni di distribuzione del modello per soddisfare le esigenze di diversi casi d'uso. Per i dettagli, fare riferimento a Distribuire modelli per l'inferenza quando scegli l'opzione giusta per il tuo caso d'uso. Innanzitutto, registriamo il modello nel registro dei modelli SageMaker:

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

Lo stato attuale del modello è PendingApproval. Dobbiamo impostare il suo stato su Approved prima della distribuzione:

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
)

ripulire

Una volta terminata la sperimentazione, ricorda di ripulire le risorse per evitare addebiti inutili. Per pulire, elimina l'endpoint in tempo reale, il gruppo di modelli, la pipeline e il gruppo di funzionalità chiamando le API Elimina punto finale, EliminaModelPackageGroup, Elimina pipelinee EliminaFeatureGroup, rispettivamente, e arrestare tutte le istanze notebook di SageMaker Studio.

Conclusione

Questo post ha illustrato una procedura dettagliata su come utilizzare SageMaker Pipelines per orchestrare flussi di lavoro ML basati su Ray. Abbiamo anche dimostrato la capacità di SageMaker Pipelines di integrarsi con strumenti ML di terze parti. Esistono vari servizi AWS che supportano i carichi di lavoro Ray in modo scalabile e sicuro per garantire prestazioni eccellenti ed efficienza operativa. Ora tocca a te esplorare queste potenti funzionalità e iniziare a ottimizzare i flussi di lavoro di machine learning con Amazon SageMaker Pipelines e Ray. Agisci oggi e sblocca tutto il potenziale dei tuoi progetti ML!

L'autore

Raju Rangan è Senior Solutions Architect presso Amazon Web Services (AWS). Lavora con enti sponsorizzati dal governo, aiutandoli a creare soluzioni AI/ML utilizzando AWS. Quando non armeggia con le soluzioni cloud, lo vedrai uscire con la famiglia o fare a pezzi gli uccellini in una vivace partita di badminton con gli amici.

Sherry Ding è un architetto senior di soluzioni specializzate in AI/ML presso Amazon Web Services (AWS). Ha una vasta esperienza nell'apprendimento automatico con un dottorato di ricerca in informatica. Lavora principalmente con clienti del settore pubblico su varie sfide aziendali legate all'intelligenza artificiale/ML, aiutandoli ad accelerare il loro percorso di apprendimento automatico sul cloud AWS. Quando non aiuta i clienti, le piacciono le attività all'aria aperta.