Orchestrați fluxuri de lucru de învățare automată bazate pe Ray folosind Amazon SageMaker | Amazon Web Services

Învățarea automată (ML) devine din ce în ce mai complexă, pe măsură ce clienții încearcă să rezolve probleme din ce în ce mai dificile. Această complexitate duce adesea la necesitatea ML distribuită, în care mai multe mașini sunt utilizate pentru a antrena un singur model. Deși acest lucru permite paralelizarea sarcinilor pe mai multe noduri, ceea ce duce la timpi de antrenament accelerați, scalabilitate îmbunătățită și performanță îmbunătățită, există provocări semnificative în utilizarea eficientă a hardware-ului distribuit. Oamenii de știință de date trebuie să abordeze provocări precum partiționarea datelor, echilibrarea sarcinii, toleranța la erori și scalabilitatea. Inginerii ML trebuie să gestioneze manual paralelizarea, programarea, erorile și reîncercările, necesitând cod de infrastructură complex.

În această postare, discutăm despre beneficiile utilizării Rază și Amazon SageMaker pentru ML distribuit și oferiți un ghid pas cu pas despre cum să utilizați aceste cadre pentru a construi și implementa un flux de lucru ML scalabil.

Ray, un cadru de calcul distribuit open-source, oferă un cadru flexibil pentru instruirea distribuită și servirea modelelor ML. Abstrage detaliile sistemului distribuit de nivel scăzut prin biblioteci simple și scalabile pentru sarcini ML obișnuite, cum ar fi preprocesarea datelor, instruirea distribuită, reglarea hiperparametrilor, învățarea prin consolidare și servirea modelelor.

SageMaker este un serviciu complet gestionat pentru construirea, instruirea și implementarea modelelor ML. Ray se integrează perfect cu caracteristicile SageMaker pentru a construi și a implementa sarcini de lucru complexe de ML, care sunt atât eficiente, cât și fiabile. Combinația dintre Ray și SageMaker oferă capabilități end-to-end pentru fluxuri de lucru ML scalabile și are următoarele caracteristici evidențiate:

• Actorii distribuiti și constructele de paralelism în Ray simplifică dezvoltarea aplicațiilor distribuite.
• Ray AI Runtime (AIR) reduce frecarea de la dezvoltare la producție. Cu Ray și AIR, același cod Python se poate scala fără probleme de la un laptop la un cluster mare.
• Infrastructura gestionată a SageMaker și funcții precum joburi de procesare, joburi de instruire și joburi de reglare a hiperparametrilor pot folosi bibliotecile Ray de dedesubt pentru calcul distribuit.
• Experimente Amazon SageMaker permite repetarea rapidă și urmărirea încercărilor.
• Magazinul de caracteristici Amazon SageMaker oferă un depozit scalabil pentru stocarea, preluarea și partajarea caracteristicilor ML pentru formarea modelului.
• Modelele instruite pot fi stocate, versionate și urmărite Registrul de modele Amazon SageMaker pentru guvernare și management.

• Pipelines Amazon SageMaker permite orchestrarea ciclului de viață ML end-to-end, de la pregătirea datelor și instruirea până la implementarea modelului ca fluxuri de lucru automatizate.

Prezentare generală a soluțiilor

Această postare se concentrează pe beneficiile utilizării Ray și SageMaker împreună. Am configurat un flux de lucru ML, bazat pe Ray, de la capăt la capăt, orchestrat folosind SageMaker Pipelines. Fluxul de lucru include ingerarea paralelă a datelor în depozitul de caracteristici folosind actori Ray, preprocesarea datelor cu Ray Data, modele de antrenament și reglarea hiperparametrică la scară utilizând joburi de reglare Ray Train și optimizarea hiperparametrului (HPO) și, în final, evaluarea modelului și înregistrarea modelului într-un model de registru.

Pentru datele noastre, folosim un set de date de locuințe sintetice care constă din opt caracteristici (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCH, și DECK) iar modelul nostru va prezice PRICE al casei.

Fiecare etapă a fluxului de lucru ML este împărțită în pași discreti, cu propriul script care preia parametrii de intrare și de ieșire. În secțiunea următoare, evidențiem fragmente de cod cheie de la fiecare pas. Codul complet poate fi găsit pe Depozitul GitHub aws-samples-for-ray.

