AlexaTM 20B est désormais disponible dans Amazon SageMaker JumpStart

Aujourd'hui, nous annonçons la disponibilité publique de l'état de l'art d'Amazon Alexa Teacher Model avec 20 milliards de paramètres  (AlexaTM 20B) via Amazon SageMaker JumpStart, le centre d'apprentissage automatique de SageMaker. AlexaTM 20B est un modèle de langage séquence à séquence à grande échelle (seq2seq) multilingue développé par Amazon. Vous pouvez utiliser AlexaTM 20B pour un large éventail de cas d'utilisation de l'industrie, de la synthèse des rapports financiers à la réponse aux questions pour les chatbots du service client. Il peut être appliqué même lorsqu'il n'y a que quelques exemples de formation disponibles, voire aucun. AlexaTM 20B surperforme un 175 milliards Modèle GPT-3 sur les tâches d'apprentissage zéro coup telles que SuperGLUE et affiche des performances de pointe pour les tâches zéro coup multilingues telles que XNLI.

Dans cet article, nous fournissons un aperçu de la façon de déployer et d'exécuter l'inférence avec le modèle AlexaTM 20B par programmation via les API JumpStart, disponibles dans le Kit de développement logiciel (SDK) SageMaker Python. Nous illustrons comment vous pouvez utiliser ce modèle pour traduire entre plusieurs langues, résumer un texte long, répondre à des questions basées sur un contexte donné et générer un texte qui semble impossible à distinguer du texte écrit par l'homme.

AlexaTM 20B et apprentissage en contexte

Le programme Alexa Teacher Model (AlexaTM) d'Amazon Alexa AI est conçu pour créer des modèles d'apprentissage en profondeur multilingues à grande échelle (principalement basés sur Transformer), visant à améliorer la généralisation et la gestion de la rareté des données pour les tâches en aval. Avec une pré-formation à grande échelle, les modèles d'enseignants peuvent bien se généraliser pour apprendre de nouvelles tâches à partir de données rares et aider les développeurs à améliorer les performances des tâches en aval. AlexaTM 20B a montré performances compétitives sur les points de repère et les tâches courants de traitement du langage naturel (TAL), tels que la traduction automatique, la génération de données et la synthèse.

L'utilisation de modèles de base tels que AlexaTM 20B réduit le besoin d'une pré-formation de modèle coûteuse et fournit un point de départ à la pointe de la technologie pour développer des modèles de tâches avec moins d'effort et moins de données de formation spécifiques à la tâche. L'une des principales capacités des modèles de base est que nous pouvons apprendre à un modèle à effectuer de nouvelles tâches telles que des questions et des réponses dans différentes langues, avec de très petites quantités d'exemples d'entrée et aucun réglage fin ou mise à jour de gradient requis. Ceci est connu comme apprentissage en contexte. Avec seulement quelques exemples d'une nouvelle tâche fournie comme contexte d'inférence, le modèle AlexaTM 20B peut transférer des connaissances à partir de ce qui a été appris lors d'une pré-formation à grande échelle, même dans plusieurs langues. C'est appelé apprentissage en quelques étapes. Dans certains cas, le modèle peut bien fonctionner sans aucune donnée de formation, avec seulement une explication de ce qui doit être prédit. C'est appelé apprentissage zéro coup. Par exemple, disons que nous utilisons AlexaTM 20B pour la génération de langage naturel en une seule fois. L'entrée transmise au modèle est l'exemple d'apprentissage sous la forme de paires attribut-valeur, ainsi que son texte de sortie correspondant. L'exemple de test est ensuite ajouté pour former l'invite de saisie complète, comme illustré dans la figure suivante.

Pour en savoir plus sur le modèle, consultez Le modèle Alexa à 20B paramètres établit de nouvelles marques dans l'apprentissage en quelques prises de vue ou l'original papier.

