Note :

• Ce tutoriel nécessite l'accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, voir Introduction à l' niveau gratuit d'Oracle Cloud Infrastructure.
• Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles propres à votre environnement en nuage.

Régler et servir des modèles linguistiques volumineux sur Oracle Cloud Infrastructure avec dstack

Présentation

dstack est un outil à code source libre qui simplifie l'orchestration de conteneurs d'intelligence artificielle (IA) et rend plus accessible la formation distribuée et le déploiement de modèles LLL (Large Language Models). La combinaison de dstack et d'Oracle Cloud Infrastructure (OCI) déverrouille un processus simplifié pour configurer l'infrastructure en nuage pour un entraînement distribué et un déploiement de modèle évolutif.

Comment fonctionne dstack?

dstack offre une interface unifiée pour le développement, la formation et le déploiement de modèles d'IA dans n'importe quel nuage ou centre de données. Par exemple, vous pouvez spécifier une configuration pour une tâche d'entraînement ou un modèle à déployer, et dstack s'occupera de la configuration de l'infrastructure requise et de l'orchestration des conteneurs. L'un des avantages offerts par dstack est qu'il permet l'utilisation de tout matériel, cadre et script.

Objectifs

• Ajustez un modèle LLM à l'aide de dstack sur OCI, incorporez les meilleures pratiques du manuel Hugging Face Alignment Handbook et déployez le modèle à l'aide de Hugging Face Text Generation Inference (TGI).

  Note : L'expérience décrite dans le tutoriel utilise une grappe OCI de trois noeuds, chacun avec 2 processeurs graphiques A10, pour peaufiner le modèle Gemma 7B.

Préalables

• Accès à une location OCI.

• Accès à des formes avec des processeurs graphiques NVIDIA tels que les processeurs graphiques A10 (par exemple, VM.GPU.A10.2). Pour plus d'informations sur les demandes d'augmentation de limite, voir Limites de service.

• Un compte Hugging Face avec un jeton d'accès configuré pour télécharger le modèle Gemma 7B.

Tâche 1 : Configurer dstack avec OCI

1. Installez l'ensemble Python dstack à l'aide de la commande suivante. Comme dstack prend en charge plusieurs fournisseurs de nuage, nous pouvons restreindre la portée à OCI.

   pip install dstack[oci]
   

2. Configurez les données d'identification propres à OCI dans le fichier ~/.dstack/server/config.yml. Le code suivant suppose que vous avez configuré des données d'identification pour l'interface de ligne de commande OCI. Pour d'autres options de configuration, consultez la documentation sur la pile.

   projects:
   - name: main
     backends:
     - type: oci
       creds:
         type: default
   

3. Exécutez le serveur dstack à l'aide de la commande suivante.

   dstack server
   INFO     Applying ~/.dstack/server/config.yml...
   INFO     Configured the main project in ~/.dstack/config.yml
   INFO     The admin token is ab6e8759-9cd9-4e84-8d47-5b94ac877ebf
   INFO     The dstack server 0.18.4 is running at http://127.0.0.1:3000
   

4. Passez au dossier avec vos scripts de projet et initialisez dstack à l'aide de la commande suivante.

   dstack init
   

Tâche 2 : Tâche de réglage fin sur OCI avec dstack

Pour affiner le modèle Gemma 7B, nous utiliserons le manuel Hugging Face Alignment Handbook pour assurer l'intégration des meilleures pratiques de réglage fin. Vous pouvez obtenir le code source de ce tutoriel à partir d'ici : GitHub. Plongeons dans les étapes pratiques pour affiner votre LLM.

Une fois que vous passez au dossier de projet, utilisez les commandes suivantes pour lancer la tâche de réglage fin sur OCI avec dstack.

ACCEL_CONFIG_PATH=fsdp_qlora_full_shard.yaml \
  FT_MODEL_CONFIG_PATH=qlora_finetune_config.yaml \
  HUGGING_FACE_HUB_TOKEN=xxxx \
  WANDB_API_KEY=xxxx \
  dstack run . -f ft.task.dstack.yml

Les variables d'environnement FT_MODEL_CONFIG_PATH, ACCEL_CONFIG_PATH, HUGGING_FACE_HUB_TOKEN et WANDB_API_KEY sont définies dans la configuration de tâche ft.task.dstack.yml. dstack run soumet la tâche définie dans ft.task.dstack.yml sur OCI.

Note : dstack copie automatiquement le contenu du répertoire courant lors de l'exécution de la tâche.

Explorons les parties clés de chaque fichier YAML (pour le contenu complet, consultez le référentiel).

Le fichier qlora_finetune_config.yaml est la configuration de recette que le manuel d'alignement utilise pour comprendre comment ajuster un modèle de langue volumineux (LLM).

# Model arguments
model_name_or_path: google/gemma-7b
tokenizer_name_or_path: philschmid/gemma-tokenizer-chatml
torch_dtype: bfloat16
bnb_4bit_quant_storage: bfloat16

# LoRA arguments
load_in_4bit: true
use_peft: true
lora_r: 8
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
  - q_proj
  - k_proj
# ...

# Data training arguments
dataset_mixer:
  chansung/mental_health_counseling_conversations: 1.0
dataset_splits:
  - train
  - test
# ...

• Arguments de modèle :

  • model_name_or_path : Gemma 7B de Google est choisi comme modèle de base.
  • tokenizer_name_or_path : Le manuel d'alignement utilise la méthode apply_chat_template() du marqueur sélectionné. Ce tutoriel utilise le modèle ChatML au lieu du modèle de conversation standard de Gemma 7B.
  • torch_dtype et bnb_4bit_quant_storage : Ces deux valeurs doivent être définies de la même façon si nous voulons tirer parti de la méthode de réglage fin FSDP+QLoRA. Comme Gemma 7B est difficile à intégrer dans un seul GPU A10, ce tutoriel utilise FSDP+QLoRA pour fragmenter un modèle en GPU 2 x A10 tout en tirant parti de la technique QLoRA.

• LoRA Arguments : Configurations spécifiques à LoRA. Comme cet article du tutoriel tire parti de la technique FSDP+QLoRA, load_in_4bit est réglé à true. D'autres configurations peuvent varier d'une expérience à l'autre.

• Arguments de formation sur les données : Nous avons préparé un jeu de données basé sur le jeu de données des conversations de conseil en santé mentale d'Amod. Comme le manuel d'alignement ne comprend que les données sous la forme [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}, …] qui peuvent être interprétées avec la méthode apply_chat_template() de tokenizer, le jeu de données préparé est essentiellement la conversion du jeu de données initial dans le format compatible apply_chat_template().

Le fichier fsdp_qlora_full_shard.yaml configure l'utilisation accélérée de l'infrastructure sous-jacente pour le réglage fin du LLM.

compute_environment: LOCAL_MACHINE
distributed_type: FSDP  # Use Fully Sharded Data Parallelism
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch: BACKWARD_PRE
  fsdp_cpu_ram_efficient_loading: true
  fsdp_use_orig_params: false
  fsdp_offload_params: true
  fsdp_sharding_strategy: FULL_SHARD
  # ... (other FSDP configurations)
# ... (other configurations)

• distributed_type : FSDP indique l'utilisation du protocole FSDP (Fullly Sharded Data Parallel), technique qui permet d'entraîner des modèles volumineux qui, autrement, ne conviendraient pas à un seul processeur graphique.
• fsdp_config : Ceux-ci configurent le fonctionnement du protocole FSDP, par exemple la partition du modèle (fsdp_sharding_strategy) et le déchargement des paramètres dans l'UC (fsdp_offload_params).

Avec FSDP de distributed_type et FULL_SHARD de fsdp_sharding_strategy de fsdp_config, un modèle est fragmenté sur plusieurs GPU dans une seule machine. Lorsque vous traitez avec plusieurs noeuds de calcul, chaque noeud hébergera une copie identique du modèle, qui est elle-même fractionnée entre plusieurs GPU au sein de ce noeud. Cela signifie que chaque instance de modèle partitionnée sur chaque noeud traite différentes sections ou lots de votre jeu de données. Pour répartir un modèle unique entre plusieurs GPU sur plusieurs noeuds, configurez le paramètre fsdp_sharding_strategy en tant que HYBRID_SHARD.

Des paramètres supplémentaires tels que machine_rank, num_machines et num_processes sont importants pour la coordination. Toutefois, il est recommandé de définir ces valeurs dynamiquement lors de l'exécution, car cela offre une flexibilité lors du basculement entre différentes configurations d'infrastructure.

Tâche 3 : Instructions dstack à l'aide de la configuration simplifiée pour provisionner l'infrastructure

Explorons la configuration fsdp_qlora_full_shard.yaml qui regroupe tous les éléments et indique à dstack comment provisionner l'infrastructure et exécuter la tâche.

type: task
nodes: 3

python: "3.11"
env:
  - ACCEL_CONFIG_PATH
  - FT_MODEL_CONFIG_PATH
  - HUGGING_FACE_HUB_TOKEN
  - WANDB_API_KEY
