Ray-alapú gépi tanulási munkafolyamatok hangszerelése az Amazon SageMaker | segítségével Amazon webszolgáltatások

A gépi tanulás (ML) egyre összetettebbé válik, ahogy az ügyfelek egyre nagyobb kihívást jelentő problémákat próbálnak megoldani. Ez a bonyolultság gyakran vezet az elosztott ML szükségességéhez, ahol több gépet használnak egyetlen modell betanításához. Noha ez lehetővé teszi a feladatok párhuzamosítását több csomóponton keresztül, ami felgyorsítja a betanítási időt, javítja a méretezhetőséget és javítja a teljesítményt, az elosztott hardverek hatékony használata jelentős kihívásokat jelent. Az adattudósoknak olyan kihívásokkal kell szembenézniük, mint az adatparticionálás, a terheléselosztás, a hibatűrés és a méretezhetőség. Az ML mérnököknek kézzel kell kezelniük a párhuzamosítást, az ütemezést, a hibákat és az újrapróbálkozásokat, bonyolult infrastruktúrakódot igényelve.

Ebben a bejegyzésben a használat előnyeiről beszélünk Sugár és a Amazon SageMaker az elosztott ML-hez, és lépésről lépésre nyújt útmutatót arról, hogyan használhatja ezeket a keretrendszereket egy méretezhető ML-munkafolyamat létrehozásához és üzembe helyezéséhez.

A Ray, egy nyílt forráskódú elosztott számítási keretrendszer, rugalmas keretrendszert biztosít az ML-modellek elosztott képzéséhez és kiszolgálásához. Elvonja az alacsony szintű elosztott rendszer részleteit egyszerű, méretezhető könyvtárakon keresztül az általános ML-feladatokhoz, mint például az adat-előfeldolgozás, az elosztott betanítás, a hiperparaméter-hangolás, a megerősítő tanulás és a modellszolgáltatás.

A SageMaker egy teljesen felügyelt szolgáltatás ML-modellek építéséhez, betanításához és telepítéséhez. A Ray zökkenőmentesen integrálódik a SageMaker szolgáltatásaival, így összetett ML munkaterheléseket hozhat létre és telepíthet, amelyek egyszerre hatékonyak és megbízhatóak. A Ray és a SageMaker kombinációja teljes körű képességeket biztosít a méretezhető ML munkafolyamatokhoz, és a következő kiemelt funkciókkal rendelkezik:

• Az elosztott szereplők és a Ray párhuzamossági konstrukciói leegyszerűsítik az elosztott alkalmazások fejlesztését.
• A Ray AI Runtime (AIR) csökkenti a súrlódást a fejlesztéstől a gyártásig. A Ray és az AIR segítségével ugyanaz a Python-kód zökkenőmentesen méretezhető laptopról nagy fürtre.
• A SageMaker felügyelt infrastruktúrája és az olyan szolgáltatások, mint a feldolgozási feladatok, a betanítási feladatok és a hiperparaméter-hangolási feladatok, az alatta lévő Ray-könyvtárakat használhatja az elosztott számításokhoz.
• Amazon SageMaker kísérletek lehetővé teszi a kísérletek gyors iterációját és nyomon követését.
• Amazon SageMaker Feature Store méretezhető adattárat biztosít az ML-funkciók tárolására, lekérésére és megosztására a modellképzéshez.
• A betanított modellek tárolhatók, verziózhatók és nyomon követhetők Amazon SageMaker Model Registry kormányzásra és irányításra.

• Amazon SageMaker csővezetékek lehetővé teszi a végpontok közötti ML-életciklus összehangolását az adatok előkészítésétől és betanításától a modell-telepítésig, mint automatizált munkafolyamatok.

Megoldás áttekintése

Ez a bejegyzés a Ray és a SageMaker együttes használatának előnyeire összpontosít. Beállítottunk egy végpontok közötti, Ray-alapú ML munkafolyamatot, amelyet a SageMaker Pipelines segítségével irányítunk. A munkafolyamat magában foglalja az adatok párhuzamos bevitelét a szolgáltatástárolóba Ray-aktorok segítségével, adat-előfeldolgozást Ray Data segítségével, betanítási modelleket és nagy léptékű hiperparaméter-hangolást Ray Train és hiperparaméter-optimalizálási (HPO) hangolási feladatok segítségével, végül pedig a modell kiértékelését és a modell regisztrálását egy modell nyilvántartás.

Adatainkhoz használjuk szintetikus ház adatkészlet amely nyolc jellemzőből áll (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCHés DECK), és a modellünk megjósolja a PRICE a ház.

Az ML munkafolyamat minden szakasza különálló lépésekre oszlik, saját szkripttel, amely bemeneti és kimeneti paramétereket vesz fel. A következő részben minden lépésből kiemeljük a kulcsfontosságú kódrészleteket. A teljes kód megtalálható a aws-samples-for-ray GitHub adattár.

Előfeltételek

A SageMaker Python SDK használatához és a bejegyzéshez társított kód futtatásához a következő előfeltételekre van szüksége:

Nyújtsa be az adatokat a SageMaker Feature Store-ba

Az ML munkafolyamat első lépése a forrásadatfájl kiolvasása Amazon egyszerű tárolási szolgáltatás (Amazon S3) CSV formátumban, és töltse be a SageMaker Feature Store-ba. A SageMaker Feature Store egy erre a célra kialakított adattár, amely megkönnyíti a csapatok számára az ML-funkciók létrehozását, megosztását és kezelését. Leegyszerűsíti a funkciók felfedezését, újrafelhasználását és megosztását, ami gyorsabb fejlesztést, fokozott együttműködést tesz lehetővé az ügyfélcsapatokon belül, és csökkenti a költségeket.

A funkciók funkciótárba való betöltése a következő lépéseket tartalmazza:

1. Határozzon meg egy jellemzőcsoportot, és hozza létre a szolgáltatáscsoportot a szolgáltatástárban.
2. Készítse elő a forrásadatokat a szolgáltatástárolóhoz úgy, hogy minden adatsorhoz adjon hozzá eseményidőt és rekordazonosítót.
3. Foglalja be az előkészített adatokat a funkciócsoportba a Boto3 SDK használatával.

Ebben a részben csak a 3. lépést emeljük ki, mert ez az a rész, amely a feldolgozási feladat párhuzamos feldolgozását foglalja magában a Ray segítségével. A folyamat teljes kódját itt tekintheti meg GitHub repo.

A ingest_features nevű osztályon belül van definiálva a metódus Featurestore. Vegye figyelembe, hogy a Featurestore osztályt díszítik @ray.remote. Ez azt jelzi, hogy ennek az osztálynak egy példánya egy Ray-aktor, egy állapottartó és párhuzamos számítási egység a Ray-n belül. Ez egy programozási modell, amely lehetővé teszi olyan elosztott objektumok létrehozását, amelyek belső állapotot tartanak fenn, és egyidejűleg elérhetők több feladat által, amelyek egy Ray-fürt különböző csomópontjain futnak. A szereplők módot biztosítanak a változékony állapot kezelésére és beágyazására, így értékesek lehetnek összetett, állapotalapú alkalmazások elosztott környezetben történő létrehozásához. A szereplőknél is megadhat erőforrásigényeket. Ebben az esetben a FeatureStore osztály 0.5 CPU-t igényel. Lásd a következő kódot:

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

A színésszel kapcsolatba léphet, ha felhívja a remote operátor. A következő kódban a kívánt számú szereplő bemeneti argumentumként kerül átadásra a szkriptbe. Az adatokat ezután a szereplők száma alapján particionálják, és továbbítják a távoli párhuzamos folyamatoknak, hogy bekerüljenek a szolgáltatástárolóba. Hívhatsz get a ref objektumon, hogy blokkolja az aktuális feladat végrehajtását, amíg a távoli számítás be nem fejeződik és az eredmény elérhető lesz. Amikor az eredmény elérhető, ray.get visszaadja az eredményt, és az aktuális feladat végrehajtása folytatódik.

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)

