Publique modelos abertos Gemma com TPUs no GKE com o Saxml

Este tutorial demonstra como implementar e publicar um grande modelo de linguagem (GML) Gemma 2 usando TPUs no GKE com a framework de publicação Saxml. Este tutorial fornece uma base para compreender e explorar a implementação prática de MDIs para inferência num ambiente Kubernetes gerido. Implementa um contentor pré-criado com o Saxml no GKE. Também configura o GKE para carregar os pesos do Gemma 2B e 7B a partir do Cloud Storage no momento da execução.

Este tutorial destina-se a engenheiros de aprendizagem automática (AA), administradores e operadores de plataformas, bem como a especialistas em dados e IA interessados em usar as capacidades de orquestração de contentores do Kubernetes para publicar MDIs/CEs. Para saber mais sobre as funções comuns e as tarefas de exemplo a que fazemos referência no Cloud de Confiance by S3NS conteúdo, consulte Funções e tarefas comuns de utilizadores do GKE.

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

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.

Contexto

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

Gemma

O Gemma é um conjunto de modelos de 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, além de poder otimizar estes modelos para tarefas especializadas.

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

TPUs

As UTPs são circuitos integrados específicos da aplicação (ASICs) desenvolvidos pela Google e usados para acelerar as estruturas de tratamento de dados, como o TensorFlow, o PyTorch e o JAX.

Este tutorial disponibiliza os modelos Gemma 2B e Gemma 7B. O GKE aloja estes modelos nos seguintes conjuntos de nós da TPU v5e de anfitrião único:

  • Gemma 2B: modelo ajustado por instruções alojado num conjunto de nós da TPU v5e com uma 1x1topologia que representa um chip da TPU. O tipo de máquina dos nós é ct5lp-hightpu-1t.
  • Gemma 7B: modelo otimizado para instruções alojado num conjunto de nós da TPU v5e com uma 2x2 topologia que representa quatro chips da TPU. O tipo de máquina dos nós é ct5lp-hightpu-4t.

Saxml

O Saxml é um sistema experimental que publica modelos Paxml, JAX e PyTorch para inferência. O sistema Saxml inclui os seguintes componentes:

  • Célula Saxml ou cluster Sax: um servidor de administração e um grupo de servidores de modelos. O servidor de administração monitoriza os servidores de modelos, atribui modelos publicados aos servidores de modelos para publicação e ajuda os clientes a localizarem servidores de modelos que publicam modelos específicos.
  • Cliente Saxml: a interface de programação virada para o utilizador do sistema Saxml. O cliente Saxml inclui uma ferramenta de linha de comandos (saxutil) e um conjunto de bibliotecas cliente em Python, C++ e Go.

Neste tutorial, também usa o servidor HTTP Saxml. O servidor HTTP Saxml é um servidor HTTP personalizado que encapsula a biblioteca cliente Python Saxml e expõe APIs REST para interagir com o sistema Saxml. As APIs REST incluem pontos finais para publicar, listar, anular a publicação de modelos e gerar previsões.

Prepare o ambiente para o Gemma

Inicie o Cloud Shell

Neste tutorial, vai usar o Cloud Shell para gerir recursos alojados no Cloud de Confiance. O Cloud Shell está pré-instalado com o software necessário para este tutorial, incluindo kubectl e a CLI gcloud.

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

  2. Defina as variáveis de ambiente predefinidas:

    gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export LOCATION=LOCATION
export CLUSTER_NAME=saxml-tpu

    Substitua os seguintes valores:

Crie um cluster padrão do GKE

Nesta secção, cria o cluster do GKE e o node pool.

Gemma 2B-it

Use o Cloud Shell para fazer o seguinte:

  1. Crie um cluster Standard que use a Workload Identity Federation para o GKE:

    gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --release-channel=rapid \
    --workload-pool=${PROJECT_ID}.s3ns.svc.id.goog \
    --location=${LOCATION}

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

  2. Crie um node pool da TPU v5e com uma topologia 1x1 e um nó:

    gcloud container node-pools create tpu-v5e-1x1 \
    --cluster=${CLUSTER_NAME} \
    --machine-type=ct5lp-hightpu-1t \
    --num-nodes=1 \
    --location=${LOCATION}

    Publica o modelo Gemma 2B neste conjunto de nós.

