Adaptation au domaine Ajustement des modèles de base dans Amazon SageMaker JumpStart sur les données financières

Les grands modèles de langage (LLM) avec des milliards de paramètres sont actuellement à la pointe du traitement du langage naturel (TAL). Ces modèles bouleversent le domaine avec leurs incroyables capacités à générer du texte, à analyser les sentiments, à traduire les langues et bien plus encore. Avec un accès à des quantités massives de données, les LLM ont le potentiel de révolutionner la façon dont nous interagissons avec le langage. Bien que les LLM soient capables d'effectuer diverses tâches de PNL, ils sont considérés comme des généralistes et non des spécialistes. Afin de former un LLM pour devenir un expert dans un domaine particulier, un ajustement est généralement nécessaire.

L'un des principaux défis de la formation et du déploiement de LLM avec des milliards de paramètres est leur taille, ce qui peut rendre difficile leur intégration dans des GPU uniques, le matériel couramment utilisé pour l'apprentissage en profondeur. L'ampleur de ces modèles nécessite des ressources de calcul hautes performances, telles que des GPU spécialisés dotés de grandes quantités de mémoire. De plus, la taille de ces modèles peut les rendre coûteux en termes de calcul, ce qui peut augmenter considérablement les temps d'apprentissage et d'inférence.

Dans cet article, nous montrons comment nous pouvons utiliser Amazon SageMaker JumpStart pour affiner facilement un modèle de génération de texte de grande langue sur un ensemble de données spécifique à un domaine de la même manière que vous entraîneriez et déploieriez n'importe quel modèle sur Amazon Sage Maker. En particulier, nous montrons comment vous pouvez affiner le modèle de langage GPT-J 6B pour la génération de texte financier en utilisant à la fois le SDK JumpStart et Amazon SageMakerStudio Interface utilisateur sur un ensemble de données accessible au public des dépôts auprès de la SEC.

JumpStart vous aide à démarrer rapidement et facilement avec l'apprentissage automatique (ML) et fournit un ensemble de solutions pour les cas d'utilisation les plus courants qui peuvent être formés et déployés facilement en quelques étapes seulement. Toutes les étapes de cette démo sont disponibles dans le cahier d'accompagnement Ajustement du modèle de génération de texte GPT-J 6B sur un ensemble de données spécifique à un domaine.

Vue d'ensemble de la solution

Dans les sections suivantes, nous fournissons une démonstration étape par étape pour affiner un LLM pour les tâches de génération de texte via l'interface utilisateur JumpStart Studio et Python SDK. Nous abordons notamment les sujets suivants :

• Un aperçu des données de dépôt auprès de la SEC dans le domaine financier sur lesquelles le modèle est affiné
• Un aperçu du modèle LLM GPT-J 6B que nous avons choisi d'affiner
• Une démonstration de deux façons différentes d'affiner le LLM à l'aide de JumpStart :
  • Utiliser JumpStart par programmation avec le SDK SageMaker Python
  • Accéder à JumpStart à l'aide de l'interface utilisateur de Studio
• Une évaluation du modèle affiné en le comparant avec le modèle pré-entraîné sans ajustement fin

Le réglage fin fait référence au processus consistant à prendre un modèle de langage pré-formé et à le former pour une tâche différente mais connexe à l'aide de données spécifiques. Cette approche est également connue sous le nom de transférer l'apprentissage, qui consiste à transférer les connaissances acquises d'une tâche à une autre. Les LLM comme GPT-J 6B sont formés sur des quantités massives de données non étiquetées et peuvent être affinés sur des ensembles de données plus petits, ce qui rend le modèle plus performant dans un domaine spécifique.

Pour illustrer comment les performances s'améliorent lorsque le modèle est affiné, envisagez de lui poser la question suivante :

« Qu'est-ce qui stimule la croissance des ventes chez Amazon ? »

Sans ajustement, la réponse serait :

« Amazon est le plus grand détaillant en ligne au monde. C'est aussi la plus grande place de marché en ligne au monde. C'est aussi le monde"

