Disponibilizar modelos abertos do Gemma usando GPUs no GKE com o TGI Hugging Face

Neste tutorial, mostramos como disponibilizar o modelo de linguagem grande (LLM, na sigla em inglês) Gemma, família de modelos abertos, usando unidades de processamento gráfico (GPUs) no Google Kubernetes Engine (GKE) com o framework de veiculação Text Generation Inference (TGI) da Hugging Face. Neste tutorial, você fará o download da família de modelos Gemma pré-treinados e ajustados por instrução de parâmetros 2B e 7B da Hugging Face e os implantará em um cluster do GKE Autopilot ou Standard usando um contêiner que executa o TGI.

Este guia é um bom ponto de partida se você precisar do controle granular, da escalonabilidade, da resiliência, da portabilidade e da economia do Kubernetes gerenciado ao implantar e disponibilizar suas cargas de trabalho de IA/ML. Se você precisa de uma plataforma de IA gerenciada unificada para criar e disponibilizar modelos de ML rapidamente e de maneira econômica, recomendamos testar nossa solução de implantação da Vertex AI.

Experiência

Ao disponibilizar o Gemma usando GPUs no GKE com o TGI, é possível implementar uma solução de veiculação de inferência robusta e pronta para produção com todos os benefícios do Kubernetes gerenciado, incluindo escalonabilidade eficiente e maior disponibilidade. Esta seção descreve as principais tecnologias usadas neste guia.

Gemma

O Gemma é um conjunto de modelos de inteligência artificial (IA) generativa, leve e abertamente lançados sob licença aberta. Esses modelos de IA estão disponíveis para execução em aplicativos, hardware, dispositivos móveis ou serviços hospedados.

Neste guia, apresentamos os seguintes modelos:

  • Gemma para geração de texto, também é possível ajustar esses modelos para se especializar na execução de tarefas específicas.
  • CodeGemma é uma coleção de modelos poderosos e leves que podem executar várias tarefas de programação, como preenchimento de código intermediário, geração de código, compreensão de linguagem natural, raciocínio matemático e instruções a seguir.

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

GPUs

As GPUs permitem acelerar cargas de trabalho específicas em execução nos nós, como machine learning e processamento de dados. O GKE oferece uma gama de opções de tipos de máquina para configuração de nós, incluindo tipos de máquinas com GPUs NVIDIA H100, L4 e A100.

Antes de usar GPUs no GKE, recomendamos que você conclua o seguinte programa de aprendizado:

  1. Saiba mais sobre a disponibilidade atual da versão da GPU.
  2. Saiba mais sobre GPUs no .

Inferência de geração de texto (TGI)

O TGI é o kit de ferramentas do Hugging Face para implantar e disponibilizar LLMs. O TGI permite a geração de texto de alto desempenho para LLMs de código aberto conhecidos, incluindo o Gemma. O TGI inclui recursos como:

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

Objetivos

Este guia é destinado a clientes de IA generativa que usam PyTorch, usuários novos ou antigos do GKE, engenheiros de ML, engenheiros de MLOps (DevOps) ou administradores de plataformas interessados no uso dos recursos de orquestração de contêineres do Kubernetes para disponibilizar LLMs em hardwares de GPU H100, A100 e L4.

Ao final deste guia, você será capaz de realizar as seguintes etapas:

  1. Prepare seu ambiente com um cluster do GKE no modo Autopilot.
  2. Implante o TGI no seu cluster.
  3. Use o TGI para exibir o modelo Gemma 2B ou 7B por meio de curl e de uma interface de chat na Web.