commands:
  # ... (setup steps, cloning repo, installing requirements)
  - ACCELERATE_LOG_LEVEL=info accelerate launch \
      --config_file recipes/custom/accel_config.yaml \
      --main_process_ip=$DSTACK_MASTER_NODE_IP \
      --main_process_port=8008 \
      --machine_rank=$DSTACK_NODE_RANK \
      --num_processes=$DSTACK_GPUS_NUM \
      --num_machines=$DSTACK_NODES_NUM \
      scripts/run_sft.py recipes/custom/config.yaml
ports:
  - 6006
resources:
  gpu: 1..2
  shm_size: 24GB

Points clés à mettre en évidence : :

• Intégration transparente : dstack s'intègre aisément à l'écosystème à code source libre Hugging Face. En particulier, vous pouvez simplement utiliser la bibliothèque d'accélération avec les configurations que nous avons définies dans fsdp_qlora_full_shard.yaml comme normales.
• Configuration automatique : Les variables DSTACK_MASTER_NODE_IP, DSTACK_NODE_RANK, DSTACK_GPUS_NUM et DSTACK_NODES_NUM sont gérées automatiquement par dstack, ce qui réduit la configuration manuelle.
• Affectation de ressources : dstack facilite la spécification du nombre de noeuds et de GPU (gpu : 1..2) pour la tâche de réglage fin. Par conséquent, pour ce tutoriel, il y a trois noeuds dont chacun est équipé de 2 processeurs graphiques A10(24 Go).

Tâche 4 : Servez votre modèle à réglage fin avec dstack

Une fois votre modèle ajusté, dstack facilite son déploiement sur OCI à l'aide du cadre TGI (Hugging Face Text Generation Inference).

Voici un exemple de définition d'un service dans dstack :

type: service
image: ghcr.io/huggingface/text-generation-inference:latest
env:
  - HUGGING_FACE_HUB_TOKEN
  - MODEL_ID=chansung/mental_health_counseling_merged_v0.1
commands:
  - text-generation-launcher \
    --max-input-tokens 512 --max-total-tokens 1024 \
    --max-batch-prefill-tokens 512 --port 8000
port: 8000

resources:
  gpu:
    memory: 48GB

# (Optional) Enable the OpenAI-compatible endpoint
model:
  format: tgi
  type: chat
  name: chansung/mental_health_counseling_merged_v0.1

Principaux avantages de cette approche :

• Passerelle HTTPS sécurisée : dstack simplifie le processus de configuration d'une connexion HTTPS sécurisée au moyen d'une passerelle, un aspect crucial du service de modèle de niveau production.
• Optimisé pour l'inférence : Le cadre TGI est conçu pour l'inférence de génération de texte efficace, ce qui garantit que votre modèle offre des résultats réactifs et fiables.
• Ajustement automatique : dstack permet de spécifier la politique d'ajustement automatique, notamment le nombre minimal et maximal de répliques de modèle.

À ce stade, vous pouvez interagir avec le service à l'aide de la commande curl standard et des demandes Python, de la trousse SDK OpenAI et des bibliothèques client d'inférence de Hugging Face. Par exemple, l'extrait de code suivant présente un exemple de curl.

curl -X POST https://black-octopus-1.mycustomdomain.com/generate \
  -H "Authorization: Bearer <dstack-token>" \
  -H 'Content-Type: application/json' \
  -d '{"inputs": "I feel bad...", "parameters": {"max_new_tokens": 128}}'

De plus, pour un modèle déployé, dstack fournit automatiquement une interface utilisateur pour interagir directement avec le modèle.

Étapes suivantes

En suivant les étapes décrites dans ce tutoriel, vous avez débloqué une approche puissante pour affiner et déployer les LLM à l'aide des capacités combinées de dstack, OCI et de l'écosystème Hugging Face. Vous pouvez maintenant tirer parti de l'interface conviviale de dstack pour gérer vos ressources OCI de manière efficace, simplifiant le processus de configuration des environnements de formation répartis pour vos projets de LLM.

De plus, l'intégration avec le manuel d'alignement de Hugging Face et le cadre TGI vous permet d'affiner et de servir vos modèles de façon transparente, en vous assurant qu'ils sont optimisés pour les performances et prêts pour les applications du monde réel. Nous vous encourageons à explorer davantage les possibilités et à expérimenter différents modèles et configurations pour atteindre les résultats souhaités dans le monde du traitement du langage naturel.

Confirmation

• Auteur - Chansung Park (HuggingFace boursier - chercheur en intelligence artificielle), Yann Caniou (spécialiste en infra/GPU de l'IA), Bruno Garbaccio (spécialiste en infra/GPU de l'IA)

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.

---

Titre et droits d'auteur

Fine-Tune and Serve Large Language Models on Oracle Cloud Infrastructure with dstack

G11975-01

July 2024

Copyright ©2024,

Oracle et/ou ses sociétés affiliées.