Adatok előkészítése oktatáshoz, érvényesítéshez és teszteléshez

Ebben a lépésben a Ray Dataset segítségével hatékonyan felosztjuk, átalakítjuk és méretezzük adatkészletünket a gépi tanulásra való felkészülés érdekében. A Ray Dataset szabványos módot biztosít az elosztott adatok Ray-be való betöltésére, támogatva a különféle tárolórendszereket és fájlformátumokat. API-kkal rendelkezik az általános ML adat-előfeldolgozási műveletekhez, mint például a párhuzamos átalakításokhoz, keveréshez, csoportosításhoz és összesítéshez. A Ray Dataset olyan műveleteket is kezel, amelyek állapotalapú beállítást és GPU-gyorsítást igényelnek. Zökkenőmentesen integrálható más adatfeldolgozó könyvtárakkal, mint például a Spark, Pandas, NumPy és még sok más, valamint olyan ML keretrendszerekkel, mint a TensorFlow és a PyTorch. Ez lehetővé teszi a végpontok közötti adatfolyamok és ML munkafolyamatok felépítését a Ray tetején. A cél az elosztott adatfeldolgozás és az ML megkönnyítése a gyakorlati szakemberek és kutatók számára.

Nézzük meg a szkriptek azon részeit, amelyek ezt az adat-előfeldolgozást végzik. Kezdjük azzal, hogy betöltjük az adatokat a szolgáltatástárolóból:

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

Ezután felosztjuk és skálázzuk az adatokat a következőből elérhető magasabb szintű absztrakciók segítségével ray.data könyvtár:

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

A feldolgozott vonat-, érvényesítési és tesztadatkészleteket az Amazon S3 tárolja, és a következő lépések bemeneti paramétereiként továbbítják.

Végezzen modelltanítást és hiperparaméter-optimalizálást

Mivel adataink előfeldolgozva és modellezésre készen állnak, ideje betanítani néhány ML modellt, és finomhangolni hiperparamétereiket a prediktív teljesítmény maximalizálása érdekében. Használjuk XGBoost-Ray, az XGBoost Ray-re épülő elosztott háttérprogramja, amely lehetővé teszi az XGBoost modellek betanítását nagy adatkészleteken több csomópont és GPU használatával. Egyszerűen beugró cseréket biztosít az XGBoost vonathoz és előrejelzi az API-kat, miközben kezeli az elosztott adatkezelés és képzés bonyolultságát.

A képzés több csomóponton való elosztásának lehetővé tétele érdekében egy segítő osztályt használunk RayHelper. Amint az a következő kódban látható, a betanítási feladat erőforrás-konfigurációját használjuk, és főcsomópontként az első gazdagépet választjuk:

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

A gazdagép információ alapján eldönthetjük, hogyan inicializáljuk a Rayt az egyes képzési feladatokon:

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)

Amikor egy betanítási feladat elindul, egy Ray-fürt inicializálható a következő hívásával start_ray() módszer egy példányán RayHelper:

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

Ezután az XGBoost-Ray XGBoost trénerét használjuk az edzéshez:

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)

Vegye figyelembe, hogy a példányosítás során a trainer, átmegyünk RayParams, amely a szereplők számát és a CPU-k számát veszi fel szereplőnként. Az XGBoost-Ray ezeket az információkat használja fel a képzés elosztására a Ray-fürthöz kapcsolódó összes csomópont között.

Most létrehozunk egy XGBoost becslő objektumot a SageMaker Python SDK alapján, és ezt használjuk a HPO-feladathoz.

Végezze el az előző lépéseket a SageMaker Pipelines segítségével

