Tingkatkan kinerja inferensi untuk model Mixtral dan Llama 2 dengan kontainer Amazon SageMaker baru | Layanan Web Amazon

Pada bulan Januari 2024, Amazon SageMaker meluncurkan versi baru (0.26.0) Wadah Pembelajaran Mendalam (DLC) Inferensi Model Besar (LMI). Versi ini menawarkan dukungan untuk model baru (termasuk Campuran Pakar), peningkatan kinerja dan kegunaan di seluruh backend inferensi, serta detail generasi baru untuk meningkatkan kontrol dan kemampuan menjelaskan prediksi (seperti alasan penyelesaian pembuatan dan probabilitas log tingkat token).

DLC LMI menawarkan antarmuka kode rendah yang menyederhanakan penggunaan teknik dan perangkat keras pengoptimalan inferensi yang canggih. LMI memungkinkan Anda menerapkan paralelisme tensor; teknik perhatian, batching, kuantisasi, dan manajemen memori terbaru yang efisien; streaming token; dan masih banyak lagi, hanya dengan memerlukan ID model dan parameter model opsional. Dengan DLC LMI di SageMaker, Anda dapat mempercepat waktu terhadap nilai untuk Anda kecerdasan buatan generatif (AI) aplikasi, membongkar beban berat terkait infrastruktur, dan mengoptimalkan model bahasa besar (LLM) untuk perangkat keras pilihan Anda guna mencapai kinerja harga terbaik di kelasnya.

Dalam postingan ini, kami menjelajahi fitur-fitur terbaru yang diperkenalkan dalam rilis ini, memeriksa tolok ukur kinerja, dan memberikan panduan terperinci tentang penerapan LLM baru dengan DLC LMI dengan kinerja tinggi.

Fitur baru dengan DLC LMI

Di bagian ini, kami membahas fitur-fitur baru di seluruh backend LMI, dan menelusuri beberapa fitur lain yang spesifik untuk backend. LMI saat ini mendukung backend berikut:

• Perpustakaan Terdistribusi LMI – Ini adalah kerangka kerja AWS untuk menjalankan inferensi dengan LLM, yang terinspirasi dari OSS, untuk mencapai latensi dan akurasi terbaik pada hasilnya
• LMI vLLM – Ini adalah implementasi backend AWS yang hemat memori vLLM perpustakaan inferensi
• Perangkat LMI TensorRT-LLM – Ini adalah implementasi backend AWS NVIDIA TensorRT-LLM, yang menciptakan mesin khusus GPU untuk mengoptimalkan kinerja pada GPU yang berbeda
• Kecepatan Dalam LMI – Ini adalah adaptasi AWS dari Kecepatan Dalam, yang menambahkan pengelompokan berkelanjutan yang sebenarnya, kuantisasi SmoothQuant, dan kemampuan untuk menyesuaikan memori secara dinamis selama inferensi
• LMI NeuronX – Anda dapat menggunakan ini untuk penerapan AWS Inferensia2 dan Pelatihan AWSinstans berbasis, menampilkan pengelompokan dan percepatan berkelanjutan yang sebenarnya, berdasarkan SDK Neuron AWS

Tabel berikut merangkum fitur-fitur baru yang ditambahkan, baik yang umum maupun khusus backend.

Model-model baru didukung

Model populer baru didukung di seluruh backend, seperti Mistral-7B (semua backend), Mixtral berbasis MoE (semua backend kecuali Transformers-NeuronX), dan Llama2-70B (Transformers-NeuronX).

Teknik perluasan jendela konteks

Penskalaan konteks berbasis Rotary Positional Embedding (RoPE) kini tersedia di backend LMI-Dist, vLLM, dan TensorRT-LLM. Penskalaan RoPE memungkinkan perpanjangan panjang urutan model selama inferensi ke hampir semua ukuran, tanpa perlu penyesuaian.

Berikut ini adalah dua pertimbangan penting saat menggunakan RoPE:

