Déployez Falcon-40B avec des DLC d’inférence de modèles volumineux sur Amazon SageMaker.

Deploy Falcon-40B with large model inference DLCs on Amazon SageMaker.

La semaine dernière, l’Institut d’innovation technologique (TII) a lancé TII Falcon LLM, un modèle de langage large (LLM) open-source. Entraîné sur 1 billion de tokens avec Amazon SageMaker, Falcon offre des performances de premier ordre (en tête du classement Hugging Face au moment de la rédaction) tout en étant relativement léger et moins cher à héberger que d’autres LLMs tels que llama-65B. Dans cet article, nous montrons comment déployer Falcon pour des applications telles que la compréhension du langage et l’aide à l’écriture automatisée en utilisant des conteneurs d’apprentissage en profondeur pour l’inférence de modèles de grande taille sur SageMaker.

Le Falcon a atterri sur SageMaker

TII est l’organisme de recherche appliquée du Conseil de recherche sur les technologies avancées d’Abou Dhabi. Son équipe de scientifiques, de chercheurs et d’ingénieurs est dédiée à la découverte de technologies transformatrices et au développement de percées scientifiques qui permettront de future-proof notre société. Plus tôt cette année, TII a entrepris de former un LLM open-source de pointe et a utilisé l’infrastructure, les outils et l’expertise de SageMaker pour y parvenir (pour en savoir plus sur la façon dont ce modèle a été formé sur SageMaker, voir “Technology Innovation Institute trains the state-of-the-art Falcon LLM 40B foundation model on Amazon SageMaker”). Le résultat de cet effort est TII Falcon LLM.

Entraîné sur 1 billion de tokens, Falcon offre des performances de premier ordre contre l’Eleuther AI Language Model Evaluation Harness et est actuellement en tête du classement Hugging Face pour la précision. Le modèle est disponible en deux tailles différentes – Falcon-40B et Falcon-7B – et peut être utilisé pour des performances de pointe dans des applications telles que la compréhension du langage, les expériences conversationnelles et l’aide à l’écriture automatisée. Cet article vous aidera à démarrer avec le déploiement de Falcon sur SageMaker pour une inférence de haute précision dans ces types de domaines.

Les conteneurs d’apprentissage en profondeur pour l’inférence de modèles de grande taille sur SageMaker simplifient l’hébergement de LLM

L’hébergement de LLM tels que Falcon-40B et Falcon-7B peut être difficile. Les modèles plus grands sont souvent plus précis car ils incluent des milliards de paramètres, mais leur taille peut également entraîner une latence d’inférence plus lente ou un débit inférieur. L’hébergement d’un LLM peut nécessiter plus de mémoire GPU et des noyaux optimisés pour atteindre des performances acceptables. Pour compliquer les choses, bien que des modèles plus petits tels que Falcon-7B puissent généralement s’adapter à une seule GPU telle qu’une instance NVIDIA A10G qui alimente les types d’instances AWS G5, des modèles plus grands comme Falcon-40B ne le peuvent pas. Lorsque cela se produit, des stratégies telles que la parallélisme de tenseur doivent être utilisées pour fragmenter ce modèle plus grand en plusieurs morceaux et profiter de la mémoire de plusieurs GPU. Les solutions d’hébergement héritées utilisées pour les modèles plus petits ne proposent généralement pas ce type de fonctionnalité, ce qui ajoute à la difficulté.

• Comment BrainPad favorise le partage interne de connaissances avec Amazon Kendra
• Comment Forethought économise plus de 66% sur les coûts des modèles d’IA générative en utilisant Amazon SageMaker
• AI Time Journal présente un eBook révolutionnaire sur les tendances de l’IA en 2023.

