Auteur
30 maart 2021
In dit tweede artikel van de serie van twee, duik ik in de inzet en het serveren van onze modellen op schaal. Als u het eerste artikel over het trainen van een fastai-model op schaal op AI Platform Training hebt gemist, dan vindt u hier het link.
TL;DR
In dit tweede artikel van de serie van twee, duik ik in de inzet en het serveren van onze modellen op schaal. Als u het eerste artikel over het trainen van een fastai-model op schaal op AI Platform Training hebt gemist, dan vindt u hier het link.
Het bedienen van een deep learning-model kan verschillende uitdagingen met zich meebrengen, waaronder:
In dit artikel leg ik uit hoe ik een deep learning tekstclassificator, getraind met de FastAI bibliotheek, heb gemaakt aan de hand van 2 hoofdstappen:
Alle materialen zijn te vinden in de github archief. Deze repository werd geïnspireerd door een ander project dat een fastai-afbeeldingsclassificator wilde implementeren op AWS SageMaker Inference Endpoint hier.
1- Implementeer fastai-model met TorchServe
TorchServe maakt het gemakkelijk om PyTorch-modellen op schaal in productieomgevingen te implementeren. Het neemt het zware werk weg van het ontwikkelen van uw eigen client-server architectuur. De FastAI bibliotheek is gebaseerd op het PyTorch framework. Het maakt het mogelijk om deze technologie te gebruiken om fastai-modellen te serveren door uw fastai-model als een puur pytorch-object te laden (fastai-abstractie verwijderen).
1-1 Modelgewichten exporteren vanuit FastAI
Om dat te doen, moet u de FastAI-leerder herstellen vanuit de export pickle uit de vorige post, en de modelgewichten ervan opslaan met PyTorch.
uit fastai.text importeer load_learner
uit fastai.text.learner import get_c, get_text_vocab
leren = load_learner(“fastai_cls.pkl”)
vocab_sz = len(_get_text_vocab(dls)) #dls is de dataloader die u voor de training hebt gebruikt
n_klasse = get_c(dls)
config = awd_lstm_clas_config.copy()
torch.save(learn.model.state_dict(), “fastai_cls_weights.pth”)
1-2 PyTorch-model van FastAI
Zodra u uw pytorch-gewichten hebt geëxporteerd, moet u de modelstructuur opnieuw opbouwen om uw gewichten erin te kunnen laden. U moet misschien een beetje graven in de fastai-broncode om uw implementatie te vinden, maar gelukkig kunt u in Jupyter notebook de broncode onderzoeken door ?? voor een functienaam te zetten.
Voor tekstclassificeerders kunt u een puur pytorch-object laden met de functie fastai get_text_classifier
uit fastai.text.all importeert AWD_LSTM
torch_pure_model = get_text_classifier(AWD_LSTM, vocab_sz, n_class, config=config)
1-3 De fastai-voorverwerkingsstappen herhalen
Zodra u uw pure pytorch-model hebt verkregen, moet u dezelfde voorbewerking toepassen die voor de training werd gebruikt. FastAI heeft een zeer handige methode .predict die kan worden toegepast op een tekst (eenvoudig stringobject), die op natuurlijke wijze de preprocessing van de training reproduceert en daarom het risico van scheve trainingsservices wegneemt.
pred_fastai = learn.predict(tekst)
pred_fastai
>>(Categorie tensor(1), tensor(1), tensor([0,0036, 0,9964]))
In ons geval moeten we deze verantwoordelijkheid zelf nemen, omdat we ons moeten ontdoen van de fastai-abstractie en direct met PyTorch-objecten moeten werken.
In mijn voorbeeld gebruikte ik een spacy tokenizer, dus reproduceerde ik fastai preprocessing zoals hieronder getoond:
fakkel importeren
uit fastai.text.core importeer Tokenizer, SpacyTokenizer uit fastai.text.data importeer Numericalize
voorbeeld = “Hallo, dit is een test.”
tokenizer = Tokenizer(
tok=SpacyTokenizer(“en”)
)
numericalizer = Numericalize(vocab=vocab)
voorbeeld_verwerkt = numericalizer(tokenizer(voorbeeld))
voorbeeld_verwerkt
>>> tensor([ 4, 7, 26, 29, 16, 72, 69, 31])
inputs = voorbeeld_verwerkt.resize(1, len(voorbeeld_verwerkt))
uitgangen = model_torch.forward(ingangen)[0] preds = torch.softmax(uitgangen, dim=-1) #U kunt elke activeringsfunctie gebruiken die u nodig hebt
preds
>>> tensor([[0.0036, 0.9964]], grad_fn=)
Zoals u kunt zien, zijn de resultaten die ik krijg met torch functies en learn.predict hetzelfde, omdat ik erin geslaagd ben om dezelfde voorbewerkingsstappen te behouden.
1-4 Implementeer uw model via torchserve
In dit gedeelte implementeren we het PyTorch-model op TorchServe. Raadpleeg voor installatie de TorchServe Github Repository.
In het algemeen zijn er 3 stappen om TorchServe te gebruiken:
- Archiveer het model in *.mar.
- Start de toortsdienst.
Roep de API aan en ontvang het antwoord.
Om het model te archiveren, zijn in ons geval minstens 2 bestanden nodig:
- PyTorch modelgewichten fastai_cls_weights.pth.
- TorchServe aangepaste handler.
Aangepaste behandelaar
Zoals te zien is in /deployment/handler.py, accepteert de TorchServe handler data en context. In ons voorbeeld definiëren we nog een helper Python klasse met 4 instance methodes om te implementeren: initialize, preprocess, inference en postprocess.
Nu kunt u TorchServe instellen en starten.
TorchServe in actie
Stap 1: Archiveer het model PyTorch
--modelnaam=fastai_model
-versie=1.0
-serialized-file=/home/model-server/fastai_cls_weights.pth
-- extra-bestanden=/home/model-server/config.py,/home/model-server/vocab.json
-handler=/home/model-server/handler.py
--export-path=/home/model-server/model-store/
Stap 2: Het model bedienen
Stap 3: API aanroepen en de respons ophalen (hier gebruiken we curl).
De eerste aanroep zou een langere latentie hebben vanwege het laden van modelgewichten die gedefinieerd zijn in initialiseren, maar dit zal vanaf de tweede aanroep gemitigeerd worden.
2- Uitrol naar AI-platform Voorspelling
In deze sectie implementeren we het FastAI getrainde model met TorchServe in het GCP AI Platform Prediction met behulp van een aangepast Docker image. Voor meer details over GCP AI Platform Prediction routines met behulp van aangepaste containers verwijzen wij u naar dit artikel. Merk op dat deze optie alleen beschikbaar is als u AI Platform Prediction gebruikt met regionale eindpunten.
Stappen om een fastai-model te implementeren op AI Platform Voorspelling:
Maak eerst een AI-platformvoorspellingsmodel op een regionaal eindpunt:
-region=REGIO #eg: europa-west1
-logboekregistratie inschakelen
-console-logging inschakelen
2-1 Bouw uw docker-image dat door uw versie zal worden gebruikt
-opslagplaats-formaat=docker
-locatie=REGIO #eg: europa-west1
2-2 (Optioneel) Controleer of uw docker image goed draait
curl -X POST -H "Content-Type: application/json" -d '["dit was een slechte film"]' 127.0.0.1:8080/voorspellingen/fastai_model
2-3 Push uw docker image naar een container register in uw GCP project
Daarvoor hebt u de IAM-referenties nodig. Zodra u er zeker van bent dat u ze hebt, voert u het volgende uit
docker push REGION-docker.pkg.dev/PROJECT_ID/ARTIFACT_REGISTRY_NAME/fastai_text_cls:v0
2-4 Maak een modelversie met behulp van uw docker-image
-regio=REGIO
-model=MODEL_NAME
-image=REGION-docker.pkg.dev/PROJECT_ID/ARTIFACT_REGISTRY_NAME/fastai_text_cls:v0
-ports=8080
-gezondheid-route=/ping
-predict-route=/predictions/fastai_model
2-5 Test uw modelversie
-H "Autorisatie: Bearer $(gcloud auth print-access-token)"
-H "Inhoudstype: toepassing/json"."
-d '["dit was een slechte film"]'
https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models/MODEL_NAME/versions/VERSION_NAME:predict
Uw fastai-model wordt nu ingezet in een serverloze architectuur op het AI Platform Prediction. U kunt online voorspellingen doen door verzoeken naar uw model te sturen als een REST API. Alle methoden om voorspellingen op te vragen vindt u in google documentatie.
Conclusie
Het gebruik van AI Platform Prediction om elk type model te serveren kan erg nuttig zijn. Dit artikel was bedoeld om een voorbeeld van een deep learning-model te laten zien met behulp van een zwaar framework (pytorch) en dit op een kosteneffectieve manier te serveren.
Houd rekening met enkele beperkingen:
