Memanggil model untuk inferensi waktu nyata

Setelah menerapkan model Anda menggunakan layanan SageMaker hosting, Anda dapat menguji model Anda pada titik akhir tersebut dengan mengirimkan data pengujian. Anda dapat menguji titik akhir menggunakan Amazon SageMaker Studio Classic, AWS SDK, atau. AWS CLI

Memanggil Endpoint Anda Menggunakan Amazon Studio Classic SageMaker

Setelah menerapkan model ke titik akhir, Anda dapat memeriksa titik akhir tersebut dengan Amazon SageMaker Studio Classic.

catatan

Catatan: SageMaker hanya mendukung pengujian titik akhir dengan Amazon SageMaker Studio Classic untuk titik akhir real-time.

Untuk mengirim permintaan inferensi pengujian ke titik akhir Anda

1. Luncurkan Amazon SageMaker Studio Classic.

2. Di bagian Beranda panel navigasi di sebelah kiri, pilih Deployment.

3. Dari dropdown, pilih Endpoints.

4. Temukan titik akhir Anda berdasarkan nama, dan pilih nama di tabel. Nama titik akhir yang tercantum di panel Endpoints ditentukan saat Anda menerapkan model. Ruang kerja Studio membuka halaman Endpoints di tab baru.

5. Di tab Inferensi uji, kirim permintaan ke titik akhir Anda dengan memberikan data sampel dalam format JSON. Gunakan editor JSON untuk mengirimkan permintaan ke titik akhir Anda.

6. (Opsional) Anda dapat memberikan URL khusus untuk mengirim permintaan Anda. Di bagian Configure endpoint URL dan header, untuk kolom Custom URL, berikan URL tempat model Anda di-host. Biarkan bidang ini kosong jika Anda menggunakan SageMaker titik akhir. Di bawah Header, Anda juga dapat menambahkan header nilai kunci secara opsional untuk meneruskan informasi tambahan dengan permintaan inferensi.

7. Pilih Kirim Permintaan. Studio menunjukkan output inferensi dalam kartu di sebelah kanan editor JSON.

Bagian atas kartu menunjukkan jenis permintaan yang dikirim ke titik akhir (hanya JSON yang diterima). Kartu menunjukkan bidang-bidang berikut:

• Status - menampilkan salah satu jenis status berikut:

  • CompletePermintaan itu berhasil.

  • Failed— Permintaan gagal. Respons muncul di bawah Failure Reason.

  • Pending— Saat permintaan inferensi tertunda, status menunjukkan ikon melingkar yang berputar.

• Panjang Eksekusi — Berapa lama waktu pemanggilan (waktu akhir dikurangi waktu mulai) dalam milidetik.

• Waktu Permintaan — Berapa menit telah berlalu sejak permintaan dikirim.

• Waktu Hasil — Berapa menit telah berlalu sejak hasilnya dikembalikan.

Memanggil Endpoint Anda dengan Menggunakan AWS SDK for Python (Boto3)

Setelah menerapkan model ke titik akhir, Anda dapat memeriksa titik akhir dengan menggunakan salah satu AWS SDK, termasuk sebagai. AWS SDK for Python (Boto3) Untuk menguji titik akhir Anda dengan SDK ini, Anda menggunakan salah satu metode berikut:

• invoke_endpoint— Mengirim permintaan inferensi ke titik akhir model dan mengembalikan respons yang dihasilkan model. Metode ini mengembalikan muatan inferensi sebagai satu respons setelah model selesai menghasilkannya. Untuk informasi selengkapnya, lihat invoke_endpoint di Referensi API AWSSDK for Python (Boto3).

• invoke_endpoint_with_response_stream— Mengirim permintaan inferensi ke titik akhir model dan mengalirkan respons di bagian tambahan sementara model menghasilkan inferensi. Dengan metode ini, aplikasi klien Anda segera mulai menerima bagian dari respons saat bagian-bagiannya tersedia. Klien Anda tidak perlu menunggu model menghasilkan seluruh muatan respons. Anda dapat menerapkan streaming untuk mendukung pengalaman interaktif yang cepat, seperti chatbots, asisten virtual, dan generator musik.

  Gunakan metode ini hanya untuk memanggil model yang mendukung streaming inferensi.

  Ketika sebuah wadah menangani permintaan inferensi streaming, ia mengembalikan inferensi model sebagai serangkaian bagian secara bertahap saat model menghasilkannya. Aplikasi klien mulai menerima tanggapan segera ketika tersedia. Mereka tidak perlu menunggu model untuk menghasilkan seluruh respons. Anda dapat menerapkan streaming untuk mendukung pengalaman interaktif yang cepat, seperti chatbots, asisten virtual, dan generator musik.

Sebelum Anda dapat menggunakan metode ini dalam kode klien Anda, Anda harus membuat klien SageMaker Runtime, dan Anda harus menentukan nama titik akhir Anda. Contoh berikut mengatur klien dan titik akhir untuk sisa contoh berikut:

import boto3

# Create a low-level client representing Amazon SageMaker Runtime
sagemaker_runtime = boto3.client(
    "sagemaker-runtime", region_name='aws_region')

# The endpoint name must be unique within 
# an AWS Region in your AWS account. 
endpoint_name='endpoint-name'

Memohon untuk Mendapatkan Respons Inferensi

Contoh berikut menggunakan invoke_endpoint metode untuk memanggil titik akhir dengan: AWS SDK for Python (Boto3)

# Gets inference from the model hosted at the specified endpoint:
response = sagemaker_runtime.invoke_endpoint(
    EndpointName=endpoint_name, 
    Body=bytes('{"features": ["This is great!"]}', 'utf-8')
    )

# Decodes and prints the response body:
print(response['Body'].read().decode('utf-8'))

Contoh ini memberikan data input di Body lapangan SageMaker untuk diteruskan ke model. Data ini harus dalam format yang sama dengan yang digunakan untuk pelatihan. Contoh menyimpan respons dalam response variabel.

responseVariabel menyediakan akses ke status HTTP, nama model yang digunakan, dan bidang lainnya. Cuplikan berikut mencetak: HTTPStatusCode

print(response["HTTPStatusCode"])

Memanggil untuk Streaming Respons Inferensi

Jika Anda menerapkan model yang mendukung streaming inferensi, Anda dapat memanggil model untuk menerima muatan inferensinya sebagai aliran suku cadang. Model memberikan bagian-bagian ini secara bertahap saat model menghasilkannya. Saat aplikasi menerima aliran inferensi, aplikasi tidak perlu menunggu model menghasilkan seluruh muatan respons. Sebagai gantinya, aplikasi segera mulai menerima bagian dari respons saat tersedia.

Dengan menggunakan aliran inferensi dalam aplikasi Anda, Anda dapat membuat interaksi di mana pengguna Anda menganggap inferensi menjadi cepat karena mereka mendapatkan bagian pertama dengan segera. Misalnya, Anda dapat membuat chatbot yang secara bertahap menampilkan teks yang dihasilkan oleh model bahasa besar (LLM).

Untuk mendapatkan aliran inferensi, Anda dapat menggunakan invoke_endpoint_with_response_stream metode di SDK for Python (Boto3). Dalam badan respons, SDK menyediakan EventStream objek, yang memberikan inferensi sebagai serangkaian PayloadPart objek.

contoh Aliran Inferensi

Contoh berikut adalah aliran PayloadPart objek:

{'PayloadPart': {'Bytes': b'{"outputs": [" a"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" challenging"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" problem"]}\n'}}
. . .

Di setiap bagian muatan, Bytes bidang menyediakan sebagian dari respons inferensi dari model. Bagian ini dapat berupa jenis konten apa pun yang dihasilkan model, seperti teks, gambar, atau data audio. Dalam contoh ini, bagian-bagiannya adalah objek JSON yang berisi teks yang dihasilkan dari LLM.

Biasanya, bagian payload berisi potongan data terpisah dari model. Dalam contoh ini, potongan diskrit adalah objek JSON utuh. Kadang-kadang, respons streaming membagi potongan menjadi beberapa bagian muatan, atau menggabungkan beberapa potongan menjadi satu bagian muatan. Contoh berikut menunjukkan potongan data dalam format JSON yang dibagi menjadi dua bagian payload:

{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}

Saat Anda menulis kode aplikasi yang memproses aliran inferensi, sertakan logika yang menangani pemisahan dan kombinasi data sesekali ini. Sebagai salah satu strategi, Anda dapat menulis kode yang menggabungkan konten Bytes saat aplikasi Anda menerima bagian payload. Dengan menggabungkan contoh data JSON di sini, Anda akan menggabungkan data menjadi badan JSON yang dibatasi baris baru. Kemudian, kode Anda dapat memproses aliran dengan mengurai seluruh objek JSON pada setiap baris.

Contoh berikut menunjukkan JSON yang dibatasi baris baru yang akan Anda buat saat Anda menggabungkan isi contoh: Bytes

{"outputs": [" a"]}
{"outputs": [" challenging"]}
{"outputs": [" problem"]}
. . .

contoh Kode untuk Memproses Aliran Inferensi

Contoh kelas Python berikut,SmrInferenceStream, menunjukkan bagaimana Anda dapat memproses aliran inferensi yang mengirimkan data teks dalam format JSON:

import io
import json

