Publique um MDG em GPUs L4 com o Ray

Autopilot Padrão

Este guia demonstra como publicar modelos de linguagem (conteúdo extenso) (MDL/CE) através do Ray e do suplemento do operador do Ray com o Google Kubernetes Engine (GKE). A estrutura Ray oferece uma plataforma de IA/AA ponto a ponto para preparação, preparação detalhada e inferência de cargas de trabalho de aprendizagem automática. O Ray Serve é uma estrutura no Ray que pode usar para publicar MDIs populares do Hugging Face.

Antes de ler este guia, certifique-se de que conhece o modelo que quer publicar neste tutorial. Pode publicar qualquer um dos seguintes modelos:

• Gemma 2B IT
• Gemma 7B IT
• Llama 2 7B
• Llama 3 8B
• Mistral 7B

Nota: não recomendamos a utilização de modelos base, como o Llama 3 8B, para chatbots de produção devido a preocupações de segurança. Para mais informações sobre as práticas recomendadas, consulte o artigo Instruções do sistema para segurança.

Esta página destina-se a engenheiros de aprendizagem automática (ML) e administradores e operadores da plataforma que facilitam as cargas de trabalho de ML. Para saber mais sobre as funções comuns e as tarefas de exemplo a que fazemos referência no Google Cloud conteúdo, consulte Funções e tarefas comuns de utilizadores do GKE.

Este guia aborda os seguintes passos:

1. Crie um cluster do GKE no modo Autopilot ou Standard com o suplemento do operador do Ray ativado.
2. Implemente um recurso RayService que transfere e disponibiliza um modelo de linguagem (conteúdo extenso) (MDL/CE) do Hugging Face.
3. Implemente uma interface de chat e uma caixa de diálogo com MDIs/CEs.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

• Ative a API Google Kubernetes Engine.
Ative a API Google Kubernetes Engine
• Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute gcloud components update para obter a versão mais recente.
  Nota: para instalações existentes da CLI gcloud, certifique-se de que define a compute/region propriedade. Se usar principalmente clusters zonais, defina o compute/zone. Ao definir uma localização predefinida, pode evitar erros na CLI gcloud, como os seguintes: One of [--zone, --region] must be supplied: Please specify location. Pode ter de especificar a localização em determinados comandos se a localização do seu cluster for diferente da predefinição que definiu.

• Crie uma conta Hugging Face, se ainda não tiver uma.
• Certifique-se de que tem um token do Hugging Face.
• Certifique-se de que tem acesso ao modelo do Hugging Face que quer usar. Normalmente, isto é concedido através da assinatura de um contrato e da solicitação de acesso ao proprietário do modelo na página do modelo do Hugging Face.
• Certifique-se de que tem quota de GPU na região us-central1. Para saber mais, consulte o artigo Quota de GPU.

Prepare o seu ambiente

1. Na Google Cloud consola, inicie uma instância do Cloud Shell:
   Abrir Cloud Shell

2. Clone o repositório de exemplo:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   cd kubernetes-engine-samples/ai-ml/gke-ray/rayserve/llm
   export TUTORIAL_HOME=`pwd`
   

3. Defina as variáveis de ambiente predefinidas:

   gcloud config set project PROJECT_ID
   export PROJECT_ID=$(gcloud config get project)
   export COMPUTE_REGION=us-central1
   export CLUSTER_VERSION=CLUSTER_VERSION
   export HF_TOKEN=HUGGING_FACE_TOKEN
   

   Substitua o seguinte:

   • PROJECT_ID: o seu Google Cloud ID do projeto.
   • CLUSTER_VERSION: a versão do GKE a usar. Tem de ser 1.30.1 ou posterior.
   • HUGGING_FACE_TOKEN: o seu token de acesso do Hugging Face.

Crie um cluster com um node pool de GPU

Pode publicar um MDG em GPUs L4 com o Ray num cluster do GKE Autopilot ou Standard através do suplemento do operador do Ray. Geralmente, recomendamos que use um cluster do Autopilot para uma experiência do Kubernetes totalmente gerida. Em alternativa, escolha um cluster padrão se o seu exemplo de utilização exigir uma elevada escalabilidade ou se quiser ter mais controlo sobre a configuração do cluster. 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.

Use o Cloud Shell para criar um cluster do Autopilot ou Standard:

Piloto automático

Crie um cluster do Autopilot com o suplemento do operador do Ray ativado:

