Amazon SageMaker प्रयोग और Amazon SageMaker पाइपलाइनों के साथ अपनी मशीन सीखने की यात्रा को व्यवस्थित करें

मशीन लर्निंग (एमएल) मॉडल के निर्माण की प्रक्रिया तब तक चलती रहती है जब तक आपको वह उम्मीदवार मॉडल नहीं मिल जाता जो अच्छा प्रदर्शन कर रहा हो और तैनात करने के लिए तैयार हो। जैसा कि डेटा वैज्ञानिक उस प्रक्रिया के माध्यम से पुनरावृति करते हैं, उन्हें यह समझने के लिए प्रयोगों को आसानी से ट्रैक करने के लिए एक विश्वसनीय विधि की आवश्यकता होती है कि प्रत्येक मॉडल संस्करण कैसे बनाया गया था और यह कैसे प्रदर्शन करता है।

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

इस पोस्ट में, हम प्रयोगों के साथ प्रयोगों और पाइपलाइनों में निर्मित मूल क्षमताओं को ट्रैक करने के लिए एक स्वचालित प्रक्रिया होने के पीछे की प्रेरणा पर करीब से नज़र डालते हैं।

अपने प्रयोगों को व्यवस्थित रखना क्यों महत्वपूर्ण है?

आइए एक पल के लिए एक कदम पीछे हटें और यह समझने की कोशिश करें कि मशीन लर्निंग के लिए प्रयोगों का आयोजन करना क्यों महत्वपूर्ण है। जब डेटा वैज्ञानिक एक नई एमएल समस्या से संपर्क करते हैं, तो उन्हें डेटा उपलब्धता से लेकर मॉडल प्रदर्शन को कैसे मापेंगे, कई अलग-अलग सवालों के जवाब देने होंगे।

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

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

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

सेजमेकर प्रयोगों के लाभ

सेजमेकर एक्सपेरिमेंट्स डेटा वैज्ञानिकों को उनके प्रशिक्षण पुनरावृत्तियों को व्यवस्थित, ट्रैक, तुलना और मूल्यांकन करने की अनुमति देता है।

आइए सबसे पहले इस बात का अवलोकन करें कि आप प्रयोगों के साथ क्या कर सकते हैं:

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

प्रयोग API और SDK के बारे में अधिक जानने के लिए, हम निम्नलिखित दस्तावेज़ीकरण की अनुशंसा करते हैं: प्रयोग बनाएं और अमेज़ॅन सेजमेकर प्रयोग पायथन एसडीके।

यदि आप अधिक गहराई तक जाना चाहते हैं, तो हम अनुशंसा करते हैं कि आप इसमें देखें अमेज़ॅन-सेजमेकर-उदाहरण/सेजमेकर-प्रयोग गिटहब रिपोजिटरी आगे के उदाहरणों के लिए।

पाइपलाइनों और प्रयोगों के बीच एकीकरण

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

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

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

सेजमेकर पाइपलाइन कोड

आप नोटबुक की समीक्षा और डाउनलोड कर सकते हैं गिटहब भंडार इस पोस्ट से जुड़े। हम इसे बेहतर ढंग से समझने के लिए पाइपलाइन-विशिष्ट कोड को देखते हैं।

पाइपलाइन आपको रन टाइम पर पैरामीटर पास करने में सक्षम बनाती है। यहां हम प्रीसेट डिफॉल्ट के साथ प्रोसेसिंग और ट्रेनिंग इंस्टेंस प्रकार और रन टाइम पर काउंट को परिभाषित करते हैं:

base_job_prefix = "pipeline-experiment-sample"
model_package_group_name = "pipeline-experiment-model-package"

processing_instance_count = ParameterInteger(
  name="ProcessingInstanceCount", default_value=1
)

training_instance_count = ParameterInteger(
  name="TrainingInstanceCount", default_value=1
)

processing_instance_type = ParameterString(
  name="ProcessingInstanceType", default_value="ml.m5.xlarge"
)
training_instance_type = ParameterString(
  name="TrainingInstanceType", default_value="ml.m5.xlarge"
)

