Enviar solicitações de prompt multimodais

A família de modelos do Gemini inclui modelos que funcionam com solicitações de comando multimodais. O termo multimodal indica que é possível usar mais de uma modalidade, ou tipo de entrada, em um comando. Os modelos que não são multimodais aceitam solicitações apenas com texto. As modalidades podem incluir texto, áudio, vídeo e muito mais.

Há várias maneiras de implementar soluções multimodais usando a API Gemini, incluindo os SDKs para Python, Node.js, Java e Go, o console do Google Cloud e a API REST. Os exemplos de código mais adiante neste documento demonstram como criar soluções multimodais usando essas opções.

Os modelos multimodais do Gemini são:

  • Gemini 1.5 Flash
  • Gemini 1.5 Pro
  • Gemini 1.0 Pro Vision

A tabela a seguir indica com quais modalidades cada API multimodal do Gemini trabalha em uma solicitação de solicitação.

Modelo Texto Código Imagens Áudio Vídeo Vídeo/áudio PDF
Gemini 1.5 Flash
Gemini 1.5 Pro
Gemini 1.0 Pro Vision
Gemini 1.0 Pro

Para usar um modelo multimodal no console do Google Cloud, selecione o card de modelo no Model Garden:


Para uma lista de idiomas compatíveis com os modelos do Gemini, consulte as informações do modelo Suporte a idiomas. Para saber mais sobre como criar comandos multimodais, consulte Criar comandos multimodais. Se você está procurando uma maneira de usar o Gemini diretamente dos seus apps para dispositivos móveis e da Web, consulte os SDKs da IA do Google para Android, Swift e Web.

Diferenças de modelos multimodais

As diferenças entre os modelos multimodais do Gemini são especificadas nas tabelas a seguir. Use essas informações para decidir qual é o melhor modelo para você.

Texto

Veja a seguir algumas das diferenças na modalidade de texto entre os modelos multimodais do Genmini:

Modelo Detalhes da modalidade de texto
Gemini 1.5 Flash,
Gemini 1.5 Pro
O tamanho do contexto é de 1 milhão de tokens,o que equivale a aproximadamente um livro de 4.000 páginas. Isso permite que o modelo gere textos longos, como livros, vários PDFs ou manuais do usuário.
Gemini 1.0 Pro Vision O número máximo de tokens é 16.384,ou seja, aproximadamente um livro de 128 páginas supondo 250 palavras por página. Esse máximo inclui tokens de entrada e saída. O número máximo de tokens de saída é 2.048.

Programar

Veja a seguir algumas das diferenças entre os modelos multimodais do Gemini ao trabalhar com código:

Modelo Detalhes da modalidade de código
Gemini 1.5 Flash,
Gemini 1.5 Pro
O tamanho do contexto é de 1 milhão de tokens, o que permite que o modelo funcione com uma base de código inteira ou com uma base de código inteira do aplicativo.
Gemini 1.0 Pro Vision O número máximo de tokens é 16.384,ou seja, aproximadamente um livro de 128 páginas supondo 250 palavras por página. Esse máximo inclui tokens de entrada e saída. O número máximo de tokens de saída é 2.048.

Imagem

Veja a seguir algumas das diferenças na modalidade de imagem entre os modelos multimodais do Genmini:

Modelo Detalhes da modalidade de imagem
Gemini 1.5 Flash,
Gemini 1.5 Pro
O número máximo de imagens por comando é de 3.000.
Gemini 1.0 Pro Vision O número máximo de imagens por comando é 16.

Áudio (somente fala)

Veja a seguir algumas das diferenças na modalidade de áudio entre os modelos multimodais do Genmini:

Modelo Detalhes da modalidade de áudio
Gemini 1.5 Flash,
Gemini 1.5 Pro
O número máximo de horas de áudio por solicitação é de aproximadamente 8,4 horas, ou até 1 milhão de tokens. É possível compreender a fala para resumo, transcrição e tradução de áudio.
Gemini 1.0 Pro Vision O áudio não é compatível.

Video

Veja a seguir algumas das diferenças na modalidade de vídeo entre os modelos multimodais do Genmini:

Modelo Detalhes da modalidade de vídeo
Gemini 1.5 Flash,
Gemini 1.5 Pro
A duração máxima de um vídeo que inclui áudio é de aproximadamente 50 minutos. A duração máxima para vídeos sem áudio é de uma hora. O máximo de vídeos por solicitação é de 10. O modelo pode usar dados de vídeo e áudio para responder à solicitação. Por exemplo, ela pode resumir um vídeo usando o conteúdo visual e a fala do vídeo.
Gemini 1.0 Pro Vision A duração máxima do vídeo é de dois minutos. O número máximo de vídeos por solicitação é 1. O áudio do vídeo é ignorado.

PDF

Veja a seguir algumas das diferenças na modalidade PDF entre os modelos multimodais do Genmini:

Modelo Detalhes da modalidade em PDF
Gemini 1.5 Flash,
Gemini 1.5 Pro
O número máximo de páginas por solicitação é 300. O tamanho máximo do arquivo PDF é de 30 MB.
Gemini 1.0 Pro Vision O número máximo de páginas por solicitação é 16. O tamanho máximo do arquivo PDF é de 30 MB.

Guia de início rápido

Use os exemplos de código a seguir para começar a usar a API Gemini. Cada exemplo de código demonstra o trabalho com uma modalidade diferente. Alguns exemplos de código neste documento funcionam com todos os modelos multimodais do Gemini, e outros funcionam apenas com o Gemini 1.5 Pro. Cada exemplo de código especifica com quais modelos ela funciona.

Para testar e iterar em comandos multimodais, recomendamos usar o console do Google Cloud. Para enviar um prompt multimodal com imagens de maneira programática para o modelo, use a API REST, o SDK da Vertex AI para Python ou uma das outras bibliotecas e SDKs compatíveis mostrados nas guias a seguir:

Imagem única

O exemplo de código em cada uma das guias a seguir mostra uma maneira diferente de identificar o que está em uma imagem. Esta amostra funciona com todos os modelos multimodais do Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a solicitações à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o parâmetro stream em generate_content.

  response = model.generate_content(contents=[...], stream = True)
  

Para uma resposta que não seja de streaming, remova o parâmetro ou defina-o como False.

Código de amostra

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

image_file = Part.from_uri(
    "gs://cloud-samples-data/generative-ai/image/scones.jpg", "image/jpeg"
)

# Query the model
response = model.generate_content([image_file, "what is this image?"])
print(response.text)

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no guia de início rápido da Vertex AI. Para mais informações, consulte a documentação de referência do SDK da Vertex AI para Java para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  public ResponseStream generateContentStream(Content content)
  

Para uma resposta que não seja de streaming, use o método generateContent.

  public GenerateContentResponse generateContent(Content content)
  

Código de amostra

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.util.Base64;

public class MultimodalQuery {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.0-pro-vision-001";
    String dataImageBase64 = "your-base64-encoded-image";

    String output = multimodalQuery(projectId, location, modelName, dataImageBase64);
    System.out.println(output);
  }


  // Ask the model to recognise the brand associated with the logo image.
  public static String multimodalQuery(String projectId, String location, String modelName,
      String dataImageBase64) throws Exception {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      String output;
      byte[] imageBytes = Base64.getDecoder().decode(dataImageBase64);

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "What is this image?",
              PartMaker.fromMimeTypeAndData("image/png", imageBytes)
          ));

      output = ResponseHandler.getText(response);
      return output;
    }
  }
}

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 IA generativa usando o SDK do Node.js. Para mais informações, consulte a documentação de referência do SDK do Node.js para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);
  

Para uma resposta que não seja de streaming, use o método generateContent.

  const streamingResp = await generativeModel.generateContent(request);
  

