Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Stellen Sie große Modelle für Inferenzen bereit mit TorchServe

Dieses Tutorial zeigt, wie Sie große Modelle bereitstellen und Inferenzen in Amazon SageMaker AI mit TorchServe GPUs bereitstellen. In diesem Beispiel wird das OPT-30b Modell auf einer Instance bereitgestellt. ml.g5 Sie können dies so ändern, dass es mit anderen Modellen und Instance-Typen funktioniert. Ersetzen Sie die italicized placeholder text in den Beispielen durch Ihre eigenen Angaben.

TorchServe ist eine leistungsstarke offene Plattform für umfangreiche verteilte Modellinferenzen. Durch die Unterstützung gängiger Bibliotheken wie PyTorch natives PiPPy und HuggingFace Accelerate bietet sie einheitliche Handler-APIs, die in verteilten großen Modellen und nicht verteilten Modellinferenzszenarien konsistent bleiben. DeepSpeed Weitere Informationen finden Sie in der umfangreichen Dokumentation TorchServe zur Modellinferenz.

Deep-Learning-Container mit TorchServe

Um ein großes Modell ohne TorchServe KI bereitzustellen, können Sie einen der SageMaker SageMaker KI-Deep-Learning-Container (DLCs) verwenden. TorchServe Ist standardmäßig in allen AWS PyTorch DLCs installiert. Beim Laden des Modells TorchServe können spezielle Bibliotheken installiert werden, die auf große Modelle zugeschnitten sind, wie PiPPY, Deepspeed und Accelerate.

In der folgenden Tabelle sind alle SageMaker AI-DLCs mit aufgeführt. TorchServe

Erste Schritte

Bevor Sie Ihr Modell bereitstellen, müssen Sie die Voraussetzungen erfüllen. Sie können auch die Modellparameter konfigurieren und den Handler Code anpassen.

Voraussetzungen

Um mit der Arbeit zu beginnen, müssen Sie die folgenden Voraussetzungen erfüllen:

Modelleinstellungen und Parameter konfigurieren

TorchServe verwendet torchrun, um die verteilte Umgebung für die parallele Modellverarbeitung einzurichten. TorchServe ist in der Lage, mehrere Worker für ein großes Modell zu unterstützen. TorchServe Verwendet standardmäßig einen Round-Robin-Algorithmus, um GPUs einem Worker auf einem Host zuzuweisen. Bei umfangreichen Modellinferenzen wird die Anzahl der jedem Worker zugewiesenen GPUs automatisch auf der Grundlage der in der model_config.yaml-Datei angegebenen Anzahl der GPUs berechnet. Die Umgebungsvariable CUDA_VISIBLE_DEVICES, die die GPU-Geräte-IDs angibt, die zu einem bestimmten Zeitpunkt sichtbar sind, wird auf der Grundlage dieser Zahl festgelegt.

Nehmen wir zum Beispiel an, es gibt 8 GPUs auf einem Knoten und ein Worker benötigt 4 GPUs auf einem Knoten (nproc_per_node=4). TorchServe Weist in diesem Fall dem ersten Worker (CUDA_VISIBLE_DEVICES="0,1,2,3") vier GPUs zu und dem zweiten Worker () vier GPUs. CUDA_VISIBLE_DEVICES="4,5,6,7”

Zusätzlich zu diesem Standardverhalten TorchServe bietet es Benutzern die Flexibilität, GPUs für einen Worker anzugeben. Wenn Sie beispielsweise die Variable deviceIds: [2,3,4,5] in der YAML-Datei der Modellkonfiguration festlegen und setzen nproc_per_node=2, wird sie dann dem ersten Worker und CUDA_VISIBLE_DEVICES=”2,3” CUDA_VISIBLE_DEVICES="4,5” dem zweiten Worker TorchServe zugewiesen.

Im folgenden model_config.yaml Beispiel konfigurieren wir sowohl Front-End- als auch Back-End-Parameter für das Modell. OPT-30b Die konfigurierten Front-End-Parameter sind parallelType, deviceType, deviceIds und torchrun. Weitere Informationen zu den Frontend-Parametern, die Sie konfigurieren können, finden Sie in der Dokumentation. PyTorch GitHub Die Back-End-Konfiguration basiert auf einer YAML-Map, die eine individuelle Anpassung ermöglicht. Für die Backend-Parameter definieren wir die DeepSpeed Konfiguration und zusätzliche Parameter, die vom benutzerdefinierten Handlercode verwendet werden.

# 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

Handler anpassen

TorchServe bietet Basishandler und Handler-Dienstprogramme für umfangreiche Modellinferenzen, die mit gängigen Bibliotheken erstellt wurden. Das folgende Beispiel zeigt, wie die benutzerdefinierte Handler-Klasse die TransformersSeqClassifierHandler BaseDeepSpeedHandler Handler-Dienstprogramme erweitert und verwendet. https://github.com/pytorch/serve/blob/master/ts/handler_utils/distributed/deepspeed.py Ein vollständiges Codebeispiel finden Sie im custom_handler.py Code in der PyTorch GitHub Dokumentation.

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

Vorbereiten Ihrer Modellartefakte

Bevor Sie Ihr Modell auf SageMaker KI bereitstellen, müssen Sie Ihre Modellartefakte verpacken. Für große Modelle empfehlen wir, das Tool PyTorch Torch-Model-Archiver mit dem Argument zu verwenden, wodurch das Komprimieren von Modellartefakten --archive-format no-archive übersprungen wird. Im folgenden Beispiel werden alle Modellartefakte in einem neuen Ordner mit dem Namen opt/ gespeichert.

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

Sobald der opt/ Ordner erstellt wurde, laden Sie das OPT-30b Modell mithilfe des Tools in den Ordner herunter. PyTorch Download_model

cd opt
python path_to/Download_model.py --model_path model --model_name facebook/opt-30b --revision main

Laden Sie abschließend die Modellartefakte zu einem Amazon S3 Bucket hoch.

aws s3 cp opt {your_s3_bucket}/opt --recursive

Sie sollten jetzt Modellartefakte in Amazon S3 gespeichert haben, die für die Bereitstellung auf einem SageMaker KI-Endpunkt bereit sind.

Stellen Sie das Modell mithilfe des SageMaker Python-SDK bereit

Nachdem Sie Ihre Modellartefakte vorbereitet haben, können Sie Ihr Modell auf einem SageMaker AI Hosting-Endpunkt bereitstellen. In diesem Abschnitt wird beschrieben, wie Sie ein einzelnes großes Modell auf einem Endpunkt bereitstellen und Streaming-Antwortprognosen erstellen. Weitere Informationen zum Streamen von Antworten von Endpunkten finden Sie unter Echtzeit-Endpunkte aufrufen.

Führen Sie die folgenden Schritte aus, um Ihr Modell bereitzustellen:

Sie haben Ihr Modell jetzt auf einem SageMaker KI-Endpunkt bereitgestellt und sollten in der Lage sein, es für Antworten aufzurufen. Weitere Informationen zu SageMaker KI-Echtzeit-Endpunkten finden Sie unter. Single-model Endpunkte