इसके बाद, हम एक प्रोसेसिंग स्क्रिप्ट सेट करते हैं जो इनपुट डेटासेट को ट्रेन, टेस्ट और सत्यापन भागों में डाउनलोड और विभाजित करती है। हम उपयोग करते हैं SKLearnProcessor इस प्रीप्रोसेसिंग चरण को चलाने के लिए। ऐसा करने के लिए, हम प्रसंस्करण कार्य को चलाने के लिए आवश्यक उदाहरण प्रकार और गणना के साथ एक प्रोसेसर ऑब्जेक्ट को परिभाषित करते हैं।

पाइपलाइन हमें निष्पादन-विशिष्ट चर का उपयोग करके प्रोग्रामेटिक तरीके से डेटा संस्करण प्राप्त करने की अनुमति देती है जैसे ExecutionVariables.PIPELINE_EXECUTION_ID, जो एक पाइपलाइन रन की अद्वितीय आईडी है। उदाहरण के लिए, हम आउटपुट डेटासेट को स्टोर करने के लिए एक अद्वितीय कुंजी बना सकते हैं अमेज़न सरल भंडारण सेवा (अमेज़ॅन एस 3) जो उन्हें एक विशिष्ट पाइपलाइन रन से जोड़ता है। चर की पूरी सूची के लिए, देखें निष्पादन चर.

framework_version = "0.23-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=processing_instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-ca-housing",
    role=role,
)

process_step = ProcessingStep(
    name="ca-housing-preprocessing",
    processor=sklearn_processor,
    outputs=[
        ProcessingOutput(
            output_name="train",
            source="/opt/ml/processing/train",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "train",
                ],
            ),
        ),
        ProcessingOutput(
            output_name="validation",
            source="/opt/ml/processing/validation",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "validation",
                ],
            )
        ),
        ProcessingOutput(
            output_name="test",
            source="/opt/ml/processing/test",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "test",
                ],
            )
        ),
    ],
    code="california-housing-preprocessing.py",
)

फिर हम XGBoost मॉडल को प्रशिक्षित करने के लिए एक अनुमानक वस्तु बनाने के लिए आगे बढ़ते हैं। हम कुछ स्थिर हाइपरपैरामीटर सेट करते हैं जो आमतौर पर XGBoost के साथ उपयोग किए जाते हैं:

model_path = f"s3://{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"

image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.2-2",
    py_version="py3",
    instance_type=training_instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    instance_type=training_instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    base_job_name=f"{base_job_prefix}/ca-housing-train",
    sagemaker_session=sagemaker_session,
    role=role,
)

xgb_train.set_hyperparameters(
    eval_metric="rmse",
    objective="reg:squarederror",  # Define the object metric for the training job
    num_round=50,
    max_depth=5,
    eta=0.2,
    gamma=4,
    min_child_weight=6,
    subsample=0.7
)

हम उन मॉडलों की हाइपरपैरामीटर ट्यूनिंग करते हैं जो हम a . का उपयोग करके बनाते हैं ContinuousParameter के लिए रेंज lambda. एक मीट्रिक को उद्देश्य मीट्रिक के रूप में चुनना ट्यूनर को बताता है कि आप इस विशिष्ट मीट्रिक के आधार पर प्रशिक्षण कार्य का मूल्यांकन करेंगे। ट्यूनर इस उद्देश्य मीट्रिक के लिए सर्वोत्तम मूल्य के आधार पर सबसे अच्छा संयोजन देता है, जिसका अर्थ है सबसे अच्छा संयोजन जो सर्वोत्तम रूट माध्य वर्ग त्रुटि (आरएमएसई) को कम करता है।

objective_metric_name = "validation:rmse"

hyperparameter_ranges = {
    "lambda": ContinuousParameter(0.01, 10, scaling_type="Logarithmic")
}

tuner = HyperparameterTuner(estimator,
                            objective_metric_name,
                            hyperparameter_ranges,
                            objective_type=objective_type,
                            strategy="Bayesian",
                            max_jobs=10,
                            max_parallel_jobs=3)

tune_step = TuningStep(
    name="HPTuning",
    tuner=tuner_log,
    inputs={
        "train": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "train"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
        "validation": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "validation"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
    } 
)

