O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Implante e faça inferências com a Gemma usando o Model Garden e os endpoints da plataforma de agentes do Gemini Enterprise com suporte de TPU

Neste tutorial, você usa o Model Garden para implantar o modelo aberto Gemma 2 2B em um endpoint da Gemini Enterprise Agent Platform acelerado por 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 disponibilizar previsões on-line com baixa latência.

Depois de implantar o modelo Gemma 2 2B, faça a inferência do 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 2 2B em um endpoint com suporte de TPU usando o Model Garden
Usar o PredictionServiceClient para receber previsões on-line

Custos

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

A ct5lp-hightpu-1t machine type with one TPU_V5 accelerator
Gemini Enterprise Agent Platform 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 um teste sem custo financeiro.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Para mais informações, consulte Limpeza.

Antes de começar

Para este tutorial, você precisa:

Configurar um projeto Google Cloud e ativar a API Agent Platform
Na sua máquina local:
- Instalar, inicializar e autenticar com a Google Cloud CLI
- Instalar o SDK para sua linguagem

Configurar um projeto do Google Cloud

Configure seu projeto do Google Cloud e ative a API Agent Platform.

Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloud, 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.

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Agent Platform API, if it is not already enabled.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the API

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Agent Platform API, if it is not already enabled.

Roles required to enable APIs

Enable the API

Configure a Google Cloud CLI

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

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 autenticar com a CLI gcloud, gere um arquivo local de Application Default Credentials (ADC) 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 CLI gcloud 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 Gemini Enterprise Agent Platform 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 seguintes guias para instalar o SDK da linguagem de programação.

Python

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

Instale e atualize o SDK da Agent Platform para Python executando este comando.
```
pip3 install --upgrade "google-cloud-aiplatform>=1.64"
```
Execute este comando para instalar a biblioteca Protocol Buffers para Python.
```
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 seu 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 seu 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 2 2B em um tipo de máquina do Compute Engine ct5lp-hightpu-1t 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 Gemma 2 2B ajustado por instruções usando o card de modelo no Model Garden. A versão específica do modelo é gemma2-2b-it. -it significa ajustado por instrução.

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

No console 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 Agent Platform.
2. Na seção Implantar modelo:
  1. Em ID do recurso, escolha gemma-2b-it.
  2. Em 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 dele 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ásicas.
  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. Para conferir os detalhes do endpoint, clique em Previsão on-line > Endpoints e selecione sua região.

Acessar o Endpoints

Fazer inferência do Gemma 2 2B com o PredictionServiceClient

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

Parâmetros de código

As amostras 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 Boas-vindas no console do Google Cloud .
  Acessar "Boas-vindas"
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 depois do título Bem-vindo.
ENDPOINT_REGION: a região em que você implantou o endpoint.
ENDPOINT_ID: para encontrar o ID do endpoint, consulte-o no console ou execute o comando gcloud ai endpoints list. Você vai precisar do nome e da região do endpoint no painel Implantar modelo.
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 da sua linguagem, atualize PROJECT_ID, ENDPOINT_REGION e ENDPOINT_ID. Em seguida, execute o código.

Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API 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 esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido da Agent Platform: como usar bibliotecas de cliente.

Para autenticar no Agent Platform, 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 esta amostra, siga as instruções de configuração do Java no Guia de início rápido da Agent Platform: como usar bibliotecas de cliente.

Para autenticar no Agent Platform, 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 esta amostra, siga as instruções de configuração do Go no Guia de início rápido da Agent Platform: como usar bibliotecas de cliente.

Para autenticar no Agent Platform, 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

No console Google Cloud , acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir recursos individuais

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

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

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

Use um dos seguintes métodos para cancelar a implantação de um modelo e excluir o endpoint.

Console

No console do Google Cloud , clique em Previsão on-line e depois 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, clique 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 cancelar a implantação do modelo e excluir o endpoint usando a Google Cloud CLI, 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 com o 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
...

Remova a implantação do 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 Model Registry na seção "Agent Platform" do console 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 associadas são excluídas do seu projeto do Google Cloud .
No prompt de confirmação, clique em Excluir.

gcloud

Para excluir o modelo usando a Google Cloud CLI, 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 modelos abertos.
Saiba como implantar um modelo ajustado.
Saiba como implantar o Gemma 2 no Google Kubernetes Engine usando a inferência Textgen (TGI) do HuggingFace.
Saiba mais sobre o PredictionServiceClient na sua linguagem preferida: Python, Node.js, Java ou Go.

Implante e faça inferências com a Gemma usando o Model Garden e os endpoints da plataforma de agentes do Gemini Enterprise com suporte de TPU Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Objetivos

Custos

Antes de começar

Configurar um projeto do Google Cloud

Configure a Google Cloud CLI

Configurar o SDK para sua linguagem de programação

Python

Node.js

Java

Maven com BoM

Maven sem BOM

Gradle sem BoM

Go

Implantar o Gemma usando o Model Garden

Fazer inferência do Gemma 2 2B com o PredictionServiceClient

Parâmetros de código

Console

gcloud

Código de amostra

Python

Node.js

Java

Go

Limpar

Excluir o projeto

Excluir recursos individuais

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

Console

gcloud

Excluir o modelo

Console

gcloud

A seguir

Implante e faça inferências com a Gemma usando o Model Garden e os endpoints da plataforma de agentes do Gemini Enterprise com suporte de TPU