• Kebingungan model – Dengan bertambahnya panjang barisan, jadi bisa milik sang model kebingungan. Efek ini sebagian dapat diimbangi dengan melakukan penyesuaian minimal pada rangkaian masukan yang lebih besar daripada yang digunakan dalam pelatihan awal. Untuk pemahaman mendalam tentang bagaimana RoPE memengaruhi kualitas model, lihat Memperluas Tali.
• Kinerja inferensi – Panjang urutan yang lebih panjang akan menggunakan memori bandwidth tinggi (HBM) akselerator yang lebih tinggi. Peningkatan penggunaan memori ini dapat berdampak buruk pada jumlah permintaan bersamaan yang dapat ditangani akselerator Anda.

Menambahkan detail generasi

Anda sekarang bisa mendapatkan dua detail terperinci tentang hasil pembuatan:

• alasan_selesai – Hal ini memberikan alasan penyelesaian pembuatan, yang dapat berupa mencapai panjang pembuatan maksimum, menghasilkan token akhir kalimat (EOS), atau menghasilkan token penghentian yang ditentukan pengguna. Itu dikembalikan dengan potongan urutan streaming terakhir.
• log_probs – Ini mengembalikan probabilitas log yang ditetapkan oleh model untuk setiap token dalam potongan urutan yang dialirkan. Anda dapat menggunakan ini sebagai perkiraan kasar kepercayaan model dengan menghitung probabilitas gabungan suatu barisan sebagai jumlah dari log_probs dari masing-masing token, yang dapat berguna untuk menilai dan memberi peringkat pada keluaran model. Ingatlah bahwa probabilitas token LLM umumnya terlalu percaya diri tanpa kalibrasi.

Anda dapat mengaktifkan output hasil pembangkitan dengan menambahkan detail=True pada payload input Anda ke LMI, membiarkan semua parameter lainnya tidak berubah:

payload = {“inputs”:“your prompt”,
“parameters”:{max_new_tokens”:256,...,“details”:True}
}

Parameter konfigurasi konsolidasi

Terakhir, parameter konfigurasi LMI juga telah dikonsolidasikan. Untuk informasi selengkapnya tentang semua parameter konfigurasi penerapan umum dan khusus backend, lihat Konfigurasi Inferensi Model Besar.

Backend terdistribusi LMI

Di AWS re:Invent 2023, LMI-Dist menambahkan operasi kolektif baru yang dioptimalkan untuk mempercepat komunikasi antar GPU, sehingga menghasilkan latensi lebih rendah dan throughput lebih tinggi untuk model yang terlalu besar untuk satu GPU. Kolektif ini tersedia secara eksklusif untuk SageMaker, untuk instans p4d.

Sedangkan iterasi sebelumnya hanya mendukung sharding di seluruh 8 GPU, LMI 0.26.0 memperkenalkan dukungan untuk tingkat paralel tensor 4, dalam pola parsial semua-ke-semua. Ini dapat dikombinasikan dengan Komponen inferensi SageMaker, yang dengannya Anda dapat mengonfigurasi secara terperinci berapa banyak akselerator yang harus dialokasikan untuk setiap model yang diterapkan di belakang titik akhir. Bersama-sama, fitur-fitur ini memberikan kontrol yang lebih baik terhadap pemanfaatan sumber daya dari instans yang mendasarinya, memungkinkan Anda meningkatkan multi-tenancy model dengan menghosting model yang berbeda di belakang satu titik akhir, atau menyempurnakan throughput agregat penerapan Anda agar sesuai dengan model dan karakteristik lalu lintas Anda.

Gambar berikut membandingkan direct all-to-all dengan parsial all-to-all.

Bagian belakang TensorRT-LLM

TensorRT-LLM NVIDIA diperkenalkan sebagai bagian dari rilis DLC LMI sebelumnya (0.25.0), memungkinkan performa GPU tercanggih dan pengoptimalan seperti SmoothQuant, FP8, dan batching berkelanjutan untuk LLM saat menggunakan GPU NVIDIA.

TensorRT-LLM mengharuskan model dikompilasi menjadi mesin yang efisien sebelum diterapkan. DLC LMI TensorRT-LLM dapat secara otomatis menangani kompilasi daftar model just-in-time (JIT) yang didukung, sebelum memulai server dan memuat model untuk inferensi real-time. DLC versi 0.26.0 menambah daftar model yang didukung untuk kompilasi JIT, memperkenalkan model Baichuan, ChatGLM, GPT2, GPT-J, InternLM, Mistral, Mixtral, Qwen, SantaCoder, dan StarCoder.

