अमेज़ॅन सेजमेकर का उपयोग करके ऑर्केस्ट्रेट रे-आधारित मशीन लर्निंग वर्कफ़्लोज़ | अमेज़न वेब सेवाएँ

मशीन लर्निंग (एमएल) तेजी से जटिल होती जा रही है क्योंकि ग्राहक अधिक से अधिक चुनौतीपूर्ण समस्याओं को हल करने का प्रयास कर रहे हैं। यह जटिलता अक्सर वितरित एमएल की आवश्यकता की ओर ले जाती है, जहां एक मॉडल को प्रशिक्षित करने के लिए कई मशीनों का उपयोग किया जाता है। यद्यपि यह कई नोड्स में कार्यों के समानांतरीकरण को सक्षम बनाता है, जिससे त्वरित प्रशिक्षण समय, बढ़ी हुई स्केलेबिलिटी और बेहतर प्रदर्शन होता है, लेकिन वितरित हार्डवेयर का प्रभावी ढंग से उपयोग करने में महत्वपूर्ण चुनौतियाँ हैं। डेटा वैज्ञानिकों को डेटा विभाजन, लोड संतुलन, दोष सहनशीलता और स्केलेबिलिटी जैसी चुनौतियों का समाधान करना होगा। एमएल इंजीनियरों को समानांतरीकरण, शेड्यूलिंग, दोषों को संभालना होगा और जटिल बुनियादी ढांचे कोड की आवश्यकता के लिए मैन्युअल रूप से पुनः प्रयास करना होगा।

इस पोस्ट में, हम उपयोग के लाभों पर चर्चा करते हैं रे और अमेज़न SageMaker वितरित एमएल के लिए, और स्केलेबल एमएल वर्कफ़्लो को बनाने और तैनात करने के लिए इन फ़्रेमवर्क का उपयोग कैसे करें, इस पर चरण-दर-चरण मार्गदर्शिका प्रदान करें।

रे, एक ओपन-सोर्स वितरित कंप्यूटिंग ढांचा, वितरित प्रशिक्षण और एमएल मॉडल की सेवा के लिए एक लचीला ढांचा प्रदान करता है। यह डेटा प्रीप्रोसेसिंग, वितरित प्रशिक्षण, हाइपरपैरामीटर ट्यूनिंग, सुदृढीकरण सीखने और मॉडल सर्विंग जैसे सामान्य एमएल कार्यों के लिए सरल, स्केलेबल पुस्तकालयों के माध्यम से निम्न-स्तरीय वितरित सिस्टम विवरणों को हटा देता है।

सेजमेकर एमएल मॉडल के निर्माण, प्रशिक्षण और तैनाती के लिए पूरी तरह से प्रबंधित सेवा है। रे जटिल एमएल वर्कलोड को बनाने और तैनात करने के लिए सेजमेकर सुविधाओं के साथ सहजता से एकीकृत होता है जो कुशल और विश्वसनीय दोनों हैं। रे और सेजमेकर का संयोजन स्केलेबल एमएल वर्कफ़्लो के लिए एंड-टू-एंड क्षमताएं प्रदान करता है, और इसमें निम्नलिखित हाइलाइट की गई विशेषताएं हैं:

