Atur perjalanan pembelajaran mesin Anda dengan Amazon SageMaker Experiments dan Amazon SageMaker Pipelines

Proses pembuatan model machine learning (ML) bersifat iteratif hingga Anda menemukan kandidat model yang berperforma baik dan siap untuk di-deploy. Saat ilmuwan data mengulangi proses itu, mereka membutuhkan metode yang andal untuk melacak eksperimen dengan mudah guna memahami bagaimana setiap versi model dibuat dan bagaimana kinerjanya.

Amazon SageMaker memungkinkan tim memanfaatkan berbagai fitur untuk mempersiapkan, membangun, melatih, menerapkan, dan memantau model ML dengan cepat. Pipa Amazon SageMaker menyediakan proses berulang untuk iterasi melalui aktivitas pembuatan model, dan terintegrasi dengan Eksperimen Amazon SageMaker. Secara default, setiap pipeline SageMaker dikaitkan dengan eksperimen, dan setiap proses pipeline tersebut dilacak sebagai uji coba dalam eksperimen tersebut. Kemudian iterasi Anda dilacak secara otomatis tanpa langkah tambahan apa pun.

Dalam postingan ini, kita melihat lebih dekat motivasi di balik memiliki proses otomatis untuk melacak eksperimen dengan Eksperimen dan kemampuan asli yang ada di dalam Pipeline.

Mengapa penting untuk menjaga agar eksperimen Anda tetap teratur?

Mari kita mundur sejenak dan mencoba memahami mengapa eksperimen perlu diatur untuk pembelajaran mesin. Ketika ilmuwan data mendekati masalah ML baru, mereka harus menjawab banyak pertanyaan berbeda, mulai dari ketersediaan data hingga bagaimana mereka akan mengukur kinerja model.

Pada awalnya, prosesnya penuh dengan ketidakpastian dan sangat berulang. Hasilnya, fase eksperimen ini dapat menghasilkan beberapa model, masing-masing dibuat dari inputnya sendiri (set data, skrip pelatihan, dan hyperparameter) dan menghasilkan outputnya sendiri (artefak model dan metrik evaluasi). Tantangannya kemudian adalah untuk melacak semua input dan output dari setiap iterasi.

Ilmuwan data biasanya melatih banyak versi model yang berbeda hingga mereka menemukan kombinasi transformasi data, algoritme, dan hyperparameter yang menghasilkan versi model dengan performa terbaik. Masing-masing kombinasi unik ini adalah eksperimen tunggal. Dengan catatan input, algoritme, dan hyperparameter yang dapat dilacak yang digunakan oleh uji coba tersebut, tim ilmu data dapat dengan mudah mereproduksi langkah-langkah mereka.

Memiliki proses otomatis untuk melacak eksperimen meningkatkan kemampuan untuk mereproduksi serta menerapkan versi model tertentu yang berperforma baik. Integrasi asli Pipeline dengan Eksperimen memudahkan pelacakan dan pengelolaan eksperimen secara otomatis di seluruh proses pipeline.

Manfaat Eksperimen SageMaker

Eksperimen SageMaker memungkinkan ilmuwan data mengatur, melacak, membandingkan, dan mengevaluasi iterasi pelatihan mereka.

Mari kita mulai terlebih dahulu dengan ikhtisar tentang apa yang dapat Anda lakukan dengan Eksperimen:

• Mengatur percobaan- Eksperimen menyusun eksperimen dengan entitas tingkat atas yang disebut an eksperimen yang berisi satu set uji. Setiap percobaan berisi serangkaian langkah yang disebut komponen percobaan. Setiap komponen percobaan merupakan kombinasi dari dataset, algoritma, dan parameter. Anda dapat membayangkan eksperimen sebagai folder tingkat atas untuk mengatur hipotesis Anda, uji coba Anda sebagai subfolder untuk setiap uji coba grup, dan komponen uji coba Anda sebagai file Anda untuk setiap contoh uji coba.
• Lacak eksperimen – Eksperimen memungkinkan ilmuwan data melacak eksperimen. Ini menawarkan kemungkinan untuk secara otomatis menetapkan tugas SageMaker ke uji coba melalui konfigurasi sederhana dan melalui SDK pelacakan.
• Bandingkan dan evaluasi eksperimen – Integrasi Eksperimen dengan Studio Amazon SageMaker memudahkan untuk menghasilkan visualisasi data dan membandingkan uji coba yang berbeda. Anda juga dapat mengakses data percobaan melalui Python SDK untuk menghasilkan visualisasi Anda sendiri menggunakan pustaka plot pilihan Anda.