L'utilisation d'AlexaTM 20B est mise à disposition pour un usage non commercial et est couverte par la Contrat de licence du modèle Alexa Teacher.

Vue d'ensemble de la solution

Les sections suivantes fournissent une démonstration étape par étape sur la façon de déployer le modèle, d'exécuter l'inférence et d'effectuer un apprentissage en contexte pour résoudre des tâches d'apprentissage en quelques étapes.

Notez que la section suivante contient des extraits de code ; le code complet avec toutes les étapes de cette démo est disponible dans le cahier d'accompagnement : Apprentissage en contexte avec AlexaTM 20B dans SageMaker JumpStart.

Déployer le modèle

Pour utiliser un grand modèle de langage dans SageMaker, vous avez besoin d'un script d'inférence spécifique au modèle, qui comprend des étapes telles que le chargement du modèle, la parallélisation, etc. Vous devez également créer des tests de bout en bout pour les scripts, le modèle et les types d'instances souhaités afin de valider que les trois peuvent fonctionner ensemble. JumpStart supprime cet effort en fournissant des scripts prêts à l'emploi qui ont été rigoureusement testés.

SageMaker vous donne la possibilité d'exécuter de manière intensive des conteneurs Docker pour la formation et l'inférence. JumpStart utilise ces outils disponibles spécifiques au framework Conteneurs d'apprentissage en profondeur SageMaker (DLC). Nous commençons par récupérer le DLC optimisé (deploy_image_uri) en utilisant le model_id. Puis on va chercher le model_uri contenant les paramètres du modèle, ainsi que les scripts de gestion des inférences et toutes les dépendances associées. Ensuite, nous créons un instance de modèle dans SageMaker et déployez-le sur un point de terminaison en temps réel. Voir le code suivant :

# model_version="*" fetches the latest version of the model
model_id, model_version = "pytorch-textgeneration1-alexa20b", "*"

instance_type = "ml.g4dn.12xlarge"

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve(
    region=None,
    framework=None,  # automatically inferred from model_id
    image_scope="inference",
    model_id=model_id,
    model_version=model_version,
    instance_type=inference_instance_type,
)

# Retrieve the model uri. This includes the model parameters, all dependencies and scripts for model loading, inference handling etc.
 model_uri = model_uris.retrieve(
 model_id=model_id, 
 model_version=model_version, 
 model_scope="inference")

Le déploiement d'AlexaTM 20B nécessite une instance basée sur GPU avec au moins 50 Go de mémoire CPU et au moins 42 Go de mémoire GPU. SageMaker fournit de nombreuses instances de ce type qui prennent en charge l'inférence en temps réel. Nous avons testé cette solution sur trois instances : ml.g4dn.12xlarge, ml.p3.8xlarge, ml.p3.16xlarge. Voir le code suivant :

env = {
        "SAGEMAKER_MODEL_SERVER_TIMEOUT": str(3600),
        "MODEL_CACHE_ROOT": "/opt/ml/model",
        "SAGEMAKER_ENV": "1",
        "SAGEMAKER_SUBMIT_DIRECTORY":"/opt/ml/model/code/",
        "SAGEMAKER_PROGRAM": "inference.py",
        "SAGEMAKER_MODEL_SERVER_WORKERS": "1", # One worker for the endpoint rather than one worker per GPU by default
        "TS_DEFAULT_WORKERS_PER_MODEL":"1" # 1 TS worker which allocates all memory to the single master worker.
    }
    
#Create the SageMaker model instance. Note that we need to pass Predictor class when we deploy model through Model class,
#for being able to run inference through the sagemaker API.
model = Model(
    image_uri=deploy_image_uri,
    model_data=model_uri,
    role=aws_role,
    predictor_cls=Predictor,
    name=endpoint_name,
    env=env
)

Ensuite, nous déployons le modèle sur un point de terminaison en temps réel SageMaker :