Kompilasi JIT menambahkan beberapa menit overhead pada waktu penyediaan dan penskalaan titik akhir, jadi selalu disarankan untuk mengkompilasi model Anda terlebih dahulu. Untuk panduan tentang cara melakukan hal ini dan daftar model yang didukung, lihat Tutorial kompilasi model TensorRT-LLM sebelumnya. Jika model pilihan Anda belum didukung, lihat Tutorial kompilasi model manual TensorRT-LLM untuk mengkompilasi model lain yang didukung oleh TensorRT-LLM.

Selain itu, LMI kini menampilkan kuantisasi TensorRT-LLM SmootQuant asli, dengan parameter untuk mengontrol faktor alfa dan penskalaan berdasarkan token atau saluran. Untuk informasi lebih lanjut tentang konfigurasi terkait, lihat TensorRT-LLM.

vLLM bagian belakang

Rilis vLLM yang diperbarui yang disertakan dalam DLC LMI menghadirkan peningkatan kinerja hingga 50% yang didorong oleh mode grafik CUDA, bukan mode bersemangat. Grafik CUDA mempercepat beban kerja GPU dengan meluncurkan beberapa operasi GPU sekaligus alih-alih meluncurkannya satu per satu, sehingga mengurangi overhead. Hal ini sangat efektif untuk model kecil saat menggunakan paralelisme tensor.

Performa tambahan ini diperoleh dengan mengorbankan tambahan konsumsi memori GPU. Mode grafik CUDA kini menjadi default untuk backend vLLM, jadi jika Anda dibatasi pada jumlah memori GPU yang tersedia, Anda dapat mengaturnya option.enforce_eager=True untuk memaksa mode bersemangat PyTorch.

Bagian belakang Transformers-NeuronX

Rilis terbaru dari NeuronX termasuk dalam DLC LMI NeuronX sekarang mendukung model yang menampilkan mekanisme perhatian kueri yang dikelompokkan, seperti Mistral-7B dan LLama2-70B. Perhatian kueri yang dikelompokkan merupakan pengoptimalan penting dari mekanisme perhatian transformator default, di mana model dilatih dengan kepala kunci dan nilai yang lebih sedikit dibandingkan kepala kueri. Hal ini mengurangi ukuran cache KV pada memori GPU, memungkinkan konkurensi yang lebih besar, dan meningkatkan kinerja harga.

Gambar berikut mengilustrasikan metode perhatian multi-head, kueri yang dikelompokkan, dan multi-kueri (sumber).

Strategi sharding cache KV yang berbeda tersedia untuk disesuaikan dengan jenis beban kerja yang berbeda. Untuk informasi lebih lanjut tentang strategi sharding, lihat Dukungan perhatian kueri yang dikelompokkan (GQA).. Anda dapat mengaktifkan strategi yang Anda inginkan (shard-over-heads, misalnya) dengan kode berikut:

option.group_query_attention=shard-over-heads

Selain itu, implementasi baru DLC NeuronX memperkenalkan API cache untuk TransformerNeuronX yang memungkinkan akses ke cache KV. Hal ini memungkinkan Anda untuk menyisipkan dan menghapus baris cache KV dari permintaan baru saat Anda menyerahkan inferensi batch. Sebelum memperkenalkan API ini, cache KV dihitung ulang untuk setiap permintaan yang baru ditambahkan. Dibandingkan dengan LMI V7 (0.25.0), kami telah meningkatkan latensi lebih dari 33% dengan permintaan bersamaan, dan mendukung throughput yang jauh lebih tinggi.

Memilih backend yang tepat

Untuk memutuskan backend mana yang akan digunakan berdasarkan model dan tugas yang dipilih, gunakan diagram alur berikut. Untuk panduan pengguna backend individual beserta model yang didukung, lihat Panduan Pengguna Backend LMI.

Terapkan Mixtral dengan DLC LMI dengan atribut tambahan

Mari kita telusuri bagaimana Anda dapat menerapkan model Mixtral-8x7B dengan container LMI 0.26.0 dan menghasilkan detail tambahan seperti log_prob dan finish_reason sebagai bagian dari keluaran. Kami juga membahas bagaimana Anda dapat memperoleh manfaat dari atribut tambahan ini melalui kasus penggunaan pembuatan konten.

Buku catatan lengkap dengan petunjuk rinci tersedia di GitHub repo.

Kita mulai dengan mengimpor perpustakaan dan mengkonfigurasi lingkungan sesi:

import boto3
import sagemaker 
import json 
import io 
import numpy as np 
from sagemaker import Model, image_uris, serializers, deserializers 

role = sagemaker.get_execution_role() # execution role for the endpoint 
session = sagemaker.session.Session() # sagemaker session for interacting with different AWS APIs 
region = session._region_name # region name of the current SageMaker Studio environment

Anda dapat menggunakan kontainer LMI SageMaker untuk menghosting model tanpa kode inferensi tambahan apa pun. Anda dapat mengkonfigurasi server model baik melalui variabel lingkungan atau a serving.properties mengajukan. Secara opsional, Anda dapat memiliki model.py file untuk prapemrosesan atau pascapemrosesan dan a requirements.txt file untuk paket tambahan apa pun yang perlu diinstal.

Dalam hal ini, kami menggunakan serving.properties file untuk mengonfigurasi parameter dan menyesuaikan perilaku kontainer LMI. Untuk lebih jelasnya, lihat GitHub repo. Repo menjelaskan detail berbagai parameter konfigurasi yang dapat Anda atur. Kami memerlukan parameter kunci berikut:

• mesin – Menentukan mesin runtime yang akan digunakan DJL. Hal ini mendorong strategi sharding dan pemuatan model di akselerator untuk model tersebut.
• pilihan.model_id – Menentukan Layanan Penyimpanan Sederhana Amazon (Amazon S3) URI model terlatih atau ID model dari model terlatih yang dihosting di dalam repositori model di Wajah Memeluk. Dalam hal ini, kami menyediakan ID model untuk model Mixtral-8x7B.
• opsi.tensor_parallel_degree – Menetapkan jumlah perangkat GPU yang dibutuhkan Accelerate untuk mempartisi model. Parameter ini juga mengontrol jumlah pekerja per model yang akan dimulai saat layanan DJL berjalan. Kami menetapkan nilai ini menjadi max (GPU maksimum pada mesin saat ini).
• opsi.rolling_batch – Memungkinkan batching berkelanjutan untuk mengoptimalkan pemanfaatan akselerator dan throughput secara keseluruhan. Untuk container TensorRT-LLM, kami menggunakan auto.
• pilihan.model_loading_timeout – Menetapkan nilai batas waktu untuk mengunduh dan memuat model untuk menyajikan inferensi.
• opsi.max_rolling_batch – Menetapkan ukuran maksimum batch berkelanjutan, menentukan berapa banyak urutan yang dapat diproses secara paralel pada waktu tertentu.

%%writefile serving.properties 
engine=MPI 
option.model_id=mistralai/Mixtral-8x7B-v0.1 
option.tensor_parallel_degree=max 
option.max_rolling_batch_size=32 
option.rolling_batch=auto 
option.model_loading_timeout = 7200

Kami mengemasnya serving.properties file konfigurasi dalam format tar.gz, sehingga memenuhi persyaratan hosting SageMaker. Kami mengkonfigurasi wadah DJL LMI dengan tensorrtllm sebagai mesin backend. Selain itu, kami menentukan versi penampung terbaru (0.26.0).

image_uri = image_uris.retrieve(
   framework="djl-tensorrtllm",
   region=sess.boto_session.region_name,
   version="0.26.0"
)

Selanjutnya, kami mengunggah tarball lokal (berisi file serving.properties file konfigurasi) ke awalan S3. Kami menggunakan URI gambar untuk kontainer DJL dan lokasi Amazon S3 tempat model yang menyajikan tarball artefak diunggah, untuk membuat objek model SageMaker.

model = Model(image_uri=image_uri, model_data=code_artifact, role=role) 

instance_type = "ml.p4d.24xlarge" 
endpoint_name = sagemaker.utils.name_from_base("mixtral-lmi-model") 

model.deploy(
   initial_instance_count=1,
   instance_type=instance_type,
   endpoint_name=endpoint_name,
   container_startup_health_check_timeout=1800
)

Sebagai bagian dari LMI 0.26.0, Anda sekarang dapat menggunakan dua detail tambahan tentang output yang dihasilkan:

• log_probs – Ini adalah probabilitas log yang ditetapkan oleh model untuk setiap token dalam potongan urutan yang dialirkan. Anda dapat menggunakan ini sebagai perkiraan kasar kepercayaan model dengan menghitung probabilitas gabungan suatu urutan sebagai jumlah probabilitas log dari masing-masing token, yang dapat berguna untuk menilai dan memberi peringkat pada keluaran model. Ingatlah bahwa probabilitas token LLM umumnya terlalu percaya diri tanpa kalibrasi.
• alasan_selesai – Ini adalah alasan penyelesaian pembangkitan, yang dapat berupa mencapai panjang pembangkitan maksimum, menghasilkan token EOS, atau menghasilkan token penghentian yang ditentukan pengguna. Ini dikembalikan dengan potongan urutan streaming terakhir.

Anda dapat mengaktifkannya dengan meneruskan "details"=True sebagai bagian dari masukan Anda ke model.

Mari kita lihat bagaimana Anda dapat menghasilkan detail ini. Kami menggunakan contoh pembuatan konten untuk memahami penerapannya.

Kami mendefinisikan a LineIterator kelas pembantu, yang memiliki fungsi untuk dengan malas mengambil byte dari aliran respons, melakukan buffering, dan memecah buffer menjadi beberapa baris. Idenya adalah untuk menyajikan byte dari buffer sambil mengambil lebih banyak byte dari aliran secara asinkron.

class LineIterator:
    def __init__(self, stream):
        # Iterator to get bytes from stream 
        self.byte_iterator = iter(stream)  
        # Buffer stream bytes until we get a full line
        self.buffer = io.BytesIO()  
        # Track current reading position within buffer
        self.read_pos = 0

   def __iter__(self):
        # Make class iterable 
        return self

    def __next__(self):
        while True:
           # Seek read position within buffer
           self.buffer.seek(self.read_pos)  
           # Try reading a line from current position
           line = self.buffer.readline()
           # If we have a full line
           if line and line[-1] == ord('n'):
               # Increment reading position past this line
               self.read_pos += len(line)  
               # Return the line read without newline char
               return line[:-1] 
           # Fetch next chunk from stream  
           try:
               chunk = next(self.byte_iterator)
           # Handle end of stream 
           except StopIteration:
               # Check if we have any bytes still unread
               if self.read_pos < self.buffer.getbuffer().nbytes:
                   continue
               # If not, raise StopIteration
               raise
           # Add fetched bytes to end of buffer
           self.buffer.seek(0, io.SEEK_END)  
           self.buffer.write(chunk['PayloadPart']['Bytes'])

Hasilkan dan gunakan probabilitas token sebagai detail tambahan

Pertimbangkan kasus penggunaan saat kita membuat konten. Secara khusus, kami ditugaskan untuk menulis paragraf singkat tentang manfaat berolahraga secara teratur untuk situs web yang berfokus pada gaya hidup. Kami ingin membuat konten dan mengeluarkan beberapa skor indikatif keyakinan model terhadap konten yang dihasilkan.

Kami memanggil titik akhir model dengan perintah kami dan menangkap respons yang dihasilkan. Kami mengatur "details": True sebagai parameter runtime dalam masukan ke model. Karena probabilitas log dihasilkan untuk setiap token keluaran, kami menambahkan probabilitas log individual ke daftar. Kami juga menangkap teks lengkap yang dihasilkan dari respons.

sm_client = boto3.client("sagemaker-runtime")

# Set details: True as a runtime parameter within the input.
body = {"inputs": prompt, "parameters": {"max_new_tokens":512, "details": True}}
resp = sm_client.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=json.dumps(body), ContentType="application/json")
event_stream = resp['Body']

overall_log_prob = []

for line in LineIterator(event_stream):
    resp = json.loads(line)
    if resp['token'].get('text') != None:
        token_log_prob = resp['token']['log_prob']
        overall_log_prob.append(token_log_prob)
    elif resp['generated_text'] != None:
        generated_text= resp['generated_text']

Untuk menghitung skor kepercayaan keseluruhan, kami menghitung rata-rata semua probabilitas token individual dan kemudian mendapatkan nilai eksponensial antara 0 dan 1. Ini adalah skor kepercayaan keseluruhan yang kami simpulkan untuk teks yang dihasilkan, yang dalam hal ini adalah paragraf tentang manfaatnya. dari berolahraga secara teratur.

