Eksperimen Amazon SageMaker generasi berikutnya – Atur, lacak, dan bandingkan pelatihan pembelajaran mesin Anda dalam skala besar

Hari ini, kami dengan senang hati mengumumkan pembaruan untuk kami Eksperimen Amazon SageMaker kemampuan Amazon SageMaker yang memungkinkan Anda mengatur, melacak, membandingkan, dan mengevaluasi eksperimen machine learning (ML) dan versi model dari lingkungan pengembangan terintegrasi (IDE) apa pun menggunakan SageMaker Python SDK atau boto3, termasuk Notebook Jupyter lokal.

Pembelajaran mesin (ML) adalah proses berulang. Saat menyelesaikan kasus penggunaan baru, ilmuwan data dan teknisi ML melakukan iterasi melalui berbagai parameter untuk menemukan konfigurasi model terbaik (alias hyperparameter) yang dapat digunakan dalam produksi untuk mengatasi tantangan bisnis yang teridentifikasi. Seiring waktu, setelah bereksperimen dengan beberapa model dan hyperparameter, menjadi sulit bagi tim ML untuk secara efisien mengelola model yang dijalankan untuk menemukan yang optimal tanpa alat untuk melacak berbagai eksperimen. Sistem pelacakan eksperimen merampingkan proses untuk membandingkan iterasi yang berbeda dan membantu menyederhanakan kolaborasi dan komunikasi dalam tim, sehingga meningkatkan produktivitas dan menghemat waktu. Hal ini dicapai dengan mengatur dan mengelola eksperimen ML dengan cara yang mudah untuk menarik kesimpulan dari eksperimen tersebut, misalnya, menemukan pelatihan yang dijalankan dengan akurasi terbaik.

Untuk mengatasi tantangan ini, SageMaker menyediakan Eksperimen SageMaker, kemampuan SageMaker yang terintegrasi penuh. Ini memberikan fleksibilitas untuk mencatat metrik model, parameter, file, artefak, bagan plot Anda dari berbagai metrik, menangkap berbagai metadata, menelusurinya, dan mendukung reproduktifitas model. Ilmuwan data dapat dengan cepat membandingkan kinerja dan hyperparameter untuk evaluasi model melalui bagan dan tabel visual. Mereka juga dapat menggunakan Eksperimen SageMaker untuk mengunduh bagan yang dibuat dan berbagi evaluasi model dengan pemangku kepentingan mereka.

Dengan pembaruan baru untuk Eksperimen SageMaker, ini sekarang menjadi bagian dari SDK SageMaker, menyederhanakan pekerjaan ilmuwan data dan menghilangkan kebutuhan untuk menginstal pustaka tambahan untuk mengelola beberapa eksekusi model. Kami memperkenalkan konsep inti baru berikut:

• Percobaan: Kumpulan lari yang dikelompokkan bersama. Eksperimen mencakup proses untuk beberapa jenis yang dapat dimulai dari mana saja menggunakan SageMaker Python SDK.
• Run: Setiap langkah eksekusi dari proses pelatihan model. Run terdiri dari semua input, parameter, konfigurasi, dan hasil untuk satu iterasi pelatihan model. Parameter dan metrik khusus dapat dicatat menggunakan log_parameter, log_parameters, dan log_metric fungsi. Input dan output kustom dapat dicatat menggunakan log_file fungsi.

Konsep-konsep yang dilaksanakan sebagai bagian dari a Run kelas tersedia dari IDE apa pun tempat SageMaker Python SDK diinstal. Untuk Pelatihan, Pemrosesan, dan SageMaker

Transform Job, Proses Eksperimen SageMaker secara otomatis diteruskan ke tugas jika tugas dipanggil dalam konteks proses. Anda dapat memulihkan objek yang dijalankan menggunakan load_run() dari pekerjaan Anda. Akhirnya, dengan integrasi fungsionalitas baru, ilmuwan data juga dapat secara otomatis mencatat matriks kebingungan, grafik presisi dan penarikan kembali, dan kurva ROC untuk kasus penggunaan klasifikasi menggunakan run.log_confusion_matrix, run.log_precision_recall, dan run.log_roc_curve fungsi, masing-masing.