Avec un réglage fin, la réponse est :

"La croissance des ventes chez Amazon est principalement due à l'utilisation accrue des clients, y compris une sélection accrue, des prix plus bas, une commodité accrue et une augmentation des ventes par d'autres vendeurs sur nos sites Web."

L'amélioration du réglage fin est évidente.

Nous utilisons le texte financier des dépôts auprès de la SEC pour affiner un GPT-J 6B LLM pour les applications financières. Dans les sections suivantes, nous introduisons les données et le LLM qui seront affinés.

Ensemble de données de dépôt auprès de la SEC

Les documents déposés auprès de la SEC sont essentiels pour la réglementation et la divulgation dans le domaine financier. Les dépôts informent la communauté des investisseurs sur les conditions commerciales des entreprises et les perspectives d'avenir des entreprises. Le texte des documents déposés auprès de la SEC couvre toute la gamme des opérations et des conditions commerciales d'une entreprise. En raison de leur valeur prédictive potentielle, ces dépôts sont de bonnes sources d'information pour les investisseurs. Bien que ces dépôts auprès de la SEC soient Disponible publiquement pour quiconque, télécharger des fichiers analysés et construire un ensemble de données propre avec des fonctionnalités supplémentaires est un exercice qui prend du temps. Nous rendons cela possible en quelques appels d'API dans le JumpStart SDK de l'industrie.

À l'aide de l'API SageMaker, nous avons téléchargé les rapports annuels (Dépôts 10-K; voir Comment lire un 10-K pour plus d'informations) pour un grand nombre d'entreprises. Nous sélectionnons les rapports de dépôt SEC d'Amazon pour les années 2021-2022 comme données de formation pour affiner le modèle GPT-J 6B. En particulier, nous concaténons les rapports de dépôt auprès de la SEC de la société au cours de différentes années dans un seul fichier texte, à l'exception de la section « Discussion et analyse de la direction », qui contient des déclarations prospectives de la direction de la société et sont utilisées comme données de validation.

On s'attend à ce qu'après avoir affiné le modèle de génération de texte GPT-J 6B sur les documents SEC financiers, le modèle soit capable de générer une sortie textuelle pertinente liée aux finances et puisse donc être utilisée pour résoudre plusieurs tâches NLP spécifiques à un domaine.

Grand modèle de langage GPT-J 6B

GPT-J6B est un modèle open source de 6 milliards de paramètres publié par Eleuther AI. GPT-J 6B a été formé sur un grand corpus de données textuelles et est capable d'effectuer diverses tâches NLP telles que la génération de texte, la classification de texte et la synthèse de texte. Bien que ce modèle soit impressionnant sur un certain nombre de tâches NLP sans nécessiter de réglage fin, dans de nombreux cas, vous devrez affiner le modèle sur un ensemble de données et des tâches NLP spécifiques que vous essayez de résoudre. Les cas d'utilisation incluent les chatbots personnalisés, la génération d'idées, l'extraction d'entités, la classification et l'analyse des sentiments.

Accéder aux LLM sur SageMaker

Maintenant que nous avons identifié l'ensemble de données et le modèle que nous allons affiner, JumpStart offre deux possibilités pour commencer à utiliser l'ajustement de la génération de texte : le SDK SageMaker et Studio.

Utiliser JumpStart par programmation avec le SDK SageMaker

Nous passons maintenant en revue un exemple de la façon dont vous pouvez utiliser le SDK SageMaker JumpStart pour accéder à un LLM (GPT-J 6B) et l'affiner sur l'ensemble de données de dépôt SEC. Une fois les ajustements terminés, nous déploierons le modèle affiné et ferons des inférences par rapport à celui-ci. Toutes les étapes de cet article sont disponibles dans le cahier d'accompagnement : Ajustement du modèle de génération de texte GPT-J 6B sur un ensemble de données spécifique à un domaine.

Dans cet exemple, JumpStart utilise le Conteneur d'apprentissage en profondeur SageMaker Hugging Face (DLC) et Vitesse profonde bibliothèque pour affiner le modèle. La bibliothèque DeepSpeed ​​est conçue pour réduire la puissance de calcul et l'utilisation de la mémoire et pour former de grands modèles distribués avec un meilleur parallélisme sur le matériel informatique existant. Il prend en charge la formation distribuée à nœud unique, en utilisant les points de contrôle de gradient et le parallélisme des modèles pour former de grands modèles sur une seule instance de formation SageMaker avec plusieurs GPU. Avec JumpStart, nous intégrons la bibliothèque DeepSpeed ​​avec le DLC SageMaker Hugging Face pour vous et nous nous occupons de tout sous le capot. Vous pouvez facilement affiner le modèle sur votre jeu de données spécifique à un domaine sans le configurer manuellement.

Affiner le modèle pré-formé sur des données spécifiques au domaine

Pour affiner un modèle sélectionné, nous devons obtenir l'URI de ce modèle, ainsi que le script de formation et l'image de conteneur utilisée pour la formation. Pour faciliter les choses, ces trois entrées dépendent uniquement du nom du modèle, de la version (pour une liste des modèles disponibles, voir Algorithmes intégrés avec table modèle pré-formée) et le type d'instance sur laquelle vous souhaitez vous entraîner. Ceci est démontré dans l'extrait de code suivant :

from sagemaker import image_uris, model_uris, script_uris, hyperparameters model_id, model_version = "huggingface-textgeneration1-gpt-j-6b", "*"
training_instance_type = "ml.g5.12xlarge" # Retrieve the docker image
train_image_uri = image_uris.retrieve( region=None, framework=None, model_id=model_id, model_version=model_version, image_scope="training", instance_type=training_instance_type,
) # Retrieve the training script
train_source_uri = script_uris.retrieve( model_id=model_id, model_version=model_version, script_scope="training"
) # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve( model_id=model_id, model_version=model_version, model_scope="training"
)

