Orkestreerige Ray-põhiseid masinõppe töövooge, kasutades Amazon SageMaker | Amazoni veebiteenused

Masinaõpe (ML) muutub üha keerukamaks, kuna kliendid püüavad lahendada üha keerukamaid probleeme. See keerukus toob sageli kaasa vajaduse hajutatud ML-i järele, kus ühe mudeli treenimiseks kasutatakse mitut masinat. Kuigi see võimaldab ülesandeid paralleelselt mitme sõlme vahel, kiirendades treeninguaega, suurendades skaleeritavust ja paremat jõudlust, on hajutatud riistvara tõhusal kasutamisel olulisi väljakutseid. Andmeteadlased peavad tegelema selliste väljakutsetega nagu andmete jaotamine, koormuse tasakaalustamine, tõrketaluvus ja mastaapsus. ML-i insenerid peavad käsitlema paralleelsust, ajastamist, tõrkeid ja uuesti katseid käsitsi, nõudes keerukat infrastruktuuri koodi.

Selles postituses käsitleme kasutamise eeliseid kiir ja Amazon SageMaker hajutatud ML-i jaoks ja esitage samm-sammuline juhend nende raamistike kasutamiseks skaleeritava ML-i töövoo loomiseks ja juurutamiseks.

Ray, avatud lähtekoodiga hajutatud andmetöötlusraamistik, pakub paindlikku raamistikku hajutatud koolituseks ja ML-mudelite teenindamiseks. See abstraheerib madala taseme hajutatud süsteemi üksikasju lihtsate, skaleeritavate teekide kaudu tavaliste ML-ülesannete jaoks, nagu andmete eeltöötlus, hajutatud koolitus, hüperparameetrite häälestamine, õppimine ja mudelite serveerimine.

SageMaker on täielikult hallatav teenus ML-mudelite ehitamiseks, koolitamiseks ja juurutamiseks. Ray integreerub sujuvalt SageMakeri funktsioonidega, et luua ja juurutada keerukaid ML-i töökoormusi, mis on ühtaegu tõhusad ja usaldusväärsed. Ray ja SageMakeri kombinatsioon pakub skaleeritavate ML-töövoogude jaoks täielikke võimalusi ja sellel on järgmised esiletõstetud funktsioonid.

• Ray hajutatud näitlejad ja paralleelsuse konstruktsioonid lihtsustavad hajutatud rakenduste arendamist.
• Ray AI Runtime (AIR) vähendab hõõrdumist arenduselt tootmisele üleminekul. Ray ja AIR-iga saab sama Pythoni koodi sujuvalt skaleerida sülearvutist suure klastrini.
• SageMakeri hallatav infrastruktuur ja sellised funktsioonid nagu töötlemistööd, koolitustööd ja hüperparameetrite häälestustööd võivad hajutatud andmetöötluseks kasutada allolevaid kiirteeke.
• Amazon SageMakeri katsed võimaldab katseid kiiresti itereerida ja jälgida.
• Amazon SageMakeri funktsioonipood pakub skaleeritavat hoidlat mudelikoolituse ML-funktsioonide salvestamiseks, toomiseks ja jagamiseks.
• Koolitatud mudeleid saab salvestada, versioonida ja jälgida Amazon SageMakeri mudeliregister valitsemise ja juhtimise jaoks.

• Amazon SageMakeri torujuhtmed võimaldab korraldada täielikku ML-i elutsüklit andmete ettevalmistamisest ja koolitusest kuni mudeli juurutamiseni automatiseeritud töövoogudena.

Lahenduse ülevaade

See postitus keskendub Ray ja SageMakeri koos kasutamise eelistele. Seadistasime otsast lõpuni kiirpõhise ML-töövoo, mis on korraldatud SageMakeri torujuhtmete abil. Töövoog hõlmab andmete paralleelset sissevõtmist funktsioonisalve kiirnäitlejate abil, andmete eeltöötlust kiirandmetega, treenimismudeleid ja hüperparameetrite häälestamist mastaabis, kasutades Ray Traini ja hüperparameetrite optimeerimise (HPO) häälestustöid ning lõpuks mudeli hindamist ja mudeli registreerimist mudeliregister.

Oma andmete jaoks kasutame sünteetilise korpuse andmestik mis koosneb kaheksast funktsioonist (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCHja DECK) ja meie mudel ennustab PRICE maja.

ML-i töövoo iga etapp on jagatud eraldiseisvateks sammudeks, millel on oma skript, mis võtab sisend- ja väljundparameetrid. Järgmises jaotises tõstame esile iga sammu võtmekoodilõigud. Täieliku koodi leiate aadressilt aws-samples-for-ray GitHubi hoidla.

