Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Parameter untuk Algoritma Bawaan
Tabel berikut mencantumkan parameter untuk masing-masing algoritme yang disediakan oleh Amazon SageMaker AI.
| 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 |
| BlazingText | melatih | File atau Pipa | File teks (satu kalimat per baris dengan token yang dipisahkan spasi) | CPU atau GPU (hanya satu contoh) | Tidak |
| CatBoost | pelatihan dan validasi (opsional) | File | CSV | CPU (hanya satu contoh) | Tidak |
| Peramalan DeepAR | melatih dan (opsional) tes | File | Garis JSON atau Parket | CPU atau GPU | Ya |
| Mesin Faktorisasi | melatih dan (opsional) tes | File atau Pipa | Protobuf Recordio | CPU (GPU untuk data padat) | Ya |
| Klasifikasi Gambar - MXNet | melatih dan validasi, (opsional) train\$1lst, validation\$1lst, dan model | File atau Pipa | RecorDo atau file gambar (.jpg atau.png) | GPU | Ya |
| Klasifikasi Gambar - TensorFlow | pelatihan dan validasi | File | file gambar (.jpg, .jpeg, atau .png) | CPU atau GPU | Ya (hanya di beberapa GPUs pada satu instance) |
| Wawasan IP | melatih dan (opsional) validasi | File | CSV | CPU atau GPU | Ya |
| K-Berarti | melatih dan (opsional) tes | File atau Pipa | Recordio-protobuf atau CSV | CPU atau GPUCommon (perangkat GPU tunggal pada satu atau beberapa instance) | Tidak |
| 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 |
| LDA | melatih dan (opsional) tes | File atau Pipa | Recordio-protobuf atau CSV | CPU (hanya satu contoh) | Tidak |
| LightGBM | pelatihan/pelatihan dan validasi (opsional) | File | CSV | CPU | Ya |
| Linear Learner | melatih dan (opsional) validasi, tes, atau keduanya | File atau Pipa | Recordio-protobuf atau CSV | CPU atau GPU | Ya |
| Model Topik Saraf | melatih dan (opsional) validasi, tes, atau keduanya | File atau Pipa | Recordio-protobuf atau CSV | CPU atau GPU | Ya |
| Object2Vec | melatih dan (opsional) validasi, tes, atau keduanya | File | Garis JSON | CPU atau GPU (hanya satu contoh) | Tidak |
| Deteksi Objek - MXNet | melatih dan validasi, (opsional) train\$1annotation, validation\$1annotation, dan model | File atau Pipa | RecorDo atau file gambar (.jpg atau.png) | GPU | Ya |
| Deteksi Objek - TensorFlow | pelatihan dan validasi | File | file gambar (.jpg, .jpeg, atau .png) | GPU | Ya (hanya di beberapa GPUs pada satu instance) |
| PCA | melatih dan (opsional) tes | File atau Pipa | Recordio-protobuf atau CSV | CPU atau GPU | Ya |
| Random Cut Forest | melatih dan (opsional) tes | File atau Pipa | Recordio-protobuf atau CSV | CPU | Ya |
| Segmentasi Semantik | melatih dan validasi, train\$1annotation, validation\$1annotation, dan (opsional) label\$1map dan model | File atau Pipa | File gambar | GPU (hanya satu contoh) | Tidak |
| Pemodelan Seq2Seq | melatih, validasi, dan vocab | File | Protobuf Recordio | GPU (hanya satu contoh) | Tidak |
| TabTransformer | pelatihan dan validasi (opsional) | File | CSV | CPU atau GPU (hanya satu contoh) | Tidak |
| Klasifikasi Teks - TensorFlow | pelatihan dan validasi | File | CSV | CPU atau GPU | Ya (hanya di beberapa GPUs pada satu instance) |
| 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 |
Algoritma yang dapat *diparalelkan dapat* digunakan pada beberapa instance komputasi untuk pelatihan terdistribusi.
Topik berikut memberikan informasi tentang format data, jenis instans Amazon EC2 yang direkomendasikan, dan CloudWatch log yang umum untuk semua algoritme bawaan yang disediakan oleh Amazon AI. SageMaker
**catatan**
Untuk mencari image Docker URIs dari algoritma bawaan yang dikelola oleh SageMaker AI, lihat [Docker Registry Paths and](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths) Example Code.
**Topics**
+ [Format Data Umum untuk Pelatihan](cdf-training.md)
+ [Format data umum untuk inferensi](cdf-inference.md)
+ [Jenis Instance untuk Algoritma Bawaan](cmn-info-instance-types.md)
+ [Log untuk Algoritma Bawaan](common-info-all-sagemaker-models-logs.md)
# Format Data Umum untuk Pelatihan
Untuk mempersiapkan pelatihan, Anda dapat memproses data Anda menggunakan berbagai AWS layanan, termasuk Amazon EMR, Amazon Redshift AWS Glue, Amazon Relational Database Service, dan Amazon Athena. Setelah preprocessing, publikasikan data ke bucket Amazon S3. Untuk pelatihan, data harus melalui serangkaian konversi dan transformasi, termasuk:
+ Serialisasi data pelatihan (ditangani oleh Anda)
+ Deserialisasi data pelatihan (ditangani oleh algoritme)
+ Serialisasi model pelatihan (ditangani oleh algoritma)
+ Deserialisasi model terlatih (opsional, ditangani oleh Anda)
Saat menggunakan Amazon SageMaker AI di bagian pelatihan algoritme, pastikan untuk mengunggah semua data sekaligus. Jika lebih banyak data ditambahkan ke lokasi itu, panggilan pelatihan baru perlu dibuat untuk membangun model baru.
**Topics**
+ [Jenis Konten yang Didukung oleh Algoritma Bawaan](#cdf-common-content-types)
+ [Menggunakan Mode Pipa](#cdf-pipe-mode)
+ [Menggunakan Format CSV](#cdf-csv-format)
+ [Menggunakan Format RecorDio](#cdf-recordio-format)
+ [Deserialisasi Model Terlatih](#td-deserialization)
## Jenis Konten yang Didukung oleh Algoritma Bawaan
Tabel berikut mencantumkan beberapa [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType)nilai yang didukung umum dan algoritma yang menggunakannya:
ContentTypes untuk Algoritma Bawaan
| ContentType | Algoritme |
| --- | --- |
| aplikasi/x-image | Algoritma Deteksi Objek, Segmentasi Semantik |
| aplikasi/x-recordio | Algoritma Deteksi Objek |
| aplikasi/ x-recordio-protobuf | Mesin Faktorisasi, K-Means, K-NN, Alokasi Dirichlet Laten, Linear Learner, NTM, PCA, RCF, Sequence-to-Sequence |
| aplikasi/jsonlines | BlazingText, DeepAR |
| gambar/jpeg | Algoritma Deteksi Objek, Segmentasi Semantik |
| gambar/png | Algoritma Deteksi Objek, Segmentasi Semantik |
| teks/csv | Wawasan IP, K-Means, K-NN, Alokasi Dirichlet Laten, Pelajar Linear, NTM, PCA, RCF, XGBoost |
| teks/libsvm | XGBoost |
Untuk ringkasan parameter yang digunakan oleh setiap algoritma, lihat dokumentasi untuk algoritma individu atau [tabel](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html) ini.
## Menggunakan Mode Pipa
Dalam *mode Pipe*, pekerjaan latihan Anda mengalirkan data langsung dari Amazon Simple Storage Service (Amazon S3). Streaming dapat memberikan waktu mulai yang lebih cepat untuk pekerjaan pelatihan dan throughput yang lebih baik. Ini berbeda dengan *mode File*, di mana data Anda dari Amazon S3 disimpan pada volume instans pelatihan. Mode file menggunakan ruang disk untuk menyimpan artefak model akhir dan kumpulan data pelatihan lengkap Anda. Dengan streaming data Anda langsung dari Amazon S3 dalam mode Pipa, Anda mengurangi ukuran volume Amazon Elastic Block Store dari instans pelatihan Anda. Mode pipa hanya membutuhkan ruang disk yang cukup untuk menyimpan artefak model akhir Anda. Lihat [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)untuk detail tambahan tentang mode input pelatihan.
## Menggunakan Format CSV
Banyak algoritma Amazon SageMaker AI mendukung pelatihan dengan data dalam format CSV. Untuk menggunakan data dalam format CSV untuk pelatihan, dalam spesifikasi saluran data input, tentukan **text/csv** sebagai. [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType) Amazon SageMaker AI mengharuskan file CSV tidak memiliki catatan header dan variabel target ada di kolom pertama. Untuk menjalankan algoritme pembelajaran tanpa pengawasan yang tidak memiliki target, tentukan jumlah kolom label dalam jenis konten. Misalnya, dalam hal ini**'content\$1type=text/csv;label\$1size=0'**. Untuk informasi selengkapnya, lihat [Sekarang menggunakan mode Pipa dengan kumpulan data CSV untuk pelatihan lebih cepat tentang algoritme bawaan Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/now-use-pipe-mode-with-csv-datasets-for-faster-training-on-amazon-sagemaker-built-in-algorithms/).
## Menggunakan Format RecorDio
Dalam format protobuf Recordio, SageMaker AI mengubah setiap pengamatan dalam dataset menjadi representasi biner sebagai satu set float 4-byte, lalu memuatnya di bidang nilai protobuf. Jika Anda menggunakan Python untuk persiapan data Anda, kami sangat menyarankan Anda menggunakan transformasi yang ada ini. Namun, jika Anda menggunakan bahasa lain, file definisi protobuf di bawah ini menyediakan skema yang Anda gunakan untuk mengonversi data Anda menjadi format protobuf SageMaker AI.
**catatan**
Untuk contoh yang menunjukkan cara mengonversi array NumPy yang umum digunakan ke dalam format protobuf RecorDio, *[lihat Pengantar Mesin Faktorisasi dengan MNIST](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/factorization_machines_mnist/factorization_machines_mnist.html)*.
```
syntax = "proto2";
package aialgs.data;
option java_package = "com.amazonaws.aialgorithms.proto";
option java_outer_classname = "RecordProtos";
// A sparse or dense rank-R tensor that stores data as doubles (float64).
message Float32Tensor {
// Each value in the vector. If keys is empty, this is treated as a
// dense vector.
repeated float values = 1 [packed = true];
// If key is not empty, the vector is treated as sparse, with
// each key specifying the location of the value in the sparse vector.
repeated uint64 keys = 2 [packed = true];
// An optional shape that allows the vector to represent a matrix.
// For example, if shape = [ 10, 20 ], floor(keys[i] / 20) gives the row,
// and keys[i] % 20 gives the column.
// This also supports n-dimensonal tensors.
// Note: If the tensor is sparse, you must specify this value.
repeated uint64 shape = 3 [packed = true];
}
// A sparse or dense rank-R tensor that stores data as doubles (float64).
message Float64Tensor {
// Each value in the vector. If keys is empty, this is treated as a
// dense vector.
repeated double values = 1 [packed = true];
// If this is not empty, the vector is treated as sparse, with
// each key specifying the location of the value in the sparse vector.
repeated uint64 keys = 2 [packed = true];
// An optional shape that allows the vector to represent a matrix.
// For example, if shape = [ 10, 20 ], floor(keys[i] / 10) gives the row,
// and keys[i] % 20 gives the column.
// This also supports n-dimensonal tensors.
// Note: If the tensor is sparse, you must specify this value.
repeated uint64 shape = 3 [packed = true];
}
// A sparse or dense rank-R tensor that stores data as 32-bit ints (int32).
message Int32Tensor {
// Each value in the vector. If keys is empty, this is treated as a
// dense vector.
repeated int32 values = 1 [packed = true];
// If this is not empty, the vector is treated as sparse with
// each key specifying the location of the value in the sparse vector.
repeated uint64 keys = 2 [packed = true];
// An optional shape that allows the vector to represent a matrix.
// For Exmple, if shape = [ 10, 20 ], floor(keys[i] / 10) gives the row,
// and keys[i] % 20 gives the column.
// This also supports n-dimensonal tensors.
// Note: If the tensor is sparse, you must specify this value.
repeated uint64 shape = 3 [packed = true];
}
// Support for storing binary data for parsing in other ways (such as JPEG/etc).
// This is an example of another type of value and may not immediately be supported.
message Bytes {
repeated bytes value = 1;
// If the content type of the data is known, stores it.
// This allows for the possibility of using decoders for common formats
// in the future.
optional string content_type = 2;
}
message Value {
oneof value {
// The numbering assumes the possible use of:
// - float16, float128
// - int8, int16, int32
Float32Tensor float32_tensor = 2;
Float64Tensor float64_tensor = 3;
Int32Tensor int32_tensor = 7;
Bytes bytes = 9;
}
}
message Record {
// Map from the name of the feature to the value.
//
// For vectors and libsvm-like datasets,
// a single feature with the name `values`
// should be specified.
map features = 1;
// An optional set of labels for this record.
// Similar to the features field above, the key used for
// generic scalar / vector labels should be 'values'.
map label = 2;
// A unique identifier for this record in the dataset.
//
// Whilst not necessary, this allows better
// debugging where there are data issues.
//
// This is not used by the algorithm directly.
optional string uid = 3;
// Textual metadata describing the record.
//
// This may include JSON-serialized information
// about the source of the record.
//
// This is not used by the algorithm directly.
optional string metadata = 4;
// An optional serialized JSON object that allows per-record
// hyper-parameters/configuration/other information to be set.
//
// The meaning/interpretation of this field is defined by
// the algorithm author and may not be supported.
//
// This is used to pass additional inference configuration
// when batch inference is used (e.g. types of scores to return).
optional string configuration = 5;
}
```
Setelah membuat buffer protokol, simpan di lokasi Amazon S3 yang dapat diakses SageMaker Amazon AI dan yang dapat diteruskan sebagai bagian darinya`InputDataConfig`. `create_training_job`
**catatan**
Untuk semua algoritma Amazon SageMaker AI, `ChannelName` in `InputDataConfig` harus diatur ke`train`. Beberapa algoritma juga mendukung validasi atau pengujian. `input channels` Ini biasanya digunakan untuk mengevaluasi kinerja model dengan menggunakan dataset penahanan. Kumpulan data penahanan tidak digunakan dalam pelatihan awal tetapi dapat digunakan untuk menyetel model lebih lanjut.
## Deserialisasi Model Terlatih
Model Amazon SageMaker AI disimpan sebagai model.tar.gz di bucket S3 yang ditentukan dalam `OutputDataConfig` `S3OutputPath` parameter `create_training_job` panggilan. Bucket S3 harus berada di AWS Region yang sama dengan instance notebook. Anda dapat menentukan sebagian besar artefak model ini saat membuat model hosting. Anda juga dapat membuka dan meninjaunya di instance notebook Anda. Ketika `model.tar.gz` untarred, itu berisi`model_algo-1`, yang merupakan objek Apache serial. MXNet Misalnya, Anda menggunakan yang berikut ini untuk memuat model k-means ke dalam memori dan melihatnya:
```
import mxnet as mx
print(mx.ndarray.load('model_algo-1'))
```
# Format data umum untuk inferensi
Algoritma Amazon SageMaker AI menerima dan menghasilkan beberapa jenis MIME yang berbeda untuk muatan HTTP yang digunakan dalam mengambil prediksi online dan mini-batch. Anda dapat menggunakan beberapa AWS layanan untuk mengubah atau memproses catatan sebelum menjalankan inferensi. Minimal, Anda perlu mengonversi data untuk yang berikut:
+ Serialisasi permintaan inferensi (ditangani oleh Anda)
+ Deserialisasi permintaan inferensi (ditangani oleh algoritma)
+ Serialisasi respons inferensi (ditangani oleh algoritme)
+ Deserialisasi respons inferensi (ditangani oleh Anda)
**Topics**
+ [Mengkonversi data untuk serialisasi permintaan inferensi](#ir-serialization)
+ [Konversi data untuk deserialisasi respons inferensi](#ir-deserialization)
+ [Format permintaan umum untuk semua algoritme](#common-in-formats)
+ [Gunakan transformasi batch dengan algoritme bawaan](#cm-batch)
## Mengkonversi data untuk serialisasi permintaan inferensi
Opsi jenis konten untuk permintaan inferensi algoritme Amazon SageMaker AI meliputi:`text/csv`,`application/json`, dan`application/x-recordio-protobuf`. Algoritma yang tidak mendukung semua jenis ini dapat mendukung jenis lain. XGBoost, misalnya, hanya mendukung `text/csv` dari daftar ini, tetapi juga mendukung`text/libsvm`.
Untuk`text/csv`, nilai argumen Body `invoke_endpoint` harus berupa string dengan koma yang memisahkan nilai untuk setiap fitur. Misalnya, rekaman untuk model dengan empat fitur mungkin terlihat seperti`1.5,16.0,14,23.0`. Setiap transformasi yang dilakukan pada data pelatihan juga harus dilakukan pada data sebelum mendapatkan inferensi. Urutan fitur penting dan harus tetap tidak berubah.
`application/json`lebih fleksibel dan menyediakan beberapa format yang mungkin bagi pengembang untuk digunakan dalam aplikasi mereka. Pada tingkat tinggi, di JavaScript, payload mungkin terlihat seperti berikut:
```
let request = {
// Instances might contain multiple rows that predictions are sought for.
"instances": [
{
// Request and algorithm specific inference parameters.
"configuration": {},
// Data in the specific format required by the algorithm.
"data": {
"": dataElement
}
}
]
}
```
Anda memiliki opsi berikut untuk menentukan: `dataElement`
**Protokol buffer setara**
```
// Has the same format as the protocol buffers implementation described for training.
let dataElement = {
"keys": [],
"values": [],
"shape": []
}
```
**vektor numerik sederhana**
```
// An array containing numeric values is treated as an instance containing a
// single dense vector.
let dataElement = [1.5, 16.0, 14.0, 23.0]
// It will be converted to the following representation by the SDK.
let converted = {
"features": {
"values": dataElement
}
}
```
**Untuk beberapa catatan**
```
let request = {
"instances": [
// First instance.
{
"features": [ 1.5, 16.0, 14.0, 23.0 ]
},
// Second instance.
{
"features": [ -2.0, 100.2, 15.2, 9.2 ]
}
]
}
```
## Konversi data untuk deserialisasi respons inferensi
Algoritma Amazon SageMaker AI mengembalikan JSON dalam beberapa tata letak. Pada tingkat tinggi, strukturnya adalah:
```
let response = {
"predictions": [{
// Fields in the response object are defined on a per algorithm-basis.
}]
}
```
Bidang yang disertakan dalam prediksi berbeda di seluruh algoritme. Berikut ini adalah contoh output untuk algoritma k-means.
**Inferensi rekor tunggal**
```
let response = {
"predictions": [{
"closest_cluster": 5,
"distance_to_cluster": 36.5
}]
}
```
**Inferensi multi-rekam**
```
let response = {
"predictions": [
// First instance prediction.
{
"closest_cluster": 5,
"distance_to_cluster": 36.5
},
// Second instance prediction.
{
"closest_cluster": 2,
"distance_to_cluster": 90.3
}
]
}
```
**Inferensi multi-rekam dengan input protobuf**
```
{
"features": [],
"label": {
"closest_cluster": {
"values": [ 5.0 ] // e.g. the closest centroid/cluster was 1.0
},
"distance_to_cluster": {
"values": [ 36.5 ]
}
},
"uid": "abc123",
"metadata": "{ "created_at": '2017-06-03' }"
}
```
SageMaker Algoritma AI juga mendukung format JSONLINES, di mana konten respons per rekaman sama dengan format JSON. Struktur multi-record adalah kumpulan objek respons per rekaman yang dipisahkan oleh karakter baris baru. Konten respons untuk KMeans algoritme bawaan untuk 2 titik data input adalah:
```
{"distance_to_cluster": 23.40593910217285, "closest_cluster": 0.0}
{"distance_to_cluster": 27.250282287597656, "closest_cluster": 0.0}
```
Saat menjalankan transformasi batch, kami merekomendasikan menggunakan tipe `jsonlines` respons dengan menyetel `Accept` bidang di `CreateTransformJobRequest` to`application/jsonlines`.
## Format permintaan umum untuk semua algoritme
Sebagian besar algoritma menggunakan banyak format permintaan inferensi berikut.
### Format permintaan JSON
**Jenis konten:** Aplikasi/JSON
**Format padat**
```
let request = {
"instances": [
{
"features": [1.5, 16.0, 14.0, 23.0]
}
]
}
let request = {
"instances": [
{
"data": {
"features": {
"values": [ 1.5, 16.0, 14.0, 23.0]
}
}
}
]
}
```
**Format jarang**
```
{
"instances": [
{"data": {"features": {
"keys": [26, 182, 232, 243, 431],
"shape": [2000],
"values": [1, 1, 1, 4, 1]
}
}
},
{"data": {"features": {
"keys": [0, 182, 232, 243, 431],
"shape": [2000],
"values": [13, 1, 1, 4, 1]
}
}
},
]
}
```
### Format permintaan JSONLINES
**Jenis konten:** Aplikasi/JSONLines
**Format padat**
Sebuah catatan tunggal dalam format padat dapat direpresentasikan sebagai:
```
{ "features": [1.5, 16.0, 14.0, 23.0] }
```
atau:
```
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
```
**Format Jarang**
Sebuah catatan tunggal dalam format jarang direpresentasikan sebagai:
```
{"data": {"features": { "keys": [26, 182, 232, 243, 431], "shape": [2000], "values": [1, 1, 1, 4, 1] } } }
```
Beberapa catatan direpresentasikan sebagai kumpulan representasi rekaman tunggal, dipisahkan oleh karakter baris baru:
```
{"data": {"features": { "keys": [0, 1, 3], "shape": [4], "values": [1, 4, 1] } } }
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
{ "features": [1.5, 16.0, 14.0, 23.0] }
```
### Format permintaan CSV
**Jenis konten:** teks/CSV; label\$1size = 0
**catatan**
Dukungan CSV tidak tersedia untuk mesin faktorisasi.
### Format permintaan RECORDIO
Jenis konten: aplikasi/ x-recordio-protobuf
## Gunakan transformasi batch dengan algoritme bawaan
Saat menjalankan transformasi batch, sebaiknya gunakan tipe respons JSONLINES alih-alih JSON, jika didukung oleh algoritme. Untuk melakukan ini, atur `Accept` bidang `CreateTransformJobRequest` ke`application/jsonlines`.
Ketika Anda membuat pekerjaan transformasi, `SplitType` harus diatur berdasarkan data input. `ContentType` Demikian pula, tergantung pada `Accept` bidang di`CreateTransformJobRequest`, `AssembleWith` harus diatur sesuai. Gunakan tabel berikut untuk mengatur bidang ini:
| ContentType | Direkomendasikan SplitType |
| --- | --- |
| application/x-recordio-protobuf | RecordIO |
| text/csv | Line |
| application/jsonlines | Line |
| application/json | None |
| application/x-image | None |
| image/\$1 | None |
| Menerima | Direkomendasikan AssembleWith |
| --- | --- |
| application/x-recordio-protobuf | None |
| application/json | None |
| application/jsonlines | Line |
Untuk informasi selengkapnya tentang format respons untuk algoritme tertentu, lihat berikut ini:
+ [Format Inferensi DeepAR](deepar-in-formats.md)
+ [Format Respon Mesin Faktorisasi](fm-in-formats.md)
+ [Format Data Inferensi Wawasan IP](ip-insights-inference-data-formats.md)
+ [Format Respons K-Means](km-in-formats.md)
+ [Format Permintaan dan Respons K-nn](kNN-inference-formats.md)
+ [Format respons pelajar linier](LL-in-formats.md)
+ [Format Respons NTM](ntm-in-formats.md)
+ [Format Data untuk Inferensi Object2Vec](object2vec-inference-formats.md)
+ [Embeddings Encoder untuk Object2Vec](object2vec-encoder-embeddings.md)
+ [Format Respons PCA](PCA-in-formats.md)
+ [Format Respons RCF](rcf-in-formats.md)
# Jenis Instance untuk Algoritma Bawaan
Sebagian besar algoritma Amazon SageMaker AI telah direkayasa untuk memanfaatkan komputasi GPU untuk pelatihan. Meskipun biaya per instans lebih tinggi, GPUs latih lebih cepat, membuatnya lebih hemat biaya. Pengecualian dicatat dalam panduan ini.
[Untuk mempelajari tentang instans EC2 yang didukung, lihat Detail instans.](https://aws.amazon.com/sagemaker-ai/pricing/#Instance_details)
Ukuran dan jenis data dapat memiliki efek besar pada konfigurasi perangkat keras mana yang paling efektif. Ketika model yang sama dilatih secara berulang, pengujian awal di seluruh spektrum jenis instance dapat menemukan konfigurasi yang lebih hemat biaya dalam jangka panjang. Selain itu, algoritme yang melatih paling efisien GPUs mungkin tidak memerlukan inferensi GPUs yang efisien. Eksperimen untuk menentukan solusi efektivitas biaya yang paling banyak. Untuk mendapatkan rekomendasi instans otomatis atau melakukan uji pemuatan khusus, gunakan [Amazon SageMaker Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html).
Untuk informasi selengkapnya tentang spesifikasi perangkat keras SageMaker AI, lihat [harga Amazon SageMaker AI](https://aws.amazon.com/sagemaker/ai/pricing/).
**UltraServers**
UltraServers sambungkan beberapa instans Amazon EC2 menggunakan interkoneksi akselerator bandwidth tinggi latensi rendah. Mereka dibangun untuk menangani AI/ML beban kerja skala besar yang membutuhkan daya pemrosesan yang signifikan. Untuk informasi selengkapnya, lihat [Amazon EC2 UltraServers](https://aws.amazon.com/ec2/ultraservers/). Untuk memulai UltraServers, lihat [Cadangan rencana pelatihan untuk pekerjaan atau HyperPod klaster pelatihan Anda](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html).
Untuk memulai UltraServers di Amazon SageMaker AI, [buat rencana pelatihan](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html). Setelah Anda UltraServer tersedia dalam rencana pelatihan, buat pekerjaan pelatihan dengan Konsol Manajemen AWS, Amazon SageMaker AI API, atau AWS CLI. Ingatlah untuk menentukan jenis UltraServer instans yang Anda beli dalam rencana pelatihan.
An UltraServer dapat menjalankan satu atau beberapa pekerjaan sekaligus. UltraServers mengelompokkan contoh bersama, yang memberi Anda fleksibilitas dalam hal cara mengalokasikan UltraServer kapasitas Anda di organisasi Anda. Saat Anda mengonfigurasi pekerjaan, ingat juga pedoman keamanan data organisasi Anda, karena instance dalam satu pekerjaan UltraServer dapat mengakses data untuk pekerjaan lain di instans lain pada saat yang sama UltraServer.
Jika Anda mengalami kegagalan perangkat keras di dalamnya UltraServer, SageMaker AI secara otomatis mencoba menyelesaikan masalah tersebut. Saat SageMaker AI menyelidiki dan menyelesaikan masalah, Anda mungkin menerima pemberitahuan dan tindakan melalui AWS Health Acara atau. AWS Dukungan
Setelah pekerjaan pelatihan Anda selesai, SageMaker AI menghentikan instans, tetapi mereka tetap tersedia dalam rencana pelatihan Anda jika rencananya masih aktif. Untuk menjaga instance tetap UltraServer berjalan setelah pekerjaan selesai, Anda dapat menggunakan [kolam hangat yang dikelola](https://docs.aws.amazon.com/sagemaker/latest/dg/train-warm-pools.html).
Jika rencana pelatihan Anda memiliki kapasitas yang cukup, Anda bahkan dapat menjalankan pekerjaan pelatihan di beberapa UltraServers. Secara default, masing-masing UltraServer dilengkapi dengan 18 instance, terdiri dari 17 instance dan 1 instance cadangan. Jika Anda membutuhkan lebih banyak contoh, Anda harus membeli lebih banyak UltraServers. Saat membuat pekerjaan pelatihan, Anda dapat mengonfigurasi bagaimana pekerjaan ditempatkan UltraServers menggunakan `InstancePlacementConfig` parameter.
Jika Anda tidak mengonfigurasi penempatan pekerjaan, SageMaker AI secara otomatis mengalokasikan pekerjaan ke instans di dalam Anda. UltraServer Strategi default ini didasarkan pada upaya terbaik yang memprioritaskan mengisi semua instance dalam satu UltraServer sebelum menggunakan yang berbeda. UltraServer Misalnya, jika Anda meminta 14 instans dan memiliki 2 UltraServers dalam rencana pelatihan Anda, SageMaker AI menggunakan semua instance di yang pertama. UltraServer Jika Anda meminta 20 instans dan memiliki 2 UltraServers dalam rencana pelatihan Anda, SageMaker AI akan menggunakan semua 17 instance di yang pertama UltraServer dan kemudian menggunakan 3 dari yang kedua. UltraServer Contoh dalam UltraServer penggunaan NVLink untuk berkomunikasi, tetapi individu UltraServers menggunakan Elastic Fabric Adapter (EFA), yang dapat memengaruhi kinerja pelatihan model.
# Log untuk Algoritma Bawaan
Algoritma Amazon SageMaker AI menghasilkan CloudWatch log Amazon, yang memberikan informasi terperinci tentang proses pelatihan. Untuk melihat log, di konsol AWS manajemen, pilih **CloudWatch**, pilih **Log**, lalu pilih **grup/aws/sagemaker/TrainingJobslog**. Setiap pekerjaan pelatihan memiliki satu aliran log per node tempat ia dilatih. Nama log stream dimulai dengan nilai yang ditentukan dalam `TrainingJobName` parameter saat pekerjaan dibuat.
**catatan**
Jika pekerjaan gagal dan log tidak muncul CloudWatch, kemungkinan kesalahan terjadi sebelum dimulainya pelatihan. Alasannya termasuk menentukan gambar pelatihan yang salah atau lokasi S3.
Isi log bervariasi menurut algoritma. Namun, Anda biasanya dapat menemukan informasi berikut:
+ Konfirmasi argumen yang diberikan di awal log
+ Kesalahan yang terjadi selama pelatihan
+ Pengukuran akurasi algoritma atau kinerja numerik
+ Pengaturan waktu untuk algoritme dan tahapan utama apa pun dalam algoritma
## Kesalahan Umum
Jika pekerjaan pelatihan gagal, beberapa detail tentang kegagalan diberikan oleh nilai `FailureReason` pengembalian dalam uraian pekerjaan pelatihan, sebagai berikut:
```
sage = boto3.client('sagemaker')
sage.describe_training_job(TrainingJobName=job_name)['FailureReason']
```
Lainnya dilaporkan hanya di CloudWatch log. Kesalahan umum termasuk yang berikut:
1. Salah menentukan hyperparameter atau menentukan hyperparameter yang tidak valid untuk algoritma.
**Dari CloudWatch Log**
```
[10/16/2017 23:45:17 ERROR 139623806805824 train.py:48]
Additional properties are not allowed (u'mini_batch_siz' was
unexpected)
```
1. Menentukan nilai yang tidak valid untuk hyperparameter.
**FailureReason**
```
AlgorithmError: u'abc' is not valid under any of the given
schemas\n\nFailed validating u'oneOf' in
schema[u'properties'][u'feature_dim']:\n {u'oneOf':
[{u'pattern': u'^([1-9][0-9]*)$', u'type': u'string'},\n
{u'minimum': 1, u'type': u'integer'}]}\
```
**FailureReason**
```
[10/16/2017 23:57:17 ERROR 140373086025536 train.py:48] u'abc'
is not valid under any of the given schemas
```
1. Format file protobuf tidak akurat.
**Dari CloudWatch log**
```
[10/17/2017 18:01:04 ERROR 140234860816192 train.py:48] cannot
copy sequence with size 785 to array axis with dimension 784
```