# deploy the Model.
model_predictor = model.deploy(
    initial_instance_count=1,
    instance_type=instance_type,
    endpoint_name=endpoint_name,
    volume_size= volume_size, # Specify the size of the Amazon EBS volume in GBs.
    model_data_download_timeout = 3600, # Specify the model download timeout in seconds.
    container_startup_health_check_timeout = 3600, # Specify the health checkup timeout in seconds
)

AlexaTM 20B nécessite 40 Go d'espace disque dans le conteneur d'inférence. Une instance ml.g4dn.12xlarge répond à cette exigence. Pour les types d'instance ml.p3.8xlarge et ml.p3.16xlarge, nous attachons un Boutique de blocs élastiques Amazon (Amazon EBS) pour gérer la grande taille du modèle. Par conséquent, nous fixons volume_size = None lors du déploiement sur ml.g4dn.12xlarge et volume_size=256 lors du déploiement sur ml.p3.8xlarge ou ml.p3.16xlarge.

Le déploiement du modèle peut prendre jusqu'à 10 minutes. Une fois le modèle déployé, nous pouvons en tirer des prédictions en temps réel !

Exécuter l'inférence

AlexaTM 20B est un modèle de génération de texte qui, à partir d'une séquence partielle (une phrase ou un morceau de texte), génère l'ensemble de mots suivant. L'extrait de code suivant vous donne un aperçu de la façon d'interroger le point de terminaison que nous avons déployé et d'analyser les sorties pour la tâche d'auto-complétion. Pour envoyer des requêtes à un modèle déployé, nous utilisons un dictionnaire JSON encodé au format UTF-8. La réponse du point de terminaison est un objet JSON contenant une liste de textes générés.

def query(model_predictor, text, kwargs = None):
    """Query the model predictor."""

    payload = {"text_inputs": text}
    if kwargs is not None:
        payload.update(kwargs)
        
    encoded_inp = json.dumps(payload).encode("utf-8")

    query_response = model_predictor.predict(
        encoded_inp,
        {
            "ContentType": "application/json",
            "Accept": "application/json",
        },
    )
    return query_response
 
def parse_response(query_response):
    """Parse response and return the generated texts."""

    model_predictions = json.loads(query_response)
    generated_texts = model_predictions["generated_texts"]
    return generated_texts

Ensuite, nous interrogeons le point de terminaison et analysons la réponse sur un exemple de texte d'entrée :

# text can be a single string or a list of strings
text = “[CLM]My name is Lewis and I like to"
kwargs = {"num_beams": 5, "no_repeat_ngram_size": 2, “max_length”: 50}
query_response = query_endpoint(model_predictor, text, kwargs)
generated_texts = parse_response(query_response)

Generated_texts: “travel and meet new people. I have been to many countries and I like to meet people from all over the world. If you are interested in meeting me, please feel free to send me a message and we can arrange a meeting.”

AlexaTM 20B prend actuellement en charge 10 paramètres de génération de texte lors de l'inférence : max_length, num_return_sequences, num_beams, no_repeat_ngram_size, temperature, early_stopping, do_sample, top_k, top_pet seed. Pour des informations détaillées sur les valeurs valides pour chaque paramètre et leur impact sur la sortie, consultez le bloc-notes d'accompagnement : Apprentissage en contexte avec AlexaTM 20B dans SageMaker JumpStart.

Apprentissage en contexte

L'apprentissage en contexte fait référence à ce qui suit : nous fournissons au modèle de langage une invite, qui consiste à former des paires entrée-sortie qui démontrent la tâche. Nous ajoutons une entrée de test à l'invite et permettons au modèle de langage de faire des prédictions en conditionnant l'invite et en prédisant les jetons ou mots suivants. Il s'agit d'une technique très efficace pour résoudre quelques problèmes d'apprentissage par tir, dans laquelle nous apprenons une tâche à partir de quelques échantillons d'apprentissage.