Gemma 7B-it

Use o Cloud Shell para fazer o seguinte:

  1. Crie um cluster Standard que use a Workload Identity Federation para o GKE:

    gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --release-channel=rapid \
    --workload-pool=${PROJECT_ID}.s3ns.svc.id.goog \
    --location=${LOCATION}

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

  2. Crie um node pool da TPU v5e com uma topologia 2x2 e um nó:

    gcloud container node-pools create tpu-v5e-2x2 \
    --cluster=${CLUSTER_NAME} \
    --machine-type=ct5lp-hightpu-4t \
    --num-nodes=1 \
    --location=${LOCATION}

    Publica o modelo Gemma 7B neste conjunto de nós.

Crie os contentores do Cloud Storage

Crie dois contentores do Cloud Storage para gerir o estado do servidor de administração do Saxml e os pontos de verificação do modelo.

No Cloud Shell, execute o seguinte:

  1. Crie um contentor do Cloud Storage para armazenar as configurações do servidor de administração do Saxml.

    gcloud storage buckets create gs://ADMIN_BUCKET_NAME

    Substitua ADMIN_BUCKET_NAME pelo nome do contentor do Cloud Storage que armazena o servidor de administração do SAXML.

  2. Crie um contentor do Cloud Storage para armazenar pontos de verificação do modelo:

    gcloud storage buckets create gs://CHECKPOINTS_BUCKET_NAME

    Substitua CHECKPOINTS_BUCKET_NAME pelo nome do contentor do Cloud Storage que armazena os pontos de verificação do modelo.

Configure o acesso das suas cargas de trabalho através da federação de identidades de cargas de trabalho para o GKE

Atribua uma conta de serviço do Kubernetes à aplicação e configure essa conta de serviço do Kubernetes para funcionar como uma conta de serviço do IAM.

  1. Configure kubectl para comunicar com o cluster:

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

  2. Crie uma ServiceAccount do Kubernetes para a sua aplicação usar:

    gcloud iam service-accounts create wi-sax

  3. Adicione uma associação de políticas de IAM para a sua conta de serviço de IAM para ler e escrever no Cloud Storage:

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-sax@${PROJECT_ID}.s3ns.iam.gserviceaccount.com" \
    --role roles/storage.objectUser

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-sax@${PROJECT_ID}.s3ns.iam.gserviceaccount.com" \
    --role roles/storage.insightsCollectorService

  4. Permita que a conta de serviço do Kubernetes use a identidade da conta de serviço da IAM adicionando uma associação de políticas da IAM entre as duas contas de serviço. Esta associação permite que a conta de serviço do Kubernetes atue como a conta de serviço do IAM:

    gcloud iam service-accounts add-iam-policy-binding wi-sax@${PROJECT_ID}.s3ns.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:${PROJECT_ID}.s3ns.svc.id.goog[default/default]"

  5. Anotar a conta de serviço do Kubernetes com o endereço de email da conta de serviço do IAM:

    kubectl annotate serviceaccount default \
    iam.gke.io/gcp-service-account=wi-sax@${PROJECT_ID}.s3ns.iam.gserviceaccount.com

Aceda ao modelo

Para aceder aos modelos Gemma para implementação no GKE, tem de iniciar sessão na plataforma Kaggle, assinar o contrato de consentimento da licença e obter um token da API Kaggle. Neste tutorial, vai usar um segredo do Kubernetes para as credenciais do Kaggle.

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

  1. Aceda à página de consentimento do modelo em Kaggle.com.
  2. Inicie sessão no Kaggle, se ainda não o tiver feito.
  3. Clique em Pedir acesso.
  4. Na secção Escolher conta para consentimento, selecione Validar através da conta do Kaggle para usar a sua conta do Kaggle para conceder consentimento.
  5. 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:

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

