Điều phối các quy trình học máy dựa trên Ray bằng Amazon SageMaker | Dịch vụ web của Amazon

Học máy (ML) ngày càng trở nên phức tạp khi khách hàng cố gắng giải quyết ngày càng nhiều vấn đề khó khăn hơn. Sự phức tạp này thường dẫn đến nhu cầu về ML phân tán, trong đó nhiều máy được sử dụng để huấn luyện một mô hình duy nhất. Mặc dù điều này cho phép song song hóa các tác vụ trên nhiều nút, dẫn đến thời gian đào tạo được tăng tốc, khả năng mở rộng nâng cao và hiệu suất được cải thiện, nhưng vẫn có những thách thức đáng kể trong việc sử dụng hiệu quả phần cứng phân tán. Các nhà khoa học dữ liệu phải giải quyết các thách thức như phân vùng dữ liệu, cân bằng tải, khả năng chịu lỗi và khả năng mở rộng. Các kỹ sư ML phải xử lý việc song song hóa, lập lịch, lỗi và thử lại theo cách thủ công, đòi hỏi mã cơ sở hạ tầng phức tạp.

Trong bài đăng này, chúng tôi thảo luận về lợi ích của việc sử dụng cá đuối và Amazon SageMaker dành cho ML phân tán và cung cấp hướng dẫn từng bước về cách sử dụng các khung này để xây dựng và triển khai quy trình làm việc ML có thể mở rộng.

Ray, một khung điện toán phân tán nguồn mở, cung cấp một khung linh hoạt để đào tạo và phục vụ phân tán các mô hình ML. Nó tóm tắt các chi tiết hệ thống phân tán cấp thấp thông qua các thư viện đơn giản, có thể mở rộng cho các tác vụ ML phổ biến như tiền xử lý dữ liệu, đào tạo phân tán, điều chỉnh siêu tham số, học tăng cường và phân phát mô hình.

SageMaker là dịch vụ được quản lý hoàn toàn để xây dựng, đào tạo và triển khai các mô hình ML. Ray tích hợp liền mạch với các tính năng của SageMaker để xây dựng và triển khai khối lượng công việc ML phức tạp vừa hiệu quả vừa đáng tin cậy. Sự kết hợp giữa Ray và SageMaker cung cấp khả năng toàn diện cho quy trình công việc ML có thể mở rộng và có các tính năng nổi bật sau:

• Các tác nhân phân tán và cấu trúc song song trong Ray đơn giản hóa việc phát triển các ứng dụng phân tán.
• Ray AI Runtime (AIR) làm giảm trở ngại trong quá trình chuyển từ giai đoạn phát triển sang sản xuất. Với Ray và AIR, cùng một mã Python có thể mở rộng quy mô một cách liền mạch từ máy tính xách tay đến một cụm lớn.
• Cơ sở hạ tầng được quản lý của SageMaker và các tính năng như xử lý công việc, công việc đào tạo và công việc điều chỉnh siêu tham số có thể sử dụng các thư viện Ray bên dưới cho điện toán phân tán.
• Thử nghiệm Amazon SageMaker cho phép lặp lại nhanh chóng và theo dõi các thử nghiệm.
• Cửa hàng tính năng Amazon SageMaker cung cấp một kho lưu trữ có thể mở rộng để lưu trữ, truy xuất và chia sẻ các tính năng ML cho việc đào tạo mô hình.
• Các mô hình đã đào tạo có thể được lưu trữ, tạo phiên bản và theo dõi trong Cơ quan đăng ký mô hình Amazon SageMaker cho việc quản lý và điều hành.

• Đường ống Amazon SageMaker cho phép điều phối vòng đời ML từ đầu đến cuối từ chuẩn bị và đào tạo dữ liệu đến triển khai mô hình dưới dạng quy trình làm việc tự động.

Tổng quan về giải pháp

Bài đăng này tập trung vào những lợi ích của việc sử dụng Ray và SageMaker cùng nhau. Chúng tôi thiết lập quy trình làm việc ML dựa trên Ray từ đầu đến cuối, được điều phối bằng SageMaker Pipelines. Quy trình công việc bao gồm việc nhập dữ liệu song song vào kho tính năng bằng cách sử dụng các tác nhân Ray, xử lý trước dữ liệu bằng Ray Data, đào tạo mô hình và điều chỉnh siêu tham số trên quy mô lớn bằng cách sử dụng Ray Train và các công việc điều chỉnh tối ưu hóa siêu tham số (HPO), cuối cùng là đánh giá mô hình và đăng ký mô hình vào một sổ đăng ký mô hình.