Código de amostra

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function createNonStreamingMultipartContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision-001',
  image = 'gs://generativeai-downloads/images/scones.jpg',
  mimeType = 'image/jpeg'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  // Instantiate the model
  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // For images, the SDK supports both Google Cloud Storage URI and base64 strings
  const filePart = {
    fileData: {
      fileUri: image,
      mimeType: mimeType,
    },
  };

  const textPart = {
    text: 'what is shown in this image?',
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  console.log('Prompt Text:');
  console.log(request.contents[0].parts[1].text);

  console.log('Non-Streaming Response Text:');
  // Create the response stream
  const responseStream =
    await generativeVisionModel.generateContentStream(request);

  // Wait for the response stream to complete
  const aggregatedResponse = await responseStream.response;

  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

REST

Use REST para testar um prompt de texto usando a API Vertex AI para enviar uma solicitação POST ao endpoint do modelo do editor.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • GENERATE_RESPONSE_METHOD: o tipo de resposta que você quer que o modelo gere. Escolha um método que gere como você quer que a resposta do modelo seja retornada:
    • streamGenerateContent: a resposta é transmitida conforme é gerada para reduzir a percepção de latência para o público humano.
    • generateContent: a resposta será retornada depois de ser totalmente gerada.
  • LOCATION: a região para processar a solicitação. As opções disponíveis incluem:

    Clique para expandir as regiões disponíveis

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: o ID do projeto.
  • MODEL_ID: o ID do modelo multimodal que você quer usar. As opções são:
    • gemini-1.0-pro-vision
  • ROLE: o papel em uma conversa associada ao conteúdo. É necessário especificar um papel mesmo em casos de uso de turno único. Os valores aceitáveis são os seguintes:
    • USER: especifica o conteúdo que é enviado por você.
  • TEXT: as instruções de texto a serem incluídas no comando.
  • B64_BASE: a codificação Base64 da imagem, do PDF ou do vídeo a ser incluído in-line no comando. Ao incluir mídia in-line, você também precisa especificar MIMETYPE.
  • FILE_URI: o URI do Cloud Storage da imagem ou do vídeo a ser incluído no comando. O bucket que armazena o arquivo precisa estar no mesmo projeto do Google Cloud que está enviando a solicitação. Também é necessário especificar MIMETYPE.
  • MIME_TYPE: o tipo de mídia da imagem, PDF ou vídeo especificado nos campos data ou fileUri. Os valores aceitáveis são os seguintes:

    Clique para expandir os tipos MIME.

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
  • SAFETY_CATEGORY: a categoria de segurança para a qual configurar um limite. Os valores aceitáveis são os seguintes:

    Clique para expandir as categorias de segurança

    • HARM_CATEGORY_SEXUALLY_EXPLICIT
    • HARM_CATEGORY_HATE_SPEECH
    • HARM_CATEGORY_HARASSMENT
    • HARM_CATEGORY_DANGEROUS_CONTENT
  • THRESHOLD: o limite de bloqueio de respostas que podem pertencer à categoria de segurança especificada com base na probabilidade. Os valores aceitáveis são os seguintes:

    Clique para expandir os limites de bloqueio

    • BLOCK_NONE
    • BLOCK_ONLY_HIGH
    • BLOCK_MEDIUM_AND_ABOVE (padrão)
    • BLOCK_LOW_AND_ABOVE
    BLOCK_LOW_AND_ABOVE bloqueia mais, e BLOCK_ONLY_HIGH bloqueia a menor.
  • TEMPERATURE: a temperatura é usada para amostragem durante a geração da resposta, que ocorre quando topP e topK são aplicados. A temperatura controla o grau de aleatoriedade na seleção do token. Temperaturas mais baixas são boas para solicitações que exigem uma resposta menos aberta ou criativa, enquanto temperaturas mais altas podem levar a resultados mais diversos ou criativos. Uma temperatura de 0 significa que os tokens de maior probabilidade são sempre selecionados. Nesse caso, as respostas para uma determinada solicitação são, na maioria das vezes, deterministas, mas uma pequena variação ainda é possível.

    Se o modelo retornar uma resposta muito genérica, muito curta ou se o modelo fornecer uma resposta alternativa, tente aumentar a temperatura.

  • TOP_P: o Top-P muda a forma como o modelo seleciona tokens para saída. Os tokens são selecionados do mais provável (veja o top-K) para o menos provável até que a soma das probabilidades seja igual ao valor do top-P. Por exemplo, se os tokens A, B e C tiverem uma probabilidade de 0,3, 0,2 e 0,1 e o valor de top-P for 0.5, o modelo selecionará A ou B como token seguinte usando temperatura e exclui C como candidato.

    Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

  • TOP_K: o Top-K muda a forma como o modelo seleciona tokens para saída. Um top-K de 1 significa que o próximo token selecionado é o mais provável entre todos os tokens no vocabulário do modelo (também chamado de decodificação gananciosa), enquanto um top-K de 3 significa que o próximo token está selecionado entre os três tokens mais prováveis usando a temperatura.

    Para cada etapa da seleção de tokens, são amostrados os tokens top-K com as maiores probabilidades. Em seguida, os tokens são filtrados com base no valor de top-P com o token final selecionado por meio da amostragem de temperatura.

    Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

  • MAX_OUTPUT_TOKENS: número máximo de tokens que podem ser gerados na resposta. Um token tem cerca de quatro caracteres. 100 tokens correspondem a cerca de 60 a 80 palavras.

    Especifique um valor mais baixo para respostas mais curtas e um valor mais alto para respostas potencialmente mais longas.

  • STOP_SEQUENCES: especifica uma lista de strings que instrui o modelo a parar de gerar texto se uma das strings for encontrada na resposta. Se uma string aparecer várias vezes na resposta, a resposta truncará quando for encontrada pela primeira vez. As strings diferenciam maiúsculas de minúsculas.

    Por exemplo, se a resposta a seguir for retornada quando stopSequences não for especificado:

    public static string reverse(string myString)

    A resposta retornada com stopSequences definida como ["Str", "reverse"] é:

    public static string

Método HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD

Corpo JSON da solicitação:

{
  "contents": {
    "role": "ROLE",
    "parts": [
      {
        "inlineDATA": {
          "mimeType": "MIME_TYPE",
          "data": "B64_BASE_IMAGE"
        }
      },
      {
        "fileData": {
          "mimeType": "MIME_TYPE",
          "fileUri": "FILE_URI"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "stopSequences": STOP_SEQUENCES,
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD"

PowerShell

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a seguinte.

Exemplo de comando curl

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro-vision"
PROJECT_ID="test-project"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json"
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:${GENERATE_RESPONSE_METHOD} -d \
$'{
  "contents": {
    "role": "user",
    "parts": [
      {
        "fileData": {
          "mimeType": "image/png",
          "fileUri": "gs://my-bucket/images/cat.png"
        }
      },
      {
        "text": "Describe this picture."
      },
    ]
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.4,
    "topP": 1,
    "topK": 32,
    "maxOutputTokens": 2048,
  }
}'

PDF único

A guia a seguir mostra como incluir um PDF em uma solicitação de comando usando o SDK do Python. Esta amostra em PDF funciona com todos os modelos multimodais do Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a solicitações à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o parâmetro stream em generate_content.

  response = model.generate_content(contents=[...], stream = True)
  

Para uma resposta que não seja de streaming, remova o parâmetro ou defina-o como False.

Código de amostra

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

prompt = """
You are a very professional document summarization specialist.
Please summarize the given document.
"""

pdf_file_uri = "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf"
pdf_file = Part.from_uri(pdf_file_uri, mime_type="application/pdf")
contents = [pdf_file, prompt]

response = model.generate_content(contents)
print(response.text)

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no guia de início rápido da Vertex AI. Para mais informações, consulte a documentação de referência do SDK da Vertex AI para Java para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  public ResponseStream generateContentStream(Content content)
  

Para uma resposta que não seja de streaming, use o método generateContent.

  public GenerateContentResponse generateContent(Content content)
  

Código de amostra


import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class PdfInput {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";

    pdfInput(projectId, location, modelName);
  }

  // Analyzes the given video input.
  public static String pdfInput(String projectId, String location, String modelName)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      String pdfUri = "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "You are a very professional document summarization specialist.\n"
                  + "Please summarize the given document.",
              PartMaker.fromMimeTypeAndData("application/pdf", pdfUri)
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);
      return output;
    }
  }
}

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 IA generativa usando o SDK do Node.js. Para mais informações, consulte a documentação de referência do SDK do Node.js para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);
  

Para uma resposta que não seja de streaming, use o método generateContent.

  const streamingResp = await generativeModel.generateContent(request);
  

Código de amostra

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function analyze_pdf(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-pro-preview-0409',
  });

  const filePart = {
    file_data: {
      file_uri: 'gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf',
      mime_type: 'application/pdf',
    },
  };
  const textPart = {
    text: `
    You are a very professional document summarization specialist.
    Please summarize the given document.`,
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

C#

Antes de testar essa amostra, siga as instruções de configuração para C# Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para C#.

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.


using Google.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class PdfInput
{
    public async Task<string> SummarizePdf(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        string prompt = @"You are a very professional document summarization specialist.
Please summarize the given document.";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "application/pdf", FileUri = "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf" }}
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

Vídeo único

Cada uma das guias a seguir mostra uma maneira diferente de incluir um vídeo em uma solicitação de comando. Esses exemplos de PDF funcionam com todos os modelos multimodais do Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a solicitações à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o parâmetro stream em generate_content.

  response = model.generate_content(contents=[...], stream = True)
  

Para uma resposta que não seja de streaming, remova o parâmetro ou defina-o como False.

Código de amostra

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

vision_model = GenerativeModel(model_name="gemini-1.5-flash-001")

# Generate text
response = vision_model.generate_content(
    [
        Part.from_uri(
            "gs://cloud-samples-data/video/animals.mp4", mime_type="video/mp4"
        ),
        "What is in the video?",
    ]
)
print(response.text)

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no guia de início rápido da Vertex AI. Para mais informações, consulte a documentação de referência do SDK da Vertex AI para Java para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  public ResponseStream generateContentStream(Content content)
  

Para uma resposta que não seja de streaming, use o método generateContent.

  public GenerateContentResponse generateContent(Content content)
  

Código de amostra

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class MultimodalVideoInput {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.0-pro-vision-001";

    multimodalVideoInput(projectId, location, modelName);
  }

  // Analyzes the given video input.
  public static void multimodalVideoInput(String projectId, String location, String modelName)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      String videoUri = "gs://cloud-samples-data/video/animals.mp4";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "What is in the video?",
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri)
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);
    }
  }
}

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 IA generativa usando o SDK do Node.js. Para mais informações, consulte a documentação de referência do SDK do Node.js para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);
  

