Auteur
30 mars 2021
Dans ce deuxième article de la série de deux, je vais me plonger dans le déploiement et le service de nos modèles à l'échelle. Si vous avez manqué le premier article sur l'entraînement d'un modèle fastai à l'échelle sur AI Platform Training, voici le lien suivant lien.
TL;DR
Dans ce deuxième article de la série de deux, je vais me plonger dans le déploiement et le service de nos modèles à l'échelle. Si vous avez manqué le premier article sur l'entraînement d'un modèle fastai à l'échelle sur AI Platform Training, voici le lien suivant lien.
Servir un modèle d'apprentissage profond peut révéler plusieurs défis parmi lesquels :
Dans cet article, je vais vous expliquer comment j'ai servi un classificateur de texte par apprentissage profond formé avec la bibliothèque FastAI en suivant 2 étapes principales :
Tous les documents peuvent être consultés dans la section gdépôt ithub. Ce dépôt a été inspiré par un autre projet qui visait à déployer un classificateur d'images fastai sur AWS SageMaker Inference Endpoint. ici.
1- Déployer le modèle fastai à l'aide de TorchServe
TorchServe facilite le déploiement de modèles PyTorch à grande échelle dans des environnements de production. Il élimine la lourde tâche de développer votre propre architecture client-serveur. La bibliothèque FastAI est basée sur le framework PyTorch. Elle permet d'utiliser cette technologie pour servir des modèles fastai en chargeant votre modèle fastai comme un pur objet PyTorch (suppression de l'abstraction fastai).
1-1 Exporter les poids des modèles à partir de FastAI
Pour ce faire, vous devez restaurer l'apprenant FastAI à partir de l'export pickle du dernier article, et enregistrer les poids de son modèle avec PyTorch.
from fastai.text import load_learner
from fastai.text.learner import get_c, get_text_vocab
learn = load_learner(“fastai_cls.pkl”)
vocab_sz = len(_get_text_vocab(dls)) #dls est le chargeur data que vous avez utilisé pour la formation
n_class = get_c(dls)
config = awd_lstm_clas_config.copy()
torch.save(learn.model.state_dict(), “fastai_cls_weights.pth”)
1-2 Modèle PyTorch de FastAI
Une fois que vous avez exporté vos poids pytorch, vous devez reconstruire la structure du modèle pour pouvoir y charger vos poids. Vous devrez peut-être creuser un peu dans le code source de Fastai pour trouver votre implémentation mais heureusement, dans le carnet Jupyter, on peut investiguer le code source en ajoutant ? ? devant le nom d'une fonction.
Pour le classificateur de texte, vous pouvez charger un objet pytorch pur en utilisant la fonction fastai get_text_classifier
from fastai.text.all import AWD_LSTM
torch_pure_model = get_text_classifier(AWD_LSTM, vocab_sz, n_class, config=config)
1-3 Reproduire les étapes de prétraitement de fastai
Une fois que vous avez obtenu votre modèle pur pytorch, vous devez appliquer le même prétraitement que celui utilisé pour l'entraînement. FastAI dispose d'une méthode .predict très pratique qui peut être appliquée à un texte (objet chaîne simple), qui reproduit naturellement le prétraitement de l'entraînement et élimine donc le risque de distorsion de l'entraînement.
pred_fastai = learn.predict(text)
pred_fastai
>>(Catégorie tenseur(1), tenseur(1), tenseur([0.0036, 0.9964]))
Dans notre cas, nous devons prendre cette responsabilité nous-mêmes, puisque nous devons nous débarrasser de l'abstraction fastai et travailler directement avec les objets PyTorch.
Dans mon exemple, j'ai utilisé un tokenizer spacy et j'ai donc reproduit le prétraitement fastai comme indiqué ci-dessous :
torche d'importation
from fastai.text.core import Tokenizer, SpacyTokenizer from fastai.text.data import Numericalize
exemple = “Bonjour, ceci est un test”.”
tokenizer = Tokenizer(
tok=SpacyTokenizer(“en”)
)
numericalizer = Numericalize(vocab=vocab)
exemple_traité = numericalizer(tokenizer(exemple))
exemple_traité
>>> tenseur([ 4, 7, 26, 29, 16, 72, 69, 31])
inputs = example_processed.resize(1, len(example_processed))
outputs = model_torch.forward(inputs)[0] preds = torch.softmax(outputs, dim=-1) 1TP45Vous pouvez utiliser n'importe quelle fonction d'activation.
prédateurs
>>> tenseur([[0.0036, 0.9964]], grad_fn=)
Comme vous pouvez le constater, les résultats que j'obtiens en utilisant les fonctions torch et learn.predict sont les mêmes car j'ai réussi à conserver les mêmes étapes de prétraitement.
1-4 Déployez votre modèle via torchserve
Dans cette section, nous déployons le modèle PyTorch sur TorchServe. Pour l'installation, veuillez vous référer au dépôt Github de TorchServe.
Globalement, l'utilisation de TorchServe se fait en trois étapes :
- Archivez le modèle dans *.mar.
- Commencez le service de la torche.
Appelez l'API et obtenez la réponse.
Afin d'archiver le modèle, au moins 2 fichiers sont nécessaires dans notre cas :
- Poids des modèles PyTorch fastai_cls_weights.pth.
- Gestionnaire personnalisé de TorchServe.
Gestionnaire personnalisé
Comme le montre le fichier /deployment/handler.py, le gestionnaire TorchServe accepte data et le contexte. Dans notre exemple, nous définissons une autre classe Python d'aide avec 4 méthodes d'instance à mettre en œuvre : initialiser, prétraiter, inférer et post-traiter.
Vous pouvez maintenant configurer et lancer TorchServe.
TorchServe en action
Étape 1 : Archiver le modèle PyTorch
--nom-modèle=modèle_fastai
-version=1.0
-serialized-file=/home/model-server/fastai_cls_weights.pth
-- extra-files=/home/model-server/config.py,/home/model-server/vocab.json
-handler=/home/model-server/handler.py
--export-path=/home/model-server/model-store/
Étape 2 : Servir le modèle
Étape 3 : Appeler l'API et obtenir la réponse (ici nous utilisons curl).
Le premier appel aurait une latence plus longue en raison du chargement des poids du modèle défini dans initialize, mais ce problème sera atténué à partir du deuxième appel.
2- Déploiement vers la plateforme d'IA Prédiction
Dans cette section, nous déployons le modèle FastAI entraîné avec TorchServe dans GCP AI Platform Prediction à l'aide d'une image Docker personnalisée. Pour plus de détails sur les routines GCP AI Platform Prediction utilisant des conteneurs personnalisés, veuillez vous référer à cet article. Notez que cette option n'est disponible que si vous utilisez AI Platform Prediction avec des terminaux régionaux.
Étapes pour déployer un modèle fastai sur la plateforme d'IA Prediction :
Tout d'abord, créez un modèle de prédiction de plateforme d'IA sur un terminal régional :
-region=REGION #eg : europe-west1
-enable-logging
-enable-console-logging
2-1 Construisez votre image docker qui sera utilisée par votre version
-repository-format=docker
-location=REGION #eg : europe-west1
2-2 (Facultatif) Vérifiez que votre image Docker fonctionne correctement.
curl -X POST -H "Content-Type : application/json" -d '["ceci était un mauvais film"]' 127.0.0.1:8080/prédictions/fastai_model
2-3 Pousser votre image docker vers un registre de conteneurs dans votre projet GCP
Pour ce faire, vous devez disposer des informations d'identification IAM. Une fois que vous vous êtes assuré de les avoir, exécutez la commande suivante
docker push REGION-docker.pkg.dev/PROJECT_ID/ARTIFACT_REGISTRY_NAME/fastai_text_cls:v0
2-4 Créer une version modèle à l'aide de votre image docker
-region=REGION
-modèle=NOM_DE_MODÈLE
-image=REGION-docker.pkg.dev/PROJECT_ID/ARTIFACT_REGISTRY_NAME/fastai_text_cls:v0
-ports=8080
-health-route=/ping
-predict-route=/predictions/fastai_model
2-5 Testez la version de votre modèle
-H "Authorization : Bearer $(gcloud auth print-access-token)"
-H "Content-Type : application/json"
-d '["c'était un mauvais film"]'
https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models/MODEL_NAME/versions/VERSION_NAME:predict
Votre modèle fastai est désormais déployé dans une architecture sans serveur sur la plateforme d'IA Prediction. Vous pouvez faire des prédictions en ligne en envoyant des demandes à votre modèle sous la forme d'une API REST. Toutes les méthodes pour demander des prédictions peuvent être trouvées dans documentation google.
Conclusion
L'utilisation de la plateforme d'IA Prediction pour servir n'importe quel type de modèle peut être très utile. Cet article avait pour but de montrer un exemple de modèle d'apprentissage profond utilisant un framework lourd (pytorch) et de le servir d'une manière rentable.
Il convient de garder à l'esprit certaines limites :