Nous récupérons le model_id correspondant au même modèle que nous voulons utiliser. Dans ce cas, nous affinons huggingface-textgeneration1-gpt-j-6b.

La définition d'hyperparamètres implique de définir les valeurs de divers paramètres utilisés lors du processus de formation d'un modèle ML. Ces paramètres peuvent affecter les performances et la précision du modèle. Dans l'étape suivante, nous établissons les hyperparamètres en utilisant les paramètres par défaut et en spécifiant des valeurs personnalisées pour des paramètres tels que epochs et les learning_rate:

from sagemaker import hyperparameters # Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version) # [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "6" hyperparameters["learning_rate"] = "2e-04"
print(hyperparameters)

JumpStart fournit une liste complète d'hyperparamètres disponibles pour le réglage. La liste suivante donne un aperçu d'une partie des hyperparamètres clés utilisés pour affiner le modèle. Pour une liste complète des hyperparamètres, voir le cahier Ajustement du modèle de génération de texte GPT-J 6B sur un ensemble de données spécifique à un domaine.

• époques – Spécifie au maximum le nombre d'époques de l'ensemble de données d'origine qui seront itérées.
• taux d'apprentissage – Contrôle la taille du pas ou le taux d'apprentissage de l'algorithme d'optimisation pendant la formation.
• eval_steps – Spécifie le nombre d'étapes à exécuter avant d'évaluer le modèle sur le jeu de validation pendant la formation. L'ensemble de validation est un sous-ensemble des données qui n'est pas utilisé pour la formation, mais qui est plutôt utilisé pour vérifier les performances du modèle sur des données invisibles.
• perte de poids – Contrôle la force de régularisation pendant la formation du modèle. La régularisation est une technique qui permet d'éviter que le modèle ne surajuste les données d'apprentissage, ce qui peut entraîner de meilleures performances sur des données invisibles.
• fp16 – Contrôle s'il faut utiliser la formation de précision fp16 16 bits (mixte) au lieu de la formation 32 bits.
• stratégie_évaluation – La stratégie d'évaluation utilisée lors de la formation.
• gradient_accumulation_steps – Le nombre d'étapes de mises à jour pour lesquelles accumuler les gradients, avant d'effectuer une passe en arrière/mise à jour.

