Compreensão de imagens

É possível adicionar imagens às solicitações do Gemini para realizar tarefas que envolvem compreender o conteúdo das imagens incluídas. Esta página mostra como adicionar imagens às solicitações para o Gemini na Vertex AI usando o console do Google Cloud e a API Vertex AI.

Modelos compatíveis

A tabela a seguir lista os modelos compatíveis com a compreensão de imagens:

Modelo	Detalhes da modalidade de imagem
Gemini 1.5 Flash Acessar o card de modelo em Flash do Gemini 1.5	Máximo de imagens por comando: 3.000
Gemini 1.5 Pro Acessar o card de modelo do Gemini 1.5 Pro	Máximo de imagens por comando: 3.000
Gemini 1.0 Pro Vision Acessar o card de modelo Gemini 1.0 Pro Vision	Máximo de imagens por comando: 16

Para uma lista de linguagens compatíveis com os modelos do Gemini, consulte as informações do modelo Modelos do Google. Para saber mais sobre como criar comandos multimodais, consulte Criar comandos multimodais. Se você está procurando uma maneira de usar o Gemini diretamente no seu dispositivo móvel e e apps da Web, consulte os SDKs da Vertex AI para Firebase para apps para Android, Swift, da Web e Flutter.

Adicionar imagens a uma solicitação

É possível adicionar uma ou várias imagens na sua solicitação para o Gemini.

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 vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas 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 vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas depois que todos os tokens de saída forem gerados.

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

  public ResponseStream<GenerateContentResponse> 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.5-flash-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 vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas 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.5-flash-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);
}

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 vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas 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"
	"encoding/json"
	"fmt"
	"io"

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

func tryGemini(w io.Writer, projectID string, location string, modelName string) error {
	// location := "us-central1"
	// modelName := "gemini-1.5-flash-001"

	ctx := context.Background()
	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("error creating client: %w", err)
	}
	gemini := client.GenerativeModel(modelName)

	img := genai.FileData{
		MIMEType: "image/jpeg",
		FileURI:  "gs://generativeai-downloads/images/scones.jpg",
	}
	prompt := genai.Text("What is in this image?")

	resp, err := gemini.GenerateContent(ctx, img, prompt)
	if err != nil {
		return fmt.Errorf("error generating content: %w", err)
	}
	rb, err := json.MarshalIndent(resp, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))
	return nil
}

C#

Antes de testar este exemplo, siga as instruções de configuração do C# na Vertex AI guia de início rápido. Para mais informações, consulte a documentação de referência da Vertex AI 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.

Respostas com e sem streaming

Escolha se o modelo vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas depois que todos os tokens de saída forem gerados.

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

  public virtual PredictionServiceClient.StreamGenerateContentStream StreamGenerateContent(GenerateContentRequest request)
  

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

  public virtual Task<GenerateContentResponse> GenerateContentAsync(GenerateContentRequest request)
  

Para mais informações sobre como o servidor pode transmitir respostas, consulte RPCs de streaming.

Código de amostra

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

public class GeminiQuickstart
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001"
    )
    {
        // Create client
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        // Initialize content request
        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            GenerationConfig = new GenerationConfig
            {
                Temperature = 0.4f,
                TopP = 1,
                TopK = 32,
                MaxOutputTokens = 2048
            },
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = "What's in this photo?" },
                        new Part { FileData = new() { MimeType = "image/png", FileUri = "gs://generativeai-downloads/images/scones.jpg" } }
                    }
                }
            }
        };

        // Make the request, returning a streaming response
        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        // Read streaming responses from server until complete
        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }

        return fullText.ToString();
    }
}

REST

Depois de configurou seu ambiente use REST para testar uma solicitação de texto. O exemplo a seguir envia uma solicitação ao publisher endpoint do modelo.

É possível incluir imagens armazenadas no Cloud Storage ou usar dados de imagem codificados em Base64.

Imagem no Cloud Storage

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

• LOCATION: a região para processar a solicitação. Insira uma região compatível. Para a lista completa de regiões compatíveis, consulte Locais disponíveis.

  Clicar para abrir uma lista parcial das 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.
• FILE_URI: o URI do Cloud Storage do arquivo a ser incluído no prompt. O objeto do bucket precisa ser publicamente legível ou residir no mesmo projeto do Google Cloud que está enviando a solicitação. Você também precisa especificar o tipo de mídia (mimeType) do arquivo.

  Se você não tiver um arquivo de imagem no Cloud Storage, use o seguinte arquivo disponível publicamente: gs://cloud-samples-data/generative-ai/image/scones.jpg com um tipo MIME de image/jpeg. Para visualizar esta imagem, abra a imagem de amostra.