Antes de começar

  • Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

  • No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  • Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  • Ative a API necessária.

    Ative a API

    •

  • No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  • Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  • Ative a API necessária.

    Ative a API

    •

  • Verifique se você tem os seguintes papéis no projeto: roles/container.admin, roles/iam.serviceAccountAdmin

    Verificar os papéis

    1. No console do Google Cloud, abra a página IAM.

      Acessar IAM
    2. Selecionar um projeto.

    3. Na coluna Principal, encontre a linha que contém seu endereço de e-mail.

      Caso seu endereço de e-mail não esteja nessa coluna, isso significa que você não tem papéis.

    4. Na coluna Papel da linha com seu endereço de e-mail, verifique se a lista de papéis inclui os papéis necessários.

    Conceder os papéis

    1. No console do Google Cloud, abra a página IAM.

      Acesse o IAM
    2. Selecionar um projeto.
    3. Clique em CONCEDER ACESSO.
    4. No campo Novos participantes, digite seu endereço de e-mail.
    5. Na lista Selecionar um papel, escolha um.
    6. Para conceder outros papéis, clique em Adicionar outro papel e adicione cada papel adicional.
    7. Clique em Save.

Receber acesso ao modelo

Para ter acesso aos modelos Gemma para implantação no GKE, primeiro assine o contrato de consentimento de licença e gere um token de acesso do Hugging Face.

É necessário assinar o contrato de consentimento para usar o Gemma. Siga estas instruções:

  1. Acesse a página de consentimento do modelo em Kaggle.com.
  2. Confirme seu consentimento usando sua conta do Hugging Face.
  3. Aceite os termos do modelo.

Gerar um token de acesso

Para acessar o modelo usando Hugging Face, você vai precisar de um token do Hugging Face.

Siga as etapas abaixo para gerar um novo token, caso ainda não tenha um:

  1. Clique em Seu perfil > Configurações > Tokens de acesso.
  2. Selecione Novo token.
  3. Especifique um Nome de sua escolha e um Papel de pelo menos Read.
  4. Selecione Gerar um token.
  5. Copie o token gerado para a área de transferência.

Prepare o ambiente

Neste tutorial, você usará o Cloud Shell para gerenciar recursos hospedados no Google Cloud. O Cloud Shell vem pré-instalado com o software necessário para este tutorial, incluindo kubectl e gcloud CLI.

Para configurar o ambiente com o Cloud Shell, siga estas etapas:

  1. No console do Google Cloud, inicie uma sessão do Cloud Shell clicando em Ícone de ativação do Cloud Shell Ativar o Cloud Shell no console do Google Cloud. Isso inicia uma sessão no painel inferior do console do Google Cloud.

  2. Defina as variáveis de ambiente padrão:

    gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export CLUSTER_NAME=tgi
export HF_TOKEN=HF_TOKEN

    Substitua os seguintes valores:

    • PROJECT_ID: seu ID do projeto no Google Cloud.
    • REGION: uma região compatível com o tipo de acelerador que você quer usar, por exemplo, us-central1 para GPU L4.
    • HF_TOKEN: o token do Hugging Face gerado anteriormente.

Criar e configurar recursos do Google Cloud

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

Criar um cluster do GKE e um pool de nós

É possível disponibilizar o Gemma em GPUs em um cluster do GKE Autopilot ou Standard. Recomendamos que você use um cluster do Autopilot para ter uma experiência totalmente gerenciada do Kubernetes. Para escolher o modo de operação do GKE mais adequado para suas cargas de trabalho, consulte Escolher um modo de operação do GKE.

Autopilot

No Cloud Shell, execute este comando:

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

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

Standard

  1. No Cloud Shell, execute o seguinte comando para criar um cluster 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

    A criação do cluster pode levar vários minutos.

  2. Execute o seguinte comando para criar um pool de nós para o cluster:

    gcloud container node-pools create gpupool \
  --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
  --project=${PROJECT_ID} \
  --location=${REGION} \
  --node-locations=${REGION}-a \
  --cluster=${CLUSTER_NAME} \
  --machine-type=g2-standard-24 \
  --num-nodes=1

    O GKE cria um único pool de nós contendo duas GPUs L4 para cada nó.

Criar um secret do Kubernetes para as credenciais do Hugging Face

No Cloud Shell, faça o seguinte:

  1. Configure kubectl para se comunicar com o cluster:

    gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}

  2. Crie um secret do Kubernetes que contenha o token do Hugging Face:

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

Implantar o TGI

Nesta seção, você implanta o contêiner do TGI para exibir o modelo Gemma que quer usar. Para saber mais sobre os modelos ajustados e pré-treinados por instrução e qual deles selecionar para seu caso de uso, consulte Modelos ajustados.

Implantar um modelo Gemma ajustado por instruções

Siga estas instruções se você quiser implantar uma variante ou modelo Gemma ajustado por instruções.

Gemma 2B-it

Siga estas instruções para implantar o modelo ajustado por instruções do Gemma 2B.

  1. Crie o seguinte manifesto tgi-2b-it.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/gemma-2b-it
        - name: PORT
          value: "8000"
        - 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. Aplique o manifesto:

    kubectl apply -f tgi-2b-it.yaml

Gemma 7B-it

Siga estas instruções para implantar o modelo ajustado por instruções do Gemma 7B.

  1. Crie o seguinte manifesto tgi-7b-it.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/gemma-7b-it
        - name: PORT
          value: "8000"
        - 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. Aplique o manifesto:

    kubectl apply -f tgi-7b-it.yaml

CodeGemma 7B-it

Siga estas instruções para implantar o modelo ajustado por instruções do CodeGemma 7B.

  1. Crie o seguinte manifesto tgi-codegemma-1.1-7b-it.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: codegemma-1.1-7b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/codegemma-1.1-7b-it
        - name: PORT
          value: "8000"
        - 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. Aplique o manifesto:

    kubectl apply -f tgi-codegemma-1.1-7b-it.yaml

Implantar um modelo Gemma pré-treinado

Siga estas instruções se quiser implantar uma variante ou modelo Gemma pré-treinado.

Gemma 2B

Siga estas instruções para implantar o modelo pré-treinado do Gemma 2B.

  1. Crie o seguinte manifesto tgi-2b.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-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: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/gemma-2b
        - name: PORT
          value: "8000"
        - 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. Aplique o manifesto:

    kubectl apply -f tgi-2b.yaml

Gemma 7B

Siga estas instruções para implantar o modelo pré-treinado do Gemma 2B.

  1. Crie o seguinte manifesto tgi-7b.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/gemma-7b
        - name: PORT
          value: "8000"
        - 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. Aplique o manifesto:

    kubectl apply -f tgi-7b.yaml

CodeGemma 2B

Siga estas instruções para implantar o modelo pré-treinado do CodeGemma 2B.

  1. Crie o seguinte manifesto tgi-codegemma-1.1-2b.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: codegemma-1.1-2b
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/codegemma-1.1-2b
        - name: PORT
          value: "8000"
        - 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. Aplique o manifesto:

    kubectl apply -f tgi-codegemma-1.1-2b.yaml

Um pod no cluster faz o download dos pesos do modelo do Hugging Face e inicia o mecanismo de exibição.

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

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

Confira os registros da implantação em execução:

kubectl logs -f -l app=gemma-server

O recurso de implantação faz o download dos dados do modelo. O processo pode levar alguns minutos. O resultado será assim:

2024-05-08T20:27:37.557836Z  INFO text_generation_router: router/src/main.rs:317: Warming up model
2024-05-08T20:27:39.206371Z  INFO text_generation_launcher: Cuda Graphs are enabled for sizes [1, 2, 4, 8, 16, 32]
2024-05-08T20:27:40.461998Z  INFO text_generation_router: router/src/main.rs:354: Setting max batch total tokens to 632992
2024-05-08T20:27:40.462018Z  INFO text_generation_router: router/src/main.rs:355: Connected
2024-05-08T20:27:40.462025Z  WARN text_generation_router: router/src/main.rs:369: Invalid hostname, defaulting to 0.0.0.0

Verifique se o download do modelo foi concluído antes de prosseguir para a próxima seção.

Disponibilizar o modelo

Nesta seção, você vai interagir com o modelo.

Configurar o encaminhamento de portas

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

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

O resultado será assim:

Forwarding from 127.0.0.1:8000 -> 8000