Pour plus de détails concernant les hyperparamètres, reportez-vous au document officiel Documentation de l'Entraîneur de visage étreignant.

Vous pouvez maintenant affiner ce modèle JumpStart sur votre propre jeu de données personnalisé à l'aide du SDK SageMaker. Nous utilisons les données de dépôt auprès de la SEC que nous avons décrites précédemment. Les données de train et de validation sont hébergées sous train_dataset_s3_path et les validation_dataset_s3_path. Le format de données pris en charge comprend CSV, JSON et TXT. Pour les données CSV et JSON, les données textuelles sont utilisées à partir de la colonne appelée text ou la première colonne si aucune colonne appelée texte n'est trouvée. Étant donné qu'il s'agit d'un réglage fin de la génération de texte, aucune étiquette de vérité terrain n'est requise. Le code suivant est un exemple de SDK illustrant comment affiner le modèle :

from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
from sagemaker.tuner import HyperparameterTuner
from sagemaker.huggingface import HuggingFace train_dataset_s3_path = "s3://jumpstart-cache-prod-us-west-2/training-datasets/tc/data.csv"
validation_dataset_s3_path = "s3://jumpstart-cache-prod-us-west-2/training-datasets/tc/data.csv" training_job_name = name_from_base(f"jumpstart-example-{model_id}") metric_definitions=[ {'Name': 'train:loss', 'Regex': "'loss': ([0-9]+.[0-9]+)"}, {'Name': 'eval:loss', 'Regex': "'eval_loss': ([0-9]+.[0-9]+)"}, {'Name': 'eval:runtime', 'Regex': "'eval_runtime': ([0-9]+.[0-9]+)"}, {'Name': 'eval:samples_per_second', 'Regex': "'eval_samples_per_second': ([0-9]+.[0-9]+)"}, {'Name': 'eval:eval_steps_per_second', 'Regex': "'eval_steps_per_second': ([0-9]+.[0-9]+)"},
] # # Create SageMaker Estimator instance
tg_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=train_model_uri, entry_point="transfer_learning.py", instance_count=1, instance_type=training_instance_type, hyperparameters=hyperparameters, output_path=s3_output_location, base_job_name=training_job_name, enable_network_isolation=True, metric_definitions=metric_definitions
) # Launch a SageMaker Training job by passing s3 path of the training data
tg_estimator.fit({"train": train_dataset_s3_path, "validation": validation_dataset_s3_path}, logs=True)

Après avoir configuré l'estimateur SageMaker avec les hyperparamètres requis, nous instancions un estimateur SageMaker et appelons le .fit méthode pour commencer à affiner notre modèle, en lui passant le Service de stockage simple Amazon (Amazon S3) URI pour nos données de formation. Comme vous pouvez le voir, le entry_point le script fourni est nommé transfer_learning.py (le même pour les autres tâches et modèles), et le canal de données d'entrée transmis à .fit doit être nommé train et validation.

JumpStart prend également en charge l'optimisation des hyperparamètres avec Réglage automatique du modèle SageMaker. Pour plus de détails, voir l'exemple cahier.

Déployer le modèle affiné

Lorsque la formation est terminée, vous pouvez déployer votre modèle affiné. Pour ce faire, tout ce que nous devons obtenir est l'URI du script d'inférence (le code qui détermine comment le modèle est utilisé pour l'inférence une fois déployé) et l'URI de l'image du conteneur d'inférence, qui comprend un serveur de modèle approprié pour héberger le modèle que nous avons choisi. Voir le code suivant :

from sagemaker.predictor import Predictor
from sagemaker import image_uris
from sagemaker.utils import name_from_base
import boto3 sagemaker_session = sagemaker.Session(boto_session=boto3.Session(region_name="us-west-2")) #Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve( region=None, framework=None, image_scope="inference", model_id=model_id, model_version=model_version, instance_type=inference_instance_type,
) endpoint_name = name_from_base(f"jumpstart-example-{model_id}") # Use the estimator from the previous step to deploy to a SageMaker endpoint
finetuned_predictor = tg_estimator.deploy( initial_instance_count=1, instance_type="ml.g5.12xlarge", image_uri=image_uri, endpoint_name=endpoint_name,
)

