Auteur
TL;DR
Het trainen van een ML-model kan soms ingewikkeld zijn om op te zetten en te herhalen:
- Het kan worden gedaan met behulp van code die wordt gehost op een notebook op een VM die u handmatig moet starten en uitschakelen wanneer het klaar is
- Het kan zijn dat u een dataset moet uploaden telkens wanneer u de training opnieuw wilt uitvoeren.
- U moet diep in uw code duiken als u een enkele parameter wilt wijzigen
- enz.
In dit artikel zullen we zien hoe we het trainingsproces van FastAI's tekstclassifiers hebben geautomatiseerd, met behulp van Google Cloud AI Platform.
In een tweede artikel zullen we zien hoe we erin geslaagd zijn om dergelijke modellen te implementeren met AI Platform en TorchServe.
Voor wie?
Als u werkt aan een project waarvoor u ML-modellen meerdere keren moet trainen, en u het beu bent om uw trainingen handmatig uit te voeren, dan bent u hier aan het juiste adres.
Als u moe bent van het beheren van VM's voor uw training en u wilt uw tijd aan iets interessanters besteden, zoals het lezen van artikelen in Medium, dan bent u hier ook aan het juiste adres!
Dit artikel is bedoeld voor degenen die willen weten hoe ze tijd en middelen kunnen winnen door AI Platform te gebruiken voor het trainen van hun ML-modellen. We zullen in dit artikel zien hoe we dit hebben toegepast op een project waaraan we hebben gewerkt, met behulp van FastAI.
Dit artikel is bedoeld voor degenen die willen weten hoe ze tijd en middelen kunnen winnen door AI Platform te gebruiken voor het trainen van hun ML-modellen. We zullen in dit artikel zien hoe we dit hebben toegepast op een project waaraan we hebben gewerkt, met behulp van FastAI.
Vereisten als u wilt reproduceren wat wij hebben gedaan
AI Platform maakt deel uit van de Google Cloud Platform suite, net als de andere diensten die we gebruikten om onze trainingspijplijn te automatiseren. Hier zijn de GCP services die we hebben gebruikt:
Google Cloud SDK, Docker en Nvidia-docker moeten worden geïnstalleerd en ingesteld op de machine waar de Docker-image wordt gebouwd. Het doel van het installeren van Nvidia-docker is om de gebouwde Docker-image direct op de GPU van de machine (als die er is) te kunnen draaien, om ervoor te zorgen dat er geen fouten in de code zitten en dat de training naar verwachting zal draaien wanneer deze op het AI-platform draait.
Zoals we later in het artikel zullen zien, is de Docker Image gemaakt van de Nvidia-Cuda docker image, dus de vereiste Nvidia-stuurprogramma's worden automatisch geïnstalleerd bij het bouwen van de image.
Context
We zullen in dit artikel zien hoe we de training van een tekstclassificatie hebben geautomatiseerd met FastAI, een bibliotheek waarmee gebruikers krachtige modellen kunnen maken dankzij de ULM FiT methode.
We hebben het al gepresenteerd in een ander artikel op Medium, dus ik nodig u uit om het te bekijken als u er meer over wilt weten.
Aangezien wat we in dit artikel zullen zien toepasbaar is op elk framework, hoeft u niet bekend te zijn met FastAI om verder te lezen. Het enige dat u moet weten is dat we een voorgetraind model hebben gebruikt om onze tekst-klassificator te trainen, naast een gelabelde dataset.
Hoe we de training met AIPlatform opzetten
Om modeltraining met AI Platform te automatiseren, moet u specificeren welke code in welke omgeving moet worden uitgevoerd wanneer het trainingscommando wordt aangeroepen. De beste manier om dit te doen is om een Docker Image aan te maken die alle trainingscode en zijn omgeving bevat, zodat AI Platform elke keer dat u het vraagt om een model te trainen, gewoon een container van deze image hoeft aan te maken. We zullen in dit deel zien hoe we dat gedaan hebben.
Sla alle benodigde bestanden op in een GCS emmer
Voordat we ons Docker image met onze training creëerden, moesten we nadenken over de bestanden die gebruikt worden tijdens de training van een FastAI tekstclassificatiemodel. We besloten daarom om alle bestanden die nodig waren voor de training op te slaan in een GCS emmer, gescheiden in mappen voor elke taal, met een specifieke naam voor elk bestand.
Vervolgens hebben we in onze trainingscode (zoals we hieronder zullen zien) een methode geïmplementeerd om die vereiste bestanden van GCS op te halen, door alleen de doeltaal als argument op te geven.
De trainingscode schrijven
Na het uploaden van de benodigde bestanden in GCS, hebben we een repo die de code voor onze modeltraining bevat, bedoeld om later in een Docker Image opgeslagen te worden.
Zoals u in de gekoppelde repo kunt zien, hebben we de code voor de training in aparte bestanden verdeeld om alle trainingspijplijnen goed af te handelen.
We hebben een bestand gedefinieerd dat alle trainingsworkflows als volgt uitvoert:
fastai_train.py is het enige bestand dat direct gebruik maakt van methodes van FastAI, dus als iemand een ander framework voor zijn training wil gebruiken, hoeft hij alleen maar dit bestand aan te passen (en de inhoud van het config-bestand natuurlijk).
De volgende stap was dan het maken van een docker image die alles bevat wat nodig is om de training correct uit te voeren.
Het Dockerbestand maken
Na het voorbereiden van de trainingscode moest er een Dockerfile worden aangemaakt en naar de Google Container Registry worden geduwd, zodat het AI Platform de code in de juiste omgeving kon ophalen en uitvoeren.
Aangezien de training van ons model op GPU's moest draaien, importeerden we Nvidia-cuda Docker image om onze eigen image te maken, zodat alle benodigde stuurprogramma's al geïnstalleerd waren.
# Dockerbestand
VAN nvidia/cuda:10.2-devel
RUN apt-get update && apt-get install -y --no-install-recommends
wget
build-essential
RUN apt-get update && apt-get install -y --no-install-recommends
python3-dev
python3-setuptools
python3-pip
RUN pip3 installeren pip==20.3.1
WERKDIR /root
# Mappen aanmaken met code en gedownload model van GCS
RUN mkdir /root/trainer
RUN mkdir /root/models
# Vereisten kopiëren
COPY requirements.txt /root/requirements.txt
# Installeer pytorch
RUN pip3 install torch==1.8.0
# Installeer vereisten
RUN pip3 install -r requirements.txt
# Installeert google cloud sdk, dit is voornamelijk voor het gebruik van gsutil om modellen te exporteren.
RUN wget -nv
https://dl.google.com/dl/cloudsdk/release/google-cloud-sdk.tar.gz &&
mkdir /root/tools &&
tar xvzf google-cloud-sdk.tar.gz -C /root/tools &&
rm google-cloud-sdk.tar.gz &&
/root/tools/google-cloud-sdk/install.sh --usage-reporting=false
--path-update=false --bash-completion=false
--installatie-opties uitschakelen &&
rm -rf /root/.config/* &&
ln -s /root/.config /config &&
# Verwijder de back-upmap die gcloud aanmaakt
rm -rf /root/tools/google-cloud-sdk/.install/.backup
# Kopieer bestanden
COPY trainer/fastai_train.py /root/trainer/fastai_train.py
COPY trainer/fastai_config.py /root/trainer/fastai_config.py
COPY trainer/args_getter.py /root/trainer/args_getter.py
COPY trainer/gcs_utils.py /root/trainer/gcs_utils.py
COPY trainer/training_workflow.py /root/trainer/training_workflow.py
# Pad configuratie
ENV PATH $PATH:/root/tools/google-cloud-sdk/bin
# Zorg ervoor dat gsutil de standaard serviceaccount gebruikt
RUN echo '[GoogleCompute]nservice_account = standaard' > /etc/boto.cfg
# Authentificeer naar GCP
CMD gcloud auth login
# Stelt het toegangspunt in om de trainer aan te roepen.
ENTRYPOINT ["python3", "trainer/training_workflow.py"]
Zoals u hierboven kunt zien, voert de Dockerfile de volgende stappen uit om de image aan te maken:
Bouw de image en push deze naar GCR
Na het aanmaken van de Dockerfile, was het nodig om het image te bouwen om het naar GCR te pushen. Zoals gespecificeerd in de repo, moesten er verschillende lokale variabelen gedefinieerd worden, zoals de IMAGE_URI in GCR, de REGIO onze activiteiten in, enz.
De image werd gebouwd door dit commando uit te voeren:
docker build -f Dockerfile -t $IMAGE_URI ./
Voordat we het naar GCR pushten, wilden we er zeker van zijn dat alles goed zou werken bij het aanroepen van de training, dus omdat onze VM een GPU beschikbaar had, hebben we het image uitgevoerd voordat we het pushten om te zien wat er gebeurde:
docker run --runtime=nvidia $IMAGE_URI --epochs 1 --bucket-name $BUCKET_NAME
Deze stap is niet noodzakelijk, maar kan u veel tijd besparen omdat u direct kunt zien of er fouten in uw code zitten.
Uiteindelijk hebben we de container naar GCR gepushed door het volgende commando uit te voeren, $IMAGE_URI is de variabele die verwijst naar de URI waar de afbeelding is opgeslagen in GCR:
docker push $IMAGE_URI
De taak uitvoeren en volgen
Na het volgen van de vorige stappen was de training van het model klaar om aangeroepen te worden met een eenvoudig commando in de terminal. De Google Cloud SDK hoefde alleen maar te worden ingeschakeld en lokale variabelen gedefinieerd:
gcloud ai-platform jobs training indienen $JOB_NAME --schaalniveau BASIC_GPU --regio $REGION --master-image-uri $IMAGE_URI -- --lang=fr -epochs=10 --bucket-naam=$BUCKET_NAME --model-dir=$MODEL_DIR
Dit commando vraagt AI Platform om de container in GCR op te halen met de IMAGE_URI, en dan de training uit te voeren op de GPU van een machine gehost in de regio REGION.
We hebben hier verschillende argumenten opgegeven, zoals de taal van de training, het aantal epochs, de bucketnaam om bestanden te uploaden en downloaden in GCS, en de map waar het getrainde model opgeslagen moet worden. Dit zijn de argumenten die worden opgehaald door het bestand args_getter.py
Na het uitvoeren van het commando startte de training en werd er een taak aangemaakt in de AI Platform console, waardoor we de evolutie van de training konden volgen en de logboeken van de machine die de training uitvoerde konden controleren.
Veel informatie is toegankelijk wanneer u de taak in AI Platform console bekijkt
Als de taak voltooid is, wordt het getrainde model opgeslagen in een GCS-bucket als een .pth-bestand, samen met een .json-bestand met de prestaties.
We besloten om de resultaten op labels afzonderlijk te bekijken, alsof we een binaire classificator hadden voor elk mogelijk label.
Omdat we FastAI gebruikten, kon het modelbestand direct in elke omgeving worden geladen door FastAI's load_learner() methode aan te roepen.
Belangrijkste opmerkingen
Door de training van onze modellen te automatiseren met AI Platform konden we veel tijd besparen en moesten we verschillende aspecten van onze modeltraining in overweging nemen om het efficiënt in productie te kunnen nemen.
Hier zijn enkele dingen die we hieruit kunnen afleiden:
Wat is de volgende stap?
Nu we hebben uitgelegd hoe we de training van ons model hebben geautomatiseerd, kunnen we u laten zien hoe we het eenvoudig oproepbaar hebben gemaakt om bestanden op aanvraag te classificeren.
Blijf kijken voor het tweede deel van dit artikel, waarin alles wordt uitgelegd wat u moet weten om uw getrainde classificeerders in te zetten met AI Platform en TorchServe!
Bedankt voor het lezen!
Wij hopen dat u vandaag iets geleerd hebt, en dat het nuttig zal zijn voor uw toekomstige ML-projecten. Neem gerust contact met ons op als u vragen of opmerkingen hebt over dit onderwerp.
