จัดระเบียบเส้นทางการเรียนรู้ของเครื่องด้วย Amazon SageMaker Experiments และ Amazon SageMaker Pipelines

กระบวนการสร้างแบบจำลองแมชชีนเลิร์นนิง (ML) จะทำซ้ำจนกว่าคุณจะพบโมเดลที่เป็นตัวเลือกที่ทำงานได้ดีและพร้อมที่จะปรับใช้ ในขณะที่นักวิทยาศาสตร์ข้อมูลทำซ้ำผ่านกระบวนการนั้น พวกเขาต้องการวิธีการที่เชื่อถือได้เพื่อติดตามการทดลองอย่างง่ายดาย เพื่อทำความเข้าใจว่าแต่ละรุ่นถูกสร้างขึ้นอย่างไรและทำงานอย่างไร

อเมซอน SageMaker ช่วยให้ทีมใช้ประโยชน์จากคุณลักษณะที่หลากหลายเพื่อจัดเตรียม สร้าง ฝึกอบรม ปรับใช้ และตรวจสอบโมเดล ML ได้อย่างรวดเร็ว ท่อส่ง Amazon SageMaker ให้กระบวนการที่ทำซ้ำได้สำหรับการวนซ้ำผ่านกิจกรรมการสร้างแบบจำลอง และรวมเข้ากับ การทดลอง Amazon SageMaker. ตามค่าเริ่มต้น ไปป์ไลน์ของ SageMaker ทุกรายการจะเชื่อมโยงกับการทดสอบ และทุกการทำงานของไปป์ไลน์นั้นจะถูกติดตามเป็นการทดลองใช้ในการทดสอบนั้น จากนั้นการวนซ้ำของคุณจะถูกติดตามโดยอัตโนมัติโดยไม่มีขั้นตอนเพิ่มเติม

ในโพสต์นี้ เราจะพิจารณาถึงแรงจูงใจเบื้องหลังการมีกระบวนการอัตโนมัติในการติดตามการทดสอบด้วย Experiments และความสามารถดั้งเดิมที่สร้างไว้ในไปป์ไลน์อย่างละเอียดยิ่งขึ้น

เหตุใดการจัดระเบียบการทดลองของคุณจึงเป็นเรื่องสำคัญ

ลองย้อนกลับไปสักครู่แล้วพยายามทำความเข้าใจว่าทำไมการจัดการทดลองสำหรับแมชชีนเลิร์นนิงจึงสำคัญ เมื่อนักวิทยาศาสตร์ข้อมูลเข้าใกล้ปัญหา ML ใหม่ พวกเขาต้องตอบคำถามต่างๆ มากมาย ตั้งแต่ความพร้อมใช้งานของข้อมูลไปจนถึงวิธีที่พวกเขาจะวัดประสิทธิภาพของแบบจำลอง

ในตอนเริ่มต้น กระบวนการเต็มไปด้วยความไม่แน่นอนและมีการทำซ้ำอย่างมาก ด้วยเหตุนี้ ขั้นตอนการทดลองนี้จึงสามารถสร้างแบบจำลองได้หลายแบบ โดยแต่ละแบบสร้างจากอินพุตของตนเอง (ชุดข้อมูล สคริปต์การฝึก และไฮเปอร์พารามิเตอร์) และสร้างผลลัพธ์ของตนเอง (สิ่งประดิษฐ์ของแบบจำลองและเมตริกการประเมิน) ความท้าทายคือการติดตามอินพุตและเอาต์พุตทั้งหมดของการวนซ้ำแต่ละครั้ง

โดยทั่วไปแล้ว นักวิทยาศาสตร์ด้านข้อมูลจะฝึกโมเดลรุ่นต่างๆ มากมาย จนกว่าจะพบการผสมผสานของการแปลงข้อมูล อัลกอริธึม และพารามิเตอร์ไฮเปอร์พารามิเตอร์ซึ่งส่งผลให้โมเดลมีประสิทธิภาพดีที่สุด ชุดค่าผสมที่ไม่ซ้ำกันแต่ละชุดนี้เป็นการทดสอบเดียว ด้วยบันทึกที่ตรวจสอบย้อนกลับได้ของอินพุต อัลกอริทึม และพารามิเตอร์ไฮเปอร์พารามิเตอร์ที่ใช้โดยการทดลองนั้น ทีมวิทยาศาสตร์ข้อมูลสามารถค้นหาขั้นตอนที่ทำซ้ำได้ง่าย

