Remarques :

• Ce tutoriel nécessite un accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, reportez-vous à Introduction au niveau gratuit d'Oracle Cloud Infrastructure.
• Il utilise des exemples de valeur pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. A la fin de l'exercice, remplacez ces valeurs par des valeurs propres à votre environnement cloud.

Réglez et servez des modèles de langage volumineux sur Oracle Cloud Infrastructure avec dstack

Introduction

dstack est un outil open source qui simplifie l'orchestration de conteneurs d'intelligence artificielle (IA) et rend plus accessible l'entraînement et le déploiement distribués de modèles de langage volumineux. L'association de dstack et d'Oracle Cloud Infrastructure (OCI) déverrouille un processus simplifié de configuration de l'infrastructure cloud pour l'entraînement distribué et le déploiement de modèles évolutifs.

Fonctionnement de dstack

dstack offre une interface unifiée pour le développement, l'entraînement et le déploiement de modèles d'IA dans n'importe quel cloud ou centre de données. Par exemple, vous pouvez indiquer une configuration pour une tâche d'entraînement ou un modèle à déployer, et dstack se charge de configurer l'infrastructure requise et d'orchestrer les conteneurs. L'un des avantages offerts par dstack est qu'il permet l'utilisation de tout matériel, frameworks et scripts.

Objectifs

• Affinez le réglage d'un modèle LLM à l'aide de dstack sur OCI, intégrez les meilleures pratiques du manuel d'alignement de face Hugging et déployez le modèle à l'aide de l'inférence de génération de texte de face Hugging (TGI).

  Remarque : l'expérience décrite dans le tutoriel utilise un cluster OCI de trois noeuds, chacun avec 2 GPU A10, pour affiner le modèle Gemma 7B.

Prérequis

• Accès à une location OCI.

• Accès aux formes avec un GPU NVIDIA tel que les GPU A10 (par exemple, VM.GPU.A10.2). Pour plus d'informations sur les demandes d'augmentation de la limite, reportez-vous à 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 le package Python dstack à l'aide de la commande suivante. Comme dstack prend en charge plusieurs fournisseurs cloud, nous pouvons limiter la portée à OCI.

   pip install dstack[oci]
   

2. Configurez les informations d'identification propres à OCI dans le fichier ~/.dstack/server/config.yml. Le code suivant suppose que vous disposez d'informations d'identification pour l'interface de ligne de commande (CLI) OCI configurée. Pour obtenir d'autres options de configuration, reportez-vous à la dstack documentation.

   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. Accédez au dossier contenant vos scripts de projet et initialisez dstack à l'aide de la commande suivante.

   dstack init
   

Tâche 2 : affiner le travail sur OCI avec dstack

Pour peaufiner le modèle Gemma 7B, nous utiliserons le manuel d'alignement du visage pour assurer l'intégration des meilleures pratiques d'ajustement. Le code source de ce tutoriel est disponible ici : GitHub. Laissez-nous plonger dans les étapes pratiques pour affiner votre LLM.

Une fois que vous avez basculé vers le dossier du projet, utilisez les commandes suivantes pour lancer le travail 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.

Remarque : dstack copie automatiquement le contenu du répertoire en cours 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 utilisée par le manuel d'alignement pour comprendre comment affiner un modèle de langage volumineux.

# 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 tokeniseur choisi. 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 manière 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 diviser un modèle en GPU 2 x A10 tout en tirant parti de la technique QLoRA.

• Arguments LoRA : configurations spécifiques à LoRA. Comme ce tutoriel utilise la technique FSDP+QLoRA, load_in_4bit est défini sur true. D'autres configurations peuvent varier d'une expérience à l'autre.

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

Le fichier fsdp_qlora_full_shard.yaml configure la façon d'accélérer l'utilisation de l'infrastructure sous-jacente pour affiner le 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 de Fullly Sharded Data Parallel (FSDP), une technique qui permet d'entraîner des modèles volumineux qui, autrement, ne seraient pas adaptés à un seul GPU.
• fsdp_config : ces options permettent de configurer le fonctionnement de Full Stack Disaster Recovery, par exemple la façon dont le modèle est partagé (fsdp_sharding_strategy) et si les paramètres sont déchargés vers la CPU (fsdp_offload_params).

Avec FSDP de distributed_type et FULL_SHARD de fsdp_sharding_strategy de fsdp_config, un modèle sera distribué sur plusieurs GPU dans une seule machine. Lorsqu'il s'agit de plusieurs noeuds de calcul, chaque noeud héberge une copie identique du modèle, qui est lui-même répartie entre plusieurs GPU au sein de ce noeud. Cela signifie que chaque instance de modèle partitionné sur chaque noeud traite différentes sections ou lots de votre ensemble de données. Pour distribuer un modèle unique sur plusieurs GPU couvrant 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 certaine flexibilité lors du basculement entre différentes configurations d'infrastructure.

Tâche 3 : indiquer à dstack d'utiliser la configuration simplifiée pour provisionner l'infrastructure

Explorons la configuration fsdp_qlora_full_shard.yaml qui rassemble 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 facilement à l'écosystème open source Hugging Face. En particulier, vous pouvez simplement utiliser la bibliothèque Accelerate 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 des ressources : dstack facilite la spécification du nombre de noeuds et de GPU (gpu : 1..2) pour le travail de réglage fin. Par conséquent, pour ce tutoriel, il existe trois noeuds dotés chacun de 2 GPU A10(24 Go).

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

Une fois votre modèle affiné, dstack facilite son déploiement sur OCI à l'aide de la structure 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 via une passerelle, un aspect crucial du service de modèle au niveau de la production.
• Optimisé pour l'inférence : la structure TGI est conçue pour une inférence de génération de texte efficace, garantissant que votre modèle fournit des résultats réactifs et fiables.
• Redimensionnement automatique : dstack permet d'indiquer la stratégie de redimensionnement automatique, y compris le nombre minimal et maximal de répliques de modèle.

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

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}}'

En outre, pour un modèle déployé, dstack fournit automatiquement une interface utilisateur permettant d'interagir directement avec le modèle.

Etapes suivantes

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

En outre, 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 manière transparente, en vous assurant qu'ils sont optimisés pour les performances et prêts pour des applications concrètes. 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.

Remerciements

• Auteur - Chansung Park (HuggingFace fellow - chercheur en IA), Yann Caniou (AI Infra/GPU Specialist), Bruno Garbaccio (AI Infra/GPU Specialist)

Ressources de formation supplémentaires

Parcourez d'autres ateliers sur docs.oracle.com/learn ou accédez à davantage de contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, rendez-vous sur education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

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

---

Informations relatives au titre et au copyright

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

G11976-01

July 2024

Copyright ©2024,

Oracle et/ou ses affiliés.