Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Algoritma SageMaker AI bawaan untuk Data Tabular
Amazon SageMaker AI menyediakan algoritme bawaan yang disesuaikan dengan analisis data tabular. Data tabular mengacu pada kumpulan data apa pun yang diatur dalam tabel yang terdiri dari baris (pengamatan) dan kolom (fitur). Algoritma SageMaker AI bawaan untuk data tabular dapat digunakan untuk masalah klasifikasi atau regresi.
+ [AutoGluon-Tabular](autogluon-tabular.md)—kerangka AutoML open-source yang berhasil dengan menyamai model dan menumpuknya dalam beberapa lapisan.
+ [CatBoost](catboost.md)—implementasi algoritma pohon yang ditingkatkan gradien yang memperkenalkan peningkatan berurutan dan algoritme inovatif untuk memproses fitur kategoris.
+ [Algoritma Mesin Faktorisasi](fact-machines.md)—perpanjangan dari model linier yang dirancang untuk menangkap interaksi secara ekonomis antara fitur dalam kumpulan data jarang dimensi tinggi.
+ [Algoritma K-Nearest Neighbors (k-NN)](k-nearest-neighbors.md)—metode non-parametrik yang menggunakan k titik berlabel terdekat untuk menetapkan label ke titik data baru untuk klasifikasi atau nilai target yang diprediksi dari rata-rata k titik terdekat untuk regresi.
+ [LightGBM](lightgbm.md)—implementasi algoritma pohon yang ditingkatkan gradien yang menambahkan dua teknik baru untuk meningkatkan efisiensi dan skalabilitas: Pengambilan Sampel Satu Sisi Berbasis Gradien (GOSS) dan Bundling Fitur Eksklusif (EFB).
+ [Algoritma Pembelajar Linear](linear-learner.md)—mempelajari fungsi linier untuk regresi atau fungsi ambang linier untuk klasifikasi.
+ [TabTransformer](tabtransformer.md)—arsitektur pemodelan data tabular mendalam baru yang dibangun di atas self-attention-based Transformers.
+ [XGBoost algoritma dengan Amazon SageMaker AI](xgboost.md)—implementasi algoritma pohon yang ditingkatkan gradien yang menggabungkan ansambel perkiraan dari serangkaian model yang lebih sederhana dan lebih lemah.
| Nama algoritma | Nama saluran | Mode masukan pelatihan | Tipe file | Kelas instans | Dapat diparalelkan |
| --- | --- | --- | --- | --- | --- |
| AutoGluon-Tabular | pelatihan dan validasi (opsional) | File | CSV | CPU atau GPU (hanya satu contoh) | Tidak |
| CatBoost | pelatihan dan validasi (opsional) | File | CSV | CPU (hanya satu contoh) | Tidak |
| Mesin Faktorisasi | melatih dan (opsional) tes | File atau Pipa | Protobuf Recordio | CPU (GPU untuk data padat) | Ya |
| K-Nearest-Neighbors (K-nn) | melatih dan (opsional) tes | File atau Pipa | Recordio-protobuf atau CSV | CPU atau GPU (perangkat GPU tunggal pada satu atau beberapa instance) | Ya |
| LightGBM | pelatihan dan validasi (opsional) | File | CSV | CPU (hanya satu contoh) | Tidak |
| Linear Learner | melatih dan (opsional) validasi, tes, atau keduanya | File atau Pipa | Recordio-protobuf atau CSV | CPU atau GPU | Ya |
| TabTransformer | pelatihan dan validasi (opsional) | File | CSV | CPU atau GPU (hanya satu contoh) | Tidak |
| XGBoost (0,90-1, 0,90-2, 1,0-1, 1,2-1, 1,2-21) | melatih dan (opsional) validasi | File atau Pipa | CSV, LibSVM, atau Parket | CPU (atau GPU untuk 1.2-1) | Ya |
# AutoGluon-Tabular
[AutoGluon-Tabular](https://auto.gluon.ai/stable/index.html) adalah kerangka kerja AutoML open-source populer yang melatih model pembelajaran mesin yang sangat akurat pada kumpulan data tabular yang belum diproses. Tidak seperti kerangka kerja AutoML yang ada yang terutama berfokus pada pemilihan model dan hiperparameter, AutoGluon -Tabular berhasil dengan menyamarkan beberapa model dan menumpuknya dalam beberapa lapisan. Halaman ini mencakup informasi tentang rekomendasi instans Amazon EC2 dan contoh buku catatan untuk -Tabular. AutoGluon
# Cara menggunakan SageMaker AI AutoGluon -Tabular
Anda dapat menggunakan AutoGluon -Tabular sebagai algoritma bawaan Amazon SageMaker AI. Bagian berikut menjelaskan cara menggunakan AutoGluon -Tabular dengan Python SageMaker SDK. Untuk informasi tentang cara menggunakan AutoGluon -Tabular dari Amazon SageMaker Studio Classic UI, lihat. [SageMaker JumpStart model terlatih](studio-jumpstart.md)
+ **Gunakan AutoGluon -Tabular sebagai algoritma bawaan**
Gunakan algoritme bawaan AutoGluon -Tabular untuk membangun wadah pelatihan AutoGluon -Tabular seperti yang ditunjukkan pada contoh kode berikut. Anda dapat secara otomatis melihat URI image algoritma bawaan AutoGluon -Tabular menggunakan SageMaker AI `image_uris.retrieve` API (atau `get_image_uri` API jika menggunakan Amazon [ SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) versi 2).
Setelah menentukan URI gambar AutoGluon -Tabular, Anda dapat menggunakan wadah AutoGluon -Tabular untuk membuat estimator menggunakan SageMaker AI Estimator API dan memulai pekerjaan pelatihan. Algoritma bawaan AutoGluon -Tabular berjalan dalam mode skrip, tetapi skrip pelatihan disediakan untuk Anda dan tidak perlu menggantinya. Jika Anda memiliki pengalaman luas menggunakan mode skrip untuk membuat pekerjaan SageMaker pelatihan, maka Anda dapat memasukkan skrip pelatihan AutoGluon -Tabular Anda sendiri.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "autogluon-classification-ensemble", "*", "training"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_binary/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"auto_stack"
] = "True"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1,
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"training": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Untuk informasi selengkapnya tentang cara mengatur AutoGluon -Tabular sebagai algoritma bawaan, lihat contoh notebook berikut. Bucket S3 apa pun yang digunakan dalam contoh ini harus berada di AWS Region yang sama dengan instance notebook yang digunakan untuk menjalankannya.
+ [Klasifikasi tabel dengan algoritma Amazon SageMaker AI AutoGluon -Tabular](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Classification_AutoGluon.ipynb)
+ [Regresi tabular dengan algoritma Amazon SageMaker AI -Tabular AutoGluon](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Regression_AutoGluon.ipynb)
# Antarmuka Input dan Output untuk algoritma AutoGluon -Tabular
Peningkatan gradien beroperasi pada data tabular, dengan baris mewakili pengamatan, satu kolom mewakili variabel target atau label, dan kolom yang tersisa mewakili fitur.
Implementasi SageMaker AI AutoGluon -Tabular mendukung CSV untuk pelatihan dan inferensi:
+ Untuk **Pelatihan ContentType**, input yang valid harus *teks/csv*.
+ *Untuk **Inferensi ContentType**, input yang valid harus teks/csv.*
**catatan**
Untuk pelatihan CSV, algoritme mengasumsikan bahwa variabel target ada di kolom pertama dan CSV tidak memiliki catatan header.
Untuk inferensi CSV, algoritme mengasumsikan bahwa input CSV tidak memiliki kolom label.
**Format input untuk data pelatihan, data validasi, dan fitur kategoris**
Perhatikan cara memformat data pelatihan Anda untuk masukan ke model AutoGluon -Tabular. Anda harus menyediakan jalur ke bucket Amazon S3 yang berisi data pelatihan dan validasi Anda. Anda juga dapat menyertakan daftar fitur kategoris. Gunakan saluran `training` dan `validation` saluran untuk memberikan data masukan Anda. Atau, Anda hanya dapat menggunakan `training` saluran.
**Gunakan kedua `validation` saluran `training` dan**
Anda dapat memberikan data input Anda melalui dua jalur S3, satu untuk `training` saluran dan satu untuk `validation` saluran. Setiap jalur S3 dapat berupa awalan S3 atau jalur S3 lengkap yang menunjuk ke satu file CSV tertentu. Variabel target harus berada di kolom pertama file CSV Anda. Variabel prediktor (fitur) harus berada di kolom yang tersisa. Data validasi digunakan untuk menghitung skor validasi di akhir setiap iterasi peningkatan. Penghentian awal diterapkan ketika skor validasi berhenti membaik.
Jika prediktor Anda menyertakan fitur kategoris, Anda dapat memberikan file JSON bernama `categorical_index.json` di lokasi yang sama dengan file data pelatihan Anda. Jika Anda menyediakan file JSON untuk fitur kategoris, `training` saluran Anda harus menunjuk ke awalan S3 dan bukan file CSV tertentu. File ini harus berisi kamus Python di mana kuncinya adalah string `"cat_index_list"` dan nilainya adalah daftar bilangan bulat unik. Setiap bilangan bulat dalam daftar nilai harus menunjukkan indeks kolom dari fitur kategoris yang sesuai dalam file CSV data pelatihan Anda. Setiap nilai harus berupa bilangan bulat positif (lebih besar dari nol karena nol mewakili nilai target), kurang dari `Int32.MaxValue` (2147483647), dan kurang dari jumlah kolom. Seharusnya hanya ada satu file JSON indeks kategoris.
**Gunakan hanya `training` saluran**:
Sebagai alternatif, Anda dapat memberikan data input Anda melalui jalur S3 tunggal untuk `training` saluran tersebut. Path S3 ini harus menunjuk ke direktori dengan subdirektori bernama `training/` yang berisi file CSV. Anda dapat secara opsional menyertakan subdirektori lain di lokasi yang sama yang disebut `validation/` yang juga memiliki file CSV. Jika data validasi tidak disediakan, maka 20% data pelatihan Anda diambil sampelnya secara acak untuk dijadikan sebagai data validasi. Jika prediktor Anda menyertakan fitur kategoris, Anda dapat memberikan file JSON bernama `categorical_index.json` di lokasi yang sama dengan subdirektori data Anda.
**catatan**
Untuk mode input pelatihan CSV, total memori yang tersedia untuk algoritme (jumlah instance dikalikan dengan memori yang tersedia di`InstanceType`) harus dapat menampung kumpulan data pelatihan.
SageMaker AI AutoGluon -Tabular menggunakan `autogluon.tabular.TabularPredictor` modul untuk membuat serial atau deserialisasi model, yang dapat digunakan untuk menyimpan atau memuat model.
**Untuk menggunakan model yang dilatih dengan SageMaker AI AutoGluon -Tabular dengan kerangka kerja AutoGluon**
+ Gunakan kode Python berikut:
```
import tarfile
from autogluon.tabular import TabularPredictor
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
model = TabularPredictor.load(model_file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Rekomendasi instans Amazon EC2 untuk algoritme AutoGluon -Tabular
SageMaker AI AutoGluon -Tabular mendukung pelatihan CPU satu instans dan GPU instans tunggal. Meskipun biaya per instans lebih tinggi, GPUs latih lebih cepat, membuatnya lebih hemat biaya. Untuk memanfaatkan pelatihan GPU, tentukan jenis instans sebagai salah satu instance GPU (misalnya, P3). SageMaker AI AutoGluon -Tabular saat ini tidak mendukung pelatihan multi-GPU.
## AutoGluon-Notebook sampel tabel
Tabel berikut menguraikan berbagai contoh notebook yang membahas berbagai kasus penggunaan algoritma Amazon SageMaker AI AutoGluon -Tabular.
****
| **Judul Notebook** | **Deskripsi** |
| --- | --- |
| [Klasifikasi tabel dengan algoritma Amazon SageMaker AI AutoGluon -Tabular](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Classification_AutoGluon.ipynb) | Notebook ini menunjukkan penggunaan algoritma Amazon SageMaker AI AutoGluon -Tabular untuk melatih dan menjadi tuan rumah model klasifikasi tabular. |
| [Regresi tabular dengan algoritma Amazon SageMaker AI -Tabular AutoGluon](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Regression_AutoGluon.ipynb) | Notebook ini menunjukkan penggunaan algoritma Amazon SageMaker AI AutoGluon -Tabular untuk melatih dan menjadi tuan rumah model regresi tabular. |
Untuk petunjuk tentang cara membuat dan mengakses instance notebook Jupyter yang dapat Anda gunakan untuk menjalankan contoh di SageMaker AI, lihat. [Instans SageMaker notebook Amazon](nbi.md) Setelah Anda membuat instance notebook dan membukanya, pilih tab **Contoh SageMaker AI** untuk melihat daftar semua sampel SageMaker AI. Untuk membuka buku catatan, pilih tab **Use** dan pilih **Create copy**.
# Bagaimana AutoGluon -Tabular bekerja
AutoGluon-Tabular melakukan pemrosesan data tingkat lanjut, pembelajaran mendalam, dan metode ansambel model multi-layer. Secara otomatis mengenali tipe data di setiap kolom untuk preprocessing data yang kuat, termasuk penanganan khusus bidang teks.
AutoGluon cocok untuk berbagai model mulai dari pohon yang off-the-shelf ditingkatkan hingga jaringan saraf yang disesuaikan. Model-model ini diansambel dengan cara baru: model ditumpuk dalam beberapa lapisan dan dilatih secara berlapis yang menjamin data mentah dapat diterjemahkan ke dalam prediksi berkualitas tinggi dalam batasan waktu tertentu. Proses ini mengurangi overfitting dengan membagi data dengan berbagai cara dengan pelacakan contoh yang cermat. out-of-fold
Algoritma AutoGluon -Tabular berkinerja baik dalam kompetisi pembelajaran mesin karena penanganannya yang kuat dari berbagai tipe data, hubungan, dan distribusi. Anda dapat menggunakan AutoGluon -Tabular untuk regresi, klasifikasi (biner dan multiclass), dan masalah peringkat.
Lihat diagram berikut yang menggambarkan cara kerja strategi susun multi-layer.
![\[AutoGluonstrategi penumpukan multi-layer ditampilkan dengan dua lapisan susun.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/autogluon_tabular_illustration.png)
Untuk informasi selengkapnya, lihat *[AutoGluon-Tabular: AutoML yang Kuat dan Akurat untuk Data Terstruktur](https://arxiv.org/pdf/2003.06505.pdf)*.
# AutoGluon-Hiperparameter tabel
Tabel berikut berisi subset hiperparameter yang diperlukan atau paling umum digunakan untuk algoritma Amazon SageMaker AI AutoGluon -Tabular. Pengguna mengatur parameter ini untuk memfasilitasi estimasi parameter model dari data. [Algoritma SageMaker AI AutoGluon -Tabular adalah implementasi dari paket -Tabular open-sourceAutoGluon.](https://github.com/awslabs/autogluon)
**catatan**
Hyperparameter default didasarkan pada contoh kumpulan data di file. [AutoGluon-Notebook sampel tabel](autogluon-tabular.md#autogluon-tabular-sample-notebooks)
Secara default, algoritma SageMaker AI AutoGluon -Tabular secara otomatis memilih metrik evaluasi berdasarkan jenis masalah klasifikasi. Algoritma mendeteksi jenis masalah klasifikasi berdasarkan jumlah label dalam data Anda. Untuk masalah regresi, metrik evaluasi adalah kesalahan kuadrat rata-rata akar. Untuk masalah klasifikasi biner, metrik evaluasi adalah area di bawah kurva karakteristik operasi penerima (AUC). Untuk masalah klasifikasi multikelas, metrik evaluasi adalah akurasi. Anda dapat menggunakan `eval_metric` hyperparameter untuk mengubah metrik evaluasi default. Lihat tabel berikut untuk informasi lebih lanjut tentang hiperparameter AutoGluon -Tabular, termasuk deskripsi, nilai yang valid, dan nilai default.
| Nama Parameter | Deskripsi |
| --- | --- |
| eval\$1metric | Metrik evaluasi untuk data validasi. Jika `eval_metric` diatur ke `"auto"` nilai default, maka algoritme secara otomatis memilih metrik evaluasi berdasarkan jenis masalah klasifikasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/autogluon-tabular-hyperparameters.html) Nilai yang valid: string, lihat [AutoGluon dokumentasi](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html) untuk nilai yang valid. Nilai default:`"auto"`. |
| presets | Daftar konfigurasi preset untuk berbagai argumen di. `fit()` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/autogluon-tabular-hyperparameters.html) Untuk lebih jelasnya, lihat [AutoGluon Prediktor](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html). Nilai yang valid: string, salah satu dari berikut ini: (`"best_quality"``"high_quality"`,,`good_quality"`,`"medium_quality"`,`"optimize_for_deployment"`,` or "interpretable"`). Nilai default:`"medium_quality"`. |
| auto\$1stack | Apakah AutoGluon harus secara otomatis menggunakan bagging dan multi-layer stack ansambling untuk meningkatkan akurasi prediktif. Atur `auto_stack` ke `"True"` jika Anda bersedia mentolerir waktu pelatihan yang lebih lama untuk memaksimalkan akurasi prediktif. Ini secara otomatis menetapkan `num_stack_levels` argumen `num_bag_folds` dan berdasarkan properti dataset. Nilai yang valid: string, `"True"` atau`"False"`. Nilai default:`"False"`. |
| num\$1bag\$1folds | Jumlah lipatan yang digunakan untuk mengantongi model. `num_bag_folds`Kapan sama dengan`k`, waktu pelatihan secara kasar meningkat dengan faktor`k`. Setel `num_bag_folds` ke 0 untuk menonaktifkan bagging. Ini dinonaktifkan secara default, tetapi kami sarankan menggunakan nilai antara 5 dan 10 untuk memaksimalkan kinerja prediktif. Peningkatan `num_bag_folds` hasil dalam model dengan bias yang lebih rendah, tetapi itu lebih rentan terhadap overfitting. Salah satunya adalah nilai yang tidak valid untuk parameter ini, dan akan menaikkan nilai. `ValueError` Nilai yang lebih besar dari 10 dapat menghasilkan pengembalian yang berkurang dan bahkan dapat merusak hasil keseluruhan karena overfitting. Untuk lebih meningkatkan prediksi, hindari peningkatan `num_bag_folds` dan sebaliknya tingkatkan`num_bag_sets`. Nilai yang valid: string, bilangan bulat apa pun antara (dan termasuk) `"0"` dan`"10"`. Nilai default:`"0"`. |
| num\$1bag\$1sets | Jumlah pengulangan kfold bagging untuk dilakukan (nilai harus lebih besar dari atau sama dengan 1). Jumlah total model yang dilatih selama pengantongan sama `num_bag_folds` dengan\$1`num_bag_sets`. Parameter ini default ke satu jika `time_limit` tidak ditentukan. Parameter ini dinonaktifkan `num_bag_folds` jika tidak ditentukan. Nilai yang lebih besar dari satu menghasilkan kinerja prediktif yang unggul, terutama pada masalah yang lebih kecil dan dengan penumpukan diaktifkan. Nilai yang valid: integer, range: [`1`,`20`]. Nilai default:`1`. |
| num\$1stack\$1levels | Jumlah tingkat susun untuk digunakan dalam ansambel tumpukan. Secara kasar meningkatkan waktu pelatihan model dengan faktor `num_stack_levels` \$1 1. Setel parameter ini ke 0 untuk menonaktifkan ansambel tumpukan. Parameter ini dinonaktifkan secara default, tetapi kami sarankan menggunakan nilai antara 1 dan 3 untuk memaksimalkan kinerja prediktif. Untuk mencegah overfitting dan a`ValueError`, `num_bag_folds` harus lebih besar dari atau sama dengan 2. Nilai yang valid: float, range: [`0`,`3`]. Nilai default:`0`. |
| refit\$1full | Apakah akan melatih ulang semua model pada semua data (pelatihan dan validasi) setelah prosedur pelatihan normal atau tidak. Untuk lebih jelasnya, lihat [AutoGluon Prediktor](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html). Nilai yang valid: string, `"True"` atau`"False"`. Nilai default:`"False"`. |
| set\$1best\$1to\$1refit\$1full | Apakah akan mengubah model default yang digunakan prediktor untuk prediksi atau tidak. Jika `set_best_to_refit_full` disetel ke`"True"`, model default berubah ke model yang menunjukkan skor validasi tertinggi sebagai hasil dari refitting (diaktifkan oleh). `refit_full` Hanya valid jika `refit_full` disetel. Nilai yang valid: string, `"True"` atau`"False"`. Nilai default:`"False"`. |
| save\$1space | Apakah atau perhatikan untuk mengurangi memori dan ukuran disk prediktor dengan menghapus file model tambahan yang tidak diperlukan untuk prediksi pada data baru. Ini tidak berdampak pada akurasi inferensi. Kami merekomendasikan pengaturan `save_space` `"True"` apakah satu-satunya tujuan adalah menggunakan model terlatih untuk prediksi. Fungsionalitas lanjutan tertentu mungkin tidak lagi tersedia jika `save_space` disetel ke`"True"`. Lihat `[predictor.save\$1space()](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.save_space.html)` dokumentasi untuk lebih jelasnya. Nilai yang valid: string, `"True"` atau`"False"`. Nilai default:`"False"`. |
| verbosity | Verbositas pesan cetak. `verbosity`tingkat berkisar dari `0` ke`4`, dengan tingkat yang lebih tinggi sesuai dengan pernyataan cetak yang lebih rinci. Sebuah `verbosity` dari `0` menekan peringatan. Nilai yang valid: bilangan bulat, salah satu dari berikut ini: (`0`,`1`,`2`,`3`, atau`4`). Nilai default:`2`. |
# Menyetel model AutoGluon -Tabular
Meskipun AutoGluon -Tabular dapat digunakan dengan penyetelan model, desainnya dapat memberikan kinerja yang baik menggunakan metode susun dan ansambel, yang berarti optimasi hyperparameter tidak diperlukan. Alih-alih berfokus pada penyetelan model, AutoGluon -Tabular berhasil dengan menumpuk model dalam beberapa lapisan dan pelatihan dengan cara yang bijaksana.
Untuk informasi lebih lanjut tentang AutoGluon -Tabular hyperparameters, lihat. [AutoGluon-Hiperparameter tabel](autogluon-tabular-hyperparameters.md)
# CatBoost
[CatBoost](https://catboost.ai/)adalah implementasi open-source yang populer dan berkinerja tinggi dari algoritma Gradient Boosting Decision Tree (GBDT). GBDT adalah algoritma pembelajaran yang diawasi yang mencoba memprediksi variabel target secara akurat dengan menggabungkan ansambel perkiraan dari serangkaian model yang lebih sederhana dan lebih lemah.
CatBoost memperkenalkan dua kemajuan algoritmik penting ke GBDT:
1. Implementasi peningkatan berurutan, alternatif yang digerakkan oleh permutasi untuk algoritme klasik
1. Algoritma inovatif untuk memproses fitur kategoris
Kedua teknik diciptakan untuk melawan pergeseran prediksi yang disebabkan oleh jenis kebocoran target khusus yang ada di semua implementasi algoritma peningkatan gradien yang ada saat ini. Halaman ini mencakup informasi tentang rekomendasi instans Amazon EC2 dan contoh buku catatan untuk. CatBoost
# Cara menggunakan SageMaker AI CatBoost
Anda dapat menggunakannya CatBoost sebagai algoritma bawaan Amazon SageMaker AI. Bagian berikut menjelaskan cara menggunakan CatBoost dengan SageMaker Python SDK. Untuk informasi tentang cara menggunakan CatBoost dari Amazon SageMaker Studio Classic UI, lihat[SageMaker JumpStart model terlatih](studio-jumpstart.md).
+ **Gunakan CatBoost sebagai algoritma bawaan**
Gunakan algoritma CatBoost bawaan untuk membangun wadah CatBoost pelatihan seperti yang ditunjukkan pada contoh kode berikut. Anda dapat secara otomatis melihat URI image algoritme CatBoost bawaan menggunakan SageMaker AI `image_uris.retrieve` API (atau `get_image_uri` API jika menggunakan [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) versi 2).
Setelah menentukan URI CatBoost gambar, Anda dapat menggunakan CatBoost wadah untuk membuat estimator menggunakan SageMaker AI Estimator API dan memulai pekerjaan pelatihan. Algoritma CatBoost bawaan berjalan dalam mode skrip, tetapi skrip pelatihan disediakan untuk Anda dan tidak perlu menggantinya. Jika Anda memiliki pengalaman luas menggunakan mode skrip untuk membuat pekerjaan SageMaker pelatihan, maka Anda dapat memasukkan skrip CatBoost pelatihan Anda sendiri.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "catboost-classification-model", "*", "training"
training_instance_type = "ml.m5.xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_multiclass/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"iterations"
] = "500"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1,
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"training": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Untuk informasi selengkapnya tentang cara mengatur CatBoost sebagai algoritma bawaan, lihat contoh buku catatan berikut.
+ [Klasifikasi tabel dengan Amazon SageMaker AI LightGBM dan algoritma CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)
+ [Regresi tabular dengan Amazon SageMaker AI LightGBM dan algoritma CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)
# Antarmuka Input dan Output untuk CatBoost algoritma
Peningkatan gradien beroperasi pada data tabular, dengan baris mewakili pengamatan, satu kolom mewakili variabel target atau label, dan kolom yang tersisa mewakili fitur.
Implementasi SageMaker AI CatBoost mendukung CSV untuk pelatihan dan inferensi:
+ Untuk **Pelatihan ContentType**, input yang valid harus berupa *teks/csv*.
+ *Untuk **Inferensi ContentType**, input yang valid harus teks/csv.*
**catatan**
Untuk pelatihan CSV, algoritme mengasumsikan bahwa variabel target ada di kolom pertama dan CSV tidak memiliki catatan header.
Untuk inferensi CSV, algoritme mengasumsikan bahwa input CSV tidak memiliki kolom label.
**Format input untuk data pelatihan, data validasi, dan fitur kategoris**
Perhatikan cara memformat data pelatihan Anda untuk masukan ke CatBoost model. Anda harus menyediakan jalur ke bucket Amazon S3 yang berisi data pelatihan dan validasi Anda. Anda juga dapat menyertakan daftar fitur kategoris. Gunakan saluran `training` dan `validation` saluran untuk memberikan data masukan Anda. Atau, Anda hanya dapat menggunakan `training` saluran.
**Gunakan kedua `validation` saluran `training` dan**
Anda dapat memberikan data input Anda melalui dua jalur S3, satu untuk `training` saluran dan satu untuk `validation` saluran. Setiap jalur S3 dapat berupa awalan S3 yang menunjuk ke satu atau lebih file CSV atau jalur S3 lengkap yang menunjuk ke satu file CSV tertentu. Variabel target harus berada di kolom pertama file CSV Anda. Variabel prediktor (fitur) harus berada di kolom yang tersisa. Jika beberapa file CSV disediakan untuk `validation` saluran `training` atau, CatBoost algoritme menggabungkan file. Data validasi digunakan untuk menghitung skor validasi di akhir setiap iterasi peningkatan. Penghentian awal diterapkan ketika skor validasi berhenti membaik.
Jika prediktor Anda menyertakan fitur kategoris, Anda dapat memberikan file JSON bernama `categorical_index.json` di lokasi yang sama dengan file atau file data pelatihan Anda. Jika Anda menyediakan file JSON untuk fitur kategoris, `training` saluran Anda harus menunjuk ke awalan S3 dan bukan file CSV tertentu. File ini harus berisi kamus Python di mana kuncinya adalah string `"cat_index_list"` dan nilainya adalah daftar bilangan bulat unik. Setiap bilangan bulat dalam daftar nilai harus menunjukkan indeks kolom dari fitur kategoris yang sesuai dalam file CSV data pelatihan Anda. Setiap nilai harus berupa bilangan bulat positif (lebih besar dari nol karena nol mewakili nilai target), kurang dari `Int32.MaxValue` (2147483647), dan kurang dari jumlah kolom. Seharusnya hanya ada satu file JSON indeks kategoris.
**Gunakan hanya `training` saluran**:
Sebagai alternatif, Anda dapat memberikan data input Anda melalui jalur S3 tunggal untuk `training` saluran tersebut. Jalur S3 ini harus menunjuk ke direktori dengan subdirektori bernama `training/` yang berisi satu atau lebih file CSV. Anda dapat secara opsional menyertakan subdirektori lain di lokasi yang sama yang disebut `validation/` yang juga memiliki satu atau lebih file CSV. Jika data validasi tidak disediakan, maka 20% data pelatihan Anda diambil sampelnya secara acak untuk dijadikan data validasi. Jika prediktor Anda menyertakan fitur kategoris, Anda dapat memberikan file JSON bernama `categorical_index.json` di lokasi yang sama dengan subdirektori data Anda.
**catatan**
Untuk mode input pelatihan CSV, total memori yang tersedia untuk algoritme (jumlah instance dikalikan dengan memori yang tersedia di`InstanceType`) harus dapat menampung kumpulan data pelatihan.
SageMaker AI CatBoost menggunakan `catboost.CatBoostRegressor` modul `catboost.CatBoostClassifier` dan untuk membuat serial atau deserialisasi model, yang dapat digunakan untuk menyimpan atau memuat model.
**Untuk menggunakan model yang dilatih dengan SageMaker AI CatBoost dengan `catboost`**
+ Gunakan kode Python berikut:
```
import tarfile
from catboost import CatBoostClassifier
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
file_path = os.path.join(model_file_path, "model")
model = CatBoostClassifier()
model.load_model(file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Rekomendasi instans Amazon EC2 untuk algoritme CatBoost
SageMaker AI CatBoost saat ini hanya menggunakan CPUs kereta. CatBoost adalah algoritma yang terikat memori (sebagai lawan dari compute-bound). Jadi, instance komputasi tujuan umum (misalnya, M5) adalah pilihan yang lebih baik daripada instance yang dioptimalkan komputasi (misalnya, C5). Selanjutnya, kami menyarankan Anda memiliki memori total yang cukup dalam instance yang dipilih untuk menyimpan data pelatihan.
## CatBoost contoh notebook
Tabel berikut menguraikan berbagai contoh notebook yang membahas berbagai kasus penggunaan algoritma Amazon SageMaker AI CatBoost .
****
| **Judul Notebook** | **Deskripsi** |
| --- | --- |
| [Klasifikasi tabel dengan Amazon SageMaker AI LightGBM dan algoritma CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb) | Notebook ini menunjukkan penggunaan CatBoost algoritma Amazon SageMaker AI untuk melatih dan menjadi tuan rumah model klasifikasi tabular. |
| [Regresi tabular dengan Amazon SageMaker AI LightGBM dan algoritma CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb) | Notebook ini menunjukkan penggunaan CatBoost algoritma Amazon SageMaker AI untuk melatih dan menjadi tuan rumah model regresi tabular. |
Untuk petunjuk tentang cara membuat dan mengakses instance notebook Jupyter yang dapat Anda gunakan untuk menjalankan contoh di SageMaker AI, lihat. [Instans SageMaker notebook Amazon](nbi.md) Setelah Anda membuat instance notebook dan membukanya, pilih tab **Contoh SageMaker AI** untuk melihat daftar semua sampel SageMaker AI. Untuk membuka buku catatan, pilih tab **Use** dan pilih **Create copy**.
# Cara CatBoost Kerja
CatBoost mengimplementasikan algoritma Gradient Boosting Decision Tree (GBDT) konvensional dengan penambahan dua kemajuan algoritmik penting:
1. Implementasi peningkatan berurutan, alternatif yang digerakkan oleh permutasi untuk algoritme klasik
1. Algoritma inovatif untuk memproses fitur kategoris
Kedua teknik diciptakan untuk melawan pergeseran prediksi yang disebabkan oleh jenis kebocoran target khusus yang ada di semua implementasi algoritma peningkatan gradien yang ada saat ini.
CatBoost Algoritma ini berkinerja baik dalam kompetisi pembelajaran mesin karena penanganannya yang kuat terhadap berbagai tipe data, hubungan, distribusi, dan keragaman hiperparameter yang dapat Anda sesuaikan. Anda dapat menggunakan CatBoost untuk regresi, klasifikasi (biner dan multiclass), dan masalah peringkat.
Untuk informasi lebih lanjut tentang peningkatan gradien, lihat. [Bagaimana XGBoost algoritma SageMaker AI bekerja](xgboost-HowItWorks.md) Untuk detail mendalam tentang teknik GOSS dan EFB tambahan yang digunakan dalam CatBoost metode ini, lihat *[CatBoost: peningkatan yang tidak bias](https://arxiv.org/pdf/1706.09516.pdf)* dengan fitur kategoris.
# CatBoost hiperparameter
Tabel berikut berisi subset hiperparameter yang diperlukan atau paling umum digunakan untuk algoritma Amazon SageMaker AI CatBoost . Pengguna mengatur parameter ini untuk memfasilitasi estimasi parameter model dari data. CatBoost Algoritma SageMaker AI adalah implementasi dari [CatBoost](https://github.com/catboost/catboost)paket open-source.
**catatan**
Hyperparameter default didasarkan pada contoh kumpulan data di file. [CatBoost contoh notebook](catboost.md#catboost-sample-notebooks)
Secara default, CatBoost algoritme SageMaker AI secara otomatis memilih metrik evaluasi dan fungsi kerugian berdasarkan jenis masalah klasifikasi. CatBoost Algoritma mendeteksi jenis masalah klasifikasi berdasarkan jumlah label dalam data Anda. Untuk masalah regresi, metrik evaluasi dan fungsi kerugian keduanya merupakan kesalahan kuadrat rata-rata akar. Untuk masalah klasifikasi biner, metrik evaluasi adalah Area Under the Curve (AUC) dan fungsi kerugiannya adalah kehilangan log. Untuk masalah klasifikasi multikelas, metrik evaluasi dan fungsi kerugian adalah entropi silang multiklas. Anda dapat menggunakan `eval_metric` hyperparameter untuk mengubah metrik evaluasi default. Lihat tabel berikut untuk informasi selengkapnya tentang hyperparameters LightGBM, termasuk deskripsi, nilai valid, dan nilai default.
| Nama Parameter | Deskripsi |
| --- | --- |
| iterations | Jumlah maksimum pohon yang dapat dibangun. Nilai yang valid: bilangan bulat, rentang: Bilangan bulat positif. Nilai default:`500`. |
| early\$1stopping\$1rounds | Pelatihan akan berhenti jika satu metrik dari satu titik data validasi tidak membaik di `early_stopping_rounds` babak terakhir. Jika `early_stopping_rounds` kurang dari atau sama dengan nol, hyperparameter ini diabaikan. Nilai yang valid: bilangan bulat. Nilai default:`5`. |
| eval\$1metric | Metrik evaluasi untuk data validasi. Jika `eval_metric` diatur ke `"auto"` nilai default, maka algoritme secara otomatis memilih metrik evaluasi berdasarkan jenis masalah klasifikasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/catboost-hyperparameters.html) Nilai yang valid: string, lihat [CatBoost dokumentasi](https://catboost.ai/en/docs/references/eval-metric__supported-metrics) untuk nilai yang valid. Nilai default:`"auto"`. |
| learning\$1rate | Tingkat di mana bobot model diperbarui setelah mengerjakan setiap batch contoh pelatihan. Nilai yang valid: float, range: (`0.0`,`1.0`). Nilai default:`0.009`. |
| depth | Kedalaman pohon. Nilai yang valid: integer, range: (`1`,`16`). Nilai default:`6`. |
| l2\$1leaf\$1reg | Koefisien untuk jangka waktu regularisasi L2 dari fungsi biaya. Nilai yang valid: bilangan bulat, rentang: Bilangan bulat positif. Nilai default:`3`. |
| random\$1strength | Jumlah keacakan yang digunakan untuk penilaian terbelah ketika struktur pohon dipilih. Gunakan parameter ini untuk menghindari model yang terlalu pas. Nilai yang valid: float, range: Nomor floating point positif. Nilai default:`1.0`. |
| max\$1leaves | Jumlah maksimum daun di pohon yang dihasilkan. Hanya dapat digunakan dengan kebijakan yang `"Lossguide"` berkembang. Nilai yang valid: integer, range: [`2`,`64`]. Nilai default:`31`. |
| rsm | Metode subruang acak. Persentase fitur yang akan digunakan pada setiap pemilihan split, ketika fitur dipilih lagi secara acak. Nilai yang valid: float, range: (`0.0`,`1.0`]. Nilai default:`1.0`. |
| sampling\$1frequency | Frekuensi untuk mengambil sampel bobot dan benda saat membangun pohon. Nilai yang valid: string, baik: (`"PerTreeLevel"`atau`"PerTree"`). Nilai default:`"PerTreeLevel"`. |
| min\$1data\$1in\$1leaf | Jumlah minimum sampel pelatihan dalam satu daun. CatBoost tidak mencari split baru di daun dengan jumlah sampel kurang dari nilai yang ditentukan. Hanya dapat digunakan dengan kebijakan yang `"Depthwise"` berkembang `"Lossguide"` dan berkembang. Nilai yang valid: bilangan bulat, rentang: (`1`atau`∞`). Nilai default:`1`. |
| bagging\$1temperature | Mendefinisikan pengaturan bootstrap Bayesian. Gunakan bootstrap Bayesian untuk menetapkan bobot acak ke objek. Jika `bagging_temperature` diatur ke`1.0`, maka bobot diambil sampelnya dari distribusi eksponensial. Jika `bagging_temperature` diatur ke`0.0`, maka semua bobot adalah 1.0. Nilai yang valid: float, range: Float non-negatif. Nilai default:`1.0`. |
| boosting\$1type | Skema peningkatan. “Otomatis” berarti `boosting_type` dipilih berdasarkan jenis unit pemrosesan, jumlah objek dalam kumpulan data pelatihan, dan mode pembelajaran yang dipilih. Nilai yang valid: string, salah satu dari berikut ini: (`"Auto"`,`"Ordered"`,`"Plain"`). Nilai default:`"Auto"`. |
| scale\$1pos\$1weight | Bobot untuk kelas positif dalam klasifikasi biner. Nilai ini digunakan sebagai pengganda untuk bobot objek dari kelas positif. Nilai yang valid: float, range: Positive float. Nilai default:`1.0`. |
| max\$1bin | Jumlah split untuk fitur numerik. `"Auto"`berarti yang `max_bin` dipilih berdasarkan jenis unit pengolahan dan parameter lainnya. Untuk detailnya, lihat CatBoost dokumentasi. Nilai yang valid: string, baik: (`"Auto"`atau string integer dari `"1"` ke `"65535"` inklusif). Nilai default:`"Auto"`. |
| grow\$1policy | Kebijakan penanaman pohon. Mendefinisikan bagaimana melakukan konstruksi pohon serakah. Nilai yang valid: string, salah satu dari berikut ini: (`"SymmetricTree"`,`"Depthwise"`, atau`"Lossguide"`). Nilai default:`"SymmetricTree"`. |
| random\$1seed | Benih acak yang digunakan untuk pelatihan. Nilai yang valid: bilangan bulat, rentang: Bilangan bulat non-negatif. Nilai default:`1.0`. |
| thread\$1count | Jumlah utas yang akan digunakan selama pelatihan. Jika `thread_count` ya`-1`, maka jumlah utas sama dengan jumlah inti prosesor. `thread_count`tidak bisa`0`. Nilai valid: integer, baik: (`-1`atau bilangan bulat positif). Nilai default:`-1`. |
| verbose | Verbositas pesan cetak, dengan tingkat yang lebih tinggi sesuai dengan pernyataan cetak yang lebih rinci. Nilai yang valid: bilangan bulat, rentang: Bilangan bulat positif. Nilai default:`1`. |
# Menyetel CatBoost model
*Penyetelan model otomatis*, juga dikenal sebagai tuning hyperparameter, menemukan versi terbaik dari model dengan menjalankan banyak pekerjaan yang menguji berbagai hiperparameter pada kumpulan data pelatihan dan validasi Anda. Penyetelan model berfokus pada hiperparameter berikut:
**catatan**
Fungsi kehilangan pembelajaran secara otomatis ditetapkan berdasarkan jenis tugas klasifikasi, yang ditentukan oleh jumlah bilangan bulat unik di kolom label. Untuk informasi selengkapnya, lihat [CatBoost hiperparameter](catboost-hyperparameters.md).
+ Fungsi kehilangan belajar untuk mengoptimalkan selama pelatihan model
+ Metrik evaluasi yang digunakan untuk mengevaluasi kinerja model selama validasi
+ Satu set hyperparameters dan rentang nilai untuk masing-masing untuk digunakan saat menyetel model secara otomatis
Penyetelan model otomatis mencari hiperparameter pilihan Anda untuk menemukan kombinasi nilai yang menghasilkan model yang mengoptimalkan metrik evaluasi yang dipilih.
**catatan**
Penyetelan model otomatis hanya CatBoost tersedia dari Amazon SageMaker SDKs, bukan dari konsol SageMaker AI.
Untuk informasi selengkapnya tentang penyetelan model, lihat[Penyetelan model otomatis dengan AI SageMaker](automatic-model-tuning.md).
## Metrik evaluasi dihitung oleh algoritme CatBoost
CatBoost Algoritma SageMaker AI menghitung metrik berikut untuk digunakan untuk validasi model. Metrik evaluasi secara otomatis ditetapkan berdasarkan jenis tugas klasifikasi, yang ditentukan oleh jumlah bilangan bulat unik di kolom label.
| Nama Metrik | Deskripsi | Arah Optimasi | Pola Regex |
| --- | --- | --- | --- |
| RMSE | kesalahan kuadrat rata-rata akar | memperkecil | "bestTest = ([0-9\$1\$1.]\$1)" |
| MAE | berarti kesalahan absolut | memperkecil | "bestTest = ([0-9\$1\$1.]\$1)" |
| MedianAbsoluteError | kesalahan absolut median | memperkecil | "bestTest = ([0-9\$1\$1.]\$1)" |
| R2 | skor r2 | memaksimalkan | "bestTest = ([0-9\$1\$1.]\$1)" |
| Logloss | entropi silang biner | memaksimalkan | "bestTest = ([0-9\$1\$1.]\$1)" |
| Precision | ketepatan | memaksimalkan | "bestTest = ([0-9\$1\$1.]\$1)" |
| Recall | penarikan | memaksimalkan | "bestTest = ([0-9\$1\$1.]\$1)" |
| F1 | skor f1 | memaksimalkan | "bestTest = ([0-9\$1\$1.]\$1)" |
| AUC | skor auc | memaksimalkan | "bestTest = ([0-9\$1\$1.]\$1)" |
| MultiClass | entropi silang multiclass | memaksimalkan | "bestTest = ([0-9\$1\$1.]\$1)" |
| Accuracy | ketepatan | memaksimalkan | "bestTest = ([0-9\$1\$1.]\$1)" |
| BalancedAccuracy | akurasi seimbang | memaksimalkan | "bestTest = ([0-9\$1\$1.]\$1)" |
## Hiperparameter yang dapat disetel CatBoost
Setel CatBoost model dengan hyperparameters berikut. Hiperparameter yang memiliki efek terbesar dalam mengoptimalkan metrik CatBoost evaluasi adalah:`learning_rate`,,`depth`, `l2_leaf_reg` dan. `random_strength` Untuk daftar semua CatBoost hyperparameters, lihat[CatBoost hiperparameter](catboost-hyperparameters.md).
| Nama Parameter | Jenis Parameter | Rentang yang Direkomendasikan |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001, MaxValue: 0,01 |
| depth | IntegerParameterRanges | MinValue: 4, MaxValue: 10 |
| l2\$1leaf\$1reg | IntegerParameterRanges | MinValue: 2, MaxValue: 10 |
| random\$1strength | ContinuousParameterRanges | MinValue: 0, MaxValue: 10 |
# Algoritma Mesin Faktorisasi
Algoritma Factorization Machines adalah algoritma pembelajaran terawasi tujuan umum yang dapat Anda gunakan untuk tugas klasifikasi dan regresi. Ini adalah perpanjangan dari model linier yang dirancang untuk menangkap interaksi antara fitur dalam kumpulan data jarang dimensi tinggi secara ekonomis. Misalnya, dalam sistem prediksi klik, model Mesin Faktorisasi dapat menangkap pola rasio klik yang diamati saat iklan dari kategori iklan tertentu ditempatkan pada halaman dari kategori halaman tertentu. Mesin faktorisasi adalah pilihan yang baik untuk tugas-tugas yang berhubungan dengan kumpulan data jarang dimensi tinggi, seperti prediksi klik dan rekomendasi item.
**catatan**
Implementasi Amazon SageMaker AI dari algoritma Factorization Machines hanya mempertimbangkan interaksi berpasangan (urutan ke-2) antar fitur.
**Topics**
+ [Antarmuka Input/Output untuk Algoritma Mesin Faktorisasi](#fm-inputoutput)
+ [Rekomendasi Instans EC2 untuk Algoritma Mesin Faktorisasi](#fm-instances)
+ [Mesin Faktorisasi Contoh Notebook](#fm-sample-notebooks)
+ [Bagaimana Mesin Faktorisasi Bekerja](fact-machines-howitworks.md)
+ [Mesin Faktorisasi Hyperparameters](fact-machines-hyperparameters.md)
+ [Menyetel Model Mesin Faktorisasi](fm-tuning.md)
+ [Format Respon Mesin Faktorisasi](fm-in-formats.md)
## Antarmuka Input/Output untuk Algoritma Mesin Faktorisasi
Algoritma Factorization Machines dapat dijalankan baik dalam mode klasifikasi biner atau mode regresi. Dalam setiap mode, kumpulan data dapat diberikan ke saluran **uji** bersama dengan kumpulan data saluran kereta api. Skor tergantung pada mode yang digunakan. Dalam mode regresi, dataset pengujian dinilai menggunakan Root Mean Square Error (RMSE). Dalam mode klasifikasi biner, kumpulan data pengujian dinilai menggunakan Binary Cross Entropy (Log Loss), Akurasi (pada ambang = 0,5) dan Skor F1 (pada ambang = 0,5).
Untuk **pelatihan**, algoritma Mesin Faktorisasi saat ini hanya mendukung `recordIO-protobuf` format dengan `Float32` tensor. Karena kasus penggunaan mereka sebagian besar pada data yang jarang, `CSV` bukan kandidat yang baik. Pelatihan mode File dan Pipa didukung untuk protobuf yang dibungkus Recordio.
Untuk **inferensi**, algoritma Mesin Faktorisasi mendukung dan format. `application/json` `x-recordio-protobuf`
+ Untuk masalah **klasifikasi biner**, algoritma memprediksi skor dan label. Label adalah angka dan bisa berupa `0` atau`1`. Skor adalah angka yang menunjukkan seberapa kuat algoritma percaya bahwa label seharusnya`1`. Algoritma menghitung skor terlebih dahulu dan kemudian mendapatkan label dari nilai skor. Jika skor lebih besar dari atau sama dengan 0,5, labelnya adalah`1`.
+ Untuk masalah **regresi**, hanya skor yang dikembalikan dan itu adalah nilai yang diprediksi. Misalnya, jika Mesin Faktorisasi digunakan untuk memprediksi peringkat film, skor adalah nilai peringkat yang diprediksi.
Silakan lihat [Mesin Faktorisasi Contoh Notebook](#fm-sample-notebooks) untuk detail lebih lanjut tentang format file pelatihan dan inferensi.
## Rekomendasi Instans EC2 untuk Algoritma Mesin Faktorisasi
Algoritma Amazon SageMaker AI Factorization Machines sangat skalabel dan dapat dilatih di seluruh instans terdistribusi. Kami merekomendasikan pelatihan dan inferensi dengan instance CPU untuk kumpulan data yang jarang dan padat. Dalam beberapa keadaan, pelatihan dengan satu atau lebih GPUs tentang data padat mungkin memberikan beberapa manfaat. Pelatihan dengan hanya GPUs tersedia pada data padat. Gunakan instance CPU untuk data yang jarang. Algoritma Mesin Faktorisasi mendukung instans P2, P3, G4dn, dan G5 untuk pelatihan dan inferensi.
## Mesin Faktorisasi Contoh Notebook
[Untuk contoh notebook yang menggunakan algoritme Mesin Faktorisasi SageMaker AI untuk menganalisis gambar digit tulisan tangan dari nol hingga sembilan dalam kumpulan data MNIST, lihat Pengantar Mesin Faktorisasi dengan MNIST.](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/factorization_machines_mnist/factorization_machines_mnist.html) Untuk petunjuk cara membuat dan mengakses instance notebook Jupyter yang dapat Anda gunakan untuk menjalankan contoh di SageMaker AI, lihat. [Instans SageMaker notebook Amazon](nbi.md) Setelah Anda membuat instance notebook dan membukanya, pilih tab **Contoh SageMaker AI** untuk melihat daftar semua sampel SageMaker AI. Contoh notebook yang menggunakan algoritma Mesin Faktorisasi terletak di bagian Pengantar Algoritma **Amazon**. Untuk membuka buku catatan, klik tab **Use** dan pilih **Create copy**.
# Bagaimana Mesin Faktorisasi Bekerja
Tugas prediksi untuk model Mesin Faktorisasi adalah memperkirakan fungsi dari set fitur x i ke domain target. Domain ini bernilai nyata untuk regresi dan biner untuk klasifikasi. Model Mesin Faktorisasi diawasi dan memiliki dataset pelatihan (xi, y) yang tersedia. j Keuntungan yang disajikan model ini terletak pada cara menggunakan parametriisasi yang difaktorisasi untuk menangkap interaksi fitur berpasangan. Ini dapat direpresentasikan secara matematis sebagai berikut:
![\[Gambar yang berisi persamaan untuk model Mesin Faktorisasi.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/FM1.jpg)
Tiga istilah dalam persamaan ini masing-masing sesuai dengan tiga komponen model:
+ 0Istilah w mewakili bias global.
+ Istilah i linier w memodelkan kekuatan variabel i th.
+ Istilah faktorisasi memodelkan interaksi berpasangan antara variabel i th dan j th.
Bias global dan istilah linier sama dengan model linier. Interaksi fitur berpasangan dimodelkan dalam suku ketiga sebagai produk dalam dari faktor-faktor terkait yang dipelajari untuk setiap fitur. Faktor yang dipelajari juga dapat dianggap sebagai vektor penyematan untuk setiap fitur. Misalnya, dalam tugas klasifikasi, jika sepasang fitur cenderung lebih sering terjadi bersamaan dalam sampel berlabel positif, maka produk bagian dalam dari faktor-faktor mereka akan besar. Dengan kata lain, vektor penyematan mereka akan dekat satu sama lain dalam kesamaan kosinus. Untuk informasi lebih lanjut tentang model Mesin Faktorisasi, lihat Mesin [Faktorisasi](https://www.ismll.uni-hildesheim.de/pub/pdfs/Rendle2010FM.pdf).
Untuk tugas regresi, model dilatih dengan meminimalkan kesalahan kuadrat antara prediksi model n dan nilai target y. n Ini dikenal sebagai kerugian kuadrat:
![\[Gambar yang berisi persamaan untuk kerugian kuadrat.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/FM2.jpg)
Untuk tugas klasifikasi, model dilatih dengan meminimalkan kehilangan entropi silang, juga dikenal sebagai kehilangan log:
![\[Gambar yang berisi persamaan kehilangan log.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/FM3.jpg)
di mana:
![\[Gambar yang berisi fungsi logistik dari nilai yang diprediksi.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/FM4.jpg)
Untuk informasi selengkapnya tentang fungsi kerugian untuk klasifikasi, lihat [Fungsi kerugian untuk klasifikasi](https://en.wikipedia.org/wiki/Loss_functions_for_classification).
# Mesin Faktorisasi Hyperparameters
Tabel berikut berisi hyperparameters untuk algoritma Factorization Machines. Ini adalah parameter yang ditetapkan oleh pengguna untuk memfasilitasi estimasi parameter model dari data. Hyperparameter yang diperlukan yang harus ditetapkan terdaftar terlebih dahulu, dalam urutan abjad. Hyperparameter opsional yang dapat diatur tercantum berikutnya, juga dalam urutan abjad.
| Nama Parameter | Deskripsi |
| --- | --- |
| feature\$1dim | Dimensi ruang fitur input. Ini bisa sangat tinggi dengan input yang jarang. **Diperlukan** Nilai yang valid: Bilangan bulat positif. Rentang nilai yang disarankan: [10000,10000000] |
| num\$1factors | Dimensionalitas faktorisasi. **Diperlukan** Nilai yang valid: Bilangan bulat positif. Rentang nilai yang disarankan: [2.000], 64 biasanya menghasilkan hasil yang baik dan merupakan titik awal yang baik. |
| predictor\$1type | Jenis prediktor. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Diperlukan** Nilai yang valid: String: `binary_classifier` atau `regressor` |
| bias\$1init\$1method | Metode inisialisasi untuk istilah bias: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Opsional** Nilai valid: `uniform`, `normal`, atau `constant` Nilai default: `normal` |
| bias\$1init\$1scale | Rentang untuk inisialisasi istilah bias. Berlaku jika `bias_init_method` diatur ke`uniform`. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: Tidak ada |
| bias\$1init\$1sigma | Standar deviasi untuk inisialisasi istilah bias. Berlaku jika `bias_init_method` diatur ke`normal`. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: 0,01 |
| bias\$1init\$1value | Nilai awal istilah bias. Berlaku jika `bias_init_method` diatur ke`constant`. **Opsional** Nilai yang valid: Float. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: Tidak ada |
| bias\$1lr | Tingkat pembelajaran untuk istilah bias. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: 0,1 |
| bias\$1wd | Peluruhan berat untuk istilah bias. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: 0,01 |
| clip\$1gradient | Parameter pengoptimal kliping gradien. Klip gradien dengan memproyeksikan ke interval [-`clip_gradient`, \$1`clip_gradient`]. **Opsional** Nilai yang valid: Float Nilai default: Tidak ada |
| epochs | Jumlah zaman pelatihan untuk dijalankan. **Opsional** Nilai yang valid: Bilangan bulat positif Nilai default: 1 |
| eps | Parameter Epsilon untuk menghindari pembagian dengan 0. **Opsional** Nilai yang valid: Float. Nilai yang disarankan: kecil. Nilai default: Tidak ada |
| factors\$1init\$1method | Metode inisialisasi untuk istilah faktorisasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Opsional** Nilai yang valid:`uniform`,`normal`, atau`constant`. Nilai default: `normal` |
| factors\$1init\$1scale | Rentang untuk inisialisasi istilah faktorisasi. Berlaku jika `factors_init_method` diatur ke`uniform`. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: Tidak ada |
| factors\$1init\$1sigma | Standar deviasi untuk inisialisasi istilah faktorisasi. Berlaku jika `factors_init_method` diatur ke`normal`. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: 0,001 |
| factors\$1init\$1value | Nilai awal istilah faktorisasi. Berlaku jika `factors_init_method` diatur ke`constant`. **Opsional** Nilai yang valid: Float. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: Tidak ada |
| factors\$1lr | Tingkat pembelajaran untuk istilah faktorisasi. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: 0,0001 |
| factors\$1wd | Peluruhan berat untuk istilah faktorisasi. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: 0,00001 |
| linear\$1lr | Tingkat pembelajaran untuk istilah linier. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: 0,001 |
| linear\$1init\$1method | Metode inisialisasi untuk istilah linier: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Opsional** Nilai yang valid:`uniform`,`normal`, atau`constant`. Nilai default: `normal` |
| linear\$1init\$1scale | Rentang untuk inisialisasi istilah linier. Berlaku jika `linear_init_method` diatur ke`uniform`. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: Tidak ada |
| linear\$1init\$1sigma | Standar deviasi untuk inisialisasi istilah linier. Berlaku jika `linear_init_method` diatur ke`normal`. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: 0,01 |
| linear\$1init\$1value | Nilai awal istilah linier. Berlaku jika `linear_init_method` diatur ke *konstan*. **Opsional** Nilai yang valid: Float. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: Tidak ada |
| linear\$1wd | Peluruhan berat untuk istilah linier. **Opsional** Nilai yang valid: Float non-negatif. Rentang nilai yang disarankan: [1e-8, 512]. Nilai default: 0,001 |
| mini\$1batch\$1size | Ukuran mini-batch yang digunakan untuk pelatihan. **Opsional** Nilai yang valid: Bilangan bulat positif Nilai default: 1000 |
| rescale\$1grad | Parameter pengoptimal penskalaan ulang gradien. Jika diatur, kalikan gradien dengan `rescale_grad` sebelum memperbarui. Sering memilih menjadi 1.0/`batch_size`. **Opsional** Nilai yang valid: Float Nilai default: Tidak ada |
# Menyetel Model Mesin Faktorisasi
*Penyetelan model otomatis*, juga dikenal sebagai tuning hyperparameter, menemukan versi terbaik dari model dengan menjalankan banyak pekerjaan yang menguji berbagai hiperparameter pada kumpulan data Anda. Anda memilih hyperparameters yang dapat disetel, rentang nilai untuk masing-masing, dan metrik objektif. Anda memilih metrik objektif dari metrik yang dihitung algoritme. Penyetelan model otomatis mencari hiperparameter yang dipilih untuk menemukan kombinasi nilai yang menghasilkan model yang mengoptimalkan metrik objektif.
Untuk informasi selengkapnya tentang penyetelan model, lihat[Penyetelan model otomatis dengan AI SageMaker](automatic-model-tuning.md).
## Metrik yang Dihitung oleh Algoritma Mesin Faktorisasi
Algoritma Mesin Faktorisasi memiliki klasifikasi biner dan tipe prediktor regresi. Jenis prediktor menentukan metrik mana yang dapat Anda gunakan untuk penyetelan model otomatis. Algoritma melaporkan metrik `test:rmse` regressor, yang dihitung selama pelatihan. Saat menyetel model untuk tugas regresi, pilih metrik ini sebagai tujuannya.
| Nama Metrik | Deskripsi | Arah Optimasi |
| --- | --- | --- |
| test:rmse | Root Mean Square Error | Minimalkan |
Algoritma Mesin Faktorisasi melaporkan tiga metrik klasifikasi biner, yang dihitung selama pelatihan. Saat menyetel model untuk tugas klasifikasi biner, pilih salah satunya sebagai tujuannya.
| Nama Metrik | Deskripsi | Arah Optimasi |
| --- | --- | --- |
| test:binary\$1classification\$1accuracy | Akurasi | Maksimalkan |
| test:binary\$1classification\$1cross\$1entropy | Entropi Lintas | Minimalkan |
| test:binary\$1f\$1beta | Beta | Maksimalkan |
## Mesin Factorisasi Tunable Hyperparameters
Anda dapat menyetel hiperparameter berikut untuk algoritma Mesin Faktorisasi. Parameter inisialisasi yang berisi istilah bias, linier, dan faktorisasi bergantung pada metode inisialisasi mereka. Ada tiga metode inisialisasi:`uniform`,`normal`, dan`constant`. Metode inisialisasi ini sendiri tidak dapat disetel. Parameter yang dapat disetel tergantung pada pilihan metode inisialisasi ini. Misalnya, jika metode inisialisasi adalah`uniform`, maka hanya `scale` parameter yang dapat disetel. Khususnya, jika`bias_init_method==uniform`, kemudian `bias_init_scale``linear_init_scale`, dan dapat `factors_init_scale` disetel. Demikian pula, jika metode inisialisasi adalah`normal`, maka hanya `sigma` parameter yang dapat disetel. Jika metode inisialisasi adalah`constant`, maka hanya `value` parameter yang dapat disetel. Dependensi ini tercantum dalam tabel berikut.
| Nama Parameter | Jenis Parameter | Rentang yang Direkomendasikan | Dependensi |
| --- | --- | --- | --- |
| bias\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method==seragam |
| bias\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method== normal |
| bias\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method== konstan |
| bias\$1lr | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | Tidak ada |
| bias\$1wd | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | Tidak ada |
| epoch | IntegerParameterRange | MinValue: 1, MaxValue: 1000 | Tidak ada |
| factors\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method==seragam |
| factors\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method== normal |
| factors\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method== konstan |
| factors\$1lr | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | Tidak ada |
| factors\$1wd | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512] | Tidak ada |
| linear\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method==seragam |
| linear\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method== normal |
| linear\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | bias\$1init\$1method== konstan |
| linear\$1lr | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | Tidak ada |
| linear\$1wd | ContinuousParameterRange | MinValue: 1e-8, MaxValue: 512 | Tidak ada |
| mini\$1batch\$1size | IntegerParameterRange | MinValue: 100, MaxValue: 10000 | Tidak ada |
# Format Respon Mesin Faktorisasi
Amazon SageMaker AI menyediakan beberapa format respons untuk mendapatkan inferensi dari model Mesin Faktorisasi, seperti JSON, JSONLINES, dan RECORDIO, dengan struktur khusus untuk tugas klasifikasi dan regresi biner.
## Format Respons JSON
Klasifikasi biner
```
let response = {
"predictions": [
{
"score": 0.4,
"predicted_label": 0
}
]
}
```
Regresi
```
let response = {
"predictions": [
{
"score": 0.4
}
]
}
```
## Format Respons JSONLINES
Klasifikasi biner
```
{"score": 0.4, "predicted_label": 0}
```
Regresi
```
{"score": 0.4}
```
## Format Respons RECORDIO
Klasifikasi biner
```
[
Record = {
features = {},
label = {
'score’: {
keys: [],
values: [0.4] # float32
},
'predicted_label': {
keys: [],
values: [0.0] # float32
}
}
}
]
```
Regresi
```
[
Record = {
features = {},
label = {
'score’: {
keys: [],
values: [0.4] # float32
}
}
}
]
```
# Algoritma K-Nearest Neighbors (k-NN)
Algoritma Amazon SageMaker AI k-Nearest Neighbors (K-NN) adalah algoritma berbasis indeks. Ini menggunakan metode non-parametrik untuk klasifikasi atau regresi. Untuk masalah klasifikasi, algoritme menanyakan titik *k* yang paling dekat dengan titik sampel dan mengembalikan label kelas yang paling sering digunakan sebagai label yang diprediksi. Untuk masalah regresi, algoritme menanyakan *k* titik terdekat ke titik sampel dan mengembalikan rata-rata nilai fitur mereka sebagai nilai prediksi.
Pelatihan dengan algoritma K-NN memiliki tiga langkah: pengambilan sampel, pengurangan dimensi, dan pembangunan indeks. Pengambilan sampel mengurangi ukuran dataset awal sehingga cocok dengan memori. Untuk pengurangan dimensi, algoritme mengurangi dimensi fitur data untuk mengurangi jejak model k-NN dalam memori dan latensi inferensi. Kami menyediakan dua metode metode reduksi dimensi: proyeksi acak dan transformasi Johnson-Lindenstrauss yang cepat. Biasanya, Anda menggunakan pengurangan dimensi untuk kumpulan data dimensi tinggi (d >1000) untuk menghindari “kutukan dimensi” yang mengganggu analisis statistik data yang menjadi jarang saat dimensi meningkat. Tujuan utama pelatihan K-NN adalah untuk membangun indeks. Indeks memungkinkan pencarian jarak yang efisien antara titik-titik yang nilai atau label kelasnya belum ditentukan dan k titik terdekat untuk digunakan untuk inferensi.
**Topics**
+ [Antarmuka Input/Output untuk Algoritma K-nN](#kNN-input_output)
+ [K-nn Contoh Notebook](#kNN-sample-notebooks)
+ [Bagaimana Algoritma K-NN Bekerja](kNN_how-it-works.md)
+ [Rekomendasi Instans EC2 untuk Algoritma k-NN](#kNN-instances)
+ [Hiperparameter K-nn](kNN_hyperparameters.md)
+ [Menyetel Model K-NN](kNN-tuning.md)
+ [Format Data untuk Input Pelatihan K-nn](kNN-in-formats.md)
+ [Format Permintaan dan Respons K-nn](kNN-inference-formats.md)
## Antarmuka Input/Output untuk Algoritma K-nN
SageMaker AI k-NN mendukung saluran data kereta dan uji.
+ Gunakan *saluran kereta* untuk data yang ingin Anda sampel dan bangun ke dalam indeks k-NN.
+ Gunakan *saluran uji* untuk memancarkan skor dalam file log. Skor terdaftar sebagai satu baris per batch mini: akurasi untuk`classifier`, kesalahan kuadrat rata-rata (mse) untuk skor. `regressor`
Untuk input pelatihan, K-NN mendukung `text/csv` dan `application/x-recordio-protobuf` format data. Untuk tipe input`text/csv`, `label_size` kolom pertama ditafsirkan sebagai vektor label untuk baris itu. Anda dapat menggunakan mode File atau mode Pipa untuk melatih model pada data yang diformat sebagai `recordIO-wrapped-protobuf` atau sebagai`CSV`.
Untuk input inferensi, k-NN mendukung format`application/json`,`application/x-recordio-protobuf`, dan data. `text/csv` `text/csv`Format menerima parameter `label_size` dan encoding. Ini mengasumsikan 0 dan `label_size` pengkodean UTF-8.
Untuk output inferensi, k-NN mendukung format dan data. `application/json` `application/x-recordio-protobuf` Kedua format data ini juga mendukung mode keluaran verbose. Dalam mode keluaran verbose, API menyediakan hasil pencarian dengan vektor jarak yang diurutkan dari terkecil hingga terbesar, dan elemen yang sesuai dalam vektor label.
Untuk transformasi batch, k-NN mendukung format `application/jsonlines` data untuk input dan output. Contoh masukan adalah sebagai berikut:
```
content-type: application/jsonlines
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```
Contoh output adalah sebagai berikut:
```
accept: application/jsonlines
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```
Untuk informasi lebih lanjut tentang format file input dan output, lihat [Format Data untuk Input Pelatihan K-nn](kNN-in-formats.md) untuk pelatihan, [Format Permintaan dan Respons K-nn](kNN-inference-formats.md) untuk inferensi, dan file. [K-nn Contoh Notebook](#kNN-sample-notebooks)
## K-nn Contoh Notebook
Untuk contoh notebook yang menggunakan algoritme tetangga terdekat SageMaker AI k-terdekat untuk memprediksi jenis tutupan hutan belantara dari data geologi dan layanan kehutanan, lihat [K-Nearest](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/k_nearest_neighbors_covtype/k_nearest_neighbors_covtype.html) Neighbor Covertype.
Gunakan instance notebook Jupyter untuk menjalankan contoh di SageMaker AI. Untuk mempelajari cara membuat dan membuka instance notebook Jupyter di SageMaker AI, lihat. [Instans SageMaker notebook Amazon](nbi.md) Setelah Anda membuat instance notebook dan membukanya, pilih tab **Contoh SageMaker AI** untuk melihat daftar semua notebook contoh SageMaker AI. Temukan notebook K-Nearest Neighbor di bagian **Pengantar Algoritma Amazon**. Untuk membuka buku catatan, klik tab **Use** dan pilih **Create copy**.
# Bagaimana Algoritma K-NN Bekerja
Algoritma Amazon SageMaker AI k-nearest neighbors (k-NN) mengikuti proses pelatihan multi-langkah yang mencakup pengambilan sampel data input, melakukan pengurangan dimensi, dan membangun indeks. Data yang diindeks kemudian digunakan selama inferensi untuk secara efisien menemukan k-tetangga terdekat untuk titik data tertentu dan membuat prediksi berdasarkan label atau nilai tetangga.
## Langkah 1: Sampel
Untuk menentukan jumlah total titik data yang akan diambil sampelnya dari kumpulan data pelatihan, gunakan parameternya`sample_size`. Misalnya, jika dataset awal memiliki 1.000 titik data dan `sample_size` diatur ke 100, di mana jumlah total instance adalah 2, setiap pekerja akan mengambil sampel 50 poin. Satu set total 100 titik data akan dikumpulkan. Pengambilan sampel berjalan dalam waktu linier sehubungan dengan jumlah titik data.
## Langkah 2: Lakukan Pengurangan Dimensi
Implementasi algoritma k-NN saat ini memiliki dua metode pengurangan dimensi. Anda menentukan metode di `dimension_reduction_type` hyperparameter. `sign`Metode ini menentukan proyeksi acak, yang menggunakan proyeksi linier menggunakan matriks tanda acak, dan `fjlt` metode menentukan transformasi Johnson-Lindenstrauss yang cepat, metode berdasarkan transformasi Fourier. Kedua metode mempertahankan jarak produk L2 dan bagian dalam. `fjlt`Metode ini harus digunakan ketika dimensi target besar dan memiliki kinerja yang lebih baik dengan inferensi CPU. Metode berbeda dalam kompleksitas komputasi mereka. `sign`Metode ini membutuhkan waktu O (ndk) untuk mengurangi dimensi batch n titik dimensi d menjadi dimensi target k. `fjlt`Metode ini membutuhkan waktu O (nd log (d)), tetapi konstanta yang terlibat lebih besar. Menggunakan pengurangan dimensi memperkenalkan noise ke dalam data dan noise ini dapat mengurangi akurasi prediksi.
## Langkah 3: Membangun Indeks
Selama inferensi, algoritme menanyakan indeks untuk k-nearest-neighbors titik sampel. Berdasarkan referensi ke poin, algoritma membuat klasifikasi atau prediksi regresi. Itu membuat prediksi berdasarkan label kelas atau nilai yang disediakan. k-NN menyediakan tiga jenis indeks yang berbeda: indeks datar, indeks terbalik, dan indeks terbalik dengan kuantisasi produk. Anda menentukan jenis dengan `index_type` parameter.
## Serialisasi Model
Ketika algoritma K-NN menyelesaikan pelatihan, ia membuat serial tiga file untuk mempersiapkan inferensi.
+ model\$1algo-1: Berisi indeks serial untuk menghitung tetangga terdekat.
+ model\$1algo-1.labels: Berisi label serial (format biner np.float32) untuk menghitung label yang diprediksi berdasarkan hasil kueri dari indeks.
+ model\$1algo-1.json: Berisi metadata model berformat JSON yang menyimpan parameter dan hiper dari pelatihan untuk inferensi bersama dengan status relevan lainnya. `k` `predictor_type`
Dengan implementasi k-NN saat ini, Anda dapat memodifikasi file metadata untuk mengubah cara prediksi dihitung. Misalnya, Anda dapat mengubah `k` ke 10 atau mengubah `predictor_type` ke *regressor*.
```
{
"k": 5,
"predictor_type": "classifier",
"dimension_reduction": {"type": "sign", "seed": 3, "target_dim": 10, "input_dim": 20},
"normalize": False,
"version": "1.0"
}
```
## Rekomendasi Instans EC2 untuk Algoritma k-NN
Kami merekomendasikan pelatihan pada instance CPU (seperti ml.m5.2xlarge) atau pada instance GPU. Algoritma K-nN mendukung keluarga instance GPU P2, P3, G4dn, dan G5 untuk pelatihan dan inferensi.
Permintaan inferensi dari CPUs umumnya memiliki latensi rata-rata yang lebih rendah daripada permintaan dari GPUs karena ada pajak atas CPU-to-GPU komunikasi ketika Anda menggunakan perangkat keras GPU. Namun, GPUs umumnya memiliki throughput yang lebih tinggi untuk batch yang lebih besar.
# Hiperparameter K-nn
Tabel berikut mencantumkan hyperparameters yang dapat Anda atur untuk algoritma Amazon SageMaker AI k-nearest neighbors (k-NN).
| Nama Parameter | Deskripsi |
| --- | --- |
| feature\$1dim | Jumlah fitur dalam data input. **Diperlukan** Nilai yang valid: bilangan bulat positif. |
| k | Jumlah tetangga terdekat. **Diperlukan** Nilai yang valid: bilangan bulat positif |
| predictor\$1type | Jenis inferensi yang digunakan pada label data. **Diperlukan** Nilai yang valid: *pengklasifikasi* untuk klasifikasi atau *regressor untuk regresi*. |
| sample\$1size | Jumlah titik data yang akan diambil sampelnya dari kumpulan data pelatihan. **Diperlukan** Nilai yang valid: bilangan bulat positif |
| dimension\$1reduction\$1target | Dimensi target untuk dikurangi menjadi. **Diperlukan** saat Anda menentukan `dimension_reduction_type` parameter. Nilai valid: bilangan bulat positif lebih besar dari 0 dan kurang dari`feature_dim`. |
| dimension\$1reduction\$1type | Jenis metode pengurangan dimensi. **Opsional** Nilai yang valid: *tanda* untuk proyeksi acak atau *fjlt untuk transformasi Johnson-Lindenstrauss* yang cepat. Nilai default: Tidak ada pengurangan dimensi |
| faiss\$1index\$1ivf\$1nlists | *Jumlah centroid yang akan dibangun dalam indeks kapan `index_type` adalah faiss. IVFFlat*atau *FAISS.IVFPQ*. **Opsional** Nilai yang valid: bilangan bulat positif Nilai default: *auto*, yang menyelesaikan ke. `sqrt(sample_size)` |
| faiss\$1index\$1pq\$1m | *Jumlah sub-komponen vektor yang akan dibangun dalam indeks ketika `index_type` diatur ke FAISS.IVFPQ.* Pustaka FaceBook AI Similarity Search (FAISS) mensyaratkan bahwa nilai `faiss_index_pq_m` adalah pembagi dimensi data. Jika `faiss_index_pq_m` bukan pembagi dimensi data, kami meningkatkan dimensi data menjadi bilangan bulat terkecil yang dapat dibagi dengan. `faiss_index_pq_m` Jika tidak ada pengurangan dimensi yang diterapkan, algoritma menambahkan padding nol. Jika pengurangan dimensi diterapkan, algoritma meningkatkan nilai parameter `dimension_reduction_target` hiper. **Opsional** Nilai yang valid: Salah satu bilangan bulat positif berikut: 1, 2, 3, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 96 |
| index\$1metric | Metrik untuk mengukur jarak antar titik saat menemukan tetangga terdekat. Saat berlatih dengan `index_type` set to`faiss.IVFPQ`, `INNER_PRODUCT` jarak dan `COSINE` kesamaan tidak didukung. **Opsional** *Nilai valid: *L2* untuk jarak Euclidean, *INNER\$1PRODUCT untuk jarak produk dalam, COSINE* untuk kesamaan kosinus.* Nilai default: *L2* |
| index\$1type | Jenis indeks. **Opsional** *Nilai yang valid: *Faiss.flat, faiss*. IVFFlat*, *FAISS.IVFPQ*. Nilai default: *Faiss.flat* |
| mini\$1batch\$1size | Jumlah pengamatan per mini-batch untuk iterator data. **Opsional** Nilai yang valid: bilangan bulat positif Nilai default: 5000 |
# Menyetel Model K-NN
Algoritma Amazon SageMaker AI k-terdekat tetangga adalah algoritma yang diawasi. Algoritma menggunakan kumpulan data uji dan memancarkan metrik tentang akurasi untuk tugas klasifikasi atau tentang kesalahan kuadrat rata-rata untuk tugas regresi. Metrik akurasi ini membandingkan prediksi model untuk tugas masing-masing dengan kebenaran dasar yang disediakan oleh data uji empiris. Untuk menemukan model terbaik yang melaporkan akurasi tertinggi atau kesalahan terendah pada kumpulan data pengujian, jalankan pekerjaan penyetelan hiperparameter untuk k-NN.
*Penyetelan model otomatis*, juga dikenal sebagai tuning hyperparameter, menemukan versi terbaik dari model dengan menjalankan banyak pekerjaan yang menguji berbagai hiperparameter pada kumpulan data Anda. Anda memilih hyperparameters yang dapat disetel, rentang nilai untuk masing-masing, dan metrik objektif. Anda memilih metrik objektif yang sesuai untuk tugas prediksi algoritma. Penyetelan model otomatis mencari hiperparameter yang dipilih untuk menemukan kombinasi nilai yang menghasilkan model yang mengoptimalkan metrik objektif. Hiperparameter hanya digunakan untuk membantu memperkirakan parameter model dan tidak digunakan oleh model terlatih untuk membuat prediksi.
Untuk informasi lebih lanjut tentang penyetelan model, lihat[Penyetelan model otomatis dengan AI SageMaker](automatic-model-tuning.md).
## Metrik yang Dihitung oleh Algoritma K-NN
Algoritma k-terdekat tetangga menghitung salah satu dari dua metrik dalam tabel berikut selama pelatihan tergantung pada jenis tugas yang ditentukan oleh parameter hiper. `predictor_type`
+ *classifier* menentukan tugas klasifikasi dan menghitung `test:accuracy`
+ *regressor* menentukan tugas regresi dan menghitung. `test:mse`
Pilih `predictor_type` nilai yang sesuai untuk jenis tugas yang dilakukan untuk menghitung metrik tujuan yang relevan saat menyetel model.
| Nama Metrik | Deskripsi | Arah Optimasi |
| --- | --- | --- |
| test:accuracy | Ketika `predictor_type` diatur ke *pengklasifikasi*, k-NN membandingkan label yang diprediksi, berdasarkan rata-rata label tetangga terdekat k, dengan label kebenaran dasar yang disediakan dalam data saluran uji. Akurasi yang dilaporkan berkisar dari 0,0 (0%) hingga 1,0 (100%). | Maksimalkan |
| test:mse | Ketika `predictor_type` diatur ke *regressor*, k-NN membandingkan label yang diprediksi, berdasarkan rata-rata label tetangga terdekat k, dengan label kebenaran dasar yang disediakan dalam data saluran uji. Kesalahan kuadrat rata-rata dihitung dengan membandingkan dua label. | Minimalkan |
## Hiperparameter K-nn yang dapat disetel
Setel model tetangga Amazon SageMaker AI k-terdekat dengan hiperparameter berikut.
| Nama Parameter | Jenis Parameter | Rentang yang Direkomendasikan |
| --- | --- | --- |
| k | IntegerParameterRanges | MinValue: 1, MaxValue: 1024 |
| sample\$1size | IntegerParameterRanges | MinValue: 256, MaxValue: 20000000 |
# Format Data untuk Input Pelatihan K-nn
Semua algoritma bawaan Amazon SageMaker AI mematuhi format pelatihan input umum yang dijelaskan dalam [Format Data Umum - Pelatihan](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-training.html). Topik ini berisi daftar format input yang tersedia untuk k-nearest-neighbor algoritme SageMaker AI.
## Format Data CSV
tipe konten: teks/csv; label\$1size = 1
```
4,1.2,1.3,9.6,20.3
```
`label_size`Kolom pertama ditafsirkan sebagai vektor label untuk baris itu.
## Format Data RECORDIO
tipe konten: aplikasi/ x-recordio-protobuf
```
[
Record = {
features = {
'values': {
values: [1.2, 1.3, 9.6, 20.3] # float32
}
},
label = {
'values': {
values: [4] # float32
}
}
}
]
}
```
# Format Permintaan dan Respons K-nn
Semua algoritme bawaan Amazon SageMaker AI mematuhi format inferensi input umum yang dijelaskan dalam [Format Data Umum -](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) Inferensi. Topik ini berisi daftar format keluaran yang tersedia untuk k-nearest-neighbor algoritme SageMaker AI.
## MASUKAN: Format Permintaan CSV
tipe konten: teks/csv
```
1.2,1.3,9.6,20.3
```
Ini menerima parameter `label_size` atau pengkodean. Ini mengasumsikan 0 dan `label_size` pengkodean utf-8.
## MASUKAN: Format Permintaan JSON
tipe konten: aplikasi/json
```
{
"instances": [
{"data": {"features": {"values": [-3, -1, -4, 2]}}},
{"features": [3.0, 0.1, 0.04, 0.002]}]
}
```
## MASUKAN: Format Permintaan JSONLINES
tipe konten: aplikasi/jsonlines
```
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```
## MASUKAN: Format Permintaan RECORDIO
tipe konten: aplikasi/ x-recordio-protobuf
```
[
Record = {
features = {
'values': {
values: [-3, -1, -4, 2] # float32
}
},
label = {}
},
Record = {
features = {
'values': {
values: [3.0, 0.1, 0.04, 0.002] # float32
}
},
label = {}
},
]
```
## KELUARAN: Format Respons JSON
terima: aplikasi/json
```
{
"predictions": [
{"predicted_label": 0.0},
{"predicted_label": 2.0}
]
}
```
## KELUARAN: Format Respons JSONLINES
terima: aplikasi/jsonlines
```
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```
## KELUARAN: Format Respons JSON VERBOSE
Dalam mode verbose, API menyediakan hasil pencarian dengan vektor jarak yang diurutkan dari terkecil hingga terbesar, dengan elemen yang sesuai dalam vektor label. Dalam contoh ini, k diatur ke 3.
terima: aplikasi/json; verbose=true
```
{
"predictions": [
{
"predicted_label": 0.0,
"distances": [3.11792408, 3.89746071, 6.32548437],
"labels": [0.0, 1.0, 0.0]
},
{
"predicted_label": 2.0,
"distances": [1.08470316, 3.04917915, 5.25393973],
"labels": [2.0, 2.0, 0.0]
}
]
}
```
## KELUARAN: Format Respons RECORDIO-PROTOBUF
tipe konten: aplikasi/ x-recordio-protobuf
```
[
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
}
}
},
Record = {
features = {},
label = {
'predicted_label': {
values: [2.0] # float32
}
}
}
]
```
## KELUARAN: Format Respons VERBOSE RECORDIO-PROTOBUF
Dalam mode verbose, API menyediakan hasil pencarian dengan vektor jarak yang diurutkan dari terkecil hingga terbesar, dengan elemen yang sesuai dalam vektor label. Dalam contoh ini, k diatur ke 3.
terima: aplikasi/x-recordio-protobuf; verbose=true
```
[
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
},
'distances': {
values: [3.11792408, 3.89746071, 6.32548437] # float32
},
'labels': {
values: [0.0, 1.0, 0.0] # float32
}
}
},
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
},
'distances': {
values: [1.08470316, 3.04917915, 5.25393973] # float32
},
'labels': {
values: [2.0, 2.0, 0.0] # float32
}
}
}
]
```
## SAMPEL OUTPUT untuk Algoritma K-nN
Untuk tugas regressor:
```
[06/08/2018 20:15:33 INFO 140026520049408] #test_score (algo-1) : ('mse', 0.013333333333333334)
```
Untuk tugas pengklasifikasi:
```
[06/08/2018 20:15:46 INFO 140285487171328] #test_score (algo-1) : ('accuracy', 0.98666666666666669)
```
# LightGBM
[LightGBM](https://lightgbm.readthedocs.io/en/latest/) adalah implementasi open-source yang populer dan efisien dari algoritma Gradient Boosting Decision Tree (GBDT). GBDT adalah algoritma pembelajaran yang diawasi yang mencoba memprediksi variabel target secara akurat dengan menggabungkan ansambel perkiraan dari serangkaian model yang lebih sederhana dan lebih lemah. LightGBM menggunakan teknik tambahan untuk secara signifikan meningkatkan efisiensi dan skalabilitas GBDT konvensional. Halaman ini mencakup informasi tentang rekomendasi instans Amazon EC2 dan contoh notebook untuk LightGBM.
# Cara menggunakan SageMaker AI LightGBM
Anda dapat menggunakan LightGBM sebagai algoritma bawaan Amazon SageMaker AI. Bagian berikut menjelaskan cara menggunakan LightGBM dengan Python SageMaker SDK. Untuk informasi tentang cara menggunakan LightGBM dari Amazon SageMaker Studio Classic UI, lihat. [SageMaker JumpStart model terlatih](studio-jumpstart.md)
+ **Gunakan LightGBM sebagai algoritma bawaan**
Gunakan algoritma built-in LightGBM untuk membangun wadah pelatihan LightGBM seperti yang ditunjukkan pada contoh kode berikut. Anda dapat secara otomatis melihat URI gambar algoritme bawaan LightGBM menggunakan SageMaker AI `image_uris.retrieve` API (atau `get_image_uri` API jika menggunakan Amazon [ SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) versi 2).
Setelah menentukan URI image LightGBM, Anda dapat menggunakan container LightGBM untuk membuat estimator menggunakan SageMaker AI Estimator API dan memulai pekerjaan pelatihan. Algoritma bawaan LightGBM berjalan dalam mode skrip, tetapi skrip pelatihan disediakan untuk Anda dan tidak perlu menggantinya. Jika Anda memiliki pengalaman luas menggunakan mode skrip untuk membuat pekerjaan SageMaker pelatihan, maka Anda dapat memasukkan skrip pelatihan LightGBM Anda sendiri.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "lightgbm-classification-model", "*", "training"
training_instance_type = "ml.m5.xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_multiclass/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"num_boost_round"
] = "500"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1, # for distributed training, specify an instance_count greater than 1
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"train": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Untuk informasi selengkapnya tentang cara mengatur LightGBM sebagai algoritma bawaan, lihat contoh notebook berikut.
+ [Klasifikasi tabel dengan Amazon SageMaker AI LightGBM dan algoritma CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)
+ [Regresi tabular dengan Amazon SageMaker AI LightGBM dan algoritma CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)
# Antarmuka Input dan Output untuk algoritma LightGBM
Peningkatan gradien beroperasi pada data tabular, dengan baris mewakili pengamatan, satu kolom mewakili variabel target atau label, dan kolom yang tersisa mewakili fitur.
Implementasi SageMaker AI LightGBM mendukung CSV untuk pelatihan dan inferensi:
+ Untuk **Pelatihan ContentType**, input yang valid harus berupa *teks/csv*.
+ *Untuk **Inferensi ContentType**, input yang valid harus teks/csv.*
**catatan**
Untuk pelatihan CSV, algoritme mengasumsikan bahwa variabel target ada di kolom pertama dan CSV tidak memiliki catatan header.
Untuk inferensi CSV, algoritme mengasumsikan bahwa input CSV tidak memiliki kolom label.
**Format input untuk data pelatihan, data validasi, dan fitur kategoris**
Perhatikan cara memformat data pelatihan Anda untuk masukan ke model LightGBM. Anda harus menyediakan jalur ke bucket Amazon S3 yang berisi data pelatihan dan validasi Anda. Anda juga dapat menyertakan daftar fitur kategoris. Gunakan saluran `train` dan `validation` saluran untuk memberikan data masukan Anda. Atau, Anda hanya dapat menggunakan `train` saluran.
**catatan**
Keduanya `train` dan `training` merupakan nama saluran yang valid untuk pelatihan LightGBM.
**Gunakan kedua `validation` saluran `train` dan**
Anda dapat memberikan data input Anda melalui dua jalur S3, satu untuk `train` saluran dan satu untuk `validation` saluran. Setiap jalur S3 dapat berupa awalan S3 yang menunjuk ke satu atau lebih file CSV atau jalur S3 lengkap yang menunjuk ke satu file CSV tertentu. Variabel target harus berada di kolom pertama file CSV Anda. Variabel prediktor (fitur) harus berada di kolom yang tersisa. Jika beberapa file CSV disediakan untuk `validation` saluran `train` atau, algoritma LightGBM menggabungkan file. Data validasi digunakan untuk menghitung skor validasi di akhir setiap iterasi peningkatan. Penghentian awal diterapkan ketika skor validasi berhenti membaik.
Jika prediktor Anda menyertakan fitur kategoris, Anda dapat memberikan file JSON bernama `categorical_index.json` di lokasi yang sama dengan file atau file data pelatihan Anda. Jika Anda menyediakan file JSON untuk fitur kategoris, `train` saluran Anda harus menunjuk ke awalan S3 dan bukan file CSV tertentu. File ini harus berisi kamus Python di mana kuncinya adalah string `"cat_index_list"` dan nilainya adalah daftar bilangan bulat unik. Setiap bilangan bulat dalam daftar nilai harus menunjukkan indeks kolom dari fitur kategoris yang sesuai dalam file CSV data pelatihan Anda. Setiap nilai harus berupa bilangan bulat positif (lebih besar dari nol karena nol mewakili nilai target), kurang dari `Int32.MaxValue` (2147483647), dan kurang dari jumlah kolom. Seharusnya hanya ada satu file JSON indeks kategoris.
**Gunakan hanya `train` saluran**:
Sebagai alternatif, Anda dapat memberikan data input Anda melalui jalur S3 tunggal untuk `train` saluran tersebut. Jalur S3 ini harus menunjuk ke direktori dengan subdirektori bernama `train/` yang berisi satu atau lebih file CSV. Anda dapat secara opsional menyertakan subdirektori lain di lokasi yang sama yang disebut `validation/` yang juga memiliki satu atau lebih file CSV. Jika data validasi tidak disediakan, maka 20% data pelatihan Anda diambil sampelnya secara acak untuk dijadikan sebagai data validasi. Jika prediktor Anda menyertakan fitur kategoris, Anda dapat memberikan file JSON bernama `categorical_index.json` di lokasi yang sama dengan subdirektori data Anda.
**catatan**
Untuk mode input pelatihan CSV, total memori yang tersedia untuk algoritme (jumlah instance dikalikan dengan memori yang tersedia di`InstanceType`) harus dapat menampung kumpulan data pelatihan.
SageMaker AI LightGBM menggunakan modul Python Joblib untuk membuat serial atau deserialisasi model, yang dapat digunakan untuk menyimpan atau memuat model.
**Untuk menggunakan model yang dilatih dengan SageMaker AI LightGBM dengan modul JobLib**
+ Gunakan kode Python berikut:
```
import joblib
import tarfile
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
model = joblib.load(model_file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Rekomendasi instans Amazon EC2 untuk algoritme LightGBM
SageMaker AI LightGBM saat ini mendukung pelatihan CPU single-instance dan multi-instance. Untuk pelatihan CPU multi-instance (pelatihan terdistribusi), tentukan `instance_count` lebih besar dari 1 saat Anda menentukan Estimator Anda. Untuk informasi selengkapnya tentang pelatihan terdistribusi dengan LightGBM, lihat [Amazon SageMaker AI LightGBM Distributed](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html) training menggunakan Dask.
LightGBM adalah algoritma yang terikat memori (sebagai lawan dari compute-bound). Jadi, instance komputasi tujuan umum (misalnya, M5) adalah pilihan yang lebih baik daripada instance yang dioptimalkan komputasi (misalnya, C5). Selanjutnya, kami menyarankan Anda memiliki memori total yang cukup dalam instance yang dipilih untuk menyimpan data pelatihan.
## Notebook sampel LightGBM
Tabel berikut menguraikan berbagai contoh notebook yang membahas berbagai kasus penggunaan algoritma Amazon SageMaker AI LightGBM.
****
| **Judul Notebook** | **Deskripsi** |
| --- | --- |
| [Klasifikasi tabel dengan Amazon SageMaker AI LightGBM dan algoritma CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.html) | Notebook ini menunjukkan penggunaan algoritma Amazon SageMaker AI LightGBM untuk melatih dan menyelenggarakan model klasifikasi tabel. |
| [Regresi tabular dengan Amazon SageMaker AI LightGBM dan algoritma CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.html) | Notebook ini menunjukkan penggunaan algoritma Amazon SageMaker AI LightGBM untuk melatih dan menjadi tuan rumah model regresi tabular. |
| [Amazon SageMaker AI LightGBM Pelatihan terdistribusi menggunakan Dask](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html) | Notebook ini menunjukkan pelatihan terdistribusi dengan algoritma Amazon SageMaker AI LightGBM menggunakan kerangka Dask. |
Untuk petunjuk tentang cara membuat dan mengakses instance notebook Jupyter yang dapat Anda gunakan untuk menjalankan contoh di SageMaker AI, lihat. [Instans SageMaker notebook Amazon](nbi.md) Setelah Anda membuat instance notebook dan membukanya, pilih tab **Contoh SageMaker AI** untuk melihat daftar semua sampel SageMaker AI. Untuk membuka buku catatan, pilih tab **Use** dan pilih **Create copy**.
# Bagaimana LightGBM bekerja
LightGBM mengimplementasikan algoritma Gradient Boosting Decision Tree (GBDT) konvensional dengan penambahan dua teknik baru: Gradient Based One-Side Sampling (GOSS) dan Exclusive Feature Bundling (EFB). Teknik-teknik ini dirancang untuk secara signifikan meningkatkan efisiensi dan skalabilitas GBDT.
Algoritma LightGBM berkinerja baik dalam kompetisi pembelajaran mesin karena penanganannya yang kuat terhadap berbagai tipe data, hubungan, distribusi, dan keragaman hiperparameter yang dapat Anda sesuaikan. Anda dapat menggunakan LightGBM untuk masalah regresi, klasifikasi (biner dan multiclass), dan peringkat.
Untuk informasi lebih lanjut tentang peningkatan gradien, lihat. [Bagaimana XGBoost algoritma SageMaker AI bekerja](xgboost-HowItWorks.md) Untuk detail mendalam tentang teknik GOSS dan EFB tambahan yang digunakan dalam metode LightGBM, lihat *[LightGBM: Pohon Keputusan Peningkatan Gradien yang](https://proceedings.neurips.cc/paper/2017/file/6449f44a102fde848669bdd9eb6b76fa-Paper.pdf)* Sangat Efisien.
# Hiperparameter LightGBM
Tabel berikut berisi subset hiperparameter yang diperlukan atau paling umum digunakan untuk algoritma Amazon SageMaker AI LightGBM. Pengguna mengatur parameter ini untuk memfasilitasi estimasi parameter model dari data. [Algoritma SageMaker AI LightGBM adalah implementasi dari paket LightGBM open-source.](https://github.com/microsoft/LightGBM)
**catatan**
Hyperparameter default didasarkan pada contoh kumpulan data di file. [Notebook sampel LightGBM](lightgbm.md#lightgbm-sample-notebooks)
Secara default, algoritma SageMaker AI LightGBM secara otomatis memilih metrik evaluasi dan fungsi objektif berdasarkan jenis masalah klasifikasi. Algoritma LightGBM mendeteksi jenis masalah klasifikasi berdasarkan jumlah label dalam data Anda. Untuk masalah regresi, metrik evaluasi adalah kesalahan kuadrat rata-rata akar dan fungsi tujuannya adalah kerugian L2. Untuk masalah klasifikasi biner, metrik evaluasi dan fungsi objektif keduanya adalah entropi silang biner. Untuk masalah klasifikasi multikelas, metrik evaluasi adalah entropi silang multikelas dan fungsi tujuannya adalah softmax. Anda dapat menggunakan `metric` hyperparameter untuk mengubah metrik evaluasi default. Lihat tabel berikut untuk informasi selengkapnya tentang hyperparameters LightGBM, termasuk deskripsi, nilai valid, dan nilai default.
| Nama Parameter | Deskripsi |
| --- | --- |
| num\$1boost\$1round | Jumlah maksimum peningkatan iterasi. **Catatan:** Secara internal, LightGBM membangun `num_class * num_boost_round` pohon untuk masalah klasifikasi multi-kelas. Nilai yang valid: bilangan bulat, rentang: Bilangan bulat positif. Nilai default:`100`. |
| early\$1stopping\$1rounds | Pelatihan akan berhenti jika satu metrik dari satu titik data validasi tidak membaik di `early_stopping_rounds` babak terakhir. Jika `early_stopping_rounds` kurang dari atau sama dengan nol, hyperparameter ini diabaikan. Nilai yang valid: bilangan bulat. Nilai default:`10`. |
| metric | Metrik evaluasi untuk data validasi. Jika `metric` diatur ke `"auto"` nilai default, maka algoritme secara otomatis memilih metrik evaluasi berdasarkan jenis masalah klasifikasi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/lightgbm-hyperparameters.html) Nilai yang valid: string, salah satu dari berikut ini: (`"auto"``"rmse"``"l1"`,`"l2"`,`"huber"`,`"fair"`,`"binary_logloss"`,`"binary_error"`,`"auc"`,`"average_precision"`,`"multi_logloss"`,`"multi_error"`,`"auc_mu"`, atau`"cross_entropy"`). Nilai default:`"auto"`. |
| learning\$1rate | Tingkat di mana bobot model diperbarui setelah mengerjakan setiap batch contoh pelatihan. Nilai yang valid: float, range: (`0.0`,`1.0`). Nilai default:`0.1`. |
| num\$1leaves | Jumlah maksimum daun dalam satu pohon. Nilai yang valid: integer, range: (`1`,`131072`). Nilai default:`64`. |
| feature\$1fraction | Subset fitur yang akan dipilih pada setiap iterasi (pohon). Harus kurang dari 1,0. Nilai yang valid: float, range: (`0.0`,`1.0`). Nilai default:`0.9`. |
| bagging\$1fraction | Subset fitur yang mirip dengan`feature_fraction`, tetapi `bagging_fraction` secara acak memilih bagian dari data tanpa resampling. Nilai yang valid: float, range: (`0.0`,`1.0`]. Nilai default:`0.9`. |
| bagging\$1freq | Frekuensi untuk melakukan bagging. Pada setiap `bagging_freq` iterasi, LightGBM secara acak memilih persentase data yang akan digunakan untuk iterasi berikutnya. `bagging_freq` Persentase ini ditentukan oleh `bagging_fraction` hyperparameter. Jika `bagging_freq` nol, maka bagging dinonaktifkan. Nilai yang valid: bilangan bulat, rentang: Bilangan bulat non-negatif. Nilai default:`1`. |
| max\$1depth | Kedalaman maksimum untuk model pohon. Ini digunakan untuk menangani overfitting ketika jumlah data kecil. Jika `max_depth` kurang dari atau sama dengan nol, ini berarti tidak ada batasan untuk kedalaman maksimum. Nilai yang valid: bilangan bulat. Nilai default:`6`. |
| min\$1data\$1in\$1leaf | Jumlah minimum data dalam satu daun. Dapat digunakan untuk menangani overfitting. Nilai yang valid: bilangan bulat, rentang: Bilangan bulat non-negatif. Nilai default:`3`. |
| max\$1delta\$1step | Digunakan untuk membatasi output maksimal daun pohon. Jika `max_delta_step` kurang dari atau sama dengan 0, maka tidak ada kendala. Output maksimal akhir daun adalah`learning_rate * max_delta_step`. Nilai yang valid: float. Nilai default:`0.0`. |
| lambda\$1l1 | Regularisasi L1. Nilai yang valid: float, range: Float non-negatif. Nilai default:`0.0`. |
| lambda\$1l2 | Regularisasi L2. Nilai yang valid: float, range: Float non-negatif. Nilai default:`0.0`. |
| boosting | Jenis penguat Nilai yang valid: string, salah satu dari berikut ini: (`"gbdt"`,`"rf"`,`"dart"`, atau`"goss"`). Nilai default:`"gbdt"`. |
| min\$1gain\$1to\$1split | Keuntungan minimum untuk melakukan split. Dapat digunakan untuk mempercepat pelatihan. Nilai yang valid: integer, float: Float non-negatif. Nilai default:`0.0`. |
| scale\$1pos\$1weight | Berat label dengan kelas positif. Digunakan hanya untuk tugas klasifikasi biner. `scale_pos_weight`tidak dapat digunakan jika `is_unbalance` diatur ke`"True"`. Nilai yang valid: float, range: Positive float. Nilai default:`1.0`. |
| tree\$1learner | Jenis pembelajar pohon. Nilai yang valid: string, salah satu dari berikut ini: (`"serial"`,`"feature"`,`"data"`, atau`"voting"`). Nilai default:`"serial"`. |
| feature\$1fraction\$1bynode | Memilih subset fitur acak pada setiap node pohon. Misalnya, jika `feature_fraction_bynode` ya`0.8`, maka 80% fitur dipilih. Dapat digunakan untuk menangani overfitting. Nilai yang valid: integer, range: (`0.0`,`1.0`]. Nilai default:`1.0`. |
| is\$1unbalance | Setel ke `"True"` jika data pelatihan tidak seimbang. Digunakan hanya untuk tugas klasifikasi biner. `is_unbalance`tidak dapat digunakan dengan`scale_pos_weight`. Nilai yang valid: string, baik: (`"True"`atau`"False"`). Nilai default:`"False"`. |
| max\$1bin | Jumlah maksimum nampan yang digunakan untuk memasukkan nilai fitur. Sejumlah kecil tempat sampah dapat mengurangi akurasi pelatihan, tetapi dapat meningkatkan kinerja umum. Dapat digunakan untuk menangani overfitting. Nilai yang valid: bilangan bulat, rentang: (1, ∞). Nilai default:`255`. |
| tweedie\$1variance\$1power | Mengontrol varians distribusi Tweedie. Atur ini lebih dekat `2.0` untuk bergeser ke arah distribusi gamma. Atur ini lebih dekat `1.0` untuk beralih ke distribusi Poisson. Digunakan hanya untuk tugas-tugas regresi. Nilai yang valid: float, range: [`1.0`,`2.0`). Nilai default:`1.5`. |
| num\$1threads | Jumlah thread paralel yang digunakan untuk menjalankan LightGBM. Nilai 0 berarti jumlah default thread di OpenMP. Nilai yang valid: bilangan bulat, rentang: Bilangan bulat non-negatif. Nilai default:`0`. |
| verbosity | Verbositas pesan cetak. Jika `verbosity` kurang dari`0`, maka pesan cetak hanya menunjukkan kesalahan fatal. Jika `verbosity` diatur ke`0`, maka pesan cetak termasuk kesalahan dan peringatan. Jika `verbosity` ya`1`, maka cetak pesan menampilkan informasi lebih lanjut. `verbosity`Lebih besar dari `1` menunjukkan sebagian besar informasi dalam pesan cetak dan dapat digunakan untuk debugging. Nilai yang valid: bilangan bulat. Nilai default:`1`. |
# Menyetel model LightGBM
*Penyetelan model otomatis*, juga dikenal sebagai tuning hyperparameter, menemukan versi terbaik dari model dengan menjalankan banyak pekerjaan yang menguji berbagai hiperparameter pada kumpulan data pelatihan dan validasi Anda. Penyetelan model berfokus pada hiperparameter berikut:
**catatan**
Fungsi tujuan pembelajaran secara otomatis ditetapkan berdasarkan jenis tugas klasifikasi, yang ditentukan oleh jumlah bilangan bulat unik di kolom label. Untuk informasi selengkapnya, lihat [Hiperparameter LightGBM](lightgbm-hyperparameters.md).
+ Fungsi tujuan pembelajaran untuk mengoptimalkan selama pelatihan model
+ Metrik evaluasi yang digunakan untuk mengevaluasi kinerja model selama validasi
+ Satu set hyperparameters dan rentang nilai untuk masing-masing untuk digunakan saat menyetel model secara otomatis
Penyetelan model otomatis mencari hiperparameter yang Anda tentukan untuk menemukan kombinasi nilai yang menghasilkan model yang mengoptimalkan metrik evaluasi yang dipilih.
**catatan**
Penyetelan model otomatis untuk LightGBM hanya tersedia dari Amazon SageMaker SDKs, bukan dari konsol AI. SageMaker
Untuk informasi selengkapnya tentang penyetelan model, lihat[Penyetelan model otomatis dengan AI SageMaker](automatic-model-tuning.md).
## Metrik evaluasi dihitung oleh algoritma LightGBM
Algoritma SageMaker AI LightGBM menghitung metrik berikut untuk digunakan untuk validasi model. Metrik evaluasi secara otomatis ditetapkan berdasarkan jenis tugas klasifikasi, yang ditentukan oleh jumlah bilangan bulat unik di kolom label.
| Nama Metrik | Deskripsi | Arah Optimasi | Pola Regex |
| --- | --- | --- | --- |
| rmse | kesalahan kuadrat rata-rata akar | memperkecil | "rmse: ([0-9\$1\$1.]\$1)" |
| l1 | berarti kesalahan absolut | memperkecil | "l1: ([0-9\$1\$1.]\$1)" |
| l2 | berarti kesalahan kuadrat | memperkecil | "l2: ([0-9\$1\$1.]\$1)" |
| huber | kerugian huber | memperkecil | "huber: ([0-9\$1\$1.]\$1)" |
| fair | kerugian yang adil | memperkecil | "fair: ([0-9\$1\$1.]\$1)" |
| binary\$1logloss | entropi silang biner | memaksimalkan | "binary\$1logloss: ([0-9\$1\$1.]\$1)" |
| binary\$1error | kesalahan biner | memperkecil | "binary\$1error: ([0-9\$1\$1.]\$1)" |
| auc | AUC | memaksimalkan | "auc: ([0-9\$1\$1.]\$1)" |
| average\$1precision | skor presisi rata-rata | memaksimalkan | "average\$1precision: ([0-9\$1\$1.]\$1)" |
| multi\$1logloss | entropi silang multiclass | memaksimalkan | "multi\$1logloss: ([0-9\$1\$1.]\$1)" |
| multi\$1error | skor kesalahan multiclass | memperkecil | "multi\$1error: ([0-9\$1\$1.]\$1)" |
| auc\$1mu | AUC-mu | memaksimalkan | "auc\$1mu: ([0-9\$1\$1.]\$1)" |
| cross\$1entropy | entropi silang | memperkecil | "cross\$1entropy: ([0-9\$1\$1.]\$1)" |
## Hiperparameter LightGBM yang dapat disetel
Setel model LightGBM dengan hyperparameter berikut. Hiperparameter yang memiliki efek terbesar dalam mengoptimalkan metrik evaluasi LightGBM adalah:`learning_rate`,,,,,`num_leaves`, `feature_fraction` dan. `bagging_fraction` `bagging_freq` `max_depth` `min_data_in_leaf` Untuk daftar semua hyperparameters LightGBM, lihat. [Hiperparameter LightGBM](lightgbm-hyperparameters.md)
| Nama Parameter | Jenis Parameter | Rentang yang Direkomendasikan |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001, MaxValue: 0,01 |
| num\$1leaves | IntegerParameterRanges | MinValue: 10, MaxValue: 100 |
| feature\$1fraction | ContinuousParameterRanges | MinValue: 0,1, MaxValue: 1,0 |
| bagging\$1fraction | ContinuousParameterRanges | MinValue: 0,1, MaxValue: 1,0 |
| bagging\$1freq | IntegerParameterRanges | MinValue: 0, MaxValue: 10 |
| max\$1depth | IntegerParameterRanges | MinValue: 15, MaxValue: 100 |
| min\$1data\$1in\$1leaf | IntegerParameterRanges | MinValue: 10, MaxValue: 200 |
# Algoritma Pembelajar Linear
*Model linier* adalah algoritma pembelajaran yang diawasi yang digunakan untuk memecahkan masalah klasifikasi atau regresi. Untuk masukan, Anda memberikan contoh berlabel model (*x*, *y*). *x* adalah vektor berdimensi tinggi dan *y* adalah label numerik. Untuk masalah klasifikasi biner, label harus 0 atau 1. Untuk masalah klasifikasi multiclass, label harus dari 0 hingga `num_classes` - 1. Untuk masalah regresi, *y* adalah bilangan real. *Algoritma mempelajari fungsi linier, atau, untuk masalah klasifikasi, fungsi ambang linier, dan memetakan vektor *x* ke perkiraan label y.*
Algoritma pembelajar linier Amazon SageMaker AI memberikan solusi untuk masalah klasifikasi dan regresi. Dengan algoritma SageMaker AI, Anda dapat secara bersamaan menjelajahi berbagai tujuan pelatihan dan memilih solusi terbaik dari set validasi. Anda juga dapat menjelajahi sejumlah besar model dan memilih yang terbaik. Model terbaik mengoptimalkan salah satu dari berikut ini:
+ Tujuan berkelanjutan, seperti kesalahan kuadrat rata-rata, kehilangan entropi silang, kesalahan absolut.
+ Tujuan diskrit cocok untuk klasifikasi, seperti ukuran F1, presisi, penarikan, atau akurasi.
Dibandingkan dengan metode yang memberikan solusi hanya untuk tujuan berkelanjutan, algoritme pembelajar linier SageMaker AI memberikan peningkatan kecepatan yang signifikan dibandingkan teknik optimasi hiperparameter yang naif. Hal ini juga lebih nyaman.
Algoritma pembelajar linier membutuhkan matriks data, dengan baris yang mewakili pengamatan, dan kolom yang mewakili dimensi fitur. Ini juga membutuhkan kolom tambahan yang berisi label yang cocok dengan titik data. Minimal, Amazon SageMaker AI linear learner mengharuskan Anda menentukan lokasi data input dan output, serta tipe objektif (klasifikasi atau regresi) sebagai argumen. Dimensi fitur juga diperlukan. Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Anda dapat menentukan parameter tambahan di peta `HyperParameters` string dari badan permintaan. Parameter ini mengontrol proses pengoptimalan, atau spesifikasi fungsi tujuan yang Anda latih. Misalnya, jumlah zaman, regularisasi, dan jenis kerugian.
Jika Anda menggunakan [Pelatihan Spot Terkelola](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html), algoritme pelajar linier mendukung penggunaan [pos pemeriksaan untuk mengambil snapshot status model](https://docs.aws.amazon.com/sagemaker/latest/dg/model-checkpoints.html).
**Topics**
+ [Antarmuka Input/Output untuk algoritma pembelajar linier](#ll-input_output)
+ [Rekomendasi instans EC2 untuk algoritma pembelajar linier](#ll-instances)
+ [Buku catatan sampel pelajar linier](#ll-sample-notebooks)
+ [Cara kerja linear learner](ll_how-it-works.md)
+ [Hiperparameter pelajar linier](ll_hyperparameters.md)
+ [Menyetel model pembelajar linier](linear-learner-tuning.md)
+ [Format respons pelajar linier](LL-in-formats.md)
## Antarmuka Input/Output untuk algoritma pembelajar linier
Algoritma pembelajar linear Amazon SageMaker AI mendukung tiga saluran data: melatih, validasi (opsional), dan pengujian (opsional). Jika Anda memberikan data validasi, `S3DataDistributionType` seharusnya`FullyReplicated`. Algoritma mencatat kehilangan validasi di setiap zaman, dan menggunakan sampel data validasi untuk mengkalibrasi dan memilih model terbaik. Jika Anda tidak memberikan data validasi, algoritme menggunakan sampel data pelatihan untuk mengkalibrasi dan memilih model. Jika Anda memberikan data pengujian, log algoritme menyertakan skor tes untuk model akhir.
**Untuk pelatihan**, algoritma pembelajar linier mendukung keduanya `recordIO-wrapped protobuf` dan `CSV` format. Untuk tipe `application/x-recordio-protobuf` input, hanya tensor Float32 yang didukung. Untuk tipe `text/csv` input, kolom pertama diasumsikan sebagai label, yang merupakan variabel target untuk prediksi. Anda dapat menggunakan mode File atau mode Pipe untuk melatih model pelajar linier pada data yang diformat sebagai `recordIO-wrapped-protobuf` atau sebagai. `CSV`
**Untuk inferensi**, algoritma pembelajar linier mendukung`application/json`,`application/x-recordio-protobuf`, dan `text/csv` format. Ketika Anda membuat prediksi pada data baru, format respons tergantung pada jenis model. **Untuk regresi** (`predictor_type='regressor'`), `score` adalah prediksi yang dihasilkan oleh model. **Untuk klasifikasi** (`predictor_type='binary_classifier'`atau`predictor_type='multiclass_classifier'`), model mengembalikan a `score` dan juga a`predicted_label`. `predicted_label`Ini adalah kelas yang diprediksi oleh model dan `score` mengukur kekuatan prediksi itu.
+ **Untuk klasifikasi biner**`1`, `predicted_label` adalah `0` atau, dan `score` merupakan nomor floating point tunggal yang menunjukkan seberapa kuat algoritma percaya bahwa label harus 1.
+ **Untuk klasifikasi multiclass**, `predicted_class` akan menjadi bilangan bulat dari `0` ke`num_classes-1`, dan `score` akan menjadi daftar satu nomor floating point per kelas.
Untuk menafsirkan masalah klasifikasi, Anda harus mempertimbangkan fungsi kerugian yang digunakan. `score` Jika nilai `loss` hyperparameter adalah `logistic` untuk klasifikasi biner atau `softmax_loss` untuk klasifikasi multiclass, maka `score` dapat diartikan sebagai probabilitas kelas yang sesuai. Ini adalah nilai kerugian yang digunakan oleh pelajar linier ketika `loss` nilainya adalah nilai `auto` default. Tetapi jika kerugian diatur ke`hinge_loss`, maka skor tidak dapat diartikan sebagai probabilitas. Ini karena kehilangan engsel sesuai dengan Support Vector Classifier, yang tidak menghasilkan perkiraan probabilitas.
Untuk informasi selengkapnya tentang format file input dan output, lihat[Format respons pelajar linier](LL-in-formats.md). Untuk informasi lebih lanjut tentang format inferensi, dan. [Buku catatan sampel pelajar linier](#ll-sample-notebooks)
## Rekomendasi instans EC2 untuk algoritma pembelajar linier
Algoritma pembelajar linier mendukung instance CPU dan GPU untuk pelatihan dan inferensi. Untuk GPU, algoritma pembelajar linier mendukung keluarga GPU P2, P3, G4dn, dan G5.
Selama pengujian, kami belum menemukan bukti substansional bahwa instans multi-GPU lebih cepat daripada instans GPU tunggal. Hasil dapat bervariasi, tergantung pada kasus penggunaan spesifik Anda.
## Buku catatan sampel pelajar linier
Tabel berikut menguraikan berbagai contoh buku catatan yang membahas berbagai kasus penggunaan algoritme pelajar linier Amazon SageMaker AI.
| **Judul Notebook** | **Deskripsi** |
| --- | --- |
| [Pengantar dengan dataset MNIST](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/linear_learner_mnist/linear_learner_mnist.html) | Menggunakan dataset MNIST, kami melatih pengklasifikasi biner untuk memprediksi satu digit. |
| [Bagaimana Membangun Pengklasifikasi Multiclass?](https://sagemaker-examples.readthedocs.io/en/latest/scientific_details_of_algorithms/linear_learner_multiclass_classification/linear_learner_multiclass_classification.html) | Menggunakan kumpulan data Covertype UCI, kami mendemonstrasikan cara melatih pengklasifikasi multiclass. |
| [Bagaimana Membangun Pipeline Machine Learning (ML) untuk Inferensi?](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-python-sdk/scikit_learn_inference_pipeline/Inference%20Pipeline%20with%20Scikit-learn%20and%20Linear%20Learner.html) | Menggunakan kontainer Scikit-learn, kami mendemonstrasikan cara membuat pipeline HTML. end-to-end |
Untuk petunjuk tentang cara membuat dan mengakses instance notebook Jupyter yang dapat Anda gunakan untuk menjalankan contoh di SageMaker AI, lihat. [Instans SageMaker notebook Amazon](nbi.md) Setelah Anda membuat instance notebook dan membukanya, pilih tab **Contoh SageMaker AI** untuk melihat daftar semua sampel SageMaker AI. Contoh buku catatan pemodelan topik menggunakan algoritme pembelajaran linier terletak di bagian **Pengantar Algoritma Amazon**. Untuk membuka buku catatan, pilih tab **Use** dan pilih **Create copy**.
# Cara kerja linear learner
Ada tiga langkah yang terlibat dalam implementasi algoritma pembelajar linier: preprocess, train, dan validate.
## Langkah 1: Pra-proses
Normalisasi, atau penskalaan fitur, adalah langkah pra-pemrosesan penting untuk fungsi kerugian tertentu yang memastikan model yang dilatih pada kumpulan data tidak didominasi oleh bobot satu fitur. Algoritma Amazon SageMaker AI Linear Learner memiliki opsi normalisasi untuk membantu langkah pra-pemrosesan ini. Jika normalisasi dihidupkan, algoritme pertama-tama membahas sampel kecil data untuk mempelajari nilai rata-rata dan standar deviasi untuk setiap fitur dan untuk label. Setiap fitur dalam kumpulan data lengkap kemudian digeser untuk memiliki rata-rata nol dan diskalakan untuk memiliki standar deviasi unit.
**catatan**
Untuk hasil terbaik, pastikan data Anda dikocokkan sebelum pelatihan. Pelatihan dengan data yang tidak diacak dapat menyebabkan pelatihan gagal.
Anda dapat mengonfigurasi apakah algoritme pembelajar linier menormalkan data fitur dan label masing-masing menggunakan `normalize_data` dan `normalize_label` hiperparameter. Normalisasi diaktifkan secara default untuk fitur dan label untuk regresi. Hanya fitur yang dapat dinormalisasi untuk klasifikasi biner dan ini adalah perilaku default.
## Langkah 2: Melatih
Dengan algoritma pembelajar linier, Anda berlatih dengan implementasi terdistribusi dari penurunan gradien stokastik (SGD). Anda dapat mengontrol proses pengoptimalan dengan memilih algoritma pengoptimalan. Misalnya, Anda dapat memilih untuk menggunakan Adam,, penurunan gradien stokastik AdaGrad, atau algoritme pengoptimalan lainnya. Anda juga menentukan hiperparameternya, seperti momentum, tingkat pembelajaran, dan jadwal tingkat pembelajaran. Jika Anda tidak yakin algoritma atau nilai hyperparameter mana yang akan digunakan, pilih default yang berfungsi untuk sebagian besar kumpulan data.
Selama pelatihan, Anda secara bersamaan mengoptimalkan beberapa model, masing-masing dengan tujuan yang sedikit berbeda. Misalnya, Anda memvariasikan regularisasi L1 atau L2 dan mencoba pengaturan pengoptimal yang berbeda.
## Langkah 3: Validasi dan atur ambang batas
Saat melatih beberapa model secara paralel, model dievaluasi terhadap set validasi untuk memilih model yang paling optimal setelah pelatihan selesai. Untuk regresi, model yang paling optimal adalah model yang mencapai kerugian terbaik pada set validasi. Untuk klasifikasi, sampel set validasi digunakan untuk mengkalibrasi ambang klasifikasi. Model paling optimal yang dipilih adalah model yang mencapai kriteria pemilihan klasifikasi biner terbaik pada set validasi. Contoh kriteria tersebut termasuk ukuran F1, akurasi, dan kehilangan entropi silang.
**catatan**
Jika algoritma tidak disediakan set validasi, maka mengevaluasi dan memilih model yang paling optimal tidak mungkin. Untuk memanfaatkan pelatihan paralel dan pemilihan model, pastikan Anda memberikan set validasi ke algoritme.
# Hiperparameter pelajar linier
Tabel berikut berisi hyperparameters untuk algoritma pembelajar linier. Ini adalah parameter yang ditetapkan oleh pengguna untuk memfasilitasi estimasi parameter model dari data. Hyperparameter yang diperlukan yang harus ditetapkan terdaftar terlebih dahulu, dalam urutan abjad. Hyperparameter opsional yang dapat diatur tercantum berikutnya, juga dalam urutan abjad. Ketika hyperparameter disetel ke`auto`, Amazon SageMaker AI akan secara otomatis menghitung dan menetapkan nilai hyperparameter itu.
| Nama Parameter | Deskripsi |
| --- | --- |
| num\$1classes | Jumlah kelas untuk variabel respons. Algoritma mengasumsikan bahwa kelas diberi label`0`,...,. `num_classes - 1` **Diperlukan** kapan `predictor_type``multiclass_classifier`. Jika tidak, algoritma mengabaikannya. Nilai yang valid: Bilangan bulat dari 3 hingga 1.000.000 |
| predictor\$1type | Menentukan jenis variabel target sebagai klasifikasi biner, klasifikasi multiclass, atau regresi. **Diperlukan** Nilai valid: `binary_classifier`, `multiclass_classifier`, atau `regressor` |
| accuracy\$1top\$1k | *Saat menghitung metrik akurasi top-k untuk klasifikasi multiclass, nilai k.* Jika model menetapkan salah satu skor top-k ke label sebenarnya, sebuah contoh dinilai sebagai benar. **Opsional** Nilai yang valid: Bilangan bulat positif Nilai default: 3 |
| balance\$1multiclass\$1weights | Menentukan apakah akan menggunakan bobot kelas, yang memberikan masing-masing kelas sama pentingnya dalam fungsi kerugian. Digunakan hanya ketika `predictor_type` ada`multiclass_classifier`. **Opsional** Nilai valid: `true`, `false` Nilai default: `false` |
| beta\$11 | Tingkat peluruhan eksponensial untuk perkiraan momen pertama. Berlaku hanya jika `optimizer` nilainya`adam`. **Opsional** Nilai valid: `auto` atau nilai floating-point antara 0 dan 1.0 Nilai default: `auto` |
| beta\$12 | Tingkat peluruhan eksponensial untuk perkiraan momen kedua. Berlaku hanya jika `optimizer` nilainya`adam`. **Opsional** Nilai yang valid: `auto` atau bilangan bulat floating-point antara 0 dan 1.0 Nilai default: `auto` |
| bias\$1lr\$1mult | Memungkinkan tingkat pembelajaran yang berbeda untuk istilah bias. Tingkat pembelajaran aktual untuk bias adalah `learning_rate` \$1`bias_lr_mult`. **Opsional** Nilai yang valid: `auto` atau bilangan bulat floating-point positif Nilai default: `auto` |
| bias\$1wd\$1mult | Memungkinkan regularisasi yang berbeda untuk istilah bias. Bobot regularisasi L2 aktual untuk bias adalah \$1. `wd` `bias_wd_mult` Secara default, tidak ada regularisasi pada istilah bias. **Opsional** Nilai yang valid: `auto` atau bilangan bulat floating-point non-negatif Nilai default: `auto` |
| binary\$1classifier\$1model\$1selection\$1criteria | Kapan `predictor_type` disetel ke`binary_classifier`, kriteria evaluasi model untuk kumpulan data validasi (atau untuk kumpulan data pelatihan jika Anda tidak memberikan kumpulan data validasi). Kriteria meliputi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/ll_hyperparameters.html) **Opsional** Nilai yang valid:`accuracy`,`f_beta`,`precision_at_target_recall`,`recall_at_target_precision`, atau `loss_function` Nilai default: `accuracy` |
| early\$1stopping\$1patience | Jika tidak ada perbaikan yang dilakukan dalam metrik yang relevan, jumlah zaman yang harus menunggu sebelum mengakhiri pelatihan. Jika Anda telah memberikan nilai binary\$1classifier\$1model\$1selection\$1criteria untuk. metrik adalah nilai itu. Jika tidak, metriknya sama dengan nilai yang ditentukan untuk loss hyperparameter. Metrik dievaluasi pada data validasi. Jika Anda belum memberikan data validasi, metrik selalu sama dengan nilai yang ditentukan untuk `loss` hyperparameter dan dievaluasi pada data pelatihan. Untuk menonaktifkan penghentian awal, atur `early_stopping_patience` ke nilai yang lebih besar dari nilai yang ditentukan untuk`epochs`.**Opsional**Nilai yang valid: Bilangan bulat positifNilai default: 3 |
| early\$1stopping\$1tolerance | Toleransi relatif untuk mengukur peningkatan kerugian. Jika rasio peningkatan kerugian dibagi dengan kerugian terbaik sebelumnya lebih kecil dari nilai ini, penghentian awal menganggap peningkatan menjadi nol. **Opsional** Nilai yang valid: Bilangan bulat floating-point positif Nilai default: 0,001 |
| epochs | Jumlah maksimum lintasan atas data pelatihan. **Opsional** Nilai yang valid: Bilangan bulat positif Nilai default: 15 |
| f\$1beta | Nilai beta yang digunakan saat menghitung metrik skor F untuk klasifikasi biner atau multiclass. Juga digunakan jika nilai yang ditentukan untuk `binary_classifier_model_selection_criteria` adalah`f_beta`. **Opsional** Nilai yang valid: Bilangan bulat floating-point positif Nilai default: 1.0 |
| feature\$1dim | Jumlah fitur dalam data input. **Opsional** Nilai yang valid: `auto` atau bilangan bulat positif Nilai default: `auto` |
| huber\$1delta | Parameter untuk kerugian Huber. Selama pelatihan dan evaluasi metrik, hitung kerugian L2 untuk kesalahan yang lebih kecil dari delta dan kerugian L1 untuk kesalahan yang lebih besar dari delta. **Opsional** Nilai yang valid: Bilangan bulat floating-point positif Nilai default: 1.0 |
| init\$1bias | Bobot awal untuk istilah bias. **Opsional** Nilai yang valid: Integer Floating-point Nilai default: 0 |
| init\$1method | Menetapkan fungsi distribusi awal yang digunakan untuk bobot model. Fungsi meliputi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/ll_hyperparameters.html) **Opsional** Nilai yang valid: `uniform` or `normal` Nilai default: `uniform` |
| init\$1scale | Menimbang distribusi seragam awal untuk bobot model. Berlaku hanya ketika `init_method` hyperparameter disetel ke`uniform`. **Opsional** Nilai yang valid: Bilangan bulat floating-point positif Nilai default: 0,07 |
| init\$1sigma | Standar deviasi awal untuk distribusi normal. Berlaku hanya ketika `init_method` hyperparameter disetel ke`normal`. **Opsional** Nilai yang valid: Bilangan bulat floating-point positif Nilai default: 0,01 |
| l1 | Parameter regularisasi L1. Jika Anda tidak ingin menggunakan regularisasi L1, atur nilainya ke 0. **Opsional** Nilai yang valid: `auto` atau float non-negatif Nilai default: `auto` |
| learning\$1rate | Ukuran langkah yang digunakan oleh pengoptimal untuk pembaruan parameter. **Opsional** Nilai yang valid: `auto` atau bilangan bulat floating-point positif Nilai default:`auto`, yang nilainya tergantung pada pengoptimal yang dipilih. |
| loss | Menentukan fungsi kerugian. Fungsi kerugian yang tersedia dan nilai defaultnya bergantung pada nilai`predictor_type`: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/ll_hyperparameters.html) Nilai yang valid: `auto``logistic`,`squared_loss`,`absolute_loss`,`hinge_loss`,`eps_insensitive_squared_loss`,`eps_insensitive_absolute_loss`,`quantile_loss`, atau `huber_loss` **Opsional** Nilai default: `auto` |
| loss\$1insensitivity | Parameter untuk tipe kerugian epsilon-insensitive. Selama pelatihan dan evaluasi metrik, kesalahan yang lebih kecil dari nilai ini dianggap nol. **Opsional** Nilai yang valid: Bilangan bulat floating-point positif Nilai default: 0,01 |
| lr\$1scheduler\$1factor | Untuk setiap `lr_scheduler_step` hiperparameter, tingkat pembelajaran menurun dengan kuantitas ini. Berlaku hanya ketika `use_lr_scheduler` hyperparameter disetel ke`true`. **Opsional** Nilai yang valid: `auto` atau bilangan bulat floating-point positif antara 0 dan 1 Nilai default: `auto` |
| lr\$1scheduler\$1minimum\$1lr | Tingkat pembelajaran tidak pernah menurun ke nilai yang lebih rendah dari nilai yang ditetapkan`lr_scheduler_minimum_lr`. Berlaku hanya ketika `use_lr_scheduler` hyperparameter disetel ke`true`. **Opsional** Nilai yang valid: `auto` atau bilangan bulat floating-point positif Nilai default: `auto` |
| lr\$1scheduler\$1step | Jumlah langkah antara penurunan tingkat pembelajaran. Berlaku hanya ketika `use_lr_scheduler` hyperparameter disetel ke`true`. **Opsional** Nilai yang valid: `auto` atau bilangan bulat positif Nilai default: `auto` |
| margin | Margin untuk `hinge_loss` fungsi tersebut. **Opsional** Nilai yang valid: Bilangan bulat floating-point positif Nilai default: 1.0 |
| mini\$1batch\$1size | Jumlah pengamatan per mini-batch untuk iterator data. **Opsional** Nilai yang valid: Bilangan bulat positif Nilai default: 1000 |
| momentum | Momentum `sgd` pengoptimal. **Opsional** Nilai yang valid: `auto` atau bilangan bulat floating-point antara 0 dan 1.0 Nilai default: `auto` |
| normalize\$1data | Menormalkan data fitur sebelum pelatihan. Normalisasi data menggeser data untuk setiap fitur untuk memiliki rata-rata nol dan menskalakannya untuk memiliki standar deviasi unit. **Opsional** Nilai valid: `auto`, `true`, atau `false` Nilai default: `true` |
| normalize\$1label | Menormalkan label. Normalisasi label menggeser label untuk memiliki rata-rata nol dan menskalakannya untuk memiliki satuan standar deviasi. Nilai `auto` default menormalkan label untuk masalah regresi tetapi tidak untuk masalah klasifikasi. Jika Anda mengatur `normalize_label` hyperparameter `true` untuk masalah klasifikasi, algoritme mengabaikannya. **Opsional** Nilai valid: `auto`, `true`, atau `false` Nilai default: `auto` |
| num\$1calibration\$1samples | Jumlah pengamatan dari dataset validasi yang akan digunakan untuk kalibrasi model (saat menemukan ambang batas terbaik). **Opsional** Nilai yang valid: `auto` atau bilangan bulat positif Nilai default: `auto` |
| num\$1models | Jumlah model untuk dilatih secara paralel. Untuk default,`auto`, algoritma menentukan jumlah model paralel untuk dilatih. Satu model dilatih sesuai dengan parameter pelatihan yang diberikan (regularisasi, pengoptimal, kehilangan), dan sisanya dengan parameter dekat. **Opsional** Nilai yang valid: `auto` atau bilangan bulat positif Nilai default: `auto` |
| num\$1point\$1for\$1scaler | Jumlah titik data yang digunakan untuk menghitung normalisasi atau tidak bias istilah. **Opsional** Nilai yang valid: Bilangan bulat positif Nilai default: 10.000 |
| optimizer | Algoritma optimasi untuk digunakan. **Opsional** Nilai valid: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/ll_hyperparameters.html) Nilai default:`auto`. Pengaturan default untuk `auto` adalah`adam`. |
| positive\$1example\$1weight\$1mult | Bobot diberikan pada contoh positif saat melatih pengklasifikasi biner. Bobot contoh negatif ditetapkan pada 1. Jika Anda ingin algoritme memilih bobot sehingga kesalahan dalam mengklasifikasikan contoh negatif *vs.* positif memiliki dampak yang sama pada kehilangan pelatihan, tentukan. `balanced` Jika Anda ingin algoritme memilih bobot yang mengoptimalkan kinerja, tentukan`auto`. **Opsional** Nilai yang valid:`balanced`,`auto`, atau bilangan bulat floating-point positif Nilai default: 1.0 |
| quantile | Kuantil untuk kerugian kuantil. Untuk kuantil q, model mencoba menghasilkan prediksi sehingga nilai lebih besar dari `true_label` prediksi dengan probabilitas q. **Opsional** Nilai yang valid: Integer Floating-point antara 0 dan 1 Nilai default: 0,5 |
| target\$1precision | Ketepatan target. Jika `binary_classifier_model_selection_criteria` ya`recall_at_target_precision`, maka presisi dipertahankan pada nilai ini sementara recall dimaksimalkan. **Opsional** Nilai yang valid: Integer Floating-point antara 0 dan 1.0 Nilai default: 0,8 |
| target\$1recall | Target recall. Jika `binary_classifier_model_selection_criteria` ya`precision_at_target_recall`, maka recall ditahan pada nilai ini sementara presisi dimaksimalkan. **Opsional** Nilai yang valid: Integer Floating-point antara 0 dan 1.0 Nilai default: 0,8 |
| unbias\$1data | Tidak bias fitur sebelum pelatihan sehingga rata-ratanya adalah 0. Secara default, data tidak bias karena `use_bias` hyperparameter disetel ke. `true` **Opsional** Nilai valid: `auto`, `true`, atau `false` Nilai default: `auto` |
| unbias\$1label | Label tidak bias sebelum pelatihan sehingga rata-ratanya adalah 0. Berlaku untuk regresi hanya jika `use_bias` hyperparameter disetel ke. `true` **Opsional** Nilai valid: `auto`, `true`, atau `false` Nilai default: `auto` |
| use\$1bias | Menentukan apakah model harus menyertakan istilah bias, yang merupakan suku intersep dalam persamaan linier. **Opsional** Nilai yang valid: `true` or `false` Nilai default: `true` |
| use\$1lr\$1scheduler | Apakah akan menggunakan penjadwal untuk tingkat pembelajaran. Jika Anda ingin menggunakan penjadwal, tentukan`true`. **Opsional** Nilai yang valid: `true` or `false` Nilai default: `true` |
| wd | Parameter peluruhan berat, juga dikenal sebagai parameter regularisasi L2. Jika Anda tidak ingin menggunakan regularisasi L2, atur nilainya ke 0. **Opsional** Nilai yang valid: `auto` atau bilangan bulat floating-point non-negatif Nilai default: `auto` |
# Menyetel model pembelajar linier
*Penyetelan model otomatis*, juga dikenal sebagai tuning hyperparameter, menemukan versi terbaik dari model dengan menjalankan banyak pekerjaan yang menguji berbagai hiperparameter pada kumpulan data Anda. Anda memilih hyperparameters yang dapat disetel, rentang nilai untuk masing-masing, dan metrik objektif. Anda memilih metrik objektif dari metrik yang dihitung algoritme. Penyetelan model otomatis mencari hiperparameter yang dipilih untuk menemukan kombinasi nilai yang menghasilkan model yang mengoptimalkan metrik objektif.
Algoritma pembelajar linier juga memiliki mekanisme internal untuk menyetel hiperparameter yang terpisah dari fitur penyetelan model otomatis yang dijelaskan di sini. Secara default, algoritme pembelajar linier menyetel hiperparameter dengan melatih beberapa model secara paralel. Saat Anda menggunakan penyetelan model otomatis, mekanisme penyetelan internal pelajar linier dimatikan secara otomatis. Ini menetapkan jumlah model paralel,`num_models`, ke 1. Algoritma mengabaikan nilai apa pun yang Anda tetapkan`num_models`.
Untuk informasi selengkapnya tentang penyetelan model, lihat[Penyetelan model otomatis dengan AI SageMaker](automatic-model-tuning.md).
## Metrik dihitung dengan algoritma pembelajar linier
Algoritma pembelajar linier melaporkan metrik dalam tabel berikut, yang dihitung selama pelatihan. Pilih salah satunya sebagai metrik objektif. Untuk menghindari overfitting, kami sarankan untuk menyetel model terhadap metrik validasi alih-alih metrik pelatihan.
| Nama Metrik | Deskripsi | Arah Optimasi |
| --- | --- | --- |
| test:absolute\$1loss | Hilangnya mutlak model akhir pada dataset pengujian. Metrik objektif ini hanya berlaku untuk regresi. | Minimalkan |
| test:binary\$1classification\$1accuracy | Keakuratan model akhir pada dataset pengujian. Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
| test:binary\$1f\$1beta | Skor F-beta dari model akhir pada dataset pengujian. Secara default, ini adalah skor F1, yang merupakan rata-rata harmonik presisi dan ingatan. Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
| test:dcg | Keuntungan kumulatif diskon dari model akhir pada dataset pengujian. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| test:macro\$1f\$1beta | Skor F-beta dari model akhir pada dataset pengujian. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| test:macro\$1precision | Skor presisi model akhir pada dataset pengujian. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| test:macro\$1recall | Skor recall model akhir pada dataset tes. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| test:mse | Kesalahan kuadrat rata-rata dari model akhir pada dataset pengujian. Metrik objektif ini hanya berlaku untuk regresi. | Minimalkan |
| test:multiclass\$1accuracy | Keakuratan model akhir pada dataset pengujian. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| test:multiclass\$1top\$1k\$1accuracy | Akurasi di antara label k teratas yang diprediksi pada kumpulan data pengujian. Jika Anda memilih metrik ini sebagai tujuan, sebaiknya atur nilai k menggunakan `accuracy_top_k` hyperparameter. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| test:objective\$1loss | Nilai rata-rata dari fungsi kerugian objektif pada dataset uji setelah model dilatih. Secara default, kerugian adalah kerugian logistik untuk klasifikasi biner dan kerugian kuadrat untuk regresi. Untuk mengatur kerugian ke jenis lain, gunakan `loss` hyperparameter. | Minimalkan |
| test:precision | Ketepatan model akhir pada dataset pengujian. Jika Anda memilih metrik ini sebagai tujuan, kami sarankan untuk menetapkan penarikan target dengan menyetel `binary_classifier_model_selection` hyperparameter ke `precision_at_target_recall` dan menetapkan nilai untuk `target_recall` hyperparameter. Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
| test:recall | Penarikan kembali model akhir pada dataset pengujian. Jika Anda memilih metrik ini sebagai tujuan, kami sarankan untuk menetapkan presisi target dengan menyetel `binary_classifier_model_selection` hyperparameter ke `recall_at_target_precision` dan menetapkan nilai untuk `target_precision` hyperparameter. Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
| test:roc\$1auc\$1score | Area di bawah kurva karakteristik operasi penerima (kurva ROC) dari model akhir pada kumpulan data pengujian. Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
| validation:absolute\$1loss | Hilangnya mutlak model akhir pada dataset validasi. Metrik objektif ini hanya berlaku untuk regresi. | Minimalkan |
| validation:binary\$1classification\$1accuracy | Keakuratan model akhir pada dataset validasi. Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
| validation:binary\$1f\$1beta | Skor F-beta dari model akhir pada dataset validasi. Secara default, skor F-beta adalah skor F1, yang merupakan rata-rata harmonik dari metrik dan. `validation:precision` `validation:recall` Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
| validation:dcg | Keuntungan kumulatif diskon dari model akhir pada dataset validasi. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| validation:macro\$1f\$1beta | Skor F-beta dari model akhir pada dataset validasi. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| validation:macro\$1precision | Skor presisi model akhir pada dataset validasi. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| validation:macro\$1recall | Skor recall model akhir pada dataset validasi. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| validation:mse | Kesalahan kuadrat rata-rata dari model akhir pada dataset validasi. Metrik objektif ini hanya berlaku untuk regresi. | Minimalkan |
| validation:multiclass\$1accuracy | Keakuratan model akhir pada dataset validasi. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| validation:multiclass\$1top\$1k\$1accuracy | Akurasi di antara label k teratas yang diprediksi pada kumpulan data validasi. Jika Anda memilih metrik ini sebagai tujuan, sebaiknya atur nilai k menggunakan `accuracy_top_k` hyperparameter. Metrik objektif ini hanya berlaku untuk klasifikasi multiclass. | Maksimalkan |
| validation:objective\$1loss | Nilai rata-rata dari fungsi kerugian objektif pada dataset validasi setiap zaman. Secara default, kerugian adalah kerugian logistik untuk klasifikasi biner dan kerugian kuadrat untuk regresi. Untuk mengatur kerugian ke jenis lain, gunakan `loss` hyperparameter. | Minimalkan |
| validation:precision | Ketepatan model akhir pada dataset validasi. Jika Anda memilih metrik ini sebagai tujuan, kami sarankan untuk menetapkan penarikan target dengan menyetel `binary_classifier_model_selection` hyperparameter ke `precision_at_target_recall` dan menetapkan nilai untuk `target_recall` hyperparameter. Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
| validation:recall | Penarikan kembali model akhir pada dataset validasi. Jika Anda memilih metrik ini sebagai tujuan, kami sarankan untuk menetapkan presisi target dengan menyetel `binary_classifier_model_selection` hyperparameter ke `recall_at_target_precision` dan menetapkan nilai untuk `target_precision` hyperparameter. Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
| validation:rmse | Kesalahan kuadrat rata-rata akar dari model akhir pada kumpulan data validasi. Metrik objektif ini hanya berlaku untuk regresi. | Minimalkan |
| validation:roc\$1auc\$1score | Area di bawah kurva karakteristik operasi penerima (kurva ROC) dari model akhir pada kumpulan data validasi. Metrik objektif ini hanya berlaku untuk klasifikasi biner. | Maksimalkan |
## Menyetel hiperparameter pelajar linier
Anda dapat menyetel model pembelajar linier dengan hyperparameters berikut.
| Nama Parameter | Jenis Parameter | Rentang yang Direkomendasikan |
| --- | --- | --- |
| wd | `ContinuousParameterRanges` | `MinValue: ``1e-7`, `MaxValue`: `1` |
| l1 | `ContinuousParameterRanges` | `MinValue`: `1e-7`, `MaxValue`: `1` |
| learning\$1rate | `ContinuousParameterRanges` | `MinValue`: `1e-5`, `MaxValue`: `1` |
| mini\$1batch\$1size | `IntegerParameterRanges` | `MinValue`: `100`, `MaxValue`: `5000` |
| use\$1bias | `CategoricalParameterRanges` | `[True, False]` |
| positive\$1example\$1weight\$1mult | `ContinuousParameterRanges` | `MinValue`: 1e-5,: `MaxValue` `1e5` |
# Format respons pelajar linier
## Format respons JSON
Semua algoritme bawaan Amazon SageMaker AI mematuhi format inferensi input umum yang dijelaskan dalam [Format Data Umum -](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) Inferensi. Berikut ini adalah format output yang tersedia untuk algoritma SageMaker AI linear learner.
**Klasifikasi Biner**
```
let response = {
"predictions": [
{
"score": 0.4,
"predicted_label": 0
}
]
}
```
**Klasifikasi Multiclass**
```
let response = {
"predictions": [
{
"score": [0.1, 0.2, 0.4, 0.3],
"predicted_label": 2
}
]
}
```
**Regresi**
```
let response = {
"predictions": [
{
"score": 0.4
}
]
}
```
## Format respons JSONLINES
**Klasifikasi Biner**
```
{"score": 0.4, "predicted_label": 0}
```
**Klasifikasi Multiclass**
```
{"score": [0.1, 0.2, 0.4, 0.3], "predicted_label": 2}
```
**Regresi**
```
{"score": 0.4}
```
## Format respons RECORDIO
**Klasifikasi Biner**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
},
'predicted_label': {
keys: [],
values: [0.0] # float32
}
}
}
]
```
**Klasifikasi Multiclass**
```
[
Record = {
"features": [],
"label": {
"score": {
"values": [0.1, 0.2, 0.3, 0.4]
},
"predicted_label": {
"values": [3]
}
},
"uid": "abc123",
"metadata": "{created_at: '2017-06-03'}"
}
]
```
**Regresi**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
}
}
}
]
```
# TabTransformer
[TabTransformer](https://arxiv.org/abs/2012.06678)adalah arsitektur pemodelan data tabular mendalam baru untuk pembelajaran yang diawasi. TabTransformer Arsitekturnya dibangun di atas self-attention-based Transformers. Lapisan Transformer mengubah penyematan fitur kategoris menjadi penyematan kontekstual yang kuat untuk mencapai akurasi prediksi yang lebih tinggi. Selain itu, penyematan kontekstual yang dipelajari sangat kuat terhadap fitur data TabTransformer yang hilang dan berisik, dan memberikan interpretasi yang lebih baik. Halaman ini mencakup informasi tentang rekomendasi instans Amazon EC2 dan contoh buku catatan untuk. TabTransformer
# Cara menggunakan SageMaker AI TabTransformer
Anda dapat menggunakannya TabTransformer sebagai algoritma bawaan Amazon SageMaker AI. Bagian berikut menjelaskan cara menggunakan TabTransformer dengan SageMaker Python SDK. Untuk informasi tentang cara menggunakan TabTransformer dari Amazon SageMaker Studio Classic UI, lihat[SageMaker JumpStart model terlatih](studio-jumpstart.md).
+ **Gunakan TabTransformer sebagai algoritma bawaan**
Gunakan algoritma TabTransformer bawaan untuk membangun wadah TabTransformer pelatihan seperti yang ditunjukkan pada contoh kode berikut. Anda dapat secara otomatis melihat URI image algoritme TabTransformer bawaan menggunakan SageMaker AI `image_uris.retrieve` API (atau `get_image_uri` API jika menggunakan [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) versi 2).
Setelah menentukan URI TabTransformer gambar, Anda dapat menggunakan TabTransformer wadah untuk membuat estimator menggunakan SageMaker AI Estimator API dan memulai pekerjaan pelatihan. Algoritma TabTransformer bawaan berjalan dalam mode skrip, tetapi skrip pelatihan disediakan untuk Anda dan tidak perlu menggantinya. Jika Anda memiliki pengalaman luas menggunakan mode skrip untuk membuat pekerjaan SageMaker pelatihan, maka Anda dapat memasukkan skrip TabTransformer pelatihan Anda sendiri.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "pytorch-tabtransformerclassification-model", "*", "training"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_binary/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"n_epochs"
] = "50"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1,
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"training": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Untuk informasi selengkapnya tentang cara mengatur TabTransformer sebagai algoritma bawaan, lihat contoh buku catatan berikut.
+ [Klasifikasi tabel dengan algoritma Amazon SageMaker AI TabTransformer](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Classification_TabTransformer.ipynb)
+ [Regresi tabular dengan algoritma Amazon AI SageMaker TabTransformer](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Regression_TabTransformer.ipynb)
# Antarmuka Input dan Output untuk TabTransformer algoritma
TabTransformer beroperasi pada data tabular, dengan baris mewakili pengamatan, satu kolom mewakili variabel target atau label, dan kolom yang tersisa mewakili fitur.
Implementasi SageMaker AI TabTransformer mendukung CSV untuk pelatihan dan inferensi:
+ Untuk **Pelatihan ContentType**, input yang valid harus berupa *teks/csv*.
+ *Untuk **Inferensi ContentType**, input yang valid harus teks/csv.*
**catatan**
Untuk pelatihan CSV, algoritme mengasumsikan bahwa variabel target ada di kolom pertama dan CSV tidak memiliki catatan header.
Untuk inferensi CSV, algoritme mengasumsikan bahwa input CSV tidak memiliki kolom label.
**Format input untuk data pelatihan, data validasi, dan fitur kategoris**
Perhatikan cara memformat data pelatihan Anda untuk masukan ke TabTransformer model. Anda harus menyediakan jalur ke bucket Amazon S3 yang berisi data pelatihan dan validasi Anda. Anda juga dapat menyertakan daftar fitur kategoris. Gunakan saluran `training` dan `validation` saluran untuk memberikan data masukan Anda. Atau, Anda hanya dapat menggunakan `training` saluran.
**Gunakan kedua `validation` saluran `training` dan**
Anda dapat memberikan data input Anda melalui dua jalur S3, satu untuk `training` saluran dan satu untuk `validation` saluran. Setiap jalur S3 dapat berupa awalan S3 yang menunjuk ke satu atau lebih file CSV atau jalur S3 lengkap yang menunjuk ke satu file CSV tertentu. Variabel target harus berada di kolom pertama file CSV Anda. Variabel prediktor (fitur) harus berada di kolom yang tersisa. Jika beberapa file CSV disediakan untuk `validation` saluran `training` atau, TabTransformer algoritme menggabungkan file. Data validasi digunakan untuk menghitung skor validasi di akhir setiap iterasi peningkatan. Penghentian awal diterapkan ketika skor validasi berhenti membaik.
Jika prediktor Anda menyertakan fitur kategoris, Anda dapat memberikan file JSON bernama `categorical_index.json` di lokasi yang sama dengan file atau file data pelatihan Anda. Jika Anda menyediakan file JSON untuk fitur kategoris, `training` saluran Anda harus menunjuk ke awalan S3 dan bukan file CSV tertentu. File ini harus berisi kamus Python di mana kuncinya adalah string `"cat_index_list"` dan nilainya adalah daftar bilangan bulat unik. Setiap bilangan bulat dalam daftar nilai harus menunjukkan indeks kolom dari fitur kategoris yang sesuai dalam file CSV data pelatihan Anda. Setiap nilai harus berupa bilangan bulat positif (lebih besar dari nol karena nol mewakili nilai target), kurang dari `Int32.MaxValue` (2147483647), dan kurang dari jumlah kolom. Seharusnya hanya ada satu file JSON indeks kategoris.
**Gunakan hanya `training` saluran**:
Sebagai alternatif, Anda dapat memberikan data input Anda melalui jalur S3 tunggal untuk `training` saluran tersebut. Jalur S3 ini harus menunjuk ke direktori dengan subdirektori bernama `training/` yang berisi satu atau lebih file CSV. Anda dapat secara opsional menyertakan subdirektori lain di lokasi yang sama yang disebut `validation/` yang juga memiliki satu atau lebih file CSV. Jika data validasi tidak disediakan, maka 20% data pelatihan Anda diambil sampelnya secara acak untuk dijadikan data validasi. Jika prediktor Anda menyertakan fitur kategoris, Anda dapat memberikan file JSON bernama `categorical_index.json` di lokasi yang sama dengan subdirektori data Anda.
**catatan**
Untuk mode input pelatihan CSV, total memori yang tersedia untuk algoritme (jumlah instance dikalikan dengan memori yang tersedia di`InstanceType`) harus dapat menampung kumpulan data pelatihan.
## Rekomendasi instans Amazon EC2 untuk algoritme TabTransformer
SageMaker AI TabTransformer mendukung pelatihan CPU satu instans dan GPU instans tunggal. Meskipun biaya per instans lebih tinggi, GPUs latih lebih cepat, membuatnya lebih hemat biaya. Untuk memanfaatkan pelatihan GPU, tentukan jenis instans sebagai salah satu instance GPU (misalnya, P3). SageMaker AI TabTransformer saat ini tidak mendukung pelatihan multi-GPU.
## TabTransformer contoh buku catatan
Tabel berikut menguraikan berbagai contoh notebook yang membahas berbagai kasus penggunaan algoritma Amazon SageMaker AI TabTransformer .
****
| **Judul Notebook** | **Deskripsi** |
| --- | --- |
| [Klasifikasi tabel dengan algoritma Amazon SageMaker AI TabTransformer ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Classification_TabTransformer.ipynb) | Notebook ini menunjukkan penggunaan TabTransformer algoritma Amazon SageMaker AI untuk melatih dan menjadi tuan rumah model klasifikasi tabular. |
| [Regresi tabular dengan algoritma Amazon AI SageMaker TabTransformer ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Regression_TabTransformer.ipynb) | Notebook ini menunjukkan penggunaan TabTransformer algoritma Amazon SageMaker AI untuk melatih dan menjadi tuan rumah model regresi tabular. |
Untuk petunjuk tentang cara membuat dan mengakses instance notebook Jupyter yang dapat Anda gunakan untuk menjalankan contoh di SageMaker AI, lihat. [Instans SageMaker notebook Amazon](nbi.md) Setelah Anda membuat instance notebook dan membukanya, pilih tab **Contoh SageMaker AI** untuk melihat daftar semua sampel SageMaker AI. Untuk membuka buku catatan, pilih tab **Use** dan pilih **Create copy**.
# Bagaimana cara TabTransformer kerja
TabTransformer adalah arsitektur pemodelan data tabular mendalam baru untuk pembelajaran yang diawasi. TabTransformer Ini dibangun di atas Transformers berbasis perhatian diri. Lapisan Transformer mengubah penyematan fitur kategoris menjadi penyematan kontekstual yang kuat untuk mencapai akurasi prediksi yang lebih tinggi. Selain itu, penyematan kontekstual yang dipelajari sangat kuat terhadap fitur data TabTransformer yang hilang dan berisik, dan memberikan interpretasi yang lebih baik.
TabTransformer berkinerja baik dalam kompetisi pembelajaran mesin karena penanganannya yang kuat terhadap berbagai tipe data, hubungan, distribusi, dan keragaman hiperparameter yang dapat Anda sesuaikan. Anda dapat menggunakan TabTransformer untuk regresi, klasifikasi (biner dan multiclass), dan masalah peringkat.
Diagram berikut menggambarkan TabTransformer arsitektur.
![\[Arsitektur TabTransformer.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/tabtransformer_illustration.png)
Untuk informasi lebih lanjut, lihat *[TabTransformer: Pemodelan Data Tabular Menggunakan Embeddings Kontekstual](https://arxiv.org/abs/2012.06678)*.
# TabTransformer hiperparameter
Tabel berikut berisi subset hiperparameter yang diperlukan atau paling umum digunakan untuk algoritma Amazon SageMaker AI TabTransformer . Pengguna mengatur parameter ini untuk memfasilitasi estimasi parameter model dari data. TabTransformerAlgoritma SageMaker AI adalah implementasi dari [TabTransformer](https://github.com/jrzaurin/pytorch-widedeep)paket open-source.
**catatan**
Hyperparameter default didasarkan pada contoh kumpulan data di file. [TabTransformer contoh buku catatan](tabtransformer.md#tabtransformer-sample-notebooks)
TabTransformer Algoritma SageMaker AI secara otomatis memilih metrik evaluasi dan fungsi objektif berdasarkan jenis masalah klasifikasi. TabTransformer Algoritma mendeteksi jenis masalah klasifikasi berdasarkan jumlah label dalam data Anda. Untuk masalah regresi, metrik evaluasi adalah r kuadrat dan fungsi tujuannya adalah kesalahan kuadrat rata-rata. Untuk masalah klasifikasi biner, metrik evaluasi dan fungsi objektif keduanya adalah entropi silang biner. Untuk masalah klasifikasi multikelas, metrik evaluasi dan fungsi obyektif keduanya adalah entropi silang multikelas.
**catatan**
Metrik TabTransformer evaluasi dan fungsi objektif saat ini tidak tersedia sebagai hiperparameter. Alih-alih, algoritme TabTransformer bawaan SageMaker AI secara otomatis mendeteksi jenis tugas klasifikasi (regresi, biner, atau multiclass) berdasarkan jumlah bilangan bulat unik di kolom label dan menetapkan metrik evaluasi dan fungsi objektif.
| Nama Parameter | Deskripsi |
| --- | --- |
| n\$1epochs | Jumlah zaman untuk melatih jaringan saraf dalam. Nilai yang valid: bilangan bulat, rentang: Bilangan bulat positif. Nilai default:`5`. |
| patience | Pelatihan akan berhenti jika satu metrik dari satu titik data validasi tidak membaik di `patience` babak terakhir. Nilai yang valid: integer, range: (`2`,`60`). Nilai default:`10`. |
| learning\$1rate | Tingkat di mana bobot model diperbarui setelah mengerjakan setiap batch contoh pelatihan. Nilai yang valid: float, range: Nomor floating point positif. Nilai default:`0.001`. |
| batch\$1size | Jumlah contoh disebarkan melalui jaringan. Nilai yang valid: integer, range: (`1`,`2048`). Nilai default:`256`. |
| input\$1dim | Dimensi penyematan untuk menyandikan kolom kategoris dan/atau kontinu. Nilai yang valid: string, salah satu dari berikut ini: `"16"``"32"`,`"64"`,,`"128"`,`"256"`, atau`"512"`. Nilai default:`"32"`. |
| n\$1blocks | Jumlah blok encoder Transformer. Nilai yang valid: integer, range: (`1`,`12`). Nilai default:`4`. |
| attn\$1dropout | Tingkat putus sekolah diterapkan pada lapisan Multi-Head Attention. Nilai yang valid: float, range: (`0`,`1`). Nilai default:`0.2`. |
| mlp\$1dropout | Tingkat putus sekolah diterapkan ke FeedForward jaringan dalam lapisan encoder dan lapisan MLP akhir di atas encoder Transformer. Nilai yang valid: float, range: (`0`,`1`). Nilai default:`0.1`. |
| frac\$1shared\$1embed | Fraksi embeddings dibagi oleh semua kategori yang berbeda untuk satu kolom tertentu. Nilai yang valid: float, range: (`0`,`1`). Nilai default:`0.25`. |
# Menyetel TabTransformer model
*Penyetelan model otomatis*, juga dikenal sebagai tuning hyperparameter, menemukan versi terbaik dari model dengan menjalankan banyak pekerjaan yang menguji berbagai hiperparameter pada kumpulan data pelatihan dan validasi Anda. Penyetelan model berfokus pada hiperparameter berikut:
**catatan**
Fungsi tujuan pembelajaran dan metrik evaluasi keduanya secara otomatis ditetapkan berdasarkan jenis tugas klasifikasi, yang ditentukan oleh jumlah bilangan bulat unik di kolom label. Untuk informasi selengkapnya, lihat [TabTransformer hiperparameter](tabtransformer-hyperparameters.md).
+ Fungsi tujuan pembelajaran untuk mengoptimalkan selama pelatihan model
+ Metrik evaluasi yang digunakan untuk mengevaluasi kinerja model selama validasi
+ Satu set hyperparameters dan rentang nilai untuk masing-masing untuk digunakan saat menyetel model secara otomatis
Penyetelan model otomatis mencari hiperparameter pilihan Anda untuk menemukan kombinasi nilai yang menghasilkan model yang mengoptimalkan metrik evaluasi yang dipilih.
**catatan**
Penyetelan model otomatis hanya TabTransformer tersedia dari Amazon SageMaker SDKs, bukan dari konsol SageMaker AI.
Untuk informasi selengkapnya tentang penyetelan model, lihat[Penyetelan model otomatis dengan AI SageMaker](automatic-model-tuning.md).
## Metrik evaluasi dihitung oleh algoritme TabTransformer
TabTransformer Algoritma SageMaker AI menghitung metrik berikut untuk digunakan untuk validasi model. Metrik evaluasi secara otomatis ditetapkan berdasarkan jenis tugas klasifikasi, yang ditentukan oleh jumlah bilangan bulat unik di kolom label.
| Nama Metrik | Deskripsi | Arah Optimasi | Pola Regex |
| --- | --- | --- | --- |
| r2 | r persegi | memaksimalkan | "metrics=\$1'r2': (\$1\$1S\$1)\$1" |
| f1\$1score | entropi silang biner | memaksimalkan | "metrics=\$1'f1': (\$1\$1S\$1)\$1" |
| accuracy\$1score | entropi silang multiclass | memaksimalkan | "metrics=\$1'accuracy': (\$1\$1S\$1)\$1" |
## Hiperparameter yang dapat disetel TabTransformer
Setel TabTransformer model dengan hyperparameters berikut. Hiperparameter yang memiliki efek terbesar dalam mengoptimalkan metrik TabTransformer evaluasi adalah:`learning_rate`,,,, `input_dim` `n_blocks``attn_dropout`, `mlp_dropout` dan. `frac_shared_embed` Untuk daftar semua TabTransformer hyperparameters, lihat[TabTransformer hiperparameter](tabtransformer-hyperparameters.md).
| Nama Parameter | Jenis Parameter | Rentang yang Direkomendasikan |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001, MaxValue: 0,01 |
| input\$1dim | CategoricalParameterRanges | [16, 32, 64, 128, 256, 512] |
| n\$1blocks | IntegerParameterRanges | MinValue: 1, MaxValue: 12 |
| attn\$1dropout | ContinuousParameterRanges | MinValue: 0.0, MaxValue: 0.8 |
| mlp\$1dropout | ContinuousParameterRanges | MinValue: 0.0, MaxValue: 0.8 |
| frac\$1shared\$1embed | ContinuousParameterRanges | MinValue: 0.0, MaxValue: 0.5 |
# XGBoost algoritma dengan Amazon SageMaker AI
[XGBoost](https://github.com/dmlc/xgboost)(eXtreme Gradient Boosting) adalah implementasi open-source yang populer dan efisien dari algoritma gradient boosted trees. Peningkatan gradien adalah algoritma pembelajaran yang diawasi yang mencoba memprediksi variabel target secara akurat dengan menggabungkan beberapa perkiraan dari serangkaian model yang lebih sederhana. XGBoost Algoritma berkinerja baik dalam kompetisi pembelajaran mesin karena alasan berikut:
+ Penanganannya yang kuat dari berbagai tipe data, hubungan, distribusi.
+ Berbagai hiperparameter yang dapat Anda sesuaikan.
Anda dapat menggunakan XGBoost untuk regresi, klasifikasi (biner dan multiclass), dan masalah peringkat.
Anda dapat menggunakan rilis baru XGBoost algoritma sebagai:
+ Algoritma bawaan Amazon SageMaker AI.
+ Kerangka kerja untuk menjalankan skrip pelatihan di lingkungan lokal Anda.
Implementasi ini memiliki footprint memori yang lebih kecil, logging yang lebih baik, validasi hyperparameter yang lebih baik, dan set metrik yang lebih besar daripada versi aslinya. Ini menyediakan XGBoost `estimator` yang menjalankan skrip pelatihan di XGBoost lingkungan yang dikelola. Rilis SageMaker AI saat ini XGBoost didasarkan pada XGBoost versi asli 1.0, 1.2, 1.3, 1.5, 1.7 dan 3.0.
Untuk informasi selengkapnya tentang XGBoost algoritme Amazon SageMaker AI, lihat posting blog berikut:
+ [Memperkenalkan wadah XGBoost algoritme Amazon SageMaker AI sumber terbuka](https://aws.amazon.com/blogs/machine-learning/introducing-the-open-source-amazon-sagemaker-xgboost-algorithm-container/)
+ [Amazon SageMaker AI XGBoost sekarang menawarkan pelatihan GPU yang didistribusikan sepenuhnya](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-xgboost-now-offers-fully-distributed-gpu-training/)
## Versi yang didukung
Untuk detail selengkapnya, lihat [kebijakan dukungan](https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-containers-support-policy.html#pre-built-containers-support-policy-ml-framework) kami.
+ Mode kerangka kerja (sumber terbuka): 1.2-1, 1.2-2, 1.3-1, 1.5-1, 1.7-1, 3.0-5
+ Modus algoritma: 1.2-1, 1.2-2, 1.3-1, 1.5-1, 1.7-1, 3.0-5
**Awas**
Karena kapasitas komputasi yang diperlukan, SageMaker AI versi 3.0-5 tidak XGBoost kompatibel dengan instans GPU dari keluarga instans P3 untuk pelatihan atau inferensi.
**Awas**
Karena paket yang kompatibel, versi 3.0-5 SageMaker AI XGBoost tidak mendukung SageMaker debugger.
**Awas**
Karena kapasitas komputasi yang diperlukan, SageMaker AI versi 1.7-1 tidak XGBoost kompatibel dengan instans GPU dari keluarga instans P2 untuk pelatihan atau inferensi.
**Awas**
Mode Isolasi Jaringan: Jangan meng-upgrade pip di luar versi 25.2. Versi yang lebih baru mungkin mencoba mengambil setuptools dari PyPI selama instalasi modul.
**penting**
Saat Anda mengambil URI XGBoost gambar SageMaker AI, jangan gunakan `:latest` atau `:1` untuk tag URI gambar. Anda harus menentukan salah satu XGBoost wadah yang SageMaker dikelola AI dengan versi XGBoost paket asli yang ingin Anda gunakan. [Versi yang didukung](#xgboost-supported-versions) Untuk menemukan versi paket yang dimigrasikan ke XGBoost kontainer SageMaker AI, lihat [Docker Registry Paths dan Example](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html) Code. Kemudian pilih Anda Wilayah AWS, dan arahkan ke bagian **XGBoost (algoritma)**.
**Awas**
Versi XGBoost 0.90 tidak digunakan lagi. Dukungan untuk pembaruan keamanan atau perbaikan bug untuk XGBoost 0,90 dihentikan. Kami sangat menyarankan Anda meningkatkan XGBoost versi ke salah satu versi yang lebih baru.
**catatan**
XGBoost v1.1 tidak didukung pada SageMaker AI. XGBoost 1.1 memiliki kemampuan rusak untuk menjalankan prediksi ketika input pengujian memiliki lebih sedikit fitur daripada data pelatihan dalam input LIBSVM. Kemampuan ini telah dipulihkan di XGBoost v1.2. Pertimbangkan untuk menggunakan SageMaker AI XGBoost 1.2-2 atau yang lebih baru.
**catatan**
Anda dapat menggunakan XGBoost v1.0-1, tetapi tidak didukung secara resmi.
## Rekomendasi instans EC2 untuk algoritma XGBoost
SageMaker AI XGBoost mendukung pelatihan dan inferensi CPU dan GPU. Rekomendasi instans tergantung pada kebutuhan pelatihan dan inferensi, serta versi XGBoost algoritme. Pilih salah satu opsi berikut untuk informasi lebih lanjut:
+ [Pelatihan CPU](#Instance-XGBoost-training-cpu)
+ [Pelatihan GPU](#Instance-XGBoost-training-gpu)
+ [Pelatihan CPU terdistribusi](#Instance-XGBoost-distributed-training-cpu)
+ [Pelatihan GPU terdistribusi](#Instance-XGBoost-distributed-training-gpu)
+ [Inferensi](#Instance-XGBoost-inference)
### Pelatihan
XGBoost Algoritma SageMaker AI mendukung pelatihan CPU dan GPU.
#### Pelatihan CPU
SageMaker AI XGBoost 1.0-1 atau sebelumnya hanya menggunakan kereta. CPUs Ini adalah algoritma yang terikat memori (sebagai lawan dari compute-bound). Jadi, instance komputasi tujuan umum (misalnya, M5) adalah pilihan yang lebih baik daripada instance yang dioptimalkan komputasi (misalnya, C4). Selanjutnya, kami menyarankan Anda memiliki memori total yang cukup dalam instance yang dipilih untuk menyimpan data pelatihan. Ini mendukung penggunaan ruang disk untuk menangani data yang tidak sesuai dengan memori utama. Ini adalah hasil dari out-of-core fitur yang tersedia dengan modus input libsvm. Meski begitu, menulis file cache ke disk memperlambat waktu pemrosesan algoritma.
#### Pelatihan GPU
SageMaker AI XGBoost versi 1.2-2 atau yang lebih baru mendukung pelatihan GPU. Meskipun biaya per instans lebih tinggi, GPUs latih lebih cepat, membuatnya lebih hemat biaya.
SageMaker AI XGBoost versi 1.2-2 atau yang lebih baru mendukung keluarga instans GPU P2, P3, G4dn, dan G5.
SageMaker AI XGBoost versi 1.7-1 atau yang lebih baru mendukung keluarga instans GPU P3, G4dn, dan G5. Perhatikan bahwa karena persyaratan kapasitas komputasi, versi 1.7-1 atau yang lebih baru tidak mendukung keluarga instans P2.
SageMaker AI XGBoost versi 3.0-5 atau yang lebih baru mendukung keluarga instance GPU G4dn dan G5. Perhatikan bahwa karena persyaratan kapasitas komputasi, versi 3.0-5 atau yang lebih baru tidak mendukung keluarga instans P3.
Untuk memanfaatkan pelatihan GPU:
+ Tentukan jenis instance sebagai salah satu instance GPU (misalnya, G4dn)
+ Setel `tree_method` hyperparameter ke `gpu_hist` dalam skrip yang ada XGBoost
### Pelatihan terdistribusi
SageMaker AI XGBoost mendukung instans CPU dan GPU untuk pelatihan terdistribusi.
#### Pelatihan CPU terdistribusi
Untuk menjalankan pelatihan CPU pada beberapa instance, atur `instance_count` parameter untuk estimator ke nilai yang lebih besar dari satu. Data input harus dibagi antara jumlah total instance.
##### Bagilah data masukan di seluruh instance
Bagilah data input menggunakan langkah-langkah berikut:
1. Pecah data input menjadi file yang lebih kecil. Jumlah file harus setidaknya sama dengan jumlah instance yang digunakan untuk pelatihan terdistribusi. Menggunakan beberapa file yang lebih kecil sebagai lawan dari satu file besar juga mengurangi waktu pengunduhan data untuk pekerjaan pelatihan.
1. Saat membuat Anda [TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html), atur parameter distribusi ke`ShardedByS3Key`. Dengan ini, setiap instance mendapat sekitar *1/n* dari jumlah file di S3 jika ada *n* instance yang ditentukan dalam pekerjaan pelatihan.
#### Pelatihan GPU terdistribusi
Anda dapat menggunakan pelatihan terdistribusi dengan instans GPU tunggal atau multi-GPU.
**Pelatihan terdistribusi dengan instans GPU tunggal**
SageMaker AI XGBoost versi 1.2-2 hingga 1.3-1 hanya mendukung pelatihan instans GPU tunggal. Ini berarti bahwa bahkan jika Anda memilih instance multi-GPU, hanya satu GPU yang digunakan per instance.
Anda harus membagi data input Anda antara jumlah total instance jika:
+ Anda menggunakan XGBoost versi 1.2-2 hingga 1.3-1.
+ Anda tidak perlu menggunakan instance multi-GPU.
Untuk informasi selengkapnya, lihat [Bagilah data masukan di seluruh instance](#Instance-XGBoost-distributed-training-divide-data).
**catatan**
Versi 1.2-2 hingga 1.3-1 SageMaker AI XGBoost hanya menggunakan satu GPU per instans bahkan jika Anda memilih instans multi-GPU.
**Pelatihan terdistribusi dengan instans multi-GPU**
[Dimulai dengan versi 1.5-1, SageMaker AI XGBoost menawarkan pelatihan GPU terdistribusi dengan Dask.](https://www.dask.org/) Dengan Dask Anda dapat menggunakan semua GPUs saat menggunakan satu atau lebih instance multi-GPU. Dask juga berfungsi saat menggunakan instance GPU tunggal.
Berlatih dengan Dask menggunakan langkah-langkah berikut:
1. Entah menghilangkan `distribution` parameter di Anda [TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)atau mengaturnya ke`FullyReplicated`.
1. Saat mendefinisikan hyperparameters Anda, atur `use_dask_gpu_training` ke. `"true"`
**penting**
Pelatihan terdistribusi dengan Dask hanya mendukung format input CSV dan Parket. Jika Anda menggunakan format data lain seperti LIBSVM atau PROTOBUF, pekerjaan pelatihan gagal.
Untuk data Parket, pastikan bahwa nama kolom disimpan sebagai string. Kolom yang memiliki nama tipe data lain akan gagal dimuat.
**penting**
Pelatihan terdistribusi dengan Dask tidak mendukung mode pipa. Jika mode pipa ditentukan, pekerjaan pelatihan gagal.
Ada beberapa pertimbangan yang harus diperhatikan saat melatih SageMaker AI XGBoost dengan Dask. Pastikan untuk membagi data Anda menjadi file yang lebih kecil. Dask membaca setiap file Parket sebagai partisi. Ada pekerja Dask untuk setiap GPU. Akibatnya, jumlah file harus lebih besar dari jumlah total GPUs (jumlah instance\$1 jumlah GPUs per instance). Memiliki jumlah file yang sangat besar juga dapat menurunkan kinerja. Untuk informasi selengkapnya, lihat [Praktik Terbaik Dask](https://docs.dask.org/en/stable/best-practices.html).
#### Variasi dalam output
`tree_method`Hyperparameter yang ditentukan menentukan algoritma yang digunakan untuk XGBoost pelatihan. Metode pohon`approx`, `hist` dan semuanya `gpu_hist` merupakan metode perkiraan dan menggunakan sketsa untuk perhitungan kuantil. Untuk informasi selengkapnya, lihat [Metode Pohon](https://xgboost.readthedocs.io/en/stable/treemethod.html) dalam XGBoost dokumentasi. Sketsa adalah algoritma perkiraan. Oleh karena itu, Anda dapat mengharapkan variasi dalam model tergantung pada faktor-faktor seperti jumlah pekerja yang dipilih untuk pelatihan terdistribusi. Signifikansi variasi bergantung pada data.
### Inferensi
SageMaker AI XGBoost mendukung instance CPU dan GPU untuk inferensi. Untuk informasi tentang jenis instans untuk inferensi, lihat [Jenis Instance Amazon SageMaker AI ML](https://aws.amazon.com/sagemaker/pricing/).
# Cara menggunakan SageMaker AI XGBoost
Dengan SageMaker AI, Anda dapat menggunakannya XGBoost sebagai algoritma atau kerangka kerja bawaan. Ketika XGBoost sebagai kerangka kerja, Anda memiliki lebih banyak fleksibilitas dan akses ke skenario yang lebih maju karena Anda dapat menyesuaikan skrip pelatihan Anda sendiri. Bagian berikut menjelaskan cara menggunakan XGBoost dengan SageMaker Python SDK, dan input/output antarmuka untuk algoritma. XGBoost Untuk informasi tentang cara menggunakan XGBoost dari Amazon SageMaker Studio Classic UI, lihat[SageMaker JumpStart model terlatih](studio-jumpstart.md).
**Topics**
+ [Gunakan XGBoost sebagai kerangka kerja](#xgboost-how-to-framework)
+ [Gunakan XGBoost sebagai algoritma bawaan](#xgboost-how-to-built-in)
+ [Antarmuka Input/Output untuk algoritma XGBoost](#InputOutput-XGBoost)
## Gunakan XGBoost sebagai kerangka kerja
Gunakan XGBoost sebagai kerangka kerja untuk menjalankan skrip pelatihan khusus Anda yang dapat menggabungkan pemrosesan data tambahan ke dalam pekerjaan pelatihan Anda. Dalam contoh kode berikut, SageMaker Python SDK menyediakan XGBoost API sebagai kerangka kerja. Fungsi ini mirip dengan bagaimana SageMaker AI menyediakan kerangka kerja lain APIs, seperti TensorFlow, MXNet, dan PyTorch.
```
import boto3
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput
# initialize hyperparameters
hyperparameters = {
"max_depth":"5",
"eta":"0.2",
"gamma":"4",
"min_child_weight":"6",
"subsample":"0.7",
"verbosity":"1",
"objective":"reg:squarederror",
"num_round":"50"}
# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-framework'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-framework')
# construct a SageMaker AI XGBoost estimator
# specify the entry_point to your xgboost training script
estimator = XGBoost(entry_point = "your_xgboost_abalone_script.py",
framework_version='1.7-1',
hyperparameters=hyperparameters,
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.m5.2xlarge',
output_path=output_path)
# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)
# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})
```
Untuk end-to-end contoh menggunakan SageMaker AI XGBoost sebagai kerangka kerja, lihat [Regresi dengan Amazon SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_abalone_dist_script_mode.html) AI. XGBoost
## Gunakan XGBoost sebagai algoritma bawaan
Gunakan algoritma XGBoost bawaan untuk membangun wadah XGBoost pelatihan seperti yang ditunjukkan pada contoh kode berikut. Anda dapat secara otomatis melihat URI gambar algoritme XGBoost bawaan menggunakan SageMaker AI `image_uris.retrieve` API. Jika menggunakan [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) versi 1, gunakan API. `get_image_uri` Untuk memastikan bahwa `image_uris.retrieve` API menemukan URI yang benar, lihat [Parameter umum untuk algoritme bawaan](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html). Kemudian cari `xgboost` dari daftar lengkap gambar algoritma bawaan URIs dan wilayah yang tersedia.
Setelah menentukan URI XGBoost gambar, gunakan XGBoost wadah untuk membuat estimator menggunakan SageMaker AI Estimator API dan memulai pekerjaan pelatihan. Mode algoritma XGBoost bawaan ini tidak menggabungkan skrip XGBoost pelatihan Anda sendiri dan berjalan langsung pada kumpulan data input.
**penting**
Saat Anda mengambil URI XGBoost gambar SageMaker AI, jangan gunakan `:latest` atau `:1` untuk tag URI gambar. Anda harus menentukan salah satu XGBoost wadah yang SageMaker dikelola AI dengan versi XGBoost paket asli yang ingin Anda gunakan. [Versi yang didukung](xgboost.md#xgboost-supported-versions) Untuk menemukan versi paket yang dimigrasikan ke XGBoost kontainer SageMaker AI, lihat [Docker Registry Paths dan Example](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html) Code. Kemudian pilih Anda Wilayah AWS, dan arahkan ke bagian **XGBoost(algoritma)**.
```
import sagemaker
import boto3
from sagemaker import image_uris
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput
# initialize hyperparameters
hyperparameters = {
"max_depth":"5",
"eta":"0.2",
"gamma":"4",
"min_child_weight":"6",
"subsample":"0.7",
"objective":"reg:squarederror",
"num_round":"50"}
# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-built-in-algo'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-built-in-algo')
# this line automatically looks for the XGBoost image URI and builds an XGBoost container.
# specify the repo_version depending on your preference.
xgboost_container = sagemaker.image_uris.retrieve("xgboost", region, "1.7-1")
# construct a SageMaker AI estimator that calls the xgboost-container
estimator = sagemaker.estimator.Estimator(image_uri=xgboost_container,
hyperparameters=hyperparameters,
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.m5.2xlarge',
volume_size=5, # 5 GB
output_path=output_path)
# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)
# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})
```
Untuk informasi selengkapnya tentang cara mengatur XGBoost sebagai algoritma bawaan, lihat contoh buku catatan berikut.
+ [Pelatihan Spot Terkelola untuk XGBoost](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_managed_spot_training.html)
+ [Regresi dengan Amazon SageMaker AI XGBoost (input Parket)](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_parquet_input_training.html)
## Antarmuka Input/Output untuk algoritma XGBoost
Peningkatan gradien beroperasi pada data tabular, dengan baris mewakili pengamatan, satu kolom mewakili variabel target atau label, dan kolom yang tersisa mewakili fitur.
Implementasi SageMaker AI XGBoost mendukung format data berikut untuk pelatihan dan inferensi:
+ *teks/libsvm* (default)
+ *teks/csv*
+ *aplikasi/x-parket*
+ *aplikasi/ x-recordio-protobuf*
**catatan**
Ada beberapa pertimbangan yang harus diperhatikan mengenai pelatihan dan input inferensi:
Untuk meningkatkan kinerja, sebaiknya gunakan XGBoost dengan *mode File*, di mana data Anda dari Amazon S3 disimpan pada volume instans pelatihan.
Untuk pelatihan dengan input kolumnar, algoritma mengasumsikan bahwa variabel target (label) adalah kolom pertama. Untuk inferensi, algoritma mengasumsikan bahwa input tidak memiliki kolom label.
Untuk data CSV, input tidak boleh memiliki catatan header.
Untuk pelatihan LIBSVM, algoritme mengasumsikan bahwa kolom berikutnya setelah kolom label berisi pasangan nilai indeks berbasis nol untuk fitur. Jadi setiap baris memiliki format::