Dalam postingan blog ini, kami akan memberikan contoh cara menggunakan fungsionalitas Eksperimen SageMaker baru di notebook Jupyter melalui SageMaker SDK. Kami akan mendemonstrasikan kemampuan ini menggunakan a PyTorch contoh untuk melatih contoh klasifikasi digit tulisan tangan MNIST. Eksperimen akan diatur sebagai berikut:

1. Membuat parameter proses dan logging eksperimen: Kami pertama-tama akan membuat eksperimen baru, memulai proses baru untuk eksperimen ini, dan mencatat parameter ke eksperimen tersebut.
2. Metrik performa model logging: Kami akan mencatat metrik kinerja model dan grafik metrik plot.
3. Membandingkan model berjalan: Kami akan membandingkan model yang berbeda berjalan sesuai dengan model hyperparameters. Kami akan membahas cara membandingkan proses tersebut dan cara menggunakan Eksperimen SageMaker untuk memilih model terbaik.
4. Menjalankan eksperimen dari tugas SageMaker: Kami juga akan memberikan contoh cara membagikan konteks eksperimen Anda secara otomatis dengan tugas pemrosesan, pelatihan, atau transformasi batch SageMaker. Ini memungkinkan Anda untuk secara otomatis memulihkan konteks proses Anda dengan load_run berfungsi di dalam pekerjaan Anda.
5. Mengintegrasikan laporan SageMaker Clarify: Kami akan mendemonstrasikan bagaimana kami sekarang dapat berintegrasi Klarifikasi SageMaker laporan bias dan penjelasan ke satu tampilan dengan laporan model terlatih Anda.

Prasyarat

Untuk posting blog ini, kita akan menggunakan Studio Amazon SageMaker untuk menunjukkan cara membuat log metrik dari notebook Studio menggunakan fungsionalitas Eksperimen SageMaker yang diperbarui. Untuk menjalankan perintah yang disajikan dalam contoh kami, Anda memerlukan prasyarat berikut:

• Domain SageMaker Studio
• Profil pengguna SageMaker Studio dengan akses penuh SageMaker
• Notebook SageMaker Studio dengan setidaknya satu ml.t3.medium jenis contoh

Jika Anda tidak memiliki SageMaker Domain dan profil pengguna, Anda dapat membuatnya menggunakan ini panduan pengaturan cepat.

Parameter pencatatan

Untuk latihan ini, kita akan menggunakan obor, paket PyTorch yang menyediakan kumpulan data populer, arsitektur model, dan transformasi gambar umum untuk visi komputer. SageMaker Studio menyediakan satu set gambar buruh pelabuhan untuk kasus penggunaan sains data umum yang tersedia di Amazon ECR. Untuk PyTorch, Anda memiliki opsi untuk memilih gambar yang dioptimalkan untuk pelatihan CPU atau GPU. Untuk contoh ini, kita akan memilih gambar PyTorch 1.12 Python 3.8 CPU Optimized dan Python 3 inti. Contoh yang dijelaskan di bawah ini akan berfokus pada fungsionalitas Eksperimen SageMaker dan bukan kode yang lengkap.

Ayo download datanya dengan torchvision kemas dan lacak jumlah sampel data untuk melatih dan menguji set data sebagai parameter dengan Eksperimen SageMaker. Untuk contoh ini, mari kita asumsikan train_set dan test_set seperti yang sudah diunduh torchvision dataset.

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)

Dalam contoh ini, kami menggunakan run.log_parameters untuk mencatat jumlah sampel data latih dan uji dan run.log_file untuk mengunggah kumpulan data mentah ke Amazon S3 dan mencatatnya sebagai masukan untuk percobaan kami.

Melatih model dan mencatat metrik model

Sekarang kita telah mendownload dataset MNIST kita, mari kita latih a model CNN untuk mengenali digit. Saat melatih model, kami ingin memuat proses eksperimen yang ada, mencatat parameter baru ke dalamnya, dan melacak kinerja model dengan mencatat metrik model.

Kita bisa menggunakan load_run berfungsi untuk memuat proses kami sebelumnya dan menggunakannya untuk mencatat pelatihan model kami

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

Kita kemudian dapat menggunakan run.log_parameter dan run.log_parameters untuk mencatat satu atau beberapa parameter model ke proses kami.

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

Dan kita bisa menggunakan run.log_metric untuk mencatat metrik kinerja ke percobaan kami.

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