# Example class that processes an inference stream:
class SmrInferenceStream:
    
    def __init__(self, sagemaker_runtime, endpoint_name):
        self.sagemaker_runtime = sagemaker_runtime
        self.endpoint_name = endpoint_name
        # A buffered I/O stream to combine the payload parts:
        self.buff = io.BytesIO() 
        self.read_pos = 0
        
    def stream_inference(self, request_body):
        # Gets a streaming inference response 
        # from the specified model endpoint:
        response = self.sagemaker_runtime\
            .invoke_endpoint_with_response_stream(
                EndpointName=self.endpoint_name, 
                Body=json.dumps(request_body), 
                ContentType="application/json"
        )
        # Gets the EventStream object returned by the SDK:
        event_stream = response['Body']
        for event in event_stream:
            # Passes the contents of each payload part
            # to be concatenated:
            self._write(event['PayloadPart']['Bytes'])
            # Iterates over lines to parse whole JSON objects:
            for line in self._readlines():
                resp = json.loads(line)
                part = resp.get("outputs")[0]
                # Returns parts incrementally:
                yield part
    
    # Writes to the buffer to concatenate the contents of the parts:
    def _write(self, content):
        self.buff.seek(0, io.SEEK_END)
        self.buff.write(content)

    # The JSON objects in buffer end with '\n'.
    # This method reads lines to yield a series of JSON objects:
    def _readlines(self):
        self.buff.seek(self.read_pos)
        for line in self.buff.readlines():
            self.read_pos += len(line)
            yield line[:-1]

Contoh ini memproses aliran inferensi dengan melakukan hal berikut:

• Diinisialisasi dengan klien SageMaker Runtime dan nama titik akhir model. Sebelum Anda bisa mendapatkan aliran inferensi, model yang dihosting endpoint harus mendukung streaming inferensi.

• Dalam stream_inference metode contoh, menerima badan permintaan dan meneruskannya ke invoke_endpoint_with_response_stream metode SDK.

• Mengulangi setiap peristiwa dalam EventStream objek yang dikembalikan SDK.

• Dari setiap peristiwa, dapatkan isi Bytes objek dalam PayloadPart objek.

• Dalam _write metode contoh, menulis ke buffer untuk menggabungkan isi objek. Bytes Konten gabungan membentuk badan JSON yang dibatasi baris baru.

• Menggunakan _readlines metode contoh untuk mendapatkan serangkaian objek JSON yang dapat diulang.

• Di setiap objek JSON, mendapat sepotong inferensi.

• Dengan yield ekspresi, mengembalikan potongan secara bertahap.

Contoh berikut membuat dan menggunakan SmrInferenceStream objek:

request_body = {"inputs": ["Large model inference is"],
                "parameters": {"max_new_tokens": 100,
                               "enable_sampling": "true"}}
smr_inference_stream = SmrInferenceStream(
    sagemaker_runtime, endpoint_name)
stream = smr_inference_stream.stream_inference(request_body)
for part in stream:
    print(part, end='')

Contoh ini meneruskan badan permintaan ke stream_inference metode. Ini mengulangi respons untuk mencetak setiap bagian yang dikembalikan oleh aliran inferensi.

Contoh mengasumsikan bahwa model pada titik akhir yang ditentukan adalah LLM yang menghasilkan teks. Output dari contoh ini adalah kumpulan teks yang dihasilkan yang mencetak secara bertahap:

a challenging problem in machine learning. The goal is to . . .

Memanggil Endpoint Anda dengan Menggunakan AWS CLI

Anda dapat menguji titik akhir Anda dengan menjalankan perintah dengan AWS Command Line Interface (AWS CLI). AWS CLIMendukung permintaan inferensi standar dengan invoke-endpoint perintah, dan mendukung permintaan inferensi asinkron dengan perintah. invoke-endpoint-async

catatan

AWS CLIItu tidak mendukung permintaan inferensi streaming.

Contoh berikut menggunakan invoke-endpoint perintah untuk mengirim permintaan inferensi ke titik akhir model:

aws sagemaker-runtime invoke-endpoint \
    --endpoint-name endpoint_name \
    --body fileb://$file_name \
    output_file.txt

Untuk --endpoint-name parameter, berikan nama yang Anda tentukan EndpointName saat Anda membuat titik akhir. CreateEndpoint Untuk --body parameter, berikan data input SageMaker untuk diteruskan ke model. Data harus dalam format yang sama dengan yang digunakan untuk pelatihan. Contoh ini menunjukkan cara mengirim data biner ke titik akhir Anda.

Untuk informasi selengkapnya tentang fileb:// kapan harus menggunakan file:// over saat meneruskan konten file ke parameterAWS CLI, lihat Praktik Terbaik untuk Parameter File Lokal.

Untuk informasi selengkapnya, dan untuk melihat parameter tambahan yang dapat Anda lewati, lihat invoke-endpointdi AWS CLICommand Reference.

Jika invoke-endpoint perintah berhasil mengembalikan respon seperti berikut:

{
    "ContentType": "<content_type>; charset=utf-8",
    "InvokedProductionVariant": "<Variant>"
}

Jika perintah tidak berhasil, periksa apakah muatan input dalam format yang benar.

Lihat output dari pemanggilan dengan memeriksa file output file (output_file.txtdalam contoh ini).

more output_file.txt