Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menyebarkan model besar untuk inferensi dengan TorchServe
Tutorial ini menunjukkan cara menerapkan model besar dan menyajikan inferensi di Amazon SageMaker AI dengan TorchServe pada GPU. Contoh ini menyebarkan [OPT-30b](https://huggingface.co/facebook/opt-30b)model ke sebuah `ml.g5` instance. Anda dapat memodifikasi ini untuk bekerja dengan model dan jenis instance lainnya. Ganti contoh `{{italicized placeholder text}}` dalam dengan informasi Anda sendiri.
TorchServe adalah platform terbuka yang kuat untuk inferensi model terdistribusi besar. Dengan mendukung pustaka populer seperti PyTorch, PiPPy asli,, DeepSpeed dan HuggingFace Accelerate, ia menawarkan API penangan seragam yang tetap konsisten di seluruh model besar terdistribusi dan skenario inferensi model non-terdistribusi. Untuk informasi lebih lanjut, [TorchServelihat dokumentasi inferensi model besar](https://pytorch.org/serve/large_model_inference.html#).
## Wadah pembelajaran mendalam dengan TorchServe
Untuk menerapkan model besar dengan TorchServe SageMaker AI, Anda dapat menggunakan salah satu wadah pembelajaran mendalam (DLC) SageMaker AI. Secara default, TorchServe diinstal di semua AWS PyTorch DLC. Selama pemuatan model, TorchServe dapat menginstal perpustakaan khusus yang disesuaikan untuk model besar seperti PiPPy, Deepspeed, dan Accelerate.
Tabel berikut mencantumkan semua [SageMaker AI DLC](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) dengan. TorchServe
| Kateogri DLC | Kerangka Kerja | Hardware | Contoh URL |
| --- | --- | --- | --- |
| [SageMaker Wadah Kerangka AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) | PyTorch 2.0.0\+ | CPU, GPU | 763104351884.dkr.ecr.us-east-1.amazonaws. com/pytorch-inferensi: 2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker |
| [SageMaker Wadah Graviton Kerangka AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) | PyTorch 2.0.0\+ | CPU | 763104351884.dkr.ecr.us-east-1.amazonaws. com/pytorch-inferensi-gravitasi: 2.0.1-cpu-py310-ubuntu20.04-sagemaker |
| [Wadah Inferensi StabilityAI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#stabilityai-inference-containers) | PyTorch 2.0.0\+ | GPU | 763104351884.dkr.ecr.us-east-1.amazonaws. com/stabilityai-pytorch-inferensi: 2.0.1-sgm0.1.0-gpu-py310-cu118-ubuntu20.04-sagemaker |
| [Wadah Neuron](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) | PyTorch 1.13.1 | Neuronx | 763104351884.dkr.ecr.us-west-2.amazonaws. com/pytorch-inferensi-neuron:1.13.1-neuron-py310-sdk2.12.0-ubuntu20.04 |
## Memulai
Sebelum menerapkan model Anda, selesaikan prasyarat. Anda juga dapat mengonfigurasi parameter model dan menyesuaikan kode handler.
### Prasyarat
Untuk memulai, pastikan Anda memiliki prasyarat berikut:
1. Pastikan Anda memiliki akses ke AWS akun. [Siapkan lingkungan Anda](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) sehingga AWS CLI dapat mengakses akun Anda melalui pengguna AWS IAM atau peran IAM. Kami merekomendasikan menggunakan peran IAM. Untuk tujuan pengujian di akun pribadi Anda, Anda dapat melampirkan kebijakan izin terkelola berikut ke peran IAM:
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWSServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
*Untuk informasi selengkapnya tentang melampirkan kebijakan IAM ke peran, lihat [Menambahkan dan menghapus izin identitas IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) di Panduan Pengguna IAM.AWS *
1. Konfigurasikan dependensi Anda secara lokal, seperti yang ditunjukkan pada contoh berikut.
1. Instal versi 2 dari AWS CLI:
```
# Install the latest AWS CLI v2 if it is not installed
!curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" !unzip awscliv2.zip
#Follow the instructions to install v2 on the terminal
!cat aws/README.md
```
1. Instal SageMaker AI dan klien Boto3:
```
# If already installed, update your client
#%pip install sagemaker pip --upgrade --quiet
!pip install -U sagemaker
!pip install -U boto
!pip install -U botocore
!pip install -U boto3
```
### Konfigurasikan pengaturan dan parameter model
TorchServe digunakan [https://pytorch.org/docs/stable/elastic/run.html](https://pytorch.org/docs/stable/elastic/run.html)untuk mengatur lingkungan terdistribusi untuk pemrosesan paralel model. TorchServe memiliki kemampuan untuk mendukung banyak pekerja untuk model besar. Secara default, TorchServe menggunakan algoritma round-robin untuk menetapkan GPU ke pekerja di host. Dalam kasus inferensi model besar, jumlah GPU yang ditetapkan untuk setiap pekerja dihitung secara otomatis berdasarkan jumlah GPU yang ditentukan dalam file. `model_config.yaml` Variabel lingkungan`CUDA_VISIBLE_DEVICES`, yang menentukan ID perangkat GPU yang terlihat pada waktu tertentu, ditetapkan berdasarkan nomor ini.
Misalnya, ada 8 GPU pada sebuah node dan satu pekerja membutuhkan 4 GPU pada node ()`nproc_per_node=4`. Dalam hal ini, TorchServe tetapkan empat GPU ke worker pertama (`CUDA_VISIBLE_DEVICES="0,1,2,3"`) dan empat GPU ke worker kedua (). `CUDA_VISIBLE_DEVICES="4,5,6,7”`
Selain perilaku default ini, TorchServe memberikan fleksibilitas bagi pengguna untuk menentukan GPU untuk pekerja. Misalnya, jika Anda mengatur variabel `deviceIds: [2,3,4,5]` dalam [file YAMAL konfigurasi model](https://github.com/pytorch/serve/blob/5ee02e4f050c9b349025d87405b246e970ee710b/model-archiver/README.md?plain=1#L164), dan mengatur`nproc_per_node=2`, kemudian TorchServe menetapkan `CUDA_VISIBLE_DEVICES=”2,3”` ke pekerja pertama dan pekerja `CUDA_VISIBLE_DEVICES="4,5”` kedua.
Dalam `model_config.yaml` contoh berikut, kita mengkonfigurasi parameter front-end dan back-end untuk model. [OPT-30b ](https://huggingface.co/facebook/opt-30b) Parameter front-end yang dikonfigurasi adalah`parallelType`,`deviceType`, `deviceIds ` dan. `torchrun` [Untuk informasi lebih rinci tentang parameter front-end yang dapat Anda konfigurasi, lihat dokumentasi. PyTorch GitHub ](https://github.com/pytorch/serve/blob/2bf505bae3046b0f7d0900727ec36e611bb5dca3/docs/configuration.md?plain=1#L267) Konfigurasi back-end didasarkan pada peta YAMM yang memungkinkan kustomisasi gaya bebas. Untuk parameter back-end, kita mendefinisikan DeepSpeed konfigurasi dan parameter tambahan yang digunakan oleh kode handler kustom.
```
# TorchServe front-end parameters
minWorkers: 1
maxWorkers: 1
maxBatchDelay: 100
responseTimeout: 1200
parallelType: "tp"
deviceType: "gpu"
# example of user specified GPU deviceIds
deviceIds: [0,1,2,3] # sets CUDA_VISIBLE_DEVICES
torchrun:
nproc-per-node: 4
# TorchServe back-end parameters
deepspeed:
config: ds-config.json
checkpoint: checkpoints.json
handler: # parameters for custom handler code
model_name: "facebook/opt-30b"
model_path: "model/models--facebook--opt-30b/snapshots/ceea0a90ac0f6fae7c2c34bcb40477438c152546"
max_length: 50
max_new_tokens: 10
manual_seed: 40
```
### Sesuaikan penangan
TorchServe menawarkan [penangan dasar](https://github.com/pytorch/serve/tree/master/ts/torch_handler/distributed) dan [utilitas penangan](https://github.com/pytorch/serve/tree/master/ts/handler_utils) untuk inferensi model besar yang dibangun dengan perpustakaan populer. [Contoh berikut menunjukkan bagaimana kelas handler kustom [TransformersSeqClassifierHandler](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/examples/large_models/deepspeed/custom_handler.py#L16C7-L16C39)meluas [BaseDeepSpeedHandler](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/ts/torch_handler/distributed/base_deepspeed_handler.py#L8)dan menggunakan utilitas handler.](https://github.com/pytorch/serve/blob/master/ts/handler_utils/distributed/deepspeed.py) Untuk contoh kode lengkap, lihat [`custom_handler.py`kode pada PyTorch GitHub dokumentasi](https://github.com/pytorch/serve/blob/master/examples/large_models/deepspeed/custom_handler.py).
```
class TransformersSeqClassifierHandler(BaseDeepSpeedHandler, ABC):
"""
Transformers handler class for sequence, token classification and question answering.
"""
def __init__(self):
super(TransformersSeqClassifierHandler, self).__init__()
self.max_length = None
self.max_new_tokens = None
self.tokenizer = None
self.initialized = False
def initialize(self, ctx: Context):
"""In this initialize function, the HF large model is loaded and
partitioned using DeepSpeed.
Args:
ctx (context): It is a JSON Object containing information
pertaining to the model artifacts parameters.
"""
super().initialize(ctx)
model_dir = ctx.system_properties.get("model_dir")
self.max_length = int(ctx.model_yaml_config["handler"]["max_length"])
self.max_new_tokens = int(ctx.model_yaml_config["handler"]["max_new_tokens"])
model_name = ctx.model_yaml_config["handler"]["model_name"]
model_path = ctx.model_yaml_config["handler"]["model_path"]
seed = int(ctx.model_yaml_config["handler"]["manual_seed"])
torch.manual_seed(seed)
logger.info("Model %s loading tokenizer", ctx.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.tokenizer.pad_token = self.tokenizer.eos_token
config = AutoConfig.from_pretrained(model_name)
with torch.device("meta"):
self.model = AutoModelForCausalLM.from_config(
config, torch_dtype=torch.float16
)
self.model = self.model.eval()
ds_engine = get_ds_engine(self.model, ctx)
self.model = ds_engine.module
logger.info("Model %s loaded successfully", ctx.model_name)
self.initialized = True
def preprocess(self, requests):
"""
Basic text preprocessing, based on the user's choice of application mode.
Args:
requests (list): A list of dictionaries with a "data" or "body" field, each
containing the input text to be processed.
Returns:
tuple: A tuple with two tensors: the batch of input ids and the batch of
attention masks.
"""
def inference(self, input_batch):
"""
Predicts the class (or classes) of the received text using the serialized transformers
checkpoint.
Args:
input_batch (tuple): A tuple with two tensors: the batch of input ids and the batch
of attention masks, as returned by the preprocess function.
Returns:
list: A list of strings with the predicted values for each input text in the batch.
"""
def postprocess(self, inference_output):
"""Post Process Function converts the predicted response into Torchserve readable format.
Args:
inference_output (list): It contains the predicted response of the input text.
Returns:
(list): Returns a list of the Predictions and Explanations.
"""
```
## Siapkan artefak model Anda
Sebelum menerapkan model Anda pada SageMaker AI, Anda harus mengemas artefak model Anda. Untuk model besar, kami menyarankan Anda menggunakan alat PyTorch [arsip model obor dengan argumen, yang melewatkan artefak model](https://github.com/pytorch/serve/blob/master/model-archiver/README.md) `--archive-format no-archive` kompresi. Contoh berikut menyimpan semua artefak model ke folder baru bernama`opt/`.
```
torch-model-archiver --model-name opt --version 1.0 --handler custom_handler.py --extra-files ds-config.json -r requirements.txt --config-file opt/model-config.yaml --archive-format no-archive
```
Setelah `opt/` folder dibuat, unduh OPT-30b model ke folder menggunakan PyTorch [Download\_model](https://github.com/pytorch/serve/blob/master/examples/large_models/utils/Download_model.py)alat.
```
cd opt
python path_to/Download_model.py --model_path model --model_name facebook/opt-30b --revision main
```
Terakhir, unggah artefak model ke ember Amazon S3.
```
aws s3 cp opt {{{your_s3_bucket}}}/opt --recursive
```
Anda sekarang harus memiliki artefak model yang disimpan di Amazon S3 yang siap digunakan ke titik akhir AI. SageMaker
## Terapkan model menggunakan SageMaker Python SDK
Setelah menyiapkan artefak model Anda, Anda dapat menerapkan model Anda ke titik akhir SageMaker AI Hosting. Bagian ini menjelaskan cara menerapkan satu model besar ke titik akhir dan membuat prediksi respons streaming. Untuk informasi selengkapnya tentang respons streaming dari titik akhir, lihat [Memanggil titik akhir waktu nyata](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-test-endpoints.html).
Untuk menerapkan model Anda, selesaikan langkah-langkah berikut:
1. Buat sesi SageMaker AI, seperti yang ditunjukkan pada contoh berikut.
```
import boto3
import sagemaker
from sagemaker import Model, image_uris, serializers, deserializers
boto3_session=boto3.session.Session(region_name="us-west-2")
smr = boto3.client('sagemaker-runtime-demo')
sm = boto3.client('sagemaker')
role = sagemaker.get_execution_role() # execution role for the endpoint
sess= sagemaker.session.Session(boto3_session, sagemaker_client=sm, sagemaker_runtime_client=smr) # SageMaker AI session for interacting with different AWS APIs
region = sess._region_name # region name of the current SageMaker Studio Classic environment
account = sess.account_id() # account_id of the current SageMaker Studio Classic environment
# Configuration:
bucket_name = sess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}"
print(f'account={account}, region={region}, role={role}, output_path={output_path}')
```
1. Buat model yang tidak terkompresi di SageMaker AI, seperti yang ditunjukkan pada contoh berikut.
```
from datetime import datetime
instance_type = "ml.g5.24xlarge"
endpoint_name = sagemaker.utils.name_from_base("ts-opt-30b")
s3_uri = {your_s3_bucket}/opt
model = Model(
name="torchserve-opt-30b" + datetime.now().strftime("%Y-%m-%d-%H-%M-%S"),
# Enable SageMaker uncompressed model artifacts
model_data={
"S3DataSource": {
"S3Uri": s3_uri,
"S3DataType": "S3Prefix",
"CompressionType": "None",
}
},
image_uri=container,
role=role,
sagemaker_session=sess,
env={"TS_INSTALL_PY_DEP_PER_MODEL": "true"},
)
print(model)
```
1. Menerapkan model ke instans Amazon EC2, seperti yang ditunjukkan pada contoh berikut.
```
model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
volume_size=512, # increase the size to store large model
model_data_download_timeout=3600, # increase the timeout to download large model
container_startup_health_check_timeout=600, # increase the timeout to load large model
)
```
1. Inisialisasi kelas untuk memproses respons streaming, seperti yang ditunjukkan pada contoh berikut.
```
import io
class Parser:
"""
A helper class for parsing the byte stream input.
The output of the model will be in the following format:
```
b'{"outputs": [" a"]}\n'
b'{"outputs": [" challenging"]}\n'
b'{"outputs": [" problem"]}\n'
...
```
While usually each PayloadPart event from the event stream will contain a byte array
with a full json, this is not guaranteed and some of the json objects may be split across
PayloadPart events. For example:
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
This class accounts for this by concatenating bytes written via the 'write' function
and then exposing a method which will return lines (ending with a '\n' character) within
the buffer via the 'scan_lines' function. It maintains the position of the last read
position to ensure that previous bytes are not exposed again.
"""
def __init__(self):
self.buff = io.BytesIO()
self.read_pos = 0
def write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
data = self.buff.getvalue()
def scan_lines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
if line[-1] != b'\n':
self.read_pos += len(line)
yield line[:-1]
def reset(self):
self.read_pos = 0
```
1. Uji prediksi respons streaming, seperti yang ditunjukkan pada contoh berikut.
```
import json
body = "Today the weather is really nice and I am planning on".encode('utf-8')
resp = smr.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=body, ContentType="application/json")
event_stream = resp['Body']
parser = Parser()
for event in event_stream:
parser.write(event['PayloadPart']['Bytes'])
for line in parser.scan_lines():
print(line.decode("utf-8"), end=' ')
```
Anda sekarang telah menerapkan model Anda ke titik akhir SageMaker AI dan harus dapat memanggilnya untuk tanggapan. Untuk informasi selengkapnya tentang titik akhir real-time SageMaker AI, lihat[Single-model titik akhir](realtime-single-model.md).