Esta página foi traduzida pela API Cloud Translation.

Implantar e inferir o Gemma usando endpoints com TPU do Model Garden e da Vertex AI

Neste tutorial, você vai usar o Model Garden para implantar o modelo aberto Gemma 2B em um endpoint da Vertex AI com suporte a TPU. Implante um modelo em um endpoint antes de ele ser usado para exibir previsões on-line. A implantação de um modelo associa recursos físicos ao modelo para que ele possa exibir previsões on-line com baixa latência.

Depois de implantar o modelo Gemma 2B, você infere o modelo treinado usando o PredictionServiceClient para receber previsões on-line. As previsões on-line são solicitações síncronas feitas em um modelo implantado em um endpoint.

Objetivos

Este tutorial mostra como fazer as seguintes tarefas:

Implante o modelo aberto Gemma 2B em um endpoint com suporte a TPU usando o Model Garden.
Usar o PredictionServiceClient para receber previsões on-line

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

A ct5lp-hightpu-1t machine type with one TPU_V5 accelerator
Vertex AI prediction and explanation

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

Para este tutorial, você precisa:

Configurar um projeto do Google Cloud e ativar a API Vertex AI
Na máquina local:
- Instalar, inicializar e autenticar com a Google Cloud CLI
- Instalar o SDK para seu idioma

Configurar um Google Cloud projeto

Configure o Google Cloud projeto e ative a API Vertex AI.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Vertex AI API.

Enable the API

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Vertex AI API.

Enable the API

Configure a Google Cloud CLI

Na máquina local, configure a CLI do Google Cloud.

Instale e inicialize a Google Cloud CLI.
Se você já instalou a CLI gcloud, execute este comando para garantir que os componentes gcloud estejam atualizados.
```
gcloud components update
```
Para fazer a autenticação com a CLI gcloud, gere um arquivo local de credenciais padrão do aplicativo (ADC, na sigla em inglês) executando este comando. O fluxo da Web iniciado pelo comando é usado para fornecer suas credenciais de usuário.
```
gcloud auth application-default login
```
Para mais informações, consulte Configuração de autenticação da gcloud CLI e configuração do ADC.

Configurar o SDK para sua linguagem de programação

Para configurar o ambiente usado neste tutorial, instale o SDK da Vertex AI para sua linguagem e a biblioteca Protocol Buffers. Os exemplos de código usam funções da biblioteca Protocol Buffers para converter o dicionário de entrada no formato JSON esperado pela API.

Na máquina local, clique em uma das guias a seguir para instalar o SDK para sua linguagem de programação.

Python

Na máquina local, clique em uma das guias a seguir para instalar o SDK da sua linguagem de programação.

Instale e atualize o SDK da Vertex AI para Python executando este comando.
```
pip3 install --upgrade "google-cloud-aiplatform>=1.64"
```
Instale a biblioteca Protocol Buffers para Python executando este comando.
```
pip3 install --upgrade "protobuf>=5.28"
```

Node.js

Instale ou atualize o SDK aiplatform para Node.js executando o seguinte comando.

npm install @google-cloud/aiplatform

Java

Para adicionar google-cloud-aiplatform como uma dependência, adicione o código apropriado para seu ambiente.

Maven com BoM

Adicione o seguinte HTML ao pom.xml:

<dependencyManagement>
<dependencies>
  <dependency>
    <artifactId>libraries-bom</artifactId>
    <groupId>com.google.cloud</groupId>
    <scope>import</scope>
    <type>pom</type>
    <version>26.34.0</version>
  </dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-aiplatform</artifactId>
</dependency>
<dependency>
  <groupId>com.google.protobuf</groupId>
  <artifactId>protobuf-java-util</artifactId>
</dependency>
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
</dependency>
</dependencies>

Maven sem BOM

Adicione o seguinte ao pom.xml:

<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-aiplatform</artifactId>
  <version>1.1.0</version>
</dependency>
<dependency>
  <groupId>com.google.protobuf</groupId>
  <artifactId>protobuf-java-util</artifactId>
  <version>5.28</version>
</dependency>
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.11.0</version>
</dependency>

