Orkestrirajte poteke dela strojnega učenja, ki temeljijo na Ray, z uporabo Amazon SageMaker | Spletne storitve Amazon

Strojno učenje (ML) postaja vse bolj zapleteno, saj stranke poskušajo rešiti vedno več zahtevnih problemov. Ta zapletenost pogosto vodi do potrebe po porazdeljenem ML, kjer se za usposabljanje enega modela uporablja več strojev. Čeprav to omogoča vzporedno izvajanje nalog v več vozliščih, kar vodi do pospešenega časa usposabljanja, izboljšane razširljivosti in izboljšane zmogljivosti, obstajajo pomembni izzivi pri učinkoviti uporabi porazdeljene strojne opreme. Podatkovni znanstveniki se morajo spopasti z izzivi, kot so particioniranje podatkov, uravnoteženje obremenitve, toleranca napak in razširljivost. Inženirji ML se morajo ukvarjati s paralelizacijo, razporejanjem, napakami in ponovnimi poskusi ročno, kar zahteva kompleksno infrastrukturno kodo.

V tej objavi razpravljamo o prednostih uporabe Ray in Amazon SageMaker za porazdeljeno ML in nudijo vodnik po korakih o tem, kako uporabiti ta ogrodja za gradnjo in uvajanje razširljivega delovnega toka ML.

Ray, odprtokodno porazdeljeno računalniško ogrodje, zagotavlja prilagodljivo ogrodje za porazdeljeno usposabljanje in streženje modelov ML. Abstrahira nizkonivojske porazdeljene sistemske podrobnosti s preprostimi, razširljivimi knjižnicami za običajna opravila ML, kot so predprocesiranje podatkov, porazdeljeno usposabljanje, uravnavanje hiperparametrov, okrepljeno učenje in strežba modela.

SageMaker je popolnoma upravljana storitev za gradnjo, usposabljanje in uvajanje modelov ML. Ray se brezhibno integrira s funkcijami SageMaker za gradnjo in uvajanje kompleksnih delovnih obremenitev ML, ki so učinkovite in zanesljive. Kombinacija Ray in SageMaker zagotavlja zmogljivosti od konca do konca za razširljive poteke dela ML in ima naslednje poudarjene funkcije:

• Porazdeljeni akterji in vzporedni konstrukti v Rayu poenostavljajo razvoj porazdeljenih aplikacij.
• Ray AI Runtime (AIR) zmanjša trenje pri prehodu od razvoja do proizvodnje. Z Ray in AIR se lahko ista koda Python neopazno razširi iz prenosnega računalnika v veliko gručo.
• Upravljana infrastruktura SageMakerja in funkcije, kot so opravila obdelave, opravila usposabljanja in opravila prilagajanja hiperparametrov, lahko pod seboj uporabljajo knjižnice Ray za porazdeljeno računalništvo.
• Eksperimenti Amazon SageMaker omogoča hitro ponavljanje in spremljanje poskusov.
• Trgovina s funkcijami Amazon SageMaker ponuja razširljiv repozitorij za shranjevanje, pridobivanje in skupno rabo funkcij ML za usposabljanje modelov.
• Izurjene modele je mogoče shranjevati, spreminjati različice in jim slediti Register modelov Amazon SageMaker za upravljanje in upravljanje.

• Amazonski cevovodi SageMaker omogoča orkestriranje življenjskega cikla ML od konca do konca od priprave podatkov in usposabljanja do uvajanja modela kot avtomatiziranih delovnih tokov.

Pregled rešitev

Ta objava se osredotoča na prednosti skupne uporabe Ray in SageMaker. Vzpostavili smo potek dela ML od konca do konca, ki temelji na Ray-u in je orkestriran s pomočjo SageMaker Pipelines. Delovni tok vključuje vzporedno vnašanje podatkov v shrambo funkcij z uporabo akterjev Ray, predprocesiranje podatkov z Ray Data, modele usposabljanja in nastavitev hiperparametrov v obsegu z uporabo Ray Traina in nastavitev optimizacije hiperparametrov (HPO) ter končno vrednotenje modela in registracijo modela v register modelov.

Za naše podatke uporabljamo nabor sintetičnih stanovanjskih podatkov ki je sestavljen iz osmih funkcij (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCHin DECK) in naš model bo napovedal PRICE hiše.

Vsaka stopnja v delovnem toku ML je razdeljena na ločene korake z lastnim skriptom, ki sprejme vhodne in izhodne parametre. V naslednjem razdelku poudarjamo ključne delčke kode iz vsakega koraka. Celotno kodo lahko najdete na repozitorij aws-samples-for-ray GitHub.

Predpogoji

Za uporabo SDK-ja SageMaker Python in zagon kode, povezane s to objavo, potrebujete naslednje predpogoje:

Vnesite podatke v SageMaker Feature Store

Prvi korak v delovnem toku ML je branje izvorne podatkovne datoteke Preprosta storitev shranjevanja Amazon (Amazon S3) v formatu CSV in ga vnesite v SageMaker Feature Store. SageMaker Feature Store je namensko izdelano skladišče, ki ekipam olajša ustvarjanje, skupno rabo in upravljanje funkcij ML. Poenostavlja odkrivanje, ponovno uporabo in skupno rabo funkcij, kar vodi do hitrejšega razvoja, povečanega sodelovanja znotraj skupin strank in nižjih stroškov.

Vnašanje funkcij v shrambo funkcij vključuje naslednje korake:

1. Definirajte skupino funkcij in ustvarite skupino funkcij v shrambi funkcij.
2. Pripravite izvorne podatke za shrambo funkcij tako, da dodate čas dogodka in ID zapisa za vsako vrstico podatkov.
3. Vnesite pripravljene podatke v skupino funkcij z uporabo Boto3 SDK.

V tem razdelku izpostavljamo le 3. korak, ker je to del, ki vključuje vzporedno obdelavo naloge za vnos z uporabo Ray-a. Celotno kodo za ta postopek si lahko ogledate v GitHub repo.

O ingest_features metoda je definirana znotraj razreda, imenovanega Featurestore. Upoštevajte, da Featurestore razred je okrašen z @ray.remote. To nakazuje, da je primerek tega razreda igralec Ray, sočasna računska enota znotraj Raya s stanjem. To je model programiranja, ki vam omogoča ustvarjanje porazdeljenih objektov, ki ohranjajo notranje stanje in do katerih lahko hkrati dostopa več nalog, ki se izvajajo na različnih vozliščih v gruči Ray. Akterji zagotavljajo način za upravljanje in enkapsulacijo spremenljivega stanja, zaradi česar so dragoceni za gradnjo kompleksnih aplikacij s stanjem v porazdeljeni nastavitvi. Zahteve za vire lahko določite tudi v akterjih. V tem primeru vsak primerek FeatureStore bo zahteval 0.5 procesorja. Oglejte si naslednjo kodo:

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

Z igralcem lahko komunicirate tako, da pokličete remote operater. V naslednji kodi je želeno število igralcev posredovano kot vhodni argument v skript. Podatki so nato razdeljeni glede na število akterjev in posredovani oddaljenim vzporednim procesom, ki se vnesejo v shrambo funkcij. Lahko pokličeš get na objektu ref, da blokira izvajanje trenutne naloge, dokler oddaljeni izračun ni končan in je rezultat na voljo. Ko je rezultat na voljo, ray.get bo vrnil rezultat in izvajanje trenutne naloge se bo nadaljevalo.

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)

Pripravite podatke za usposabljanje, validacijo in testiranje

V tem koraku uporabljamo Ray Dataset za učinkovito razdelitev, transformacijo in skaliranje našega nabora podatkov v pripravi na strojno učenje. Ray Dataset ponuja standardni način za nalaganje distribuiranih podatkov v Ray, ki podpira različne sisteme za shranjevanje in formate datotek. Ima API-je za običajne operacije predprocesiranja podatkov ML, kot so vzporedne transformacije, mešanje, združevanje in združevanje. Ray Dataset obravnava tudi operacije, ki potrebujejo nastavitev s stanjem in pospešek GPE. Brezhibno se integrira z drugimi knjižnicami za obdelavo podatkov, kot so Spark, Pandas, NumPy in druge, pa tudi z ogrodji ML, kot sta TensorFlow in PyTorch. To omogoča gradnjo podatkovnih cevovodov od konca do konca in delovnih tokov ML na vrhu Raya. Cilj je olajšati porazdeljeno obdelavo podatkov in ML za praktike in raziskovalce.

Oglejmo si dele skriptov, ki izvajajo to predhodno obdelavo podatkov. Začnemo z nalaganjem podatkov iz shrambe funkcij:

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

Podatke nato razdelimo in skaliramo z abstrakcijami višje ravni, ki so na voljo pri ray.data knjižnica:

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

Obdelani nabori podatkov o usposabljanju, validaciji in preskusu so shranjeni v Amazon S3 in bodo posredovani kot vhodni parametri v naslednje korake.