Egy végpontokig méretezhető és újrafelhasználható ML-munkafolyamat felépítéséhez egy CI/CD eszközt kell használnunk az előző lépések folyamatba rendezése érdekében. A SageMaker Pipelines közvetlenül integrálható a SageMakerrel, a SageMaker Python SDK-val és a SageMaker Studio-val. Ez az integráció lehetővé teszi ML munkafolyamatok létrehozását egy könnyen használható Python SDK segítségével, majd a munkafolyamatok megjelenítését és kezelését a SageMaker Studio segítségével. Ezenkívül nyomon követheti az adatok előzményeit a folyamat végrehajtásán belül, és kijelölheti a gyorsítótárazás lépéseit.

A SageMaker Pipelines létrehoz egy irányított aciklikus grafikont (DAG), amely tartalmazza az ML munkafolyamat felépítéséhez szükséges lépéseket. Minden egyes folyamat egymáshoz kapcsolódó lépések sorozata, amelyeket a lépések közötti adatfüggőségek rendeznek, és paraméterezhetők, lehetővé téve, hogy bemeneti változókat adjon meg paraméterként a folyamat minden egyes futtatásához. A SageMaker Pipelines négyféle folyamatparaméterrel rendelkezik: ParameterString, ParameterInteger, ParameterFloatés ParameterBoolean. Ebben a részben paraméterezünk néhány bemeneti változót, és beállítjuk a lépéses gyorsítótárazási konfigurációt:

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

Két feldolgozási lépést határozunk meg: az egyik a SageMaker Feature Store feldolgozáshoz, a másik az adatok előkészítéséhez. Ennek nagyon hasonlónak kell lennie a korábban leírt lépésekhez. Az egyetlen új kódsor a ProcessingStep a lépések definíciója után, amely lehetővé teszi a feldolgozási feladat konfigurációjának felvételét és folyamatlépésként való felvételét. Tovább meghatározzuk az adat-előkészítési lépés függőségét a SageMaker Feature Store feldolgozási lépéstől. Lásd a következő kódot:

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

Hasonlóképpen, egy modell képzési és hangolási lépés felépítéséhez hozzá kell adnunk egy definíciót TuningStep a modell betanítási lépésének kódja után, amely lehetővé teszi számunkra a SageMaker hiperparaméter-hangolás futtatását folyamatban lévő lépésként:

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

A hangolási lépés után úgy döntünk, hogy a legjobb modellt regisztráljuk a SageMaker Model Registry-be. A modell minőségének szabályozásához minimális minőségi kaput alkalmazunk, amely összehasonlítja a legjobb modell objektív mérőszámát (RMSE) a folyamat bemeneti paramétereként meghatározott küszöbértékkel. rmse_threshold. Az értékelés elvégzéséhez létrehozunk egy másik feldolgozási lépést egy értékelő szkript. A modell kiértékelési eredménye tulajdonságfájlként kerül tárolásra. A tulajdonságfájlok különösen hasznosak egy feldolgozási lépés eredményeinek elemzésekor, hogy eldöntsék, hogyan kell más lépéseket futtatni. Lásd a következő kódot:

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

Meghatározzuk a ModelStep hogy regisztráljuk a legjobb modellt a folyamatban lévő SageMaker Model Registry-be. Abban az esetben, ha a legjobb modell nem megy át az előre meghatározott minőségellenőrzésünkön, ezen felül megadjuk a FailStep hibaüzenet kiadásához:

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

Ezután használjuk a ConditionStep annak értékelésére, hogy a modellregisztrációs lépést vagy a meghibásodási lépést kell-e a következő lépés megtenni a folyamatban. Esetünkben a legjobb modellt akkor regisztráljuk, ha az RMSE pontszáma alacsonyabb, mint a küszöbérték.

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

Végül az összes meghatározott lépést egy folyamatba rendezzük:

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)

