Esta página foi traduzida pela API Cloud Translation.

Implemente modelos abertos Gemma com GPUs no GKE com o Triton e o TensorRT-LLM

Autopilot Padrão

Este tutorial demonstra como implementar e publicar um modelo de linguagem (conteúdo extenso) (MDI/CE) Gemma usando GPUs no Google Kubernetes Engine (GKE) com a pilha de publicação da Triton e do TensorRT-LLM. Isto fornece uma base para compreender e explorar a implementação prática de MDIs/CEs para inferência num ambiente Kubernetes gerido. Implementa um contentor pré-criado com o Triton e o TensorRT-LLM no GKE. Também configura o GKE para carregar as ponderações do Gemma 2B e 7B.

Este tutorial destina-se a engenheiros de aprendizagem automática (AA), administradores e operadores de plataformas, e especialistas em dados e IA interessados em usar capacidades de orquestração de contentores do Kubernetes para publicar GMLs em hardware de GPU H100, A100 e L4. Para saber mais sobre as funções comuns e exemplos de tarefas que referimos no conteúdo, consulte o artigo Funções e tarefas comuns do utilizador do GKE. Google Cloud

Se precisar de uma plataforma de IA gerida unificada para criar e apresentar rapidamente modelos de ML de forma económica, recomendamos que experimente a nossa solução de implementação do Vertex AI.

Antes de ler esta página, certifique-se de que conhece o seguinte:

Contexto

Esta secção descreve as principais tecnologias usadas neste guia.

Gemma

O Gemma é um conjunto de modelos de inteligência artificial (IA) generativa, leves e disponíveis abertamente, lançados ao abrigo de uma licença aberta. Estes modelos de IA estão disponíveis para execução nas suas aplicações, hardware, dispositivos móveis ou serviços alojados. Pode usar os modelos Gemma para a geração de texto. No entanto, também pode ajustar estes modelos para tarefas especializadas.

Para saber mais, consulte a documentação do Gemma.

GPUs

As GPUs permitem-lhe acelerar cargas de trabalho específicas executadas nos seus nós, como a aprendizagem automática e o processamento de dados. O GKE oferece uma variedade de opções de tipos de máquinas para a configuração de nós, incluindo tipos de máquinas com GPUs NVIDIA H100, L4 e A100.

TensorRT-LLM

O NVIDIA TensorRT-LLM (TRT-LLM) é um conjunto de ferramentas com uma API Python para montar soluções otimizadas para definir MDIs/CEs e criar motores TensorRT que realizam inferências de forma eficiente em GPUs NVIDIA. O TensorRT-LLM inclui funcionalidades como:

Implementação otimizada do transformador com fusões de camadas, colocação em cache de ativação, reutilização do buffer de memória e PagedAttention
Processamento em lote contínuo ou em tempo real para melhorar o débito geral da publicação
Paralelismo de tensores e paralelismo de pipelines para publicação distribuída em várias GPUs
Quantização (FP16, FP8 e INT8)

Para saber mais, consulte a documentação do TensorRT-LLM.

Triton

O NVIDIA Triton Inference Server é um servidor de inferência de código aberto para aplicações de IA/ML. O Triton suporta a inferência de alto desempenho em GPUs NVIDIA e CPUs com backends otimizados, incluindo TensorRT e TensorRT-LLM. O Triton inclui funcionalidades como:

Inferência com várias GPUs e vários nós
Execução simultânea de vários modelos
Encadeamento ou combinação de modelos
Agrupamento estático, dinâmico e contínuo ou em curso de pedidos de previsão

Para saber mais, consulte a documentação do Triton.

Objetivos

Prepare o seu ambiente com um cluster do GKE no modo Autopilot.
Implemente um contentor com o Triton e o TritonRT-LLM no seu cluster.
Use o Triton e o TensorRT-LLM para publicar o modelo Gemma 2B ou 7B através do curl.

Antes de começar

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.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

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

In the Google Cloud console, go to the IAM page.
Go to IAM
Select the project.
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.
For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

Grant the roles

In the Google Cloud console, go to the IAM page.
Aceder ao IAM
Selecione o projeto.
Clique em Conceder acesso.
No campo Novos responsáveis, introduza o identificador do utilizador. Normalmente, este é o endereço de email de uma Conta Google.
Na lista Selecionar uma função, selecione uma função.
Para conceder funções adicionais, clique em Adicionar outra função e adicione cada função adicional.
Clique em Guardar.