• MIME_TYPE: O tipo de mídia do arquivo especificado em 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
• TEXT: as instruções de texto a serem incluídas no comando. Por exemplo, What is shown in this image?

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

curl

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo chamado request.json. Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual:

cat > request.json << 'EOF'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
EOF

Depois execute o comando a seguir para enviar a solicitação REST:

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/gemini-1.5-flash:generateContent"

PowerShell

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo chamado request.json. Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual:

@'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Depois execute o comando a seguir para enviar a solicitação REST:

$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/gemini-1.5-flash:generateContent" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a seguinte.

Resposta

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": " The image shows a table with a cup of coffee, a bowl of blueberries, and a plate of scones with blueberries on it. There are also pink flowers on the table."
          }
        ]
      },
      "finishReason": "STOP",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.027742893,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.07276838
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.026155617,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.07172113
        },
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.04304285,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.037608635
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.08803312,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.09203286
        }
      ]
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 265,
    "candidatesTokenCount": 35,
    "totalTokenCount": 300
  }
}

Dados de imagem Base64

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

• LOCATION: a região para processar a solicitação. Insira uma região compatível. Para a lista completa de regiões compatíveis, consulte Locais disponíveis.

  Clicar para abrir uma lista parcial das 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.

• B64_BASE_IMAGE

  : A codificação Base64 da imagem, do PDF ou do vídeo a ser incluído in-line no comando. Ao incluir mídia inline, você também precisa especificar a mídia tipo (mimeType) dos dados.
• MIME_TYPE: O tipo de mídia do arquivo especificado em 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
• TEXT: as instruções de texto a serem incluídas no comando. Por exemplo, What is shown in this image?.

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

curl

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo chamado request.json. Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual:

cat > request.json << 'EOF'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "inlineData": {
          "data": "B64_BASE_IMAGE",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
EOF

Depois execute o comando a seguir para enviar a solicitação REST:

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/gemini-1.5-flash:generateContent"

PowerShell

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo chamado request.json. Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual:

@'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "inlineData": {
          "data": "B64_BASE_IMAGE",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Depois execute o comando a seguir para enviar a solicitação REST:

$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/gemini-1.5-flash:generateContent" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a seguinte.

Resposta

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": " The image shows a table with a cup of coffee, a bowl of blueberries, and a plate of scones with blueberries on it. There are also pink flowers on the table."
          }
        ]
      },
      "finishReason": "STOP",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.027742893,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.07276838
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.026155617,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.07172113
        },
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.04304285,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.037608635
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.08803312,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.09203286
        }
      ]
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 265,
    "candidatesTokenCount": 35,
    "totalTokenCount": 300
  }
}

Observe o seguinte no URL deste exemplo:

• Use o generateContent para solicitar que a resposta seja retornada depois de ser totalmente gerada. Para reduzir a percepção de latência ao público humano, transmita a resposta à medida que geradas usando o streamGenerateContent .
• O ID do modelo multimodal está localizado no final do URL, antes do método Por exemplo, gemini-1.5-flash ou gemini-1.0-pro-vision). Este exemplo pode oferecer suporte a outras modelos de classificação.

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. Opcional: configure o modelo e os parâmetros:

   • Modelo: selecione um modelo.
   • Região: selecione a região que você quer usar.

   • 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 de saída: 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 paradas: opcional. Insira uma sequência de paradas, que é uma série de caracteres que inclui espaços. Se o modelo encontrar uma sequência de paradas, a geração de resposta será interrompida. A sequência de paradas não é incluída na resposta, e 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:

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". (incompatível com o Gemini 1.5).

  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.
• Ativar embasamento: o embasamento não é compatível com recursos multimodais. solicitações.
5. Para fazer upload de mídia, como arquivos PNG, faça o seguinte:
1. Clique em Inserir mídia e selecione uma origem.

   Se você escolher o Google Drive como seu origem, escolha uma conta e dê consentimento o Vertex AI Studio acesse sua conta na primeira vez que selecione essa opção. É possível fazer o upload de vários arquivos de mídia com até 10 MB. Um arquivo não pode exceder 7 MB.

2. Clique no arquivo que você quer adicionar.
3. Clique em Selecionar.

   A miniatura do arquivo é mostrada no painel Comando. O número total de tokens também é exibido. Se os dados de solicitação excederem o limite de tokens, eles serão truncados e não serão incluídos no processamento dos dados.

4. Opcional: para exibir o número de tokens calculados nas imagens e a soma de todos os tokens, clique em Ver tokens.

   Pode levar até 15 segundos para calcular a contagem de tokens para arquivos de mídia. As visualizações ID do token para texto e ID do token não mostram resultados importantes porque não há compatibilidade com tokens de mídia.

   Para fechar o painel da ferramenta tokenizador, clique em X ou clique fora do painel.

