Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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)
```