Gradle sem BoM

Adicione o seguinte ao seu build.gradle:

implementation 'com.google.cloud:google-cloud-aiplatform:1.1.0'

Go

Instale esses pacotes Go executando os seguintes comandos.

go get cloud.google.com/go/aiplatform
go get google.golang.org/protobuf
go get github.com/googleapis/gax-go/v2

Implantar o Gemma usando o Model Garden

Você implanta o modelo Gemma 2B em um tipo de máquina ct5lp-hightpu-1t do Compute Engine otimizado para treinamento de pequena a média escala. Essa máquina tem um acelerador TPU v5e. Para mais informações sobre o treinamento de modelos usando TPUs, consulte Treinamento do Cloud TPU v5e.

Neste tutorial, você implanta o modelo aberto do Gemma 2B ajustado por instrução usando o card de modelo no Model Garden. A versão específica do modelo é gemma2-2b-it. -it significa ajuste de instruções.

O modelo Gemma 2B tem um tamanho de parâmetro menor, o que significa requisitos de recursos menores e mais flexibilidade de implantação.

No Console do Google Cloud, acesse a página Model Garden.

Acessar o Model Garden
Clique no card de modelo Gemma 2.

Acessar o Gemma 2
Clique em Implantar para abrir o painel Implantar modelo.
No painel Implantar modelo, especifique estes detalhes.
1. Em Ambiente de implantação, clique em Vertex AI.
2. Na seção Implantar modelo:
  1. Em ID do recurso, escolha gemma-2b-it.
  2. Para Nome do modelo e Nome do endpoint, aceite os valores padrão. Exemplo:
    - Nome do modelo: gemma2-2b-it-1234567891234
    - Nome do endpoint: gemma2-2b-it-mg-one-click-deploy
    Anote o nome do endpoint. Você vai precisar dela para encontrar o ID do endpoint usado nos exemplos de código.
3. Na seção Configurações de implantação:
  1. Aceite a opção padrão para as configurações Básico.
  2. Em Região, aceite o valor padrão ou escolha uma região na lista. Anote a região. Você vai precisar dele para os exemplos de código.
  3. Em Especificação da máquina, escolha a instância com suporte de TPU: ct5lp-hightpu-1t (1 TPU_V5_LITEPOD; ct5lp-hightpu-1t).
Clique em Implantar. Quando a implantação for concluída, você vai receber um e-mail com detalhes sobre o novo endpoint. Também é possível conferir os detalhes do endpoint clicando em Previsão on-line > Endpoints e selecionando sua região.

Acessar o Endpoints

Inferir o Gemma 2B com o PredictionServiceClient

Depois de implantar o Gemma 2B, use o PredictionServiceClient para receber previsões on-line para a instrução: "Por que o céu é azul?"

Parâmetros de código

Os exemplos de código PredictionServiceClient exigem que você atualize o seguinte:

PROJECT_ID: para encontrar o ID do projeto, siga estas etapas.
1. Acesse a página Welcome no console do Google Cloud.
  Acesse a página "Bem-vindo"
2. No seletor de projetos na parte de cima da página, selecione seu projeto.
  
  O nome, o número e o ID do projeto aparecem após o título Welcome.
ENDPOINT_REGION: é a região em que você implantou o endpoint.
ENDPOINT_ID: para encontrar o ID do endpoint, confira no console ou execute o comando gcloud ai endpoints list. Você vai precisar do nome e da região do endpoint no painel Deploy model.
Console
Para conferir os detalhes do endpoint, clique em Previsão on-line > Endpoints e selecione sua região. Anote o número que aparece na coluna ID.

Acessar o Endpoints
gcloud
Para conferir os detalhes do endpoint, execute o comando gcloud ai endpoints list.
```
gcloud ai endpoints list \
  --region=ENDPOINT_REGION \
  --filter=display_name=ENDPOINT_NAME
```
A saída é semelhante a esta.
```
Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy
```

Código de amostra

No exemplo de código para sua linguagem, atualize o PROJECT_ID, ENDPOINT_REGION e ENDPOINT_ID. Em seguida, execute o código.