การมีกระบวนการอัตโนมัติในการติดตามการทดลองช่วยเพิ่มความสามารถในการทำซ้ำและปรับใช้รุ่นเฉพาะรุ่นที่มีประสิทธิภาพดี การผสานการทำงานแบบเนทีฟของ Pipelines กับ Experiments ทำให้ง่ายต่อการติดตามและจัดการการทดลองโดยอัตโนมัติในการรันไปป์ไลน์

ประโยชน์ของการทดลอง SageMaker

SageMaker Experiments ช่วยให้นักวิทยาศาสตร์ด้านข้อมูลที่จัดระเบียบ ติดตาม เปรียบเทียบ และประเมินการทำซ้ำการฝึกอบรมของตนได้

มาเริ่มกันที่ภาพรวมของสิ่งที่คุณสามารถทำได้ด้วยการทดสอบก่อน:

• จัดการทดลอง – โครงสร้างการทดลองการทดลองกับเอนทิตีระดับบนสุดที่เรียกว่า an การทดลอง ที่มีชุดของ การทดลอง. การทดลองแต่ละครั้งประกอบด้วยชุดของขั้นตอนที่เรียกว่า ส่วนประกอบทดลอง. องค์ประกอบการทดลองใช้แต่ละส่วนเป็นการผสมผสานระหว่างชุดข้อมูล อัลกอริธึม และพารามิเตอร์ คุณสามารถนึกภาพการทดลองเป็นโฟลเดอร์ระดับบนสุดสำหรับการจัดระเบียบสมมติฐานของคุณ การทดลองใช้งานของคุณเป็นโฟลเดอร์ย่อยสำหรับการทดสอบแต่ละกลุ่ม และส่วนประกอบการทดลองใช้ของคุณเป็นไฟล์สำหรับอินสแตนซ์ของการทดสอบแต่ละครั้ง
• ติดตามการทดลอง – การทดลองช่วยให้นักวิทยาศาสตร์ข้อมูลสามารถติดตามการทดลองได้ มอบความเป็นไปได้ในการกำหนดงาน SageMaker ให้กับการทดลองใช้โดยอัตโนมัติผ่านการกำหนดค่าอย่างง่าย และผ่าน SDK การติดตาม
• เปรียบเทียบและประเมินการทดลอง – การรวมการทดลองกับ สตูดิโอ Amazon SageMaker ทำให้ง่ายต่อการสร้างภาพข้อมูลและเปรียบเทียบการทดลองต่างๆ คุณยังสามารถเข้าถึงข้อมูลการทดลองใช้ผ่าน Python SDK เพื่อสร้างการแสดงภาพของคุณเองโดยใช้ไลบรารีการพล็อตที่คุณต้องการ

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ Experiments API และ SDK เราขอแนะนำเอกสารต่อไปนี้: สร้างการทดลอง และ Amazon SageMaker Experiments Python SDK

หากคุณต้องการดำน้ำให้ลึกยิ่งขึ้น เราขอแนะนำให้คุณดู amazon-sagemaker-examples/sagemaker-experiments พื้นที่เก็บข้อมูล GitHub สำหรับตัวอย่างเพิ่มเติม

การบูรณาการระหว่างไปป์ไลน์และการทดลอง

ไปป์ไลน์การสร้างแบบจำลองที่เป็นส่วนหนึ่งของไปป์ไลน์สร้างขึ้นตามวัตถุประสงค์สำหรับ ML และช่วยให้คุณสามารถจัดการงานสร้างโมเดลของคุณโดยใช้เครื่องมือไปป์ไลน์ที่รวมการผสานรวมดั้งเดิมกับฟีเจอร์ SageMaker อื่นๆ รวมถึงความยืดหยุ่นในการขยายไปป์ไลน์ของคุณด้วยขั้นตอนที่ทำงานนอก SageMaker . แต่ละขั้นตอนจะกำหนดการดำเนินการที่ไปป์ไลน์ดำเนินการ การพึ่งพาระหว่างขั้นตอนถูกกำหนดโดยกราฟ acyclic โดยตรง (DAG) ที่สร้างขึ้นโดยใช้ Pipelines Python SDK คุณสามารถสร้างไปป์ไลน์ SageMaker โดยทางโปรแกรมผ่าน SDK เดียวกัน หลังจากปรับใช้ไปป์ไลน์แล้ว คุณสามารถเลือกแสดงภาพเวิร์กโฟลว์ภายใน Studio ได้

ไปป์ไลน์ผสานรวมกับการทดสอบโดยอัตโนมัติโดยการสร้างการทดสอบและการทดลองใช้ทุกครั้งโดยอัตโนมัติ ไปป์ไลน์จะสร้างการทดสอบและการทดลองใช้โดยอัตโนมัติสำหรับการรันไปป์ไลน์ทุกครั้งก่อนที่จะดำเนินการตามขั้นตอน เว้นแต่จะระบุอินพุตเหล่านี้อย่างใดอย่างหนึ่งหรือทั้งสองอย่าง ขณะใช้งาน SageMaker ของไปป์ไลน์ ไปป์ไลน์จะเชื่อมโยงการทดลองใช้งานกับการทดสอบ และเชื่อมโยงกับการทดลองใช้ทุกองค์ประกอบการทดลองใช้ที่สร้างขึ้นโดยงาน การระบุการทดสอบหรือการทดลองใช้โดยทางโปรแกรมทำให้คุณสามารถปรับแต่งวิธีจัดระเบียบการทดสอบของคุณได้

เวิร์กโฟลว์ที่เรานำเสนอในตัวอย่างนี้ประกอบด้วยชุดของขั้นตอน: ขั้นตอนก่อนการประมวลผลเพื่อแยกชุดข้อมูลอินพุตของเราออกเป็นชุดข้อมูลฝึก ทดสอบ และการตรวจสอบ ขั้นตอนการปรับแต่งเพื่อปรับแต่งไฮเปอร์พารามิเตอร์ของเราและเริ่มต้นงานการฝึกอบรมเพื่อฝึกแบบจำลองโดยใช้ อัลกอริทึมในตัว XGBoost; และสุดท้ายคือขั้นตอนการสร้างแบบจำลองเพื่อสร้างแบบจำลอง SageMaker จากสิ่งประดิษฐ์แบบจำลองที่ได้รับการฝึกฝนอย่างดีที่สุด ไปป์ไลน์ยังมีบริการที่รองรับมากมาย ประเภทขั้นตอน นอกเหนือที่กล่าวถึงในโพสต์นี้ เรายังแสดงให้เห็นวิธีที่คุณสามารถติดตามเวิร์กโฟลว์ไปป์ไลน์ของคุณ และสร้างตัวชี้วัดและแผนภูมิเปรียบเทียบ นอกจากนี้ เรายังแสดงวิธีเชื่อมโยงการทดลองใช้ใหม่ที่สร้างขึ้นกับการทดลองที่มีอยู่ซึ่งอาจสร้างขึ้นก่อนกำหนดไปป์ไลน์

รหัสไปป์ไลน์ SageMaker

คุณสามารถตรวจสอบและดาวน์โหลดสมุดบันทึกจาก พื้นที่เก็บข้อมูล GitHub ที่เกี่ยวข้องกับโพสต์นี้ เราดูที่โค้ดเฉพาะของไปป์ไลน์เพื่อทำความเข้าใจให้ดีขึ้น

ไปป์ไลน์ช่วยให้คุณส่งผ่านพารามิเตอร์ ณ รันไทม์ได้ ที่นี่ เรากำหนดประเภทและจำนวนอินสแตนซ์การประมวลผลและการฝึกอบรม ณ รันไทม์ด้วยค่าเริ่มต้นที่ตั้งไว้ล่วงหน้า:

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ซึ่งเป็น ID เฉพาะของการรันไปป์ไลน์ ตัวอย่างเช่น เราสามารถสร้างคีย์เฉพาะสำหรับจัดเก็บชุดข้อมูลเอาต์พุตใน บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) ที่ผูกไว้กับการเรียกใช้ไปป์ไลน์เฉพาะ สำหรับรายการตัวแปรทั้งหมด โปรดดูที่ ตัวแปรการดำเนินการ.

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. การเลือกตัววัดหนึ่งตัวให้เป็นตัวชี้วัดวัตถุประสงค์จะบอกตัวปรับแต่ง (อินสแตนซ์ที่รันงานการปรับแต่งไฮเปอร์พารามิเตอร์) ว่าคุณจะประเมินงานการฝึกอบรมตามตัวชี้วัดเฉพาะนี้ จูนเนอร์จะส่งกลับชุดค่าผสมที่ดีที่สุดโดยพิจารณาจากค่าที่ดีที่สุดสำหรับเมตริกวัตถุประสงค์นี้ ซึ่งหมายถึงชุดค่าผสมที่ดีที่สุดที่จะลดค่าความผิดพลาดกำลังสองของรากที่ดีที่สุด (RMSE)

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เราจัดอันดับ 50 เวอร์ชันที่มีประสิทธิภาพสูงสุดของแบบจำลองสิ่งประดิษฐ์ S3 URI และแยกเฉพาะเวอร์ชันที่มีประสิทธิภาพดีที่สุดเท่านั้น (เราระบุ k=0 เพื่อสิ่งที่ดีที่สุด) เพื่อสร้างแบบจำลอง SageMaker

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

เมื่อไปป์ไลน์ทำงาน จะสร้างส่วนประกอบทดลองสำหรับงานปรับแต่งไฮเปอร์พารามิเตอร์แต่ละงานและงาน SageMaker แต่ละงานที่สร้างโดยขั้นตอนไปป์ไลน์

คุณสามารถกำหนดค่าการรวมไปป์ไลน์กับ Experiments เพิ่มเติมได้โดยสร้าง 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],
)

ขณะนี้ท่อส่งที่เต็มเปี่ยมถูกสร้างขึ้นและพร้อมที่จะไป เราเพิ่มบทบาทการดำเนินการให้กับไปป์ไลน์และเริ่มต้น จากที่นี่ เราสามารถไปที่คอนโซล SageMaker Studio Pipelines และติดตามทุกขั้นตอนด้วยสายตา คุณยังสามารถเข้าถึงบันทึกที่เชื่อมโยงจากคอนโซลเพื่อแก้ไขจุดบกพร่องของไปป์ไลน์

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

เปรียบเทียบเมตริกสำหรับส่วนประกอบการทดลองใช้แต่ละส่วน

คุณสามารถพล็อตผลลัพธ์ของการปรับแต่งไฮเปอร์พารามิเตอร์ใน Studio หรือผ่านไลบรารีการพล็อต Python อื่นๆ เราแสดงทั้งสองวิธีในการทำเช่นนี้

สำรวจเมตริกการฝึกอบรมและการประเมินใน Studio

Studio มีส่วนต่อประสานกับผู้ใช้แบบโต้ตอบซึ่งคุณสามารถสร้างแผนการโต้ตอบได้ ขั้นตอนมีดังนี้:

1. Choose การทดลองและการทดลอง จาก แหล่งข้อมูล SageMaker ไอคอนบนแถบด้านข้างด้านซ้าย
2. เลือกการทดสอบของคุณเพื่อเปิด
3. เลือก (คลิกขวา) การทดลองใช้ที่สนใจ
4. Choose เปิดในรายการส่วนประกอบทดลอง.
5. ข่าวประชา เปลี่ยน เพื่อเลือกส่วนประกอบทดลองที่เป็นตัวแทนของงานฝึกอบรม
6. Choose เพิ่มแผนภูมิ.
7. Choose ชาร์ตใหม่ และปรับแต่งเพื่อพล็อตเมตริกที่รวบรวมไว้ที่คุณต้องการวิเคราะห์ สำหรับกรณีการใช้งานของเรา ให้เลือกดังต่อไปนี้:
   1. สำหรับ ประเภทข้อมูล¸ เลือก สรุปสถิติ.
   2. สำหรับ ชนิดแผนภูมิ¸ เลือก พล็อตกระจาย.
   3. สำหรับ แกน Xเลือก lambda.
   4. สำหรับ แกน Yเลือก validation:rmse_last.

แผนภูมิใหม่จะปรากฏที่ด้านล่างของหน้าต่าง โดยมีป้ายกำกับว่า '8'

คุณสามารถรวมงานฝึกอบรมมากหรือน้อยได้โดยกด เปลี่ยน และเลือกไอคอนรูปตาเพื่อประสบการณ์การโต้ตอบที่มากขึ้น

การวิเคราะห์ด้วย SageMaker Experiments

เมื่อการดำเนินการไปป์ไลน์เสร็จสมบูรณ์ เราจะเห็นภาพได้อย่างรวดเร็วว่ารูปแบบต่างๆ เปรียบเทียบกันอย่างไรในแง่ของเมตริกที่รวบรวมระหว่างการฝึกอบรม ก่อนหน้านี้ เราได้ส่งออกตัวชี้วัดการทดลองทั้งหมดไปยัง a นุ่น DataFrame การใช้ ExperimentAnalytics. เราสามารถทำซ้ำพล็อตที่ได้รับใน Studio โดยใช้ไลบรารี Matplotlib

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

สรุป

การผสานรวมแบบเนทีฟระหว่าง SageMaker Pipelines และ SageMaker Experiments ช่วยให้นักวิทยาศาสตร์ข้อมูลสามารถจัดระเบียบ ติดตาม และแสดงภาพการทดลองโดยอัตโนมัติในระหว่างกิจกรรมการพัฒนาแบบจำลอง คุณสามารถสร้างการทดลองเพื่อจัดระเบียบงานการพัฒนาแบบจำลองทั้งหมดของคุณได้ เช่น:

• กรณีการใช้งานทางธุรกิจที่คุณกำลังพูดถึง เช่น การสร้างการทดลองเพื่อคาดการณ์การเลิกราของลูกค้า
• การทดลองที่ทีมวิทยาศาสตร์ข้อมูลเป็นเจ้าของเกี่ยวกับการวิเคราะห์การตลาด เช่น
• วิทยาศาสตร์ข้อมูลเฉพาะและโครงการ ML

ในโพสต์นี้ เราเจาะลึกเข้าไปในไปป์ไลน์เพื่อแสดงให้เห็นว่าคุณสามารถใช้มันควบคู่ไปกับการทดลองเพื่อจัดระเบียบเวิร์กโฟลว์แบบอัตโนมัติตั้งแต่ต้นทางถึงปลายทางได้อย่างไร

ในขั้นตอนต่อไป คุณสามารถใช้คุณลักษณะ SageMaker ทั้งสามนี้ – Studio, Experiments และ Pipelines – สำหรับโครงการ ML ถัดไปของคุณ

การอ่านที่แนะนำ

เกี่ยวกับผู้แต่ง

เปาโล ดิ ฟรานเชสโก้ เป็นสถาปนิกโซลูชันที่ AWS เขามีประสบการณ์ด้านวิศวกรรมโทรคมนาคมและซอฟต์แวร์ เขาหลงใหลเกี่ยวกับแมชชีนเลิร์นนิงและกำลังมุ่งเน้นไปที่การใช้ประสบการณ์ของเขาเพื่อช่วยให้ลูกค้าบรรลุเป้าหมายใน AWS โดยเฉพาะอย่างยิ่งในการอภิปรายเกี่ยวกับ MLOps นอกเวลางาน เขาชอบเล่นฟุตบอลและอ่านหนังสือ

มาริโอ บูร์กอ็อง เป็น Senior Partner Solutions Architect for AWS, ผู้เชี่ยวชาญ AI/ML และผู้นำด้านเทคโนโลยีระดับโลกสำหรับ MLOps เขาทำงานร่วมกับลูกค้าองค์กรและคู่ค้าในการปรับใช้โซลูชัน AI ในระบบคลาวด์ เขามีประสบการณ์มากกว่า 30 ปีในการทำแมชชีนเลิร์นนิงและ AI ในบริษัทสตาร์ทอัพและในองค์กรต่างๆ โดยเริ่มจากการสร้างระบบแมชชีนเลิร์นนิงเชิงพาณิชย์ระบบแรกสำหรับบิ๊กดาต้า มาริโอใช้เวลาว่างเล่นกับเทอร์วูเรนชาวเบลเยียมสามคน ทำอาหารเย็นให้ครอบครัว และเรียนรู้เกี่ยวกับคณิตศาสตร์และจักรวาลวิทยา

คณปาถี กฤษณมัวร์ธี เป็นสถาปนิกอาวุโส ML Solutions ที่ AWS Ganapathi ให้คำแนะนำที่กำหนดไว้สำหรับการเริ่มต้นและลูกค้าระดับองค์กรที่ช่วยพวกเขาในการออกแบบและปรับใช้แอปพลิเคชันระบบคลาวด์ในวงกว้าง เขาเชี่ยวชาญด้านแมชชีนเลิร์นนิงและมุ่งเน้นที่การช่วยเหลือลูกค้าให้ใช้ประโยชน์จาก AI/ML เพื่อผลลัพธ์ทางธุรกิจ เมื่อไม่ได้ทำงาน เขาชอบออกสำรวจกลางแจ้งและฟังเพลง

วาเลอรี สุนทรกิจ เป็นสถาปนิกโซลูชันสำหรับ AWS ซึ่งทำงานในอุตสาหกรรมเกมและกับคู่ค้าที่ปรับใช้โซลูชัน AI เธอตั้งเป้าที่จะสร้างอาชีพของเธอเกี่ยวกับ Computer Vision ในช่วงเวลาว่างของเธอ วาเลอรีใช้จ่ายเพื่อท่องเที่ยว ค้นพบร้านอาหารใหม่ๆ และเปลี่ยนการตกแต่งภายในบ้านของเธอ