Les conteneurs d’apprentissage en profondeur pour l’inférence de modèles de grande taille (DLC) de SageMaker peuvent aider. Les DLC d’inférence de modèles de grande taille sont une solution complète de bout en bout pour l’hébergement de LLM tels que Falcon-40B. À l’avant, ils incluent un serveur de modèle haute performance (DJL Serving) conçu pour l’inférence de modèles de grande taille avec des fonctionnalités telles que le streaming de jetons et la réplication automatique de modèles dans une instance pour augmenter le débit. À l’arrière, les DLC d’inférence de modèles de grande taille incluent également plusieurs moteurs de parallélisme de modèle haute performance, tels que DeepSpeed et FasterTransformer, qui peuvent fragmenter et gérer les paramètres de modèle sur plusieurs GPU. Ces moteurs incluent également des noyaux optimisés pour les modèles de transformateurs populaires, ce qui peut accélérer l’inférence jusqu’à trois fois plus vite. Avec les DLC d’inférence de modèles de grande taille, il vous suffit de créer un fichier de configuration pour commencer à héberger LLM sur SageMaker. Pour en savoir plus sur les DLC d’inférence de modèles de grande taille de SageMaker, voir “Model parallelism and large model inference” et notre liste d’images disponibles . Vous pouvez également consulter notre précédent article sur l’hébergement de Bloom-175B sur SageMaker en utilisant les DLC d’inférence de modèles de grande taille.

Aperçu de la solution

Cet article vous guide à travers la façon d’héberger Falcon-40B en utilisant DeepSpeed sur SageMaker en utilisant les DLC d’inférence de modèles de grande taille. Falcon-40B nécessite que nous utilisions plusieurs GPU A10, tandis que Falcon-7B n’en nécessite qu’un seul. Nous avons également préparé des exemples que vous pouvez utiliser pour héberger Falcon-40B et Falcon-7B en utilisant à la fois DeepSpeed et Accélérate. Vous pouvez trouver nos exemples de code sur GitHub.

Cet exemple peut être exécuté dans des instances de cahiers SageMaker ou des cahiers Amazon SageMaker Studio. Pour héberger Falcon-40B en utilisant LMI et DeepSpeed, nous devons utiliser une instance ml.g5.24xlarge. Ces instances fournissent 4 GPU NVIDIA A10G, chacun prenant en charge 96 GiB de mémoire GPU. De plus, l’hôte fournit 96 vCPU et 384 GiB de mémoire d’hôte. Le conteneur LMI aidera à traiter une grande partie du levage lourd non différencié associé à l’hébergement de LLM, y compris le téléchargement du modèle et la partition de l’artefact de modèle de sorte que ses paramètres constitutifs puissent être répartis sur plusieurs GPU.

Les quotas pour les instances d’apprentissage automatique (ML) SageMaker peuvent varier entre les comptes. Si vous recevez une erreur indiquant que vous avez dépassé votre quota pour les instances g5.24xlarge tout en suivant ce post, vous pouvez augmenter la limite via la console Service Quotas.

Parcours de carnet

Pour commencer, nous commençons par installer et importer les dépendances nécessaires pour notre exemple. Nous utilisons le SDK Boto3 ainsi que le SDK SageMaker. Notez que nous utilisons Amazon Simple Storage Service (Amazon S3) pour stocker les artefacts de modèle dont nous avons besoin pour que SageMaker et LMI les utilisent, nous configurons donc une variable de préfixe S3 en conséquence. Voyez le code suivant:

import sagemaker
import jinja2
from sagemaker import image_uris
import boto3
import os
import time
import json
from pathlib import Path
from sagemaker.utils import name_from_base

role = sagemaker.get_execution_role()  # rôle d'exécution pour l'endpoint
sess = sagemaker.session.Session()  # session SageMaker pour interagir avec différentes API AWS
bucket = sess.default_bucket()  # seau pour abriter les artefacts
model_bucket = sess.default_bucket()  # seau pour abriter les artefacts
s3_code_prefix_deepspeed = "hf-large-model-djl-/code_falcon40b/deepspeed"  # dossier dans le seau où l'artefact de code ira
region = sess._region_name
account_id = sess.account_id()
s3_client = boto3.client("s3")
sm_client = boto3.client("sagemaker")
smr_client = boto3.client("sagemaker-runtime")
jinja_env = jinja2.Environment()

Nous créons ensuite un dossier local pour notre espace de travail afin de stocker nos artefacts de modèle:

!mkdir -p code_falcon40b_deepspeed