Untuk model klasifikasi, Anda juga dapat menggunakan run.log_confusion_matrix, run.log_precision_recall, dan run.log_roc_curve, untuk memplot matriks konfusi, grafik perolehan presisi, dan kurva ROC model Anda secara otomatis. Karena model kita memecahkan masalah klasifikasi multikelas, mari kita catat hanya matriks kebingungannya.

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

Saat melihat detail proses kami, sekarang kami dapat melihat metrik yang dihasilkan seperti yang ditunjukkan pada tangkapan layar di bawah:

Halaman detail proses memberikan informasi lebih lanjut tentang metrik.

Dan parameter model baru dilacak di halaman ikhtisar parameter.

Anda juga dapat menganalisis kinerja model berdasarkan kelas menggunakan matriks kebingungan yang diplot secara otomatis, yang juga dapat diunduh dan digunakan untuk berbagai laporan. Dan Anda dapat memplot grafik tambahan untuk menganalisis performa model Anda berdasarkan metrik yang dicatat.

Membandingkan beberapa parameter model

Sebagai ilmuwan data, Anda ingin menemukan model terbaik. Itu termasuk melatih model berkali-kali dengan hyperparameter yang berbeda dan membandingkan kinerja model dengan hyperparameter tersebut. Untuk melakukannya, Eksperimen SageMaker memungkinkan kami membuat beberapa proses dalam eksperimen yang sama. Mari jelajahi konsep ini dengan melatih model kita dengan yang berbeda num_hidden_channels dan 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
            )

Kami sekarang membuat enam proses baru untuk eksperimen kami. Masing-masing akan mencatat parameter model, metrik, dan matriks kebingungan. Kami kemudian dapat membandingkan proses untuk memilih model berperforma terbaik untuk masalah tersebut. Saat menganalisis proses, kita dapat memplot grafik metrik untuk proses yang berbeda sebagai plot tunggal, membandingkan performa proses di berbagai langkah (atau zaman) pelatihan yang berbeda.

Menggunakan Eksperimen SageMaker dengan pelatihan SageMaker, pemrosesan, dan tugas transformasi batch

Pada contoh di atas, kami menggunakan Eksperimen SageMaker untuk mencatat performa model dari notebook SageMaker Studio tempat model dilatih secara lokal di notebook. Kita dapat melakukan hal yang sama untuk mencatat performa model dari tugas pemrosesan, pelatihan, dan transformasi batch SageMaker. Dengan kemampuan penerusan konteks otomatis yang baru, kami tidak perlu secara khusus membagikan konfigurasi eksperimen dengan tugas SageMaker, karena ini akan diambil secara otomatis.

Contoh di bawah ini akan berfokus pada fungsionalitas Eksperimen SageMaker dan bukan kode yang lengkap.

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

Dalam file skrip model kami, kami dapat menggunakan konteks run load_run(). Dalam tugas pemrosesan dan pelatihan SageMaker, kami tidak perlu menyediakan konfigurasi eksperimen untuk memuat konfigurasi. Untuk pekerjaan transformasi batch, kami perlu menyediakan experiment_name dan run_name untuk memuat konfigurasi percobaan.

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

Selain informasi yang kami dapatkan saat menjalankan Eksperimen SageMaker dari skrip notebook, proses dari tugas SageMaker akan mengisi parameter dan output tugas secara otomatis.

SDK Eksperimen SageMaker yang baru juga memastikan kompatibilitas mundur dengan versi sebelumnya menggunakan konsep uji coba dan komponen uji coba. Eksperimen apa pun yang dipicu menggunakan versi Eksperimen SageMaker sebelumnya akan tersedia secara otomatis di UI baru, untuk menganalisis eksperimen.

Mengintegrasikan SageMaker Clarify dan memodelkan laporan pelatihan

SageMaker Clarify membantu menyempurnakan model ML kami dengan mendeteksi bias potensial dan membantu menjelaskan bagaimana model ini membuat prediksi. Clarify menyediakan kontainer bawaan yang berjalan sebagai tugas pemrosesan SageMaker setelah model Anda dilatih, menggunakan informasi tentang data Anda (konfigurasi data), model (konfigurasi model), dan kolom data sensitif yang ingin kami analisis untuk kemungkinan bias (bias konfigurasi). Hingga saat ini, Eksperimen SageMaker menampilkan pelatihan model dan laporan Klarifikasi kami sebagai komponen uji coba individual yang terhubung melalui uji coba.