Eeldused

SageMaker Python SDK kasutamiseks ja selle postitusega seotud koodi käitamiseks vajate järgmisi eeltingimusi:

Sisestage andmed SageMakeri funktsioonipoodi

ML-i töövoo esimene samm on lähteandmete faili lugemine Amazoni lihtne salvestusteenus (Amazon S3) CSV-vormingus ja sisestage see SageMakeri funktsioonipoodi. SageMaker Feature Store on spetsiaalselt loodud hoidla, mis muudab meeskondade jaoks lihtsaks ML-funktsioonide loomise, jagamise ja haldamise. See lihtsustab funktsioonide avastamist, taaskasutamist ja jagamist, mis viib kiirema arenduseni, suurema koostööni kliendimeeskondade vahel ja kulude vähenemiseni.

Funktsioonide sisestamine funktsioonipoodi sisaldab järgmisi samme.

1. Määratlege funktsioonide rühm ja looge funktsioonide grupp funktsioonide poes.
2. Valmistage ette funktsioonide salvestamise lähteandmed, lisades iga andmerea jaoks sündmuse aja ja kirje ID.
3. Sisestage ettevalmistatud andmed funktsioonirühma Boto3 SDK abil.

Selles jaotises tõstame esile ainult sammu 3, kuna see on osa, mis hõlmab sisestusülesande paralleelset töötlemist Ray abil. Selle protsessi täielikku koodi saate vaadata aadressilt GitHub repo.

. ingest_features meetod on määratletud klassis nimega Featurestore. Pange tähele, et Featurestore klass on kaunistatud @ray.remote. See näitab, et selle klassi eksemplar on Ray actor, olekupõhine ja samaaegne arvutusüksus Ray sees. See on programmeerimismudel, mis võimaldab teil luua hajutatud objekte, mis säilitavad sisemise oleku ja millele pääseb samaaegselt juurde mitu toimingut, mis töötavad kiirklastri erinevates sõlmedes. Näitlejad pakuvad viisi muutuva oleku haldamiseks ja kapseldamiseks, muutes need väärtuslikuks keerukate olekupõhiste rakenduste ehitamiseks hajutatud keskkonnas. Saate määrata ka näitlejate ressursinõudeid. Sel juhul on iga eksemplar FeatureStore klass vajab 0.5 protsessorit. Vaadake järgmist koodi:

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

Näitlejaga saate suhelda helistades remote operaator. Järgmises koodis edastatakse skripti sisendargumendina soovitud arv näitlejaid. Seejärel jagatakse andmed osalejate arvu alusel osadeks ja edastatakse paralleelsetele kaugprotsessidele, et need funktsioonide poodi neelata. Sa võid helistada get objektil ref, et blokeerida praeguse ülesande täitmine, kuni kaugarvutus on lõppenud ja tulemus saadaval. Kui tulemus on käes, ray.get tagastab tulemuse ja praeguse ülesande täitmine jätkub.

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)

Valmistage ette andmed koolituseks, valideerimiseks ja testimiseks

Selles etapis kasutame Ray Datasetti, et masinõppeks valmistudes tõhusalt jagada, teisendada ja skaleerida oma andmestikku. Ray Dataset pakub standardset viisi hajutatud andmete laadimiseks Raysse, toetades erinevaid salvestussüsteeme ja failivorminguid. Sellel on API-d tavaliste ML-andmete eeltöötlustoimingute jaoks, nagu paralleelsed teisendused, segamine, rühmitamine ja koondamine. Ray Dataset käsitleb ka toiminguid, mis vajavad olekupõhist seadistamist ja GPU kiirendust. See integreerub sujuvalt teiste andmetöötlusteekidega, nagu Spark, Pandas, NumPy ja palju muud, aga ka ML-raamistikega, nagu TensorFlow ja PyTorch. See võimaldab luua otsast lõpuni andmekonveierid ja ML-töövood Ray peale. Eesmärk on muuta hajutatud andmetöötlus ja ML praktikutele ja teadlastele lihtsamaks.

Vaatame skriptide jaotisi, mis seda andmete eeltöötlust teostavad. Alustuseks laadime funktsioonide poest andmed:

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

Seejärel jagame ja skaleerime andmed, kasutades teenusest saadaolevaid kõrgema taseme abstraktsioone ray.data raamatukogu:

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

Töödeldud rongi-, valideerimis- ja testiandmed salvestatakse Amazon S3-sse ja edastatakse sisendparameetritena järgmistele etappidele.