gcloud container clusters create-auto rayserve-cluster \
    --enable-ray-operator \
    --cluster-version=${CLUSTER_VERSION} \
    --location=${COMPUTE_REGION}

Standard

Crie um cluster padrão com o suplemento do operador Ray ativado:

gcloud container clusters create rayserve-cluster \
    --addons=RayOperator \
    --cluster-version=${CLUSTER_VERSION} \
    --machine-type=g2-standard-24 \
    --location=${COMPUTE_ZONE} \
    --num-nodes=2 \
    --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest

Crie um segredo do Kubernetes para as credenciais do Hugging Face

No Cloud Shell, crie um segredo do Kubernetes fazendo o seguinte:

1. Configure kubectl para comunicar com o cluster:

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

2. Crie um segredo 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 -
   

Implemente o modelo de GML

O repositório do GitHub que clonou tem um diretório para cada modelo que inclui uma configuração do RayService. A configuração de cada modelo inclui os seguintes componentes:

• Implementação do Ray Serve: a implementação do Ray Serve, que inclui a configuração de recursos e as dependências de tempo de execução.
• Modelo: o ID do modelo do Hugging Face.

• Cluster do Ray: o cluster do Ray subjacente e os recursos necessários para cada componente, que inclui pods principais e de trabalho.

Gemma 2B IT

1. Implemente o modelo:

   kubectl apply -f gemma-2b-it/
   

2. Aguarde até que o recurso RayService esteja pronto:

   kubectl get rayservice gemma-2b-it -o yaml
   

   O resultado é semelhante ao seguinte:

   status:
     activeServiceStatus:
       applicationStatuses:
         llm:
           healthLastUpdateTime: "2024-06-22T02:51:52Z"
           serveDeploymentStatuses:
             VLLMDeployment:
               healthLastUpdateTime: "2024-06-22T02:51:52Z"
               status: HEALTHY
           status: RUNNING
   

   Nesta saída, status: RUNNING indica que o recurso RayService está pronto.

3. Confirme que o GKE criou o serviço para a aplicação Ray Serve:

   kubectl get service gemma-2b-it-serve-svc
   

   O resultado é semelhante ao seguinte:

   NAME                    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
   gemma-2b-it-serve-svc   ClusterIP   34.118.226.104   <none>        8000/TCP   45m
   

Gemma 7B IT

1. Implemente o modelo:

   kubectl apply -f gemma-7b-it/
   

2. Aguarde até que o recurso RayService esteja pronto:

   kubectl get rayservice gemma-7b-it -o yaml
   

   O resultado é semelhante ao seguinte:

   status:
     activeServiceStatus:
       applicationStatuses:
         llm:
           healthLastUpdateTime: "2024-06-22T02:51:52Z"
           serveDeploymentStatuses:
             VLLMDeployment:
               healthLastUpdateTime: "2024-06-22T02:51:52Z"
               status: HEALTHY
           status: RUNNING
   

   Nesta saída, status: RUNNING indica que o recurso RayService está pronto.

3. Confirme que o GKE criou o serviço para a aplicação Ray Serve:

   kubectl get service gemma-7b-it-serve-svc
   

   O resultado é semelhante ao seguinte:

   NAME                    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
   gemma-7b-it-serve-svc   ClusterIP   34.118.226.104   <none>        8000/TCP   45m
   

Llama 2 7B

1. Implemente o modelo:

   kubectl apply -f llama-2-7b/
   

2. Aguarde até que o recurso RayService esteja pronto:

   kubectl get rayservice llama-2-7b -o yaml
   

   O resultado é semelhante ao seguinte:

   status:
     activeServiceStatus:
       applicationStatuses:
         llm:
           healthLastUpdateTime: "2024-06-22T02:51:52Z"
           serveDeploymentStatuses:
             VLLMDeployment:
               healthLastUpdateTime: "2024-06-22T02:51:52Z"
               status: HEALTHY
           status: RUNNING
   

   Nesta saída, status: RUNNING indica que o recurso RayService está pronto.

3. Confirme que o GKE criou o serviço para a aplicação Ray Serve:

   kubectl get service llama-2-7b-serve-svc
   

   O resultado é semelhante ao seguinte:

   NAME                    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
   llama-2-7b-serve-svc    ClusterIP   34.118.226.104   <none>        8000/TCP   45m
   

Llama 3 8B

1. Implemente o modelo:

   kubectl apply -f llama-3-8b/
   