Ensuite, nous montrons comment vous pouvez utiliser AlexaTM 20B pour plusieurs tâches 1-shot et zero-shot via l'apprentissage en contexte. Contrairement aux modèles séquence-à-séquence précédents, AlexaTM 20B a été formé sur la modélisation causale du langage en plus du débruitage, ce qui en fait un bon modèle pour l'apprentissage en contexte.

Résumé de texte en une seule fois

Le résumé de texte consiste à raccourcir les données et à créer un résumé qui représente les informations les plus importantes présentes dans le texte original. Le résumé de texte en une seule fois fait référence au cadre dans lequel nous apprenons à résumer le texte sur la base d'un seul échantillon d'apprentissage. Le code suivant est un exemple de résumé de texte du Jeu de données XSUM:

train_article = "The announcement ends months of uncertainty for Cornish Language Partnership staff whose contracts had been due to end. Local government minister Andrew Stunnell said the three-year funding package for the service would help make sure the language survived. But he warned that long term funding should come from Cornwall. He said it was "important to make sure the Cornish were given the opportunity to put down sound foundations." "In the longer term support for the Cornish language is going to be something which is going to have to be based in Cornwall and will not come from London," he added. The Cornish Language Partnership's, Jennifer Lowe, said: "We can now plan for the future thanks to the funding." The United Nations recently upgraded the status of the Cornish language from "extinct" to "critically endangered". It is thought fewer than 500 people worldwide are fluent in the language.""
                
train_summary = "The government is spending nearly £400,000 to help save the Cornish language."

test_article = "Torrents of water brought down a suspended ceiling and damaged stock "
                "in the Victoria Centre store at about 22:40 BST on Tuesday. Managers "
                "had hoped for a weekend reopening but it is now closed "until "
                "further notice". Staff have been helping with the clean-up "
                "operation. Water poured through from a rooftop room, leaving the "
                "top floor under three inches of water and stock "significantly" "
                "damaged. A spokeswoman said: "Our teams are working around the "
                "clock to get the shop open as quickly as possible and we're sorry "
                "for the inconvenience this has caused to our customers.""

Nous utilisons l'invite suivante pour le résumé lorsqu'un seul échantillon d'apprentissage est fourni. Le texte généré à partir du modèle est interprété comme le résumé prédit de l'article de test.

La sortie est la suivante:

AlexaTM 20B output: 'The top floor of a London department store has been flooded.'

Génération de langage naturel en 1 coup

La génération de langage naturel est la tâche de produire des récits de texte compte tenu du texte d'entrée. L'exemple suivant montre un exemple d'apprentissage de la Jeu de données E2E:

train_inp = "name[The Punter], food[Indian], priceRange[cheap]"
train_out = "The Punter provides Indian food in the cheap price range."

test_inp = "name[Blue Spice], eatType[coffee shop], area"

Nous utilisons l'invite suivante pour la génération du langage naturel lorsqu'un seul échantillon d'apprentissage (1 coup) est fourni. Le texte généré à partir du modèle est interprété comme le texte narratif prédit pour l'entrée de test (test_inp).

La sortie est la suivante:

AlexaTM 20B output: 'Blue Spice is a coffee shop in the city centre. '

Traduction automatique en 1 coup

La traduction automatique consiste à traduire un texte d'une langue à une autre. L'exemple suivant montre un exemple d'apprentissage de la Jeu de données WMT19 dans lequel nous devons traduire de l'allemand vers l'anglais :

train_inp = "Das Parlament erhebt sich zu einer Schweigeminute."
train_out = "The House rose and observed a minute' s silence"

test_inp = "Kleingärtner bewirtschaften den einstigen Grund von Bauern."

Nous utilisons l'invite suivante pour la traduction automatique lorsqu'un seul échantillon d'apprentissage (1-shot) est fourni. Le texte généré à partir du modèle est interprété comme la traduction de l'entrée de test (test_inp).

La sortie est la suivante:

AlexaTM 20B translation: 'Gardeners cultivate the former land of farmers.'

