Affiner les modèles ouverts Gemma à l'aide de plusieurs GPU sur GKE

Ce tutoriel vous explique comment affiner un grand modèle de langage (LLM) Gemma, notre famille de modèles ouverts, à l'aide de processeurs graphiques (GPU) sur Google Kubernetes Engine (GKE) avec la bibliothèque Transformers de Hugging Face. L'affinage est un processus d'apprentissage supervisé qui améliore la capacité d'un modèle pré-entraîné à effectuer des tâches spécifiques en mettant à jour ses paramètres avec un nouvel ensemble de données. Dans ce tutoriel, vous allez télécharger les modèles de la famille Gemma pré-entraînés de paramètre 2B à partir de Hugging Face et les affiner sur un cluster GKE Autopilot ou Standard.

Ce guide est un bon point de départ si vous avez besoin du contrôle précis, de l'évolutivité, de la résilience, de la portabilité et de la rentabilité des services Kubernetes gérés lors de l'affinage d'un LLM.

Bonne pratique :

Essayez notre solution Vertex AI si vous avez besoin d'une plate-forme d'IA gérée unifiée pour créer et diffuser rapidement des modèles de ML à moindre coût.

Arrière-plan

En diffusant Gemma à l'aide de GPU sur GKE avec la bibliothèque Transformers, vous pouvez mettre en œuvre une solution de diffusion d'inférences robuste et prête pour la production avec tous les avantages de Kubernetes géré, y compris une évolutivité efficace et une meilleure disponibilité. Cette section décrit les principales technologies utilisées dans ce guide.

Gemma

Gemma est un ensemble de modèles d'intelligence artificielle (IA) générative, légers et disponibles publiquement, publiés sous licence ouverte. Ces modèles d'IA sont disponibles pour s'exécuter dans vos applications, votre matériel, vos appareils mobiles ou vos services hébergés.

Dans ce guide, nous présentons Gemma pour la génération de texte. Vous pouvez également affiner ces modèles pour vous spécialiser dans l'exécution de tâches spécifiques.

L'ensemble de données que vous utilisez dans ce document est b-mc2/sql-create-context.

Pour en savoir plus, consultez la documentation Gemma.

GPU

Les GPU vous permettent d'accélérer des charges de travail spécifiques exécutées sur vos nœuds, telles que le machine learning et le traitement de données. GKE fournit toute une gamme d'options de types de machines pour la configuration des nœuds, y compris les types de machines avec des GPU NVIDIA H100, L4 et A100.

Avant d'utiliser des GPU dans GKE, nous vous recommandons de suivre le parcours de formation suivant :

  1. Découvrez la disponibilité actuelle des versions des GPU.
  2. Apprenez-en plus sur les GPU dans GKE.

Hugging Face Transformers

La bibliothèque Transformers de Hugging Face vous permet d'accéder à des modèles pré-entraînés de pointe. La bibliothèque Transformers vous permet de réduire la durée, les ressources et les coûts de calcul associés à l'entraînement complet du modèle.

Dans ce tutoriel, vous allez utiliser les API et les outils Hugging Face pour télécharger et affiner ces modèles pré-entraînés.

Accéder au modèle

Pour accéder aux modèles Gemma en vue du déploiement sur GKE, vous devez d'abord signer le contrat d'autorisation de licence, puis générer un jeton d'accès Hugging Face.

Vous devez signer le contrat de consentement pour utiliser Gemma. Procédez comme suit :

  1. Accédez à la page de consentement du modèle sur Kaggle.com.
  2. Vérifiez l'autorisation à l'aide de votre compte Hugging Face.
  3. Acceptez les conditions du modèle.

Générer un jeton d'accès

Pour accéder au modèle via Hugging Face, vous avez besoin d'un jeton Hugging Face.