2. Aguarde até que o recurso RayService esteja pronto:

   kubectl get rayservice llama-3-8b -o yaml
   

   O resultado é semelhante ao seguinte:

   status:
     activeServiceStatus:
       applicationStatuses:
         llm:
           healthLastUpdateTime: "2024-06-22T02:51:52Z"
           serveDeploymentStatuses:
             VLLMDeployment:
               healthLastUpdateTime: "2024-06-22T02:51:52Z"
               status: HEALTHY
           status: RUNNING
   

   Nesta saída, status: RUNNING indica que o recurso RayService está pronto.

3. Confirme que o GKE criou o serviço para a aplicação Ray Serve:

   kubectl get service llama-3-8b-serve-svc
   

   O resultado é semelhante ao seguinte:

   NAME                    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
   llama-3-8b-serve-svc    ClusterIP   34.118.226.104   <none>        8000/TCP   45m
   

Mistral 7B

1. Implemente o modelo:

   kubectl apply -f mistral-7b/
   

2. Aguarde até que o recurso RayService esteja pronto:

   kubectl get rayservice mistral-7b -o yaml
   

   O resultado é semelhante ao seguinte:

   status:
     activeServiceStatus:
       applicationStatuses:
         llm:
           healthLastUpdateTime: "2024-06-22T02:51:52Z"
           serveDeploymentStatuses:
             VLLMDeployment:
               healthLastUpdateTime: "2024-06-22T02:51:52Z"
               status: HEALTHY
           status: RUNNING
   

   Nesta saída, status: RUNNING indica que o recurso RayService está pronto.

3. Confirme que o GKE criou o serviço para a aplicação Ray Serve:

   kubectl get service mistral-7b-serve-svc
   

   O resultado é semelhante ao seguinte:

   NAME                    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
   mistral-7b-serve-svc    ClusterIP   34.118.226.104   <none>        8000/TCP   45m
   

Publique o modelo

Os modelos Llama2 7B e Llama3 8B usam a especificação de chat da API OpenAI. Os outros modelos só suportam a geração de texto, que é uma técnica que gera texto com base num comando.

Configure o encaminhamento de porta

Configure o encaminhamento de portas para o servidor de inferência:

Gemma 2B IT

kubectl port-forward svc/gemma-2b-it-serve-svc 8000:8000

Gemma 7B IT

kubectl port-forward svc/gemma-7b-it-serve-svc 8000:8000

Llama2 7B

kubectl port-forward svc/llama-7b-serve-svc 8000:8000

Llama 3 8B

kubectl port-forward svc/llama-3-8b-serve-svc 8000:8000

Mistral 7B

kubectl port-forward svc/mistral-7b-serve-svc 8000:8000

Interaja com o modelo através do curl

Use o curl para conversar com o seu modelo:

Gemma 2B IT

Numa nova sessão de terminal:

curl -X POST http://localhost:8000/ -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'

Gemma 7B IT

Numa nova sessão de terminal:

curl -X POST http://localhost:8000/ -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'

Llama2 7B

Numa nova sessão de terminal:

curl http://localhost:8000/v1/chat/completions     -H "Content-Type: application/json"     -d '{
      "model": "meta-llama/Llama-2-7b-chat-hf",
      "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What are the top 5 most popular programming languages? Please be brief."}
      ],
      "temperature": 0.7
    }'

Llama 3 8B

Numa nova sessão de terminal:

curl http://localhost:8000/v1/chat/completions     -H "Content-Type: application/json"     -d '{
      "model": "meta-llama/Meta-Llama-3-8B-Instruct",
      "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What are the top 5 most popular programming languages? Please be brief."}
      ],
      "temperature": 0.7
    }'

Mistral 7B

Numa nova sessão de terminal:

curl -X POST http://localhost:8000/ -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Be brief.", "max_tokens": 1024}'

Uma vez que os modelos que publicou não retêm nenhum histórico, cada mensagem e resposta tem de ser enviada novamente para o modelo para criar uma experiência de diálogo interativo. O exemplo seguinte mostra como pode criar um diálogo interativo usando o modelo Llama 3 8B:

Crie um diálogo com o modelo através de curl:

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
      "model": "meta-llama/Meta-Llama-3-8B-Instruct",
      "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What are the top 5 most popular programming languages? Please be brief."},
        {"role": "assistant", "content": " \n1. Java\n2. Python\n3. C++\n4. C#\n5. JavaScript"},
        {"role": "user", "content": "Can you give me a brief description?"}
      ],
      "temperature": 0.7
}'

O resultado é semelhante ao seguinte:

{
  "id": "cmpl-3cb18c16406644d291e93fff65d16e41",
  "object": "chat.completion",
  "created": 1719035491,
  "model": "meta-llama/Meta-Llama-3-8B-Instruct",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Here's a brief description of each:\n\n1. **Java**: A versatile language for building enterprise-level applications, Android apps, and web applications.\n2. **Python**: A popular language for data science, machine learning, web development, and scripting, known for its simplicity and ease of use.\n3. **C++**: A high-performance language for building operating systems, games, and other high-performance applications, with a focus on efficiency and control.\n4. **C#**: A modern, object-oriented language for building Windows desktop and mobile applications, as well as web applications using .NET.\n5. **JavaScript**: A versatile language for client-side scripting on the web, commonly used for creating interactive web pages, web applications, and mobile apps.\n\nNote: These descriptions are brief and don't do justice to the full capabilities and uses of each language."
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": null
    }
  ],
  "usage": {
    "prompt_tokens": 73,
    "total_tokens": 245,
    "completion_tokens": 172
  }
}

(Opcional) Ligue-se à interface do chat

Pode usar o Gradio para criar aplicações Web que lhe permitem interagir com o seu modelo. O Gradio é uma biblioteca Python que tem um wrapper ChatInterface que cria interfaces do utilizador para chatbots. Para o Llama 2 7B e o Llama 3 7B, instalou o Gradio quando implementou o modelo de MDG.

1. Configure o encaminhamento de portas para o gradio serviço:

   kubectl port-forward service/gradio 8080:8080 &
   

2. Abra http://localhost:8080 no seu navegador para conversar com o modelo.

Publique vários modelos com a multiplexagem de modelos

A multiplexagem de modelos é uma técnica usada para publicar vários modelos no mesmo cluster do Ray. Pode encaminhar o tráfego para modelos específicos através de cabeçalhos de pedidos ou do equilíbrio de carga.

Neste exemplo, cria uma aplicação Ray Serve multiplexada composta por dois modelos: Gemma 7B IT e Llama 3 8B.

Aviso: esta secção usa 4 GPUs. Certifique-se de que tem capacidade de GPU suficiente no cluster.

1. Implemente o recurso RayService:

   kubectl apply -f model-multiplexing/
   

2. Aguarde até que o recurso RayService esteja pronto:

   kubectl get rayservice model-multiplexing -o yaml
   

   O resultado é semelhante ao seguinte:

   status:
     activeServiceStatus:
       applicationStatuses:
         llm:
           healthLastUpdateTime: "2024-06-22T14:00:41Z"
           serveDeploymentStatuses:
             MutliModelDeployment:
               healthLastUpdateTime: "2024-06-22T14:00:41Z"
               status: HEALTHY
             VLLMDeployment:
               healthLastUpdateTime: "2024-06-22T14:00:41Z"
               status: HEALTHY
             VLLMDeployment_1:
               healthLastUpdateTime: "2024-06-22T14:00:41Z"
               status: HEALTHY
           status: RUNNING
   

   Nesta saída, status: RUNNING indica que o recurso RayService está pronto.

3. Confirme se o GKE criou o serviço Kubernetes para a aplicação Ray Serve:

   kubectl get service model-multiplexing-serve-svc
   

   O resultado é semelhante ao seguinte:

   NAME                           TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
   model-multiplexing-serve-svc   ClusterIP   34.118.226.104   <none>        8000/TCP   45m
   

4. Configure o encaminhamento de porta para a aplicação Ray Serve:

   kubectl port-forward svc/model-multiplexing-serve-svc 8000:8000
   

5. Enviar um pedido ao modelo de TI Gemma 7B:

   curl -X POST http://localhost:8000/ -H "Content-Type: application/json" --header "serve_multiplexed_model_id: google/gemma-7b-it" -d '{"prompt": "What are the top 5 most popular programming languages? Please be brief.", "max_tokens": 200}'
   

   O resultado é semelhante ao seguinte:

   {"text": ["What are the top 5 most popular programming languages? Please be brief.\n\n1. JavaScript\n2. Java\n3. C++\n4. Python\n5. C#"]}
   