Para uma resposta que não seja de streaming, use o método generateContent.

  const streamingResp = await generativeModel.generateContent(request);
  

Código de amostra

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function sendMultiModalPromptWithVideo(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision-001'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // Pass multimodal prompt
  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            fileData: {
              fileUri: 'gs://cloud-samples-data/video/animals.mp4',
              mimeType: 'video/mp4',
            },
          },
          {
            text: 'What is in the video?',
          },
        ],
      },
    ],
  };

  // Create the response
  const response = await generativeVisionModel.generateContent(request);
  // Wait for the response to complete
  const aggregatedResponse = await response.response;
  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido da Vertex AI. Para mais informações, consulte a documentação de referência do SDK da Vertex AI para Go para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método GenerateContentStream.

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))
  

Para uma resposta que não seja de streaming, use o método GenerateContent.

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))
  

Código de amostra

import (
	"context"
	"errors"
	"fmt"
	"io"
	"mime"
	"path/filepath"

	"cloud.google.com/go/vertexai/genai"
)

// generateMultimodalContent generates a response into w, based upon the prompt
// and video provided.
// video is a Google Cloud Storage path starting with "gs://"
func generateMultimodalContent(w io.Writer, prompt, video, projectID, location, modelName string) error {
	// prompt := "What is in this video?"
	// video := "gs://cloud-samples-data/video/animals.mp4"
	// location := "us-central1"
	// modelName := "gemini-1.0-pro-vision-001"
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("unable to create client: %v", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)
	model.SetTemperature(0.4)

	// Given a video file URL, prepare video file as genai.Part
	part := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext(video)),
		FileURI:  video,
	}

	res, err := model.GenerateContent(ctx, part, genai.Text(prompt))
	if err != nil {
		return fmt.Errorf("unable to generate contents: %v", err)
	}

	if len(res.Candidates) == 0 ||
		len(res.Candidates[0].Content.Parts) == 0 {
		return errors.New("empty response from model")
	}

	fmt.Fprintf(w, "generated response: %s\n", res.Candidates[0].Content.Parts[0])
	return nil
}

C#

Antes de testar essa amostra, siga as instruções de configuração para C# Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para C#.

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.


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using System.Text;
using System.Threading.Tasks;

public class MultimodalVideoInput
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro-vision"
    )
    {
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = "What's in the video?" },
                        new Part { FileData = new() { MimeType = "video/mp4", FileUri = "gs://cloud-samples-data/video/animals.mp4" }}
                    }
                }
            }
        };

        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }
        return fullText.ToString();
    }
}

REST

Use REST para testar um prompt de texto usando a API Vertex AI para enviar uma solicitação POST ao endpoint do modelo do editor.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • GENERATE_RESPONSE_METHOD: o tipo de resposta que você quer que o modelo gere. Escolha um método que gere como você quer que a resposta do modelo seja retornada:
    • streamGenerateContent: a resposta é transmitida conforme é gerada para reduzir a percepção de latência para o público humano.
    • generateContent: a resposta será retornada depois de ser totalmente gerada.
  • LOCATION: a região para processar a solicitação. As opções disponíveis incluem:

    Clique para expandir as regiões disponíveis

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: o ID do projeto.
  • MODEL_ID: o ID do modelo multimodal que você quer usar. As opções são:
    • gemini-1.0-pro-vision
  • ROLE: o papel em uma conversa associada ao conteúdo. É necessário especificar um papel mesmo em casos de uso de turno único. Os valores aceitáveis são os seguintes:
    • USER: especifica o conteúdo que é enviado por você.
  • TEXT: as instruções de texto a serem incluídas no comando.
  • B64_BASE: a codificação Base64 da imagem, do PDF ou do vídeo a ser incluído in-line no comando. Ao incluir mídia in-line, você também precisa especificar MIMETYPE.
  • FILE_URI: o URI do Cloud Storage da imagem ou do vídeo a ser incluído no comando. O bucket que armazena o arquivo precisa estar no mesmo projeto do Google Cloud que está enviando a solicitação. Também é necessário especificar MIMETYPE.
  • MIME_TYPE: o tipo de mídia da imagem, PDF ou vídeo especificado nos campos data ou fileUri. Os valores aceitáveis são os seguintes:

    Clique para expandir os tipos MIME.

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
  • SAFETY_CATEGORY: a categoria de segurança para a qual configurar um limite. Os valores aceitáveis são os seguintes:

    Clique para expandir as categorias de segurança

    • HARM_CATEGORY_SEXUALLY_EXPLICIT
    • HARM_CATEGORY_HATE_SPEECH
    • HARM_CATEGORY_HARASSMENT
    • HARM_CATEGORY_DANGEROUS_CONTENT
  • THRESHOLD: o limite de bloqueio de respostas que podem pertencer à categoria de segurança especificada com base na probabilidade. Os valores aceitáveis são os seguintes:

    Clique para expandir os limites de bloqueio

    • BLOCK_NONE
    • BLOCK_ONLY_HIGH
    • BLOCK_MEDIUM_AND_ABOVE (padrão)
    • BLOCK_LOW_AND_ABOVE
    BLOCK_LOW_AND_ABOVE bloqueia mais, e BLOCK_ONLY_HIGH bloqueia a menor.
  • TEMPERATURE: a temperatura é usada para amostragem durante a geração da resposta, que ocorre quando topP e topK são aplicados. A temperatura controla o grau de aleatoriedade na seleção do token. Temperaturas mais baixas são boas para solicitações que exigem uma resposta menos aberta ou criativa, enquanto temperaturas mais altas podem levar a resultados mais diversos ou criativos. Uma temperatura de 0 significa que os tokens de maior probabilidade são sempre selecionados. Nesse caso, as respostas para uma determinada solicitação são, na maioria das vezes, deterministas, mas uma pequena variação ainda é possível.

    Se o modelo retornar uma resposta muito genérica, muito curta ou se o modelo fornecer uma resposta alternativa, tente aumentar a temperatura.

  • TOP_P: o Top-P muda a forma como o modelo seleciona tokens para saída. Os tokens são selecionados do mais provável (veja o top-K) para o menos provável até que a soma das probabilidades seja igual ao valor do top-P. Por exemplo, se os tokens A, B e C tiverem uma probabilidade de 0,3, 0,2 e 0,1 e o valor de top-P for 0.5, o modelo selecionará A ou B como token seguinte usando temperatura e exclui C como candidato.

    Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

  • TOP_K: o Top-K muda a forma como o modelo seleciona tokens para saída. Um top-K de 1 significa que o próximo token selecionado é o mais provável entre todos os tokens no vocabulário do modelo (também chamado de decodificação gananciosa), enquanto um top-K de 3 significa que o próximo token está selecionado entre os três tokens mais prováveis usando a temperatura.

    Para cada etapa da seleção de tokens, são amostrados os tokens top-K com as maiores probabilidades. Em seguida, os tokens são filtrados com base no valor de top-P com o token final selecionado por meio da amostragem de temperatura.

    Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

  • MAX_OUTPUT_TOKENS: número máximo de tokens que podem ser gerados na resposta. Um token tem cerca de quatro caracteres. 100 tokens correspondem a cerca de 60 a 80 palavras.

    Especifique um valor mais baixo para respostas mais curtas e um valor mais alto para respostas potencialmente mais longas.

  • STOP_SEQUENCES: especifica uma lista de strings que instrui o modelo a parar de gerar texto se uma das strings for encontrada na resposta. Se uma string aparecer várias vezes na resposta, a resposta truncará quando for encontrada pela primeira vez. As strings diferenciam maiúsculas de minúsculas.

    Por exemplo, se a resposta a seguir for retornada quando stopSequences não for especificado:

    public static string reverse(string myString)

    A resposta retornada com stopSequences definida como ["Str", "reverse"] é:

    public static string

Método HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD

Corpo JSON da solicitação:

{
  "contents": {
    "role": "ROLE",
    "parts": [
      {
        "inlineDATA": {
          "mimeType": "MIME_TYPE",
          "data": "B64_BASE_IMAGE"
        }
      },
      {
        "fileData": {
          "mimeType": "MIME_TYPE",
          "fileUri": "FILE_URI"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "stopSequences": STOP_SEQUENCES,
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD"

PowerShell

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a seguinte.

Exemplo de comando curl

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro-vision"
PROJECT_ID="test-project"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json"
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:${GENERATE_RESPONSE_METHOD} -d \
$'{
  "contents": {
    "role": "user",
    "parts": [
      {
        "fileData": {
          "mimeType": "image/png",
          "fileUri": "gs://my-bucket/images/cat.png"
        }
      },
      {
        "text": "Describe this picture."
      },
    ]
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.4,
    "topP": 1,
    "topK": 32,
    "maxOutputTokens": 2048,
  }
}'

Console

Para enviar um prompt multimodal usando o console do Google Cloud, faça o seguinte:

  1. Na seção "Vertex AI" do console do Google Cloud, acesse a página do Vertex AI Studio.

    Acessar o Vertex AI Studio

  2. Em Design de comandos (turno único), clique em Abrir.
  3. Configure o modelo e os parâmetros:

    • Região: selecione a região que você quer usar.
    • Modelo: selecione Gemini Pro Vision.
    • Temperatura: use o controle deslizante ou a caixa de texto para inserir um valor para a temperatura.

      A temperatura é usada para amostragem durante a geração da resposta, que ocorre quando topP e topK são aplicados. A temperatura controla o grau de aleatoriedade na seleção do token. Temperaturas mais baixas são boas para solicitações que exigem uma resposta menos aberta ou criativa, enquanto temperaturas mais altas podem levar a resultados mais diversos ou criativos. Uma temperatura de 0 significa que os tokens de maior probabilidade são sempre selecionados. Nesse caso, as respostas para uma determinada solicitação são, na maioria das vezes, deterministas, mas uma pequena variação ainda é possível.

      Se o modelo retornar uma resposta muito genérica, muito curta ou se o modelo fornecer uma resposta alternativa, tente aumentar a temperatura.

    • Limite de token: use o controle deslizante ou a caixa de texto para inserir um valor para o limite de saída máximo.

      Número máximo de tokens que podem ser gerados na resposta. Um token tem cerca de quatro caracteres. 100 tokens correspondem a cerca de 60 a 80 palavras.

      Especifique um valor mais baixo para respostas mais curtas e um valor mais alto para respostas potencialmente mais longas.

    • Adicionar sequência de parada: insira uma sequência de parada, que é uma série de caracteres (incluindo espaços) que interrompe a geração de resposta se ela for encontrada pelo modelo. A sequência não é incluída como parte da resposta. Você pode adicionar até cinco sequências de paradas.
  4. Opcional: para configurar parâmetros avançados, clique em Avançado e faça as configurações da seguinte maneira:
  5. Clique para abrir as configurações avançadas

    • Top-K: use o controle deslizante ou a caixa de texto para inserir um valor para "top-K".

      O top-k muda a forma como o modelo seleciona tokens para saída. Um top-K de 1 significa que o próximo token selecionado é o mais provável entre todos os tokens no vocabulário do modelo (também chamado de decodificação gananciosa), enquanto um top-K de 3 significa que o próximo token está selecionado entre os três tokens mais prováveis usando a temperatura.

      Para cada etapa da seleção de tokens, são amostrados os tokens top-K com as maiores probabilidades. Em seguida, os tokens são filtrados com base no valor de top-P com o token final selecionado por meio da amostragem de temperatura.

      Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

    • Top-P: use o controle deslizante ou a caixa de texto para inserir um valor para essa parte. Os tokens são selecionados do mais provável para o menos até que a soma das probabilidades seja igual ao valor do top-P. Para ter menos resultados de variáveis, defina top-P como 0.
  6. O console do Google Cloud só oferece suporte a streaming, que envolve o recebimento de respostas aos comandos à medida que são gerados. Você já pode inserir uma mensagem na caixa para iniciar uma conversa com o modelo.

    O modelo usa as mensagens anteriores como contexto para novas respostas. Para incluir uma imagem, PDF ou vídeo no comando, clique no ícone .

    Para saber mais sobre comandos multimodais, consulte Criar comandos multimodais.

  7. Opcional: para salvar a solicitação em Minhas solicitações, clique em Salvar.
  8. Opcional: para receber o código Python ou um comando curl para seu prompt, clique em Ver código.
  9. Opcional: para limpar todas as mensagens anteriores, clique em Limpar conversa

Áudio único

Confira a seguir como usar um arquivo de áudio para resumir um podcast. Esta amostra funciona apenas com o Gemini 1.5 Pro.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a solicitações à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o parâmetro stream em generate_content.

  response = model.generate_content(contents=[...], stream = True)
  

Para uma resposta que não seja de streaming, remova o parâmetro ou defina-o como False.

Código de amostra


  import vertexai
  from vertexai.generative_models import GenerativeModel, Part

  # TODO(developer): Update and un-comment below lines
  # project_id = "PROJECT_ID"

  vertexai.init(project=project_id, location="us-central1")

  model = GenerativeModel(model_name="gemini-1.5-flash-001")

  prompt = """
  Please provide a summary for the audio.
  Provide chapter titles, be concise and short, no need to provide chapter summaries.
  Do not make up any information that is not part of the audio and do not be verbose.
"""

  audio_file_uri = "gs://cloud-samples-data/generative-ai/audio/pixel.mp3"
  audio_file = Part.from_uri(audio_file_uri, mime_type="audio/mpeg")

  contents = [audio_file, prompt]

  response = model.generate_content(contents)
  print(response.text)

Exemplos avançados

Os exemplos a seguir são mais complexos do que os anteriores.

Várias imagens

Cada uma das guias a seguir mostra uma maneira diferente de incluir várias imagens em uma solicitação de solicitação. Essas amostras de imagem funcionam com todos os modelos multimodais do Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a solicitações à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o parâmetro stream em generate_content.

  response = model.generate_content(contents=[...], stream = True)
  

Para uma resposta que não seja de streaming, remova o parâmetro ou defina-o como False.

Código de amostra

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

# Load images from Cloud Storage URI
image_file1 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png",
    mime_type="image/png",
)
image_file2 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark2.png",
    mime_type="image/png",
)
image_file3 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark3.png",
    mime_type="image/png",
)

model = GenerativeModel(model_name="gemini-1.5-flash-001")
response = model.generate_content(
    [
        image_file1,
        "city: Rome, Landmark: the Colosseum",
        image_file2,
        "city: Beijing, Landmark: Forbidden City",
        image_file3,
    ]
)
print(response.text)

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no guia de início rápido da Vertex AI. Para mais informações, consulte a documentação de referência do SDK da Vertex AI para Java para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  public ResponseStream generateContentStream(Content content)
  

Para uma resposta que não seja de streaming, use o método generateContent.

  public GenerateContentResponse generateContent(Content content)
  

Código de amostra

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.Content;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class MultimodalMultiImage {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.0-pro-vision-001";

    multimodalMultiImage(projectId, location, modelName);
  }

  // Generates content from multiple input images.
  public static void multimodalMultiImage(String projectId, String location, String modelName)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);

      Content content = ContentMaker.fromMultiModalData(
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png")),
          "city: Rome, Landmark: the Colosseum",
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png")),
          "city: Beijing, Landmark: Forbidden City",
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png"))
      );

      GenerateContentResponse response = model.generateContent(content);

      String output = ResponseHandler.getText(response);
      System.out.println(output);
    }
  }

  // Reads the image data from the given URL.
  public static byte[] readImageFile(String url) throws IOException {
    URL urlObj = new URL(url);
    HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
    connection.setRequestMethod("GET");

    int responseCode = connection.getResponseCode();

    if (responseCode == HttpURLConnection.HTTP_OK) {
      InputStream inputStream = connection.getInputStream();
      ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

      byte[] buffer = new byte[1024];
      int bytesRead;
      while ((bytesRead = inputStream.read(buffer)) != -1) {
        outputStream.write(buffer, 0, bytesRead);
      }

      return outputStream.toByteArray();
    } else {
      throw new RuntimeException("Error fetching file: " + responseCode);
    }
  }
}

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 IA generativa usando o SDK do Node.js. Para mais informações, consulte a documentação de referência do SDK do Node.js para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);
  

Para uma resposta que não seja de streaming, use o método generateContent.

  const streamingResp = await generativeModel.generateContent(request);
  

Código de amostra

const {VertexAI} = require('@google-cloud/vertexai');
const axios = require('axios');