O Kaggle transfere um ficheiro denominado kaggle.json.

Carregue o token de acesso para o Cloud Shell

No Cloud Shell, pode carregar o token da API Kaggle para o seu Cloud de Confiance by S3NS projeto:

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

Crie um segredo do Kubernetes para as credenciais da Kaggle

No Cloud Shell, siga estes passos:

  1. Configure kubectl para comunicar com o cluster:

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

  2. Crie um Secret para armazenar as credenciais do Kaggle:

    kubectl create secret generic kaggle-secret \
    --from-file=kaggle.json

Implemente o Saxml

Nesta secção, implementa o servidor de administração do Saxml, os servidores de modelos e o servidor HTTP. Este tutorial usa manifestos de implementação do Kubernetes. Uma implementação é um objeto da API Kubernetes que lhe permite executar várias réplicas de pods distribuídas entre os nós num cluster.

Implemente o servidor de administração do Saxml

Nesta secção, implementa o servidor de administração do Saxml.

  1. Crie o seguinte manifesto saxml-admin-server.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-admin-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sax-admin-server
  template:
    metadata:
      labels:
        app: sax-admin-server
    spec:
      hostNetwork: false
      containers:
      - name: sax-admin-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-admin-server:v1.2.0
        securityContext:
          privileged: true
        ports:
        - containerPort: 10000
        env:
        - name: GSBUCKET
          value: ADMIN_BUCKET_NAME

    Substitua ADMIN_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Não inclua o prefixo gs://.

  2. Aplique o manifesto:

    kubectl apply -f saxml-admin-server.yaml

  3. Valide a implementação do servidor de administração:

    kubectl get deployment

    O resultado tem um aspeto semelhante ao seguinte:

    NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
sax-admin-server                  1/1     1            1           ##s

Implemente o servidor de modelos Saxml

Siga estas instruções para implementar o servidor de modelos para o modelo Gemma 2B ou Gemma 7B.

Gemma 2B-it

  1. Crie o seguinte manifesto saxml-model-server-1x1.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-model-server-v5e-1x1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b-it
        ai.gke.io/inference-server: saxml
        examples.ai.gke.io/source: user-guide
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 1x1
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      hostNetwork: false
      restartPolicy: Always
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
        args:
        - "--jax_platforms=tpu"
        - "--platform_chip=tpuv5e"
        - "--platform_topology=1x1"
        - "--port=10001"
        - "--sax_cell=/sax/test"
        ports:
        - containerPort: 10001
        securityContext:
          privileged: true
        env:
        - name: SAX_ROOT
          value: "gs://ADMIN_BUCKET_NAME/sax-root"
        resources:
          requests:
            google.com/tpu: 1
          limits:
            google.com/tpu: 1

    Substitua ADMIN_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Não inclua o prefixo gs://.

  2. Aplique o manifesto:

    kubectl apply -f saxml-model-server-1x1.yaml

  3. Verifique o estado da implementação do servidor de modelos:

    kubectl get deployment

    O resultado tem um aspeto semelhante ao seguinte:

    NAME                                              READY   STATUS    RESTARTS   AGE
sax-admin-server                                  1/1     Running   0          ##m
sax-model-server-v5e-1x1                          1/1     Running   0          ##s

Gemma 7B-it

  1. Crie o seguinte manifesto saxml-model-server-2x2.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-model-server-v5e-2x2
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b-it
        ai.gke.io/inference-server: saxml
        examples.ai.gke.io/source: user-guide
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x2
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      hostNetwork: false
      restartPolicy: Always
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
        args:
        - "--jax_platforms=tpu"
        - "--platform_chip=tpuv5e"
        - "--platform_topology=2x2"
        - "--port=10001"
        - "--sax_cell=/sax/test"
        ports:
        - containerPort: 10001
        securityContext:
          privileged: true
        env:
        - name: SAX_ROOT
          value: "gs://ADMIN_BUCKET_NAME/sax-root"
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4

    Substitua ADMIN_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Não inclua o prefixo gs://.

  2. Aplique o manifesto:

    kubectl apply -f saxml-model-server-2x2.yaml

  3. Verifique o estado da implementação do servidor de modelos:

    kubectl get deployment

    O resultado tem um aspeto semelhante ao seguinte:

    NAME                                              READY   STATUS    RESTARTS   AGE