• रे में वितरित अभिनेता और समांतरता निर्माण वितरित अनुप्रयोगों को विकसित करना सरल बनाते हैं।
• रे एआई रनटाइम (एआईआर) विकास से उत्पादन तक जाने के घर्षण को कम करता है। रे और एआईआर के साथ, एक ही पायथन कोड एक लैपटॉप से ​​​​बड़े क्लस्टर तक निर्बाध रूप से स्केल कर सकता है।
• सेजमेकर का प्रबंधित बुनियादी ढांचा और प्रसंस्करण कार्य, प्रशिक्षण कार्य और हाइपरपैरामीटर ट्यूनिंग कार्य जैसी सुविधाएं वितरित कंप्यूटिंग के लिए नीचे दिए गए रे लाइब्रेरी का उपयोग कर सकती हैं।
• अमेज़न SageMaker प्रयोग तेजी से पुनरावृत्ति करने और परीक्षणों पर नज़र रखने की अनुमति देता है।
• अमेज़न SageMaker फ़ीचर स्टोर मॉडल प्रशिक्षण के लिए एमएल सुविधाओं को संग्रहीत करने, पुनर्प्राप्त करने और साझा करने के लिए एक स्केलेबल रिपॉजिटरी प्रदान करता है।
• प्रशिक्षित मॉडलों को संग्रहीत, संस्करणित और ट्रैक किया जा सकता है अमेज़न सैजमेकर मॉडल रजिस्ट्री शासन और प्रबंधन के लिए.

• अमेज़न SageMaker पाइपलाइन स्वचालित वर्कफ़्लो के रूप में डेटा तैयारी और प्रशिक्षण से लेकर मॉडल परिनियोजन तक एंड-टू-एंड एमएल जीवनचक्र को व्यवस्थित करने की अनुमति देता है।

समाधान अवलोकन

यह पोस्ट रे और सेजमेकर को एक साथ उपयोग करने के लाभों पर केंद्रित है। हमने सेजमेकर पाइपलाइनों का उपयोग करके ऑर्केस्ट्रेटेड एक एंड-टू-एंड रे-आधारित एमएल वर्कफ़्लो स्थापित किया है। वर्कफ़्लो में रे एक्टर्स का उपयोग करके फीचर स्टोर में डेटा का समानांतर अंतर्ग्रहण, रे डेटा के साथ डेटा प्रीप्रोसेसिंग, प्रशिक्षण मॉडल और रे ट्रेन और हाइपरपैरामीटर ऑप्टिमाइज़ेशन (एचपीओ) ट्यूनिंग नौकरियों का उपयोग करके बड़े पैमाने पर हाइपरपैरामीटर ट्यूनिंग, और अंत में मॉडल मूल्यांकन और मॉडल को एक में पंजीकृत करना शामिल है। मॉडल रजिस्ट्री.

अपने डेटा के लिए, हम उपयोग करते हैं एक सिंथेटिक हाउसिंग डेटासेट इसमें आठ विशेषताएं शामिल हैं (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCH, तथा DECK) और हमारा मॉडल भविष्यवाणी करेगा PRICE घर का।

एमएल वर्कफ़्लो में प्रत्येक चरण को अलग-अलग चरणों में विभाजित किया गया है, इसकी अपनी स्क्रिप्ट है जो इनपुट और आउटपुट पैरामीटर लेती है। अगले भाग में, हम प्रत्येक चरण से मुख्य कोड स्निपेट को हाइलाइट करेंगे। पूरा कोड यहां पाया जा सकता है एडब्ल्यूएस-सैंपल्स-फॉर-रे GitHub रिपॉजिटरी.

.. पूर्वापेक्षाएँ

सेजमेकर पायथन एसडीके का उपयोग करने और इस पोस्ट से जुड़े कोड को चलाने के लिए, आपको निम्नलिखित शर्तों की आवश्यकता है:

सेजमेकर फ़ीचर स्टोर में डेटा डालें

एमएल वर्कफ़्लो में पहला चरण स्रोत डेटा फ़ाइल को पढ़ना है अमेज़न सरल भंडारण सेवा (अमेज़ॅन एस3) सीएसवी प्रारूप में और इसे सेजमेकर फीचर स्टोर में डालें। सेजमेकर फ़ीचर स्टोर एक उद्देश्य-निर्मित रिपॉजिटरी है जो टीमों के लिए एमएल सुविधाओं को बनाना, साझा करना और प्रबंधित करना आसान बनाता है। यह फीचर खोज, पुन: उपयोग और साझाकरण को सरल बनाता है, जिससे तेजी से विकास होता है, ग्राहक टीमों के बीच सहयोग बढ़ता है और लागत कम होती है।

