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, AWS SDK, atau file. AWS CLI

Memanggil Endpoint 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:

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:

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

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

Memanggil Endpoint Anda dengan Menggunakan AWS CLI

Anda dapat menguji titik akhir 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 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 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