Izvedite usposabljanje modela in optimizacijo hiperparametrov

Ker so naši podatki vnaprej obdelani in pripravljeni za modeliranje, je čas, da usposobimo nekatere modele ML in natančno prilagodimo njihove hiperparametre, da povečamo napovedno zmogljivost. Uporabljamo XGBoost-Ray, porazdeljeno zaledje za XGBoost, zgrajeno na Rayju, ki omogoča usposabljanje modelov XGBoost na velikih nizih podatkov z uporabo več vozlišč in grafičnih procesorjev. Zagotavlja preproste nadomestne zamenjave za XGBoost's vlak in predvidevanje API-jev, medtem ko obravnava zapletenost porazdeljenega upravljanja podatkov in usposabljanja pod pokrovom.

Da bi omogočili distribucijo usposabljanja na več vozliščih, uporabljamo pomožni razred z imenom RayHelper. Kot je prikazano v naslednji kodi, uporabimo konfiguracijo virov učnega opravila in izberemo prvega gostitelja kot glavno vozlišče:

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

Podatke o gostitelju lahko uporabimo, da se odločimo, kako inicializirati Ray na vsakem primerku opravila usposabljanja:

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)

Ko se začne učno opravilo, je mogoče inicializirati gručo Ray s klicem start_ray() metoda na primeru RayHelper:

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

Nato za usposabljanje uporabimo XGBoost trainer podjetja XGBoost-Ray:

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)

Upoštevajte, da med ustvarjanjem primerka trainer, mimo RayParams, ki zajema število akterjev in število procesorjev na akterja. XGBoost-Ray uporablja te informacije za distribucijo usposabljanja po vseh vozliščih, ki so priključena na gručo Ray.

Zdaj ustvarimo objekt ocenjevalnika XGBoost na podlagi SDK-ja SageMaker Python in ga uporabimo za opravilo HPO.

Orkestrirajte prejšnje korake z uporabo SageMaker Pipelines

Za izgradnjo razširljivega in ponovno uporabljivega delovnega toka ML od konca do konca moramo uporabiti orodje CI/CD za orkestracijo predhodnih korakov v cevovod. SageMaker Pipelines ima neposredno integracijo s SageMaker, SDK SageMaker Python in SageMaker Studio. Ta integracija vam omogoča ustvarjanje delovnih tokov ML s Python SDK-jem, ki je enostaven za uporabo, ter nato vizualizacijo in upravljanje vašega delovnega toka s SageMaker Studio. Prav tako lahko spremljate zgodovino svojih podatkov v izvajanju cevovoda in določite korake za predpomnjenje.

SageMaker Pipelines ustvari usmerjeni aciklični graf (DAG), ki vključuje korake, potrebne za izgradnjo poteka dela ML. Vsak cevovod je vrsta medsebojno povezanih korakov, ki so usklajeni z odvisnostmi podatkov med koraki in ga je mogoče parametrizirati, kar vam omogoča, da zagotovite vhodne spremenljivke kot parametre za vsak zagon cevovoda. SageMaker Pipelines ima štiri vrste parametrov cevovoda: ParameterString, ParameterInteger, ParameterFloatin ParameterBoolean. V tem razdelku parametriramo nekatere vhodne spremenljivke in nastavimo konfiguracijo predpomnjenja korakov:

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

Določimo dva koraka obdelave: enega za vnos SageMaker Feature Store, drugega za pripravo podatkov. To bi moralo izgledati zelo podobno prejšnjim korakom, opisanim prej. Edina nova vrstica kode je ProcessingStep po definiciji korakov, kar nam omogoča, da vzamemo konfiguracijo opravila obdelave in jo vključimo kot korak cevovoda. Nadalje določamo odvisnost koraka priprave podatkov od koraka vnosa SageMaker Feature Store. Oglejte si naslednjo kodo:

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

Podobno moramo za izgradnjo koraka usposabljanja in prilagajanja modela dodati definicijo TuningStep po kodi koraka usposabljanja modela, ki nam omogoča zagon nastavitve hiperparametrov SageMaker kot korak v cevovodu:

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

Po koraku uglaševanja se odločimo za registracijo najboljšega modela v register modelov SageMaker. Za nadzor kakovosti modela implementiramo vrata minimalne kakovosti, ki primerjajo objektivno metriko najboljšega modela (RMSE) s pragom, definiranim kot vhodni parameter cevovoda. rmse_threshold. Za izvedbo te ocene ustvarimo še en korak obdelave za izvajanje ocenjevalni scenarij. Rezultat vrednotenja modela bo shranjen kot datoteka lastnosti. Datoteke z lastnostmi so še posebej uporabne pri analizi rezultatov koraka obdelave, da se odločite, kako naj se izvajajo drugi koraki. Oglejte si naslednjo kodo:

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

Določimo a ModelStep za registracijo najboljšega modela v SageMaker Model Registry v našem načrtu. V primeru, da najboljši model ne prestane našega vnaprej določenega preverjanja kakovosti, dodatno določimo a FailStep za izpis sporočila o napaki:

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

Nato uporabimo a ConditionStep da ocenite, ali je naslednji v pripravi korak registracije modela ali korak napake. V našem primeru bo najboljši model registriran, če je njegov rezultat RMSE nižji od praga.

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

Končno orkestriramo vse definirane korake v cevovod:

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)

Predhodni cevovod je mogoče vizualizirati in izvesti neposredno v programu SageMaker Studio ali pa ga izvesti s klicem execution = training_pipeline.start(). Naslednja slika prikazuje tok cevovoda.

Poleg tega lahko pregledamo rod artefaktov, ustvarjenih z izvajanjem cevovoda.

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)

Namestite model

Ko je najboljši model registriran v registru modelov SageMaker prek cevovoda, uvedemo model na končno točko v realnem času z uporabo popolnoma upravljanih zmogljivosti uvajanja modela SageMaker. SageMaker ima druge možnosti uvajanja modela, ki ustrezajo potrebam različnih primerov uporabe. Za podrobnosti glejte Razporedite modele za sklepanje pri izbiri prave možnosti za vaš primer uporabe. Najprej registrirajmo model v registru modelov SageMaker:

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

Trenutno stanje modela je PendingApproval. Njegovo stanje moramo nastaviti na Approved pred namestitvijo:

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
)

Čiščenje

Ko končate z eksperimentiranjem, ne pozabite očistiti virov, da se izognete nepotrebnim stroškom. Če želite počistiti, izbrišite končno točko v realnem času, skupino modelov, cevovod in skupino funkcij s klicem API-jev DeleteEndpoint, DeleteModelPackageGroup, DeletePipelinein DeleteFeatureGroupin zaustavite vse primerke prenosnika SageMaker Studio.

zaključek

Ta objava je predstavila korak za korakom navodila za uporabo SageMaker Pipelines za orkestriranje delovnih tokov ML, ki temeljijo na Ray. Prikazali smo tudi zmožnost SageMaker Pipelines za integracijo z orodji ML tretjih oseb. Obstajajo različne storitve AWS, ki podpirajo delovne obremenitve Ray na razširljiv in varen način, da zagotovijo odlično delovanje in operativno učinkovitost. Zdaj ste vi na vrsti, da raziščete te zmogljive zmožnosti in začnete optimizirati svoje poteke dela strojnega učenja z Amazon SageMaker Pipelines in Ray. Ukrepajte še danes in sprostite polni potencial svojih projektov ML!

---

O Author

Raju Rangan je višji arhitekt rešitev pri Amazon Web Services (AWS). Sodeluje s subjekti, ki jih sponzorira vlada, in jim pomaga zgraditi rešitve AI/ML z uporabo AWS. Ko se ne bo ukvarjal z rešitvami v oblaku, ga boste ujeli med druženjem z družino ali razbijanjem ptičkov v živahni igri badmintona s prijatelji.

Sherry Ding je višji specialist za rešitve AI/ML pri Amazon Web Services (AWS). Ima bogate izkušnje s strojnim učenjem z doktoratom iz računalništva. V glavnem sodeluje s strankami iz javnega sektorja pri različnih poslovnih izzivih, povezanih z AI/ML, in jim pomaga pospešiti njihovo pot strojnega učenja v oblaku AWS. Ko ne pomaga strankam, uživa v dejavnostih na prostem.

• Distribucija vsebine in PR s pomočjo SEO. Okrepite se še danes.
• PlatoData.Network Vertical Generative Ai. Opolnomočite se. Dostopite tukaj.
• PlatoAiStream. Web3 Intelligence. Razširjeno znanje. Dostopite tukaj.
• PlatoESG. Ogljik, CleanTech, Energija, Okolje, sončna energija, Ravnanje z odpadki. Dostopite tukaj.
• PlatoHealth. Obveščanje o biotehnologiji in kliničnih preskušanjih. Dostopite tukaj.
• BlockOffsets. Posodobitev okoljskega offset lastništva. Dostopite tukaj.
• vir: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/