Đối với dữ liệu của chúng tôi, chúng tôi sử dụng một tập dữ liệu nhà ở tổng hợp bao gồm tám tính năng (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCHvà DECK) và mô hình của chúng tôi sẽ dự đoán PRICE của căn nhà.

Mỗi giai đoạn trong quy trình làm việc ML được chia thành các bước riêng biệt, có tập lệnh riêng lấy các tham số đầu vào và đầu ra. Trong phần tiếp theo, chúng tôi đánh dấu các đoạn mã chính từ mỗi bước. Mã đầy đủ có thể được tìm thấy trên kho lưu trữ GitHub aws-samples-for-ray.

Điều kiện tiên quyết

Để sử dụng SageMaker Python SDK và chạy mã được liên kết với bài đăng này, bạn cần có các điều kiện tiên quyết sau:

Nhập dữ liệu vào Cửa hàng tính năng SageMaker

Bước đầu tiên trong quy trình ML là đọc tệp dữ liệu nguồn từ Dịch vụ lưu trữ đơn giản của Amazon (Amazon S3) ở định dạng CSV và nhập vào Cửa hàng tính năng SageMaker. Cửa hàng tính năng SageMaker là kho lưu trữ được xây dựng có mục đích giúp các nhóm dễ dàng tạo, chia sẻ và quản lý các tính năng ML. Nó đơn giản hóa việc khám phá, tái sử dụng và chia sẻ tính năng, dẫn đến phát triển nhanh hơn, tăng cường hợp tác trong các nhóm khách hàng và giảm chi phí.

Việc nhập các tính năng vào cửa hàng tính năng bao gồm các bước sau:

1. Xác định nhóm tính năng và tạo nhóm tính năng trong kho tính năng.
2. Chuẩn bị dữ liệu nguồn cho kho tính năng bằng cách thêm thời gian sự kiện và ID bản ghi cho mỗi hàng dữ liệu.
3. Nhập dữ liệu đã chuẩn bị vào nhóm tính năng bằng cách sử dụng Boto3 SDK.

Trong phần này, chúng tôi chỉ nêu bật Bước 3, vì đây là phần liên quan đến việc xử lý song song tác vụ nhập bằng Ray. Bạn có thể xem lại mã đầy đủ cho quá trình này trong phần Repo GitHub.

Sản phẩm nhập_features phương thức được định nghĩa bên trong một lớp gọi là Featurestore. Lưu ý rằng Featurestore lớp học được trang trí với @ray.remote. Điều này chỉ ra rằng một thể hiện của lớp này là một tác nhân Ray, một đơn vị tính toán có trạng thái và đồng thời trong Ray. Đó là mô hình lập trình cho phép bạn tạo các đối tượng phân tán duy trì trạng thái bên trong và có thể được truy cập đồng thời bằng nhiều tác vụ chạy trên các nút khác nhau trong cụm Ray. Các tác nhân cung cấp một cách để quản lý và đóng gói trạng thái có thể thay đổi, khiến chúng có giá trị trong việc xây dựng các ứng dụng có trạng thái, phức tạp trong môi trường phân tán. Bạn cũng có thể chỉ định các yêu cầu về tài nguyên trong diễn viên. Trong trường hợp này, mỗi phiên bản của FeatureStore lớp sẽ yêu cầu 0.5 CPU. Xem đoạn mã sau:

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

Bạn có thể tương tác với diễn viên bằng cách gọi remote nhà điều hành. Trong đoạn mã sau, số lượng diễn viên mong muốn được chuyển vào làm đối số đầu vào cho tập lệnh. Sau đó, dữ liệu được phân vùng dựa trên số lượng tác nhân và chuyển đến các quy trình song song từ xa để đưa vào kho tính năng. Bạn có thể gọi get trên đối tượng sẽ chặn việc thực thi tác vụ hiện tại cho đến khi quá trình tính toán từ xa hoàn tất và có kết quả. Khi có kết quả, ray.get sẽ trả về kết quả và việc thực hiện tác vụ hiện tại sẽ tiếp tục.

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)