6. Digite o comando de texto no painel Prompt. O modelo usa as mensagens anteriores como contexto para novas respostas.
7. Opcional: para exibir o número de tokens calculados nas imagens e a soma de todos os tokens, clique em Ver tokens. É possível conferir os tokens ou IDs de token do comando de texto.
   • Para ver os tokens no comando de texto destacados com cores diferentes marcando o limite de cada ID de token, clique em ID do token para texto. Tokens de mídia não são aceitos.
   • Para acessar os IDs de token, clique em ID do token.

     Para fechar o painel da ferramenta tokenizador, clique em X ou clique fora do painel.

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

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. Cada amostra recebe dois conjuntos das seguintes entradas:

• Imagem de um ponto turístico famoso
• O tipo de mídia da imagem
• Texto indicando a cidade e o ponto de referência na imagem

A amostra também aceita uma terceira imagem e tipo de mídia, mas nenhum texto. O exemplo retorna uma resposta de texto indicando a cidade e o ponto de referência na terceira imagem.

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 vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas 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 vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas depois que todos os tokens de saída forem gerados.

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

  public ResponseStream<GenerateContentResponse> 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.5-flash-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 vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas 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.5-flash-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 vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas 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.5-flash-001"
	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: %w", 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: %w", 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 este exemplo, siga as instruções de configuração do C# na Vertex AI guia de início rápido. Para mais informações, consulte a documentação de referência da Vertex AI 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.

Respostas com e sem streaming

Escolha se o modelo vai gerar respostas de streaming ou sem streaming. Para respostas de streaming, você recebe cada resposta assim que o token de saída for gerado. Para respostas que não são de streaming, você recebe todas as respostas depois que todos os tokens de saída forem gerados.

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

  public virtual PredictionServiceClient.StreamGenerateContentStream StreamGenerateContent(GenerateContentRequest request)
  

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

  public virtual Task<GenerateContentResponse> GenerateContentAsync(GenerateContentRequest request)
  

Para mais informações sobre como o servidor pode transmitir respostas, consulte RPCs de streaming.

Código de amostra

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.5-flash-001"
    )
    {
        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

Depois de configurou seu ambiente use REST para testar uma solicitação de texto. O exemplo a seguir envia uma solicitação ao publisher endpoint do modelo.

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

• LOCATION: a região para processar a solicitação. Insira uma região compatível. Para a lista completa de regiões compatíveis, consulte Locais disponíveis.

  Clicar para abrir uma lista parcial das 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.
• FILE_URI1: o URI do Cloud Storage do arquivo a ser incluído no prompt. O objeto do bucket precisa ser publicamente legível ou residir no mesmo projeto do Google Cloud que está enviando a solicitação. Você também precisa especificar o tipo de mídia (mimeType) do arquivo.

  Se você não tiver um arquivo de imagem no Cloud Storage, use o seguinte arquivo disponível publicamente: gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png com um tipo MIME de image/png. Para visualizar esta imagem, abra a imagem de amostra.

• MIME_TYPE: O tipo de mídia do arquivo especificado em 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
  . Para simplificar, este exemplo usa o mesmo tipo de mídia para as três imagens de entrada.
• TEXT1: as instruções de texto a serem incluídas no comando. Por exemplo, city: Rome, Landmark: the Colosseum
• FILE_URI2: o URI do Cloud Storage do arquivo a ser incluído no prompt. O objeto do bucket precisa ser publicamente legível ou residir no mesmo projeto do Google Cloud que está enviando a solicitação. Você também precisa especificar o tipo de mídia (mimeType) do arquivo.

  Se você não tiver um arquivo de imagem no Cloud Storage, use o seguinte arquivo disponível publicamente: gs://cloud-samples-data/vertex-ai/llm/prompts/landmark2.png com um tipo MIME de image/png. Para visualizar esta imagem, abra a imagem de amostra.

• TEXT2: as instruções de texto a serem incluídas no comando. Por exemplo, city: Beijing, Landmark: Forbidden City
• FILE_URI3: o URI do Cloud Storage do arquivo a ser incluído no prompt. O objeto do bucket precisa ser publicamente legível ou residir no mesmo projeto do Google Cloud que está enviando a solicitação. Você também precisa especificar o tipo de mídia (mimeType) do arquivo.

  Se você não tiver um arquivo de imagem no Cloud Storage, use o seguinte arquivo disponível publicamente: gs://cloud-samples-data/vertex-ai/llm/prompts/landmark3.png com um tipo MIME de image/png. Para visualizar esta imagem, abra a imagem de amostra.

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

curl

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo chamado request.json. Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual:

cat > request.json << 'EOF'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI1",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT1"
      },
      {
        "fileData": {
          "fileUri": "FILE_URI2",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT2"
      },
      {
        "fileData": {
          "fileUri": "FILE_URI3",
          "mimeType": "MIME_TYPE"
        }
      }
    ]
  }
}
EOF

