Orkesteroi Ray-pohjaisia ​​koneoppimisen työnkulkuja Amazon SageMakerin avulla Amazon Web Services

Koneoppimisesta (ML) tulee yhä monimutkaisempaa, kun asiakkaat yrittävät ratkaista yhä haastavampia ongelmia. Tämä monimutkaisuus johtaa usein hajautetun ML:n tarpeeseen, jossa yhden mallin kouluttamiseen käytetään useita koneita. Vaikka tämä mahdollistaa tehtävien rinnastamisen useiden solmujen välillä, mikä nopeuttaa harjoitusaikoja, parantaa skaalautuvuutta ja parantaa suorituskykyä, hajautetun laitteiston tehokkaaseen käyttöön liittyy merkittäviä haasteita. Tietojen tutkijoiden on vastattava haasteisiin, kuten tietojen osiointi, kuormituksen tasapainottaminen, vikasietoisuus ja skaalautuvuus. ML-insinöörien on käsiteltävä rinnakkaisuutta, ajoitusta, vikoja ja uudelleenyrityksiä manuaalisesti, mikä vaatii monimutkaista infrastruktuurikoodia.

Tässä viestissä keskustelemme käytön eduista säde ja Amazon Sage Maker hajautettua ML-käyttöjärjestelmää varten ja antaa vaiheittaisen oppaan näiden kehysten käyttämisestä skaalautuvan ML-työnkulun rakentamiseen ja käyttöönottoon.

Ray, avoimen lähdekoodin hajautettu laskentakehys, tarjoaa joustavan kehyksen hajautettuun koulutukseen ja ML-mallien palvelemiseen. Se tiivistää pois matalan tason hajautetun järjestelmän yksityiskohdat yksinkertaisten, skaalautuvien kirjastojen avulla yleisiä ML-tehtäviä varten, kuten tietojen esikäsittely, hajautettu koulutus, hyperparametrien viritys, vahvistusoppiminen ja mallin käyttö.

SageMaker on täysin hallittu palvelu ML-mallien rakentamiseen, koulutukseen ja käyttöönottoon. Ray integroituu saumattomasti SageMaker-ominaisuuksiin luodakseen ja ottaakseen käyttöön monimutkaisia ​​ML-työkuormia, jotka ovat sekä tehokkaita että luotettavia. Rayn ja SageMakerin yhdistelmä tarjoaa päästä päähän -ominaisuudet skaalautuviin ML-työnkulkuihin, ja siinä on seuraavat korostetut ominaisuudet:

• Hajautetut toimijat ja rinnakkaisuuskonstruktit Rayssa yksinkertaistavat hajautettujen sovellusten kehittämistä.
• Ray AI Runtime (AIR) vähentää kitkaa siirtyessä kehityksestä tuotantoon. Rayn ja AIR:n avulla sama Python-koodi voi skaalata saumattomasti kannettavasta tietokoneesta suureen klusteriin.
• SageMakerin hallittu infrastruktuuri ja ominaisuudet, kuten prosessointityöt, koulutustyöt ja hyperparametrien viritystyöt, voivat käyttää alla olevia Ray-kirjastoja hajautettuun laskentaan.
• Amazon SageMaker -kokeilut mahdollistaa nopean iteroinnin ja kokeiden seuraamisen.
• Amazon SageMaker -ominaisuuskauppa tarjoaa skaalautuvan arkiston mallikoulutuksen ML-ominaisuuksien tallentamiseen, hakemiseen ja jakamiseen.
• Koulutetut mallit voidaan tallentaa, versioida ja seurata Amazon SageMaker -mallirekisteri hallintoa ja johtamista varten.

• Amazon SageMaker -putkistot mahdollistaa kokonaisvaltaisen ML-elinkaarin organisoinnin tietojen valmistelusta ja koulutuksesta mallin käyttöönottoon automatisoituina työnkulkuina.

Ratkaisun yleiskatsaus