Chuẩn bị dữ liệu cho đào tạo, xác nhận và kiểm tra

Trong bước này, chúng tôi sử dụng Bộ dữ liệu Ray để phân chia, chuyển đổi và mở rộng quy mô tập dữ liệu của mình một cách hiệu quả nhằm chuẩn bị cho việc học máy. Ray Dataset cung cấp một cách tiêu chuẩn để tải dữ liệu phân tán vào Ray, hỗ trợ các hệ thống lưu trữ và định dạng tệp khác nhau. Nó có các API cho các hoạt động tiền xử lý dữ liệu ML phổ biến như chuyển đổi song song, xáo trộn, nhóm và tổng hợp. Ray Dataset cũng xử lý các hoạt động cần thiết lập trạng thái và tăng tốc GPU. Nó tích hợp trơn tru với các thư viện xử lý dữ liệu khác như Spark, Pandas, NumPy, v.v., cũng như các khung ML như TensorFlow và PyTorch. Điều này cho phép xây dựng các đường dẫn dữ liệu từ đầu đến cuối và quy trình công việc ML trên Ray. Mục tiêu là làm cho việc xử lý dữ liệu phân tán và ML dễ dàng hơn đối với những người thực hành và nhà nghiên cứu.

Hãy xem xét các phần của tập lệnh thực hiện quá trình tiền xử lý dữ liệu này. Chúng tôi bắt đầu bằng cách tải dữ liệu từ cửa hàng tính năng:

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

Sau đó, chúng tôi phân chia và chia tỷ lệ dữ liệu bằng cách sử dụng các khái niệm trừu tượng ở cấp độ cao hơn có sẵn từ ray.data thư viện:

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

Các tập dữ liệu huấn luyện, xác thực và kiểm tra đã xử lý được lưu trữ trong Amazon S3 và sẽ được chuyển dưới dạng tham số đầu vào cho các bước tiếp theo.

Thực hiện đào tạo mô hình và tối ưu hóa siêu tham số

Với dữ liệu của chúng tôi đã được xử lý trước và sẵn sàng để lập mô hình, đã đến lúc đào tạo một số mô hình ML và tinh chỉnh siêu tham số của chúng để tối đa hóa hiệu suất dự đoán. Chúng tôi sử dụng XGBoost-Ray, một chương trình phụ trợ phân tán dành cho XGBoost được xây dựng trên Ray cho phép đào tạo các mô hình XGBoost trên các tập dữ liệu lớn bằng cách sử dụng nhiều nút và GPU. Nó cung cấp các giải pháp thay thế đơn giản cho việc đào tạo và dự đoán API của XGBoost trong khi xử lý sự phức tạp của việc đào tạo và quản lý dữ liệu phân tán một cách chuyên sâu.

Để cho phép phân phối chương trình đào tạo qua nhiều nút, chúng tôi sử dụng lớp trợ giúp có tên RayHelper. Như được hiển thị trong đoạn mã sau, chúng tôi sử dụng cấu hình tài nguyên của công việc đào tạo và chọn máy chủ đầu tiên làm nút chính:

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

Chúng ta có thể sử dụng thông tin máy chủ để quyết định cách khởi tạo Ray trên từng trường hợp công việc đào tạo:

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)

Khi công việc huấn luyện được bắt đầu, cụm Ray có thể được khởi tạo bằng cách gọi phương thức start_ray() phương pháp trên một trường hợp của RayHelper:

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

Sau đó, chúng tôi sử dụng trình huấn luyện XGBoost của XGBoost-Ray để đào tạo:

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)

Lưu ý rằng trong khi khởi tạo trainer, chúng tôi vượt qua RayParams, lấy số lượng tác nhân và số lượng CPU cho mỗi tác nhân. XGBoost-Ray sử dụng thông tin này để phân phối nội dung đào tạo trên tất cả các nút được gắn vào cụm Ray.

Bây giờ chúng tôi tạo đối tượng công cụ ước tính XGBoost dựa trên SDK SageMaker Python và sử dụng đối tượng đó cho công việc HPO.

Sắp xếp các bước trước đó bằng SageMaker Pipelines

