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. 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, nous vous recommandons d'essayer notre solution de déploiement Vertex AI.

Contexte

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.

Objectifs

Ce guide est destiné aux utilisateurs nouveaux ou existants de GKE, aux ingénieurs en ML, aux ingénieurs MLOps (DevOps) ou aux administrateurs de plate-forme qui souhaitent utiliser les fonctionnalités d'orchestration de conteneurs Kubernetes pour affiner des LLM sur du matériel GPU H100, A100 et L4.

À la fin de ce guide, vous devriez être capable d'effectuer les étapes suivantes:

  1. Préparez votre environnement avec un cluster GKE en mode Autopilot.
  2. Créez un conteneur d'affinage.
  3. Utilisez un GPU pour affiner le modèle Gemma 2B et l'importer dans Hugging Face.

Avant de commencer

  • Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

    Enable the API

    •

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

    Enable the API

    •

  • Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

    Check for the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.

    3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

    4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.

    Grant the roles

    1. In the Google Cloud console, go to the IAM page.

      Accéder à IAM
    2. Sélectionnez le projet.
    3. Cliquez sur Accorder l'accès.

    4. Dans le champ Nouveaux comptes principaux, saisissez votre identifiant utilisateur. Il s'agit généralement de l'adresse e-mail d'un compte Google.

    5. Dans la liste Sélectionner un rôle, sélectionnez un rôle.
    6. Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
    7. Cliquez sur Enregistrer.

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 sur Google 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 console Google 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 REGION=REGION
export CLUSTER_NAME=finetuning
export HF_TOKEN=HF_TOKEN
export HF_PROFILE=HF_PROFILE

    Remplacez les valeurs suivantes :

    • PROJECT_ID : L'ID de votre projet Google Cloud.
    • REGION: région compatible avec le type d'accélérateur que vous souhaitez utiliser, par exemple us-central1 pour les GPU L4.
    • 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. Nous vous recommandons d'utiliser un cluster GKE Autopilot pour une expérience Kubernetes entièrement gérée. Pour choisir le mode de fonctionnement GKE le mieux adapté à vos charges de travail, consultez la section Choisir un mode de fonctionnement GKE.

Autopilot

Dans Cloud Shell, exécutez la commande suivante :

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --release-channel=rapid \
  --cluster-version=1.29

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} \
  --region=${REGION} \
  --workload-pool=${PROJECT_ID}.svc.id.goog \
  --release-channel=rapid \
  --num-nodes=1

    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=${REGION} \
  --node-locations=${REGION}-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=${REGION}

  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 -

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éer un dépôt Docker Artifact Registry

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

  2. Créer et transférer 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

Déployer le job d'affinage Gemma

  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.

  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: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20240220_0936_RC01
        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.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        env:
        - 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éer une variable d'environnement pour un nouvel MODEL_ID 

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

  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-finetune

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 :

L'exemple de commande suivant est 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.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer les ressources déployées

Pour éviter que les ressources que vous avez créées dans ce guide soient facturées sur votre compte Google Cloud, exécutez la commande suivante:

gcloud container clusters delete ${CLUSTER_NAME} \
  --region=${REGION}

Étapes suivantes