फीचर स्टोर में सुविधाओं को शामिल करने में निम्नलिखित चरण शामिल हैं:

1. एक फीचर समूह को परिभाषित करें और फीचर स्टोर में फीचर समूह बनाएं।
2. डेटा की प्रत्येक पंक्ति के लिए इवेंट समय और रिकॉर्ड आईडी जोड़कर फीचर स्टोर के लिए स्रोत डेटा तैयार करें।
3. Boto3 SDK का उपयोग करके तैयार डेटा को फीचर समूह में शामिल करें।

इस अनुभाग में, हम केवल चरण 3 पर प्रकाश डालते हैं, क्योंकि यह वह भाग है जिसमें रे का उपयोग करके अंतर्ग्रहण कार्य की समानांतर प्रसंस्करण शामिल है। आप इस प्रक्रिया के लिए पूर्ण कोड की समीक्षा कर सकते हैं गीथहब रेपो.

RSI निगलना_सुविधाएँ विधि को एक वर्ग के अंदर परिभाषित किया गया है जिसे कहा जाता है Featurestore। ध्यान दें कि Featurestore क्लास को सजाया गया है @ray.remote. यह इंगित करता है कि इस वर्ग का एक उदाहरण एक रे अभिनेता है, जो रे के भीतर एक स्टेटफुल और समवर्ती कम्प्यूटेशनल इकाई है। यह एक प्रोग्रामिंग मॉडल है जो आपको वितरित ऑब्जेक्ट बनाने की अनुमति देता है जो आंतरिक स्थिति बनाए रखता है और रे क्लस्टर में विभिन्न नोड्स पर चल रहे कई कार्यों द्वारा समवर्ती रूप से पहुंचा जा सकता है। अभिनेता परिवर्तनशील स्थिति को प्रबंधित और समाहित करने का एक तरीका प्रदान करते हैं, जिससे वे वितरित सेटिंग में जटिल, स्टेटफुल अनुप्रयोगों के निर्माण के लिए मूल्यवान बन जाते हैं। आप एक्टर्स में भी संसाधन आवश्यकताओं को निर्दिष्ट कर सकते हैं। इस मामले में, प्रत्येक उदाहरण FeatureStore क्लास को 0.5 सीपीयू की आवश्यकता होगी। निम्नलिखित कोड देखें:

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

आप कॉल करके एक्टर से बातचीत कर सकते हैं remote ऑपरेटर। निम्नलिखित कोड में, अभिनेताओं की वांछित संख्या को स्क्रिप्ट में इनपुट तर्क के रूप में पारित किया जाता है। फिर डेटा को अभिनेताओं की संख्या के आधार पर विभाजित किया जाता है और फीचर स्टोर में शामिल होने के लिए दूरस्थ समानांतर प्रक्रियाओं में भेज दिया जाता है। आप कॉल कर सकते हैं get दूरस्थ गणना पूरी होने और परिणाम उपलब्ध होने तक वर्तमान कार्य के निष्पादन को अवरुद्ध करने के लिए ऑब्जेक्ट रेफरी पर। जब परिणाम उपलब्ध हो, ray.get परिणाम लौटाएगा, और वर्तमान कार्य का निष्पादन जारी रहेगा।

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)

प्रशिक्षण, सत्यापन और परीक्षण के लिए डेटा तैयार करें

इस चरण में, हम मशीन लर्निंग की तैयारी में अपने डेटासेट को कुशलतापूर्वक विभाजित करने, बदलने और स्केल करने के लिए रे डेटासेट का उपयोग करते हैं। रे डेटासेट विभिन्न भंडारण प्रणालियों और फ़ाइल स्वरूपों का समर्थन करते हुए वितरित डेटा को रे में लोड करने का एक मानक तरीका प्रदान करता है। इसमें सामान्य एमएल डेटा प्रीप्रोसेसिंग संचालन जैसे समानांतर परिवर्तन, शफ़लिंग, ग्रुपिंग और एकत्रीकरण के लिए एपीआई हैं। रे डेटासेट स्टेटफुल सेटअप और जीपीयू त्वरण की आवश्यकता वाले संचालन को भी संभालता है। यह अन्य डेटा प्रोसेसिंग लाइब्रेरी जैसे स्पार्क, पांडा, न्यूमपी और अन्य के साथ-साथ टेन्सरफ्लो और पायटोरच जैसे एमएल फ्रेमवर्क के साथ आसानी से एकीकृत होता है। यह रे के शीर्ष पर एंड-टू-एंड डेटा पाइपलाइन और एमएल वर्कफ़्लो बनाने की अनुमति देता है। लक्ष्य चिकित्सकों और शोधकर्ताओं के लिए वितरित डेटा प्रोसेसिंग और एमएल को आसान बनाना है।

आइए उन स्क्रिप्ट के अनुभागों को देखें जो इस डेटा को प्रीप्रोसेसिंग करते हैं। हम फीचर स्टोर से डेटा लोड करके शुरुआत करते हैं:

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

फिर हम उपलब्ध उच्च-स्तरीय अमूर्तों का उपयोग करके डेटा को विभाजित और स्केल करते हैं ray.data पुस्तकालय:

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

संसाधित ट्रेन, सत्यापन और परीक्षण डेटासेट अमेज़ॅन S3 में संग्रहीत किए जाते हैं और बाद के चरणों में इनपुट पैरामीटर के रूप में पारित किए जाएंगे।

मॉडल प्रशिक्षण और हाइपरपैरामीटर अनुकूलन करें

हमारे डेटा के पूर्व-संसाधित और मॉडलिंग के लिए तैयार होने के साथ, अब कुछ एमएल मॉडल को प्रशिक्षित करने और पूर्वानुमानित प्रदर्शन को अधिकतम करने के लिए उनके हाइपरपैरामीटर को ठीक करने का समय आ गया है। हम उपयोग करते हैं XGBoost-रे, रे पर निर्मित XGBoost के लिए एक वितरित बैकएंड जो कई नोड्स और GPU का उपयोग करके बड़े डेटासेट पर XGBoost मॉडल को प्रशिक्षित करने में सक्षम बनाता है। यह XGBoost की ट्रेन के लिए सरल ड्रॉप-इन प्रतिस्थापन प्रदान करता है और हुड के तहत वितरित डेटा प्रबंधन और प्रशिक्षण की जटिलताओं को संभालते हुए एपीआई की भविष्यवाणी करता है।

कई नोड्स पर प्रशिक्षण के वितरण को सक्षम करने के लिए, हम नामक एक सहायक वर्ग का उपयोग करते हैं रेहेल्पर. जैसा कि निम्नलिखित कोड में दिखाया गया है, हम प्रशिक्षण कार्य के संसाधन कॉन्फ़िगरेशन का उपयोग करते हैं और पहले होस्ट को हेड नोड के रूप में चुनते हैं:

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

हम प्रत्येक प्रशिक्षण कार्य उदाहरण पर रे को आरंभ करने का निर्णय लेने के लिए होस्ट जानकारी का उपयोग कर सकते हैं:

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)

जब कोई प्रशिक्षण कार्य शुरू किया जाता है, तो रे क्लस्टर को कॉल करके प्रारंभ किया जा सकता है start_ray() के उदाहरण पर विधि RayHelper:

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

फिर हम प्रशिक्षण के लिए XGBoost-Ray के XGBoost ट्रेनर का उपयोग करते हैं:

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)

ध्यान दें कि इंस्टेंटिअट करते समय trainer, हम उत्तीर्ण हुए RayParams, जो अभिनेताओं की संख्या और प्रति अभिनेता सीपीयू की संख्या लेता है। XGBoost-Ray इस जानकारी का उपयोग रे क्लस्टर से जुड़े सभी नोड्स में प्रशिक्षण वितरित करने के लिए करता है।

अब हम SageMaker Python SDK के आधार पर एक XGBoost अनुमानक ऑब्जेक्ट बनाते हैं और HPO कार्य के लिए उसका उपयोग करते हैं।

सेजमेकर पाइपलाइनों का उपयोग करके पिछले चरणों को व्यवस्थित करें

एंड-टू-एंड स्केलेबल और पुन: प्रयोज्य एमएल वर्कफ़्लो बनाने के लिए, हमें पिछले चरणों को एक पाइपलाइन में व्यवस्थित करने के लिए सीआई/सीडी टूल का उपयोग करने की आवश्यकता है। सेजमेकर पाइपलाइन का सेजमेकर, सेजमेकर पायथन एसडीके और सेजमेकर स्टूडियो के साथ सीधा एकीकरण है। यह एकीकरण आपको उपयोग में आसान पायथन एसडीके के साथ एमएल वर्कफ़्लो बनाने की अनुमति देता है, और फिर सेजमेकर स्टूडियो का उपयोग करके अपने वर्कफ़्लो को विज़ुअलाइज़ और प्रबंधित करता है। आप पाइपलाइन निष्पादन के भीतर अपने डेटा के इतिहास को भी ट्रैक कर सकते हैं और कैशिंग के लिए चरण निर्दिष्ट कर सकते हैं।

सेजमेकर पाइपलाइन एक डायरेक्टेड एसाइक्लिक ग्राफ़ (डीएजी) बनाता है जिसमें एमएल वर्कफ़्लो बनाने के लिए आवश्यक चरण शामिल होते हैं। प्रत्येक पाइपलाइन चरणों के बीच डेटा निर्भरता द्वारा ऑर्केस्ट्रेटेड इंटरकनेक्टेड चरणों की एक श्रृंखला है, और इसे पैरामीटर किया जा सकता है, जिससे आप पाइपलाइन के प्रत्येक रन के लिए पैरामीटर के रूप में इनपुट चर प्रदान कर सकते हैं। सेजमेकर पाइपलाइन में चार प्रकार के पाइपलाइन पैरामीटर हैं: ParameterString, ParameterInteger, ParameterFloat, तथा ParameterBoolean. इस अनुभाग में, हम कुछ इनपुट वेरिएबल्स को पैरामीटराइज़ करते हैं और चरण कैशिंग कॉन्फ़िगरेशन सेट करते हैं:

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

हम दो प्रसंस्करण चरणों को परिभाषित करते हैं: एक सेजमेकर फ़ीचर स्टोर अंतर्ग्रहण के लिए, दूसरा डेटा तैयारी के लिए। यह पहले वर्णित पिछले चरणों के समान ही दिखना चाहिए। कोड की एकमात्र नई पंक्ति है ProcessingStep चरणों की परिभाषा के बाद, जो हमें प्रसंस्करण कार्य कॉन्फ़िगरेशन लेने और इसे पाइपलाइन चरण के रूप में शामिल करने की अनुमति देता है। हम आगे सेजमेकर फ़ीचर स्टोर अंतर्ग्रहण चरण पर डेटा तैयारी चरण की निर्भरता को निर्दिष्ट करते हैं। निम्नलिखित कोड देखें:

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

इसी प्रकार, एक मॉडल प्रशिक्षण और ट्यूनिंग चरण बनाने के लिए, हमें एक परिभाषा जोड़ने की आवश्यकता है TuningStep मॉडल प्रशिक्षण चरण के कोड के बाद हमें पाइपलाइन में एक चरण के रूप में सेजमेकर हाइपरपैरामीटर ट्यूनिंग चलाने की अनुमति मिलती है:

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

ट्यूनिंग चरण के बाद, हम सेजमेकर मॉडल रजिस्ट्री में सर्वश्रेष्ठ मॉडल को पंजीकृत करना चुनते हैं। मॉडल की गुणवत्ता को नियंत्रित करने के लिए, हम एक न्यूनतम गुणवत्ता गेट लागू करते हैं जो पाइपलाइन के इनपुट पैरामीटर के रूप में परिभाषित सीमा के विरुद्ध सर्वोत्तम मॉडल के उद्देश्य मीट्रिक (आरएमएसई) की तुलना करता है। rmse_threshold. इस मूल्यांकन को करने के लिए, हम चलाने के लिए एक और प्रोसेसिंग चरण बनाते हैं मूल्यांकन स्क्रिप्ट. मॉडल मूल्यांकन परिणाम एक संपत्ति फ़ाइल के रूप में संग्रहीत किया जाएगा। संपत्ति फ़ाइलें विशेष रूप से तब उपयोगी होती हैं जब प्रसंस्करण चरण के परिणामों का विश्लेषण करके यह तय किया जाता है कि अन्य चरण कैसे चलाए जाने चाहिए। निम्नलिखित कोड देखें:

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

हम एक परिभाषित करते हैं ModelStep हमारी पाइपलाइन में सेजमेकर मॉडल रजिस्ट्री में सर्वश्रेष्ठ मॉडल को पंजीकृत करने के लिए। यदि सर्वोत्तम मॉडल हमारी पूर्व निर्धारित गुणवत्ता जांच में उत्तीर्ण नहीं होता है, तो हम अतिरिक्त रूप से निर्दिष्ट करते हैं FailStep एक त्रुटि संदेश आउटपुट करने के लिए:

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

अगला, हम ए का उपयोग करते हैं ConditionStep यह मूल्यांकन करने के लिए कि पाइपलाइन में अगला कदम मॉडल पंजीकरण चरण या विफलता चरण उठाया जाना चाहिए या नहीं। हमारे मामले में, सबसे अच्छा मॉडल पंजीकृत किया जाएगा यदि उसका आरएमएसई स्कोर सीमा से कम है।

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

अंत में, हम सभी परिभाषित चरणों को एक पाइपलाइन में व्यवस्थित करते हैं:

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)

पूर्ववर्ती पाइपलाइन को सीधे सेजमेकर स्टूडियो में देखा और निष्पादित किया जा सकता है, या कॉल करके निष्पादित किया जा सकता है execution = training_pipeline.start(). निम्नलिखित चित्र पाइपलाइन प्रवाह को दर्शाता है।

इसके अतिरिक्त, हम पाइपलाइन निष्पादन द्वारा उत्पन्न कलाकृतियों की वंशावली की समीक्षा कर सकते हैं।

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)

मॉडल तैनात करें

पाइपलाइन रन के माध्यम से सेजमेकर मॉडल रजिस्ट्री में सर्वश्रेष्ठ मॉडल पंजीकृत होने के बाद, हम सेजमेकर की पूरी तरह से प्रबंधित मॉडल परिनियोजन क्षमताओं का उपयोग करके मॉडल को वास्तविक समय के समापन बिंदु पर तैनात करते हैं। विभिन्न उपयोग के मामलों की जरूरतों को पूरा करने के लिए सेजमेकर के पास अन्य मॉडल परिनियोजन विकल्प हैं। विवरण के लिए, देखें अनुमान के लिए मॉडल तैनात करें अपने उपयोग के मामले के लिए सही विकल्प चुनते समय। सबसे पहले, आइए मॉडल को सेजमेकर मॉडल रजिस्ट्री में पंजीकृत करवाएं:

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

मॉडल की वर्तमान स्थिति है PendingApproval. हमें इसकी स्थिति निर्धारित करने की आवश्यकता है Approved तैनाती से पहले:

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
)

क्लीन अप