Pour générer un nouveau jeton si vous n'en possédez pas, procédez comme suit :

  1. Cliquez sur Your Profile > Settings > Access Tokens (Votre profil > Paramètres > Jetons d'accès).
  2. Sélectionnez New Token (Nouveau jeton).
  3. Spécifiez le nom de votre choix et un rôle d'au moins Write.
  4. Sélectionnez Générer un jeton.
  5. Copiez le jeton dans votre presse-papiers.

Préparer votre environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées surGoogle Cloud. Cloud Shell est préinstallé avec les logiciels dont vous avez besoin pour ce tutoriel, y compris kubectl et gcloud CLI.

Pour configurer votre environnement avec Cloud Shell, procédez comme suit :

  1. Dans la console Google Cloud , lancez une session Cloud Shell en cliquant sur Icône d'activation Cloud Shell Activer Cloud Shell dans la consoleGoogle Cloud . Une session s'ouvre dans le volet inférieur de la console Google Cloud .

  2. Définissez les variables d'environnement par défaut :

    gcloud config set project PROJECT_ID
    export PROJECT_ID=$(gcloud config get project)
    export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
    export CLUSTER_NAME=CLUSTER_NAME
    export HF_TOKEN=HF_TOKEN
    export HF_PROFILE=HF_PROFILE
    

    Remplacez les valeurs suivantes :

    • PROJECT_ID : ID de votre projet Google Cloud.
    • CONTROL_PLANE_LOCATION : région Compute Engine du plan de contrôle de votre cluster. Indiquez une région compatible avec le type d'accélérateur que vous souhaitez utiliser, par exemple us-central1 pour les GPU L4.
    • CLUSTER_NAME : nom du cluster
    • HF_TOKEN : jeton Hugging Face que vous avez généré précédemment.
    • HF_PROFILE : ID du profil Hugging Face que vous avez créé précédemment.
  3. Clonez l'exemple de dépôt de code depuis GitHub :

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    cd kubernetes-engine-samples/ai-ml/llm-finetuning-gemma
    

Créer et configurer des ressources Google Cloud

Suivez les instructions ci-dessous pour créer les ressources requises.

Créer un cluster GKE et un pool de nœuds

Vous pouvez diffuser les modèles Gemma sur des GPU dans un cluster GKE Autopilot ou GKE Standard. Pour choisir le mode de fonctionnement GKE le mieux adapté à vos charges de travail, consultez la section Choisir un mode de fonctionnement GKE.

Bonne pratique:

Utilisez Autopilot pour une expérience Kubernetes entièrement gérée.

Autopilot

Dans Cloud Shell, exécutez la commande suivante :

gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --release-channel=rapid \
    --cluster-version=1.29

Remplacez les valeurs suivantes :

  • PROJECT_ID : ID de votre projet Google Cloud.
  • CONTROL_PLANE_LOCATION : région Compute Engine du plan de contrôle de votre cluster. Indiquez une région compatible avec le type d'accélérateur que vous souhaitez utiliser, par exemple us-central1 pour les GPU L4.
  • CLUSTER_NAME : nom du cluster

GKE crée un cluster Autopilot avec des nœuds de processeur et de GPU, à la demande des charges de travail déployées.

Standard

  1. Dans Cloud Shell, exécutez la commande suivante pour créer un cluster GKE Standard :

    gcloud container clusters create CLUSTER_NAME \
        --project=PROJECT_ID \
        --location=CONTROL_PLANE_LOCATION \
        --workload-pool=PROJECT_ID.svc.id.goog \
        --release-channel=rapid \
        --num-nodes=1
    

    Remplacez les valeurs suivantes :

    • PROJECT_ID : ID de votre projet Google Cloud.
    • CONTROL_PLANE_LOCATION : région Compute Engine du plan de contrôle de votre cluster. Indiquez une région compatible avec le type d'accélérateur que vous souhaitez utiliser, par exemple us-central1 pour les GPU L4.
    • CLUSTER_NAME : nom du cluster

    La création du cluster peut prendre plusieurs minutes.

  2. Exécutez la commande suivante pour créer un pool de nœuds pour votre cluster :

    gcloud container node-pools create gpupool \
        --accelerator type=nvidia-l4,count=8,gpu-driver-version=latest \
        --project=PROJECT_ID \
        --location=CONTROL_PLANE_LOCATION \
        --node-locations=CONTROL_PLANE_LOCATION-a \
        --cluster=CLUSTER_NAME \
        --machine-type=g2-standard-96 \
        --num-nodes=1
    

    GKE crée un pool de nœuds unique contenant deux GPU L4 pour chaque nœud.

Créer un secret Kubernetes pour les identifiants Hugging Face

Dans Cloud Shell, procédez comme suit :

  1. Configurez kubectl de manière à communiquer avec votre cluster :

    gcloud container clusters get-credentials CLUSTER_NAME \
        --location=CONTROL_PLANE_LOCATION
    

    Remplacez les valeurs suivantes :

    • CONTROL_PLANE_LOCATION : région Compute Engine du plan de contrôle de votre cluster.
    • CLUSTER_NAME : nom du cluster
  2. Créez un secret Kubernetes contenant le jeton Hugging Face:

    kubectl create secret generic hf-secret \
        --from-literal=hf_api_token=$HF_TOKEN \
        --dry-run=client -o yaml | kubectl apply -f -
    

    Remplacez $HF_TOKEN par le jeton Hugging Face que vous avez généré précédemment, ou utilisez la variable d'environnement si vous l'avez définie.

Créer un conteneur d'affinage à l'aide de Docker et Cloud Build

Ce conteneur utilise le code PyTorch et Hugging Face Transformers pour affiner le modèle Gemma pré-entraîné existant.

  1. Créez un dépôt Docker Artifact Registry :

    gcloud artifacts repositories create gemma \
        --project=PROJECT_ID \
        --repository-format=docker \
        --location=us \
        --description="Gemma Repo"
    

    Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

  2. Créez et transférez l'image:

    gcloud builds submit .
    
  3. Exportez le IMAGE_URL pour une utilisation ultérieure dans ce tutoriel.

    export IMAGE_URL=us-docker.pkg.dev/PROJECT_ID/gemma/finetune-gemma-gpu:1.0.0
    

Exécuter un job d'affinage sur GKE

Dans cette section, vous allez déployer le job d'affinage Gemma. Dans Kubernetes, un contrôleur Job crée un ou plusieurs pods et s'assure qu'ils exécutent correctement une tâche spécifique.

  1. Ouvrez le fichier finetune.yaml.

    apiVersion: batch/v1
    kind: Job
    metadata:
      name: finetune-job
      namespace: default
    spec:
      backoffLimit: 2
      template:
        metadata:
          annotations:
            kubectl.kubernetes.io/default-container: finetuner
        spec:
          terminationGracePeriodSeconds: 600
          containers:
          - name: finetuner
            image: $IMAGE_URL
            resources:
              limits:
                nvidia.com/gpu: "8"
            env:
            - name: MODEL_NAME
              value: "google/gemma-2b"
            - name: NEW_MODEL
              value: "gemma-2b-sql-finetuned"
            - name: LORA_R
              value: "8"
            - name: LORA_ALPHA
              value: "16"
            - name: TRAIN_BATCH_SIZE
              value: "1"
            - name: EVAL_BATCH_SIZE
              value: "2"
            - name: GRADIENT_ACCUMULATION_STEPS
              value: "2"
            - name: DATASET_LIMIT
              value: "1000"
            - name: MAX_SEQ_LENGTH
              value: "512"
            - name: LOGGING_STEPS
              value: "5"
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
          volumes:
          - name: dshm
            emptyDir:
              medium: Memory
          nodeSelector:
            cloud.google.com/gke-accelerator: nvidia-l4
          restartPolicy: OnFailure
  2. Appliquez le fichier manifeste pour créer le job d'affinage :

    envsubst < finetune.yaml | kubectl apply -f -
    

    Cette instruction remplace IMAGE_URL par la variable du fichier manifeste.

  3. Mettez à jour le job en exécutant la commande suivante :

    watch kubectl get pods
    
  4. Vérifiez les journaux du job en exécutant la commande suivante :

    kubectl logs job.batch/finetune-job -f
    

    La ressource du job télécharge les données du modèle, puis affine le modèle sur les huit GPU. Cette opération peut prendre jusqu'à 20 minutes.

  5. Une fois le job terminé, accédez à votre compte Hugging Face. Un nouveau modèle nommé HF_PROFILE/gemma-2b-sql-finetuned apparaît dans votre profil Hugging Face.

Diffuser le modèle affiné sur GKE

Dans cette section, vous allez déployer le conteneur vLLM pour diffuser le modèle Gemma. Ce tutoriel utilise un déploiement Kubernetes pour déployer le conteneur vLLM. Un déploiement est un objet de l'API Kubernetes qui vous permet d'exécuter plusieurs instances dupliquées de pods répartis entre les nœuds d'un cluster.

  1. Créez le fichier manifeste serve-gemma.yaml suivant :

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: vllm-gemma-deployment
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: gemma-server
      template:
        metadata:
          labels:
            app: gemma-server
            ai.gke.io/model: gemma-2b
            ai.gke.io/inference-server: vllm
            examples.ai.gke.io/source: user-guide
        spec:
          containers:
          - name: inference-server
            image: docker.io/vllm/vllm-openai:v0.10.0
            resources:
              requests:
                cpu: "2"
                memory: "7Gi"
                ephemeral-storage: "10Gi"
                nvidia.com/gpu: 1
              limits:
                cpu: "2"
                memory: "7Gi"
                ephemeral-storage: "10Gi"
                nvidia.com/gpu: 1
            command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
            args:
            - --model=$(MODEL_ID)
            - --tensor-parallel-size=1
            env:
            - name: LD_LIBRARY_PATH
              value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
            - name: MODEL_ID
              value: google/gemma-2b
            - name: HUGGING_FACE_HUB_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
          volumes:
          - name: dshm
            emptyDir:
                medium: Memory
          nodeSelector:
            cloud.google.com/gke-accelerator: nvidia-l4
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: llm-service
    spec:
      selector:
        app: gemma-server
      type: ClusterIP
      ports:
        - protocol: TCP
          port: 8000
          targetPort: 8000
  2. Créez la variable d'environnement pour le nouveau MODEL_ID :

    export MODEL_ID=HF_PROFILE/gemma-2b-sql-finetuned
    

    Remplacez HF_PROFILE par l'ID de profil Hugging Face que vous avez créé précédemment.

  3. Remplacez MODEL_ID dans le fichier manifeste :

    sed -i "s|google/gemma-2b|$MODEL_ID|g" serve-gemma.yaml
    
  4. Appliquez le fichier manifeste :

    kubectl apply -f serve-gemma.yaml
    

    Un pod du cluster télécharge les pondérations du modèle à partir de Hugging Face et lance le moteur de diffusion.

  5. Attendez que le déploiement soit disponible :

    kubectl wait --for=condition=Available --timeout=700s deployment/vllm-gemma-deployment
    
  6. Affichez les journaux du déploiement en cours d'exécution :

    kubectl logs -f -l app=gemma-server
    

La ressource Déploiement télécharge les données du modèle. Ce processus peut prendre quelques minutes. Le résultat ressemble à ce qui suit :

INFO 01-26 19:02:54 model_runner.py:689] Graph capturing finished in 4 secs.
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Assurez-vous que le modèle est entièrement téléchargé avant de passer à la section suivante.