Dengan Eksperimen SageMaker baru, kami juga dapat mengintegrasikan laporan SageMaker Clarify dengan pelatihan model kami yang memiliki satu sumber kebenaran yang memungkinkan kami untuk lebih memahami model kami. Untuk laporan terintegrasi, yang perlu kita lakukan adalah memiliki nama proses yang sama untuk pelatihan dan pekerjaan Klarifikasi kita. Contoh berikut menunjukkan bagaimana kita dapat mengintegrasikan laporan menggunakan Model XGBoost untuk memprediksi pendapatan orang dewasa di seluruh Amerika Serikat. Modelnya menggunakan Kumpulan data UCI Dewasa. Untuk latihan ini, kami berasumsi bahwa model sudah dilatih dan kami telah menghitung konfigurasi data, model, dan bias.

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

Dengan penyiapan ini, kami mendapatkan tampilan gabungan yang menyertakan metrik model, input dan output gabungan, dan laporan Clarify untuk bias statistik model dan keterjelasan.

Kesimpulan

Dalam postingan ini, kami menjelajahi generasi baru Eksperimen SageMaker, bagian terintegrasi dari SageMaker SDK. Kami mendemonstrasikan cara mencatat alur kerja ML Anda dari mana saja dengan kelas Run yang baru. Kami menyajikan UI Eksperimen baru yang memungkinkan Anda melacak eksperimen dan memplot grafik untuk satu metrik proses serta membandingkan beberapa proses dengan kemampuan analisis baru. Kami menyediakan contoh eksperimen logging dari notebook SageMaker Studio dan dari tugas pelatihan SageMaker Studio. Terakhir, kami menunjukkan cara mengintegrasikan pelatihan model dan laporan SageMaker Clarify dalam tampilan terpadu, memungkinkan Anda untuk lebih memahami model Anda.

Kami mendorong Anda untuk mencoba fungsi Eksperimen baru dan terhubung dengan Pembelajaran Mesin & komunitas AI jika Anda memiliki pertanyaan atau umpan balik!

Tentang Penulis

Maira Ladeira Tanke adalah Spesialis Pembelajaran Mesin di AWS. Dengan latar belakang Ilmu Data, dia memiliki 9 tahun pengalaman merancang dan membangun aplikasi ML dengan pelanggan di berbagai industri. Sebagai pimpinan teknis, dia membantu pelanggan mempercepat pencapaian nilai bisnis mereka melalui teknologi baru dan solusi inovatif. Di waktu luangnya, Maira senang bepergian dan menghabiskan waktu bersama keluarganya di tempat yang hangat.

Mani Khanuja adalah Spesialis Artificial Intelligence dan Machine Learning SA di Amazon Web Services (AWS). Dia membantu pelanggan menggunakan pembelajaran mesin untuk memecahkan tantangan bisnis mereka menggunakan AWS. Dia menghabiskan sebagian besar waktunya untuk menyelam lebih dalam dan mengajar pelanggan tentang proyek AI/ML yang terkait dengan visi komputer, pemrosesan bahasa alami, perkiraan, ML di edge, dan banyak lagi. Dia sangat menyukai ML di edge, oleh karena itu, dia telah membuat labnya sendiri dengan kit self-driving dan lini produksi manufaktur prototipe, di mana dia menghabiskan banyak waktu luangnya.

Dewi Qi adalah Insinyur Pengembangan Perangkat Lunak di AWS. Dia saat ini berpartisipasi dalam membangun kumpulan layanan platform dan alat di AWS SageMaker untuk membantu pelanggan menyukseskan proyek ML mereka. Dia juga bersemangat membawa konsep MLOps ke audiens yang lebih luas. Di luar pekerjaan, Dewen senang berlatih Cello.

Abhishek Agarwal adalah Manajer Produk Senior untuk Amazon SageMaker. Dia bersemangat bekerja dengan pelanggan dan membuat pembelajaran mesin lebih mudah diakses. Di waktu luangnya, Abhishek menikmati melukis, bersepeda, dan belajar tentang teknologi inovatif.

Dan Benson adalah Insinyur Perangkat Lunak yang bekerja di tim Eksperimen, Silsilah, dan Penelusuran Amazon SageMaker. Sebelum bergabung dengan AWS, Dana menghabiskan waktu mengaktifkan fungsionalitas rumah pintar di Alexa dan pemesanan seluler di Starbucks.