परीक्षण किए गए पैरामीटर श्रेणियों के बीच सर्वश्रेष्ठ मॉडल का निर्धारण करने के लक्ष्य के साथ ट्यूनिंग चरण कई परीक्षण चलाता है। विधि के साथ get_top_model_s3_uri, हम मॉडल आर्टिफैक्ट S50 URI के शीर्ष 3 प्रदर्शन करने वाले संस्करणों को रैंक करते हैं और केवल सबसे अच्छा प्रदर्शन करने वाले संस्करण को निकालते हैं (हम निर्दिष्ट करते हैं k=0 सर्वश्रेष्ठ के लिए) एक सेजमेकर मॉडल बनाने के लिए।

model_bucket_key = f"{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"
model_candidate = Model(
    image_uri=image_uri,
    model_data=tune_step.get_top_model_s3_uri(top_k=0, s3_bucket=model_bucket_key),
    sagemaker_session=sagemaker_session,
    role=role,
    predictor_cls=XGBoostPredictor,
)

create_model_step = CreateModelStep(
    name="CreateTopModel",
    model=model_candidate,
    inputs=sagemaker.inputs.CreateModelInput(instance_type="ml.m4.large"),
)

जब पाइपलाइन चलती है, तो यह प्रत्येक हाइपरपैरामीटर ट्यूनिंग कार्य और पाइपलाइन चरणों द्वारा बनाए गए प्रत्येक सेजमेकर कार्य के लिए परीक्षण घटक बनाती है।

आप a . बनाकर प्रयोगों के साथ पाइपलाइनों के एकीकरण को और अधिक कॉन्फ़िगर कर सकते हैं PipelineExperimentConfig ऑब्जेक्ट करें और इसे पाइपलाइन ऑब्जेक्ट में पास करें। दो पैरामीटर उस प्रयोग के नाम को परिभाषित करते हैं जिसे बनाया जाएगा, और परीक्षण जो पाइपलाइन के पूरे रन को संदर्भित करेगा।

यदि आप किसी मौजूदा प्रयोग से चलने वाली पाइपलाइन को संबद्ध करना चाहते हैं, तो आप उसका नाम पास कर सकते हैं, और पाइपलाइन नए परीक्षण को इससे संबद्ध कर देगी। आप सेटिंग द्वारा चलाई जा रही पाइपलाइन के लिए एक प्रयोग और परीक्षण के निर्माण को रोक सकते हैं pipeline_experiment_config सेवा मेरे None.

#Pipeline experiment config
ca_housing_experiment_config = PipelineExperimentConfig(
    experiment_name,
    Join(
        on="-",
        values=[
            "pipeline-execution",
            ExecutionVariables.PIPELINE_EXECUTION_ID
        ],
    )
)

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

pipeline_name = f"CAHousingExperimentsPipeline"

pipeline = Pipeline(
    name=pipeline_name,
    pipeline_experiment_config=ca_housing_experiment_config,
    parameters=[
        processing_instance_count,
        processing_instance_type,
        training_instance_count,
        training_instance_type
    ],
    steps=[process_step,tune_step,create_model_step],
)

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

pipeline.upsert(role_arn=sagemaker.get_execution_role())
execution = pipeline.start()

पिछला स्क्रीनशॉट हरे रंग में एक सफलतापूर्वक चलने वाली पाइपलाइन दिखाता है। हम निम्नलिखित कोड के साथ पाइपलाइन के एक रन से एक परीक्षण के मेट्रिक्स प्राप्त करते हैं:

# SM Pipeline injects the Execution ID into trial component names
execution_id = execution.describe()['PipelineExecutionArn'].split('/')[-1]
source_arn_filter = Filter(
    name="TrialComponentName", operator=Operator.CONTAINS, value=execution_id
)

source_type_filter = Filter(
    name="Source.SourceType", operator=Operator.EQUALS, value="SageMakerTrainingJob"
)

search_expression = SearchExpression(
    filters=[source_arn_filter, source_type_filter]
)

trial_component_analytics = ExperimentAnalytics(
    sagemaker_session=sagemaker_session,
    experiment_name=experiment_name,
    search_expression=search_expression.to_boto()
)