SDK da Vertex AI para Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Saiba mais na documentação de referência da API SDK da Vertex AI para Python.

"""
Sample to run inference on a Gemma2 model deployed to a Vertex AI endpoint with TPU accellerators.
"""

from google.cloud import aiplatform
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value

# TODO(developer): Update & uncomment lines below
# PROJECT_ID = "your-project-id"
# ENDPOINT_REGION = "your-vertex-endpoint-region"
# ENDPOINT_ID = "your-vertex-endpoint-id"

# Default configuration
config = {"max_tokens": 1024, "temperature": 0.9, "top_p": 1.0, "top_k": 1}

# Prompt used in the prediction
prompt = "Why is the sky blue?"

# Encapsulate the prompt in a correct format for TPUs
# Example format: [{'prompt': 'Why is the sky blue?', 'temperature': 0.9}]
input = {"prompt": prompt}
input.update(config)

# Convert input message to a list of GAPIC instances for model input
instances = [json_format.ParseDict(input, Value())]

# Create a client
api_endpoint = f"{ENDPOINT_REGION}-aiplatform.googleapis.com"
client = aiplatform.gapic.PredictionServiceClient(
    client_options={"api_endpoint": api_endpoint}
)

# Call the Gemma2 endpoint
gemma2_end_point = (
    f"projects/{PROJECT_ID}/locations/{ENDPOINT_REGION}/endpoints/{ENDPOINT_ID}"
)
response = client.predict(
    endpoint=gemma2_end_point,
    instances=instances,
)
text_responses = response.predictions
print(text_responses[0])

Node.js

Antes de testar esse exemplo, siga as instruções de configuração para Node.js no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

// Imports the Google Cloud Prediction Service Client library
const {
  // TODO(developer): Uncomment PredictionServiceClient before running the sample.
  // PredictionServiceClient,
  helpers,
} = require('@google-cloud/aiplatform');
/**
 * TODO(developer): Update these variables before running the sample.
 */
const projectId = 'your-project-id';
const endpointRegion = 'your-vertex-endpoint-region';
const endpointId = 'your-vertex-endpoint-id';

// Prompt used in the prediction
const prompt = 'Why is the sky blue?';

// Encapsulate the prompt in a correct format for TPUs
// Example format: [{prompt: 'Why is the sky blue?', temperature: 0.9}]
const input = {
  prompt,
  // Parameters for default configuration
  maxOutputTokens: 1024,
  temperature: 0.9,
  topP: 1.0,
  topK: 1,
};

// Convert input message to a list of GAPIC instances for model input
const instances = [helpers.toValue(input)];

// TODO(developer): Uncomment apiEndpoint and predictionServiceClient before running the sample.
// const apiEndpoint = `${endpointRegion}-aiplatform.googleapis.com`;

// Create a client
// predictionServiceClient = new PredictionServiceClient({apiEndpoint});

// Call the Gemma2 endpoint
const gemma2Endpoint = `projects/${projectId}/locations/${endpointRegion}/endpoints/${endpointId}`;

const [response] = await predictionServiceClient.predict({
  endpoint: gemma2Endpoint,
  instances,
});

const predictions = response.predictions;
const text = predictions[0].stringValue;

console.log('Predictions:', text);

