अगली पीढ़ी के अमेज़ॅन सैजमेकर प्रयोग - बड़े पैमाने पर अपने मशीन सीखने के प्रशिक्षण को व्यवस्थित करें, ट्रैक करें और तुलना करें

आज, हमें अपने अपडेट की घोषणा करते हुए खुशी हो रही है अमेज़न SageMaker प्रयोग बसकी बात अमेज़न SageMaker जो आपको स्थानीय ज्यूपिटर नोटबुक सहित SageMaker Python SDK या boto3 का उपयोग करके किसी भी एकीकृत विकास परिवेश (IDE) से मशीन लर्निंग (ML) प्रयोगों और मॉडल संस्करणों को व्यवस्थित, ट्रैक, तुलना और मूल्यांकन करने देता है।

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

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

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

• प्रयोग: रन का एक संग्रह जो एक साथ समूहीकृत किया जाता है। एक प्रयोग में कई प्रकार के रन शामिल होते हैं जिन्हें SageMaker Python SDK का उपयोग करके कहीं से भी शुरू किया जा सकता है।
• रन: मॉडल प्रशिक्षण प्रक्रिया का प्रत्येक निष्पादन चरण। एक रन में मॉडल प्रशिक्षण के एक पुनरावृत्ति के लिए सभी इनपुट, पैरामीटर, कॉन्फ़िगरेशन और परिणाम शामिल होते हैं। कस्टम पैरामीटर और मेट्रिक्स का उपयोग करके लॉग किया जा सकता है log_parameter, log_parameters, तथा log_metric कार्य करता है। कस्टम इनपुट और आउटपुट का उपयोग करके लॉग इन किया जा सकता है log_file समारोह.

अवधारणाएँ जो एक के हिस्से के रूप में कार्यान्वित की जाती हैं Run क्लास को किसी भी IDE से उपलब्ध कराया जाता है जहाँ SageMaker Python SDK स्थापित है। सेजमेकर प्रशिक्षण, प्रसंस्करण और के लिए

ट्रांसफ़ॉर्म जॉब्स, यदि जॉब को रन के संदर्भ में लागू किया जाता है, तो SageMaker एक्सपेरिमेंट रन स्वचालित रूप से जॉब को पास हो जाता है। आप रन ऑब्जेक्ट का उपयोग कर पुनर्प्राप्त कर सकते हैं load_run() आपकी नौकरी से। अंत में, नई कार्यात्मकताओं के एकीकरण के साथ, डेटा वैज्ञानिक स्वचालित रूप से एक भ्रम मैट्रिक्स, सटीक और रिकॉल ग्राफ़ और वर्गीकरण उपयोग के मामलों के लिए एक आरओसी वक्र भी लॉग कर सकते हैं। run.log_confusion_matrix, run.log_precision_recall, तथा run.log_roc_curve कार्य, क्रमशः।

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

1. प्रयोग के रन और लॉगिंग पैरामीटर बनाना: हम पहले एक नया प्रयोग बनाएंगे, इस प्रयोग के लिए एक नया रन शुरू करेंगे और इसके लिए पैरामीटर लॉग करेंगे।
2. लॉगिंग मॉडल प्रदर्शन मेट्रिक्स:हम मॉडल प्रदर्शन मेट्रिक्स लॉग करेंगे और मीट्रिक ग्राफ प्लॉट करेंगे।
3. तुलना मॉडल चलता है: हम मॉडल हाइपरपैरामीटर के अनुसार अलग-अलग मॉडल रन की तुलना करेंगे। हम चर्चा करेंगे कि उन रनों की तुलना कैसे करें और सर्वोत्तम मॉडल का चयन करने के लिए SageMaker प्रयोगों का उपयोग कैसे करें।
4. SageMaker जॉब्स से चल रहे प्रयोग: हम इसका एक उदाहरण भी देंगे कि कैसे अपने प्रयोग के संदर्भ को SageMaker प्रोसेसिंग, प्रशिक्षण या बैच ट्रांसफ़ॉर्म जॉब के साथ स्वचालित रूप से साझा किया जाए। यह आपको इसके साथ अपने रन संदर्भ को स्वचालित रूप से पुनर्प्राप्त करने की अनुमति देता है load_run अपनी नौकरी के अंदर कार्य करें।
5. सेजमेकर स्पष्ट रिपोर्ट को एकीकृत करना: हम प्रदर्शित करेंगे कि अब हम कैसे एकीकृत कर सकते हैं SageMaker स्पष्ट करें पूर्वाग्रह और व्याख्यात्मकता आपकी प्रशिक्षित मॉडल रिपोर्ट के साथ एक ही दृश्य में रिपोर्ट करती है।

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

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

• SageMaker स्टूडियो डोमेन
• सेजमेकर पूर्ण पहुंच के साथ सेजमेकर स्टूडियो उपयोगकर्ता प्रोफ़ाइल
• कम से कम एक के साथ एक सेजमेकर स्टूडियो नोटबुक ml.t3.medium उदाहरण के प्रकार