analytic_table = trial_component_analytics.dataframe()
analytic_table.head()

प्रत्येक परीक्षण घटक के लिए मीट्रिक की तुलना करें

आप स्टूडियो में या अन्य पायथन प्लॉटिंग लाइब्रेरी के माध्यम से हाइपरपैरामीटर ट्यूनिंग के परिणामों को प्लॉट कर सकते हैं। हम ऐसा करने के दोनों तरीके दिखाते हैं।

स्टूडियो में प्रशिक्षण और मूल्यांकन मेट्रिक्स का अन्वेषण करें

स्टूडियो एक इंटरैक्टिव यूजर इंटरफेस प्रदान करता है जहां आप इंटरेक्टिव प्लॉट उत्पन्न कर सकते हैं। चरण इस प्रकार हैं:

1. चुनें प्रयोग और परीक्षण से SageMaker संसाधन बाईं साइडबार पर आइकन।
2. इसे खोलने के लिए अपना प्रयोग चुनें।
3. रुचि का परीक्षण चुनें (राइट-क्लिक करें)।
4. चुनें परीक्षण घटक सूची में खोलें.
5. दबाएँ पाली प्रशिक्षण कार्यों का प्रतिनिधित्व करने वाले परीक्षण घटकों का चयन करने के लिए।
6. चुनें चार्ट जोड़ें.
7. चुनें नया चार्ट और उस एकत्रित मीट्रिक को प्लॉट करने के लिए अनुकूलित करें जिसका आप विश्लेषण करना चाहते हैं। हमारे उपयोग के मामले के लिए, निम्नलिखित चुनें:
   1. के लिए डाटा प्रकारचुनते हैं सारांश आँकड़े.
   2. के लिए चार्ट प्रकारचुनते हैं स्कैटर प्लॉट.
   3. के लिए X- अक्ष, चुनें lambda.
   4. के लिए शाफ़्ट, चुनें validation:rmse_last.

नया चार्ट विंडो के निचले भाग में दिखाई देता है, जिसे '8' के रूप में लेबल किया जाता है।

आप दबाकर कम या ज्यादा प्रशिक्षण कार्य शामिल कर सकते हैं पाली और अधिक इंटरैक्टिव अनुभव के लिए आई आइकन चुनना।

सेजमेकर प्रयोगों के साथ विश्लेषिकी

जब पाइपलाइन रन पूरा हो जाता है, तो हम जल्दी से कल्पना कर सकते हैं कि प्रशिक्षण के दौरान एकत्र किए गए मेट्रिक्स के संदर्भ में मॉडल के विभिन्न रूपांतरों की तुलना कैसे होती है। इससे पहले, हमने सभी परीक्षण मीट्रिक को a . को निर्यात किया था पांडा DataFrame का उपयोग ExperimentAnalytics. हम Matplotlib लाइब्रेरी का उपयोग करके स्टूडियो में प्राप्त प्लॉट को पुन: पेश कर सकते हैं।

analytic_table.plot.scatter("lambda", "validation:rmse - Last", grid=True)

निष्कर्ष

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

• एक व्यावसायिक उपयोग का मामला जिसे आप संबोधित कर रहे हैं, जैसे ग्राहक मंथन की भविष्यवाणी करने के लिए एक प्रयोग बनाना
• उदाहरण के लिए, मार्केटिंग एनालिटिक्स के संबंध में डेटा साइंस टीम के स्वामित्व वाला एक प्रयोग
• एक विशिष्ट डेटा विज्ञान और एमएल परियोजना

इस पोस्ट में, हमने यह दिखाने के लिए पाइपलाइनों में प्रवेश किया है कि आप पूरी तरह से स्वचालित एंड-टू-एंड वर्कफ़्लो को व्यवस्थित करने के लिए प्रयोगों के साथ इसका उपयोग कैसे कर सकते हैं।

अगले चरण के रूप में, आप अपने अगले एमएल प्रोजेक्ट के लिए इन तीन सेजमेकर सुविधाओं - स्टूडियो, प्रयोग और पाइपलाइन - का उपयोग कर सकते हैं।

सुझाई गई रीडिंग

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

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

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

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

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