6. Envie um pedido ao modelo Llama 3 8B:

   curl -X POST http://localhost:8000/ -H "Content-Type: application/json" --header "serve_multiplexed_model_id: meta-llama/Meta-Llama-3-8B-Instruct" -d '{"prompt": "What are the top 5 most popular programming languages? Please be brief.", "max_tokens": 200}'
   

   O resultado é semelhante ao seguinte:

   {"text": ["What are the top 5 most popular programming languages? Please be brief. Here are your top 5 most popular programming languages, based on the TIOBE Index, a widely used measure of the popularity of programming languages.\r\n\r\n1. **Java**: Used in Android app development, web development, and enterprise software development.\r\n2. **Python**: A versatile language used in data science, machine learning, web development, and automation.\r\n3. **C++**: A high-performance language used in game development, system programming, and high-performance computing.\r\n4. **C#**: Used in Windows and web application development, game development, and enterprise software development.\r\n5. **JavaScript**: Used in web development, mobile app development, and server-side programming with technologies like Node.js.\r\n\r\nSource: TIOBE Index (2022).\r\n\r\nThese rankings can vary depending on the source and methodology used, but this gives you a general idea of the most popular programming languages."]}
   

7. Envie um pedido a um modelo aleatório excluindo o cabeçalho serve_multiplexed_model_id:

   curl -X POST http://localhost:8000/ -H "Content-Type: application/json" -d '{"prompt": "What are the top 5 most popular programming languages? Please be brief.", "max_tokens": 200}'
   

   O resultado é um dos resultados dos passos anteriores.

Componha vários modelos com a composição de modelos

A composição de modelos é uma técnica usada para compor vários modelos numa única aplicação. A composição de modelos permite encadear entradas e saídas em vários MDIs e dimensionar os seus modelos como uma única aplicação.

Neste exemplo, compõe dois modelos, o Gemma 7B IT e o Llama 3 8B, numa única aplicação. O primeiro modelo é o modelo de assistente que responde a perguntas fornecidas no comando. O segundo modelo é o modelo de resumo. A saída do modelo de assistente é encadeada na entrada do modelo de resumo. O resultado final é a versão resumida da resposta do modelo do assistente.

Aviso: esta secção usa 4 GPUs. Certifique-se de que tem capacidade de GPU suficiente no cluster.

1. Implemente o recurso RayService:

   kubectl apply -f model-composition/
   

2. Aguarde até que o recurso RayService esteja pronto:

   kubectl get rayservice model-composition -o yaml
   

   O resultado é semelhante ao seguinte:

   status:
     activeServiceStatus:
       applicationStatuses:
         llm:
           healthLastUpdateTime: "2024-06-22T14:00:41Z"
           serveDeploymentStatuses:
             MutliModelDeployment:
               healthLastUpdateTime: "2024-06-22T14:00:41Z"
               status: HEALTHY
             VLLMDeployment:
               healthLastUpdateTime: "2024-06-22T14:00:41Z"
               status: HEALTHY
             VLLMDeployment_1:
               healthLastUpdateTime: "2024-06-22T14:00:41Z"
               status: HEALTHY
           status: RUNNING
   

   Nesta saída, status: RUNNING indica que o recurso RayService está pronto.

3. Confirme se o GKE criou o serviço para a aplicação Ray Serve:

   kubectl get service model-composition-serve-svc
   

   O resultado é semelhante ao seguinte:

   NAME                           TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
   model-composition-serve-svc    ClusterIP   34.118.226.104   <none>        8000/TCP   45m
   

4. Envie um pedido ao modelo:

   curl -X POST http://localhost:8000/ -H "Content-Type: application/json" -d '{"prompt": "What is the most popular programming language for machine learning and why?", "max_tokens": 1000}'
   

5. O resultado é semelhante ao seguinte:

   {"text": ["\n\n**Sure, here is a summary in a single sentence:**\n\nThe most popular programming language for machine learning is Python due to its ease of use, extensive libraries, and growing community."]}
   

Elimine o projeto

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Elimine os recursos individuais

Se usou um projeto existente e não o quer eliminar, pode eliminar os recursos individuais.

1. Elimine o cluster:

   gcloud container clusters delete rayserve-cluster
   

O que se segue?

• Descubra como executar cargas de trabalho de IA/ML otimizadas com as capacidades de orquestração da plataforma do GKE.
• Forme um modelo com GPUs no modo padrão do GKE
• Saiba como usar o RayServe no GKE, consultando o código de exemplo no GitHub.