Interagir com o modelo usando curl

Nesta seção, mostramos como realizar um teste preliminar básico para verificar os modelos pré-treinados ou ajustados que foram implantados. Para simplificar, esta seção descreve a abordagem de teste usando os modelos pré-treinados da Gemma 2B, ajustados por instrução do Gemma 2B e do CodeGemma 7B.

Gemma 2B

Em uma nova sessão do terminal, use curl para conversar com seu modelo:

USER_PROMPT="Java is a"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "${USER_PROMPT}",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

A saída a seguir mostra um exemplo da resposta do modelo:

{"generated_text":" general-purpose, high-level, class-based, object-oriented programming language. <strong>Is Java a statically typed language?</strong> Yes, Java is a statically typed language. Java also supports dynamic typing. Static typing means that the type of every variable is explicitly specified at the time of declaration. The type can be either implicit or explicit. Static typing means that if no types are assigned then it will be assumed as a primitive type.\n\n<h3>What is Java?</h3>\n\nJava is a general-purpose, class-based, object-oriented programming language. Java is one of the oldest programming languages that has gained a"}

Gemma 2B-it

Em uma nova sessão do terminal, use curl para conversar com 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 http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

A saída a seguir mostra um exemplo da resposta do modelo:

{"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}

CodeGemma

Em uma nova sessão do terminal, use curl para conversar com seu modelo:

USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"

curl -s -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r .generated_text
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 2000
    }
}
EOF

A saída a seguir mostra um exemplo da resposta do modelo:

def addNumbers(num1, num2):
  sum = num1 + num2
  return sum

# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Call the addNumbers function
sum = addNumbers(num1, num2)

# Print the result
print("The sum of", num1, "and", num2, "is", sum)

(Opcional) Interagir com o modelo usando uma interface de chat do GRadio

Nesta seção, você criará um aplicativo de chat na Web que permite interagir com seu modelo ajustado por instruções. Para simplificar, esta seção descreve apenas a abordagem de teste usando o modelo 2B-it.

O Gradio é uma biblioteca Python que tem um wrapper ChatInterface que cria interfaces de usuário para chatbots.

Implantar a interface de chat

  1. No Cloud Shell, salve o seguinte manifesto como gradio.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gradio
  template:
    metadata:
      labels:
        app: gradio
    spec:
      containers:
      - name: gradio
        image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.3
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://llm-service:8000"
        - name: LLM_ENGINE
          value: "tgi"
        - name: MODEL_ID
          value: "gemma"
        - name: USER_PROMPT
          value: "<start_of_turn>user\nprompt<end_of_turn>\n"
        - name: SYSTEM_PROMPT
          value: "<start_of_turn>model\nprompt<end_of_turn>\n"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 7860
  type: ClusterIP

  2. Aplique o manifesto:

    kubectl apply -f gradio.yaml

  3. Aguarde até que a implantação esteja disponível:

    kubectl wait --for=condition=Available --timeout=300s deployment/gradio

Usar a interface de chat

  1. No Cloud Shell, execute este comando:

    kubectl port-forward service/gradio 8080:8080

    Isso cria um encaminhamento de porta do Cloud Shell para o serviço GRadio.

  2. Clique no botão Ícone de visualização na Web Visualização da Web no canto superior direito da barra de tarefas do Cloud Shell. Clique em Visualizar na porta 8080. Uma nova guia será aberta no navegador.

  3. Interaja com Gemma usando a interface de chat do GRadio. Adicione uma solicitação e clique em Enviar.

Resolver problemas

  • Se você receber a mensagem Empty reply from server, é possível que o contêiner não tenha concluído o download dos dados do modelo. Verifique os registros do pod novamente para ver a mensagem Connected, que indica que o modelo está pronto para ser disponibilizado.
  • Se você vir Connection refused, verifique se o encaminhamento de portas está ativo.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Excluir os recursos implantados

Para evitar cobranças na sua conta do Google Cloud pelos recursos criados neste guia, execute o seguinte comando:

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

A seguir