Conteneurisation de modèles linguistiques avancés pour n’importe quelle langue sans préconstruire les conteneurs 🚀

Introduction

Les modèles linguistiques avancés (MLA) sont des outils puissants qui peuvent être utilisés pour générer un texte similaire à celui d’un humain, répondre à des questions et même créer de nouveaux contenus. Cependant, mettre en place un environnement pour exécuter ces modèles peut être complexe et fastidieux, surtout lorsqu’on doit gérer plusieurs langages de programmation ou des configurations matérielles variables. Ce tutoriel vous guidera tout au long du processus d’exécution des MLA dans des conteneurs Docker pour n’importe quel langage sans avoir à les préconstruire, en utilisant des avancées récentes comme Math-Shepherd, Step-DPO et FlowSteer.

Cette approche non seulement simplifie la mise en place mais facilite également l’expérimentation avec différents modèles et langages, augmentant ainsi l’accessibilité et la flexibilité pour les développeurs et chercheurs.

📺 Regardez : Introduction aux modèles linguistiques avancés

Vidéo par Andrej Karpathy

Prérequis

Avant de commencer, assurez-vous d’avoir installé :

  • Python 3.10+ (version la plus récente recommandée)
  • Docker Engine (version >=24.0)
  • Git (version >=2.38)
  • pip (installateur de paquets Python)

Pour installer Docker et Git sur votre système, utilisez les commandes suivantes :

# Installer Docker en suivant le guide d'installation officiel : https://docs.docker.com/get-docker/
sudo apt-get update
sudo apt-get install docker.io

# Installer Git à l'aide du gestionnaire de paquets APT
sudo apt-get install git

Étape 1 : Configuration du projet

Tout d’abord, nous devons cloner un référentiel contenant les fichiers Dockerfile et les scripts nécessaires pour notre projet. Cela inclura des configurations pour exécuter les MLA dans divers langages.

git clone https://github.com/example-llm/llm-docker.git
cd llm-docker

Ensuite, installez les dépendances Python à l’aide de pip :

pip install --upgrade pip
pip install torch==1.12.0 transformers [6]==4.26.0 datasets==2.9.0

Cela garantira que vous disposez des dernières versions stables des bibliothèques PyTorch, Transformers et Datasets requises pour les MLA.

Étape 2 : Implémentation centrale

Le cœur de notre projet consiste à créer un fichier Dockerfile qui peut exécuter l’environnement d’un langage donné sans avoir besoin de construire un conteneur à partir de zéro chaque fois. Nous utiliserons des constructions multi-étages et des commandes RUN dans le fichier Dockerfile pour télécharger dynamiquement les dépendances en fonction du langage choisi.

# Commencer avec une image Python officielle comme image de base
FROM python:3.10-slim

# Définir les variables d'environnement pour une flexibilité dans le choix des paquets Python
ENV PYTHONUNBUFFERED=TRUE \
    PYTHONDONTWRITEBYTECODE=TRUE

# Installer les dépendances système nécessaires
RUN apt-get update && apt-get install -y \
    curl \
    build-essential && \
    rm -rf /var/lib/apt/lists/*

# Copier le fichier requirements.txt et installer les dépendances à partir de celui-ci
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Exposer le port sur lequel votre application sera exécutée
EXPOSE 8080

# Définir le répertoire de travail à l'intérieur du conteneur
WORKDIR /app

# Spécifier le script d'entrée point (pour gérer le runtime du langage)
ENTRYPOINT ["python", "entry_point.py"]

Dans entry_point.py, nous chargeons dynamiquement un paquet Python spécifique en fonction de l’argument passé en ligne de commande lors de l’exécution de l’image Docker :

import sys
from transformers import AutoModelForCausalLM, AutoTokenizer

def main():
    model_name = sys.argv[1]
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(model_name)

if __name__ == "__main__":
    main()

Étape 3 : Configuration

Pour configurer votre setup Docker pour un langage ou modèle de MLA spécifique, modifiez le fichier requirements.txt pour inclure les paquets Python nécessaires. Par exemple :

torch==1.12.0
transformers==4.26.0
datasets==2.9.0

Spécifiez également le nom de modèle exact dans votre commande de script d’entrée point lors de l’exécution de Docker.

Étape 4 : Exécution du code

Pour exécuter le conteneur MLA pour un langage ou modèle spécifique (par exemple, distilgpt [8]2), utilisez :

docker build -t llm-app .
docker run -p 8080:8080 llm-app distilgpt2

Sortie attendue :

INFO : Chargement réussi du tokenizer et du modèle.
INFO : Démarrage de l'application sur le port 8080...

Dépannage :

  • Assurez-vous d’avoir accès à Internet pour télécharger les dépendances pendant la construction.
  • Vérifiez que votre démon Docker est en cours d’exécution.

Étape 5 : Conseils avancés

Pour une mise en place plus efficace et un déploiement plus rapide, envisagez de créer un script qui automatise le processus de construction et de lancement des conteneurs pour différents modèles. Explorez également l’utilisation de docker-compose pour gérer plusieurs services et configurations dans les setup complexes.

Résultats

En suivant ce tutoriel, vous avez réussi à mettre en place des conteneurs Docker capables d’exécuter des modèles linguistiques avancés sans avoir à les préconstruire, facilitant ainsi l’expérimentation avec divers modèles et langages dans votre environnement de développement ou de recherche.

Aller plus loin

  • Explorer différents MLA disponibles sur le Hub des modèles Hugging Face.
  • Utiliser des fichiers docker-compose.yml pour gérer les configurations multi-services.
  • Plonger dans le papier Math-Shepherd d’ArXiv pour améliorer les méthodes de vérification des sorties du modèle sans annotations humaines.

Conclusion

Ce guide vous a accompagné dans la création d’une infrastructure Docker flexible pour exécuter des modèles linguistiques avancés de manière dynamique. Avec cette infrastructure, vous pouvez facilement passer d’un langage à un autre et expérimenter avec divers MLA sans avoir à se soucier de la construction préalable des conteneurs.

Bonne codification !