प्रयोग समाप्त करने के बाद, अनावश्यक शुल्कों से बचने के लिए संसाधनों को साफ करना याद रखें। साफ़ करने के लिए, एपीआई को कॉल करके रीयल-टाइम एंडपॉइंट, मॉडल समूह, पाइपलाइन और फ़ीचर समूह को हटा दें DeleteEndpoint, DeleteModelPackageGroup, पाइपलाइन हटाएं, तथा फ़ीचर समूह हटाएँ, क्रमशः, और सभी सेजमेकर स्टूडियो नोटबुक इंस्टेंसेस को बंद कर दें।

निष्कर्ष

इस पोस्ट में रे-आधारित एमएल वर्कफ़्लोज़ को व्यवस्थित करने के लिए सेजमेकर पाइपलाइनों का उपयोग करने के तरीके पर चरण-दर-चरण पूर्वाभ्यास प्रदर्शित किया गया है। हमने तीसरे पक्ष के एमएल टूल के साथ एकीकृत करने के लिए सेजमेकर पाइपलाइन की क्षमता का भी प्रदर्शन किया। ऐसी विभिन्न AWS सेवाएँ हैं जो प्रदर्शन उत्कृष्टता और परिचालन दक्षता सुनिश्चित करने के लिए स्केलेबल और सुरक्षित तरीके से रे वर्कलोड का समर्थन करती हैं। अब, इन शक्तिशाली क्षमताओं का पता लगाने और अमेज़ॅन सेजमेकर पाइपलाइन और रे के साथ अपने मशीन लर्निंग वर्कफ़्लो को अनुकूलित करना शुरू करने की आपकी बारी है। आज ही कार्रवाई करें और अपनी एमएल परियोजनाओं की पूरी क्षमता को अनलॉक करें!

---

लेखक के बारे में

राजू रंगन अमेज़ॅन वेब सर्विसेज (एडब्ल्यूएस) में एक वरिष्ठ समाधान वास्तुकार हैं। वह सरकार प्रायोजित संस्थाओं के साथ काम करता है, और उन्हें AWS का उपयोग करके AI/ML समाधान बनाने में मदद करता है। जब आप क्लाउड समाधानों के साथ छेड़छाड़ नहीं कर रहे हों, तो आप उसे परिवार के साथ घूमते या दोस्तों के साथ बैडमिंटन के जीवंत खेल में बर्डी मारते हुए देखेंगे।

शेरी डिंग अमेज़ॅन वेब सर्विसेज (एडब्ल्यूएस) में एक वरिष्ठ एआई/एमएल विशेषज्ञ समाधान वास्तुकार हैं। उन्हें कंप्यूटर विज्ञान में पीएचडी की डिग्री के साथ मशीन लर्निंग में व्यापक अनुभव है। वह मुख्य रूप से विभिन्न एआई/एमएल-संबंधित व्यावसायिक चुनौतियों पर सार्वजनिक क्षेत्र के ग्राहकों के साथ काम करती है, जिससे उन्हें एडब्ल्यूएस क्लाउड पर उनकी मशीन सीखने की यात्रा में तेजी लाने में मदद मिलती है। जब ग्राहकों की मदद नहीं की जाती, तो वह बाहरी गतिविधियों का आनंद लेती है।

• एसईओ संचालित सामग्री और पीआर वितरण। आज ही प्रवर्धित हो जाओ।
• प्लेटोडेटा.नेटवर्क वर्टिकल जेनरेटिव एआई। स्वयं को शक्तिवान बनाएं। यहां पहुंचें।
• प्लेटोआईस्ट्रीम। Web3 इंटेलिजेंस। ज्ञान प्रवर्धित। यहां पहुंचें।
• प्लेटोईएसजी. कार्बन, क्लीनटेक, ऊर्जा, पर्यावरण, सौर, कचरा प्रबंधन। यहां पहुंचें।
• प्लेटोहेल्थ। बायोटेक और क्लिनिकल परीक्षण इंटेलिजेंस। यहां पहुंचें।
• BlockOffsets. पर्यावरणीय ऑफसेट स्वामित्व का आधुनिकीकरण। यहां पहुंचें।
• स्रोत: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/