Nous créons d’abord un fichier de configuration serving.properties dans le répertoire local que nous avons créé. Ce fichier serving.properties indique au conteneur LMI et à la bibliothèque de serveur DJL front-end quelle moteur de parallélisation de modèle et d’optimisation d’inférence nous voulons utiliser. Vous pouvez trouver les options de configuration pour DeepSpeed et Hugging Face Accelerate dans Configurations et paramètres. Ici, notez que nous définissons le paramètre option.model_id pour définir le modèle Hugging Face à extraire. SageMaker facilite le travail avec les modèles Hugging Face, et cette seule ligne suffit. De plus, nous avons défini option.tensor_parallel_degree sur une valeur de 4 car nous avons quatre GPU sur notre instance ml.g5.24xlarge. Ce paramètre définit le nombre de partitions du modèle à créer et à distribuer. Notez que si nous avions utilisé une instance plus grande avec huit GPU, comme ml.g5.48xlarge, et que nous avions encore défini une valeur de 4, alors LMI créerait automatiquement deux répliques du modèle (deux répliques réparties sur quatre GPU chacune). Voyez le code suivant:

%%writefile ./code_falcon40b_deepspeed/serving.properties
engine=Python
#pour déployer falcon-40b-instruct, réglez la valeur model_id sur 'tiiuae/falcon-40b-instruct'
option.model_id=tiiuae/falcon-40b
option.tensor_parallel_degree=4
#option.s3url = {{s3url}}

Vous pouvez également remplacer tiiuae/falcon-40b par tiiuae/falcon-40b-instruct si cela convient mieux à vos besoins.

Nous incluons également un fichier requirements.txt que vous pouvez spécifier pour installer les packages dont vous avez besoin:

%%writefile ./code_falcon40b_deepspeed/requirements.txt
einops
torch==2.0.1

La dernière chose dont nous avons besoin est le fichier model.py qui sera utilisé avec votre modèle:

%%writefile ./code_falcon40b_deepspeed/model.py
from djl_python import Input, Output
import os
import torch
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
from typing import Any, Dict, Tuple
import warnings

predictor = None


def get_model(properties):
    model_name = properties["model_id"]
    local_rank = int(os.getenv("LOCAL_RANK", "0"))
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        low_cpu_mem_usage=True,
        trust_remote_code=True,
        torch_dtype=torch.bfloat16,
        device_map="auto",
    )
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    generator = pipeline(
        task="text-generation", model=model, tokenizer=tokenizer, device_map="auto"
    )
    return generator


def handle(inputs: Input) -> None:
    global predictor
    if not predictor:
        predictor = get_model(inputs.get_properties())
    if inputs.is_empty():
        # Le serveur de modèle effectue un appel vide pour réchauffer le modèle au démarrage
        return None
    data = inputs.get_as_json()
    text = data["text"]
    text_length = data["text_length"]
    outputs = predictor(text, do_sample=True, min_length=text_length, max_length=text_length)
    result = {"outputs": outputs}
    return Output().add_as_json(result)

C’est tout! À ce stade, nous avons créé tous les artefacts dont vous aurez besoin pour déployer Falcon-40B avec DeepSpeed! Nous empaquetons le répertoire dans un fichier *.tar.gz et le téléchargeons sur Amazon S3. Notez que le modèle réel n’a pas été téléchargé ni empaqueté dans ce fichier. Le conteneur LMI téléchargera le modèle pour vous directement depuis Hugging Face. Vous avez également la possibilité de cibler un bucket S3 si vous souhaitez avoir votre propre copie du modèle dans un emplacement qui sera plus performant à télécharger. LMI inclut également une optimisation pour le téléchargement à partir d’Amazon S3 avec une haute performance. Voir le code suivant:

s3_code_artifact_deepspeed = sess.upload_data("model.tar.gz", bucket, s3_code_prefix_deepspeed)
print(f"S3 Code ou modèle tar pour deepspeed téléchargé vers --- > {s3_code_artifact_deepspeed}")

Tout ce qu’il reste à faire à ce stade est de définir le conteneur que nous voulons utiliser et de créer un objet de modèle:

inference_image_uri = (
    f"763104351884.dkr.ecr.{region}.amazonaws.com/djl-inference:0.22.1-deepspeed0.8.3-cu118"
)
model_name_acc = name_from_base(f"falcon40b-model-ds")
create_model_response = sm_client.create_model(
    ModelName=model_name_acc,
    ExecutionRoleArn=role,
    PrimaryContainer={"Image": inference_image_uri, "ModelDataUrl": s3_code_artifact_deepspeed},
)
model_arn = create_model_response["ModelArn"]

Ensuite, nous créons une configuration de point de terminaison et créons le point de terminaison:

endpoint_config_name = f"{model_name}-config"
endpoint_name = f"{model_name}-endpoint"
endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.g5.24xlarge",
            "InitialInstanceCount": 1,
            "ModelDataDownloadTimeoutInSeconds": 3600,
            "ContainerStartupHealthCheckTimeoutInSeconds": 3600,
            # "VolumeSizeInGB": 512
        },
    ],
)
endpoint_config_response

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=f"{endpoint_name}", EndpointConfigName=endpoint_config_name
)
print(f"Endpoint créé: {create_endpoint_response['EndpointArn']}")

Éléments de configuration à prendre en compte pour un hébergement réussi

Une considération importante pour l’hébergement de grands modèles est de s’assurer qu’il y a suffisamment de temps pour le téléchargement du modèle depuis Hugging Face. Dans nos tests, le Falcon-40B a pris environ 90 minutes pour se télécharger sur l’instance. Un ensemble clé de configurations pour permettre cela est ContainerStartupHealthCheckTimeoutInSeconds et ModelDataDownloadTimeoutInSeconds. Assurez-vous que la configuration du point de terminaison SageMaker a une valeur de 3600 pour chacun de ces éléments. De plus, il est beaucoup plus facile de télécharger depuis Amazon S3 au lieu du modèle original zoo en utilisant les conteneurs LMI qui sont spécialement conçus pour les LLMS qui utilisent l’utilitaire S5cmd, ce qui réduit le temps de téléchargement du modèle à environ 10 minutes.

Vous pouvez surveiller l’état du point de terminaison en appelant DescribeEndpoint, qui vous indiquera quand tout est terminé. Votre point de terminaison est maintenant prêt à répondre aux demandes d’inférence! Comme LMI gère la partition et l’orchestration du modèle pour vous, chaque demande sera traitée en utilisant les 4 GPU disponibles sur notre instance ml.g5.12xlarge. Cela nous permet d’héberger des LLMS et d’augmenter les performances si vous mettez à l’échelle les accélérateurs GPU horizontalement. Voir le code suivant:

response_model = smr_client.invoke_endpoint(
    EndpointName=endpoint_name,
    Body=json.dumps({"text": "What is the purpose of life?", "text_length": 150}),
    ContentType="application/json",
)

response_model["Body"].read().decode("utf8")

Si vous avez terminé et souhaitez supprimer la configuration du point de terminaison, le point de terminaison et l’objet de modèle, vous pouvez exécuter les commandes suivantes:

sm_client.delete_endpoint(EndpointName=endpoint_name)
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)

Le code que nous avons référencé dans cet article peut être trouvé dans le notebook complet sur GitHub.

Conclusion

L’hébergement SageMaker et le LMI DLC facilitent l’hébergement de LLMS tels que Falcon-40B. Il prend en charge le levage lourd indifférencié en orchestrant ce qui est nécessaire pour héberger des modèles sur plusieurs GPU et offre des options configurables pour répondre à vos besoins. De plus, l’utilisation de modèles Hugging Face devient très simple, avec une prise en charge intégrée de ces modèles.

Dans cet article, nous avons montré comment vous pouvez utiliser SageMaker pour héberger le modèle Falcon-40B en utilisant DeepSpeed. De plus, nous avons fourni des exemples sur GitHub pour héberger Falcon-40B en utilisant Accelerate et les modèles plus petits Falcon-7B. Nous vous encourageons à essayer cela sur SageMaker avec LMI et à vous familiariser avec le LLM disponible publiquement le plus performant à ce jour !

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!