Cette page a été traduite par l'API Cloud Translation.

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 :

Découvrez la disponibilité actuelle des versions des GPU.
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 :

Accédez à la page de consentement du modèle sur Kaggle.com.
Vérifiez l'autorisation à l'aide de votre compte Hugging Face.
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 :

Cliquez sur Your Profile > Settings > Access Tokens (Votre profil > Paramètres > Jetons d'accès).
Sélectionnez New Token (Nouveau jeton).
Spécifiez le nom de votre choix et un rôle d'au moins Write.
Sélectionnez Générer un jeton.
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 :

Dans la console Google Cloud , lancez une session Cloud Shell en cliquant sur Activer Cloud Shell dans la consoleGoogle Cloud . Une session s'ouvre dans le volet inférieur de la console Google Cloud .
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.

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

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.

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 :

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

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.

Créez et transférez l'image:
```
gcloud builds submit .
```

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.

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

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.
Mettez à jour le job en exécutant la commande suivante :
```
watch kubectl get pods
```
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.
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.

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

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.

Remplacez MODEL_ID dans le fichier manifeste :

sed -i "s|google/gemma-2b|$MODEL_ID|g" serve-gemma.yaml

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.

Attendez que le déploiement soit disponible :

kubectl wait --for=condition=Available --timeout=700s deployment/vllm-gemma-deployment

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.

Affiner les modèles ouverts Gemma à l'aide de plusieurs GPU sur GKE Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.