Untuk mempelajari lebih lanjut tentang API dan SDK Eksperimen, kami merekomendasikan dokumentasi berikut: Buat Eksperimen dan Amazon SageMaker Eksperimen Python SDK.

Jika Anda ingin menyelam lebih dalam, kami sarankan untuk melihat ke dalam amazon-sagemaker-examples/sagemaker-experiments repositori GitHub untuk contoh lebih lanjut.

Integrasi antara Pipeline dan Eksperimen

Pipeline pembuatan model yang merupakan bagian dari Pipeline dibuat khusus untuk ML dan memungkinkan Anda mengatur tugas pembuatan model menggunakan alat pipeline yang menyertakan integrasi asli dengan fitur SageMaker lainnya serta fleksibilitas untuk memperluas pipeline Anda dengan langkah-langkah yang dijalankan di luar SageMaker . Setiap langkah mendefinisikan tindakan yang diambil oleh pipeline. Ketergantungan antar langkah ditentukan oleh grafik asiklik langsung (DAG) yang dibuat menggunakan Pipelines Python SDK. Anda dapat membangun saluran SageMaker secara terprogram melalui SDK yang sama. Setelah pipeline diterapkan, Anda dapat memvisualisasikan alur kerjanya secara opsional di dalam Studio.

Pipeline berintegrasi secara otomatis dengan Eksperimen dengan membuat eksperimen dan uji coba secara otomatis untuk setiap proses. Pipeline secara otomatis membuat eksperimen dan uji coba untuk setiap proses pipeline sebelum menjalankan langkah kecuali salah satu atau kedua input ini ditentukan. Saat menjalankan tugas SageMaker pipeline, pipeline mengaitkan uji coba dengan eksperimen, dan mengaitkan ke uji coba setiap komponen uji coba yang dibuat oleh tugas. Menentukan eksperimen atau uji coba Anda sendiri secara terprogram memungkinkan Anda menyempurnakan cara mengatur eksperimen.

Alur kerja yang kami sajikan dalam contoh ini terdiri dari serangkaian langkah: langkah prapemrosesan untuk membagi set data input kami menjadi set data pelatihan, pengujian, dan validasi; langkah penyetelan untuk menyetel hyperparameter kami dan memulai pekerjaan pelatihan untuk melatih model menggunakan Algoritma bawaan XGBoost; dan terakhir langkah model untuk membuat model SageMaker dari artefak model terlatih terbaik. Pipelines juga menawarkan beberapa yang didukung secara native jenis langkah di luar apa yang dibahas dalam posting ini. Kami juga mengilustrasikan bagaimana Anda dapat melacak alur kerja saluran Anda dan menghasilkan metrik dan bagan perbandingan. Selanjutnya, kami menunjukkan cara mengaitkan uji coba baru yang dihasilkan dengan eksperimen yang sudah ada yang mungkin telah dibuat sebelum pipeline ditentukan.

Kode Pipa SageMaker

Anda dapat meninjau dan mengunduh buku catatan dari Repositori GitHub terkait dengan posting ini. Kami melihat kode khusus Pipelines untuk memahaminya dengan lebih baik.

Pipeline memungkinkan Anda untuk melewatkan parameter pada saat run time. Di sini kami mendefinisikan jenis dan jumlah instans pemrosesan dan pelatihan pada waktu proses dengan default yang telah ditetapkan:

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

Selanjutnya, kami menyiapkan skrip pemrosesan yang mengunduh dan membagi set data input menjadi bagian pelatihan, pengujian, dan validasi. Kita gunakan SKLearnProcessor untuk menjalankan langkah prapemrosesan ini. Untuk melakukannya, kami mendefinisikan objek prosesor dengan jenis dan jumlah instans yang diperlukan untuk menjalankan pekerjaan pemrosesan.