print(generated_text) 
overall_score=np.exp(np.mean(overall_log_prob)) 
print(f"nnOverall confidence score in the generated text: {overall_score}")

Ini adalah salah satu contoh bagaimana Anda dapat membuat dan menggunakan log_prob, dalam konteks kasus penggunaan pembuatan konten. Demikian pula, Anda dapat menggunakan log_prob sebagai ukuran skor kepercayaan untuk kasus penggunaan klasifikasi.

Alternatifnya, Anda dapat menggunakannya untuk urutan keluaran keseluruhan atau penilaian tingkat kalimat untuk mengevaluasi pengaruh parameter seperti suhu pada keluaran yang dihasilkan.

Hasilkan dan gunakan alasan selesai sebagai detail tambahan

Mari kita membangun kasus penggunaan yang sama, namun kali ini kita ditugaskan untuk menulis artikel yang lebih panjang. Selain itu, kami ingin memastikan bahwa keluaran tidak terpotong karena masalah panjang pembuatan (panjang token maks) atau karena ditemukannya token penghentian.

Untuk mencapai hal ini, kami menggunakan finish_reason atribut yang dihasilkan dalam keluaran, pantau nilainya, dan lanjutkan pembuatan hingga seluruh keluaran dihasilkan.

Kami mendefinisikan fungsi inferensi yang mengambil masukan payload dan memanggil titik akhir SageMaker, mengalirkan kembali respons, dan memproses respons untuk mengekstrak teks yang dihasilkan. Payload berisi teks prompt sebagai input dan parameter seperti token maksimal dan detail. Responsnya dibaca dalam aliran dan diproses baris demi baris untuk mengekstrak token teks yang dihasilkan ke dalam daftar. Kami mengekstrak detail seperti finish_reason. Kami memanggil fungsi inferensi dalam satu lingkaran (permintaan berantai) sambil menambahkan lebih banyak konteks setiap kali, dan melacak jumlah token yang dihasilkan dan jumlah permintaan yang dikirim hingga model selesai.

def inference(payload):
    # Call SageMaker endpoint and get response stream
    resp = sm_client.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=json.dumps(payload), ContentType="application/json")
    event_stream = resp['Body']
    text_output = []
    for line in LineIterator(event_stream):
        resp = json.loads(line) 
        # Extract text tokens if present
        if resp['token'].get('text') != None:
            token = resp['token']['text']
            text_output.append(token)  
            print(token, end='')
        # Get finish reason if details present
        if resp.get('details') != None:
            finish_reason = resp['details']['finish_reason']
            # Return extracted output, finish reason and token length
            return payload['inputs'] + ''.join(text_output), finish_reason, len(text_output)

# set details: True as a runtime parameter within the input.
payload = {"inputs": prompt,  "parameters": {"max_new_tokens":256, "details": True}} 

finish_reason = "length"
# Print initial output 
print(f"Output: {payload['inputs']}", end='')  
total_tokens = 0
total_requests = 0
while finish_reason == 'length':
    # Call inference and get extracts
    output_text, finish_reason, out_token_len = inference(payload)
    # Update payload for next request
    payload['inputs'] = output_text 
    total_tokens += out_token_len
    total_requests += 1
# Print metrics
print(f"nntotal tokens generated: {total_tokens} ntotal requests sent: {total_requests}")

Seperti yang bisa kita lihat, meskipun max_new_token parameter disetel ke 256, kami menggunakan atribut detail finish_reason sebagai bagian dari keluaran untuk merangkai beberapa permintaan ke titik akhir, hingga seluruh keluaran dihasilkan.

Demikian pula, berdasarkan kasus penggunaan Anda, Anda dapat menggunakan stop_reason untuk mendeteksi ketidakcukupan panjang urutan keluaran yang ditentukan untuk tugas tertentu atau penyelesaian yang tidak diinginkan karena urutan penghentian manusia.

Kesimpulan