Crie uma conta do Kaggle, se ainda não tiver uma.
Certifique-se de que o seu projeto tem quota suficiente para GPUs L4. Para saber mais, consulte os artigos Acerca das GPUs e Quotas de atribuição.

Prepare o seu ambiente

Neste tutorial, vai usar o Cloud Shell para gerir recursos alojados no Google Cloud. O Cloud Shell vem pré-instalado com o software de que precisa para este tutorial, incluindo o kubectl e a CLI gcloud.

Para configurar o seu ambiente com o Cloud Shell, siga estes passos:

Na Google Cloud consola, inicie uma sessão do Cloud Shell clicando em Ativar Cloud Shell na Google Cloud consola. Esta ação inicia uma sessão no painel inferior da consola. Google Cloud
Defina as variáveis de ambiente predefinidas:
```
gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
export CLUSTER_NAME=CLUSTER_NAME
```
Substitua os seguintes valores:
- PROJECT_ID: o seu Google Cloud ID do projeto.
- CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
- CLUSTER_NAME: o nome do cluster.

Aceda ao modelo

Para aceder aos modelos Gemma, tem de iniciar sessão na plataforma Kaggle e obter uma chave da API Kaggle.

Tem de assinar o contrato de consentimento para usar o Gemma. Siga estas instruções:

Aceda à página de consentimento do modelo em Kaggle.com.
Inicie sessão no Kaggle, se ainda não o tiver feito.
Clique em Pedir acesso.
Na secção Escolher conta para consentimento, selecione Validar através da conta do Kaggle para usar a sua conta do Kaggle para consentimento.
Aceite os Termos de Utilização do modelo.

Gere um token de acesso

Para aceder ao modelo através do Kaggle, precisa de um token da API Kaggle. Siga estes passos para gerar um novo token se ainda não tiver um:

No navegador, aceda às definições do Kaggle.
Na secção API, clique em Criar novo token.

É transferido um ficheiro com o nome kaggle.json.

Carregue o token de acesso para o Cloud Shell

No Cloud Shell, carregue o token da API Kaggle para o seu Google Cloud projeto:

No Cloud Shell, clique em Mais > Carregar.
Selecione Ficheiro e clique em Escolher ficheiros.
Abra o ficheiro kaggle.json.
Clique em Carregar.

Crie e configure Google Cloud recursos

Siga estas instruções para criar os recursos necessários.

Crie um cluster e um node pool do GKE

Pode publicar o Gemma em GPUs num cluster do GKE Autopilot ou Standard. Recomendamos que use um cluster do Autopilot para uma experiência do Kubernetes totalmente gerida. Para escolher o modo de funcionamento do GKE mais adequado às suas cargas de trabalho, consulte o artigo Escolha um modo de funcionamento do GKE.

Piloto automático

No Cloud Shell, execute o seguinte comando:

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

Substitua os seguintes valores:

PROJECT_ID: o seu Google Cloud ID do projeto.
CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
CLUSTER_NAME: o nome do cluster.

O GKE cria um cluster do Autopilot com nós de CPU e GPU, conforme solicitado pelas cargas de trabalho implementadas.

Standard

No Cloud Shell, execute o seguinte comando para criar um cluster Standard:
```
gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --release-channel=rapid \
    --machine-type=e2-standard-4 \
    --num-nodes=1
```
Substitua os seguintes valores:
- PROJECT_ID: o seu Google Cloud ID do projeto.
- CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
- CLUSTER_NAME: o nome do cluster.
A criação do cluster pode demorar vários minutos.

Execute o seguinte comando para criar um node pool para o cluster:

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

O GKE cria um único node pool que contém um nó de GPU L4.

Crie um segredo do Kubernetes para as credenciais da Kaggle

Neste tutorial, usa um segredo do Kubernetes para as credenciais do Kaggle.

No Cloud Shell, faça o seguinte:

Configure kubectl para comunicar com o cluster:
```
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION
```
Substitua os seguintes valores:
- CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo, us-central1 para a GPU L4.
- CLUSTER_NAME: o nome do cluster.

Crie um Secret para armazenar as credenciais do Kaggle:

kubectl create secret generic kaggle-secret \
    --from-file=kaggle.json \
    --dry-run=client -o yaml | kubectl apply -f -