Réponse aux questions extractives sans coup sûr

La réponse à une question extractive consiste à trouver la réponse à une question à partir du paragraphe de contexte. Voici un exemple de contexte et une question de la Jeu de données SQuAD v2:

test_context = "The Normans (Norman: Nourmands; French: Normands; Latin: Normanni) were the people who in the 10th and 11th centuries gave their name to Normandy, a region in France. They were descended from Norse ("Norman" comes from "Norseman") raiders and pirates from Denmark, Iceland and Norway who, under their leader Rollo, agreed to swear fealty to King Charles III of West Francia. Through generations of assimilation and mixing with the native Frankish and Roman-Gaulish populations, their descendants would gradually merge with the Carolingian-based cultures of West Francia. The distinct cultural and ethnic identity of the Normans emerged initially in the first half of the 10th century, and it continued to evolve over the succeeding centuries."
test_question = "In what country is Normandy located?"

Notez que nous n'avons pas d'échantillons d'entraînement pour notre tâche. Au lieu de cela, nous créons une question fictive sur le dernier mot de l'invite , basée sur le test_context (photo factice). Par conséquent, nous répondons en fait à des questions extractives sans coup sûr.

Nous utilisons l'invite suivante pour répondre aux questions extractives lorsqu'aucun échantillon d'apprentissage n'est fourni. Le texte généré à partir du modèle est interprété comme la réponse à la question du test.

La sortie est la suivante:

AlexaTM 20B output: 'France'

Ingénierie rapide

L'ingénierie rapide peut parfois être un art. Même de petites modifications apportées au modèle d'invite peuvent entraîner des modifications importantes des performances du modèle sur une tâche spécifique. Voici quelques conseils pour rédiger de bons modèles d'invite. Tout d'abord, il est important de se rappeler que le modèle a été formé pour apprendre la structure de phrases réelles (modélisation causale du langage). En tant que tel, il est préférable de vous assurer que votre modèle d'invite est grammaticalement et structurellement correct en langage naturel. Deuxièmement, ce modèle particulier bénéficie de plans factices pour aider à lui enseigner la structure attendue dans la réponse, comme démontré ci-dessus. Troisièmement, il est toujours conseillé d'examiner les performances des tâches sur une variété de modèles d'invite candidats. Source d'invite ainsi que  Consignes Naturelles sont deux frameworks open source pour standardiser les modèles d'invites, et ils fournissent une variété d'exemples d'invites utilisées pour les tâches de modélisation existantes. De plus, l'annexe B de la Papier AlexaTM 20B fournit les modèles d'invite utilisés pour générer les résultats présentés dans le document. Il existe un sous-domaine en pleine croissance dédié à la création et à l'apprentissage automatiques des meilleures invites pour une tâche, y compris le langage naturel et les invites continues. Cela dépasse le cadre de ce tutoriel.

Conclusion

Dans cet article, nous avons montré comment déployer le modèle AlexaTM 20B sur un point de terminaison SageMaker et exécuter l'inférence. Vous pouvez utiliser le modèle AlexaTM 20B pour un apprentissage en contexte pour une variété de tâches d'apprentissage en quelques coups. Pour en savoir plus sur AlexaTM 20B, consultez Le modèle Alexa à 20B paramètres établit de nouvelles marques dans l'apprentissage en quelques prises de vue ou l'original papier.

Les auteurs tiennent à remercier les contributions techniques de Maciej Rudnicki, Jakub Debski, Ashish Khetan, Anastasiia Dubinina, Vitaliy Korolev, Karl Albertsen, Saleh Soltan et Mariusz Momotko pour rendre ce lancement possible.

À propos de JumpStart

