Amazon SageMaker पाइपलाइन में PySpark का उपयोग करके सुरक्षित प्रोसेसिंग जॉब चलाएं

अमेज़ॅन सैजमेकर स्टूडियो आपको अपने मॉडल बनाने, प्रशिक्षित करने, डिबग करने, तैनात करने और निगरानी करने में मदद कर सकता है और आपके मशीन लर्निंग (ML) वर्कफ़्लो को प्रबंधित कर सकता है। अमेज़न SageMaker पाइपलाइन बनाने में सक्षम बनाता है सुरक्षित, स्केलेबल और लचीला MLOps प्लेटफॉर्म स्टूडियो के भीतर।

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

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

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

हमारे उदाहरण में, हम एक प्रसंस्करण चरण चलाने वाली एक SageMaker पाइपलाइन बनाते हैं। पाइपलाइन में आप कौन से अन्य चरण जोड़ सकते हैं, इसके बारे में अधिक जानकारी के लिए देखें पाइपलाइन के चरण.

सेजमेकर प्रोसेसिंग लाइब्रेरी

SageMaker प्रसंस्करण विशिष्ट के साथ चल सकता है चौखटे (उदाहरण के लिए, SKlearnProcessor, PySparkProcessor, या Hugging Face)। उपयोग किए गए ढांचे से स्वतंत्र, प्रत्येक प्रोसेसिंगस्टेप निम्नलिखित की आवश्यकता है:

• चरण नाम - आपके SageMaker पाइपलाइन चरण के लिए उपयोग किया जाने वाला नाम
• कदम तर्क - आपके लिए तर्क ProcessingStep

इसके अतिरिक्त, आप निम्नलिखित प्रदान कर सकते हैं:

• SageMaker पाइपलाइन में आपके चरण के अनावश्यक रन से बचने के लिए आपके स्टेप कैश के लिए कॉन्फ़िगरेशन
• चरण नामों, चरण उदाहरणों या चरण संग्रह उदाहरणों की एक सूची जो ProcessingStep पर निर्भर करता है
• का प्रदर्शन नाम ProcessingStep
• का विवरण ProcessingStep
• संपत्ति फ़ाइलें
• नीतियों का पुनः प्रयास करें

को तर्क सौंपे जाते हैं ProcessingStep। आप उपयोग कर सकते हैं सेजमेकर.स्पार्क.पायस्पार्कप्रोसेसर or सेजमेकर.स्पार्क.स्पार्कजारप्रोसेसर प्रसंस्करण कार्य के अंदर अपने स्पार्क एप्लिकेशन को चलाने के लिए क्लास।

ढांचे के आधार पर प्रत्येक प्रोसेसर अपनी जरूरतों के साथ आता है। यह का उपयोग करके सबसे अच्छा सचित्र है PySparkProcessor, जहां आप ऑप्टिमाइज़ करने के लिए अतिरिक्त जानकारी पास कर सकते हैं ProcessingStep आगे, उदाहरण के लिए के माध्यम से configuration अपना काम चलाते समय पैरामीटर।

SageMaker प्रोसेसिंग जॉब को एक सुरक्षित वातावरण में चलाएं

आईटी इस सबसे अच्छा अभ्यास एक निजी अमेज़ॅन वीपीसी बनाने और इसे कॉन्फ़िगर करने के लिए ताकि आपकी नौकरियां सार्वजनिक इंटरनेट पर पहुंच योग्य न हों। SageMaker प्रसंस्करण नौकरियां आपको अपने VPC में निजी सबनेट और सुरक्षा समूहों को निर्दिष्ट करने के साथ-साथ नेटवर्क अलगाव और इंटर-कंटेनर ट्रैफ़िक एन्क्रिप्शन को सक्षम करने की अनुमति देती हैं। NetworkConfig.VpcConfig के अनुरोध पैरामीटर CreateProcessingJob एपीआई। हम इस कॉन्फ़िगरेशन का उपयोग करके उदाहरण प्रदान करते हैं सेजमेकर एसडीके अगले भाग में

सैजमेकर पाइपलाइनों के भीतर PySpark प्रसंस्करण कदम

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

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

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

{ "pipeline_name": "ProcessingPipeline", "trial": "test-blog-post", "pipeline_role": "arn:aws:iam::<ACCOUNT_NUMBER>:role/<PIPELINE_EXECUTION_ROLE_NAME>", "network_subnet_ids": [ "subnet-<SUBNET_ID>", "subnet-<SUBNET_ID>" ], "network_security_group_ids": [ "sg-<SG_ID>" ], "pyspark_process_volume_kms": "arn:aws:kms:<REGION_NAME>:<ACCOUNT_NUMBER>:key/<KMS_KEY_ID>", "pyspark_process_output_kms": "arn:aws:kms:<REGION_NAME>:<ACCOUNT_NUMBER>:key/<KMS_KEY_ID>", "pyspark_helper_code": "s3://<INFRA_S3_BUCKET>/src/helper/data_utils.py", "spark_config_file": "s3://<INFRA_S3_BUCKET>/src/spark_configuration/configuration.json", "pyspark_process_code": "s3://<INFRA_S3_BUCKET>/src/processing/process_pyspark.py", "process_spark_ui_log_output": "s3://<DATA_S3_BUCKET>/spark_ui_logs/{}", "pyspark_framework_version": "2.4", "pyspark_process_name": "pyspark-processing", "pyspark_process_data_input": "s3a://<DATA_S3_BUCKET>/data_input/abalone_data.csv", "pyspark_process_data_output": "s3a://<DATA_S3_BUCKET>/pyspark/data_output", "pyspark_process_instance_type": "ml.m5.4xlarge", "pyspark_process_instance_count": 6, "tags": { "Project": "tag-for-project", "Owner": "tag-for-owner" }
}

प्रदर्शित करने के लिए, निम्नलिखित कोड उदाहरण एक पाइप लाइन के भीतर SageMaker प्रसंस्करण पर एक PySpark स्क्रिप्ट का उपयोग करके चलाता है PySparkProcessor:

# import code requirements
# standard libraries import
import logging
import json # sagemaker model import
import sagemaker
from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.pipeline_experiment_config import PipelineExperimentConfig
from sagemaker.workflow.steps import CacheConfig
from sagemaker.processing import ProcessingInput
from sagemaker.workflow.steps import ProcessingStep
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.spark.processing import PySparkProcessor from helpers.infra.networking.networking import get_network_configuration
from helpers.infra.tags.tags import get_tags_input
from helpers.pipeline_utils import get_pipeline_config def create_pipeline(pipeline_params, logger): """ Args: pipeline_params (ml_pipeline.params.pipeline_params.py.Params): pipeline parameters logger (logger): logger Returns: () """ # Create SageMaker Session sagemaker_session = PipelineSession() # Get Tags tags_input = get_tags_input(pipeline_params["tags"]) # get network configuration network_config = get_network_configuration( subnets=pipeline_params["network_subnet_ids"], security_group_ids=pipeline_params["network_security_group_ids"] ) # Get Pipeline Configurations pipeline_config = get_pipeline_config(pipeline_params) # setting processing cache obj logger.info("Setting " + pipeline_params["pyspark_process_name"] + " cache configuration 3 to 30 days") cache_config = CacheConfig(enable_caching=True, expire_after="p30d") # Create PySpark Processing Step logger.info("Creating " + pipeline_params["pyspark_process_name"] + " processor") # setting up spark processor processing_pyspark_processor = PySparkProcessor( base_job_name=pipeline_params["pyspark_process_name"], framework_version=pipeline_params["pyspark_framework_version"], role=pipeline_params["pipeline_role"], instance_count=pipeline_params["pyspark_process_instance_count"], instance_type=pipeline_params["pyspark_process_instance_type"], volume_kms_key=pipeline_params["pyspark_process_volume_kms"], output_kms_key=pipeline_params["pyspark_process_output_kms"], network_config=network_config, tags=tags_input, sagemaker_session=sagemaker_session ) # setting up arguments run_ags = processing_pyspark_processor.run( submit_app=pipeline_params["pyspark_process_code"], submit_py_files=[pipeline_params["pyspark_helper_code"]], arguments=[ # processing input arguments. To add new arguments to this list you need to provide two entrances: # 1st is the argument name preceded by "--" and the 2nd is the argument value # setting up processing arguments "--input_table", pipeline_params["pyspark_process_data_input"], "--output_table", pipeline_params["pyspark_process_data_output"] ], spark_event_logs_s3_uri=pipeline_params["process_spark_ui_log_output"].format(pipeline_params["trial"]), inputs = [ ProcessingInput( source=pipeline_params["spark_config_file"], destination="/opt/ml/processing/input/conf", s3_data_type="S3Prefix", s3_input_mode="File", s3_data_distribution_type="FullyReplicated", s3_compression_type="None" ) ], ) # create step pyspark_processing_step = ProcessingStep( name=pipeline_params["pyspark_process_name"], step_args=run_ags, cache_config=cache_config, ) # Create Pipeline pipeline = Pipeline( name=pipeline_params["pipeline_name"], steps=[ pyspark_processing_step ], pipeline_experiment_config=PipelineExperimentConfig( pipeline_params["pipeline_name"], pipeline_config["trial"] ), sagemaker_session=sagemaker_session ) pipeline.upsert( role_arn=pipeline_params["pipeline_role"], description="Example pipeline", tags=tags_input ) return pipeline def main(): # set up logging logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) logger.info("Get Pipeline Parameter") with open("ml_pipeline/params/pipeline_params.json", "r") as f: pipeline_params = json.load(f) print(pipeline_params) logger.info("Create Pipeline") pipeline = create_pipeline(pipeline_params, logger=logger) logger.info("Execute Pipeline") execution = pipeline.start() return execution if __name__ == "__main__": main()