Crie um recurso PersistentVolume para armazenar pontos de verificação

Nesta secção, cria um PersistentVolume suportado por um disco persistente para armazenar os pontos de verificação do modelo.

Crie o seguinte manifesto trtllm_checkpoint_pv.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: model-data
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 100G

Aplique o manifesto:

kubectl apply -f trtllm_checkpoint_pv.yaml

Transfira os ficheiros do motor TensorRT-LLM para o Gemma

Nesta secção, executa um trabalho do Kubernetes para concluir as seguintes tarefas:

Transfira os ficheiros do motor TensorRT-LLM e armazene-os no PersistentVolume que criou anteriormente.
Prepare os ficheiros de configuração para implementar o modelo no servidor Triton.

Um controlador de tarefas no Kubernetes cria um ou mais pods e garante que executam com êxito uma tarefa específica.

O processo seguinte pode demorar alguns minutos.

Gemma 2B-it

O motor TensorRT-LLM é criado a partir do ponto de verificação do PyTorch de 2 mil milhões de parâmetros do Gemma (ajustado por instruções) com ativação bfloat16, comprimento da sequência de entrada=2048 e comprimento da sequência de saída=1024 GPUs L4 direcionadas. Pode implementar o modelo numa única GPU L4.

Crie o seguinte manifesto job-download-gemma-2b.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: fetch-model-scripts
data:
  fetch_model.sh: |-
    #!/usr/bin/bash -x
    pip install kaggle --break-system-packages && \

    MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
    VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
    ACTIVATION_DTYPE=bfloat16 && \

    TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
    ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
    TRITON_MODEL_REPO=/data/triton/model_repository && \

    mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    mkdir -p ${ENGINE_PATH} && \
    mkdir -p ${TRITON_MODEL_REPO} && \

    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \

    # copying configuration files
    echo -e "\nCreating configuration files" && \
    cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \

    # updating configuration files
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \

    echo -e "\nCompleted extraction to ${ENGINE_PATH}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-gemma-2b
  labels:
    app: data-loader-gemma-2b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-gemma-2b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
        command:
        - /scripts/fetch_model.sh
        env:
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/tensorrtllm/2b-it/2"
        - name: WORLD_SIZE
          value: "1"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
        - mountPath: "/data"
          name: data
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts
      - name: data
        persistentVolumeClaim:
          claimName: model-data
      tolerations:
      - key: "key"
        operator: "Exists"
        effect: "NoSchedule"

Aplique o manifesto:

kubectl apply -f job-download-gemma-2b.yaml

Veja os registos da tarefa:

kubectl logs -f job/data-loader-gemma-2b

A saída dos registos é semelhante à seguinte:

...
Creating configuration files
+ echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/2b/bfloat16/1-gpu/'
+ echo -e '\nCreating configuration files'
...

Aguarde a conclusão da tarefa:

kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-2b

O resultado é semelhante ao seguinte:

job.batch/data-loader-gemma-2b condition met

Valide se a tarefa foi concluída com êxito (este processo pode demorar alguns minutos):

kubectl get job/data-loader-gemma-2b

O resultado é semelhante ao seguinte:

NAME             COMPLETIONS   DURATION   AGE
data-loader-gemma-2b   1/1           ##s        #m##s

Gemma 7B-it

O motor TensorRT-LLM é criado a partir do ponto de verificação do PyTorch de 7 mil milhões de bits (ajustado por instruções) do Gemma com ativação bfloat16, comprimento da sequência de entrada=1024 e comprimento da sequência de saída=512 direcionados para GPUs L4. Pode implementar o modelo numa única GPU L4.

Crie o seguinte manifesto job-download-gemma-7b.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: fetch-model-scripts
data:
  fetch_model.sh: |-
    #!/usr/bin/bash -x
    pip install kaggle --break-system-packages && \

    MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
    VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
    ACTIVATION_DTYPE=bfloat16 && \

    TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
    ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
    TRITON_MODEL_REPO=/data/triton/model_repository && \

    mkdir -p ${ENGINE_PATH} && \
    mkdir -p ${TRITON_MODEL_REPO} && \

    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \

    # copying configuration files
    echo -e "\nCreating configuration files" && \
    cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \

    # updating configuration files
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \

    echo -e "\nCompleted extraction to ${ENGINE_PATH}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-gemma-7b
  labels:
    app: data-loader-gemma-7b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-gemma-7b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
        command:
        - /scripts/fetch_model.sh
        env:
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/tensorrtllm/7b-it/2"
        - name: WORLD_SIZE
          value: "1"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
        - mountPath: "/data"
          name: data
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts
      - name: data
        persistentVolumeClaim:
          claimName: model-data
      tolerations:
      - key: "key"
        operator: "Exists"
        effect: "NoSchedule"