async function getBase64(url) {
  const image = await axios.get(url, {responseType: 'arraybuffer'});
  return Buffer.from(image.data).toString('base64');
}

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function sendMultiModalPromptWithImage(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision-001'
) {
  // For images, the SDK supports base64 strings
  const landmarkImage1 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png'
  );
  const landmarkImage2 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png'
  );
  const landmarkImage3 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png'
  );

  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // Pass multimodal prompt
  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            inlineData: {
              data: landmarkImage1,
              mimeType: 'image/png',
            },
          },
          {
            text: 'city: Rome, Landmark: the Colosseum',
          },

          {
            inlineData: {
              data: landmarkImage2,
              mimeType: 'image/png',
            },
          },
          {
            text: 'city: Beijing, Landmark: Forbidden City',
          },
          {
            inlineData: {
              data: landmarkImage3,
              mimeType: 'image/png',
            },
          },
        ],
      },
    ],
  };

  // Create the response
  const response = await generativeVisionModel.generateContent(request);
  // Wait for the response to complete
  const aggregatedResponse = await response.response;
  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido da Vertex AI. Para mais informações, consulte a documentação de referência do SDK da Vertex AI para Go para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método GenerateContentStream.

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))
  

Para uma resposta que não seja de streaming, use o método GenerateContent.

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))
  

Código de amostra

import (
	"context"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"

	"cloud.google.com/go/vertexai/genai"
)

func main() {
	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	location := "us-central1"
	modelName := "gemini-1.0-pro-vision"
	temperature := 0.4

	if projectID == "" {
		log.Fatal("require environment variable GOOGLE_CLOUD_PROJECT")
	}

	// construct this multimodal prompt:
	// [image of colosseum] city: Rome, Landmark: the Colosseum
	// [image of forbidden city]  city: Beijing, Landmark: the Forbidden City
	// [new image]

	// create prompt image parts
	// colosseum
	colosseum, err := partFromImageURL("https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png")
	if err != nil {
		log.Fatalf("unable to read image: %v", err)
	}
	// forbidden city
	forbiddenCity, err := partFromImageURL("https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png")
	if err != nil {
		log.Fatalf("unable to read image: %v", err)
	}
	// new image
	newImage, err := partFromImageURL("https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png")
	if err != nil {
		log.Fatalf("unable to read image: %v", err)
	}

	// create a multimodal (multipart) prompt
	prompt := []genai.Part{
		colosseum,
		genai.Text("city: Rome, Landmark: the Colosseum "),
		forbiddenCity,
		genai.Text("city: Beijing, Landmark: the Forbidden City "),
		newImage,
	}

	// generate the response
	err = generateMultimodalContent(os.Stdout, prompt, projectID, location, modelName, float32(temperature))
	if err != nil {
		log.Fatalf("unable to generate: %v", err)
	}
}

// generateMultimodalContent provide a generated response using multimodal input
func generateMultimodalContent(w io.Writer, parts []genai.Part, projectID, location, modelName string, temperature float32) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)
	model.SetTemperature(temperature)

	res, err := model.GenerateContent(ctx, parts...)
	if err != nil {
		return fmt.Errorf("unable to generate contents: %v", err)
	}

	fmt.Fprintf(w, "generated response: %s\n", res.Candidates[0].Content.Parts[0])

	return nil
}

// partFromImageURL create a multimodal prompt part from an image URL
func partFromImageURL(image string) (genai.Part, error) {
	var img genai.Blob

	imageURL, err := url.Parse(image)
	if err != nil {
		return img, err
	}
	res, err := http.Get(image)
	if err != nil || res.StatusCode != 200 {
		return img, err
	}
	defer res.Body.Close()
	data, err := io.ReadAll(res.Body)
	if err != nil {
		return img, fmt.Errorf("unable to read from http: %v", err)
	}

	position := strings.LastIndex(imageURL.Path, ".")
	if position == -1 {
		return img, fmt.Errorf("couldn't find a period to indicate a file extension")
	}
	ext := imageURL.Path[position+1:]

	img = genai.ImageData(ext, data)
	return img, nil
}

C#

Antes de testar essa amostra, siga as instruções de configuração para C# Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para C#.

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.


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using Google.Protobuf;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

public class MultimodalMultiImage
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro-vision"
    )
    {
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        ByteString colosseum = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png");

        ByteString forbiddenCity = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png");

        ByteString christRedeemer = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png");

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { InlineData = new() { MimeType = "image/png", Data = colosseum }},
                        new Part { Text = "city: Rome, Landmark: the Colosseum" },
                        new Part { InlineData = new() { MimeType = "image/png", Data = forbiddenCity }},
                        new Part { Text = "city: Beijing, Landmark: Forbidden City"},
                        new Part { InlineData = new() { MimeType = "image/png", Data = christRedeemer }}
                    }
                }
            }
        };

        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }
        return fullText.ToString();
    }

    private static async Task<ByteString> ReadImageFileAsync(string url)
    {
        using HttpClient client = new();
        using var response = await client.GetAsync(url);
        byte[] imageBytes = await response.Content.ReadAsByteArrayAsync();
        return ByteString.CopyFrom(imageBytes);
    }
}

REST

Use REST para testar um prompt de texto usando a API Vertex AI para enviar uma solicitação POST ao endpoint do modelo do editor.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • GENERATE_RESPONSE_METHOD: o tipo de resposta que você quer que o modelo gere. Escolha um método que gere como você quer que a resposta do modelo seja retornada:
    • streamGenerateContent: a resposta é transmitida conforme é gerada para reduzir a percepção de latência para o público humano.
    • generateContent: a resposta será retornada depois de ser totalmente gerada.
  • LOCATION: a região para processar a solicitação. As opções disponíveis incluem:

    Clique para expandir as regiões disponíveis

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: o ID do projeto.
  • MODEL_ID: o ID do modelo multimodal que você quer usar. As opções são:
    • gemini-1.0-pro-vision
  • ROLE: o papel em uma conversa associada ao conteúdo. É necessário especificar um papel mesmo em casos de uso de turno único. Os valores aceitáveis são os seguintes:
    • USER: especifica o conteúdo que é enviado por você.
  • TEXT: as instruções de texto a serem incluídas no comando.
  • B64_BASE: a codificação Base64 da imagem, do PDF ou do vídeo a ser incluído in-line no comando. Ao incluir mídia in-line, você também precisa especificar MIMETYPE.
  • FILE_URI: o URI do Cloud Storage da imagem ou do vídeo a ser incluído no comando. O bucket que armazena o arquivo precisa estar no mesmo projeto do Google Cloud que está enviando a solicitação. Também é necessário especificar MIMETYPE.
  • MIME_TYPE: o tipo de mídia da imagem, PDF ou vídeo especificado nos campos data ou fileUri. Os valores aceitáveis são os seguintes:

    Clique para expandir os tipos MIME.

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
  • SAFETY_CATEGORY: a categoria de segurança para a qual configurar um limite. Os valores aceitáveis são os seguintes:

    Clique para expandir as categorias de segurança

    • HARM_CATEGORY_SEXUALLY_EXPLICIT
    • HARM_CATEGORY_HATE_SPEECH
    • HARM_CATEGORY_HARASSMENT
    • HARM_CATEGORY_DANGEROUS_CONTENT
  • THRESHOLD: o limite de bloqueio de respostas que podem pertencer à categoria de segurança especificada com base na probabilidade. Os valores aceitáveis são os seguintes:

    Clique para expandir os limites de bloqueio

    • BLOCK_NONE
    • BLOCK_ONLY_HIGH
    • BLOCK_MEDIUM_AND_ABOVE (padrão)
    • BLOCK_LOW_AND_ABOVE
    BLOCK_LOW_AND_ABOVE bloqueia mais, e BLOCK_ONLY_HIGH bloqueia a menor.
  • TEMPERATURE: a temperatura é usada para amostragem durante a geração da resposta, que ocorre quando topP e topK são aplicados. A temperatura controla o grau de aleatoriedade na seleção do token. Temperaturas mais baixas são boas para solicitações que exigem uma resposta menos aberta ou criativa, enquanto temperaturas mais altas podem levar a resultados mais diversos ou criativos. Uma temperatura de 0 significa que os tokens de maior probabilidade são sempre selecionados. Nesse caso, as respostas para uma determinada solicitação são, na maioria das vezes, deterministas, mas uma pequena variação ainda é possível.

    Se o modelo retornar uma resposta muito genérica, muito curta ou se o modelo fornecer uma resposta alternativa, tente aumentar a temperatura.

  • TOP_P: o Top-P muda a forma como o modelo seleciona tokens para saída. Os tokens são selecionados do mais provável (veja o top-K) para o menos provável até que a soma das probabilidades seja igual ao valor do top-P. Por exemplo, se os tokens A, B e C tiverem uma probabilidade de 0,3, 0,2 e 0,1 e o valor de top-P for 0.5, o modelo selecionará A ou B como token seguinte usando temperatura e exclui C como candidato.

    Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

  • TOP_K: o Top-K muda a forma como o modelo seleciona tokens para saída. Um top-K de 1 significa que o próximo token selecionado é o mais provável entre todos os tokens no vocabulário do modelo (também chamado de decodificação gananciosa), enquanto um top-K de 3 significa que o próximo token está selecionado entre os três tokens mais prováveis usando a temperatura.

    Para cada etapa da seleção de tokens, são amostrados os tokens top-K com as maiores probabilidades. Em seguida, os tokens são filtrados com base no valor de top-P com o token final selecionado por meio da amostragem de temperatura.

    Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

  • MAX_OUTPUT_TOKENS: número máximo de tokens que podem ser gerados na resposta. Um token tem cerca de quatro caracteres. 100 tokens correspondem a cerca de 60 a 80 palavras.

    Especifique um valor mais baixo para respostas mais curtas e um valor mais alto para respostas potencialmente mais longas.

  • STOP_SEQUENCES: especifica uma lista de strings que instrui o modelo a parar de gerar texto se uma das strings for encontrada na resposta. Se uma string aparecer várias vezes na resposta, a resposta truncará quando for encontrada pela primeira vez. As strings diferenciam maiúsculas de minúsculas.

    Por exemplo, se a resposta a seguir for retornada quando stopSequences não for especificado:

    public static string reverse(string myString)

    A resposta retornada com stopSequences definida como ["Str", "reverse"] é:

    public static string