Après quelques minutes, notre modèle est déployé et nous pouvons en tirer des prédictions en temps réel !

Accéder à JumpStart via l'interface utilisateur de Studio

Une autre façon d'affiner et de déployer des modèles JumpStart consiste à utiliser l'interface utilisateur de Studio. Cette interface utilisateur fournit une solution low-code/no-code pour affiner les LLM.

Sur la console Studio, choisissez Modèles, cahiers, solutions sous SageMaker JumpStart dans le volet de navigation.

Dans la barre de recherche, recherchez le modèle que vous souhaitez affiner et déployer.

Dans notre cas, nous avons choisi la carte modèle GPT-J 6B. Ici, nous pouvons directement affiner ou déployer le LLM.

Évaluation du modèle

Lors de l'évaluation d'un LLM, nous pouvons utiliser la perplexité (PPL). PPL est une mesure courante de la capacité d'un modèle de langage à prédire le mot suivant dans une séquence. En termes plus simples, c'est un moyen de mesurer dans quelle mesure le modèle peut comprendre et générer un langage de type humain.

Un score de perplexité inférieur signifie que le modèle est plus performant pour prédire le mot suivant. Concrètement, nous pouvons utiliser la perplexité pour comparer différents modèles de langage et déterminer lequel est le plus performant sur une tâche donnée. Nous pouvons également l'utiliser pour suivre les performances d'un seul modèle au fil du temps. Pour plus de détails, reportez-vous à Perplexité des modèles à longueur fixe.

Nous évaluons les performances du modèle en comparant ses performances avant et après l'ajustement fin. PPL est émis dans le travail de formation Amazon Cloud Watch journaux. De plus, nous examinons la sortie générée par le modèle en réponse à des invites de test spécifiques.

Les performances améliorées du modèle sont démontrées par deux expériences :

• Génération de texte - Nous montrons que la sortie du GPT-J affiné génère un texte qui ressemble à l'ensemble de données de la SEC, indiquant qu'il a appris à imiter les modèles de langage et les conventions du domaine de la réglementation financière
• Apprentissage sans coupure - Nous démontrons que le GPT-J affiné montre des performances nettement meilleures que le GPT-J non affiné sur la réponse aux questions zéro

Pour l'expérience de génération de texte, nous utilisons les paramètres d'inférence suivants pour obtenir nos résultats : max_length de 400 (nombre de jetons retournés), num_return_sequences de 1 (nombre d'exemples de texte de réponse), top_k de 250 (choisissez parmi l'une des 250 meilleures continuations possibles), top_p de 0.8 (ne sélectionner que les continuations qui sont au moins à 80 % probables), do_sample is True (échantillonnage) et temperature de 1 (une température élevée est un plus grand caractère aléatoire dans les réponses). Pour plus de détails sur les paramètres, reportez-vous à GénérationConfig. Le tableau suivant compare le GPT-J affiné et le GPT-J non affiné sur une tâche d'achèvement de texte.

Pour la deuxième expérience avec une tâche de réponse à une question sans coup sûr, nous avons défini le max_length être une valeur différente (40, 200 et 40, respectivement) en fonction de la sortie que nous attendons de chaque question. Les paramètres de top_k, top_p, do_sample, temperature sont définis comme 250, 0.8, False, et 0, respectivement. Nous définissons une température proche de 0 pour contrôler le caractère aléatoire de la sortie, tandis que dans la tâche de génération de texte, nous la définissons proche de 1 pour rendre le modèle plus créatif. Le tableau suivant compare les résultats. Pour chaque question, la sortie du GPT-J affiné est plus précise que celle non affinée.