Để xây dựng quy trình làm việc ML có thể mở rộng và tái sử dụng từ đầu đến cuối, chúng ta cần sử dụng công cụ CI/CD để sắp xếp các bước trước đó thành một quy trình. SageMaker Pipelines có sự tích hợp trực tiếp với SageMaker, SageMaker Python SDK và SageMaker Studio. Việc tích hợp này cho phép bạn tạo quy trình làm việc ML bằng SDK Python dễ sử dụng, sau đó trực quan hóa và quản lý quy trình làm việc của bạn bằng SageMaker Studio. Bạn cũng có thể theo dõi lịch sử dữ liệu của mình trong quá trình thực thi quy trình và chỉ định các bước để lưu vào bộ đệm.

SageMaker Pipelines tạo Đồ thị không theo chu kỳ có hướng (DAG) bao gồm các bước cần thiết để xây dựng quy trình làm việc ML. Mỗi quy trình là một chuỗi các bước được kết nối với nhau được sắp xếp theo sự phụ thuộc dữ liệu giữa các bước và có thể được tham số hóa, cho phép bạn cung cấp các biến đầu vào làm tham số cho mỗi lần chạy quy trình. SageMaker Pipelines có bốn loại tham số đường ống: ParameterString, ParameterInteger, ParameterFloatvà ParameterBoolean. Trong phần này, chúng tôi tham số hóa một số biến đầu vào và thiết lập cấu hình bộ nhớ đệm từng bước:

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

Chúng tôi xác định hai bước xử lý: một bước để nhập SageMaker Feature Store, bước còn lại là chuẩn bị dữ liệu. Điều này sẽ trông rất giống với các bước trước đó được mô tả trước đó. Dòng mã mới duy nhất là ProcessingStep sau định nghĩa của các bước, điều này cho phép chúng tôi lấy cấu hình công việc xử lý và đưa nó vào làm bước quy trình. Chúng tôi chỉ định thêm sự phụ thuộc của bước chuẩn bị dữ liệu vào bước nhập SageMaker Feature Store. Xem đoạn mã sau:

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

Tương tự, để xây dựng bước huấn luyện và điều chỉnh mô hình, chúng ta cần thêm định nghĩa về TuningStep sau mã của bước đào tạo mô hình để cho phép chúng tôi chạy điều chỉnh siêu tham số SageMaker như một bước trong quy trình:

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

Sau bước điều chỉnh, chúng tôi chọn đăng ký mô hình tốt nhất vào Sổ đăng ký mô hình SageMaker. Để kiểm soát chất lượng mô hình, chúng tôi triển khai cổng chất lượng tối thiểu để so sánh số liệu mục tiêu của mô hình tốt nhất (RMSE) với ngưỡng được xác định là tham số đầu vào của quy trình rmse_threshold. Để thực hiện đánh giá này, chúng tôi tạo một bước xử lý khác để chạy một kịch bản đánh giá. Kết quả đánh giá mô hình sẽ được lưu trữ dưới dạng tệp thuộc tính. Các tệp thuộc tính đặc biệt hữu ích khi phân tích kết quả của một bước xử lý để quyết định cách chạy các bước khác. Xem đoạn mã sau:

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

Chúng tôi xác định một ModelStep để đăng ký mô hình tốt nhất vào Cơ quan đăng ký mô hình SageMaker trong quy trình của chúng tôi. Trong trường hợp mô hình tốt nhất không vượt qua quá trình kiểm tra chất lượng được xác định trước của chúng tôi, chúng tôi cũng chỉ định thêm một FailStep để xuất ra một thông báo lỗi:

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

Tiếp theo, chúng tôi sử dụng một ConditionStep để đánh giá xem nên thực hiện bước đăng ký mô hình hay bước thất bại tiếp theo trong quy trình. Trong trường hợp của chúng tôi, mô hình tốt nhất sẽ được đăng ký nếu điểm RMSE của nó thấp hơn ngưỡng.

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

Cuối cùng, chúng tôi sắp xếp tất cả các bước đã xác định thành một quy trình:

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)

Quy trình trước đó có thể được trực quan hóa và thực thi trực tiếp trong SageMaker Studio hoặc được thực thi bằng cách gọi execution = training_pipeline.start(). Hình dưới đây minh họa dòng chảy đường ống.