JumpStart est le hub d'apprentissage automatique (ML) d'Amazon SageMaker qui propose plus de 350 modèles pré-formés, des algorithmes intégrés et des modèles de solutions prédéfinis pour vous aider à démarrer rapidement avec ML. JumpStart héberge des modèles de pointe à partir de hubs de modèles populaires tels que TensorFlow, PyTorch, Hugging Face et MXNet, qui prennent en charge les tâches ML populaires telles que la détection d'objets, la classification de texte et la génération de texte. La communauté des chercheurs en ML a déployé des efforts considérables pour rendre la majorité des modèles récemment développés accessibles au public. JumpStart vise à vous aider à trouver les bons modèles et algorithmes ML, et à commencer immédiatement à créer des modèles. Plus précisément, JumpStart offre les avantages suivants :

• Accès facile avec l'interface utilisateur et le SDK – Vous pouvez accéder aux modèles et aux algorithmes dans JumpStart par programmation à l'aide du SDK Python SageMaker ou via l'interface utilisateur JumpStart dans Amazon SageMaker Studio. Actuellement, AlexaTM 20B n'est accessible que via le SDK SageMaker Python.
• Algorithmes intégrés SageMaker - JumpStart fournit plus de 350 algorithmes intégrés et modèles pré-formés, ainsi que des scripts de formation correspondants (si pris en charge), des scripts d'inférence et des exemples de blocs-notes. Les scripts sont optimisés pour chaque framework et tâche, et fournissent des fonctionnalités telles que la prise en charge du GPU, le réglage automatique du modèle et la formation incrémentielle. Les scripts sont également testés par rapport aux instances et aux fonctionnalités de SageMaker afin que vous ne rencontriez pas de problèmes de compatibilité.
• Solutions prédéfinies - JumpStart fournit un ensemble de 23 solutions pour les cas d'utilisation courants de ML, tels que la prévision de la demande et les applications industrielles et financières, que vous pouvez déployer en quelques clics. Les solutions sont des applications ML de bout en bout qui regroupent divers services AWS pour résoudre un cas d'utilisation métier particulier. Ils utilisent des modèles et des architectures de référence AWS CloudFormation pour un déploiement rapide, ce qui signifie qu'ils sont entièrement personnalisables.
• Assistance - SageMaker fournit une gamme d'assistance, telle que la mise à jour des versions lorsque de nouvelles fonctionnalités SageMaker ou des versions Deep Learning Container sont publiées, et la création de documentation sur l'utilisation du contenu JumpStart dans un environnement SageMaker.

Pour en savoir plus sur JumpStart et sur la façon dont vous pouvez utiliser des modèles pré-formés open source pour une variété d'autres tâches de ML, consultez ce qui suit Vidéo AWS re:Invent 2020.

À propos des auteurs

Dr Vivek Madan est un scientifique appliqué au sein de l'équipe Amazon SageMaker JumpStart. Il a obtenu son doctorat à l'Université de l'Illinois à Urbana-Champaign et a été chercheur postdoctoral à Georgia Tech. Il est un chercheur actif en apprentissage automatique et en conception d'algorithmes et a publié des articles dans les conférences EMNLP, ICLR, COLT, FOCS et SODA.

Jack Fitz Gerald est un scientifique appliqué senior chez Alexa AI, où il se concentre actuellement sur la modélisation de grands langages, la modélisation de textes multilingues et les opérations d'apprentissage automatique.

Joao Moura est architecte de solutions spécialisées en IA/ML chez Amazon Web Services. Il se concentre principalement sur les cas d'utilisation du NLP et aide les clients à optimiser la formation et le déploiement de modèles d'apprentissage en profondeur. Il est également un partisan actif des solutions ML low-code et du matériel spécialisé ML.

Juin gagné est chef de produit avec SageMaker JumpStart et les algorithmes intégrés. Il se concentre sur la création de contenus ML facilement détectables et utilisables pour les clients SageMaker.

Pulkit Kapur est le chef de produit du programme Alexa Teacher Model avec Alexa AI, qui se concentre sur l'intelligence généralisée et les applications des modèles de base multitâches multimodaux d'Alexa.