Tehke mudelikoolitus ja hüperparameetrite optimeerimine

Kuna meie andmed on eeltöödeldud ja modelleerimiseks valmis, on aeg välja õpetada mõned ML-mudelid ja täpsustada nende hüperparameetreid, et maksimeerida ennustatavat jõudlust. Me kasutame XGBoost-Ray, Rayle ehitatud XGBoosti hajutatud taustaprogramm, mis võimaldab treenida XGBoosti mudeleid suurtel andmekogudel, kasutades mitut sõlme ja GPU-d. See pakub XGBoosti rongi lihtsaid asendusi ja ennustab API-sid, tegeledes samal ajal hajutatud andmehalduse ja koolituse keerukusega.

Koolituse levitamiseks mitme sõlme vahel kasutame abiklassi nimega RayHelper. Nagu on näidatud järgmises koodis, kasutame koolitustöö ressursikonfiguratsiooni ja valime peasõlmeks esimese hosti:

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

Võime kasutada hostiteavet, et otsustada, kuidas Ray initsialiseerida igal koolitustöö eksemplaril:

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)

Treeningtöö alustamisel saab kiirklastri lähtestada, helistades numbrile start_ray() meetodil RayHelper:

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

Seejärel kasutame treenimiseks XGBoost-Ray treenerit XGBoost:

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)

Pange tähele, et trainer, möödume RayParams, mis võtab osalejate arvu ja protsessorite arvu näitlejate kohta. XGBoost-Ray kasutab seda teavet koolituse levitamiseks kõigi Ray klastriga ühendatud sõlmede vahel.

Loome nüüd SageMaker Pythoni SDK-l põhineva XGBoosti hinnanguobjekti ja kasutame seda HPO töö jaoks.

Korraldage eelnevad sammud SageMakeri torujuhtmete abil

Täieliku skaleeritava ja korduvkasutatava ML-i töövoo loomiseks peame kasutama CI-/CD-tööriista, et eelnevad sammud konveierisse viia. SageMaker Pipelines on otse integreeritud SageMakeri, SageMaker Python SDK ja SageMaker Studioga. See integratsioon võimaldab teil hõlpsasti kasutatava Pythoni SDK-ga luua ML-töövooge ning seejärel visualiseerida ja hallata oma töövooge SageMaker Studio abil. Samuti saate jälgida oma andmete ajalugu konveieri täitmisel ja määrata vahemällu salvestamise etapid.

SageMaker Pipelines loob suunatud atsüklilise graafiku (DAG), mis sisaldab ML-i töövoo loomiseks vajalikke samme. Iga konveier on rida omavahel ühendatud etappe, mis on korraldatud etappidevahelise andmesõltuvusega ja mida saab parameetritega muuta, võimaldades teil anda sisendmuutujaid parameetritena konveieri iga käitamise jaoks. SageMaker Pipelinesil on nelja tüüpi torujuhtme parameetreid: ParameterString, ParameterInteger, ParameterFloatja ParameterBoolean. Selles jaotises parameetrite määrame mõned sisendmuutujad ja seadistame astmelise vahemälu konfiguratsiooni:

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

Määratleme kaks töötlemisetappi: üks SageMakeri funktsioonide poe allaneelamiseks ja teine ​​andmete ettevalmistamiseks. See peaks välja nägema väga sarnane eelnevalt kirjeldatud sammudele. Ainus uus koodirida on ProcessingStep pärast sammude määratlust, mis võimaldab meil võtta töötlemistöö konfiguratsiooni ja lisada see konveierietapina. Täpsustame veel andmete ettevalmistamise etapi sõltuvust SageMakeri funktsioonide poe allaneelamisetapist. Vaadake järgmist koodi:

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

Samamoodi peame mudeli koolituse ja häälestamise etapi koostamiseks lisama määratluse TuningStep pärast mudelitreeningu sammu koodi, et saaksime käivitada SageMakeri hüperparameetrite häälestamise protsessi etapina:

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

Pärast häälestamisetappi registreerime parima mudeli SageMakeri mudeliregistrisse. Mudeli kvaliteedi kontrollimiseks rakendame minimaalse kvaliteedivärava, mis võrdleb parima mudeli objektiivset mõõdikut (RMSE) konveieri sisendparameetrina määratletud lävega. rmse_threshold. Selle hindamise tegemiseks loome teise töötlemisetapi käivitamiseks hindamisskript. Mudeli hindamise tulemus salvestatakse atribuudifailina. Atribuudifailid on eriti kasulikud töötlemisetapi tulemuste analüüsimisel, et otsustada, kuidas teisi samme käitada. Vaadake järgmist koodi:

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