Pipeline memungkinkan kita untuk mencapai pembuatan versi data dengan cara terprogram dengan menggunakan variabel khusus eksekusi seperti ExecutionVariables.PIPELINE_EXECUTION_ID, yang merupakan ID unik dari proses pipeline. Kita dapat, misalnya, membuat kunci unik untuk menyimpan kumpulan data keluaran di Layanan Penyimpanan Sederhana Amazon (Amazon S3) yang mengikatnya ke jalur pipa tertentu. Untuk daftar lengkap variabel, lihat Variabel Eksekusi.

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

Kemudian kita melanjutkan untuk membuat objek estimator untuk melatih model XGBoost. Kami menetapkan beberapa hyperparameter statis yang biasa digunakan dengan 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
)

Kami melakukan penyetelan hyperparameter dari model yang kami buat dengan menggunakan a ContinuousParameter kisaran untuk lambda. Memilih satu metrik untuk menjadi metrik objektif memberi tahu tuner (instance yang menjalankan tugas penyetelan hyperparameters) bahwa Anda akan mengevaluasi tugas pelatihan berdasarkan metrik khusus ini. Tuner mengembalikan kombinasi terbaik berdasarkan nilai terbaik untuk metrik objektif ini, yang berarti kombinasi terbaik yang meminimalkan kesalahan akar rata-rata kuadrat (RMSE) terbaik.

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

Langkah penyetelan menjalankan beberapa percobaan dengan tujuan menentukan model terbaik di antara rentang parameter yang diuji. Dengan metode get_top_model_s3_uri, kami memberi peringkat 50 versi berkinerja terbaik dari model artefak S3 URI dan hanya mengekstrak versi berkinerja terbaik (kami menentukan k=0 untuk yang terbaik) untuk membuat model 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"),
)

Saat pipeline berjalan, ini membuat komponen uji coba untuk setiap pekerjaan penyetelan hyperparameter dan setiap tugas SageMaker yang dibuat oleh langkah-langkah pipeline.

Anda dapat mengonfigurasi lebih lanjut integrasi pipeline dengan Eksperimen dengan membuat a PipelineExperimentConfig objek dan meneruskannya ke objek pipa. Kedua parameter tersebut menentukan nama eksperimen yang akan dibuat, dan uji coba yang akan merujuk pada keseluruhan proses pipeline.

Jika Anda ingin mengaitkan proses pipeline ke eksperimen yang ada, Anda dapat meneruskan namanya, dan Pipelines akan mengaitkan uji coba baru ke eksperimen tersebut. Anda dapat mencegah pembuatan eksperimen dan uji coba untuk pipeline yang dijalankan dengan menyetel pipeline_experiment_config untuk None.

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

Kami meneruskan jenis instans dan dihitung sebagai parameter, dan merangkai langkah-langkah sebelumnya dengan urutan sebagai berikut. Alur kerja pipa secara implisit ditentukan oleh output dari suatu langkah menjadi input dari langkah lain.

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 lengkap sekarang dibuat dan siap digunakan. Kami menambahkan peran eksekusi ke pipa dan memulainya. Dari sini, kita bisa pergi ke konsol SageMaker Studio Pipelines dan melacak setiap langkah secara visual. Anda juga dapat mengakses log tertaut dari konsol untuk men-debug pipeline.

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

Tangkapan layar sebelumnya menunjukkan jalur pipa yang berhasil dijalankan dengan warna hijau. Kami memperoleh metrik satu uji coba dari proses pipeline dengan kode berikut:

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

Bandingkan metrik untuk setiap komponen uji coba

Anda dapat memplot hasil penyetelan hyperparameter di Studio atau melalui pustaka plot Python lainnya. Kami menunjukkan kedua cara untuk melakukan ini.

Jelajahi metrik pelatihan dan evaluasi di Studio

Studio menyediakan antarmuka pengguna interaktif di mana Anda dapat menghasilkan plot interaktif. Langkah-langkahnya adalah sebagai berikut:

1. Pilih Eksperimen dan Percobaan dari Sumber daya SageMaker ikon di sidebar kiri.
2. Pilih eksperimen Anda untuk membukanya.
3. Pilih (klik kanan) trial of interest.
4. Pilih Buka dalam daftar komponen percobaan.
5. Tekan perubahan untuk memilih komponen percobaan yang mewakili pekerjaan pelatihan.
6. Pilih Tambahkan bagan.
7. Pilih Bagan baru dan sesuaikan untuk memplot kumpulan metrik yang ingin Anda analisis. Untuk kasus penggunaan kami, pilih berikut ini:
   1. Untuk Tipe dataPilih Ringkasan Statistik.
   2. Untuk Jenis grafikPilih Plot Pencar.
   3. Untuk sumbu X, pilih lambda.
   4. Untuk sumbu Y, pilih validation:rmse_last.