sax-admin-server                                  1/1     Running   0          ##m
sax-model-server-v5e-2x2                          1/1     Running   0          ##s

Implemente o servidor HTTP Saxml

Nesta secção, implementa o servidor HTTP Saxml e cria um serviço de IP do cluster que usa para aceder ao servidor.

  1. Crie o seguinte manifesto saxml-http.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: sax-http
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sax-http
  template:
    metadata:
      labels:
        app: sax-http
    spec:
      hostNetwork: false
      containers:
      - name: sax-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-http:v1.2.0
        imagePullPolicy: Always
        ports:
        - containerPort: 8888
        env:
        - name: SAX_ROOT
          value: "gs://ADMIN_BUCKET_NAME/sax-root"
---
apiVersion: v1
kind: Service
metadata:
  name: sax-http-svc
spec:
  selector:
    app: sax-http
  ports:
  - protocol: TCP
    port: 8888
    targetPort: 8888
  type: ClusterIP

    Substitua ADMIN_BUCKET_NAME pelo nome do contentor do Cloud Storage que armazena o servidor de administração do SAXML.

  2. Aplique o manifesto:

    kubectl apply -f saxml-http.yaml

  3. Verifique o estado da implementação do servidor HTTP Saxml:

    kubectl get deployment

    Gemma 2B-it

    O resultado tem um aspeto semelhante ao seguinte:

    NAME                                              READY   STATUS    RESTARTS   AGE
sax-admin-server                                  1/1     Running   0          ##m
sax-model-server-v5e-1x1                          1/1     Running   0          ##m
sax-http                                          1/1     Running   0          ##s

    Gemma 7B-it

    O resultado tem um aspeto semelhante ao seguinte:

    NAME                                              READY   STATUS    RESTARTS   AGE
sax-admin-server                                  1/1     Running   0          ##m
sax-model-server-v5e-2x2                          1/1     Running   0          ##m
sax-http                                          1/1     Running   0          ##s

Transfira o ponto de verificação do modelo

Nesta secção, executa um trabalho do Kubernetes que obtém, transfere e armazena o ponto de restauro do modelo. Um controlador de tarefas no Kubernetes cria um ou mais pods e garante que executam com êxito uma tarefa específica.

Siga os passos para o modelo Gemma que quer usar:

Gemma 2B-it

  1. Crie o seguinte manifesto job-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}') && \

    mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \

    gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-2b
  labels:
    app: data-loader-2b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-2b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
        command:
        - /scripts/fetch_model.sh
        env:
        - name: BUCKET_NAME
          value: CHECKPOINTS_BUCKET_NAME
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/pax/2b-it/2"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts

    Substitua CHECKPOINTS_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Não inclua o prefixo gs://.

  2. Aplique o manifesto:

    kubectl apply -f job-2b.yaml

  3. Aguarde a conclusão da tarefa:

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

    O resultado tem um aspeto semelhante ao seguinte:

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

  4. Verifique se a tarefa foi concluída com êxito:

    kubectl get job/data-loader-2b

    O resultado tem um aspeto semelhante ao seguinte:

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

  5. Veja os registos da tarefa:

    kubectl logs --follow job/data-loader-2b

A tarefa carrega o ponto de restauro para gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000.

