Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Optimalisasi inferensi untuk model Amazon SageMaker AI
Dengan Amazon SageMaker AI, Anda dapat meningkatkan kinerja model AI generatif Anda dengan menerapkan teknik pengoptimalan inferensi. Dengan mengoptimalkan model Anda, Anda dapat mencapai kinerja biaya yang lebih baik untuk kasus penggunaan Anda. Saat mengoptimalkan model, Anda memilih teknik pengoptimalan yang didukung untuk diterapkan, termasuk kuantisasi, decoding spekulatif, dan kompilasi. Setelah model dioptimalkan, Anda dapat menjalankan evaluasi untuk melihat metrik kinerja untuk latensi, throughput, dan harga.
Untuk banyak model, SageMaker AI juga menyediakan beberapa versi yang telah dioptimalkan sebelumnya, di mana masing-masing memenuhi kebutuhan aplikasi yang berbeda untuk latensi dan throughput. Untuk model seperti itu, Anda dapat menggunakan salah satu versi yang dioptimalkan tanpa terlebih dahulu mengoptimalkan model sendiri.
## Teknik pengoptimalan
Amazon SageMaker AI mendukung teknik pengoptimalan berikut.
### Kompilasi
*Kompilasi* mengoptimalkan model untuk kinerja terbaik yang tersedia pada jenis perangkat keras yang dipilih tanpa kehilangan akurasi. Anda dapat menerapkan kompilasi model LLMs untuk mengoptimalkan perangkat keras yang dipercepat, seperti instans GPU, instans AWS Trainium, atau instans Inferentia. AWS
Saat Anda mengoptimalkan model dengan kompilasi, Anda mendapat manfaat dari ahead-of-time kompilasi. Anda mengurangi waktu penerapan model dan latensi auto-scaling karena bobot model tidak just-in-time memerlukan kompilasi saat model diterapkan ke instance baru.
Jika Anda memilih untuk mengkompilasi model Anda untuk instance GPU, SageMaker AI menggunakan pustaka Tensorrt-LLM untuk menjalankan kompilasi. Jika Anda memilih untuk mengkompilasi model Anda untuk instance AWS Trainium atau AWS Inferentia, SageMaker AI menggunakan AWS Neuron SDK untuk menjalankan kompilasi.
### Kuantisasi
*Kuantisasi* adalah teknik untuk mengurangi persyaratan perangkat keras model dengan menggunakan tipe data yang kurang tepat untuk bobot dan aktivasi. Setelah Anda mengoptimalkan model dengan kuantisasi, Anda dapat menghostingnya dengan harga yang lebih murah dan lebih tersedia. GPUs Namun, model terkuantisasi mungkin kurang akurat dibandingkan model sumber yang Anda optimalkan.
Format data yang didukung SageMaker AI untuk kuantisasi bervariasi dari model ke model. Format yang didukung meliputi:
+ INT4-AWQ — Format data 4-bit. Activation-aware Weight Quantization (AWQ) adalah teknik kuantisasi yang efisien, akurat, bit LLMs rendah, dan hanya berat.
+ FP8 — 8-bit Floating Point (FP8) adalah format presisi rendah untuk angka floating point. Ini menyeimbangkan efisiensi memori dan akurasi model dengan mewakili nilai dengan bit lebih sedikit dari format FP16 floating point standar.
+ INT8- SmoothQuant — Sebuah format data 8-bit. SmoothQuant adalah metode kuantisasi presisi campuran yang menskalakan aktivasi dan bobot secara bersama-sama dengan menyeimbangkan rentang dinamisnya.
### Penguraian spekulatif
*Decoding spekulatif* adalah teknik untuk mempercepat proses decoding besar. LLMs Ini mengoptimalkan model untuk latensi tanpa mengorbankan kualitas teks yang dihasilkan.
Teknik ini menggunakan model yang lebih kecil namun lebih cepat yang disebut model *draft*. Model draf menghasilkan token kandidat, yang kemudian divalidasi oleh model *target* yang lebih besar tetapi lebih lambat. Pada setiap iterasi, model draf menghasilkan beberapa token kandidat. Model target memverifikasi token, dan jika menemukan bahwa token tertentu tidak dapat diterima, ia menolak token dan meregenerasinya. Jadi, model target memverifikasi token dan menghasilkan sejumlah kecil token.
Model draf secara signifikan lebih cepat daripada model target. Ini menghasilkan semua token dengan cepat dan kemudian mengirimkan batch mereka ke model target untuk verifikasi. Model target mengevaluasi semuanya secara paralel, yang mempercepat respons akhir.
SageMaker AI menawarkan model draft pre-built yang dapat Anda gunakan, jadi Anda tidak perlu membuatnya sendiri. Jika Anda lebih suka menggunakan model draf khusus Anda sendiri, SageMaker AI juga mendukung opsi ini.
### Pemuatan model cepat
Teknik *pemuatan model cepat* menyiapkan LLM sehingga SageMaker AI dapat memuatnya ke instance HTML lebih cepat.
Untuk mempersiapkan model, SageMaker AI memecahnya terlebih dahulu dengan membaginya menjadi beberapa bagian yang masing-masing dapat berada pada GPU terpisah untuk inferensi terdistribusi. Selain itu, SageMaker AI menyimpan bobot model dalam potongan berukuran sama yang dapat dimuat SageMaker AI ke instance secara bersamaan.
Saat SageMaker AI memuat model yang dioptimalkan ke instance, AI mengalirkan bobot model langsung dari Amazon S3 ke GPUs instance. Dengan mengalirkan bobot, SageMaker AI menghilangkan beberapa langkah yang memakan waktu yang biasanya diperlukan. Langkah-langkah ini termasuk mengunduh artefak model dari Amazon S3 ke disk, memuat artefak model ke memori host, dan membagi model pada host sebelum akhirnya memuat pecahan ke file. GPUs
Setelah mengoptimalkan model untuk pemuatan yang lebih cepat, Anda dapat menerapkannya lebih cepat ke titik akhir SageMaker AI. Selain itu, jika Anda mengonfigurasi titik akhir untuk menggunakan penskalaan otomatis, penskalaan akan lebih cepat untuk mengakomodasi peningkatan lalu lintas.
# Terapkan model yang telah dioptimalkan sebelumnya
Beberapa model telah JumpStart dioptimalkan sebelumnya oleh SageMaker AI, yang berarti Anda dapat menerapkan versi yang dioptimalkan dari model ini tanpa terlebih dahulu membuat pekerjaan pengoptimalan inferensi.
Untuk daftar model dengan opsi yang telah dioptimalkan sebelumnya, lihat[Model pra-dioptimalkan JumpStart](#pre-optimized-js).
## SageMaker Studio Amazon
Gunakan prosedur berikut untuk menerapkan JumpStart model yang telah dioptimalkan sebelumnya menggunakan Amazon SageMaker Studio.
**Untuk menerapkan model yang telah dioptimalkan sebelumnya**
1. Di Studio, di menu navigasi di sebelah kiri, pilih **JumpStart**.
1. Pada halaman **Semua model publik**, pilih salah satu model yang telah dioptimalkan sebelumnya.
1. Pada halaman detail model, pilih **Deploy**.
1. Pada halaman penerapan, beberapa JumpStart model mengharuskan Anda untuk menandatangani perjanjian lisensi pengguna akhir (EULA) sebelum Anda dapat melanjutkan. Jika diminta, tinjau persyaratan lisensi di bagian **Perjanjian Lisensi**. Jika persyaratan dapat diterima untuk kasus penggunaan Anda, pilih kotak centang untuk **Saya menerima EULA, dan baca syarat dan ketentuan**.
Untuk informasi selengkapnya, lihat [Perjanjian lisensi pengguna akhir](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula).
1. Untuk **nama Endpoint** dan **jumlah instans awal**, terima nilai default atau setel yang kustom.
1. Untuk **tipe Instance**, pertahankan nilai default. Jika tidak, Anda tidak dapat menerapkan konfigurasi yang telah dioptimalkan sebelumnya.
1. Di bawah **Model**, perluas konfigurasi model. Studio menampilkan tabel yang menyediakan konfigurasi yang telah dioptimalkan sebelumnya yang dapat Anda pilih. Setiap opsi memiliki metrik untuk latensi dan throughput. Pilih opsi yang paling sesuai dengan kebutuhan aplikasi Anda.
1. Pilih **Deploy**.
## SageMaker SDK Python AI
Anda dapat menerapkan model yang telah dioptimalkan sebelumnya dengan menggunakan AI SageMaker Python SDK dalam proyek Anda. Pertama, Anda mendefinisikan sebuah `Model` instance dengan menggunakan `ModelBuilder` kelas. Kemudian, Anda menggunakan `set_deployment_config()` metode untuk mengatur konfigurasi yang telah dioptimalkan sebelumnya yang ingin Anda terapkan. Kemudian, Anda menggunakan `build()` metode untuk membangun model. Akhirnya, Anda menggunakan `deploy()` metode untuk menerapkannya ke titik akhir inferensi.
Untuk informasi selengkapnya tentang kelas dan metode yang digunakan dalam contoh berikut, lihat [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)di dokumentasi SageMaker AI Python SDK.
**Untuk menyiapkan proyek Anda**
1. Dalam kode aplikasi Anda, impor pustaka yang diperlukan. Contoh berikut mengimpor SDK untuk Python (Boto3). Ini juga mengimpor modul dari SageMaker AI Python SDK yang Anda gunakan untuk mendefinisikan dan bekerja dengan model:
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
```
1. Inisialisasi sesi SageMaker AI. Contoh berikut menggunakan `Session()` kelas:
```
sagemaker_session = Session()
```
**Untuk menentukan model Anda**
1. Buat `SchemaBuilder` instance, dan berikan sampel input dan output. Anda menyediakan instance ini ke `ModelBuilder` kelas ketika Anda mendefinisikan model. Dengan itu, SageMaker AI secara otomatis menghasilkan fungsi marshalling untuk membuat serial dan deserialisasi input dan output.
Untuk informasi selengkapnya tentang penggunaan `SchemaBuilder` dan `ModelBuilder` kelas, lihat[Buat model di Amazon SageMaker AI dengan ModelBuilder](how-it-works-modelbuilder-creation.md).
Contoh berikut memberikan sampel input dan output string ke `SchemaBuilder` kelas:
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Tentukan model Anda ke SageMaker AI. Contoh berikut menetapkan parameter untuk menginisialisasi `ModelBuilder` instance:
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Contoh ini menggunakan JumpStart model. Ganti `jumpstart-model-id` dengan ID JumpStart model, seperti`meta-textgeneration-llama-3-70b`.
**Untuk mengambil metrik benchmark**
1. Untuk menentukan konfigurasi pra-optimasi mana yang ingin Anda terapkan, cari opsi yang disediakan SageMaker AI. Contoh berikut menampilkannya:
```
model_builder.display_benchmark_metrics()
```
`display_benchmark_metrics()`Metode ini mencetak tabel seperti berikut:
```
| Instance Type | Config Name | Concurrent Users | Latency, TTFT (P50 in sec) | Throughput (P50 in tokens/sec/user) |
|:----------------|:--------------|-------------------:|-----------------------------:|--------------------------------------:|
| ml.g5.48xlarge | lmi-optimized | 1 | 2.25 | 49.70 |
| ml.g5.48xlarge | lmi-optimized | 2 | 2.28 | 21.10 |
| ml.g5.48xlarge | lmi-optimized | 4 | 2.37 | 14.10 |
. . .
| ml.p4d.24xlarge | lmi-optimized | 1 | 0.10 | 137.40 |
| ml.p4d.24xlarge | lmi-optimized | 2 | 0.11 | 109.20 |
| ml.p4d.24xlarge | lmi-optimized | 4 | 0.13 | 85.00 |
. . .
```
Di kolom pertama, tabel mencantumkan jenis instance potensial yang dapat Anda gunakan untuk meng-host JumpStart model yang Anda pilih. Untuk setiap jenis instance, di bawah`Config Name`, ini mencantumkan nama konfigurasi yang telah dioptimalkan sebelumnya. Konfigurasi yang disediakan SageMaker AI diberi nama`lmi-optimized`. Untuk setiap jenis dan konfigurasi instans, tabel menyediakan metrik benchmark. Metrik ini menunjukkan throughput dan latensi yang akan didukung model Anda untuk jumlah pengguna bersamaan yang berbeda.
1. Berdasarkan metrik benchmark, pilih jenis instans dan nama konfigurasi yang paling mendukung kebutuhan kinerja Anda. Anda akan menggunakan nilai-nilai ini ketika Anda membuat konfigurasi penerapan.
**Untuk menerapkan model yang telah dioptimalkan sebelumnya**
1. Buat konfigurasi penerapan. Contoh berikut menggunakan `ModelBuilder` contoh. Ini meneruskan tipe instance dan nama konfigurasi ke `set_deployment_config()` metode:
```
model_builder.set_deployment_config(
config_name="config-name",
instance_type="instance-type",
)
```
Ganti *`config-name`* dengan nama konfigurasi dari tabel, seperti seperti`lmi-optimized`. Ganti `instance-type` dengan tipe instance dari tabel, seperti`ml.p4d.24xlarge`.
1. Bangun model Anda. Contoh berikut menggunakan `.build()` metode `ModelBuilder` instance:
```
optimized_model = model_builder.build()
```
`.build()`Metode mengembalikan instance deployable`Model`.
1. Terapkan model Anda ke titik akhir inferensi. Contoh berikut menggunakan `.deploy()` metode `Model` instance:
```
predictor = optimized_model.deploy(accept_eula=True)
```
`deploy()`Metode mengembalikan `Predictor` instance, yang dapat Anda gunakan untuk mengirim permintaan inferensi ke model.
**Untuk menguji model Anda dengan permintaan inferensi**
+ Setelah Anda menerapkan model Anda ke titik akhir inferensi, uji prediksi model. Contoh berikut mengirimkan permintaan inferensi dengan menggunakan `Predictor` instance:
```
predictor.predict(sample_input)
```
Model mengembalikan teks yang dihasilkannya dengan respons seperti berikut:
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## Model pra-dioptimalkan JumpStart
Berikut ini adalah JumpStart model yang memiliki konfigurasi yang telah dioptimalkan sebelumnya.
**Meta**
+ Instruksi Llama 3.1 70B
+ Llama 3.1 70B
+ Instruksi Llama 3.1 405B FP8
+ Llama 3.1 405B FP8
+ Instruksi Llama 3 8B
+ Llama 3 8B
+ Instruksi Llama 3 70B
+ Llama 3 70B
+ Llama 2 70B Obrolan
+ Llama 2 7B Obrolan
+ Llama 2 13B Obrolan
**HuggingFace**
+ Instruksi Mixtral 8x7B
+ Mixtral 8x7B
+ Instruksi Mistral 7B
+ Mistral 7B
### Model pra-kompilasi JumpStart
Untuk beberapa model dan konfigurasi, SageMaker AI menyediakan model yang telah dikompilasi sebelumnya untuk instans AWS Inferentia dan AWS Trainium tertentu. Untuk ini, jika Anda membuat pekerjaan pengoptimalan kompilasi, dan Anda memilih ml.inf2.48xlarge atau ml.trn1.32xlarge sebagai jenis instance penerapan, AI mengambil artefak yang dikompilasi. SageMaker Karena pekerjaan menggunakan model yang sudah dikompilasi, pekerjaan selesai dengan cepat tanpa menjalankan kompilasi dari awal.
Berikut ini adalah JumpStart model yang SageMaker AI memiliki model pra-kompilasi:
**Meta**
+ Llama3 8B
+ Llama3 70B
+ Llama2 7B
+ Llama2 70B
+ Llama2 13B
+ Kode Llama 7B
+ Kode Llama 70B
**HuggingFace**
+ Mistral 7B
# Buat pekerjaan pengoptimalan inferensi
Anda dapat membuat pekerjaan pengoptimalan inferensi dengan menggunakan Studio atau SageMaker AI Python SDK. Pekerjaan mengoptimalkan model Anda dengan menerapkan teknik yang Anda pilih. Untuk informasi selengkapnya, lihat [Teknik pengoptimalan](model-optimize.md#optimization-techniques).
**Penetapan harga instans untuk pekerjaan pengoptimalan inferensi**
Saat Anda membuat pekerjaan pengoptimalan inferensi yang menerapkan kuantisasi atau kompilasi, SageMaker AI memilih jenis instans mana yang akan digunakan untuk menjalankan pekerjaan. Anda dikenakan biaya berdasarkan instance yang digunakan.
Untuk jenis instans yang mungkin dan detail harganya, lihat informasi harga pengoptimalan inferensi di halaman [ SageMaker harga Amazon](https://aws.amazon.com/sagemaker/pricing/).
Anda tidak dikenakan biaya tambahan untuk pekerjaan yang menerapkan decoding spekulatif.
Untuk model yang didukung yang dapat Anda optimalkan, lihat[Referensi model yang didukung](optimization-supported-models.md).
## SageMaker Studio Amazon
Selesaikan langkah-langkah berikut untuk membuat pekerjaan pengoptimalan inferensi di Studio.
**Untuk mulai membuat pekerjaan optimasi**
1. Di SageMaker AI Studio, buat pekerjaan pengoptimalan melalui salah satu jalur berikut:
+ Untuk membuat pekerjaan untuk JumpStart model, lakukan hal berikut:
1. Di menu navigasi, pilih **JumpStart**.
1. Pada halaman **Semua model publik**, pilih penyedia model, lalu pilih salah satu model yang mendukung pengoptimalan.
1. Pada halaman detail model, pilih **Optimalkan**. Tombol ini diaktifkan hanya untuk model yang mendukung optimasi.
1. Pada halaman **pekerjaan Buat pengoptimalan inferensi**, beberapa JumpStart model mengharuskan Anda menandatangani perjanjian lisensi pengguna akhir (EULA) sebelum Anda dapat melanjutkan. Jika diminta, tinjau persyaratan lisensi di bagian **Perjanjian Lisensi**. Jika persyaratan dapat diterima untuk kasus penggunaan Anda, pilih kotak centang untuk **Saya menerima EULA, dan baca syarat dan ketentuan**.
+ Untuk membuat pekerjaan untuk JumpStart model yang disetel dengan baik, lakukan hal berikut:
1. Di menu navigasi, di bawah **Pekerjaan**, pilih **Pelatihan**.
1. Pada halaman **Training Jobs**, pilih nama pekerjaan yang Anda gunakan untuk menyempurnakan JumpStart model. Pekerjaan ini memiliki jenis **JumpStartpelatihan** di kolom **Jenis Job**.
1. Pada halaman detail untuk pekerjaan pelatihan, pilih **Optimalkan**.
+ Untuk membuat pekerjaan untuk model kustom, lakukan hal berikut:
1. Di menu navigasi, di bawah **Jobs**, pilih **Optimasi inferensi**.
1. Pilih **Buat pekerjaan baru**.
1. Pada halaman **pekerjaan Buat optimasi inferensi**, pilih **Tambah model**.
1. Di jendela **Tambah model**, pilih **Model Kustom**.
1. Pilih salah satu opsi berikut:
**Gunakan model yang ada** - Pilih opsi ini untuk mengoptimalkan model yang telah Anda buat di SageMaker AI.
**Nama model yang ada** - masukkan nama model SageMaker AI Anda.
**Dari S3** - Pilih opsi ini untuk menyediakan artefak model dari Amazon S3. Untuk **URI S3**, masukkan URI untuk lokasi di Amazon S3 tempat Anda menyimpan artefak model.
1. (Opsional) Untuk ****nama model Output****, Anda dapat memasukkan nama khusus untuk model yang dioptimalkan yang dibuat oleh pekerjaan. Jika Anda tidak memberikan nama, Studio secara otomatis membuatnya berdasarkan pilihan Anda.
1. Pada halaman **pekerjaan Buat optimasi inferensi**, untuk **nama Job**, Anda dapat menerima nama default yang diberikan SageMaker AI. Atau, untuk memasukkan nama pekerjaan khusus, pilih bidang **Nama pekerjaan**, dan pilih **Masukkan nama pekerjaan**.
**Untuk mengatur konfigurasi optimasi**
1. Untuk **jenis instance Deployment**, pilih jenis instance yang ingin Anda optimalkan modelnya.
Jenis instans memengaruhi teknik pengoptimalan apa yang dapat Anda pilih. **Untuk sebagian besar jenis yang menggunakan perangkat keras GPU, teknik yang didukung adalah **Quantization** dan Speculative decoding.** Jika Anda memilih instance yang menggunakan silikon khusus, seperti instance AWS Inferentia ml.inf2.8xlarge, teknik yang didukung adalah **Kompilasi, yang dapat Anda gunakan untuk mengkompilasi** model untuk jenis perangkat keras tertentu.
1. Pilih satu atau beberapa teknik pengoptimalan yang disediakan Studio:
+ Jika Anda memilih **Kuantisasi**, pilih tipe data untuk tipe **data presisi**.
+ Jika Anda memilih **decoding spekulatif**, pilih salah satu opsi berikut:
+ **Gunakan model draf SageMaker AI** — Pilih untuk menggunakan model draf yang disediakan SageMaker AI.
**catatan**
Jika Anda memilih untuk menggunakan model draf SageMaker AI, Anda juga harus mengaktifkan isolasi jaringan. Studio menyediakan opsi ini di bawah **Keamanan**.
+ **Pilih model JumpStart draf** — Pilih untuk memilih model dari JumpStart katalog yang akan digunakan sebagai model draf Anda.
+ **Pilih model draf Anda sendiri** — Pilih untuk menggunakan model draf Anda sendiri, dan berikan URI S3 yang menempatkannya.
+ Jika Anda memilih **Pemuatan model cepat**, Studio menunjukkan variabel `OPTION_TENSOR_PARALLEL_DEGREE` lingkungan. Gunakan bidang **Nilai** untuk mengatur derajat paralelisme tensor. Nilai harus membagi secara merata jumlah GPUs dalam instance yang Anda pilih untuk **jenis instance Deployment**. Misalnya, untuk membelah model Anda saat menggunakan instance dengan 8 GPUs, gunakan nilai 2, 4, atau 8.
+ Jika Anda menyetel **jenis instance Deployment** ke instance AWS Inferentia atau AWS Trainium, Studio mungkin menunjukkan bahwa **Kompilasi** adalah salah satu opsi yang didukung. Dalam hal ini, Studio memilih opsi ini untuk Anda.
1. Untuk **Output**, masukkan URI lokasi di Amazon S3. Di sana, SageMaker AI menyimpan artefak dari model yang dioptimalkan yang dibuat oleh pekerjaan Anda.
1. (Opsional) Perluas **opsi lanjutan** untuk kontrol yang lebih halus atas pengaturan seperti peran IAM, VPC, dan variabel lingkungan. Untuk informasi selengkapnya, lihat *Opsi lanjutan* di bawah ini.
1. Setelah selesai mengonfigurasi pekerjaan, pilih **Buat pekerjaan**.
Studio menampilkan halaman detail pekerjaan, yang menunjukkan status pekerjaan dan semua pengaturannya.
### Opsi lanjutan
Anda dapat mengatur opsi lanjutan berikut saat membuat pekerjaan pengoptimalan inferensi.
Di bawah **Konfigurasi**, Anda dapat mengatur opsi berikut:
**Derajat paralel tensor **
Nilai untuk tingkat *paralelisme tensor*. Paralelisme tensor adalah jenis paralelisme model di mana bobot model tertentu, gradien, dan status pengoptimal dibagi di seluruh perangkat. Nilai harus merata membagi jumlah GPUs di cluster Anda.
**Panjang token maksimum**
Batas jumlah token yang akan dihasilkan oleh model. Perhatikan bahwa model mungkin tidak selalu menghasilkan jumlah token maksimum.
**Bersamaan**
Kemampuan untuk menjalankan beberapa contoh model pada perangkat keras dasar yang sama. Gunakan konkurensi untuk menyajikan prediksi kepada banyak pengguna dan untuk memaksimalkan pemanfaatan perangkat keras.
**Ukuran batch**
Jika model Anda melakukan *inferensi batch*, gunakan opsi ini untuk mengontrol ukuran batch yang diproses model Anda.
Inferensing Batch menghasilkan prediksi model pada batch pengamatan. Ini adalah pilihan yang baik untuk kumpulan data besar atau jika Anda tidak memerlukan respons langsung terhadap permintaan inferensi.
Di bawah **Keamanan**, Anda dapat mengatur opsi berikut:
**IAM Role**
Peran IAM yang memungkinkan SageMaker AI melakukan tugas atas nama Anda. Selama pengoptimalan model, SageMaker AI memerlukan izin Anda untuk:
+ Baca data masukan dari bucket S3
+ Tulis artefak model ke ember S3
+ Menulis log ke Amazon CloudWatch Logs
+ Publikasikan metrik ke Amazon CloudWatch
Anda memberikan izin untuk semua tugas ini ke peran IAM.
Untuk informasi selengkapnya, lihat [Cara menggunakan peran eksekusi SageMaker AI](sagemaker-roles.md).
**Kunci KMS enkripsi**
Sebuah kunci dalam AWS Key Management Service (AWS KMS). SageMaker AI menggunakan kunci mereka untuk mengenkripsi artefak model yang dioptimalkan saat SageMaker AI mengunggah model ke Amazon S3.
**VPC**
SageMaker AI menggunakan informasi ini untuk membuat antarmuka jaringan dan melampirkannya ke wadah model Anda. Antarmuka jaringan menyediakan wadah model Anda dengan koneksi jaringan dalam VPC Anda yang tidak terhubung ke internet. Mereka juga memungkinkan model Anda terhubung ke sumber daya di VPC pribadi Anda.
Untuk informasi selengkapnya, lihat [Berikan Akses Titik Akhir yang Dihosting SageMaker AI ke Sumber Daya di VPC Amazon Anda](host-vpc.md).
**Aktifkan isolasi jaringan**
Aktifkan opsi ini jika Anda ingin membatasi akses internet kontainer Anda. Kontainer yang berjalan dengan isolasi jaringan tidak dapat melakukan panggilan jaringan keluar.
Anda harus mengaktifkan opsi ini ketika Anda mengoptimalkan dengan decoding spekulatif dan Anda menggunakan model draf AI. SageMaker
Untuk informasi selengkapnya tentang isolasi jaringan, lihat[Isolasi Jaringan](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
Di bawah **Definisi kontainer lanjutan**, Anda dapat mengatur opsi berikut:
**Kondisi berhenti**
Menentukan batas untuk berapa lama pekerjaan dapat berjalan. Ketika pekerjaan mencapai batas waktu, SageMaker AI mengakhiri pekerjaan. Gunakan opsi ini untuk membatasi biaya.
**Tag**
Pasangan nilai kunci yang terkait dengan pekerjaan pengoptimalan.
Untuk informasi selengkapnya tentang tag, lihat [Menandai AWS sumber daya Anda](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html) di. *Referensi Umum AWS*
**Variabel-variabel lingkungan**
Pasangan kunci-nilai yang menentukan variabel lingkungan untuk diatur dalam wadah model.
## SageMaker SDK Python AI
Anda dapat membuat pekerjaan pengoptimalan inferensi dengan menggunakan SageMaker AI Python SDK dalam proyek Anda. Pertama, Anda mendefinisikan sebuah `Model` instance dengan menggunakan `ModelBuilder` kelas. Kemudian, Anda menggunakan `optimize()` metode ini untuk menjalankan pekerjaan yang mengoptimalkan model Anda dengan kuantisasi, decoding spekulatif, atau kompilasi. Ketika pekerjaan selesai, Anda menerapkan model ke titik akhir inferensi dengan menggunakan metode. `deploy()`
Untuk informasi selengkapnya tentang kelas dan metode yang digunakan dalam contoh berikut, lihat [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)di dokumentasi SageMaker AI Python SDK.
**Untuk menyiapkan proyek Anda**
1. Dalam kode aplikasi Anda, impor pustaka yang diperlukan. Contoh berikut mengimpor SDK untuk Python (Boto3). Ini juga mengimpor kelas dari SageMaker AI Python SDK yang Anda gunakan untuk mendefinisikan dan bekerja dengan model:
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
from pathlib import Path
```
1. Inisialisasi sesi SageMaker AI. Contoh berikut menggunakan `Session()` kelas:
```
sagemaker_session = Session()
```
**Untuk menentukan model Anda**
1. Buat `SchemaBuilder` instance, dan berikan sampel input dan output. Anda menyediakan instance ini ke `ModelBuilder` kelas ketika Anda mendefinisikan model. Dengan itu, SageMaker AI secara otomatis menghasilkan fungsi marshalling untuk membuat serial dan deserialisasi input dan output.
Untuk informasi selengkapnya tentang penggunaan `SchemaBuilder` dan `ModelBuilder` kelas, lihat[Buat model di Amazon SageMaker AI dengan ModelBuilder](how-it-works-modelbuilder-creation.md).
Contoh berikut memberikan sampel input dan output string ke `SchemaBuilder` kelas:
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Tentukan model Anda ke SageMaker AI. Contoh berikut menetapkan parameter untuk menginisialisasi `ModelBuilder` instance:
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Contoh ini menggunakan JumpStart model. Ganti `jumpstart-model-id` dengan ID JumpStart model, seperti`meta-textgeneration-llama-3-70b`.
**catatan**
Jika Anda ingin mengoptimalkan dengan decoding spekulatif, dan Anda ingin menggunakan draf SageMaker AI, Anda harus mengaktifkan isolasi jaringan. Untuk mengaktifkannya, sertakan argumen berikut saat Anda menginisialisasi `ModelBuilder` instance:
```
enable_network_isolation=True,
```
Untuk informasi selengkapnya tentang isolasi jaringan, lihat[Isolasi Jaringan](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
**Untuk mengoptimalkan dengan kuantisasi**
1. Untuk menjalankan pekerjaan kuantisasi, gunakan `optimize()` metode, dan atur argumen. `quantization_config` Contoh berikut ditetapkan `OPTION_QUANTIZE` sebagai variabel lingkungan dalam wadah optimasi:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
quantization_config={
"OverrideEnvironment": {
"OPTION_QUANTIZE": "awq",
},
},
output_path="s3://output-path",
)
```
Dalam contoh ini, ganti *`instance-type`* dengan instance ML, seperti`ml.p4d.24xlarge`. Ganti *`s3://output-path`* dengan jalur ke lokasi S3 tempat Anda menyimpan model yang dioptimalkan yang dibuat oleh pekerjaan.
`optimize()`Metode mengembalikan `Model` objek, yang dapat Anda gunakan untuk menyebarkan model Anda ke titik akhir.
1. Saat pekerjaan selesai, gunakan model. Contoh berikut menggunakan `deploy()` metode ini:
```
predictor = optimized_model.deploy(
instance_type="instance-type",
accept_eula=True,
)
```
Dalam contoh ini, ganti *`instance-type`* dengan instance ML, seperti`ml.p4d.24xlarge`.
`deploy()`Metode mengembalikan objek prediktor, yang dapat Anda gunakan untuk mengirim permintaan inferensi ke titik akhir yang menghosting model.
**Untuk mengoptimalkan dengan decoding spekulatif menggunakan model draft AI SageMaker**
Saat Anda mengoptimalkan model Anda dengan decoding spekulatif, Anda dapat memilih untuk menggunakan model draf yang disediakan SageMaker AI, atau Anda dapat menggunakannya sendiri. Contoh berikut menggunakan model draf SageMaker AI.
**Prasyarat**
Untuk mengoptimalkan dengan decoding spekulatif dan model draf SageMaker AI, Anda harus mengaktifkan isolasi jaringan saat menentukan model Anda.
1. Untuk menjalankan pekerjaan decoding spekulatif, gunakan `optimize()` metode, dan atur argumennya. `speculative_decoding_config` Contoh berikut menetapkan `ModelProvider` kunci `SAGEMAKER` untuk menggunakan model draf yang disediakan SageMaker AI.
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelProvider": "SAGEMAKER",
},
)
```
Dalam contoh ini, ganti *`instance-type`* dengan instance ML, seperti`ml.p4d.24xlarge`.
`optimize()`Metode mengembalikan `Model` objek, yang dapat Anda gunakan untuk menyebarkan model Anda ke titik akhir.
1. Saat pekerjaan selesai, gunakan model. Contoh berikut menggunakan `deploy()` metode ini:
```
predictor = optimized_model.deploy(accept_eula=True)
```
`deploy()`Metode mengembalikan objek prediktor, yang dapat Anda gunakan untuk mengirim permintaan inferensi ke titik akhir yang menghosting model.
**Untuk mengoptimalkan dengan decoding spekulatif menggunakan model draf khusus**
Sebelum Anda dapat memberikan model draf khusus Anda ke SageMaker AI, Anda harus terlebih dahulu mengunggah artefak model ke Amazon S3.
Contoh berikut menunjukkan satu cara yang mungkin untuk menyediakan model draf khusus. Contoh mengunduh model draf dari Hugging Face Hub, mengunggahnya ke Amazon S3, dan memberikan URI S3 ke argumen. `speculative_decoding_config`
1. Jika Anda ingin mengunduh model dari Hugging Face Hub, tambahkan pustaka `huggingface_hub` ke proyek Anda, dan unduh model dengan metode `snapshot_download()` tersebut. Contoh berikut mengunduh model ke direktori lokal:
```
import huggingface_hub
huggingface_hub.snapshot_download(
repo_id="model-id",
revision="main",
local_dir=download-dir,
token=hf-access-token,
)
```
Dalam contoh ini, ganti *`model-id`* dengan ID model Hugging Face Hub, seperti`meta-llama/Meta-Llama-3-8B`. Ganti *`download-dir`* dengan direktori lokal. Ganti *`hf-access-token`* dengan token akses pengguna Anda. Untuk mempelajari cara mendapatkan token akses, lihat [Token akses pengguna](https://huggingface.co/docs/hub/en/security-tokens) di dokumentasi Hugging Face.
Untuk informasi selengkapnya tentang `huggingface_hub` pustaka, lihat [Pustaka klien Hub](https://huggingface.co/docs/huggingface_hub/en/index) di dokumentasi Hugging Face.
1. Untuk membuat model yang Anda unduh tersedia untuk SageMaker AI, unggah ke Amazon S3. Contoh berikut mengunggah model dengan `sagemaker_session` objek:
```
custom_draft_model_uri = sagemaker_session.upload_data(
path=hf_local_download_dir.as_posix(),
bucket=sagemaker_session.default_bucket(),
key_prefix="prefix",
)
```
Dalam contoh ini, ganti *`prefix`* dengan qualifier yang membantu Anda membedakan model draf di S3, seperti. `spec-dec-custom-draft-model`
`upload_data()`Metode mengembalikan URI S3 untuk artefak model.
1. Untuk menjalankan pekerjaan decoding spekulatif, gunakan `optimize()` metode, dan atur argumennya. `speculative_decoding_config` Contoh berikut menetapkan `ModelSource` kunci ke URI S3 dari model draf kustom:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelSource": custom_draft_model_uri + "/",
},
)
```
Dalam contoh ini, ganti *`instance-type`* dengan instance ML, seperti`ml.p4d.24xlarge`.
`optimize()`Metode mengembalikan `Model` objek, yang dapat Anda gunakan untuk menyebarkan model Anda ke titik akhir.
1. Saat pekerjaan selesai, gunakan model. Contoh berikut menggunakan `deploy()` metode ini:
```
predictor = optimized_model.deploy(accept_eula=True)
```
`deploy()`Metode mengembalikan objek prediktor, yang dapat Anda gunakan untuk mengirim permintaan inferensi ke titik akhir yang menghosting model.
**Untuk mengoptimalkan dengan kompilasi**
1. Untuk menjalankan pekerjaan kompilasi, gunakan `optimize()` metode, dan atur `compilation_config` argumen. Contoh berikut menggunakan `OverrideEnvironment` kunci untuk mengatur variabel lingkungan yang diperlukan dalam wadah optimasi:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
compilation_config={
"OverrideEnvironment": {
"OPTION_TENSOR_PARALLEL_DEGREE": "24",
"OPTION_N_POSITIONS": "8192",
"OPTION_DTYPE": "fp16",
"OPTION_ROLLING_BATCH": "auto",
"OPTION_MAX_ROLLING_BATCH_SIZE": "4",
"OPTION_NEURON_OPTIMIZE_LEVEL": "2",
}
},
output_path="s3://output-path",
)
```
Dalam contoh ini, atur *`instance-type`* ke tipe instans ML dengan perangkat keras yang dipercepat. Misalnya, untuk inferensi yang dipercepat dengan AWS Inferentia, Anda dapat mengatur tipe ke instance Inf2, seperti. `ml.inf2.48xlarge` Ganti *`s3://output-path`* dengan jalur ke lokasi S3 tempat Anda menyimpan model yang dioptimalkan yang dibuat oleh pekerjaan.
1. Saat pekerjaan selesai, gunakan model. Contoh berikut menggunakan `deploy()` metode ini:
```
predictor = optimized_model.deploy(accept_eula=True)
```
`deploy()`Metode mengembalikan objek prediktor, yang dapat Anda gunakan untuk mengirim permintaan inferensi ke titik akhir yang menghosting model.
**Untuk menguji model Anda dengan permintaan inferensi**
+ Untuk mengirim permintaan inferensi pengujian ke model yang Anda gunakan, gunakan `predict()` metode objek prediktor. Contoh berikut meneruskan `sample_input` variabel yang juga diteruskan ke `SchemaBuilder` kelas dalam contoh untuk menentukan model Anda:
```
predictor.predict(sample_input)
```
Masukan sampel memiliki prompt,`"What is the largest planet in the solar system?"`. `predict()`Metode mengembalikan respon bahwa model dihasilkan, seperti yang ditunjukkan oleh contoh berikut:
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## AWS SDK untuk Python (Boto3)
Anda dapat menggunakan AWS SDK for Python (Boto3) untuk membuat dan mengelola pekerjaan pengoptimalan inferensi secara terprogram. Bagian ini memberikan contoh untuk teknik optimasi yang berbeda.
**Prasyarat**
Sebelum membuat pekerjaan pengoptimalan dengan Boto3, pastikan Anda memiliki:
+ AWS Kredensi yang dikonfigurasi - Siapkan AWS kredensil Anda dengan izin yang sesuai
+ Membuat model SageMaker AI (jika menggunakan model yang ada)
+ Data pelatihan yang disiapkan di S3 (untuk optimasi decoding spekulatif, mendukung panjang konteks hingga 4096)
+ Peran IAM dengan izin yang diperlukan - Peran eksekusi Anda harus memiliki izin untuk mengakses S3 dan membuat sumber daya SageMaker
**Contoh: Buat Job Optimasi dengan EAGLE Speculative Decoding (Llama 3.3 70B)**
Contoh ini menunjukkan pembuatan pekerjaan pengoptimalan untuk model bahasa besar menggunakan teknik decoding spekulatif EAGLE:
```
import boto3
# Initialize SageMaker client
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Step 1: Create a SageMaker model (if not already created)
model_response = sagemaker_client.create_model(
ModelName='meta-llama-3-3-70b-instruct',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/Llama-3.3-70B-Instruct/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'SAGEMAKER_ENV': '1',
'SAGEMAKER_MODEL_SERVER_TIMEOUT': '3600'
}
}
)
# Step 2: Create optimization job with speculative decoding
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'meta-llama-3-3-70b-instruct'
}
},
DeploymentInstanceType='ml.p4d.24xlarge',
# MaxInstanceCount specifies the maximum number of instances for distributed training
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_8k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/llama-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Contoh: Buat Job Optimasi dari Artefak Model S3 (Qwen3 32B)**
Contoh ini menunjukkan cara membuat pekerjaan pengoptimalan menggunakan artefak model langsung dari S3:
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Create model from S3 artifacts
model_response = sagemaker_client.create_model(
ModelName='qwen3-32b',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'Mode': 'SingleModel',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/qwen3-32b/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'AWS_REGION': 'us-west-2'
}
}
)
# Create optimization job with smaller training dataset
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='qwen3-optim-job-eagle',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'qwen3-32b'
}
},
DeploymentInstanceType='ml.g6.48xlarge',
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_1k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/qwen3-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Contoh: Memantau dan Mengelola Pekerjaan Optimasi**
Setelah membuat pekerjaan pengoptimalan, Anda dapat memantau kemajuannya dan mengelolanya menggunakan perintah ini:
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Describe optimization job to check status
describe_response = sagemaker_client.describe_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
)
print(f"Job Status: {describe_response['OptimizationJobStatus']}")
# List all optimization jobs (with pagination)
list_response = sagemaker_client.list_optimization_jobs(
MaxResults=10,
SortBy='CreationTime',
SortOrder='Descending'
)
print("\nRecent optimization jobs:")
for job in list_response['OptimizationJobSummaries']:
print(f"- {job['OptimizationJobName']}: {job['OptimizationJobStatus']}")
# Stop a running optimization job if needed
# sagemaker_client.stop_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
# Delete a completed or failed optimization job
# sagemaker_client.delete_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
```
Decoding spekulatif dengan Eagle Heads menjalankan empat pekerjaan pelatihan berurutan. Setiap pekerjaan menghasilkan output yang menjadi input ke pekerjaan berikutnya. Hanya output dari pekerjaan akhir yang dikirim ke bucket S3 Anda. Output perantara dienkripsi dan disimpan dalam bucket layanan SageMaker AI internal hingga 20 hari. SageMaker AI tidak memiliki izin untuk men-de-crypt mereka. Jika Anda ingin data perantara dihapus sebelum periode waktu tersebut, pastikan pekerjaan Anda telah selesai atau telah dihentikan, lalu buka kasus dukungan [[https://docs.aws.amazon.com/awssupport/latest/user/case-management.html\$1 creating-a-support-case](https://docs.aws.amazon.com/awssupport/latest/user/case-management.html#creating-a-support-case)] agar data ini dihapus. Sertakan dalam permintaan ID AWS akun Anda dan pekerjaan pengoptimalan ARN.
## Keterbatasan model draf SageMaker AI
Untuk model apa pun yang Anda optimalkan dengan model draf SageMaker AI, perhatikan persyaratan, batasan, dan variabel lingkungan yang didukung.
**Persyaratan**
Anda harus melakukan tindakan berikut:
+ Gunakan model yang disediakan oleh SageMaker JumpStart.
+ Aktifkan isolasi jaringan untuk penerapan model.
+ Jika Anda menerapkan model ke wadah Large Model Inference (LMI), gunakan DJLServing wadah pada versi 0.28.0 atau lebih tinggi.
Untuk kontainer yang tersedia, lihat Wadah [Inferensi Model Besar di GitHub repositori](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) Deep Learning Containers.
+ Jika Anda menyempurnakan JumpStart model, gunakan format safetensors untuk bobot model.
Untuk informasi selengkapnya tentang format ini, lihat [Safetensors](https://huggingface.co/docs/safetensors/en/index) di dokumentasi Hugging Face.
**Pembatasan**
Anda tidak dapat melakukan hal berikut:
+ Gunakan model di lingkungan pengujian lokal yang Anda buat dengan mode lokal.
Untuk informasi selengkapnya tentang mode lokal, lihat [Mode Lokal](https://sagemaker.readthedocs.io/en/stable/overview.html#local-mode) dalam dokumentasi SageMaker AI Python SDK.
+ Akses wadah model melalui AWS Systems Manager Agen (Agen SSM). Agen SSM menyediakan akses tingkat shell ke wadah model Anda sehingga Anda dapat men-debug proses dan perintah log dengan Amazon. CloudWatch
Untuk informasi selengkapnya tentang fitur ini, lihat [Akses kontainer melalui SSM](ssm-access.md).
+ Konfigurasikan wadah model untuk dump inti yang terjadi jika proses macet.
Untuk informasi selengkapnya tentang pembuangan inti dari wadah model, lihat [ProductionVariantCoreDumpConfig](sagemaker/latest/APIReference/API_ProductionVariantCoreDumpConfig.html).
+ Terapkan model ke titik akhir multi-model, titik akhir multi-kontainer, atau titik akhir yang menampung komponen inferensi.
Untuk informasi selengkapnya tentang jenis titik akhir ini, lihat[Titik akhir multi-model](multi-model-endpoints.md),[Titik akhir multi-kontainer](multi-container-endpoints.md), dan[Komponen inferensi](realtime-endpoints-deploy-models.md#inference-components).
+ Buat paket model untuk model. Anda menggunakan paket model untuk membuat model deployable yang Anda publikasikan. AWS Marketplace
Untuk informasi selengkapnya tentang fitur ini, lihat [Membuat Model Package Resource](sagemaker-mkt-create-model-package.md).
+ Gunakan kode inferensi Anda sendiri dalam wadah model.
+ Gunakan `requirements.txt` file dalam wadah model. Jenis file ini mencantumkan dependensi paket.
+ Aktifkan parameter Hugging Face`trust_remote_code`.
**Variabel lingkungan yang didukung**
Anda dapat mengkonfigurasi kontainer hanya dengan variabel lingkungan berikut:
+ Variabel lingkungan umum untuk wadah inferensi model besar (LMI).
Untuk informasi selengkapnya tentang variabel-variabel ini, lihat [Konfigurasi Variabel Lingkungan](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/deployment_guide/configurations.html#environment-variable-configurations) dalam dokumentasi kontainer LMI.
+ Variabel lingkungan umum untuk paket yang disediakan Hugging Face Hub di repositori Gitnya.
Untuk repositori, lihat [Hugging Face](https://github.com/huggingface) on. GitHub
+ Variabel lingkungan umum PyTorch & CUDA.
Untuk informasi selengkapnya tentang variabel-variabel ini, lihat [Variabel Lingkungan Obor](https://pytorch.org/docs/stable/torch_environment_variables.html) dalam PyTorch dokumentasi.
# Lihat hasil pekerjaan pengoptimalan
Setelah Anda membuat satu atau beberapa pekerjaan pengoptimalan, Anda dapat menggunakan Studio untuk melihat tabel ringkasan semua pekerjaan Anda, dan Anda dapat melihat detail untuk setiap pekerjaan individu.
## SageMaker Studio Amazon
**Untuk melihat tabel ringkasan pekerjaan optimasi**
+ Di menu navigasi Studio, di bawah **Pekerjaan**, pilih **Optimasi inferensi**.
Halaman **optimasi inferensi** menampilkan tabel yang menampilkan pekerjaan yang telah Anda buat. Untuk setiap pekerjaan, ini menunjukkan konfigurasi pengoptimalan yang Anda lamar dan status pekerjaan.
**Untuk melihat detail pekerjaan**
+ Pada halaman **Pengoptimalan inferensi**, di tabel ringkasan, pilih nama pekerjaan.
Studio menampilkan halaman detail pekerjaan, yang menunjukkan status pekerjaan dan semua pengaturan yang Anda terapkan saat Anda membuat pekerjaan. Jika pekerjaan berhasil diselesaikan, SageMaker AI menyimpan artefak model yang dioptimalkan di lokasi Amazon S3 di **bawah URI model S3 yang dioptimalkan**.
# Mengevaluasi kinerja model yang dioptimalkan
Setelah Anda menggunakan pekerjaan pengoptimalan untuk membuat model yang dioptimalkan, Anda dapat menjalankan evaluasi kinerja model. Evaluasi ini menghasilkan metrik untuk latensi, throughput, dan harga. Gunakan metrik ini untuk menentukan apakah model yang dioptimalkan memenuhi kebutuhan kasus penggunaan Anda atau apakah itu memerlukan pengoptimalan lebih lanjut.
Anda dapat menjalankan evaluasi kinerja hanya dengan menggunakan Studio. Fitur ini tidak disediakan melalui Amazon SageMaker AI API atau Python SDK.
## Sebelum Anda mulai
Sebelum Anda dapat membuat evaluasi kinerja, Anda harus terlebih dahulu mengoptimalkan model dengan membuat pekerjaan pengoptimalan inferensi. Di Studio, Anda hanya dapat mengevaluasi model yang Anda buat dengan pekerjaan ini.
## Buat evaluasi kinerja
Selesaikan langkah-langkah berikut di Studio untuk membuat evaluasi kinerja untuk model yang dioptimalkan.
1. Di menu navigasi Studio, di bawah **Pekerjaan**, pilih **Optimasi inferensi**.
1. Pilih nama pekerjaan yang menciptakan model yang dioptimalkan yang ingin Anda evaluasi.
1. Pada halaman detail pekerjaan, pilih **Evaluasi kinerja**.
1. Pada halaman **Evaluasi kinerja**, beberapa JumpStart model mengharuskan Anda untuk menandatangani perjanjian lisensi pengguna akhir (EULA) sebelum Anda dapat melanjutkan. Jika diminta, tinjau persyaratan lisensi di bagian **Perjanjian Lisensi**. Jika persyaratan dapat diterima untuk kasus penggunaan Anda, pilih kotak centang untuk **Saya menerima EULA, dan baca syarat dan ketentuan**.
1. Untuk **Pilih model untuk tokenizer**, terima default, atau pilih model tertentu untuk bertindak sebagai tokenizer untuk evaluasi Anda.
1. Untuk **kumpulan data Input**, pilih apakah akan:
+ Gunakan kumpulan data sampel default dari SageMaker AI.
+ Berikan URI S3 yang menunjuk ke kumpulan data sampel Anda sendiri.
1. Untuk **URI S3 untuk hasil kinerja**, berikan URI yang menunjuk ke lokasi di Amazon S3 tempat Anda ingin menyimpan hasil evaluasi.
1. Pilih **Evaluasi**.
Studio menunjukkan halaman **evaluasi kinerja**, di mana pekerjaan evaluasi Anda ditampilkan dalam tabel. Kolom **Status** menunjukkan status evaluasi Anda.
1. Ketika status **selesai**, pilih nama pekerjaan untuk melihat hasil evaluasi.
Halaman detail evaluasi menampilkan tabel yang menyediakan metrik kinerja untuk latensi, throughput, dan harga. Untuk informasi lebih lanjut tentang setiap metrik, lihat[Referensi metrik untuk evaluasi kinerja inferensi](#performance-eval-metrics-reference).
## Referensi metrik untuk evaluasi kinerja inferensi
Setelah Anda berhasil mengevaluasi kinerja model yang dioptimalkan, halaman detail evaluasi di Studio menunjukkan metrik berikut.
### Metrik latensi
Bagian **Latensi** menunjukkan metrik berikut
**Bersamaan**
Jumlah pengguna bersamaan yang disimulasikan evaluasi untuk memanggil titik akhir secara bersamaan.
**Waktu ke token pertama (ms)**
Waktu yang berlalu antara saat permintaan dikirim dan kapan token pertama dari respons streaming diterima.
**Latensi antar-token (ms)**
Waktu untuk menghasilkan token output untuk setiap permintaan.
**Latensi klien (ms)**
Latensi permintaan dari saat permintaan dikirim ke waktu seluruh respons diterima.
**Masukan tokens/sec (hitungan)**
Jumlah total token input yang dihasilkan, di semua permintaan, dibagi dengan total durasi dalam detik untuk konkurensi.
**Keluaran tokens/sec (hitungan)**
Jumlah total token keluaran yang dihasilkan, di semua permintaan, dibagi dengan total durasi dalam detik untuk konkurensi.
**Pemanggilan klien (hitungan)**
Jumlah total permintaan inferensi yang dikirim ke titik akhir di semua pengguna secara bersamaan.
**Kesalahan pemanggilan klien (hitungan)**
Jumlah total permintaan inferensi yang dikirim ke titik akhir di semua pengguna pada konkurensi tertentu yang mengakibatkan kesalahan pemanggilan.
**Tokenizer gagal (hitungan)**
Jumlah total permintaan inferensi di mana tokenizer gagal mengurai permintaan atau respons.
**Respon inferensi kosong (hitungan)**
Jumlah total permintaan inferensi yang menghasilkan token keluaran nol atau tokenizer gagal mengurai respons.
### Metrik throughput
Bagian **Throughput** menunjukkan metrik berikut.
**Bersamaan**
Jumlah pengguna bersamaan yang disimulasikan evaluasi untuk memanggil titik akhir secara bersamaan.
**Masukan tokens/sec/req (hitungan)**
Jumlah total token input yang dihasilkan per detik per permintaan.
**Keluaran tokens/sec/req (hitungan)**
Jumlah total token keluaran yang dihasilkan per detik per permintaan.
**Token masukan (hitungan)**
Jumlah total token input yang dihasilkan per permintaan.
**Token keluaran (hitungan)**
Jumlah total token keluaran yang dihasilkan per permintaan.
### Metrik harga
Bagian **Harga** menunjukkan metrik berikut.
**Bersamaan**
Jumlah pengguna bersamaan yang disimulasikan evaluasi untuk memanggil titik akhir secara bersamaan.
**Harga per juta token masukan**
Biaya pemrosesan token masukan 1M.
**Harga per juta token keluaran**
Biaya menghasilkan token keluaran 1M.
# Referensi model yang didukung
Tabel berikut menunjukkan model yang SageMaker AI mendukung optimasi inferensi, dan mereka menunjukkan teknik pengoptimalan yang didukung.
**Model Llama yang didukung**
| Nama Model | Format Data yang Didukung untuk Kuantisasi | Mendukung Decoding Spekulatif | Mendukung Pemuatan Model Cepat | Perpustakaan Digunakan untuk Kompilasi |
| --- | --- | --- | --- | --- |
| Meta Llama 2 13B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Meta Llama 2 13B Obrolan | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Meta Llama 2 70B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Meta Llama 2 70B Obrolan | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Meta Llama 2 7B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Meta Llama 2 7B Obrolan | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Meta Llama 3 70B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Instruksi Meta Llama 3 70B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Meta Llama 3 8B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Instruksi Meta Llama 3 8B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Kode Meta Llama 13B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Meta Kode Llama 13B Instruksi | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Kode Meta Llama 13B Python | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Kode Meta Llama 34B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Meta Kode Llama 34B Instruksi | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Kode Meta Llama 34B Python | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Kode Meta Llama 70B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Meta Kode Llama 70B Instruksi | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Kode Meta Llama 70B Python | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Kode Meta Llama 7B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Meta Kode Llama 7B Instruksi | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Kode Meta Llama 7B Python | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Meta Llama 2 13B Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 2 13B Obrolan Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 2 70B Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 2 70B Obrolan Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 2 7B Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 2 7B Neuron Obrolan | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 3 70B Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 3 70B Instruksi Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 3 8B Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 3 8B Instruksi Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Kode Meta Llama 70B Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Kode Meta Llama 7B Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Kode Meta Llama 7B Neuron Python | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 3.1 405B FP8 | Tidak ada | Ya | Ya | Tidak ada |
| Instruksi Meta Llama 3.1 405B FP8 | Tidak ada | Ya | Ya | Tidak ada |
| Meta Llama 3.1 70B | INT4-AWQ FP8 | Ya | Ya | Tidak ada |
| Instruksi Meta Llama 3.1 70B | INT4-AWQ FP8 | Ya | Ya | Tidak ada |
| Meta Llama 3.1 8B | INT4-AWQ FP8 | Ya | Ya | Tidak ada |
| Instruksi Meta Llama 3.1 8B | INT4-AWQ FP8 | Ya | Ya | Tidak ada |
| Meta Llama 3.1 70B Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 3.1 70B Instruksi Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 3 1 8B Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
| Meta Llama 3.1 8B Instruksi Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
**Model Mistral yang didukung**
| Nama Model | Format Data yang Didukung untuk Kuantisasi | Mendukung Decoding Spekulatif | Mendukung Pemuatan Model Cepat | Perpustakaan Digunakan untuk Kompilasi |
| --- | --- | --- | --- | --- |
| Mistral 7B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Instruksi Mistral 7B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | AWSNeuron Tensorrt-LLM |
| Neuron Mistral 7B | Tidak ada | Tidak | Tidak | AWSNeuron |
| Mistral 7B Instruksikan Neuron | Tidak ada | Tidak | Tidak | AWSNeuron |
**Model Mixtral yang didukung**
| Nama Model | Format Data yang Didukung untuk Kuantisasi | Mendukung Decoding Spekulatif | Mendukung Pemuatan Model Cepat | Perpustakaan Digunakan untuk Kompilasi |
| --- | --- | --- | --- | --- |
| Mixtral-8x22B-Instruksi-V0.1 | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Mixtral-8x22B V1 | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Mixtral 8x7B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
| Instruksi Mixtral 8x7B | INT4-AWQ INT8-SmoothQuant FP8 | Ya | Ya | Tensorrt-LLM |
**Arsitektur Model yang Didukung dan Tipe EAGLE**
| Nama Arsitektur Model | Jenis EAGLE |
| --- | --- |
| LlamaForCausalLM | ELANG 3 |
| Qwen3 ForCausal LM | ELANG 3 |
| Qwen3 NextForCausal LM | ELANG 2 |
| Qwen3 MoeForCausal LM | ELANG 3 |
| Qwen2 ForCausal LM | ELANG 3 |
| GptOssForCausalLM | ELANG 3 |