Depois execute o comando a seguir para enviar a solicitação REST:

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/gemini-1.5-flash:generateContent"

PowerShell

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo chamado request.json. Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual:

@'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI1",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT1"
      },
      {
        "fileData": {
          "fileUri": "FILE_URI2",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT2"
      },
      {
        "fileData": {
          "fileUri": "FILE_URI3",
          "mimeType": "MIME_TYPE"
        }
      }
    ]
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Depois execute o comando a seguir para enviar a solicitação REST:

$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/gemini-1.5-flash:generateContent" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a seguinte.

Resposta

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": "city: Rio de Janeiro, Landmark: Christ the Redeemer statue \n"
          }
        ]
      },
      "finishReason": "STOP",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.05340333,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.08740791
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.13050689,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.10338596
        },
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.05399884,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.09947021
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.10576342,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.066934206
        }
      ]
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 791,
    "candidatesTokenCount": 14,
    "totalTokenCount": 805
  }
}

Observe o seguinte no URL deste exemplo:

• Use o generateContent para solicitar que a resposta seja retornada depois de ser totalmente gerada. Para reduzir a percepção de latência ao público humano, transmita a resposta à medida que geradas usando o streamGenerateContent .
• O ID do modelo multimodal está localizado no final do URL, antes do método Por exemplo, gemini-1.5-flash ou gemini-1.0-pro-vision). Este exemplo pode oferecer suporte a outras modelos de classificação.

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. Opcional: configure o modelo e os parâmetros:

   • Modelo: selecione um modelo.
   • Região: selecione a região que você quer usar.

   • 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 de saída: 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 paradas: opcional. Insira uma sequência de paradas, que é uma série de caracteres que inclui espaços. Se o modelo encontrar uma sequência de paradas, a geração de resposta será interrompida. A sequência de paradas não é incluída na resposta, e 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:

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". (incompatível com o Gemini 1.5).

  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.
• Ativar embasamento: o embasamento não é compatível com recursos multimodais. solicitações.
5. Para fazer upload de mídia, como arquivos PNG, faça o seguinte:
1. Clique em Inserir mídia e selecione uma origem.

   Se você escolher o Google Drive como seu origem, escolha uma conta e dê consentimento o Vertex AI Studio acesse sua conta na primeira vez que selecione essa opção. É possível fazer o upload de vários arquivos de mídia com até 10 MB. Um arquivo não pode exceder 7 MB.

2. Clique no arquivo que você quer adicionar.
3. Clique em Selecionar.

   A miniatura do arquivo é mostrada no painel Comando. O número total de tokens também é exibido. Se os dados de solicitação excederem o limite de tokens, eles serão truncados e não serão incluídos no processamento dos dados.

4. Opcional: para exibir o número de tokens calculados nas imagens e a soma de todos os tokens, clique em Ver tokens.

   Pode levar até 15 segundos para calcular a contagem de tokens para arquivos de mídia. As visualizações ID do token para texto e ID do token não mostram resultados importantes porque não há compatibilidade com tokens de mídia.

   Para fechar o painel da ferramenta tokenizador, clique em X ou clique fora do painel.

6. Digite o comando de texto no painel Prompt. O modelo usa as mensagens anteriores como contexto para novas respostas.
7. Opcional: para exibir o número de tokens calculados nas imagens e a soma de todos os tokens, clique em Ver tokens. É possível conferir os tokens ou IDs de token do comando de texto.
   • Para ver os tokens no comando de texto destacados com cores diferentes marcando o limite de cada ID de token, clique em ID do token para texto. Tokens de mídia não são aceitos.
   • Para acessar os IDs de token, clique em ID do token.

     Para fechar o painel da ferramenta tokenizador, clique em X ou clique fora do painel.

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

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 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 uma imagem forem menores ou iguais a 384 pixels, então 258 tokens serão usados.
• Se uma dimensão de uma imagem for maior do que 384 pixels, a imagem 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 pixels nem maior que 768 pixels. 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

Práticas recomendadas

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.

Limitações

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. 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 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 erros ao interpretar texto escrito à mão em imagens ou documentos.

A seguir

• Comece a criar com os modelos multimodais do Gemini. Novos clientes ganham US $300 em créditos gratuitos do Google Cloud para descobrir o que eles podem fazer com o Gemini.
• Saiba como enviar solicitações de comandos de chat.
• Saiba mais sobre as práticas recomendadas de IA responsável e os filtros de segurança da Vertex AI.