जैसा कि पिछले कोड में दिखाया गया है, हम प्रदान करके डिफ़ॉल्ट स्पार्क कॉन्फ़िगरेशन को ओवरराइट कर रहे हैं configuration.json एक के रूप में ProcessingInput. हम ए का उपयोग करते हैं configuration.json फ़ाइल जिसमें सहेजा गया था अमेज़न सरल भंडारण सेवा (अमेज़न S3) निम्नलिखित सेटिंग्स के साथ:

[ { "Classification":"spark-defaults", "Properties":{ "spark.executor.memory":"10g", "spark.executor.memoryOverhead":"5g", "spark.driver.memory":"10g", "spark.driver.memoryOverhead":"10g", "spark.driver.maxResultSize":"10g", "spark.executor.cores":5, "spark.executor.instances":5, "spark.yarn.maxAppAttempts":1 "spark.hadoop.fs.s3a.endpoint":"s3.<region>.amazonaws.com", "spark.sql.parquet.fs.optimized.comitter.optimization-enabled":true } }
]

हम डिफ़ॉल्ट स्पार्क कॉन्फ़िगरेशन को फ़ाइल के रूप में पास करके अपडेट कर सकते हैं ProcessingInput या चलाते समय कॉन्फ़िगरेशन तर्क का उपयोग करके run() समारोह.

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

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

अगला, ड्राइवर और निष्पादक सेटिंग्स के लिए, हम Amazon S3 पर लिखते समय प्रदर्शन को बेहतर बनाने के लिए कमिटर सेटिंग्स की जांच करने की सलाह देते हैं। हमारे मामले में, हम Amazon S3 में Parquet फाइलें लिख रहे हैं और "सेटिंग" कर रहे हैं।spark.sql.parquet.fs.optimized.comitter.optimization-enabled"सच करने के लिए।

यदि अमेज़ॅन S3, एक क्षेत्रीय समापन बिंदु से कनेक्शन के लिए आवश्यक है "spark.hadoop.fs.s3a.endpoint” कॉन्फ़िगरेशन फ़ाइल में निर्दिष्ट किया जा सकता है।

इस उदाहरण पाइपलाइन में, PySpark script spark_process.py (जैसा कि निम्नलिखित कोड में दिखाया गया है) Amazon S3 से CSV फ़ाइल को स्पार्क डेटा फ़्रेम में लोड करता है, और डेटा को Parquet के रूप में Amazon S3 में वापस सहेजता है।

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

# import requirements
import argparse
import logging
import sys
import os
import pandas as pd # spark imports
from pyspark.sql import SparkSession
from pyspark.sql.functions import (udf, col)
from pyspark.sql.types import StringType, StructField, StructType, FloatType from data_utils import( spark_read_parquet, Unbuffered
) sys.stdout = Unbuffered(sys.stdout) # Define custom handler
logger = logging.getLogger(__name__)
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(logging.Formatter("%(asctime)s %(message)s"))
logger.addHandler(handler)
logger.setLevel(logging.INFO) def main(data_path): spark = SparkSession.builder.appName("PySparkJob").getOrCreate() spark.sparkContext.setLogLevel("ERROR") schema = StructType( [ StructField("sex", StringType(), True), StructField("length", FloatType(), True), StructField("diameter", FloatType(), True), StructField("height", FloatType(), True), StructField("whole_weight", FloatType(), True), StructField("shucked_weight", FloatType(), True), StructField("viscera_weight", FloatType(), True), StructField("rings", FloatType(), True), ] ) df = spark.read.csv(data_path, header=False, schema=schema) return df.select("sex", "length", "diameter", "rings") if __name__ == "__main__": logger.info(f"===============================================================") logger.info(f"================= Starting pyspark-processing =================") parser = argparse.ArgumentParser(description="app inputs") parser.add_argument("--input_table", type=str, help="path to the channel data") parser.add_argument("--output_table", type=str, help="path to the output data") args = parser.parse_args() df = main(args.input_table) logger.info("Writing transformed data") df.write.csv(os.path.join(args.output_table, "transformed.csv"), header=True, mode="overwrite") # save data df.coalesce(10).write.mode("overwrite").parquet(args.output_table) logger.info(f"================== Ending pyspark-processing ==================") logger.info(f"===============================================================")

