Atur alur kerja pembelajaran mesin berbasis Ray menggunakan Amazon SageMaker | Layanan Web Amazon

Pembelajaran mesin (ML) menjadi semakin kompleks seiring pelanggan mencoba memecahkan masalah yang semakin menantang. Kompleksitas ini sering kali mengarah pada kebutuhan akan ML terdistribusi, yang mana beberapa mesin digunakan untuk melatih satu model. Meskipun hal ini memungkinkan paralelisasi tugas di beberapa node, sehingga mempercepat waktu pelatihan, meningkatkan skalabilitas, dan meningkatkan kinerja, terdapat tantangan yang signifikan dalam menggunakan perangkat keras terdistribusi secara efektif. Ilmuwan data harus mengatasi tantangan seperti partisi data, penyeimbangan beban, toleransi kesalahan, dan skalabilitas. Insinyur ML harus menangani paralelisasi, penjadwalan, kesalahan, dan percobaan ulang secara manual, sehingga memerlukan kode infrastruktur yang kompleks.

Pada postingan kali ini kita akan membahas manfaat penggunaan sinar dan Amazon SageMaker untuk ML terdistribusi, dan berikan panduan langkah demi langkah tentang cara menggunakan kerangka kerja ini untuk membangun dan menerapkan alur kerja ML yang skalabel.

Ray, kerangka kerja komputasi terdistribusi sumber terbuka, menyediakan kerangka kerja fleksibel untuk pelatihan terdistribusi dan penyajian model ML. Ini mengabstraksi detail sistem terdistribusi tingkat rendah melalui pustaka sederhana dan skalabel untuk tugas-tugas ML umum seperti pemrosesan awal data, pelatihan terdistribusi, penyetelan hyperparameter, pembelajaran penguatan, dan penyajian model.

SageMaker adalah layanan yang terkelola sepenuhnya untuk membangun, melatih, dan menerapkan model ML. Ray berintegrasi secara mulus dengan fitur SageMaker untuk membangun dan menerapkan beban kerja ML kompleks yang efisien dan andal. Kombinasi Ray dan SageMaker memberikan kemampuan menyeluruh untuk alur kerja ML yang dapat diskalakan, dan memiliki fitur-fitur unggulan berikut:

• Aktor terdistribusi dan konstruksi paralelisme di Ray menyederhanakan pengembangan aplikasi terdistribusi.
• Ray AI Runtime (AIR) mengurangi hambatan dalam peralihan dari pengembangan ke produksi. Dengan Ray dan AIR, kode Python yang sama dapat diskalakan secara mulus dari laptop ke cluster besar.
• Infrastruktur terkelola SageMaker dan fitur seperti tugas pemrosesan, tugas pelatihan, dan tugas penyetelan hyperparameter dapat menggunakan pustaka Ray di bawahnya untuk komputasi terdistribusi.
• Eksperimen Amazon SageMaker memungkinkan iterasi dengan cepat dan melacak uji coba.
• Toko Fitur Amazon SageMaker menyediakan repositori yang dapat diskalakan untuk menyimpan, mengambil, dan berbagi fitur ML untuk pelatihan model.
• Model terlatih dapat disimpan, dibuat versinya, dan dilacak Registri Model Amazon SageMaker untuk tata kelola dan manajemen.

• Pipa Amazon SageMaker memungkinkan pengorganisasian siklus hidup ML end-to-end mulai dari persiapan dan pelatihan data hingga penerapan model sebagai alur kerja otomatis.

Ikhtisar solusi

Posting ini berfokus pada manfaat menggunakan Ray dan SageMaker secara bersamaan. Kami menyiapkan alur kerja ML berbasis Ray end-to-end, yang diatur menggunakan SageMaker Pipelines. Alur kerjanya mencakup penyerapan data secara paralel ke dalam penyimpanan fitur menggunakan aktor Ray, pemrosesan awal data dengan Ray Data, model pelatihan dan penyetelan hyperparameter dalam skala besar menggunakan pekerjaan penyetelan Ray Train dan pengoptimalan hyperparameter (HPO), dan terakhir evaluasi model dan mendaftarkan model ke dalam a registri model.

Untuk data kami, kami menggunakan kumpulan data perumahan sintetis yang terdiri dari delapan fitur (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCH, dan DECK) dan model kami akan memprediksi PRICE rumah.

Setiap tahapan dalam alur kerja ML dipecah menjadi langkah-langkah terpisah, dengan skripnya sendiri yang mengambil parameter masukan dan keluaran. Di bagian selanjutnya, kami menyorot cuplikan kode kunci dari setiap langkah. Kode lengkap dapat ditemukan di repositori GitHub aws-samples-for-ray.