Tämä viesti keskittyy Rayn ja SageMakerin yhteiskäytön etuihin. Perustimme päästä-päähän Ray-pohjaisen ML-työnkulun, joka on järjestetty SageMaker Pipelinesillä. Työnkulku sisältää tietojen rinnakkaisen syöttämisen ominaisuusvarastoon Ray-toimijoiden avulla, tietojen esikäsittelyn Ray Datan avulla, koulutusmallit ja hyperparametrien virityksen mittakaavassa Ray Trainin ja hyperparametrioptimoinnin (HPO) viritystöiden avulla sekä lopuksi mallin arvioinnin ja mallin rekisteröinnin mallirekisteri.

Tietojemme osalta käytämme synteettinen asuntotietojoukko joka koostuu kahdeksasta ominaisuudesta (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCHja DECK) ja mallimme ennustaa PRICE talosta.

Jokainen ML-työnkulun vaihe on jaettu erillisiin vaiheisiin, joissa on oma skriptinsä, joka ottaa syöttö- ja lähtöparametrit. Seuraavassa osiossa korostamme tärkeimmät koodinpätkät kustakin vaiheesta. Koko koodi löytyy osoitteesta aws-samples-for-ray GitHub-arkisto.

Edellytykset

Jotta voit käyttää SageMaker Python SDK:ta ja suorittaa tähän viestiin liittyvän koodin, tarvitset seuraavat edellytykset:

Siirrä tiedot SageMaker Feature Storeen

Ensimmäinen vaihe ML-työnkulussa on lukea lähdetietotiedosto Amazonin yksinkertainen tallennuspalvelu (Amazon S3) CSV-muodossa ja syötä se SageMaker Feature Storeen. SageMaker Feature Store on tarkoitukseen rakennettu tietovarasto, jonka avulla ryhmien on helppo luoda, jakaa ja hallita ML-ominaisuuksia. Se yksinkertaistaa ominaisuuksien löytämistä, uudelleenkäyttöä ja jakamista, mikä nopeuttaa kehitystä, lisää yhteistyötä asiakastiimien sisällä ja alentaa kustannuksia.

Ominaisuuksien siirtäminen ominaisuuskauppaan sisältää seuraavat vaiheet:

1. Määritä ominaisuusryhmä ja luo ominaisuusryhmä ominaisuussäilöön.
2. Valmistele lähdetiedot ominaisuusvarastoa varten lisäämällä tapahtuma-aika ja tietuetunnus kullekin tietoriville.
3. Sisällytä valmistetut tiedot ominaisuusryhmään Boto3 SDK:n avulla.

Tässä osiossa korostamme vain vaihetta 3, koska tämä on osa, joka sisältää käsittelytehtävän rinnakkaiskäsittelyn Rayn avulla. Voit tarkastella tämän prosessin koko koodia osoitteessa GitHub repo.

