Hinweis:

Optimieren und bedienen Sie große Sprachmodelle auf Oracle Cloud Infrastructure mit dstack

Einführung

dstack ist ein Open-Source-Tool, das die Orchestrierung von künstlicher Intelligenz-(KI-)Containern vereinfacht und das verteilte Training und Deployment von Large Language Models (LLMs) zugänglicher macht. Durch die Kombination von dstack und Oracle Cloud Infrastructure (OCI) wird ein optimierter Prozess zum Einrichten der Cloud-Infrastruktur für verteiltes Training und skalierbares Modell-Deployment freigeschaltet.

Wie funktioniert dstack?

dstack bietet eine einheitliche Schnittstelle für die Entwicklung, Schulung und Bereitstellung von KI-Modellen in jeder Cloud oder jedem Data Center. Beispiel: Sie können eine Konfiguration für eine Trainingsaufgabe oder ein Modell angeben, das bereitgestellt werden soll. dstack übernimmt die Einrichtung der erforderlichen Infrastruktur und die Orchestrierung der Container. Einer der Vorteile von dstack besteht darin, dass es die Verwendung beliebiger Hardware, Frameworks und Skripte ermöglicht.

Ziele

Voraussetzungen

Aufgabe 1: dstack mit OCI einrichten

  1. Installieren Sie das Python-Package dstack mit dem folgenden Befehl. Da dstack mehrere Cloud-Provider unterstützt, können wir den Geltungsbereich auf OCI eingrenzen.

    pip install dstack[oci]

  2. Konfigurieren Sie die OCI-spezifischen Zugangsdaten in der Datei ~/.dstack/server/config.yml. Im folgenden Code wird davon ausgegangen, dass Zugangsdaten für die OCI-Befehlszeilenschnittstelle (CLI) konfiguriert sind. Weitere Konfigurationsoptionen finden Sie in der dstack-Dokumentation.

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

  3. Führen Sie den dstack-Server mit dem folgenden Befehl aus.

    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. Wechseln Sie mit den Projektskripten zum Ordner, und initialisieren Sie dstack mit dem folgenden Befehl.

    dstack init

Aufgabe 2: Job auf OCI mit dstack optimieren

Zur Feinabstimmung des Gemma 7B-Modells werden wir das Hugging Face Alignment Handbook verwenden, um die Einbeziehung der besten Feinabstimmungspraktiken sicherzustellen. Den Quellcode dieses Tutorials finden Sie hier: GitHub. Lassen Sie uns in die praktischen Schritte zur Feinabstimmung Ihres LLM eintauchen.

Nachdem Sie zum Projektordner gewechselt haben, initiieren Sie mit den folgenden Befehlen den Feinabstimmungsjob auf OCI mit 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

Die Umgebungsvariablen FT_MODEL_CONFIG_PATH, ACCEL_CONFIG_PATH, HUGGING_FACE_HUB_TOKEN und WANDB_API_KEY werden in der Aufgabenkonfiguration ft.task.dstack.yml definiert. dstack run leitet die in ft.task.dstack.yml definierte Aufgabe auf OCI weiter.

Hinweis: dstack kopiert beim Ausführen der Aufgabe automatisch den aktuellen Verzeichnisinhalt.

Lassen Sie uns die wichtigsten Teile jeder YAML-Datei untersuchen (für den vollständigen Inhalt, überprüfen Sie das Repository).

Die Datei qlora_finetune_config.yaml ist die Rezeptkonfiguration, mit der das Alignment Handbook die Feinabstimmung eines großen Sprachmodells (LLM) versteht.

# 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
# ...

Die konfigurierten fsdp_qlora_full_shard.yaml-Dateien beschleunigen die Verwendung der zugrunde liegenden Infrastruktur für die Feinabstimmung des 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)

Hybrid-Shards

Wenn Sie FSDP von distributed_type und FULL_SHARD von fsdp_sharding_strategy von fsdp_config verwenden, wird ein Modell über mehrere GPUs in einem einzelnen Rechner in Shards unterteilt. Bei mehreren Compute Nodes hostet jeder Knoten eine identische Kopie des Modells, die selbst auf mehrere GPUs innerhalb dieses Knotens aufgeteilt ist. Das bedeutet, dass jede partitionierte Modellinstanz auf jedem Knoten verschiedene Abschnitte oder Batches Ihres Datasets verarbeitet. Um ein einzelnes Modell auf mehrere GPUs zu verteilen, die sich über mehrere Knoten erstrecken, konfigurieren Sie den Parameter fsdp_sharding_strategy als HYBRID_SHARD.

Zusätzliche Parameter wie machine_rank, num_machines und num_processes sind für die Koordination wichtig. Es wird jedoch empfohlen, diese Werte zur Laufzeit dynamisch festzulegen, da dies beim Wechsel zwischen verschiedenen Infrastruktur-Setups Flexibilität bietet.

Aufgabe 3: Weisen Sie dstack mit der vereinfachten Konfiguration an, Infrastruktur bereitzustellen

Sehen wir uns die fsdp_qlora_full_shard.yaml-Konfiguration an, die alles zusammenfasst und dstack anweist, wie Sie Infrastruktur bereitstellen und die Aufgabe ausführen.

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

Wichtige Punkte zum Hervorheben:

Aufgabe 4: Servieren Sie Ihr fein abgestimmtes Modell mit dstack

Nach der Feinabstimmung Ihres Modells ist es mit dstack ein Kinderspiel, es mit dem Hugging Face Text Generation Inference-(TGI-)Framework auf OCI bereitzustellen.

Im Folgenden finden Sie ein Beispiel für die Definition eines Service in 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

Die wichtigsten Vorteile dieses Ansatzes:

An diesem Punkt können Sie mit dem Service mit dem Standardbefehl curl und den Python-Anforderungen, dem OpenAI-SDK und den Inferenzclientbibliotheken von Hugging Face interagieren. Beispiel: Das folgende Code-Snippet zeigt ein Beispiel für 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}}'

Darüber hinaus stellt dstack für ein bereitgestelltes Modell automatisch eine Benutzeroberfläche bereit, mit der direkt mit dem Modell interagiert werden kann.

Benutzeroberfläche

Nächste Schritte

Durch Befolgen der in diesem Tutorial beschriebenen Schritte haben Sie einen leistungsstarken Ansatz für die Feinabstimmung und Bereitstellung von LLMs mit den kombinierten Funktionen von dstack, OCI und dem Hugging Face-Ökosystem freigeschaltet. Sie können jetzt die benutzerfreundliche Oberfläche von dstack nutzen, um Ihre OCI-Ressourcen effektiv zu verwalten und den Prozess der Einrichtung verteilter Schulungsumgebungen für Ihre LLM-Projekte zu optimieren.

Durch die Integration mit dem Alignment-Handbuch von Hugging Face und dem TGI-Framework können Sie Ihre Modelle nahtlos optimieren und bedienen, um sicherzustellen, dass sie für die Leistung optimiert und für reale Anwendungen bereit sind. Wir empfehlen Ihnen, die Möglichkeiten weiter zu erkunden und mit verschiedenen Modellen und Konfigurationen zu experimentieren, um Ihre gewünschten Ergebnisse in der Welt der Natural Language Processing zu erzielen.

Danksagungen

Weitere Lernressourcen

Lernen Sie andere Übungen auf docs.oracle.com/learn kennen, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube Channel zu. Außerdem können Sie education.oracle.com/learning-explorer besuchen, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.