Nettoyer

Pour éviter des frais permanents, supprimez les points de terminaison d'inférence SageMaker. Vous pouvez supprimer les terminaux via la console SageMaker ou depuis le notebook à l'aide des commandes suivantes :

# Delete the SageMaker endpoint and the attached resources
finetuned_predictor.delete_model()
finetuned_predictor.delete_endpoint()

Conclusion

JumpStart est une fonctionnalité de SageMaker qui vous permet de démarrer rapidement avec ML. JumpStart utilise des modèles open source pré-entraînés pour résoudre des problèmes de ML courants tels que la classification d'images, la détection d'objets, la classification de texte, la classification de paires de phrases et la réponse aux questions.

Dans cet article, nous vous avons montré comment affiner et déployer un LLM pré-formé (GPT-J 6B) pour la génération de texte basée sur l'ensemble de données de remplissage SEC. Nous avons démontré comment le modèle s'est transformé en un expert du domaine financier en subissant le processus de mise au point sur seulement deux rapports annuels de l'entreprise. Ce réglage fin a permis au modèle de générer du contenu avec une compréhension des sujets financiers et une plus grande précision. Essayez la solution par vous-même et faites-nous savoir comment cela se passe dans les commentaires.

Important : Ce message est uniquement à des fins de démonstration. Il ne s'agit pas de conseils financiers et ne doit pas être considéré comme un conseil financier ou d'investissement. Le poste a utilisé des modèles pré-formés sur les données obtenues à partir de la base de données SEC EDGAR. Vous êtes responsable du respect des conditions d'accès d'EDGAR si vous utilisez des données SEC.

Pour en savoir plus sur JumpStart, consultez les articles suivants :

À propos des auteurs

Dr Xin Huang est un scientifique appliqué senior pour Amazon SageMaker JumpStart et les algorithmes intégrés d'Amazon SageMaker. Il se concentre sur le développement d'algorithmes d'apprentissage automatique évolutifs. Ses intérêts de recherche portent sur le traitement du langage naturel, l'apprentissage en profondeur explicable sur des données tabulaires et l'analyse robuste du clustering spatio-temporel non paramétrique. Il a publié de nombreux articles dans les conférences ACL, ICDM, KDD et Royal Statistical Society: Series A.

Marc Karpe est un architecte ML au sein de l'équipe Amazon SageMaker Service. Il se concentre sur l'aide aux clients pour la conception, le déploiement et la gestion des charges de travail ML à grande échelle. Dans ses temps libres, il aime voyager et explorer de nouveaux endroits.

Dr Sanjiv Das est un boursier Amazon et le professeur Terry de finance et de science des données à l'Université de Santa Clara. Il détient des diplômes de troisième cycle en finance (M.Phil et PhD de l'Université de New York) et en informatique (MS de l'UC Berkeley), et un MBA de l'Indian Institute of Management, Ahmedabad. Avant d'être universitaire, il a travaillé dans le secteur des produits dérivés dans la région Asie-Pacifique en tant que vice-président de Citibank. Il travaille sur l'apprentissage automatique multimodal dans le domaine des applications financières.

Arun Kumar Lokanatha est architecte principal de solutions ML au sein de l'équipe Amazon SageMaker Service. Il se concentre sur l'aide aux clients pour créer, former et migrer les charges de travail de production ML vers SageMaker à grande échelle. Il est spécialisé dans l'apprentissage en profondeur, en particulier dans le domaine de la PNL et du CV. En dehors du travail, il aime courir et faire de la randonnée.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• Platoblockchain. Intelligence métaverse Web3. Connaissance Amplifiée. Accéder ici.
• Frapper l'avenir avec Adryenn Ashley. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/domain-adaptation-fine-tuning-of-foundation-models-in-amazon-sagemaker-jumpstart-on-financial-data/