Java

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.gson.Gson;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Gemma2PredictTpu {
  private final PredictionServiceClient predictionServiceClient;

  // Constructor to inject the PredictionServiceClient
  public Gemma2PredictTpu(PredictionServiceClient predictionServiceClient) {
    this.predictionServiceClient = predictionServiceClient;
  }

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String endpointRegion = "us-west1";
    String endpointId = "YOUR_ENDPOINT_ID";

    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint(String.format("%s-aiplatform.googleapis.com:443", endpointRegion))
            .build();
    PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings);
    Gemma2PredictTpu creator = new Gemma2PredictTpu(predictionServiceClient);

    creator.gemma2PredictTpu(projectId, endpointRegion, endpointId);
  }

  // Demonstrates how to run inference on a Gemma2 model
  // deployed to a Vertex AI endpoint with TPU accelerators.
  public String gemma2PredictTpu(String projectId, String region,
           String endpointId) throws IOException {
    Map<String, Object> paramsMap = new HashMap<>();
    paramsMap.put("temperature", 0.9);
    paramsMap.put("maxOutputTokens", 1024);
    paramsMap.put("topP", 1.0);
    paramsMap.put("topK", 1);
    Value parameters = mapToValue(paramsMap);
    // Prompt used in the prediction
    String instance = "{ \"prompt\": \"Why is the sky blue?\"}";
    Value.Builder instanceValue = Value.newBuilder();
    JsonFormat.parser().merge(instance, instanceValue);
    // Encapsulate the prompt in a correct format for TPUs
    // Example format: [{'prompt': 'Why is the sky blue?', 'temperature': 0.9}]
    List<Value> instances = new ArrayList<>();
    instances.add(instanceValue.build());

    EndpointName endpointName = EndpointName.of(projectId, region, endpointId);

    PredictResponse predictResponse = this.predictionServiceClient
        .predict(endpointName, instances, parameters);
    String textResponse = predictResponse.getPredictions(0).getStringValue();
    System.out.println(textResponse);
    return textResponse;
  }

  private static Value mapToValue(Map<String, Object> map) throws InvalidProtocolBufferException {
    Gson gson = new Gson();
    String json = gson.toJson(map);
    Value.Builder builder = Value.newBuilder();
    JsonFormat.parser().merge(json, builder);
    return builder.build();
  }
}

Go

Antes de testar esse exemplo, siga as instruções de configuração para Go no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Go.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/aiplatform/apiv1/aiplatformpb"

	"google.golang.org/protobuf/types/known/structpb"
)

// predictTPU demonstrates how to run interference on a Gemma2 model deployed to a Vertex AI endpoint with TPU accelerators.
func predictTPU(w io.Writer, client PredictionsClient, projectID, location, endpointID string) error {
	ctx := context.Background()

	// Note: client can be initialized in the following way:
	// apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)
	// client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	// if err != nil {
	// 	return fmt.Errorf("unable to create prediction client: %v", err)
	// }
	// defer client.Close()

	gemma2Endpoint := fmt.Sprintf("projects/%s/locations/%s/endpoints/%s", projectID, location, endpointID)
	prompt := "Why is the sky blue?"
	parameters := map[string]interface{}{
		"temperature":     0.9,
		"maxOutputTokens": 1024,
		"topP":            1.0,
		"topK":            1,
	}

	// Encapsulate the prompt in a correct format for TPUs.
	// Example format: [{'prompt': 'Why is the sky blue?', 'temperature': 0.9}]
	promptValue, err := structpb.NewValue(map[string]interface{}{
		"prompt":     prompt,
		"parameters": parameters,
	})
	if err != nil {
		fmt.Fprintf(w, "unable to convert prompt to Value: %v", err)
		return err
	}

	req := &aiplatformpb.PredictRequest{
		Endpoint:  gemma2Endpoint,
		Instances: []*structpb.Value{promptValue},
	}

	resp, err := client.Predict(ctx, req)
	if err != nil {
		return err
	}

	prediction := resp.GetPredictions()
	value := prediction[0].GetStringValue()
	fmt.Fprintf(w, "%v", value)

	return nil
}

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 o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Excluir recursos individuais

Se você quiser manter seu projeto, exclua os recursos usados neste tutorial:

Desfazer a implantação do modelo e excluir o endpoint
Excluir o modelo do Model Registry

Desfazer a implantação do modelo e excluir o endpoint

Use um dos métodos a seguir para desimplantar um modelo e excluir o endpoint.

Console

No console do Google Cloud, clique em Previsão on-line e em Endpoints.

Acessar a página do Endpoints
Na lista suspensa Região, escolha a região em que você implantou o endpoint.
Clique no nome do endpoint para abrir a página de detalhes. Por exemplo: gemma2-2b-it-mg-one-click-deploy.
Na linha do modelo Gemma 2 (Version 1), clique em Ações e, em seguida, em Cancelar a implantação do modelo no endpoint.
Na caixa de diálogo Cancelar a implantação do modelo do endpoint, clique em Cancelar a implantação.
Clique no botão Voltar para retornar à página Endpoints.