Bagan baru muncul di bagian bawah jendela, berlabel '8'.

Anda dapat memasukkan lebih banyak atau lebih sedikit pekerjaan pelatihan dengan menekan perubahan dan memilih ikon mata untuk pengalaman yang lebih interaktif.

Analisis dengan Eksperimen SageMaker

Ketika proses pipeline selesai, kami dapat dengan cepat memvisualisasikan bagaimana variasi model yang berbeda dibandingkan dalam hal metrik yang dikumpulkan selama pelatihan. Sebelumnya, kami mengekspor semua metrik uji coba ke a Panda DataFrame menggunakan ExperimentAnalytics. Kita dapat mereproduksi plot yang diperoleh di Studio dengan menggunakan library Matplotlib.

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

Kesimpulan

Integrasi asli antara SageMaker Pipelines dan SageMaker Experiments memungkinkan ilmuwan data untuk secara otomatis mengatur, melacak, dan memvisualisasikan eksperimen selama aktivitas pengembangan model. Anda dapat membuat eksperimen untuk mengatur semua pekerjaan pengembangan model Anda, seperti berikut ini:

• Kasus penggunaan bisnis yang Anda tangani, seperti membuat eksperimen untuk memprediksi churn pelanggan
• Eksperimen yang dimiliki oleh tim ilmu data mengenai analitik pemasaran, misalnya
• Ilmu data dan proyek ML tertentu

Dalam posting ini, kami terjun ke Pipelines untuk menunjukkan bagaimana Anda dapat menggunakannya bersama-sama dengan Eksperimen untuk mengatur alur kerja end-to-end yang sepenuhnya otomatis.

Sebagai langkah selanjutnya, Anda dapat menggunakan tiga fitur SageMaker ini – Studio, Eksperimen, dan Pipeline – untuk proyek ML Anda berikutnya.

Bacaan yang disarankan

Tentang penulis

Paolo Di Francesco adalah arsitek solusi di AWS. Dia memiliki pengalaman di bidang telekomunikasi dan rekayasa perangkat lunak. Dia bersemangat tentang pembelajaran mesin dan saat ini berfokus pada penggunaan pengalamannya untuk membantu pelanggan mencapai tujuan mereka di AWS, khususnya dalam diskusi seputar MLOps. Di luar pekerjaan, ia menikmati bermain sepak bola dan membaca.

Mario Bourgoin adalah Arsitek Solusi Mitra Senior untuk AWS, spesialis AI/ML, dan pemimpin teknologi global untuk MLOps. Dia bekerja dengan pelanggan dan mitra perusahaan yang menerapkan solusi AI di cloud. Dia memiliki lebih dari 30 tahun pengalaman melakukan pembelajaran mesin dan AI di perusahaan rintisan dan perusahaan, dimulai dengan membuat salah satu sistem pembelajaran mesin komersial pertama untuk data besar. Mario menghabiskan waktu luangnya bermain dengan tiga Tervuren Belgia, memasak makan malam untuk keluarganya, dan belajar tentang matematika dan kosmologi.

Ganapathi Krishnamoorthi adalah Arsitek Solusi ML Senior di AWS. Ganapathi memberikan panduan preskriptif kepada pelanggan startup dan perusahaan yang membantu mereka merancang dan menerapkan aplikasi cloud dalam skala besar. Dia berspesialisasi dalam pembelajaran mesin dan berfokus untuk membantu pelanggan memanfaatkan AI/ML untuk hasil bisnis mereka. Saat tidak di tempat kerja, ia senang menjelajahi alam bebas dan mendengarkan musik.

Valerie Sounthakit adalah Arsitek Solusi untuk AWS, bekerja di Industri Game dan dengan Mitra yang menerapkan solusi AI. Dia bertujuan untuk membangun karirnya di sekitar Computer Vision. Selama waktu luangnya, Valerie menghabiskannya untuk bepergian, menemukan tempat makan baru, dan mengubah interior rumahnya.