Az előző folyamat megjeleníthető és végrehajtható közvetlenül a SageMaker Studio-ban, vagy végrehajtható a execution = training_pipeline.start(). A következő ábra a csővezeték áramlását mutatja be.

Ezenkívül áttekinthetjük a folyamatvégrehajtás által generált műtermékek vonalát.

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)

Telepítse a modellt

Miután a legjobb modellt regisztrálták a SageMaker Model Registry-ben egy folyamatfuttatáson keresztül, a SageMaker teljes körűen felügyelt modelltelepítési képességeinek használatával a modellt egy valós idejű végpontra telepítjük. A SageMaker más modelltelepítési lehetőségeket is kínál a különböző használati esetek igényeinek kielégítésére. A részletekért lásd Telepítsen modelleket a következtetéshez amikor kiválasztja az Ön használati esetének megfelelő opciót. Először is regisztráljuk a modellt a SageMaker Model Registry-ben:

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

A modell jelenlegi állapota PendingApproval. Állapotát be kell állítanunk Approved telepítés előtt:

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
)

Tisztítsuk meg

Miután befejezte a kísérletezést, ne felejtse el megtisztítani az erőforrásokat a felesleges költségek elkerülése érdekében. A tisztításhoz törölje a valós idejű végpontot, modellcsoportot, folyamatot és szolgáltatáscsoportot az API-k hívásával Végpont törlése, DeleteModelPackageGroup, DeletePipelineés DeleteFeatureGroup, és állítsa le az összes SageMaker Studio notebook példányt.

Következtetés

Ez a bejegyzés lépésről lépésre bemutatja, hogyan lehet SageMaker Pipelines-t használni a Ray-alapú ML munkafolyamatok összehangolására. Azt is bemutattuk, hogy a SageMaker Pipelines képes integrálódni harmadik féltől származó ML-eszközökkel. Különféle AWS-szolgáltatások támogatják a Ray-munkaterheléseket méretezhető és biztonságos módon, hogy biztosítsák a kiváló teljesítményt és a működési hatékonyságot. Most Önön a sor, hogy felfedezze ezeket a hatékony képességeket, és elkezdje optimalizálni gépi tanulási munkafolyamatait az Amazon SageMaker Pipelines és Ray segítségével. Cselekedjen még ma, és aknázza ki ML projektjei teljes potenciálját!

---

A szerzőről

Raju Rangan az Amazon Web Services (AWS) vezető megoldástervezője. Együttműködik a kormány által támogatott szervezetekkel, és segít nekik AI/ML megoldások kidolgozásában az AWS használatával. Ha nem trükközik a felhőmegoldásokkal, elkaphatja őt, amint a családjával lóg, vagy egy élénk tollaslabda-játékban üti össze a madarakat a barátaival.

Sherry Ding az Amazon Web Services (AWS) vezető AI/ML-specialista megoldások építésze. Számítástechnikai PhD fokozattal rendelkezik a gépi tanulás területén. Főleg a közszférában dolgozó ügyfelekkel dolgozik különféle mesterséges intelligenciával/ML-vel kapcsolatos üzleti kihívásokon, segítve őket az AWS felhőben való gépi tanulási útjuk felgyorsításában. Amikor nem segít az ügyfeleknek, szereti a szabadtéri tevékenységeket.

• SEO által támogatott tartalom és PR terjesztés. Erősödjön még ma.
• PlatoData.Network Vertical Generative Ai. Erősítse meg magát. Hozzáférés itt.
• PlatoAiStream. Web3 Intelligence. Felerősített tudás. Hozzáférés itt.
• PlatoESG. Carbon, CleanTech, Energia, Környezet, Nap, Hulladékgazdálkodás. Hozzáférés itt.
• PlatoHealth. Biotechnológiai és klinikai vizsgálatok intelligencia. Hozzáférés itt.
• BlockOffsets. A környezetvédelmi ellentételezési tulajdon korszerűsítése. Hozzáférés itt.
• Forrás: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/