Cerințe preliminare

Pentru a utiliza SDK-ul SageMaker Python și a rula codul asociat cu această postare, aveți nevoie de următoarele cerințe preliminare:

Ingerați date în Magazinul de funcții SageMaker

Primul pas în fluxul de lucru ML este să citiți fișierul de date sursă din Serviciul Amazon de stocare simplă (Amazon S3) în format CSV și introduceți-l în SageMaker Feature Store. SageMaker Feature Store este un depozit creat special, care facilitează crearea, partajarea și gestionarea funcțiilor ML pentru echipe. Simplifică descoperirea, reutilizarea și partajarea caracteristicilor, ceea ce duce la o dezvoltare mai rapidă, o colaborare sporită în cadrul echipelor de clienți și costuri reduse.

Ingerarea funcțiilor în magazinul de caracteristici conține următorii pași:

1. Definiți un grup de caracteristici și creați grupul de caracteristici în magazinul de caracteristici.
2. Pregătiți datele sursă pentru depozitul de caracteristici adăugând o oră a evenimentului și un ID de înregistrare pentru fiecare rând de date.
3. Ingerați datele pregătite în grupul de caracteristici utilizând SDK-ul Boto3.

În această secțiune, evidențiem doar Pasul 3, deoarece aceasta este partea care implică procesarea paralelă a sarcinii de asimilare folosind Ray. Puteți consulta codul complet pentru acest proces în GitHub repo.

ingest_features metoda este definită în interiorul unei clase numite Featurestore. Rețineți că Featurestore clasa este decorată cu @ray.remote. Acest lucru indică faptul că o instanță a acestei clase este un actor Ray, o unitate de calcul cu stare și concurență în Ray. Este un model de programare care vă permite să creați obiecte distribuite care mențin o stare internă și care pot fi accesate simultan de mai multe sarcini care rulează pe diferite noduri dintr-un cluster Ray. Actorii oferă o modalitate de a gestiona și a încapsula starea mutabilă, făcându-le valoroase pentru construirea de aplicații complexe, cu state într-un cadru distribuit. Puteți specifica cerințele de resurse și în actori. În acest caz, fiecare instanță a FeatureStore clasa va necesita 0.5 procesoare. Vezi următorul cod:

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

Puteți interacționa cu actorul sunând la remote operator. În codul următor, numărul dorit de actori este transmis ca argument de intrare în script. Datele sunt apoi împărțite în funcție de numărul de actori și transmise proceselor paralele la distanță pentru a fi ingerate în depozitul de caracteristici. Poti suna get pe referința obiectului pentru a bloca execuția sarcinii curente până când calculul de la distanță este complet și rezultatul este disponibil. Când rezultatul este disponibil, ray.get va returna rezultatul, iar execuția sarcinii curente va continua.

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)

Pregătiți datele pentru instruire, validare și testare

În acest pas, folosim Ray Dataset pentru a împărți, transforma și scala în mod eficient setul de date, în pregătirea pentru învățarea automată. Ray Dataset oferă o modalitate standard de încărcare a datelor distribuite în Ray, care acceptă diverse sisteme de stocare și formate de fișiere. Are API-uri pentru operațiuni comune de preprocesare a datelor ML, cum ar fi transformări paralele, amestecare, grupare și agregare. Ray Dataset se ocupă, de asemenea, de operațiuni care necesită configurare cu stare și accelerare GPU. Se integrează fără probleme cu alte biblioteci de procesare a datelor precum Spark, Pandas, NumPy și altele, precum și cu cadre ML precum TensorFlow și PyTorch. Acest lucru permite construirea de conducte de date end-to-end și fluxuri de lucru ML pe Ray. Scopul este de a facilita procesarea datelor distribuite și ML pentru practicieni și cercetători.

Să ne uităm la secțiunile scripturilor care efectuează această preprocesare a datelor. Începem prin a încărca datele din magazinul de caracteristici:

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

Apoi împărțim și scalam datele folosind abstracțiile de nivel superior disponibile din ray.data bibliotecă:

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

Seturile de date procesate, de validare și de testare sunt stocate în Amazon S3 și vor fi transmise ca parametri de intrare la pașii următori.

Efectuați antrenamentul modelului și optimizarea hiperparametrilor