Prasyarat

Untuk menggunakan SageMaker Python SDK dan menjalankan kode yang terkait dengan postingan ini, Anda memerlukan prasyarat berikut:

Menyerap data ke SageMaker Feature Store

Langkah pertama dalam alur kerja ML adalah membaca file data sumber Layanan Penyimpanan Sederhana Amazon (Amazon S3) dalam format CSV dan memasukkannya ke SageMaker Feature Store. SageMaker Feature Store adalah repositori yang dibuat khusus untuk memudahkan tim membuat, berbagi, dan mengelola fitur ML. Ini menyederhanakan penemuan, penggunaan kembali, dan berbagi fitur, sehingga menghasilkan pengembangan yang lebih cepat, peningkatan kolaborasi dalam tim pelanggan, dan pengurangan biaya.

Menyerap fitur ke dalam penyimpanan fitur berisi langkah-langkah berikut:

1. Tentukan grup fitur dan buat grup fitur di penyimpanan fitur.
2. Siapkan data sumber untuk penyimpanan fitur dengan menambahkan waktu peristiwa dan ID rekaman untuk setiap baris data.
3. Serap data yang telah disiapkan ke dalam grup fitur dengan menggunakan Boto3 SDK.

Di bagian ini, kami hanya menyoroti Langkah 3, karena ini adalah bagian yang melibatkan pemrosesan paralel tugas penyerapan menggunakan Ray. Anda dapat meninjau kode lengkap untuk proses ini di GitHub repo.

Grafik fitur_telan metode didefinisikan di dalam kelas yang disebut Featurestore. Perhatikan bahwa Featurestore kelas dihiasi dengan @ray.remote. Hal ini menunjukkan bahwa turunan dari kelas ini adalah aktor Ray, unit komputasi stateful dan konkuren dalam Ray. Ini adalah model pemrograman yang memungkinkan Anda membuat objek terdistribusi yang mempertahankan keadaan internal dan dapat diakses secara bersamaan oleh banyak tugas yang berjalan pada node berbeda dalam cluster Ray. Aktor menyediakan cara untuk mengelola dan merangkum keadaan yang bisa berubah, menjadikannya berguna untuk membangun aplikasi yang kompleks dan berstatus dalam lingkungan terdistribusi. Anda juga dapat menentukan persyaratan sumber daya di aktor. Dalam hal ini, setiap contoh dari FeatureStore kelas akan membutuhkan 0.5 CPU. Lihat kode berikut:

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

Anda dapat berinteraksi dengan aktor dengan menelepon remote operator. Dalam kode berikut, jumlah aktor yang diinginkan diteruskan sebagai argumen masukan ke skrip. Data kemudian dipartisi berdasarkan jumlah aktor dan diteruskan ke proses paralel jarak jauh untuk dimasukkan ke dalam penyimpanan fitur. Anda bisa menelepon get pada objek ref untuk memblokir eksekusi tugas saat ini hingga komputasi jarak jauh selesai dan hasilnya tersedia. Ketika hasilnya tersedia, ray.get akan mengembalikan hasilnya, dan pelaksanaan tugas saat ini akan dilanjutkan.

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)

Mempersiapkan data untuk pelatihan, validasi, dan pengujian

Pada langkah ini, kami menggunakan Ray Dataset untuk membagi, mentransformasikan, dan menskalakan kumpulan data kami secara efisien sebagai persiapan untuk pembelajaran mesin. Ray Dataset menyediakan cara standar untuk memuat data terdistribusi ke Ray, mendukung berbagai sistem penyimpanan dan format file. Ia memiliki API untuk operasi prapemrosesan data ML umum seperti transformasi paralel, pengacakan, pengelompokan, dan agregasi. Ray Dataset juga menangani operasi yang memerlukan pengaturan stateful dan akselerasi GPU. Ini terintegrasi dengan lancar dengan perpustakaan pemrosesan data lainnya seperti Spark, Pandas, NumPy, dan banyak lagi, serta kerangka kerja ML seperti TensorFlow dan PyTorch. Hal ini memungkinkan pembuatan pipeline data end-to-end dan alur kerja ML di atas Ray. Tujuannya adalah untuk mempermudah pemrosesan data terdistribusi dan ML bagi praktisi dan peneliti.

Mari kita lihat bagian skrip yang melakukan prapemrosesan data ini. Kami mulai dengan memuat data dari penyimpanan fitur:

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

Kami kemudian membagi dan menskalakan data menggunakan abstraksi tingkat tinggi yang tersedia dari ray.data Perpustakaan:

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

Set data pelatihan, validasi, dan pengujian yang diproses disimpan di Amazon S3 dan akan diteruskan sebagai parameter input ke langkah berikutnya.

Lakukan pelatihan model dan pengoptimalan hyperparameter

Setelah data kami diproses sebelumnya dan siap untuk dimodelkan, inilah saatnya untuk melatih beberapa model ML dan menyempurnakan hyperparameternya untuk memaksimalkan performa prediktif. Kita gunakan XGBoost-Ray, backend terdistribusi untuk XGBoost yang dibangun di atas Ray yang memungkinkan pelatihan model XGBoost pada kumpulan data besar dengan menggunakan banyak node dan GPU. Ini memberikan penggantian drop-in sederhana untuk API pelatihan dan prediksi XGBoost sambil menangani kompleksitas manajemen data terdistribusi dan pelatihan di balik terpal.

Untuk mengaktifkan distribusi pelatihan ke beberapa node, kami menggunakan kelas pembantu bernama Pembantu Sinar. Seperti yang ditunjukkan dalam kode berikut, kami menggunakan konfigurasi sumber daya dari tugas pelatihan dan memilih host pertama sebagai node kepala:

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

Kita dapat menggunakan informasi host untuk memutuskan bagaimana menginisialisasi Ray pada setiap contoh pekerjaan pelatihan:

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)

Ketika tugas pelatihan dimulai, cluster Ray dapat diinisialisasi dengan memanggil start_ray() metode pada contoh RayHelper:

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

Kami kemudian menggunakan pelatih XGBoost dari XGBoost-Ray untuk pelatihan:

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)

Perhatikan bahwa saat membuat instance trainer, kami lulus RayParams, yang mengambil jumlah aktor dan jumlah CPU per aktor. XGBoost-Ray menggunakan informasi ini untuk mendistribusikan pelatihan ke seluruh node yang terpasang pada cluster Ray.

Kami sekarang membuat objek estimator XGBoost berdasarkan SageMaker Python SDK dan menggunakannya untuk pekerjaan HPO.

Atur langkah-langkah sebelumnya menggunakan SageMaker Pipelines

Untuk membangun alur kerja ML yang skalabel dan dapat digunakan kembali secara menyeluruh, kita perlu menggunakan alat CI/CD untuk mengatur langkah-langkah sebelumnya ke dalam pipeline. SageMaker Pipelines memiliki integrasi langsung dengan SageMaker, SageMaker Python SDK, dan SageMaker Studio. Integrasi ini memungkinkan Anda membuat alur kerja ML dengan Python SDK yang mudah digunakan, lalu memvisualisasikan dan mengelola alur kerja Anda menggunakan SageMaker Studio. Anda juga dapat melacak riwayat data Anda dalam eksekusi alur dan menentukan langkah-langkah untuk penyimpanan dalam cache.

SageMaker Pipelines membuat Directed Acyclic Graph (DAG) yang mencakup langkah-langkah yang diperlukan untuk membangun alur kerja ML. Setiap alur adalah serangkaian langkah yang saling berhubungan dan diatur berdasarkan ketergantungan data antar langkah, dan dapat diparameterisasi, sehingga Anda dapat menyediakan variabel masukan sebagai parameter untuk setiap proses alur. SageMaker Pipelines memiliki empat jenis parameter pipa: ParameterString, ParameterInteger, ParameterFloat, dan ParameterBoolean. Di bagian ini, kami membuat parameter beberapa variabel masukan dan menyiapkan konfigurasi langkah caching:

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

Kami mendefinisikan dua langkah pemrosesan: satu untuk penyerapan Penyimpanan Fitur SageMaker, yang lainnya untuk persiapan data. Ini akan terlihat sangat mirip dengan langkah sebelumnya yang dijelaskan sebelumnya. Satu-satunya baris kode baru adalah ProcessingStep setelah definisi langkah-langkahnya, yang memungkinkan kita mengambil konfigurasi tugas pemrosesan dan memasukkannya sebagai langkah pipeline. Kami selanjutnya menentukan ketergantungan langkah persiapan data pada langkah penyerapan SageMaker Feature Store. Lihat kode berikut:

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

Demikian pula, untuk membangun langkah pelatihan dan penyetelan model, kita perlu menambahkan definisi TuningStep setelah kode langkah pelatihan model untuk memungkinkan kita menjalankan penyetelan hyperparameter SageMaker sebagai langkah dalam pipeline:

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

