Neste tutorial, mostramos como ajustar um modelo de linguagem grande (LLM) Gemma 4 em um cluster do Google Kubernetes Engine (GKE) de host único e várias GPUs no Google Cloud. Esse cluster usa uma única instância de máquina virtual (VM) A4 com 8 GPUs NVIDIA B200 anexadas.
Os dois processos principais descritos neste tutorial são os seguintes:
- Implantar um cluster do GKE de alto desempenho usando o Autopilot do GKE. Como parte dessa implantação, você usa o Cloud Build para criar uma imagem do contêiner personalizada com o software necessário pré-instalado.
- Depois que o cluster é implantado, você executa um job de ajuste que usa o paralelismo de dados totalmente fragmentados (FSDP, na sigla em inglês) para fragmentar o modelo em todas as oito GPUs de um único nó A4 (
a4-highgpu-8g). O job usa o conjunto de scripts que acompanham este tutorial e aproveita a biblioteca Hugging Face Accelerate.
Este tutorial é destinado a engenheiros de machine learning (ML), pesquisadores, administradores e operadores de plataforma, além de especialistas em dados e IA que têm interesse em implantar clusters do GKE no Google Cloud para treinar LLMs.
Objetivos
Acesse o modelo Gemma 4 usando o Hugging Face.
Prepare o ambiente.
Criar e implantar um cluster do GKE A4.
Ajuste o modelo Gemma 4 usando a biblioteca Accelerate do Hugging Face com paralelismo de dados totalmente fragmentados (FSDP).
Monitorar o job.
Fazer a limpeza.
Custos
Neste documento, você vai usar os seguintes componentes faturáveis do Google Cloud:
- Compute Engine
- Google Kubernetes Engine (GKE)
- Artifact Registry
- Cloud Build
- Cloud Storage
- Cloud Logging
Para gerar uma estimativa de custo baseada na sua projeção de uso,
use a calculadora de preços.
Antes de começar
Ative as APIs necessárias, se ainda não estiverem ativadas:
Funções necessárias para ativar APIs
Para ativar APIs, você precisa da permissão
serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de proprietário (roles/owner). Caso contrário, é possível conseguir essa permissão pelo papel de administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis.gcloud services enable compute.googleapis.com
container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com logging.googleapis.com cloudresourcemanager.googleapis.com servicenetworking.googleapis.com Ative a conta de serviço padrão do projeto do Google Cloud :
export PROJECT_NUMBER="$(gcloud projects describe "YOUR_PROJECT_ID" --format "value(project_number)")" gcloud iam service-accounts enable "${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \ --project=YOUR_PROJECT_ID
Conceda os papéis que a conta de serviço padrão precisa para executar a carga de trabalho de ajuste:
ROLES=("roles/artifactregistry.writer" "roles/cloudbuild.builds.builder" "roles/logging.logWriter" "roles/monitoring.metricWriter" "roles/monitoring.viewer" "roles/stackdriver.resourceMetadata.writer" "roles/storage.objectViewer") for role in "${ROLES[@]}"; do gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \ --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \ --role="${role}" 1>/dev/null done unset ROLES
Para verificar se os papéis foram concedidos, execute o seguinte comando:
gcloud projects get-iam-policy YOUR_PROJECT_ID \ --flatten="bindings[].members" \ --filter="bindings.members:serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \ --format="table(bindings.role)"Crie credenciais de autenticação local para sua conta de usuário:
gcloud auth application-default login
Ative o Login do SO no seu projeto:
gcloud compute project-info add-metadata \ --metadata=enable-oslogin=TRUE \ --project=YOUR_PROJECT_ID
Para conseguir as permissões necessárias para concluir o tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no seu projeto:
- Administrador do Kubernetes Engine (
roles/container.admin) - Administrador do Compute (
roles/compute.admin) - Administrador de armazenamento (
roles/storage.admin) - Administrador do Artifact Registry (
roles/artifactregistry.admin) - Editor do Cloud Build (
roles/cloudbuild.builds.editor) - Usuário da conta de serviço (
roles/iam.serviceAccountUser) - Administrador da conta de serviço (
roles/iam.serviceAccountAdmin) - Administrador de projetos do IAM (
roles/resourcemanager.projectIamAdmin) - Administrador do Service Usage (
roles/serviceusage.serviceUsageAdmin)
Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.
Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.
Acessar o Gemma 4 usando o Hugging Face
Para usar o Hugging Face para acessar o Gemma 4, faça o seguinte:
- Faça login no Hugging Face
- Crie um token de acesso do Hugging Face
write.
Clique em Seu perfil > Configurações > Tokens de acesso > +Criar novo token. - Copie e salve o valor do token
write access. Você vai usá-lo mais adiante neste tutorial.
Preparar o ambiente
Para preparar o ambiente, defina o seguinte:
Substitua:
YOUR_PROJECT_ID: o ID do projeto do Google Cloud em que você quer criar o cluster do GKE.
YOUR_CLUSTER_NAME: o nome do cluster do GKE a ser criado.
YOUR_REGION: a região em que você quer criar o cluster do GKE. Só é possível criar o cluster na região em que a reserva está.
YOUR_RESERVATION_NAME: o identificador da capacidade reservada.
YOUR_HF_TOKEN: o token de acesso do Hugging Face que você criou na seção anterior.
YOUR_ARTIFACT_REGISTRY_LOCATION: a Google Cloud região em que você quer criar o repositório do Artifact Registry. Para minimizar a latência de extração de imagens, recomendamos usar a mesma região usada para YOUR_REGION.
Criar um cluster do GKE no modo Autopilot
Para criar um cluster do GKE no modo Autopilot, execute o seguinte comando:
A criação do cluster do GKE pode levar algum tempo. Para verificar se o Google Cloud concluiu a criação do cluster, acesse Clusters do Kubernetes no console do Google Cloud .
Criar um secret do Kubernetes para as credenciais do Hugging Face
Para criar um secret do Kubernetes para as credenciais do Hugging Face, siga estas etapas:
Configure
kubectlpara se comunicar com o cluster do GKE:Crie um secret do Kubernetes para armazenar o token do Hugging Face:
Preparar sua carga de trabalho
Para preparar a carga de trabalho, faça o seguinte:
Criar scripts de carga de trabalho
Para criar os scripts que a carga de trabalho de ajuste usa, faça o seguinte:
Crie um diretório para os scripts de carga de trabalho. Use esse diretório como seu diretório de trabalho.
Crie o arquivo
cloudbuild.yamlpara usar o Google Cloud Build. Esse arquivo cria o contêiner de carga de trabalho e o armazena no Artifact Registry:Crie um arquivo
Dockerfilepara executar o job de ajuste:Crie o arquivo
accel_fsdp_gemma4_config.yaml. Esse arquivo de configuração direciona o Hugging Face Accelerate para dividir o job de ajuste entre as oito GPUs locais no host único usando o FSDP:Crie o arquivo
finetune.yaml:Crie o arquivo
finetune.py:
Usar o Docker e o Cloud Build para criar um contêiner de ajuste fino
Criar um repositório Docker do Artifact Registry:
No diretório
llm-finetuning-gemmaque você criou em uma etapa anterior, execute o comando a seguir para criar a imagem de ajuste e enviá-la para o Artifact Registry.Exporte o URL da imagem. Você vai usá-lo em uma etapa posterior deste tutorial:
Iniciar a carga de trabalho de ajuste fino
Para iniciar a carga de trabalho de ajuste, faça o seguinte:
Aplique o manifesto de ajuste para criar o job de ajuste:
Como você está usando clusters no modo Autopilot do GKE, pode levar alguns minutos para iniciar o nó com GPU ativada.
Monitore o job executando o seguinte comando:
Depois que os pods estiverem em execução, verifique os registros do job:
O recurso de job faz o download dos dados do modelo e, em seguida, ajusta o modelo em todas as oito GPUs. O download leva cerca de cinco minutos para ser concluído. Depois que o download é concluído, o processo de ajuste leva aproximadamente 45 minutos para ser concluído. O job salva um checkpoint a cada 20 etapas e envia o adaptador de adaptação de classificação baixa (LoRA) ajustado para um repositório privado do Hugging Face chamado
gemma-31b-text-to-sql.Depois que o job for concluído, acesse o URL do modelo ajustado no Hugging Face e abra-o no navegador:
Monitorar a carga de trabalho
É possível monitorar o uso das GPUs no cluster do GKE para verificar se o job de ajuste está sendo executado de maneira eficiente. Para fazer isso, abra o seguinte link no navegador:
Ao monitorar sua carga de trabalho, você pode ver o seguinte:
- Uso de GPUs: para um job de ajuste saudável, o uso de todas as oito GPUs deve aumentar e se estabilizar em um nível alto durante o treinamento.
- Duração do job: o job deve levar aproximadamente 45 minutos para ser concluído no cluster A4 especificado.
Limpar
Para evitar cobranças extras, exclua os recursos criados durante este tutorial.
Excluir os recursos
Para excluir o job de ajuste, execute o seguinte comando:
Para excluir o cluster do GKE, execute o seguinte comando:
Para excluir o repositório do Artifact Registry, execute o seguinte comando: