Memanggil model untuk inferensi waktu nyata

Setelah menggunakan Amazon SageMaker AI untuk menerapkan model ke titik akhir, Anda dapat berinteraksi dengan model dengan mengirimkan permintaan inferensi ke model tersebut. Untuk mengirim permintaan inferensi ke model, Anda memanggil titik akhir yang menghostingnya. Anda dapat memanggil titik akhir Anda menggunakan Amazon SageMaker Studio, the AWS SDKs, atau. AWS CLI

Panggil Model Anda Menggunakan Amazon Studio SageMaker

Setelah menerapkan model ke titik akhir, Anda dapat melihat titik akhir melalui Amazon SageMaker Studio dan menguji titik akhir dengan mengirimkan permintaan inferensi tunggal.

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

Panggil Model Anda dengan Menggunakan AWS SDK for Python (Boto3)

Jika Anda ingin memanggil titik akhir model dalam kode aplikasi Anda, Anda dapat menggunakan salah satunya AWS SDKs, termasuk. AWS SDK for Python (Boto3) Untuk memanggil endpoint Anda dengan SDK ini, Anda menggunakan salah satu metode Python berikut:

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

import boto3

sagemaker_runtime = boto3.client(
    "sagemaker-runtime", region_name='aws_region')

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 agar SageMaker AI dapat diteruskan ke model. Data ini harus dalam format yang sama dengan yang digunakan untuk pelatihan. Contoh memberikan respons terhadap response variabel.

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

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 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 segera. Anda dapat menerapkan streaming untuk mendukung pengalaman interaktif yang cepat, seperti chatbots, asisten virtual, dan generator musik. 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 ini. Dalam badan respons, SDK menyediakan EventStream objek, yang memberikan inferensi sebagai serangkaian PayloadPart objek.

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

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

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

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:

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 . . .

Panggil Model Anda dengan Menggunakan AWS CLI

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

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 titik akhir yang Anda tentukan saat Anda membuat titik akhir. Untuk --body parameter, berikan data input agar SageMaker AI dapat 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 parameter AWS CLI, lihat Praktik Terbaik untuk Parameter File Lokal.

Untuk informasi selengkapnya, dan untuk melihat parameter tambahan yang dapat Anda lewati, lihat invoke-endpointdi AWS CLI Command 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