Diffuser le modèle

Dans cette section, vous allez interagir avec le modèle.

Configurer le transfert de port

Une fois le modèle déployé, exécutez la commande suivante pour configurer le transfert de port sur le modèle :

kubectl port-forward service/llm-service 8000:8000

Le résultat ressemble à ce qui suit :

Forwarding from 127.0.0.1:8000 -> 8000

Interagir avec le modèle à l'aide de curl

Dans une nouvelle session de terminal, utilisez curl pour discuter avec votre modèle :

Voici un exemple de commande pour TGI :

USER_PROMPT="Question: What is the total number of attendees with age over 30 at kubecon eu? Context: CREATE TABLE attendees (name VARCHAR, age INTEGER, kubecon VARCHAR)"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "prompt": "${USER_PROMPT}",
    "temperature": 0.1,
    "top_p": 1.0,
    "max_tokens": 24
}
EOF

Le résultat suivant affiche un exemple de réponse du modèle :

{"generated_text":" Answer: SELECT COUNT(age) FROM attendees WHERE age > 30 AND kubecon = 'eu'\n"}

Selon votre requête, vous devrez peut-être modifier la valeur max_token pour obtenir un meilleur résultat. Vous pouvez également utiliser le modèle adapté aux instructions pour une meilleure expérience de chat.