Método HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD

Corpo JSON da solicitação:

{
  "contents": {
    "role": "ROLE",
    "parts": [
      {
        "inlineDATA": {
          "mimeType": "MIME_TYPE",
          "data": "B64_BASE_IMAGE"
        }
      },
      {
        "fileData": {
          "mimeType": "MIME_TYPE",
          "fileUri": "FILE_URI"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "stopSequences": STOP_SEQUENCES,
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD"

PowerShell

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a seguinte.

Exemplo de comando curl

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro-vision"
PROJECT_ID="test-project"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json"
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:${GENERATE_RESPONSE_METHOD} -d \
$'{
  "contents": {
    "role": "user",
    "parts": [
      {
        "fileData": {
          "mimeType": "image/png",
          "fileUri": "gs://my-bucket/images/cat.png"
        }
      },
      {
        "text": "Describe this picture."
      },
    ]
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.4,
    "topP": 1,
    "topK": 32,
    "maxOutputTokens": 2048,
  }
}'

Console

Para enviar um prompt multimodal usando o console do Google Cloud, faça o seguinte:

  1. Na seção "Vertex AI" do console do Google Cloud, acesse a página do Vertex AI Studio.

    Acessar o Vertex AI Studio

  2. Em Design de comandos (turno único), clique em Abrir.
  3. Configure o modelo e os parâmetros:

    • Região: selecione a região que você quer usar.
    • Modelo: selecione Gemini Pro Vision.
    • Temperatura: use o controle deslizante ou a caixa de texto para inserir um valor para a temperatura.

      A temperatura é usada para amostragem durante a geração da resposta, que ocorre quando topP e topK são aplicados. A temperatura controla o grau de aleatoriedade na seleção do token. Temperaturas mais baixas são boas para solicitações que exigem uma resposta menos aberta ou criativa, enquanto temperaturas mais altas podem levar a resultados mais diversos ou criativos. Uma temperatura de 0 significa que os tokens de maior probabilidade são sempre selecionados. Nesse caso, as respostas para uma determinada solicitação são, na maioria das vezes, deterministas, mas uma pequena variação ainda é possível.

      Se o modelo retornar uma resposta muito genérica, muito curta ou se o modelo fornecer uma resposta alternativa, tente aumentar a temperatura.

    • Limite de token: use o controle deslizante ou a caixa de texto para inserir um valor para o limite de saída máximo.

      Número máximo de tokens que podem ser gerados na resposta. Um token tem cerca de quatro caracteres. 100 tokens correspondem a cerca de 60 a 80 palavras.

      Especifique um valor mais baixo para respostas mais curtas e um valor mais alto para respostas potencialmente mais longas.

    • Adicionar sequência de parada: insira uma sequência de parada, que é uma série de caracteres (incluindo espaços) que interrompe a geração de resposta se ela for encontrada pelo modelo. A sequência não é incluída como parte da resposta. Você pode adicionar até cinco sequências de paradas.
  4. Opcional: para configurar parâmetros avançados, clique em Avançado e faça as configurações da seguinte maneira:
  5. Clique para abrir as configurações avançadas

    • Top-K: use o controle deslizante ou a caixa de texto para inserir um valor para "top-K".

      O top-k muda a forma como o modelo seleciona tokens para saída. Um top-K de 1 significa que o próximo token selecionado é o mais provável entre todos os tokens no vocabulário do modelo (também chamado de decodificação gananciosa), enquanto um top-K de 3 significa que o próximo token está selecionado entre os três tokens mais prováveis usando a temperatura.

      Para cada etapa da seleção de tokens, são amostrados os tokens top-K com as maiores probabilidades. Em seguida, os tokens são filtrados com base no valor de top-P com o token final selecionado por meio da amostragem de temperatura.

      Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

    • Top-P: use o controle deslizante ou a caixa de texto para inserir um valor para essa parte. Os tokens são selecionados do mais provável para o menos até que a soma das probabilidades seja igual ao valor do top-P. Para ter menos resultados de variáveis, defina top-P como 0.
  6. O console do Google Cloud só oferece suporte a streaming, que envolve o recebimento de respostas aos comandos à medida que são gerados. Você já pode inserir uma mensagem na caixa para iniciar uma conversa com o modelo.

    O modelo usa as mensagens anteriores como contexto para novas respostas. Para incluir uma imagem, PDF ou vídeo no comando, clique no ícone .

    Para saber mais sobre comandos multimodais, consulte Criar comandos multimodais.

  7. Opcional: para salvar a solicitação em Minhas solicitações, clique em Salvar.
  8. Opcional: para receber o código Python ou um comando curl para seu prompt, clique em Ver código.
  9. Opcional: para limpar todas as mensagens anteriores, clique em Limpar conversa

Transcrição de áudio

A seguir, mostramos como usar um arquivo de áudio para transcrever uma entrevista. Esta amostra funciona apenas com o Gemini 1.5 Pro.

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido da Vertex AI. Para mais informações, consulte a documentação de referência do SDK da Vertex AI para Go para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método GenerateContentStream.

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))
  

Para uma resposta que não seja de streaming, use o método GenerateContent.

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))
  

Código de amostra

import (
	"context"
	"errors"
	"fmt"
	"io"
	"mime"
	"path/filepath"

	"cloud.google.com/go/vertexai/genai"
)

// audioPrompt is a sample prompt type consisting of one audio asset, and a text question.
type audioPrompt struct {
	// audio is a Google Cloud Storage path starting with "gs://"
	audio string
	// question asked to the model
	question string
}

// transcribeAudio generates a response into w, based upon the prompt
// and audio provided.
// audio is a Google Cloud Storage path starting with "gs://"
func transcribeAudio(w io.Writer, prompt audioPrompt, projectID, location, modelName string) error {
	// prompt := audioPrompt{
	// 	audio: "gs://cloud-samples-data/generative-ai/audio/pixel.mp3",
	// 	question: `
	// 		Can you transcribe this interview, in the format of timecode, speaker, caption.
	// 		Use speaker A, speaker B, etc. to identify speakers.
	// 	`,
	// },
	// location := "us-central1"
	// modelName := "gemini-1.5-pro-preview-0409"
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("unable to create client: %w", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)

	// Optional: set an explicit temperature
	model.SetTemperature(0.4)

	// Given an audio file URL, prepare audio file as genai.Part
	img := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext(prompt.audio)),
		FileURI:  prompt.audio,
	}

	res, err := model.GenerateContent(ctx, img, genai.Text(prompt.question))
	if err != nil {
		return fmt.Errorf("unable to generate contents: %w", err)
	}

	if len(res.Candidates) == 0 ||
		len(res.Candidates[0].Content.Parts) == 0 {
		return errors.New("empty response from model")
	}

	fmt.Fprintf(w, "generated transcript:\n%s\n", res.Candidates[0].Content.Parts[0])
	return nil
}

C#

Antes de testar essa amostra, siga as instruções de configuração para C# Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para C#.

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.


using Google.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class AudioInputTranscription
{
    public async Task<string> TranscribeAudio(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        string prompt = @"Can you transcribe this interview, in the format of timecode, speaker, caption.
Use speaker A, speaker B, etc. to identify speakers.";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "audio/mp3", FileUri = "gs://cloud-samples-data/generative-ai/audio/pixel.mp3" } }
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

Vídeo com áudio

Confira a seguir como resumir um arquivo de vídeo com áudio e retornar capítulos com marcações de tempo. Esta amostra funciona apenas com o Gemini 1.5 Pro.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a solicitações à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o parâmetro stream em generate_content.

  response = model.generate_content(contents=[...], stream = True)
  

Para uma resposta que não seja de streaming, remova o parâmetro ou defina-o como False.

Código de amostra


import vertexai
from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

prompt = """
Provide a description of the video.
The description should also contain anything important which people say in the video.
"""

video_file_uri = "gs://cloud-samples-data/generative-ai/video/pixel8.mp4"
video_file = Part.from_uri(video_file_uri, mime_type="video/mp4")

contents = [video_file, prompt]

response = model.generate_content(contents)
print(response.text)

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no guia de início rápido da Vertex AI. Para mais informações, consulte a documentação de referência do SDK da Vertex AI para Java para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  public ResponseStream generateContentStream(Content content)
  

Para uma resposta que não seja de streaming, use o método generateContent.

  public GenerateContentResponse generateContent(Content content)
  

Código de amostra


import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class VideoInputWithAudio {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";

    videoAudioInput(projectId, location, modelName);
  }

  // Analyzes the given video input, including its audio track.
  public static String videoAudioInput(String projectId, String location, String modelName)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      String videoUri = "gs://cloud-samples-data/generative-ai/video/pixel8.mp4";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "Provide a description of the video.\n The description should also "
                  + "contain anything important which people say in the video.",
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri)
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);

      return output;
    }
  }
}

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 IA generativa usando o SDK do Node.js. Para mais informações, consulte a documentação de referência do SDK do Node.js para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);
  

