TL;DR
La formation d'un modèle ML peut parfois être compliquée à mettre en place et à reproduire :
- Il se peut que vous utilisiez un code hébergé sur un ordinateur portable sur une machine virtuelle que vous devez lancer manuellement et éteindre lorsqu'il est terminé.
- Il se peut que vous deviez télécharger un jeu dataset de formation chaque fois que vous voulez le former à nouveau.
- Vous devez plonger dans votre code lorsque vous souhaitez modifier un seul paramètre
- etc.
Dans cet article, nous allons voir comment nous avons automatisé le processus de formation des classificateurs de texte de FastAI, en utilisant Google Cloud AI Platform.
Dans un second article, nous verrons comment nous avons réussi à déployer de tels modèles avec AI Platform et TorchServe.
Pour qui ?
Si vous travaillez sur un projet qui nécessite d'entraîner des modèles ML plusieurs fois, et que vous êtes fatigué de devoir exécuter manuellement vos entraînements, vous êtes au bon endroit.
Si vous en avez assez de gérer des machines virtuelles pour votre formation et que vous souhaitez consacrer votre temps à quelque chose de plus intéressant, comme la lecture d'articles sur Medium, vous êtes au bon endroit !
Cet article est dédié à ceux qui veulent savoir comment ils peuvent gagner du temps et des ressources en utilisant AI Platform pour l'entraînement de leurs modèles ML. Nous verrons dans cet article comment nous avons appliqué cela à un projet sur lequel nous avons travaillé, en utilisant FastAI.
Cet article est dédié à ceux qui veulent savoir comment ils peuvent gagner du temps et des ressources en utilisant AI Platform pour l'entraînement de leurs modèles ML. Nous verrons dans cet article comment nous avons appliqué cela à un projet sur lequel nous avons travaillé, en utilisant FastAI.
Pré-requis si vous souhaitez reproduire ce que nous avons fait
AI Platform fait partie de la suite Google Cloud Platform, tout comme les autres services que nous avons utilisés pour automatiser notre pipeline de formation. Voici les services GCP que nous avons utilisés :
Google Cloud SDK, Docker et Nvidia-docker doivent être installés et configurés sur la machine où l'image Docker est construite. L'intérêt d'installer Nvidia-docker est de pouvoir exécuter l'image Docker construite directement sur le GPU de la machine (s'il y en a un), de s'assurer qu'il n'y a pas d'erreurs dans le code et que l'entraînement se déroulera comme prévu lorsqu'il sera exécuté sur AI Platform.
Comme nous le verrons plus loin dans l'article, l'image Docker a été créée à partir de l'image Nvidia-Cuda, de sorte que les pilotes Nvidia requis sont automatiquement installés lors de la construction de l'image.
Contexte
Nous verrons dans cet article comment nous avons automatisé l'entraînement d'un classificateur de texte réalisé avec FastAI, une bibliothèque permettant aux utilisateurs de créer des modèles puissants grâce à la méthode FiT d'ULM.

Nous l'avons déjà présenté dans un autre article de Medium, Je vous invite donc à le consulter si vous souhaitez en savoir plus.
Étant donné que ce que nous verrons dans cet article sera applicable à n'importe quel cadre, vous n'avez pas besoin d'être familier avec FastAI pour continuer à lire. Tout ce que vous devez savoir, c'est que nous avons utilisé un modèle pré-entraîné pour entraîner notre classificateur de texte en plus d'un ensemble 1TP41 étiqueté.
Comment nous avons mis en place la formation avec AIPlatform
Pour automatiser l'apprentissage des modèles avec AI Platform, vous devez spécifier quel code doit être exécuté dans quel environnement lorsque la commande d'apprentissage est appelée. La meilleure façon de le faire est de créer une image Docker qui contient tout le code d'entraînement et son environnement, de sorte qu'AI Platform n'a qu'à créer un conteneur à partir de cette image chaque fois que vous lui demandez d'entraîner un modèle. Nous allons voir dans cette partie comment nous avons procédé.
Stockez tous les fichiers nécessaires dans une corbeille GCS.
Avant de créer notre image Docker qui contient notre entraînement, nous avons dû penser aux fichiers qui sont utilisés pendant l'entraînement d'un modèle de classificateur de texte FastAI. Nous avons donc décidé de stocker tous les fichiers nécessaires à l'entraînement dans un seau GCS, séparés dans des dossiers pour chaque langue, avec un nom spécifique donné à chaque fichier.
Nous avons ensuite implémenté dans notre code de formation (comme nous le verrons ci-dessous) une méthode permettant de récupérer les fichiers requis à partir de GCS, en spécifiant uniquement la langue cible en tant qu'argument.

Écrire le code de formation
Après avoir téléchargé les fichiers nécessaires dans GCS, nous avons créé un fichier repo contenant le code pour l'entraînement de nos modèles, destiné à être stocké dans une image Docker par la suite.
Comme vous pouvez le voir dans le repo lié, nous avons divisé le code pour l'entraînement dans des fichiers séparés afin de gérer correctement tout le pipeline d'entraînement.

Nous avons défini un fichier qui exécute tous les processus de formation comme suit :
fastai_train.py est le seul fichier qui utilise directement des méthodes de FastAI, donc si quelqu'un voulait déployer un autre framework pour sa formation, il n'aurait qu'à modifier ce fichier (et le contenu du fichier de configuration bien sûr).
L'étape suivante a consisté à créer une image docker qui contiendra tout ce qui est nécessaire pour que la formation se déroule correctement.
Créez le fichier Docker
Après avoir préparé le code d'entraînement, un fichier Docker a dû être créé et envoyé au Google Container Registry, pour permettre à AI Platform de le récupérer et de l'exécuter dans l'environnement approprié.
Comme l'entraînement de notre modèle devait être exécuté sur GPU, nous avons importé l'image Docker Nvidia-cuda pour créer la nôtre, de sorte que tous les pilotes nécessaires étaient déjà installés.
# Dockerfile
FROM nvidia/cuda:10.2-devel
RUN apt-get update && apt-get install -y --no-install-recommends
wget
build-essential
Exécuter apt-get update && apt-get install -y --no-install-recommends
python3-dev
python3-setuptools
python3-pip
Exécutez pip3 install pip==20.3.1
WORKDIR /root
# Créez des répertoires pour contenir le code et le modèle téléchargé de GCS
RUN mkdir /root/trainer
RUN mkdir /root/models
# Copiez les exigences
COPY exigences.txt /racine/exigences.txt
# Installer pytorch
RUN pip3 install torch==1.8.0
# Installer les exigences
RUN pip3 install -r requirements.txt
# Installe le sdk cloud de google, c'est surtout pour utiliser gsutil pour exporter le modèle.
Exécutez 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
--disable-installation-options &&
rm -rf /root/.config/* &&
ln -s /root/.config /config &&
# Supprimez le répertoire de sauvegarde créé par gcloud
rm -rf /root/tools/google-cloud-sdk/.install/.backup
# Copiez les fichiers
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
# Configuration du chemin d'accès
ENV PATH $PATH:/root/tools/google-cloud-sdk/bin
# Assurez-vous que gsutil utilisera le compte de service par défaut
RUN echo '[GoogleCompute]nservice_account = default' > /etc/boto.cfg
# Authentifiez vous auprès de GCP
CMD gcloud auth login
# Configure le point d'entrée pour invoquer l'entraîneur.
ENTRYPOINT ["python3", "trainer/training_workflow.py"]
Comme vous pouvez le voir ci-dessus, le fichier Docker exécute les étapes suivantes pour créer l'image :
Construire l'image et l'envoyer au GCR
Après avoir créé le fichier Docker, il était nécessaire de construire l'image pour l'envoyer à GCR. Comme spécifié dans le repo, plusieurs variables locales ont dû être définies, telles que la variable IMAGE_URI dans le RMC, le RÉGION nos opérations en, etc.
L'image a été construite en exécutant cette commande :
docker build -f Dockerfile -t $IMAGE_URI ./
Avant de l'envoyer à GCR, nous voulions nous assurer que tout fonctionnerait correctement lors de l'appel à la formation, donc puisque notre VM avait un GPU disponible, nous avons exécuté l'image avant de l'envoyer pour voir ce qui se passait :
docker run --runtime=nvidia $IMAGE_URI --epochs 1 --bucket-name $BUCKET_NAME
Cette étape n'est pas nécessaire mais peut vous faire gagner beaucoup de temps car vous verrez directement s'il y a des erreurs dans votre code.
Nous avons finalement poussé le conteneur vers GCR en exécutant la commande suivante, $IMAGE_URI étant la variable se référant à l'URI où l'image est stockée dans GCR :
docker push $IMAGE_URI
Exécutez et suivez le travail
Après avoir suivi les étapes précédentes, l'entraînement du modèle était prêt à être appelé à l'aide d'une simple commande dans le terminal. Il suffisait d'activer le SDK Google Cloud et de définir des variables locales :
gcloud ai-platform jobs submit training $JOB_NAME --scale-tier BASIC_GPU --region $REGION --master-image-uri $IMAGE_URI -- --lang=fr --epochs=10 --bucket-name=$BUCKET_NAME --model-dir=$MODEL_DIR
Cette commande demande à AI Platform de récupérer le conteneur dans GCR à l'aide de son IMAGE_URI, puis d'exécuter l'apprentissage sur le GPU d'une machine hébergée dans la région REGION.
Nous avons spécifié plusieurs arguments ici, tels que la langue de l'entraînement, le nombre d'époques, le nom du seau pour charger et télécharger les fichiers dans GCS, et le répertoire où stocker le modèle entraîné. Ce sont les arguments qui sont récupérés par le fichier args_getter.py
Après avoir exécuté la commande, la formation a démarré et un travail a été créé dans la console AI Platform, ce qui nous a permis de suivre l'évolution de la formation et de vérifier les journaux de la machine qui l'exécute.
De nombreuses informations sont accessibles lorsque l'on examine l'emploi dans la console de la plateforme d'IA

Lorsque le travail est terminé, le modèle entraîné est sauvegardé sur un godet GCS sous la forme d'un fichier .pth accompagné d'un fichier .json contenant ses performances.


Nous avons décidé de considérer les résultats sur les étiquettes séparément, comme si nous avions un classificateur binaire pour chaque étiquette possible.
Comme nous avons utilisé FastAI, le fichier modèle peut être directement chargé dans n'importe quel environnement en appelant la méthode load_learner() de FastAI.

Principaux enseignements
L'automatisation de la formation de nos modèles à l'aide d'AI Platform nous a permis de gagner beaucoup de temps et nous a fait prendre en compte différents aspects de la formation de nos modèles pour les mettre en production de manière efficace.
Voici quelques enseignements que nous en avons tirés :
Quelle est la prochaine étape ?
Maintenant que nous avons expliqué comment nous avons automatisé l'apprentissage de notre modèle, nous pouvons vous montrer comment nous avons réussi à le rendre facilement appelable pour classer des fichiers à la demande.
Restez à l'écoute pour la deuxième partie de cet article qui expliquera tout ce que vous devez savoir pour déployer vos classificateurs entraînés en utilisant AI Platform et TorchServe !
Merci de votre lecture !
Nous espérons que vous avez appris quelque chose aujourd'hui, et que cela vous sera utile pour vos futurs projets de ML. N'hésitez pas à nous contacter si vous avez des questions ou des commentaires sur ce sujet.

BLOG