Gemma 7B-it

  1. Crie o seguinte manifesto job-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}') && \

    mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \

    gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
    echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-7b
  labels:
    app: data-loader-7b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-7b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
        command:
        - /scripts/fetch_model.sh
        env:
        - name: BUCKET_NAME
          value: CHECKPOINTS_BUCKET_NAME
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/pax/7b-it/2"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts

    Substitua CHECKPOINTS_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Inclua o prefixo gs://.

  2. Aplique o manifesto:

    kubectl apply -f job-7b.yaml

  3. Aguarde a conclusão da tarefa:

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

    O resultado tem um aspeto semelhante ao seguinte:

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

  4. Verifique se a tarefa foi concluída com êxito:

    kubectl get job/data-loader-7b

    O resultado tem um aspeto semelhante ao seguinte:

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

  5. Veja os registos da tarefa:

    kubectl logs --follow job/data-loader-7b

A tarefa carrega o ponto de restauro para gs://CHECKPOINTS_BUCKET_NAME/gemma_7b_it/checkpoint_00000000.

Exponha o servidor HTTP Saxml

Pode aceder ao servidor HTTP Saxml através do serviço ClusterIP que criou quando implementou o servidor HTTP Saxml. Os serviços ClusterIP só são acessíveis a partir do cluster. Por conseguinte, para aceder ao serviço a partir do exterior do cluster, conclua os seguintes passos:

  1. Estabeleça uma sessão de encaminhamento de porta:

    kubectl port-forward service/sax-http-svc 8888:8888

  2. Verifique se consegue aceder ao servidor HTTP Saxml abrindo um novo terminal e executando o seguinte comando:

    curl -s localhost:8888

    O resultado tem um aspeto semelhante ao seguinte:

    {
    "Message": "HTTP Server for SAX Client"
}

O servidor HTTP Saxml encapsula a interface do cliente para o sistema Saxml e expõe-na através de um conjunto de APIs REST. Use estas APIs para publicar, gerir e interagir com os modelos Gemma 2B e Gemma 7B.

Publique o modelo Gemma

Em seguida, pode publicar o modelo Gemma num servidor de modelos que é executado num conjunto de nós de fragmentos de TPU. Usa a API publish do servidor HTTP Saxml para publicar um modelo. Siga estes passos para publicar o modelo de parâmetros Gemma 2B ou 7B.

Para saber mais sobre a API do servidor HTTP Saxml, consulte o artigo APIs HTTP Saxml.

Gemma 2B-it

  1. Certifique-se de que a sessão de encaminhamento de portas ainda está ativa:

    curl -s localhost:8888

  2. Publicar o parâmetro Gemma 2B:

    curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/publish \
--data \
'{
    "model": "/sax/test/gemma2bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
    "replicas": "1"
}'

    O resultado tem um aspeto semelhante ao seguinte:

    {
    "model": "/sax/test/gemma2bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
    "replicas": 1
}

    Consulte o passo seguinte para monitorizar o progresso da implementação.

  3. Monitorize o progresso observando os registos num pod do servidor de modelos da implementação sax-model-server-v5e-1x1.

    kubectl logs --follow deployment/sax-model-server-v5e-1x1

    Esta implementação pode demorar até cinco minutos a ser concluída. Aguarde até ver uma mensagem semelhante à seguinte:

    I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma2bfp16

  4. Confirme se consegue aceder ao modelo apresentando as informações do modelo:

    curl --request GET \
--header "Content-type: application/json" \
-s \
localhost:8888/listcell \
--data \
'{
    "model": "/sax/test/gemma2bfp16"
}'

    O resultado tem um aspeto semelhante ao seguinte:

    {
    "model": "/sax/test/gemma2bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
    "max_replicas": 1,
    "active_replicas": 1
}

Gemma 7B-it

  1. Certifique-se de que a sessão de encaminhamento de portas ainda está ativa:

    curl -s localhost:8888

  2. Publique o parâmetro Gemma 7B:

    curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/publish \