Määratleme a ModelStep parima mudeli registreerimiseks meie konveieri SageMakeri mudeliregistrisse. Juhul kui parim mudel ei läbi meie etteantud kvaliteedikontrolli, täpsustame lisaks a FailStep veateate väljastamiseks:

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

Järgmisena kasutame a ConditionStep hinnata, kas järgmisena tuleks teha mudeli registreerimise etapp või ebaõnnestumise etapp. Meie puhul registreeritakse parim mudel, kui selle RMSE skoor on lävest madalam.

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

Lõpuks korraldame kõik määratletud sammud konveieriks:

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)

Eelnevat konveieri saab visualiseerida ja käivitada otse SageMaker Studios või käivitada helistades execution = training_pipeline.start(). Järgmine joonis illustreerib torujuhtme voolu.

Lisaks saame üle vaadata torujuhtme täitmisel loodud artefaktide liini.

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)

Mudeli juurutamine

Pärast seda, kui parim mudel on registreeritud SageMakeri mudeliregistris konveieri käitamise kaudu, juurutame mudeli reaalajas lõpp-punkti, kasutades SageMakeri täielikult hallatud mudeli juurutamise võimalusi. SageMakeril on ka teisi mudeli juurutamise võimalusi, mis vastavad erinevate kasutusjuhtude vajadustele. Üksikasjade saamiseks vaadake Kasutage järelduste tegemiseks mudeleid kui valite oma kasutusjuhtumile sobiva valiku. Esmalt registreerime mudeli SageMakeri mudeliregistris:

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

Mudeli hetkeseis on PendingApproval. Peame selle olekuks määrama Approved enne kasutuselevõttu:

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
)

Koristage

Kui olete katsetamise lõpetanud, ärge unustage ressursse puhastada, et vältida tarbetuid tasusid. Puhastamiseks kustutage API-de kutsudes reaalajas lõpp-punkt, mudelirühm, konveier ja funktsioonirühm Kustuta lõpp-punkt, KustutaModelPackageGroup, Kustuta torujuheja DeleteFeatureGroupja sulgege kõik SageMaker Studio sülearvuti eksemplarid.

Järeldus

See postitus demonstreeris samm-sammult ülevaadet SageMakeri torujuhtmete kasutamisest Ray-põhiste ML-töövoogude korraldamiseks. Samuti demonstreerisime SageMaker Pipelinesi võimet integreerida kolmandate osapoolte ML-tööriistadega. On olemas erinevad AWS-teenused, mis toetavad Ray töökoormust skaleeritaval ja turvalisel viisil, et tagada jõudluse tipptase ja töötõhusus. Nüüd on teie kord uurida neid võimsaid võimalusi ja alustada oma masinõppe töövoogude optimeerimist Amazon SageMaker Pipelinesi ja Ray abil. Tegutsege juba täna ja avage oma ML-projektide kogu potentsiaal!

---

Teave Autor

Raju Rangan on Amazon Web Servicesi (AWS) vanemlahenduste arhitekt. Ta teeb koostööd valitsuse sponsoreeritud üksustega, aidates neil luua AWS-i abil tehisintellekti/ML-lahendusi. Kui te pilvelahenduste kallal ei nokitse, tabate ta perega aega veetmas või sõpradega elavas sulgpallimängus linnukesi löömas.

Sherry Ding on Amazon Web Servicesi (AWS) vanem AI/ML-spetsialistide lahenduste arhitekt. Tal on laialdased kogemused masinõppe alal arvutiteaduse doktorikraadiga. Ta töötab peamiselt avaliku sektori klientidega erinevate tehisintellektiga/ML-ga seotud äriprobleemidega, aidates neil kiirendada masinõppe teekonda AWS-i pilves. Kui kliente ei aita, naudib ta tegevusi väljas.

• SEO-põhise sisu ja PR-levi. Võimenduge juba täna.
• PlatoData.Network Vertikaalne generatiivne Ai. Jõustage ennast. Juurdepääs siia.
• PlatoAiStream. Web3 luure. Täiustatud teadmised. Juurdepääs siia.
• PlatoESG. Süsinik, CleanTech, Energia, Keskkond päikeseenergia, Jäätmekäitluse. Juurdepääs siia.
• PlatoTervis. Biotehnoloogia ja kliiniliste uuringute luureandmed. Juurdepääs siia.
• BlockOffsets. Keskkonnakompensatsiooni omandi ajakohastamine. Juurdepääs siia.
• Allikas: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/