यदि आपके पास SageMaker डोमेन और उपयोगकर्ता प्रोफ़ाइल उपलब्ध नहीं है, तो आप इसका उपयोग करके एक बना सकते हैं त्वरित सेटअप गाइड.

लॉगिंग पैरामीटर

इस अभ्यास के लिए हम प्रयोग करेंगे मशाल, एक PyTorch पैकेज जो कंप्यूटर दृष्टि के लिए लोकप्रिय डेटासेट, मॉडल आर्किटेक्चर और सामान्य छवि परिवर्तन प्रदान करता है। सेजमेकर स्टूडियो एक सेट प्रदान करता है डॉकटर चित्र सामान्य डेटा विज्ञान उपयोग मामलों के लिए जो Amazon ECR में उपलब्ध कराए जाते हैं। PyTorch के लिए, आपके पास CPU या GPU प्रशिक्षण के लिए अनुकूलित छवियों का चयन करने का विकल्प होता है। इस उदाहरण के लिए, हम छवि का चयन करेंगे PyTorch 1.12 Python 3.8 CPU Optimized और Python 3 कर्नेल। नीचे वर्णित उदाहरण SageMaker प्रयोगों की कार्यप्रणाली पर ध्यान केंद्रित करेंगे और कोड पूर्ण नहीं हैं।

के साथ डेटा डाउनलोड करते हैं torchvision सैजमेकर प्रयोगों के साथ पैरामीटर के रूप में ट्रेन और परीक्षण डेटासेट के लिए डेटा नमूनों की संख्या को पैकेज करें और ट्रैक करें। इस उदाहरण के लिए, मान लीजिए train_set और test_set जैसा कि पहले ही डाउनलोड हो चुका है torchvision डेटासेट

from sagemaker.session import Session
from sagemaker.experiments.run import Run
import os

# create an experiment and start a new run
experiment_name = "local-experiment-example"
run_name = "experiment-run"

with Run(experiment_name=experiment_name, sagemaker_session=Session(), run_name=run_name) as run:
    run.log_parameters({
        "num_train_samples": len(train_set.data),
        "num_test_samples": len(test_set.data)
    })
    for f in os.listdir(train_set.raw_folder):
        print("Logging", train_set.raw_folder+"/"+f)
        run.log_file(train_set.raw_folder+"/"+f, name=f, is_output=False)

इस उदाहरण में, हम उपयोग करते हैं run.log_parameters ट्रेन की संख्या लॉग करने और डेटा नमूनों का परीक्षण करने के लिए और run.log_file कच्चे डेटासेट को Amazon S3 पर अपलोड करने और उन्हें हमारे प्रयोग में इनपुट के रूप में लॉग करने के लिए।

एक मॉडल और लॉगिंग मॉडल मेट्रिक्स का प्रशिक्षण

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

हम उपयोग कर सकते हैं load_run हमारे पिछले रन को लोड करने के लिए कार्य करें और हमारे मॉडल प्रशिक्षण को लॉग करने के लिए इसका उपयोग करें

with load_run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=Session()) as run:
    train_model(
        run=run,
        train_set=train_set,
        test_set=test_set,
        epochs=10,
        hidden_channels=5,
        optimizer="adam"
    )

हम तब उपयोग कर सकते हैं run.log_parameter और run.log_parameters हमारे रन में एक या एकाधिक मॉडल पैरामीटर लॉग करने के लिए।

# log the parameters of your model
run.log_parameter("device", "cpu")
run.log_parameters({
    "data_dir": data_dir,
    "optimizer": optimizer,
    "epochs": epochs,
    "hidden_channels": hidden_channels
})

और हम प्रयोग कर सकते हैं run.log_metric हमारे प्रयोग में प्रदर्शन मेट्रिक्स लॉग करने के लिए।

run.log_metric(name=metric_type+":loss", value=loss, step=epoch)
run.log_metric(name=metric_type+":accuracy", value=accuracy, step=epoch)

वर्गीकरण मॉडल के लिए, आप भी उपयोग कर सकते हैं run.log_confusion_matrix, run.log_precision_recall, तथा run.log_roc_curve, स्वचालित रूप से भ्रम मैट्रिक्स, सटीक रिकॉल ग्राफ और अपने मॉडल के आरओसी वक्र को प्लॉट करने के लिए। चूंकि हमारा मॉडल एक मल्टीक्लास वर्गीकरण समस्या को हल करता है, आइए इसके लिए केवल भ्रम मैट्रिक्स लॉग करें।

# log confusion matrix
with torch.no_grad():
    for data, target in test_loader:
        data, target = data.to(device), target.to(device)
        output = model(data)
        pred = output.max(1, keepdim=True)[1] 
        run.log_confusion_matrix(target, pred, "Confusion-Matrix-Test-Data")

हमारे रन विवरण को देखते हुए, अब हम जनरेट किए गए मेट्रिक्स को देख सकते हैं जैसा कि नीचे स्क्रीनशॉट में दिखाया गया है:

रन विवरण पेज मेट्रिक्स के बारे में और जानकारी प्रदान करता है।

और नए मॉडल पैरामीटर को पैरामीटर ओवरव्यू पेज पर ट्रैक किया जाता है।

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

कई मॉडल मापदंडों की तुलना करना

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

# define the list of parameters to train the model with
num_hidden_channel_param = [5, 10, 20]
optimizer_param = ["adam", "sgd"]
run_id = 0
# train the model using SageMaker Experiments to track the model parameters, 
# metrics and performance
sm_session = Session()
for i, num_hidden_channel in enumerate(num_hidden_channel_param):
    for k, optimizer in enumerate(optimizer_param):
        run_id += 1
        run_name = "experiment-run-"+str(run_id)
        print(run_name)
        print(f"Training model with: {num_hidden_channel} hidden channels and {optimizer} as optimizer")
        # Defining an experiment run for each model training run
        with Run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=sm_session) as run:
            train_model(
                run=run, 
                train_set=train_set,
                test_set=test_set,
                epochs=10, 
                hidden_channels=num_hidden_channel,
                optimizer=optimizer
            )

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

सैजमेकर प्रशिक्षण, प्रसंस्करण और बैच परिवर्तन नौकरियों के साथ सैजमेकर प्रयोगों का उपयोग करना

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

नीचे दिया गया उदाहरण SageMaker प्रयोगों की कार्यात्मकताओं पर केंद्रित होगा और कोड पूर्ण नहीं है।

from sagemaker.pytorch import PyTorch
from sagemaker.experiments.run import Run
from sagemaker.session import Session
from sagemaker import get_execution_role
role = get_execution_role()

# set new experiment configuration
exp_name = "training-job-experiment-example"
run_name = "experiment-run-example"

# Start training job with experiment setting
with Run(experiment_name=exp_name, run_name=run_name, sagemaker_session=Session()) as run:
    est = PyTorch(
        entry_point="",
        dependencies=[""],
        role=role,
        model_dir=False,
        framework_version="1.12",
        py_version="py38",
        instance_type='ml.c5.xlarge',
        instance_count=1,
            hyperparameters={
            "epochs": 10,
            "hidden_channels":5,
            "optimizer": "adam",
        },
        keep_alive_period_in_seconds=3600
    )
    
    est.fit()

हमारी मॉडल स्क्रिप्ट फ़ाइल में, हम उपयोग करके रन संदर्भ प्राप्त कर सकते हैं load_run(). SageMaker प्रसंस्करण और प्रशिक्षण नौकरियों में, हमें कॉन्फ़िगरेशन लोड करने के लिए प्रयोग कॉन्फ़िगरेशन प्रदान करने की आवश्यकता नहीं है। बैच परिवर्तन कार्य के लिए, हमें प्रदान करने की आवश्यकता है experiment_name और run_name प्रयोग के विन्यास को लोड करने के लिए।

with load_run() as run:
    run.log_parameters({...})
    train_model(run, ...)

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

नया सैजमेकर एक्सपेरिमेंट्स एसडीके भी परीक्षण और परीक्षण घटकों की अवधारणाओं का उपयोग करके पिछले संस्करण के साथ पश्चगामी संगतता सुनिश्चित करता है। पिछले SageMaker प्रयोग संस्करण का उपयोग करके ट्रिगर किया गया कोई भी प्रयोग प्रयोगों के विश्लेषण के लिए स्वचालित रूप से नए UI में उपलब्ध कराया जाएगा।

SageMaker स्पष्टीकरण और मॉडल प्रशिक्षण रिपोर्ट को एकीकृत करना

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

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

with Run(
    experiment_name='clarify-experiment',
    run_name="joint-run",
    sagemaker_session=sagemaker_session,
) as run:
    xgb.fit({"train": train_input}, logs=False)
    clarify_processor.run_bias(
        data_config=bias_data_config,
        bias_config=bias_config,
        model_config=model_config,
        model_predicted_label_config=predictions_config,
        pre_training_methods="all",
        post_training_methods="all",
    )
    clarify_processor.run_explainability(
        data_config=explainability_data_config,
        model_config=model_config,
        explainability_config=shap_config,
    )

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

निष्कर्ष

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

हम आपको नई प्रयोग कार्यक्षमताओं को आज़माने और इससे जुड़ने के लिए प्रोत्साहित करते हैं मशीन लर्निंग और एआई समुदाय यदि आपके कोई प्रश्न या प्रतिक्रिया है!

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

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

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

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

अभिषेक अग्रवाल Amazon SageMaker के वरिष्ठ उत्पाद प्रबंधक हैं। उन्हें ग्राहकों के साथ काम करने और मशीन लर्निंग को अधिक सुलभ बनाने का शौक है। अपने खाली समय में, अभिषेक को पेंटिंग करना, बाइक चलाना और नवीन तकनीकों के बारे में सीखना अच्छा लगता है।

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