- ingest_features menetelmä määritellään luokan sisällä Featurestore. Huomaa, että Featurestore luokka on koristeltu @ray.remote. Tämä osoittaa, että tämän luokan esiintymä on Säteen toimija, tilallinen ja samanaikainen laskentayksikkö Säteen sisällä. Se on ohjelmointimalli, jonka avulla voit luoda hajautettuja objekteja, jotka ylläpitävät sisäistä tilaa ja joita voidaan käyttää samanaikaisesti useilla tehtävillä, jotka suoritetaan Ray-klusterin eri solmuissa. Toimijat tarjoavat tavan hallita ja kapseloida muuttuvaa tilaa, mikä tekee niistä arvokkaita rakennettaessa monimutkaisia, tilallisia sovelluksia hajautetussa ympäristössä. Voit määrittää resurssivaatimukset myös toimijoille. Tässä tapauksessa jokainen esiintymä FeatureStore luokka vaatii 0.5 CPU:ta. Katso seuraava 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. """ ...

Voit olla vuorovaikutuksessa näyttelijän kanssa soittamalla remote operaattori. Seuraavassa koodissa haluttu määrä näyttelijöitä välitetään skriptin syöttöargumenttina. Tiedot osioidaan sitten toimijoiden lukumäärän perusteella ja välitetään rinnakkaisille etäprosesseille syötettäväksi ominaisuussäilöön. Voit soittaa get objektiin ref estääksesi nykyisen tehtävän suorittamisen, kunnes etälaskenta on valmis ja tulos on saatavilla. Kun tulos on saatavilla, ray.get palauttaa tuloksen ja nykyisen tehtävän suorittaminen jatkuu.

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)

Valmistele tiedot koulutusta, validointia ja testausta varten

Tässä vaiheessa käytämme Ray Datasetiä datajoukkomme tehokkaaseen jakamiseen, muuntamiseen ja skaalaamiseen valmistautuessamme koneoppimiseen. Ray Dataset tarjoaa vakiotavan ladata hajautettua dataa Rayhin, ja se tukee erilaisia ​​tallennusjärjestelmiä ja tiedostomuotoja. Siinä on API yleisiä ML-tietojen esikäsittelytoimintoja varten, kuten rinnakkaisia ​​muunnoksia, sekoitusta, ryhmittelyä ja aggregaatioita. Ray Dataset käsittelee myös toiminnot, jotka edellyttävät tilallista asetusta ja GPU-kiihdytystä. Se integroituu sujuvasti muiden tietojenkäsittelykirjastojen, kuten Spark, Pandas, NumPy ja muiden, sekä ML-kehysten, kuten TensorFlow ja PyTorch, kanssa. Tämä mahdollistaa päästä päähän -tietoputkien ja ML-työnkulkujen rakentamisen Rayn päälle. Tavoitteena on helpottaa hajautettua tiedonkäsittelyä ja ML:ää toimijoiden ja tutkijoiden kannalta.

Katsotaanpa komentosarjojen osia, jotka suorittavat tämän tietojen esikäsittelyn. Aloitamme lataamalla tiedot ominaisuuskaupasta:

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

Sitten jaamme ja skaalaamme tiedot käyttämällä korkeamman tason abstraktioita, jotka ovat saatavilla osoitteesta ray.data kirjasto:

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

Käsitellyt juna-, validointi- ja testidatajoukot tallennetaan Amazon S3:een ja välitetään syöttöparametreina seuraaviin vaiheisiin.

Suorita mallikoulutus ja hyperparametrien optimointi

Kun tietomme on esikäsitelty ja valmis mallintamista varten, on aika kouluttaa joitain ML-malleja ja hienosäätää niiden hyperparametreja ennustavan suorituskyvyn maksimoimiseksi. Käytämme XGBoost-Ray, hajautettu taustaohjelma XGBoostille, joka on rakennettu Raylle ja joka mahdollistaa XGBoost-mallien opettamisen suurille tietojoukoille käyttämällä useita solmuja ja GPU:ita. Se tarjoaa yksinkertaisia ​​korvauksia XGBoostin junalle ja ennustaa API-liittymiä samalla kun se käsittelee hajautetun tiedonhallinnan ja koulutuksen monimutkaisuutta.

Mahdollistaaksemme koulutuksen jakamisen useille solmuille, käytämme auttajaluokkaa nimeltä RayHelper. Kuten seuraavassa koodissa näkyy, käytämme koulutustyön resurssimäärityksiä ja valitsemme pääsolmuksi ensimmäisen isännän:

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

Voimme käyttää isäntätietoja päättääksemme, kuinka Ray alustetaan kussakin koulutustyön tapauksessa:

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)

Kun koulutustyö aloitetaan, Ray-klusteri voidaan alustaa soittamalla start_ray() menetelmän tapauksessa RayHelper:

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

Käytämme sitten harjoitteluun XGBoost-Rayn XGBoost traineria:

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)

Huomaa, että instantoiessasi trainer, ohitamme RayParams, joka ottaa näyttelijöiden määrän ja suorittimien määrän näyttelijätä kohti. XGBoost-Ray käyttää näitä tietoja jakaakseen koulutuksen kaikille sädeklusteriin liitetyille solmuille.

Luomme nyt XGBoost-estimaattoriobjektin SageMaker Python SDK:n pohjalta ja käytämme sitä HPO-työhön.

Orkesteroi edelliset vaiheet SageMaker Pipelinesin avulla

Jotta voimme rakentaa päästä päähän skaalautuvan ja uudelleen käytettävän ML-työnkulun, meidän on käytettävä CI/CD-työkalua edellisten vaiheiden järjestämiseen liukuhihnaksi. SageMaker Pipelines on integroitu suoraan SageMakeriin, SageMaker Python SDK:hen ja SageMaker Studioon. Tämän integroinnin avulla voit luoda ML-työnkulkuja helppokäyttöisellä Python SDK:lla ja sitten visualisoida ja hallita työnkulkuasi SageMaker Studion avulla. Voit myös seurata tietojesi historiaa prosessin aikana ja määrittää välimuistiin tallennuksen vaiheet.

SageMaker Pipelines luo suunnatun asyklisen graafin (DAG), joka sisältää vaiheet, joita tarvitaan ML-työnkulun rakentamiseen. Jokainen liukuhihna on sarja toisiinsa yhdistettyjä vaiheita, jotka on järjestetty vaiheiden välisten datariippuvuuksien perusteella, ja ne voidaan parametroida, jolloin voit antaa syöttömuuttujia parametreiksi liukuhihnan jokaiselle ajolle. SageMaker Pipelinesillä on neljän tyyppisiä liukuhihnaparametreja: ParameterString, ParameterInteger, ParameterFloatja ParameterBoolean. Tässä osiossa parametroimme joitain syöttömuuttujia ja määritämme vaihevälimuistin määrityksen:

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äärittelemme kaksi käsittelyvaihetta: toinen SageMaker Feature Store -sovelluksen käsittelyä varten ja toinen tietojen valmistelua varten. Tämän pitäisi näyttää hyvin samanlaiselta kuin aiemmin kuvatut vaiheet. Ainoa uusi koodirivi on ProcessingStep vaiheiden määritelmän jälkeen, jonka avulla voimme ottaa käsittelytyön kokoonpanon ja sisällyttää sen liukuvaiheeseen. Määritämme edelleen tietojen valmisteluvaiheen riippuvuuden SageMaker Feature Store -käsittelyvaiheesta. Katso seuraava 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])

Samoin mallin koulutus- ja viritysvaiheen rakentamiseksi meidän on lisättävä määritelmä TuningStep mallin koulutusvaiheen koodin jälkeen, jotta voimme suorittaa SageMaker-hyperparametrien virityksen vaiheena valmisteilla:

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

Viritysvaiheen jälkeen päätämme rekisteröidä parhaan mallin SageMaker-mallirekisteriin. Mallin laadun hallitsemiseksi otamme käyttöön vähimmäislaatuportin, joka vertaa parhaan mallin tavoitemittaria (RMSE) putkilinjan syöttöparametriksi määriteltyyn kynnykseen. rmse_threshold. Tätä arviointia varten luomme toisen käsittelyvaiheen suorittamaan arviointiskripti. Mallin arvioinnin tulos tallennetaan ominaisuustiedostoksi. Ominaisuustiedostot ovat erityisen hyödyllisiä analysoitaessa käsittelyvaiheen tuloksia ja päätettäessä, miten muut vaiheet tulisi suorittaa. Katso seuraava 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ääritämme a ModelStep rekisteröidäksemme parhaan mallin valmisteillamme olevaan SageMaker-mallirekisteriin. Mikäli paras malli ei läpäise ennalta määrättyä laatutarkastusta, määritämme lisäksi a FailStep lähettääksesi virheilmoituksen:

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

Seuraavaksi käytämme a ConditionStep arvioida, pitäisikö mallin rekisteröintivaihe tai vikavaihe tehdä seuraavaksi valmisteilla. Meidän tapauksessamme paras malli rekisteröidään, jos sen RMSE-pistemäärä on pienempi kuin kynnys.

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

Lopuksi organisoimme kaikki määritellyt vaiheet liukuhihnaksi:

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)

Edellinen liukuhihna voidaan visualisoida ja suorittaa suoraan SageMaker Studiossa tai suorittaa kutsumalla execution = training_pipeline.start(). Seuraava kuva havainnollistaa putkilinjan virtausta.

Lisäksi voimme tarkastella liukuhihnan suorituksen luomien artefaktien linjaa.

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)

Ota käyttöön malli

Kun paras malli on rekisteröity SageMaker-mallirekisteriin putkiajon kautta, otamme mallin käyttöön reaaliaikaiseen päätepisteeseen käyttämällä SageMakerin täysin hallittuja mallin käyttöönottoominaisuuksia. SageMakerilla on muita mallin käyttöönottovaihtoehtoja eri käyttötapausten tarpeisiin. Katso lisätietoja kohdasta Ota mallit käyttöön johtopäätösten tekemiseksi kun valitset käyttötarkoitukseesi sopivan vaihtoehdon. Ensin rekisteröidään malli SageMaker-mallirekisteriin:

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

Mallin nykyinen tila on PendingApproval. Meidän on asetettava sen tilaksi Approved ennen käyttöönottoa:

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
)

Puhdistaa

Kun olet lopettanut kokeilun, muista puhdistaa resurssit tarpeettomien maksujen välttämiseksi. Puhdistaaksesi poista reaaliaikainen päätepiste, malliryhmä, liukuhihna ja ominaisuusryhmä kutsumalla API Poista päätepiste, PoistaModelPackageGroup, PoistaPipelineja Poista FeatureGroup, ja sulje kaikki SageMaker Studio -muistikirjan esiintymät.

Yhteenveto

Tämä viesti esitteli vaiheittaisen esittelyn SageMaker Pipelinesin käyttämisestä sädepohjaisten ML-työnkulkujen ohjaamiseen. Osoitimme myös SageMaker Pipelinesin kyvyn integroida kolmannen osapuolen ML-työkaluihin. On olemassa useita AWS-palveluita, jotka tukevat Ray-työkuormia skaalautuvalla ja turvallisella tavalla suorituskyvyn ja toiminnan tehokkuuden varmistamiseksi. Nyt on sinun vuorosi tutkia näitä tehokkaita ominaisuuksia ja aloittaa koneoppimisen työnkulkujen optimointi Amazon SageMaker Pipelinesin ja Rayn avulla. Ryhdy toimiin tänään ja hyödynnä ML-projektiesi täysi potentiaali!

---

kirjailijasta

Raju Rangan on vanhempi ratkaisuarkkitehti Amazon Web Servicesissä (AWS). Hän työskentelee valtion tukemien tahojen kanssa ja auttaa niitä rakentamaan tekoäly/ML-ratkaisuja AWS:n avulla. Kun et etsi pilviratkaisuja, saat hänet hengailemaan perheen kanssa tai lyömään lintuja vilkkaassa sulkapallopelissä ystävien kanssa.

Sherry Ding on vanhempi AI/ML-asiantuntijaratkaisujen arkkitehti Amazon Web Servicesissä (AWS). Hänellä on laaja kokemus koneoppimisesta tietojenkäsittelytieteen tohtoriksi. Hän työskentelee pääasiassa julkisen sektorin asiakkaiden kanssa erilaisissa tekoälyyn/ML:ään liittyvissä liiketoiminnan haasteissa, mikä auttaa heitä nopeuttamaan koneoppimismatkaansa AWS-pilvessä. Kun hän ei auta asiakkaita, hän nauttii ulkoilusta.

• SEO-pohjainen sisällön ja PR-jakelu. Vahvista jo tänään.
• PlatoData.Network Vertical Generatiivinen Ai. Vahvista itseäsi. Pääsy tästä.
• PlatoAiStream. Web3 Intelligence. Tietoa laajennettu. Pääsy tästä.
• PlatoESG. hiili, CleanTech, energia, ympäristö, Aurinko, Jätehuolto. Pääsy tästä.
• PlatonHealth. Biotekniikan ja kliinisten kokeiden älykkyys. Pääsy tästä.
• BlockOffsets. Ympäristövastuun omistuksen nykyaikaistaminen. Pääsy tästä.
• Lähde: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/