स्पार्क प्रोसेसिंग जॉब्स को अनुकूलित करने के लिए, आप क्लाउडवॉच लॉग के साथ-साथ स्पार्क यूआई का उपयोग कर सकते हैं। आप SageMaker नोटबुक इंस्टेंस पर प्रोसेसिंग कार्य चलाकर स्पार्क UI बना सकते हैं। आप देख सकते हैं एक पाइपलाइन के भीतर चल रहे प्रसंस्करण कार्यों के लिए स्पार्क यूआई by इतिहास सर्वर चला रहा है SageMaker नोटबुक उदाहरण के भीतर यदि स्पार्क UI लॉग उसी Amazon S3 स्थान के भीतर सहेजे गए थे।

क्लीन अप

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

निष्कर्ष

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

अगले चरण के रूप में, संपूर्ण मॉडल जीवनचक्र को स्वचालित करने का तरीका और कैसे एक्सप्लोर करें ग्राहकों ने सुरक्षित और स्केलेबल MLOps प्लेटफॉर्म बनाए सेजमेकर सेवाओं का उपयोग करना।

---

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

मारन सुइलमान में डाटा साइंटिस्ट हैं AWS व्यावसायिक सेवाएँ. वह अपने व्यावसायिक परिणामों को प्राप्त करने के लिए एआई/एमएल की शक्ति का अनावरण करने वाले उद्योगों में ग्राहकों के साथ काम करती है। मरीन नवंबर 2019 से AWS के साथ हैं। अपने खाली समय में, वह किकबॉक्सिंग, लंबी पैदल यात्रा से लेकर शानदार नज़ारों और बोर्ड गेम नाइट्स का आनंद लेती हैं।

मैरा लादेइरा टंके AWS में एमएल विशेषज्ञ हैं। डेटा साइंस की पृष्ठभूमि के साथ, उनके पास उद्योगों में ग्राहकों के साथ एमएल एप्लिकेशन बनाने और बनाने का 9 साल का अनुभव है। एक तकनीकी नेतृत्व के रूप में, वह ग्राहकों को उभरती प्रौद्योगिकियों और नवीन समाधानों के माध्यम से व्यावसायिक मूल्य की उपलब्धि में तेजी लाने में मदद करती हैं। अपने खाली समय में, मायरा यात्रा करना और अपने परिवार के साथ कहीं गर्म समय बिताना पसंद करती है।

पॉलीन टिंग में डाटा साइंटिस्ट हैं AWS व्यावसायिक सेवाएँ टीम। वह AI/ML समाधान विकसित करके ग्राहकों को उनके व्यावसायिक परिणाम प्राप्त करने और उसमें तेजी लाने में सहायता करती है। अपने खाली समय में, पॉलीन को यात्रा करना, सर्फिंग करना और मिठाई के नए स्थानों की कोशिश करना पसंद है।

डोनाल्ड फोसोउ में सीनियर डेटा आर्किटेक्ट हैं AWS व्यावसायिक सेवाएँ टीम, ज्यादातर ग्लोबल फाइनेंस सर्विस के साथ काम कर रही है। वह ग्राहकों के साथ नए समाधान बनाने के लिए संलग्न हैं जो ग्राहकों की व्यावसायिक समस्याओं का समाधान करते हैं और AWS सेवाओं को अपनाने में तेजी लाते हैं। अपने खाली समय में, डोनाल्ड को पढ़ना, दौड़ना और यात्रा करना अच्छा लगता है।

• एसईओ संचालित सामग्री और पीआर वितरण। आज ही प्रवर्धित हो जाओ।
• प्लेटोब्लॉकचैन। Web3 मेटावर्स इंटेलिजेंस। ज्ञान प्रवर्धित। यहां पहुंचें।
• स्रोत: https://aws.amazon.com/blogs/machine-learning/run-secure-processing-jobs-using-pyspark-in-amazon-sagemaker-pipelines/