Setelah langkah penyetelan, kami memilih untuk mendaftarkan model terbaik ke SageMaker Model Registry. Untuk mengontrol kualitas model, kami menerapkan gerbang kualitas minimum yang membandingkan metrik objektif model terbaik (RMSE) dengan ambang batas yang ditentukan sebagai parameter masukan saluran. rmse_threshold. Untuk melakukan evaluasi ini, kami membuat langkah pemrosesan lain untuk menjalankan naskah evaluasi. Hasil evaluasi model akan disimpan sebagai file properti. File properti sangat berguna ketika menganalisis hasil suatu langkah pemrosesan untuk memutuskan bagaimana langkah-langkah lain harus dijalankan. Lihat kode berikut:

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

Kami mendefinisikan a ModelStep untuk mendaftarkan model terbaik ke SageMaker Model Registry di saluran kami. Jika model terbaik tidak lolos pemeriksaan kualitas yang telah ditentukan, kami juga menentukan a FailStep untuk menampilkan pesan kesalahan:

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

Selanjutnya kita menggunakan a ConditionStep untuk mengevaluasi apakah langkah pendaftaran model atau langkah kegagalan harus diambil selanjutnya. Dalam kasus kami, model terbaik akan didaftarkan jika skor RMSE-nya lebih rendah dari ambang batas.

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

Terakhir, kami mengatur semua langkah yang ditentukan ke dalam pipeline:

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)

Alur sebelumnya dapat divisualisasikan dan dijalankan langsung di SageMaker Studio, atau dijalankan dengan panggilan execution = training_pipeline.start(). Gambar berikut menggambarkan aliran pipa.

Selain itu, kami dapat meninjau silsilah artefak yang dihasilkan oleh eksekusi alur.

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)

Menyebarkan model

Setelah model terbaik didaftarkan di SageMaker Model Registry melalui proses pipeline, kami menerapkan model tersebut ke titik akhir real-time dengan menggunakan kemampuan penerapan model SageMaker yang terkelola sepenuhnya. SageMaker memiliki opsi penerapan model lain untuk memenuhi kebutuhan berbagai kasus penggunaan. Untuk detailnya, lihat Terapkan model untuk inferensi saat memilih opsi yang tepat untuk kasus penggunaan Anda. Pertama, mari kita daftarkan modelnya di SageMaker Model Registry:

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

Status model saat ini adalah PendingApproval. Kita perlu mengatur statusnya menjadi Approved sebelum penerapan:

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
)

Membersihkan

Setelah Anda selesai bereksperimen, ingatlah untuk membersihkan sumber daya untuk menghindari biaya yang tidak perlu. Untuk membersihkan, hapus titik akhir real-time, grup model, alur, dan grup fitur dengan memanggil API Hapus Titik Akhir, HapusModelPackageGroup, HapusPipeline, dan HapusFeatureGroup, masing-masing, dan mematikan semua instans notebook SageMaker Studio.

Kesimpulan

Postingan ini menunjukkan panduan langkah demi langkah tentang cara menggunakan SageMaker Pipelines untuk mengatur alur kerja ML berbasis Ray. Kami juga mendemonstrasikan kemampuan SageMaker Pipelines untuk berintegrasi dengan alat ML pihak ketiga. Terdapat berbagai layanan AWS yang mendukung beban kerja Ray dengan cara yang terukur dan aman untuk memastikan keunggulan kinerja dan efisiensi operasional. Sekarang, giliran Anda untuk mengeksplorasi kemampuan canggih ini dan mulai mengoptimalkan alur kerja pembelajaran mesin Anda dengan Amazon SageMaker Pipelines dan Ray. Ambil tindakan hari ini dan wujudkan potensi penuh proyek ML Anda!

---

tentang Penulis

Raju Rangan adalah Arsitek Solusi Senior di Amazon Web Services (AWS). Dia bekerja dengan entitas yang disponsori pemerintah, membantu mereka membangun solusi AI/ML menggunakan AWS. Saat tidak bermain-main dengan solusi cloud, Anda akan melihatnya sedang berkumpul dengan keluarga atau memecahkan birdie dalam permainan bulutangkis yang meriah bersama teman-temannya.

Sherly Ding adalah arsitek solusi spesialis AI/ML senior di Amazon Web Services (AWS). Dia memiliki pengalaman luas dalam pembelajaran mesin dengan gelar PhD di bidang ilmu komputer. Dia terutama bekerja dengan pelanggan sektor publik dalam berbagai tantangan bisnis terkait AI/ML, membantu mereka mempercepat perjalanan pembelajaran mesin mereka di AWS Cloud. Saat tidak membantu pelanggan, dia menikmati aktivitas di luar ruangan.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• PlatoHealth. Kecerdasan Uji Coba Biotek dan Klinis. Akses Di Sini.
• BlockOffset. Modernisasi Kepemilikan Offset Lingkungan. Akses Di Sini.
• Sumber: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/