Dalam postingan ini, kita membahas rilis kontainer AWS LMI v0.26.0. Kami menyoroti peningkatan kinerja utama, dukungan model baru, dan fitur kegunaan baru. Dengan kemampuan ini, Anda dapat menyeimbangkan karakteristik biaya dan kinerja dengan lebih baik sekaligus memberikan pengalaman yang lebih baik kepada pengguna akhir Anda.

Untuk mempelajari lebih lanjut tentang kemampuan DLC LMI, lihat Paralelisme model dan inferensi model besar. Kami sangat senang melihat bagaimana Anda menggunakan kemampuan baru dari SageMaker ini.

Tentang penulis

João Moura adalah Arsitek Solusi Spesialis AI/ML Senior di AWS. João membantu pelanggan AWS – mulai dari startup kecil hingga perusahaan besar – melatih dan menerapkan model besar secara efisien, dan secara lebih luas membangun platform ML di AWS.

Rahul Sharma adalah Arsitek Solusi Senior di AWS, membantu pelanggan AWS merancang dan membangun solusi AI/ML. Sebelum bergabung dengan AWS, Rahul telah menghabiskan beberapa tahun di sektor keuangan dan asuransi, membantu pelanggan membangun platform data dan analitis.

Qinglan adalah Insinyur Pengembangan Perangkat Lunak di AWS. Dia telah mengerjakan beberapa produk yang menantang di Amazon, termasuk solusi inferensi ML kinerja tinggi dan sistem logging kinerja tinggi. Tim Qing berhasil meluncurkan model Billion-parameter pertama di Amazon Advertising dengan latensi yang sangat rendah. Qing memiliki pengetahuan mendalam tentang pengoptimalan infrastruktur dan akselerasi Deep Learning.

Jian Sheng adalah Insinyur Pengembangan Perangkat Lunak di Amazon Web Services yang telah mengerjakan beberapa aspek penting sistem pembelajaran mesin. Dia telah menjadi kontributor utama pada layanan SageMaker Neo, dengan fokus pada kompilasi pembelajaran mendalam dan optimalisasi runtime kerangka kerja. Baru-baru ini, dia mengarahkan upayanya dan berkontribusi dalam mengoptimalkan sistem pembelajaran mesin untuk inferensi model besar.

Tyler Osterberg adalah Insinyur Pengembangan Perangkat Lunak di AWS. Dia berspesialisasi dalam menciptakan pengalaman inferensi pembelajaran mesin berkinerja tinggi dalam SageMaker. Baru-baru ini, fokusnya adalah mengoptimalkan kinerja Inferentia Deep Learning Containers di platform SageMaker. Tyler unggul dalam mengimplementasikan solusi hosting berkinerja tinggi untuk model bahasa besar dan meningkatkan pengalaman pengguna menggunakan teknologi mutakhir.

Rupinder Grewal adalah Arsitek Solusi Spesialis AI/ML Senior di AWS. Saat ini dia berfokus pada penyajian model dan MLOps di Amazon SageMaker. Sebelumnya, dia bekerja sebagai Machine Learning Engineer yang membuat dan menghosting model. Di luar pekerjaan, dia menikmati bermain tenis dan bersepeda di jalur pegunungan.

Dhawal Patel adalah Arsitek Pembelajaran Mesin Utama di AWS. Dia telah bekerja dengan organisasi mulai dari perusahaan besar hingga perusahaan rintisan menengah pada masalah yang terkait dengan komputasi terdistribusi, dan Kecerdasan Buatan. Dia berfokus pada Deep learning termasuk domain NLP dan Computer Vision. Dia membantu pelanggan mencapai inferensi model kinerja tinggi di SageMaker.

Raghu Ramesha adalah Arsitek Solusi ML Senior di tim Layanan Amazon SageMaker. Dia berfokus membantu pelanggan membangun, menerapkan, dan memigrasikan beban kerja produksi ML ke SageMaker dalam skala besar. Ia berspesialisasi dalam pembelajaran mesin, AI, dan domain visi komputer, serta meraih gelar master di bidang Ilmu Komputer dari UT Dallas. Di waktu luangnya, ia menikmati jalan-jalan dan fotografi.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• PlatoHealth. Kecerdasan Uji Coba Biotek dan Klinis. Akses Di Sini.
• Sumber: https://aws.amazon.com/blogs/machine-learning/boost-inference-performance-for-mixtral-and-llama-2-models-with-new-amazon-sagemaker-containers/