Acessar a página do Endpoints
No final da linha gemma2-2b-it-mg-one-click-deploy, clique em Ações e selecione Excluir endpoint.
No prompt de confirmação, clique em Confirmar.

gcloud

Para desimplantar o modelo e excluir o endpoint usando a CLI do Google Cloud, siga estas etapas.

Nesses comandos, substitua:

PROJECT_ID pelo nome do projeto;
LOCATION_ID pela região em que você implantou o modelo e o endpoint
ENDPOINT_ID com o ID do endpoint
DEPLOYED_MODEL_NAME com o nome de exibição do modelo
DEPLOYED_MODEL_ID pelo ID do modelo

Para receber o ID do endpoint, execute o comando gcloud ai endpoints list. Esse comando lista os IDs de todos os endpoints no seu projeto. Anote o ID do endpoint usado neste tutorial.
```
gcloud ai endpoints list \
    --project=PROJECT_ID \
    --region=LOCATION_ID
```
A saída é semelhante a esta. Na saída, o ID é chamado de ENDPOINT_ID.
```
Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy
```

Para receber o ID do modelo, execute o comando gcloud ai models describe. Anote o ID do modelo implantado neste tutorial.

gcloud ai models describe DEPLOYED_MODEL_NAME \
    --project=PROJECT_ID \
    --region=LOCATION_ID

A saída abreviada é assim. Na saída, o ID é chamado de deployedModelId.

Using endpoint [https://us-central1-aiplatform.googleapis.com/]
artifactUri: [URI removed]
baseModelSource:
  modelGardenSource:
    publicModelName: publishers/google/models/gemma2
...
deployedModels:
- deployedModelId: '1234567891234567891'
  endpoint: projects/12345678912/locations/us-central1/endpoints/12345678912345
displayName: gemma2-2b-it-12345678912345
etag: [ETag removed]
modelSourceInfo:
  sourceType: MODEL_GARDEN
name: projects/123456789123/locations/us-central1/models/gemma2-2b-it-12345678912345
...

Desimplante o modelo do endpoint. Você vai precisar do ID do endpoint e do ID do modelo dos comandos anteriores.

gcloud ai endpoints undeploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID \
    --deployed-model-id=DEPLOYED_MODEL_ID

Esse comando não produz saída.

Execute o comando gcloud ai endpoints delete para excluir o endpoint.
```
gcloud ai endpoints delete ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID
```
Quando solicitado, digite y para confirmar. Esse comando não produz saída.

Excluir o modelo

Console

Acesse a página Registro do modelo na seção "Vertex AI" do Console do Google Cloud.

Acessar a página "Modelo de registro"
Na lista suspensa Região, escolha a região em que você implantou o modelo.
No final da linha gemma2-2b-it-1234567891234, clique em Ações.
Selecione Excluir modelo.

Quando você exclui o modelo, todas as versões e avaliações de modelo associadas são excluídas do projeto Google Cloud .
No aviso de confirmação, clique em Excluir.

gcloud

Para excluir o modelo usando a CLI do Google Cloud, forneça o nome de exibição e a região do modelo ao comando gcloud ai models delete.

gcloud ai models delete DEPLOYED_MODEL_NAME \
    --project=PROJECT_ID \
    --region=LOCATION_ID

Substitua DEPLOYED_MODEL_NAME pelo nome de exibição do modelo. Substitua PROJECT_ID pelo nome do projeto. Substitua LOCATION_ID pela região em que você implantou o modelo.

A seguir

Saiba mais sobre os modelos abertos do Gemma.
Leia os Termos de Uso do Gemma.
Saiba mais sobre os modelos abertos.
Saiba como implantar um modelo ajustado.
Saiba como implantar o Gemma 2 no Google Kubernetes Engine usando a inferência de Textgen (TGI) do HuggingFace.
Saiba mais sobre o PredictionServiceClient no seu idioma preferido: Python, Node.js, Java ou Go.