Aplique o manifesto:

kubectl apply -f job-download-gemma-7b.yaml

Veja os registos da tarefa:

kubectl logs -f job/data-loader-gemma-7b

A saída dos registos é semelhante à seguinte:

...
Creating configuration files
+ echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/7b/bfloat16/1-gpu/'
+ echo -e '\nCreating configuration files'
...

Aguarde a conclusão da tarefa:

kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-7b

O resultado é semelhante ao seguinte:

job.batch/data-loader-gemma-7b condition met

Valide se a tarefa foi concluída com êxito (este processo pode demorar alguns minutos):

kubectl get job/data-loader-gemma-7b

O resultado é semelhante ao seguinte:

NAME             COMPLETIONS   DURATION   AGE
data-loader-gemma-7b   1/1           ##s        #m##s

Certifique-se de que a tarefa é concluída com êxito antes de avançar para a secção seguinte.

Implemente o Triton

Nesta secção, implementa um contentor que usa o Triton com o back-end TensorRT-LLM para publicar o modelo Gemma que quer usar.

Crie o seguinte manifesto deploy-triton-server.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: launch-tritonserver
data:
  entrypoint.sh: |-
    #!/usr/bin/bash -x
    # Launch Triton Inference server

    WORLD_SIZE=1
    TRITON_MODEL_REPO=/data/triton/model_repository

    python3 /tensorrtllm_backend/scripts/launch_triton_server.py \
      --world_size ${WORLD_SIZE} \
      --model_repo ${TRITON_MODEL_REPO}

    tail -f /dev/null
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: triton-gemma-deployment
  labels:
    app: gemma-server
    version: v1 
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server 
      version: v1
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma
        ai.gke.io/inference-server: triton
        examples.ai.gke.io/source: user-guide
        version: v1
    spec:
      containers:
      - name: inference-server 
        image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
        imagePullPolicy: IfNotPresent
        resources:
          requests:
            ephemeral-storage: "40Gi"
            memory: "40Gi"
            nvidia.com/gpu: 1
          limits:
            ephemeral-storage: "40Gi"
            memory: "40Gi"
            nvidia.com/gpu: 1
        command:
        - /scripts/entrypoint.sh
        volumeMounts:
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
        - mountPath: "/data"
          name: data
        ports:
          - containerPort: 8000
            name: http
          - containerPort: 8001
            name: grpc
          - containerPort: 8002
            name: metrics
        livenessProbe:
          failureThreshold: 60
          initialDelaySeconds: 600
          periodSeconds: 5
          httpGet:
            path: /v2/health/live
            port: http
        readinessProbe:
          failureThreshold: 60
          initialDelaySeconds: 600
          periodSeconds: 5
          httpGet:
            path: /v2/health/ready
            port: http
      securityContext:
        runAsUser: 1000
        fsGroup: 1000
      volumes:
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: launch-tritonserver
      - name: data
        persistentVolumeClaim:
          claimName: model-data
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      tolerations:
      - key: "key"
        operator: "Exists"
        effect: "NoSchedule"
---
apiVersion: v1
kind: Service
metadata:
  name: triton-server
  labels:
    app: gemma-server 
spec:
  type: ClusterIP
  ports:
    - port: 8000
      targetPort: http
      name: http-inference-server
    - port: 8001
      targetPort: grpc
      name: grpc-inference-server
    - port: 8002
      targetPort: metrics
      name: http-metrics
  selector:
    app: gemma-server

Aplique o manifesto:

kubectl apply -f deploy-triton-server.yaml

Aguarde até que a implementação esteja disponível:

kubectl wait --for=condition=Available --timeout=900s deployment/triton-gemma-deployment

Veja os registos do manifesto:

kubectl logs -f -l app=gemma-server

O recurso de implementação inicia o servidor Triton e carrega os dados do modelo. Este processo pode demorar alguns minutos (até 20 minutos ou mais). O resultado é semelhante ao seguinte:

I0216 03:24:57.387420 29 server.cc:676]
+------------------+---------+--------+
| Model            | Version | Status |
+------------------+---------+--------+
| ensemble         | 1       | READY  |
| postprocessing   | 1       | READY  |
| preprocessing    | 1       | READY  |
| tensorrt_llm     | 1       | READY  |
| tensorrt_llm_bls | 1       | READY  |
+------------------+---------+--------+

....
....
....

I0216 03:24:57.425104 29 grpc_server.cc:2519] Started GRPCInferenceService at 0.0.0.0:8001
I0216 03:24:57.425418 29 http_server.cc:4623] Started HTTPService at 0.0.0.0:8000
I0216 03:24:57.466646 29 http_server.cc:315] Started Metrics Service at 0.0.0.0:8002

Publique o modelo

Nesta secção, interage com o modelo.

Configure o encaminhamento de portas

Execute o seguinte comando para configurar o encaminhamento de portas para o modelo:

kubectl port-forward service/triton-server 8000:8000

O resultado é semelhante ao seguinte:

Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000
Handling connection for 8000

Interaja com o modelo através do curl

Esta secção mostra como pode realizar um teste rápido básico para validar o modelo ajustado com instruções implementado. Para simplificar, esta secção descreve a abordagem de testes apenas com o modelo otimizado de instruções 2B.

Numa nova sessão de terminal, use curl para conversar com o seu modelo:

USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST localhost:8000/v2/models/ensemble/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "text_input": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "temperature": 0.9,
    "max_tokens": 128
}
EOF

A saída seguinte mostra um exemplo da resposta do modelo:

{
  "context_logits": 0,
  "cum_log_probs": 0,
  "generation_logits": 0,
  "model_name": "ensemble",
  "model_version": "1",
  "output_log_probs": [0.0,0.0,...],
  "sequence_end": false,
  "sequence_id": 0,
  "sequence_start": false,
  "text_output":"Python.\n\nPython is an excellent choice for beginners due to its simplicity, readability, and extensive documentation. Its syntax is close to natural language, making it easier for beginners to understand and write code. Python also has a vast collection of libraries and tools that make it versatile for various projects. Additionally, Python's dynamic nature allows for easier learning and experimentation, making it a perfect choice for newcomers to get started.Here are some specific reasons why Python is a good choice for beginners:\n\n- Simple and Easy to Read: Python's syntax is designed to be close to natural language, making it easier for"
}

Resolver problemas

Se receber a mensagem Empty reply from server, é possível que o contentor não tenha terminado de transferir os dados do modelo. Verifique novamente os registos do Pod para ver a mensagem Connected, que indica que o modelo está pronto para publicação.
Se vir Connection refused, verifique se o encaminhamento de portas está ativo.

Limpar

Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

Elimine os recursos implementados

Para evitar incorrer em custos na sua Google Cloud conta pelos recursos que criou neste guia, execute o seguinte comando:

gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

O que se segue?

Saiba mais acerca das GPUs no GKE.
Saiba como implementar cargas de trabalho de GPU no Autopilot.
Saiba como implementar cargas de trabalho de GPU no Standard.
Explore o repositório do GitHub do TensorRT-LLM e a documentação.
Explore o Vertex AI Model Garden.
Descubra como executar cargas de trabalho de IA/ML otimizadas com as capacidades de orquestração da plataforma do GKE.

Implemente modelos abertos Gemma com GPUs no GKE com o Triton e o TensorRT-LLM Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Contexto

Gemma

GPUs

TensorRT-LLM

Triton

Objetivos

Antes de começar

Check for the roles

Grant the roles

Prepare o seu ambiente

Aceda ao modelo

Assine o contrato de consentimento de licença

Gere um token de acesso

Carregue o token de acesso para o Cloud Shell

Crie e configure Google Cloud recursos

Crie um cluster e um node pool do GKE

Piloto automático

Standard

Crie um segredo do Kubernetes para as credenciais da Kaggle

Crie um recurso PersistentVolume para armazenar pontos de verificação

Transfira os ficheiros do motor TensorRT-LLM para o Gemma

Gemma 2B-it

Gemma 7B-it

Implemente o Triton

Publique o modelo

Configure o encaminhamento de portas

Interaja com o modelo através do curl

Resolver problemas

Limpar

Elimine os recursos implementados

O que se segue?

Implemente modelos abertos Gemma com GPUs no GKE com o Triton e o TensorRT-LLM