Les transformateurs devenant essentiels pour de nombreuses tâches de PNL grâce à leurs performances inégalées, divers modèles de PNL utiles et percutants sont créés chaque jour. Cependant, de nombreux praticiens de la PNL trouvent qu’il est difficile de déployer des modèles en production. Selon ce rapport, 90 % des modèles d’apprentissage automatique ne sont jamais mis en production.
Le déploiement de modèle vous permet d’héberger votre modèle dans un environnement de serveur afin qu’il puisse être utilisé pour générer une prédiction lorsqu’il est appelé par une API, par exemple.
Dans ce didacticiel, je vais vous montrer comment pousser un modèle de transformateur spatial NER vers Huggingface et déployer le modèle sur AWS Lambda pour exécuter des prédictions.
Selon le site Web d’AWS :
« AWS Lambda est un service de calcul sans serveur qui vous permet d’exécuter du code sans provisionner ni gérer de serveurs, en créant une logique de mise à l’échelle de cluster prenant en compte la charge de travail, en maintenant des intégrations d’événements ou en gérant des runtimes. Avec Lambda, vous pouvez exécuter du code pour pratiquement n’importe quel type d’application ou de service backend, le tout sans aucune administration.
Le déploiement de modèles sans avoir besoin de gérer les serveurs principaux change la donne. Il permettra aux développeurs et aux petites startups qui ne disposent pas de ressources DevOps de commencer à déployer des modèles prêts à être utilisés en production.
Voici les étapes que nous allons suivre :
- Déployer un modèle de transformateur spaCy formé dans Huggingface
- Stocker le modèle dans S3
- Déployer le modèle dans AWS Lambda
- Exécutez la fonction AWS Lambda pour générer une prédiction basée sur l’entrée de l’utilisateur
Déployer le modèle Spacy Transformer dans Huggingface
Dans ce didacticiel, nous avons affiné le modèle de transformateur NER SciBert pour extraire des matériaux, des processus et des tâches à partir de résumés scientifiques. L’annotation a été effectuée à l’aide de l’outil d’annotation de texte. Nous avons suivi la même approche présentée dans mon article précédent où nous avons utilisé Google Colab pour entraîner le modèle. La prochaine étape après la formation du modèle consiste à l’héberger sur huggingface afin qu’il puisse être accessible par l’API.
Tout d’abord, installez spacy-huggingface-hub à partir de pip :
pip install spacy-huggingface-hub
Créez un fichier .whl à partir du pipeline spacy formé (assurez-vous de créer le répertoire de sortie au préalable) :
huggingface-cli login
python -m spacy package ./model_science_scibert/model-last ./output --build wheel
Poussez la lime de roue dans le moyeu Huggingface :
cd ./output/en_scibert_ScienceIE-0.0.0/dist
python -m spacy huggingface-hub push en_scibert_ScienceIE-0.0.0-py3-none-any.whl
Vérifions que le modèle a été téléchargé avec succès sur Huggingface :
Maintenant que le modèle est poussé dans la bibliothèque huggingface, nous pouvons le tester sur un résumé scientifique :
Génial – cela fonctionne comme prévu ! Nous pouvons maintenant interroger directement le modèle avec l’API :
import requests
API_URL = "https://api-inference.huggingface.co/models/UBIAI/en_scibert_ScienceIE"
headers = {"Authorization": "[API Token]"}
def query(payload):
response = requests.post(API_URL, headers=headers, json=payload)
return response.json()
output = query({"inputs": "We report exptl. and theor. evidence for the formation of chiral bobbers-an interfacial topol. spin texture-in"})
L’étape suivante consiste à intégrer le modèle à AWS Lambda afin que nous ne soyons pas limités par l’utilisation de l’API de Huggingface.
Déployer sur AWS Lambda
Dans cette section, nous allons stocker le modèle entraîné sur S3 et l’importer dans la fonction lambda pour les prédictions. Ci-dessous les étapes :
- Stockez le modèle formé sur S3 (alternativement, nous pouvons télécharger le modèle directement depuis la bibliothèque huggingface)
- Configurer la fonction Lambda d’inférence basée sur une image de conteneur
- Stockez l’image du conteneur dans le référentiel Amazon Elastic Container Registry (ECR) au sein de votre compte
- Importez et cachez le modèle formé sur le stockage Amazon Elastic File System afin d’améliorer la latence d’inférence
- Exécuter des prédictions sur AWS Lambda
Afin d’accélérer le processus, nous suivons ce didacticiel d’AWS qui provisionnera automatiquement la fonction Lambda basée sur une image de conteneur. Commençons par cloner le dépôt comme indiqué dans le didacticiel :
git clone https://github.com/aws-samples/zero-administration-inference-with-aws-lambda-for-hugging-face.git
Installez toutes les exigences :
pip install -r requirements.txt
Installez AWS CDK :
npm install -g aws-cdk
Ensuite, nous ajouterons le fichier d’inférence pour obtenir les prédictions de notre modèle.
Changez de répertoire dans le dossier d’inférence et ajoutez un nouveau fichier python pour exécuter le modèle, pour ce tutoriel, j’ai ajouté le fichier science_ie.py :
Maintenant, nous allons créer deux fonctions dans science_ie.py :
- Une fonction pour télécharger le modèle depuis S3, le décompresser et le stocker dans le dossier de cache /mnt/hf_models_cache.
- Une deuxième fonction consiste à interroger notre modèle et à renvoyer les entités extraites.
import os import urllib.request import spacy import spacy_transformers from zipfile import ZipFile from pathlib import Path #Download the model from S3 def download(model, dest): save_path = Path(dest) / model if not os.path.exists(save_path): print('Downloading...')# Enter url path to the model on S3 url = f'https://[bucket name].s3.us-west-2.amazonaws.com/{model}.zip' filename = Path(dest) / f'{model}.zip' res = urllib.request.urlretrieve(url, filename) with ZipFile(filename, 'r') as f: print(dest) f.extractall(path=dest) print('finished extracting') dirname = model.split('-')[0] return save_path #Handler function for predictions def handler(event, context): doc = nlp(event['text']) response = [ { 'text': ent.text, 'label': ent.label_, 'start': ent.start_char, 'end': ent.end_char } for ent in doc.ents ] return response model = 'model-last' mnt_path = '/mnt/hf_models_cache' model_path = download(model, mnt_path) nlp = spacy.load(mnt_path)
Nous sommes maintenant prêts pour le déploiement. Exécutez simplement les commandes suivantes pour déployer l’application CDK (remarque : j’ai eu une erreur lors de l’exécution de la commande ci-dessous pour python introuvable si cela se produit, remplacez simplement python3 par python dans cette ligne « app »: « python app.py » dans le cdk fichier .json) :
cdk bootstrap
cdk deploy
Une fois le déploiement commencé, nous commencerons à voir des progrès, il faudra un certain temps pour que le déploiement complet soit terminé. Une fois cela fait, accédez à AWS Lambda dans la console AWS et sélectionnez l’onglet test :
Saisissez le texte de test comme suit et appuyez sur le bouton Test :
{
"text": "We report exptl. and theor. evidence for the formation of chiral bobbers-an interfacial topol. spin texture-in FeGe films grown by mol. beam epitaxy. After establishing the presence of skyrmions in FeGe/Si(111) thin-film samples through Lorentz transmission electron microscopy and the topol. Hall effect, we perform magnetization measurements that reveal an inverse relationship between the film thickness and the slope of the susceptibility (d?/dH). We present evidence for the evolution as a function of film thickness L from a skyrmion phase for L<LD/2 to a cone phase with chiral bobbers at the interface for L>LD/2, where LD?70nm is the FeGe pitch length. We show using micromagnetic simulations that chiral bobbers, earlier predicted to be metastable, are in fact the stable ground state in the presence of an addnl. interfacial Rashba Dzyaloshinskii-Moriya interaction."
}
Voici les pronostics :
[
{
"text": "exptl. and theor. evidence for the formation of chiral bobbers",
"label": "TASK",
"start": 10,
"end": 72
},
{
"text": "FeGe films",
"label": "MATERIAL",
"start": 111,
"end": 121
},
{
"text": "skyrmions",
"label": "MATERIAL",
"start": 186,
"end": 195
},
{
"text": "FeGe/Si(111) thin-film samples",
"label": "MATERIAL",
"start": 199,
"end": 229
},
{
"text": "transmission electron microscopy",
"label": "PROCESS",
"start": 246,
"end": 278
},
{
"text": "topol. Hall effect",
"label": "PROCESS",
"start": 287,
"end": 305
},
{
"text": "magnetization measurements",
"label": "PROCESS",
"start": 318,
"end": 344
},
{
"text": "film",
"label": "MATERIAL",
"start": 393,
"end": 397
},
{
"text": "evolution as a function of film thickness",
"label": "TASK",
"start": 482,
"end": 523
},
{
"text": "skyrmion phase",
"label": "PROCESS",
"start": 533,
"end": 547
},
{
"text": "chiral bobbers",
"label": "MATERIAL",
"start": 580,
"end": 594
},
{
"text": "FeGe pitch length",
"label": "MATERIAL",
"start": 645,
"end": 662
},
{
"text": "micromagnetic simulations",
"label": "PROCESS",
"start": 679,
"end": 704
},
{
"text": "chiral bobbers",
"label": "MATERIAL",
"start": 710,
"end": 724
}
]
Et voila, nous avons obtenu des prédictions de notre modèle sur AWS Lambda sans jamais se soucier de la mise en place de l’infrastructure du serveur.
Conclusion
Dans ce didacticiel, nous avons montré comment déployer un modèle de transformateur formé sur Huggingface, le stocker sur S3 et obtenir des prédictions à l’aide des fonctions AWS lambda sans avoir besoin de configurer une infrastructure de serveur.
Si vous avez aimé cet article, likez et partagez !