Para uma resposta que não seja de streaming, use o método generateContent.

  const streamingResp = await generativeModel.generateContent(request);
  

Código de amostra

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function analyze_video_with_audio(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-pro-preview-0409',
  });

  const filePart = {
    file_data: {
      file_uri: 'gs://cloud-samples-data/generative-ai/video/pixel8.mp4',
      mime_type: 'video/mp4',
    },
  };
  const textPart = {
    text: `
    Provide a description of the video.
    The description should also contain anything important which people say in the video.`,
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

C#

Antes de testar essa amostra, siga as instruções de configuração para C# Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para C#.

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.


using Google.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class VideoInputWithAudio
{
    public async Task<string> DescribeVideo(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        string prompt = @"Provide a description of the video.
The description should also contain anything important which people say in the video.";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "video/mp4", FileUri = "gs://cloud-samples-data/generative-ai/video/pixel8.mp4" }}
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

Todas as modalidades

Confira a seguir como processar imagens, vídeo, áudio e texto ao mesmo tempo. Este exemplo funciona com Gemini 1.5 Pro e Gemini 1.5 Flash.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a solicitações à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o parâmetro stream em generate_content.

  response = model.generate_content(contents=[...], stream = True)
  

Para uma resposta que não seja de streaming, remova o parâmetro ou defina-o como False.

Código de amostra


  import vertexai
  from vertexai.generative_models import GenerativeModel, Part

  # TODO(developer): Update and un-comment below lines
  # project_id = "PROJECT_ID"

  vertexai.init(project=project_id, location="us-central1")

  model = GenerativeModel(model_name="gemini-1.5-flash-001")

  video_file_uri = (
      "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4"
  )
  video_file = Part.from_uri(video_file_uri, mime_type="video/mp4")

  image_file_uri = "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png"
  image_file = Part.from_uri(image_file_uri, mime_type="image/png")

  prompt = """
  Watch each frame in the video carefully and answer the questions.
  Only base your answers strictly on what information is available in the video attached.
  Do not make up any information that is not part of the video and do not be too
  verbose, be to the point.

  Questions:
  - When is the moment in the image happening in the video? Provide a timestamp.
  - What is the context of the moment and what does the narrator say about it?
"""

  contents = [
      video_file,
      image_file,
      prompt,
  ]

  response = model.generate_content(contents)
  print(response.text)

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no guia de início rápido da Vertex AI. Para mais informações, consulte a documentação de referência do SDK da Vertex AI para Java para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  public ResponseStream generateContentStream(Content content)
  

Para uma resposta que não seja de streaming, use o método generateContent.

  public GenerateContentResponse generateContent(Content content)
  

Código de amostra


import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class MultimodalAllInput {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";

    multimodalAllInput(projectId, location, modelName);
  }

  // A request containing a text prompt, a video, and a picture.
  public static String multimodalAllInput(String projectId, String location, String modelName)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      String videoUri = "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4";
      String imageUri = "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri),
              PartMaker.fromMimeTypeAndData("image/png", imageUri),
              "Watch each frame in the video carefully and answer the questions.\n"
                  + "Only base your answers strictly on what information is available in "
                  + "the video attached. Do not make up any information that is not part "
                  + "of the video and do not be too verbose, be to the point.\n\n"
                  + "Questions:\n"
                  + "- When is the moment in the image happening in the video? "
                  + "Provide a timestamp.\n"
                  + "- What is the context of the moment and what does the narrator say about it?"
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);

      return output;
    }
  }
}

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 IA generativa usando o SDK do Node.js. Para mais informações, consulte a documentação de referência do SDK do Node.js para Gemini.

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.

Respostas com e sem streaming

Escolha se o modelo gera uma resposta com streaming ou sem streaming. O streaming envolve receber respostas a prompts à medida que são geradas. Ou seja, assim que o modelo gera tokens de saída, eles são enviados. Uma resposta sem streaming a prompts é enviada somente depois que todos os tokens de saída forem gerados.

Para uma resposta de streaming, use o método generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);
  

Para uma resposta que não seja de streaming, use o método generateContent.

  const streamingResp = await generativeModel.generateContent(request);
  

Código de amostra

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function analyze_all_modalities(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-pro-preview-0409',
  });

  const videoFilePart = {
    file_data: {
      file_uri:
        'gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4',
      mime_type: 'video/mp4',
    },
  };
  const imageFilePart = {
    file_data: {
      file_uri:
        'gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png',
      mime_type: 'image/png',
    },
  };

  const textPart = {
    text: `
    Watch each frame in the video carefully and answer the questions.
    Only base your answers strictly on what information is available in the video attached.
    Do not make up any information that is not part of the video and do not be too
    verbose, be to the point.

    Questions:
    - When is the moment in the image happening in the video? Provide a timestamp.
    - What is the context of the moment and what does the narrator say about it?`,
  };

  const request = {
    contents: [{role: 'user', parts: [videoFilePart, imageFilePart, textPart]}],
  };

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

C#

Antes de testar essa amostra, siga as instruções de configuração para C# Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para C#.

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.


using Google.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class MultimodalAllInput
{
    public async Task<string> AnswerFromMultimodalInput(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        string prompt = "Watch each frame in the video carefully and answer the questions.\n"
                  + "Only base your answers strictly on what information is available in "
                  + "the video attached. Do not make up any information that is not part "
                  + "of the video and do not be too verbose, be to the point.\n\n"
                  + "Questions:\n"
                  + "- When is the moment in the image happening in the video? "
                  + "Provide a timestamp.\n"
                  + "- What is the context of the moment and what does the narrator say about it?";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "video/mp4", FileUri = "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4" } },
                        new Part { FileData = new() { MimeType = "image/png", FileUri = "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png" } }
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

Definir parâmetros do modelo

Os seguintes parâmetros de modelo podem ser definidos em modelos multimodais:

Top-P

O top-p muda a forma como o modelo seleciona tokens para saída. Os tokens são selecionados do mais provável (veja o top-K) para o menos provável até que a soma das probabilidades seja igual ao valor do top-P. Por exemplo, se os tokens A, B e C tiverem uma probabilidade de 0,3, 0,2 e 0,1 e o valor de top-P for 0.5, o modelo selecionará A ou B como token seguinte usando temperatura e exclui C como candidato.

Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

Top-K

O top-k muda a forma como o modelo seleciona tokens para saída. Um top-K de 1 significa que o próximo token selecionado é o mais provável entre todos os tokens no vocabulário do modelo (também chamado de decodificação gananciosa), enquanto um top-K de 3 significa que o próximo token está selecionado entre os três tokens mais prováveis usando a temperatura.

Para cada etapa da seleção de tokens, são amostrados os tokens top-K com as maiores probabilidades. Em seguida, os tokens são filtrados com base no valor de top-P com o token final selecionado por meio da amostragem de temperatura.

Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.

Temperatura

A temperatura é usada para amostragem durante a geração da resposta, que ocorre quando topP e topK são aplicados. A temperatura controla o grau de aleatoriedade na seleção do token. Temperaturas mais baixas são boas para solicitações que exigem uma resposta menos aberta ou criativa, enquanto temperaturas mais altas podem levar a resultados mais diversos ou criativos. Uma temperatura de 0 significa que os tokens de maior probabilidade são sempre selecionados. Nesse caso, as respostas para uma determinada solicitação são, na maioria das vezes, deterministas, mas uma pequena variação ainda é possível.

Se o modelo retornar uma resposta muito genérica, muito curta ou se o modelo fornecer uma resposta alternativa, tente aumentar a temperatura.

Valores de parâmetro válidos

Parâmetro Gemini 1.0 Pro Vision Gemini 1.5 Pro Gemini 1.5 Flash
Top-K 1 - 40 (padrão 32) Sem suporte Sem suporte
Top-P 0 - 1.0 (padrão 1.0) 0 - 1.0 (padrão 0.95) 0 - 1.0 (padrão 0.95)
Temperatura 0 - 1.0 (padrão 0.4) 0 - 2.0 (padrão 1.0) 0 - 2.0 (padrão 1.0)

Requisitos de mídia

Ao usar um arquivo de mídia nas solicitações de solicitação, verifique se ele atende aos seguintes requisitos:

Requisitos de imagem

Os modelos multimodais do Gemini são compatíveis com os seguintes tipos MIME de imagem:

Tipo de Mime da imagem Gemini 1.5 Flash Gemini 1.5 Pro Gemini 1.0 Pro Vision
PNG - image/png
JPEG - image/jpeg

Não há um limite específico para o número de pixels em uma imagem. No entanto, imagens maiores são reduzidas e preenchidas para caber em uma resolução máxima de 3072 x 3072, preservando a proporção original.

No Gemini 1.0 Pro Vision, cada imagem representa 258 tokens.

Para o Gemini 1.5 Flash e Gemini 1.5 Pro:

  • Se as duas dimensões de proporção de uma imagem forem menores ou iguais a 384, 258 tokens serão usados.
  • Se uma dimensão da proporção de uma imagem for maior que 384, ela será cortada em blocos. O padrão de cada tamanho de bloco é a menor dimensão (largura ou altura) dividida por 1,5. Se necessário, cada bloco é ajustado para não ser menor que 256 nem maior que 768. Cada bloco é redimensionado para 768 x 768 e usa 258 tokens.

O número máximo de imagens que podem estar em uma solicitação de comando é:

  • 16 para o Gemini 1.0 Pro Vision
  • 3.000 para o Gemini 1.5 Flash e Gemini 1.5 Pro

Requisitos de áudio

Gemini 1.5 Flash e Gemini 1.5 Pro, compatível com os seguintes tipos de áudios MIME. Gemini 1.0 Pro Vision não tem suporte a áudio.

Tipo MIME de áudio Gemini 1.5 Flash Gemini 1.5 Pro Gemini 1.0 Pro Vision
AAC - audio/aac
FLAC - audio/flac
MP3 - audio/mp3
MPA - audio/m4a
MPEG - audio/mpeg
MPGA - audio/mpga
MP4 - audio/mp4
OPUS - audio/opus
PCM - audio/pcm
WAV - audio/wav
WEBM - audio/webm

Requisitos de vídeo

As amostras dos vídeos são feitas a 1 fps. Cada frame de vídeo representa 258 tokens.

Para o Gemini 1.5 Flash e Gemini 1.5 Pro, a faixa de áudio é codificada com frames de vídeo. A faixa de áudio também é dividida em entroncamentos de um segundo que representam 32 tokens. O frame de vídeo e os tokens de áudio são intercalados com os respectivos carimbos de data/hora. Os carimbos de data/hora são representados como sete tokens.

Os modelos multimodais do Gemini são compatíveis com os seguintes tipos MIME de vídeo:

Tipo de vídeo MIME Gemini 1.5 Flash Gemini 1.5 Pro Gemini 1.0 Pro Vision
FLV - video/x-flv
MOV - video/mov
MPEG - video/mpeg
MPEGPS - video/mpegps
MPG - video/mpg
MP4 - video/mp4
WEBM - video/webm
WMV - video/wmv
3GPP - video/3gpp

Requisitos de PDF

O tipo MIME obrigatório para um PDF é application/pdf.

Práticas recomendadas

Esta seção inclui práticas recomendadas para diferentes modalidades.

Práticas recomendadas para imagens

Ao usar imagens, siga as práticas recomendadas e informações a seguir para ter os melhores resultados.

  • Quando quiser detectar texto em uma imagem, use comandos com uma única imagem para ter resultados melhores do que aqueles com várias imagens.
  • Se o comando contiver uma única imagem, coloque a imagem antes do comando de texto.
  • Se houver várias imagens no comando e você quiser consultá-las posteriormente no comando ou fazer com que o modelo as mencione na resposta do modelo, atribua um índice a cada imagem antes da imagem de dois minutos. Use a b c ou image 1 image 2 image 3 para seu índice. Confira a seguir um exemplo de uso de imagens indexadas em um comando:

    image 1 <piano_recital.jpeg>
    image 2 <family_dinner.jpeg>
    image 3 <coffee_shop.jpeg>
    
    Write a blogpost about my day using image 1 and image 2. Then, give me ideas
    for tomorrow based on image 3.
    
  • Imagens com resolução mais alta geram resultados melhores.

  • Inclua alguns exemplos no comando.

  • Gire as imagens para a orientação correta antes de adicioná-las ao comando.

  • Evite imagens desfocadas.

Práticas recomendadas para vídeo

Ao usar vídeos, siga as práticas recomendadas e informações abaixo para ter os melhores resultados:

  • Use no máximo um vídeo por comando.
  • Se o comando contiver um único vídeo, coloque o vídeo antes do comando de texto.
  • Se você estiver usando o Gemini 1.0 Pro Vision, o modelo processará os vídeos como frames de imagem não contíguos do vídeo. O áudio não está incluído. Se você notar que falta algum conteúdo do vídeo no modelo, tente encurtar o vídeo para que ele capture uma parte maior do conteúdo.
  • Se você estiver usando o Gemini 1.0 Pro Vision, apenas as informações nos primeiros dois minutos serão processadas.
  • Se você estiver usando o Gemini 1.0 Pro Vision, nenhuma informação de áudio ou metadados de carimbo de data/hora serão analisados. Por isso, o modelo pode não funcionar bem em casos de uso que exigem entrada de áudio, como legendas de áudio, ou informações relacionadas ao tempo, como velocidade ou ritmo.
  • Quando a localização de carimbo de data/hora em um vídeo com áudio for necessária, peça ao modelo para gerar carimbos de data/hora no formato MM:SS, em que os dois primeiros dígitos representam minutos e os dois últimos dígitos representam segundos. Use o mesmo formato para perguntas sobre carimbo de data/hora.

Práticas recomendadas para PDF

Ao usar PDFs, siga as práticas recomendadas e informações a seguir para ter os melhores resultados:

  • PDFs são tratados como imagens, portanto, uma única página de um PDF é tratada como uma imagem.
    • O número de páginas suportadas é limitado ao número de imagens que um modelo aceita. No Gemini 1.0 Pro Vision, o limite é 16. No Gemini 1.5 Pro e Gemini 1.5 Flash, o limite é de 300. Se você tiver um documento longo, considere dividi-lo em vários PDFs para processá-lo.
    • Ao usar PDFs como entrada, o custo segue o preço de imagens do Gemini. Por exemplo, se você incluir um documento de duas páginas em uma chamada da API Gemini, será cobrada uma taxa de entrada pelo processamento de duas imagens.
  • Se o comando contiver um único PDF, coloque o PDF antes do comando de texto.
  • Use PDFs criados com texto renderizado como texto em vez de usar texto em imagens digitalizadas. Esse formato garante que o texto seja legível por máquina para que seja mais fácil editar, pesquisar e manipular o texto em comparação com PDFs de imagens digitalizadas. Isso fornece os resultados ideais ao trabalhar com documentos com muito texto, como contratos.

Para mais dicas de criação de comandos multimodais, consulte Criar comandos multimodais.

Limitações multimodais

Embora os modelos multimodais do Gemini sejam eficientes em muitos casos de usuários multimodais, é importante entender as limitações dos modelos:

  • Raciocínio espacial: os modelos não são precisos para localizar texto ou objetos em imagens e PDFs. Talvez eles retornem somente as contagens aproximadas de objetos.
  • Usos médicos: os modelos não são adequados para interpretar imagens médicas (por exemplo, raios-X e tomografias computadorizadas) ou fornecer aconselhamento médico.
  • Reconhecimento de pessoas: os modelos não são usados para identificar pessoas que não são celebridades em imagens.
  • Moderação de conteúdo: os modelos se recusam a fornecer respostas sobre imagens ou vídeos que violam nossas políticas de segurança.
  • Precisão: os modelos podem apresentar alucinação artificial ou cometer erros ao interpretar imagens de baixa qualidade, rotacionadas ou de resolução extremamente baixa. Os modelos também podem apresentar alucinação ao interpretar texto escrito à mão em imagens ou documentos PDF.
  • Reconhecimento de som sem fala: os modelos compatíveis com áudio podem cometer erros ao reconhecer sons que não são fala.
  • Movimento de alta velocidade: devido à taxa de amostragem fixa de 1 frame por segundo (QPS), os modelos podem cometer erros na compreensão do movimento de alta velocidade nos vídeos.
  • Carimbos de data/hora somente de áudio: os modelos compatíveis com áudio não podem gerar carimbos de data/hora com precisão para solicitações com arquivos de áudio. Isso inclui carimbos de data/hora de segmentação e localização temporal. Os carimbos de data/hora podem ser gerados com precisão para entrada que inclua um vídeo com áudio.
  • Pontuação de transcrição: as transcrições retornadas pelo Gemini 1.5 Flash podem não incluir pontuação.

A seguir