Cu datele noastre preprocesate și pregătite pentru modelare, este timpul să antrenăm câteva modele ML și să le reglam fin hiperparametrii pentru a maximiza performanța predictivă. Folosim XGBoost-Ray, un backend distribuit pentru XGBoost construit pe Ray care permite antrenamentul modelelor XGBoost pe seturi mari de date prin utilizarea mai multor noduri și GPU. Oferă înlocuiri simple pentru trenul XGBoost și API-urile de predicție, gestionând în același timp complexitățile de gestionare a datelor distribuite și de formare sub capotă.

Pentru a permite distribuirea instruirii pe mai multe noduri, folosim o clasă de ajutor numită RayHelper. După cum se arată în codul următor, folosim configurația resurselor jobului de antrenament și alegem prima gazdă ca nod 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"])

Putem folosi informațiile de gazdă pentru a decide cum să inițializam Ray pe fiecare dintre instanțe de job de instruire:

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)

Când se pornește un job de instruire, un cluster Ray poate fi inițializat apelând la start_ray() metoda pe o instanță de RayHelper:

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

Apoi folosim antrenamentul XGBoost de la XGBoost-Ray pentru antrenament:

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)

Rețineți că în timp ce instanțiați trainer, trecem RayParams, care ia numărul de actori și numărul de procesoare per actor. XGBoost-Ray folosește aceste informații pentru a distribui instruirea în toate nodurile atașate clusterului Ray.

Acum creăm un obiect estimator XGBoost bazat pe SDK-ul SageMaker Python și îl folosim pentru jobul HPO.

Orchestrați pașii precedenți folosind SageMaker Pipelines

Pentru a construi un flux de lucru ML scalabil și reutilizabil end-to-end, trebuie să folosim un instrument CI/CD pentru a orchestra pașii precedenți într-o conductă. SageMaker Pipelines are integrare directă cu SageMaker, SageMaker Python SDK și SageMaker Studio. Această integrare vă permite să creați fluxuri de lucru ML cu un SDK Python ușor de utilizat, apoi să vizualizați și să gestionați fluxul de lucru folosind SageMaker Studio. De asemenea, puteți urmări istoricul datelor dvs. în cadrul execuției conductei și puteți desemna pași pentru stocarea în cache.

SageMaker Pipelines creează un grafic aciclic direcționat (DAG) care include pași necesari pentru a construi un flux de lucru ML. Fiecare conductă este o serie de pași interconectați, orchestrați de dependențele de date dintre pași și pot fi parametrizați, permițându-vă să furnizați variabile de intrare ca parametri pentru fiecare rulare a conductei. SageMaker Pipelines are patru tipuri de parametri de conductă: ParameterString, ParameterInteger, ParameterFloat, și ParameterBoolean. În această secțiune, parametrizăm unele dintre variabilele de intrare și setăm configurația pasului de 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")

Definim doi pași de procesare: unul pentru asimilarea SageMaker Feature Store, celălalt pentru pregătirea datelor. Acest lucru ar trebui să arate foarte asemănător cu pașii anteriori descriși mai devreme. Singura linie nouă de cod este ProcessingStep după definirea pașilor, ceea ce ne permite să luăm configurația jobului de procesare și să o includem ca pas pipeline. Specificăm în continuare dependența pasului de pregătire a datelor de pasul de asimilare a Magazinului de caracteristici SageMaker. Vezi următorul cod:

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

În mod similar, pentru a construi un pas de pregătire și reglare a modelului, trebuie să adăugăm o definiție a TuningStep după codul pasului de antrenament al modelului pentru a ne permite să rulăm reglarea hiperparametrului SageMaker ca pas în conductă:

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

După pasul de reglare, alegem să înregistrăm cel mai bun model în SageMaker Model Registry. Pentru a controla calitatea modelului, implementăm o poartă de calitate minimă care compară metrica obiectivă a celui mai bun model (RMSE) cu un prag definit ca parametrul de intrare al conductei. rmse_threshold. Pentru a face această evaluare, creăm un alt pas de procesare pentru a rula un scenariul de evaluare. Rezultatul evaluării modelului va fi stocat ca fișier de proprietăți. Fișierele de proprietate sunt deosebit de utile atunci când se analizează rezultatele unui pas de procesare pentru a decide cum ar trebui să se execute alți pași. Vezi următorul cod:

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

Definim a ModelStep pentru a înregistra cel mai bun model în SageMaker Model Registry în cursul nostru. În cazul în care cel mai bun model nu trece controlul nostru de calitate prestabilit, precizăm suplimentar a FailStep pentru a afișa un mesaj de eroare:

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

În continuare, folosim a ConditionStep pentru a evalua dacă pasul de înregistrare a modelului sau pasul de defecțiune ar trebui urmat în continuare. În cazul nostru, cel mai bun model va fi înregistrat dacă scorul său RMSE este mai mic decât pragul.

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

În cele din urmă, orchestrăm toți pașii definiți într-o conductă:

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)

Conducta precedentă poate fi vizualizată și executată direct în SageMaker Studio sau poate fi executată apelând execution = training_pipeline.start(). Următoarea figură ilustrează debitul conductei.

În plus, putem revizui descendența artefactelor generate de execuția conductei.

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)

Implementați modelul

După ce cel mai bun model este înregistrat în SageMaker Model Registry printr-o rulare pipeline, implementăm modelul într-un punct final în timp real utilizând capabilitățile de implementare a modelului complet gestionate ale SageMaker. SageMaker are alte opțiuni de implementare a modelului pentru a răspunde nevoilor diferitelor cazuri de utilizare. Pentru detalii, consultați Implementați modele pentru inferență atunci când alegeți opțiunea potrivită pentru cazul dvs. de utilizare. Mai întâi, să înregistrăm modelul în SageMaker Model Registry:

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

Starea actuală a modelului este PendingApproval. Trebuie să-i setăm statutul la Approved înainte de implementare:

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
)

A curăța

După ce ați terminat de experimentat, nu uitați să curățați resursele pentru a evita taxele inutile. Pentru a curăța, ștergeți punctul final în timp real, grupul de modele, conducta și grupul de caracteristici apelând API-urile DeleteEndpoint, DeleteModelPackageGroup, DeletePipeline, și DeleteFeatureGroup, respectiv, și închideți toate instanțele de notebook-uri SageMaker Studio.

Concluzie

Această postare a demonstrat o prezentare pas cu pas despre cum să utilizați SageMaker Pipelines pentru a orchestra fluxurile de lucru ML bazate pe Ray. Am demonstrat, de asemenea, capacitatea SageMaker Pipelines de a se integra cu instrumente ML terțe. Există diverse servicii AWS care acceptă sarcinile de lucru Ray într-un mod scalabil și sigur pentru a asigura excelența în performanță și eficiența operațională. Acum, este rândul tău să explorezi aceste capabilități puternice și să începi să-ți optimizezi fluxurile de lucru de învățare automată cu Amazon SageMaker Pipelines și Ray. Acționați astăzi și deblocați întregul potențial al proiectelor dvs. de ML!

---

Despre autor

Raju Rangan este arhitect senior de soluții la Amazon Web Services (AWS). Lucrează cu entități sponsorizate de guvern, ajutându-le să construiască soluții AI/ML folosind AWS. Când nu te chinui cu soluții cloud, îl vei surprinde petrecând cu familia sau zdrobind păsări într-un joc plin de viață de badminton cu prietenii.

Sherry Ding este un arhitect senior de soluții specializate în AI/ML la Amazon Web Services (AWS). Are o vastă experiență în învățarea automată cu un doctorat în informatică. Ea lucrează în principal cu clienți din sectorul public la diverse provocări de afaceri legate de AI/ML, ajutându-i să-și accelereze călătoria de învățare automată pe AWS Cloud. Când nu ajută clienții, îi plac activitățile în aer liber.

• Distribuție de conținut bazat pe SEO și PR. Amplifică-te astăzi.
• PlatoData.Network Vertical Generative Ai. Împuterniciți-vă. Accesați Aici.
• PlatoAiStream. Web3 Intelligence. Cunoștințe amplificate. Accesați Aici.
• PlatoESG. carbon, CleanTech, Energie, Mediu inconjurator, Solar, Managementul deșeurilor. Accesați Aici.
• PlatoHealth. Biotehnologie și Inteligență pentru studii clinice. Accesați Aici.
• BlockOffsets. Modernizarea proprietății de compensare a mediului. Accesați Aici.
• Sursa: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/