Ngoài ra, chúng tôi có thể xem lại dòng sản phẩm được tạo ra trong quá trình thực thi quy trình.

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)

Triển khai mô hình

Sau khi mô hình tốt nhất được đăng ký trong Sổ đăng ký mô hình SageMaker thông qua quá trình chạy quy trình, chúng tôi triển khai mô hình đến điểm cuối thời gian thực bằng cách sử dụng khả năng triển khai mô hình được quản lý hoàn toàn của SageMaker. SageMaker có các tùy chọn triển khai mô hình khác để đáp ứng nhu cầu của các trường hợp sử dụng khác nhau. Để biết chi tiết, hãy tham khảo Triển khai các mô hình để suy luận khi chọn tùy chọn phù hợp cho trường hợp sử dụng của bạn. Trước tiên, hãy đăng ký mô hình trong Sổ đăng ký mô hình SageMaker:

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

Trạng thái hiện tại của mô hình là PendingApproval. Chúng ta cần đặt trạng thái của nó thành Approved trước khi triển khai:

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
)

Làm sạch

Sau khi thử nghiệm xong, hãy nhớ dọn sạch tài nguyên để tránh những khoản phí không cần thiết. Để dọn dẹp, hãy xóa điểm cuối thời gian thực, nhóm mô hình, quy trình và nhóm tính năng bằng cách gọi API XóaĐiểm cuối, XóaModelGóiNhóm, XóaĐường ốngvà XóaNhóm tính năng, tương ứng và tắt tất cả các phiên bản sổ ghi chép SageMaker Studio.

Kết luận

Bài đăng này trình bày hướng dẫn từng bước về cách sử dụng SageMaker Pipelines để điều phối các quy trình công việc ML dựa trên Ray. Chúng tôi cũng đã chứng minh khả năng tích hợp của SageMaker Pipelines với các công cụ ML của bên thứ ba. Có nhiều dịch vụ AWS khác nhau hỗ trợ khối lượng công việc Ray theo cách an toàn và có thể mở rộng để đảm bảo hiệu suất vượt trội và hiệu quả hoạt động. Bây giờ, đến lượt bạn khám phá những khả năng mạnh mẽ này và bắt đầu tối ưu hóa quy trình học máy của bạn với Amazon SageMaker Pipelines và Ray. Hãy hành động ngay hôm nay và khai thác toàn bộ tiềm năng của các dự án ML của bạn!

---

Lưu ý

Raju Rangan là Kiến trúc sư giải pháp cấp cao tại Amazon Web Services (AWS). Anh làm việc với các đơn vị được chính phủ tài trợ, giúp họ xây dựng các giải pháp AI/ML bằng AWS. Khi không mày mò tìm hiểu các giải pháp đám mây, bạn sẽ bắt gặp anh ấy đi chơi cùng gia đình hoặc ghi điểm birdie trong một trận cầu lông sôi động cùng bạn bè.

Sherry Đinh là kiến ​​trúc sư giải pháp chuyên môn AI/ML cấp cao tại Amazon Web Services (AWS). Cô có nhiều kinh nghiệm về học máy với bằng Tiến sĩ về khoa học máy tính. Cô chủ yếu làm việc với các khách hàng thuộc khu vực công về các thách thức kinh doanh khác nhau liên quan đến AI/ML, giúp họ đẩy nhanh hành trình học máy trên Đám mây AWS. Khi không giúp đỡ khách hàng, cô thích tham gia các hoạt động ngoài trời.

• Phân phối nội dung và PR được hỗ trợ bởi SEO. Được khuếch đại ngay hôm nay.
• PlatoData.Network Vertical Generative Ai. Trao quyền cho chính mình. Truy cập Tại đây.
• PlatoAiStream. Thông minh Web3. Kiến thức khuếch đại. Truy cập Tại đây.
• Trung tâmESG. Than đá, công nghệ sạch, Năng lượng, Môi trường Hệ mặt trời, Quản lý chất thải. Truy cập Tại đây.
• PlatoSức khỏe. Tình báo thử nghiệm lâm sàng và công nghệ sinh học. Truy cập Tại đây.
• BlockOffsets. Hiện đại hóa quyền sở hữu bù đắp môi trường. Truy cập Tại đây.
• nguồn: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/