--data \
'{
    "model": "/sax/test/gemma7bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
    "replicas": "1"
}'

    O resultado tem um aspeto semelhante ao seguinte:

    {
    "model": "/sax/test/gemma7bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
    "replicas": 1
}

    Consulte o passo seguinte para monitorizar o progresso da implementação.

  3. Monitorize o progresso observando os registos num pod do servidor de modelos da implementação sax-model-server-v5e-2x2.

    kubectl logs --follow deployment/sax-model-server-v5e-2x2

    Aguarde até ver uma mensagem semelhante à seguinte:

    I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma7bfp16

  4. Verifique se o modelo foi publicado apresentando as informações do modelo:

    curl --request GET \
--header "Content-type: application/json" \
-s \
localhost:8888/listcell \
--data \
'{
    "model": "/sax/test/gemma7bfp16"
}'

    O resultado é semelhante ao seguinte:

    {
    "model": "/sax/test/gemma7bfp16",
    "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
    "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
    "max_replicas": 1,
    "active_replicas": 1
}

Use o modelo

Pode interagir com os modelos Gemma 2B ou 7B. Use a API generate do servidor HTTP do Saxml para enviar um comando ao modelo.

Gemma 2B-it

Publique um pedido de comando através do ponto final generate do servidor HTTP Saxml:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/generate \
--data \
'{
  "model": "/sax/test/gemma2bfp16",
  "query": "What are the top 5 most popular programming languages?"
}'

Segue-se um exemplo da resposta do modelo. O resultado real varia com base no comando que apresenta:

[
    [
        "\n\n1. **Python**\n2. **JavaScript**\n3. **Java**\n4. **C++**\n5. **Go**",
        -3.0704939365386963
    ]
]

Pode executar o comando com diferentes parâmetros query. Também pode modificar parâmetros adicionais, como temperature, top_k e topc_p, através da API generate. Para saber mais sobre a API do servidor HTTP Saxml, consulte o artigo APIs HTTP Saxml.

Gemma 7B-it

Publique um pedido de comando através do ponto final generate do servidor HTTP Saxml:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/generate \
--data \
'{
  "model": "/sax/test/gemma7bfp16",
  "query": "What are the top 5 most popular programming languages?"
}'

Segue-se um exemplo da resposta do modelo. A saída pode variar em cada comando que publica:

[
    [
        "\n\n**1. JavaScript**\n\n* Most widely used language on the web.\n* Used for front-end development, such as websites and mobile apps.\n* Extensive libraries and frameworks available.\n\n**2. Python**\n\n* Known for its simplicity and readability.\n* Versatile, used for various tasks, including data science, machine learning, and web development.\n* Large and active community.\n\n**3. Java**\n\n* Object-oriented language widely used in enterprise applications.\n* Used for web applications, mobile apps, and enterprise software.\n* Strong ecosystem and support.\n\n**4. Go**\n\n",
        -16.806324005126953
    ]
]

Pode executar o comando com diferentes parâmetros query. Também pode modificar parâmetros adicionais, como temperature, top_k e topc_p, através da API generate. Para saber mais sobre a API do servidor HTTP Saxml, consulte o artigo APIs HTTP Saxml.

Anule a publicação do modelo

Siga estes passos para anular a publicação do modelo:

Gemma 2B-it

Para anular a publicação do modelo Gemma de 2 mil milhões de parâmetros, execute o seguinte comando:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/unpublish \
--data \
'{
    "model": "/sax/test/gemma2bfp16"
}'

O resultado tem um aspeto semelhante ao seguinte:

{
    "model": "/sax/test/gemma2bfp16"
}

Pode executar o comando com diferentes comandos que são transmitidos no parâmetro query.

Gemma 7B-it

Para anular a publicação do modelo Gemma de 7 mil milhões de bits, execute o seguinte comando:

curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8888/unpublish \
--data \
'{
    "model": "/sax/test/gemma7bfp16"
}'

O resultado tem um aspeto semelhante ao seguinte:

{
    "model": "/sax/test/gemma7bfp16"
}

Pode executar o comando com diferentes comandos que são transmitidos no parâmetro query.

Resolver problemas