Comprensión de imágenes

Puedes agregar imágenes a las solicitudes de Gemini para realizar tareas que implican comprender el contenido de las imágenes incluidas. En esta página, se muestra cómo agregar imágenes a tus solicitudes a Gemini en Vertex AI mediante la consola de Google Cloud y la API de Vertex AI.

Modelos compatibles

En la siguiente tabla, se enumeran los modelos que admiten la comprensión de imágenes:

Modelo Detalles de la modalidad de imagen

Gemini 1.5 Flash

Ir a la tarjeta de modelo de Gemini 1.5 Flash		 Cantidad máxima de imágenes por instrucción: 3,000

Gemini 1.5 Pro

Ir a la tarjeta de modelo de Gemini 1.5 Pro		 Cantidad máxima de imágenes por instrucción: 3,000

Gemini 1.0 Pro Vision

Ir a la tarjeta de modelo de Gemini 1.0 Pro Vision		 Cantidad máxima de imágenes por instrucción: 16

Para obtener una lista de los idiomas compatibles con los modelos de Gemini, consulta la información del modelo de los Modelos de Google. Para obtener más información sobre cómo diseñar instrucciones multimodales, consulta Diseña instrucciones multimodales. Si buscas una manera de usar Gemini directamente desde tus apps web y tus dispositivos móviles, consulta los SDK de Vertex AI in Firebase para apps de Android, Swift, Web y Flutter.

Agrega imágenes a una solicitud

Puedes agregar una o varias imágenes en tu solicitud a Gemini.

Imagen única

El código de muestra en cada una de las siguientes pestañas muestra una manera diferente de identificar el contenido de una imagen. Esta muestra funciona con todos los modelos multimodales de Gemini.

Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación del SDK de Vertex AI de referencia de la API de Vertex para Python.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el parámetro stream en generate_content.

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

Para una respuesta sin transmisión, quita el parámetro o configúralo como False.

Código de muestra

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update project_id and location
vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel("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 probar este ejemplo, sigue las instrucciones de configuración de Java en la guía de inicio rápido de Vertex AI. Si deseas obtener más información, consulta la documentación de referencia del SDK de Java de Vertex AI para Gemini.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el método generateContentStream.

  public ResponseStream<GenerateContentResponse> generateContentStream(Content content)

Para una respuesta sin transmisión, usa el método generateContent.

  public GenerateContentResponse generateContent(Content content)

Código de muestra

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 probar esta muestra, sigue las instrucciones de configuración de Node.js en la guía de inicio rápido de IA generativa para usar el SDK de Node.js. Si deseas obtener más información, consulta la documentación de referencia del SDK de Node.js para Gemini.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el método generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);

Para una respuesta sin transmisión, usa el método generateContent.

  const streamingResp = await generativeModel.generateContent(request);

Código de muestra

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:');

  // Generate a response
  const response = await generativeVisionModel.generateContent(request);

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

  console.log(fullTextResponse);
}

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración de Go en la guía de inicio rápido de Vertex AI. Si deseas obtener más información, consulta la documentación de referencia del SDK de Java de Vertex AI para Gemini.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el 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 una respuesta sin transmisión, usa el método GenerateContent.

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

Código de muestra

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 probar este ejemplo, sigue las instrucciones de configuración de C# en la guía de inicio rápido de Vertex AI. Para obtener más información, consulta la documentación de referencia de C# de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el método StreamGenerateContent.

  public virtual PredictionServiceClient.StreamGenerateContentStream StreamGenerateContent(GenerateContentRequest request)

Para una respuesta sin transmisión, usa el método GenerateContentAsync.

  public virtual Task<GenerateContentResponse> GenerateContentAsync(GenerateContentRequest request)

Para obtener más información acerca de cómo el servidor puede transmitir respuestas, consulta RPC de transmisión.

Código de muestra


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

Después de configurar tu entorno, puedes usar REST para probar una instrucción de texto. En el siguiente ejemplo, se envía una solicitud al extremo del modelo de publicador.

Puedes incluir imágenes almacenadas en Cloud Storage o usar datos de imagen codificados en base64.

Imagen en Cloud Storage

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION: La región para procesar la solicitud. Ingresa una región compatible. Para obtener la lista completa de regiones admitidas, consulta Ubicaciones disponibles.

    Haz clic para expandir una lista parcial de regiones disponibles

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: El ID del proyecto.
  • FILE_URI: El URI de Cloud Storage del archivo que se incluirá en la instrucción. El objeto del bucket debe poder leerse de forma pública o residir en el mismo proyecto de Google Cloud que envía la solicitud. También debes especificar el tipo de medio (mimeType) del archivo.

    Si no tienes un archivo de imagen en Cloud Storage, puedes usar el siguiente archivo disponible de forma pública: gs://cloud-samples-data/generative-ai/image/scones.jpg con un tipo de MIME de image/jpeg. Para ver esta imagen, abre el archivo de imagen de muestra.

  • MIME_TYPE El tipo de medio del archivo especificado en los campos data o fileUri. Los valores aceptables son los siguientes:

    Haz clic para expandir los tipos de 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: Las instrucciones de texto que se incluirán en el mensaje. Por ejemplo, What is shown in this image?

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

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

Luego, ejecuta el siguiente comando para enviar tu solicitud de 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

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

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

Luego, ejecuta el siguiente comando para enviar tu solicitud de 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

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

Datos de imágenes en base64

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION: La región para procesar la solicitud. Ingresa una región compatible. Para obtener la lista completa de regiones admitidas, consulta Ubicaciones disponibles.

    Haz clic para expandir una lista parcial de regiones disponibles

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: El ID del proyecto.
  • B64_BASE_IMAGE
     La codificación en base64 de la imagen o el video que se incluirá intercalada en la instrucción. Si incluyes contenido multimedia intercalado, también debes especificar el tipo de medio (mimeType) de los datos.
  • MIME_TYPE El tipo de medio del archivo especificado en los campos data o fileUri. Los valores aceptables son los siguientes:

    Haz clic para expandir los tipos de 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: Las instrucciones de texto que se incluirán en el mensaje. Por ejemplo, What is shown in this image?.

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

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

Luego, ejecuta el siguiente comando para enviar tu solicitud de 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

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

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

Luego, ejecuta el siguiente comando para enviar tu solicitud de 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

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:
Ten en cuenta lo siguiente en la URL para esta muestra:
  • Usa el método generateContent para solicitar que la respuesta se muestre después de que se haya generado por completo. Para reducir la percepción de latencia a un público humano, transmite la respuesta a medida que se genera; para ello, usa el método streamGenerateContent.
  • El ID del modelo multimodal se encuentra al final de la URL antes del método (por ejemplo, gemini-1.5-flash o gemini-1.0-pro-vision). Esta muestra también puede admitir otros modelos.

Console

Para enviar un mensaje multimodal con la consola de Google Cloud, haz lo siguiente:

  1. En la sección Vertex AI de la consola de Google Cloud, ve a la página Vertex AI Studio.

    Ir a Vertex AI Studio

  2. En Diseño de instrucciones (un solo turno), haz clic en Abrir.

  3. Opcional: Configura el modelo y los parámetros:

    • Modelo: Selecciona un modelo.
    • Región: selecciona la región que deseas usar.

    • Temperatura: Usa el control deslizante o el cuadro de texto para ingresar un valor de temperatura.

      La temperatura se usa para las muestras durante la generación de respuesta, que se genera cuando se aplican topP y topK. La temperatura controla el grado de aleatorización en la selección de tokens. Las temperaturas más bajas son buenas para los mensajes que requieren una respuesta menos abierta o de creativa, mientras que las temperaturas más altas pueden generar resultados más diversos o creativos. Una temperatura de 0 significa que siempre se seleccionan los tokens de probabilidad más alta. En este caso, las respuestas para un mensaje determinado son, en su mayoría, deterministas, pero es posible que haya una pequeña cantidad de variación.

      Si el modelo muestra una respuesta demasiado genérica, demasiado corta o el modelo proporciona una respuesta de resguardo, intenta aumentar la temperatura.

    • Límite de tokens de salida: Usa el control deslizante o el cuadro de texto para ingresar un valor para el límite máximo de salida.

      Cantidad máxima de tokens que se pueden generar en la respuesta. Un token tiene casi cuatro caracteres. 100 tokens corresponden a casi 60 u 80 palabras.

      Especifica un valor más bajo para las respuestas más cortas y un valor más alto para las respuestas potencialmente más largas.

    • Agrega una secuencia de detención: Opcional. Ingresa una secuencia de detención, que es una serie de caracteres que incluyen espacios. Si el modelo encuentra una secuencia de detención, la generación de respuesta se detiene. La secuencia de detención no se incluye en la respuesta y puedes agregar hasta cinco secuencias de detención.
  4. Opcional: Para configurar parámetros avanzados, haz clic en Avanzada y establece la configuración de la siguiente manera:

    5. Haz clic para expandir las configuraciones avanzadas.

    • K superior: Usa el control deslizante o el cuadro de texto con el fin de ingresar un valor para K superior. (no es compatible con Gemini 1.5).

      El parámetro Top-K cambia la manera en la que el modelo selecciona los tokens para el resultado. K superior a 1 significa que el siguiente token seleccionado es el más probable entre todos los tokens en el vocabulario del modelo (también llamado decodificación voraz), mientras que el K superior a 3 significa que el siguiente token se selecciona de los tres tokens más probables mediante la temperatura.

      Para cada paso de selección de tokens, se muestran los tokens de K superior con las probabilidades más altas. Luego, los tokens se filtran según el superior con el token final seleccionado mediante el muestreo de temperatura.

      Especifica un valor más bajo para respuestas menos aleatorias y un valor más alto para respuestas más aleatorias.

    • P superior: Usa el control deslizante o el cuadro de texto con el fin de ingresar un valor de P superior. Los tokens se seleccionan del más probable al menos probable hasta que la suma de sus probabilidades sea igual al valor de Top-P. Para obtener los resultados menos variables, establece Top-P como 0.
    • Habilitar fundamentos: Los fundamentos no son compatibles con las instrucciones multimodales.
  5. Para subir contenido multimedia, como archivos PNG, haz lo siguiente:
    1. Haz clic en Insertar medios y selecciona una fuente.

      Si eliges Google Drive como tu fuente, debes elegir una cuenta y dar consentimiento a Vertex AI Studio para acceder a tu cuenta la primera vez que selecciones esta opción. Puedes subir varios archivos multimedia con un tamaño total de hasta 10 MB. Un solo archivo no puede superar los 7 MB.

    2. Haz clic en el archivo que quieras agregar.
    3. Haz clic en Seleccionar.

      La miniatura del archivo se muestra en el panel Instrucción. También se muestra la cantidad total de tokens. Si los datos de la instrucción superan el límite de tokens, los tokens se truncan y no se incluyen en el procesamiento de tus datos.

    4. Opcional: Para mostrar la cantidad de tokens calculados en tus imágenes y la suma de todos los tokens, haz clic en Ver tokens.

      El recuento de tokens puede tardar hasta 15 segundos en calcularse para los archivos multimedia. Las vistas ID de token a texto e ID de token no muestran ningún resultado valioso porque no se admiten tokens multimedia.

      Para cerrar el panel de herramientas del tokenizador, haz clic en X o haz clic fuera del panel.

  6. Ingresa tu mensaje de texto en el panel Mensaje. El modelo usa las instrucciones anteriores como contexto para las respuestas nuevas.
  7. Opcional: Para mostrar la cantidad de tokens calculados en tus imágenes y la suma de todos los tokens, haz clic en Ver tokens. Puedes ver los tokens o los IDs de token de tu mensaje de texto.
    • Para ver los tokens en el mensaje de texto que están destacados con diferentes colores que marcan el límite de cada ID de token, haz clic en ID de token a texto. No se admiten tokens multimedia.
    • Para ver los IDs de los tokens, haz clic en ID de token.

      Para cerrar el panel de herramientas del tokenizador, haz clic en X o haz clic fuera del panel.

  8. Haz clic en Enviar.
  9. Opcional: Para guardar el mensaje en Mis mensajes, haz clic en Guardar.
  10. Opcional: Para obtener el código de Python o un comando curl para tu mensaje, haz clic en Obtener código.
  11. Opcional: Para borrar todos los mensajes anteriores, haz clic en Borrar conversación.

Varias imágenes

En cada una de las siguientes pestañas, se muestra una forma diferente de incluir varias imágenes en una solicitud de instrucciones. En cada ejemplo, se toman dos conjuntos de las siguientes entradas:

  • Imagen de un punto de referencia de una ciudad popular
  • El tipo de medio de la imagen
  • Texto que indica la ciudad y el punto de referencia en la imagen

La muestra también toma una tercera imagen y tipo de medio, pero no texto. En el ejemplo, se muestra una respuesta de texto que indica la ciudad y el punto de referencia en la tercera imagen.

Estas muestras de imágenes funcionan con todos los modelos multimodales de Gemini.

Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación del SDK de Vertex AI de referencia de la API de Vertex para Python.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el parámetro stream en generate_content.

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

Para una respuesta sin transmisión, quita el parámetro o configúralo como False.

Código de muestra

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update project_id and location
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("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 probar este ejemplo, sigue las instrucciones de configuración de Java en la guía de inicio rápido de Vertex AI. Si deseas obtener más información, consulta la documentación de referencia del SDK de Java de Vertex AI para Gemini.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el método generateContentStream.

  public ResponseStream<GenerateContentResponse> generateContentStream(Content content)

Para una respuesta sin transmisión, usa el método generateContent.

  public GenerateContentResponse generateContent(Content content)

Código de muestra

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 probar esta muestra, sigue las instrucciones de configuración de Node.js en la guía de inicio rápido de IA generativa para usar el SDK de Node.js. Si deseas obtener más información, consulta la documentación de referencia del SDK de Node.js para Gemini.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el método generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);

Para una respuesta sin transmisión, usa el método generateContent.

  const streamingResp = await generativeModel.generateContent(request);

Código de muestra

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 probar este ejemplo, sigue las instrucciones de configuración de Go en la guía de inicio rápido de Vertex AI. Si deseas obtener más información, consulta la documentación de referencia del SDK de Java de Vertex AI para Gemini.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el 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 una respuesta sin transmisión, usa el método GenerateContent.

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

Código de muestra

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

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

// generateMultimodalContent shows how to generate a text from a multimodal prompt using the Gemini model,
// writing the response to the provided io.Writer.
func generateMultimodalContent(w io.Writer, projectID, location, modelName string) error {
	// location := "us-central1"
	// modelName := "gemini-1.5-flash-001"
	ctx := context.Background()

	// create prompt image parts
	colosseum := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext("landmark1.png")),
		FileURI:  "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png",
	}
	forbiddenCity := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext("landmark2.png")),
		FileURI:  "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark2.png",
	}
	newImage := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext("landmark3.png")),
		FileURI:  "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark3.png",
	}
	// 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
	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)

	res, err := model.GenerateContent(ctx, prompt...)
	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
}

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración de C# en la guía de inicio rápido de Vertex AI. Para obtener más información, consulta la documentación de referencia de C# de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Respuestas de transmisión y sin transmisión

Puedes elegir si el modelo genera respuestas de transmisión o sin transmisión. Para las respuestas de transmisión, recibirás cada respuesta en cuanto se genere su token de salida. En el caso de las respuestas sin transmisión continua, recibes todas las respuestas después de que se generan todos los tokens de salida.

Para una respuesta de transmisión, usa el método StreamGenerateContent.

  public virtual PredictionServiceClient.StreamGenerateContentStream StreamGenerateContent(GenerateContentRequest request)

Para una respuesta sin transmisión, usa el método GenerateContentAsync.

  public virtual Task<GenerateContentResponse> GenerateContentAsync(GenerateContentRequest request)

Para obtener más información acerca de cómo el servidor puede transmitir respuestas, consulta RPC de transmisión.

Código de muestra


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

Después de configurar tu entorno, puedes usar REST para probar una instrucción de texto. En el siguiente ejemplo, se envía una solicitud al extremo del modelo de publicador.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION: La región para procesar la solicitud. Ingresa una región compatible. Para obtener la lista completa de regiones admitidas, consulta Ubicaciones disponibles.

    Haz clic para expandir una lista parcial de regiones disponibles

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: El ID del proyecto.
  • FILE_URI1: El URI de Cloud Storage del archivo que se incluirá en la instrucción. El objeto del bucket debe poder leerse de forma pública o residir en el mismo proyecto de Google Cloud que envía la solicitud. También debes especificar el tipo de medio (mimeType) del archivo.

    Si no tienes un archivo de imagen en Cloud Storage, puedes usar el siguiente archivo disponible de forma pública: gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png con un tipo de MIME de image/png. Para ver esta imagen, abre el archivo de imagen de muestra.

  • MIME_TYPE El tipo de medio del archivo especificado en los campos data o fileUri. Los valores aceptables son los siguientes:

    Haz clic para expandir los tipos de 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
    A fin de simplificar, en esta muestra se usa el mismo tipo de medio para las tres imágenes de entrada.
  • TEXT1: Las instrucciones de texto que se incluirán en el mensaje. Por ejemplo, city: Rome, Landmark: the Colosseum
  • FILE_URI2: El URI de Cloud Storage del archivo que se incluirá en la instrucción. El objeto del bucket debe poder leerse de forma pública o residir en el mismo proyecto de Google Cloud que envía la solicitud. También debes especificar el tipo de medio (mimeType) del archivo.

    Si no tienes un archivo de imagen en Cloud Storage, puedes usar el siguiente archivo disponible de forma pública: gs://cloud-samples-data/vertex-ai/llm/prompts/landmark2.png con un tipo de MIME de image/png. Para ver esta imagen, abre el archivo de imagen de muestra.

  • TEXT2: Las instrucciones de texto que se incluirán en el mensaje. Por ejemplo, city: Beijing, Landmark: Forbidden City
  • FILE_URI3: El URI de Cloud Storage del archivo que se incluirá en la instrucción. El objeto del bucket debe poder leerse de forma pública o residir en el mismo proyecto de Google Cloud que envía la solicitud. También debes especificar el tipo de medio (mimeType) del archivo.

    Si no tienes un archivo de imagen en Cloud Storage, puedes usar el siguiente archivo disponible de forma pública: gs://cloud-samples-data/vertex-ai/llm/prompts/landmark3.png con un tipo de MIME de image/png. Para ver esta imagen, abre el archivo de imagen de muestra.

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

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

Luego, ejecuta el siguiente comando para enviar tu solicitud de 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

Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

@'
{
  "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

Luego, ejecuta el siguiente comando para enviar tu solicitud de 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

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

Ten en cuenta lo siguiente en la URL para esta muestra:
  • Usa el método generateContent para solicitar que la respuesta se muestre después de que se haya generado por completo. Para reducir la percepción de latencia a un público humano, transmite la respuesta a medida que se genera; para ello, usa el método streamGenerateContent.
  • El ID del modelo multimodal se encuentra al final de la URL antes del método (por ejemplo, gemini-1.5-flash o gemini-1.0-pro-vision). Esta muestra también puede admitir otros modelos.

Console

Para enviar un mensaje multimodal con la consola de Google Cloud, haz lo siguiente:

  1. En la sección Vertex AI de la consola de Google Cloud, ve a la página Vertex AI Studio.

    Ir a Vertex AI Studio

  2. En Diseño de instrucciones (un solo turno), haz clic en Abrir.

  3. Opcional: Configura el modelo y los parámetros:

    • Modelo: Selecciona un modelo.
    • Región: selecciona la región que deseas usar.

    • Temperatura: Usa el control deslizante o el cuadro de texto para ingresar un valor de temperatura.

      La temperatura se usa para las muestras durante la generación de respuesta, que se genera cuando se aplican topP y topK. La temperatura controla el grado de aleatorización en la selección de tokens. Las temperaturas más bajas son buenas para los mensajes que requieren una respuesta menos abierta o de creativa, mientras que las temperaturas más altas pueden generar resultados más diversos o creativos. Una temperatura de 0 significa que siempre se seleccionan los tokens de probabilidad más alta. En este caso, las respuestas para un mensaje determinado son, en su mayoría, deterministas, pero es posible que haya una pequeña cantidad de variación.

      Si el modelo muestra una respuesta demasiado genérica, demasiado corta o el modelo proporciona una respuesta de resguardo, intenta aumentar la temperatura.

    • Límite de tokens de salida: Usa el control deslizante o el cuadro de texto para ingresar un valor para el límite máximo de salida.

      Cantidad máxima de tokens que se pueden generar en la respuesta. Un token tiene casi cuatro caracteres. 100 tokens corresponden a casi 60 u 80 palabras.

      Especifica un valor más bajo para las respuestas más cortas y un valor más alto para las respuestas potencialmente más largas.

    • Agrega una secuencia de detención: Opcional. Ingresa una secuencia de detención, que es una serie de caracteres que incluyen espacios. Si el modelo encuentra una secuencia de detención, la generación de respuesta se detiene. La secuencia de detención no se incluye en la respuesta y puedes agregar hasta cinco secuencias de detención.
  4. Opcional: Para configurar parámetros avanzados, haz clic en Avanzada y establece la configuración de la siguiente manera:

    5. Haz clic para expandir las configuraciones avanzadas.

    • K superior: Usa el control deslizante o el cuadro de texto con el fin de ingresar un valor para K superior. (no es compatible con Gemini 1.5).

      El parámetro Top-K cambia la manera en la que el modelo selecciona los tokens para el resultado. K superior a 1 significa que el siguiente token seleccionado es el más probable entre todos los tokens en el vocabulario del modelo (también llamado decodificación voraz), mientras que el K superior a 3 significa que el siguiente token se selecciona de los tres tokens más probables mediante la temperatura.

      Para cada paso de selección de tokens, se muestran los tokens de K superior con las probabilidades más altas. Luego, los tokens se filtran según el superior con el token final seleccionado mediante el muestreo de temperatura.

      Especifica un valor más bajo para respuestas menos aleatorias y un valor más alto para respuestas más aleatorias.

    • P superior: Usa el control deslizante o el cuadro de texto con el fin de ingresar un valor de P superior. Los tokens se seleccionan del más probable al menos probable hasta que la suma de sus probabilidades sea igual al valor de Top-P. Para obtener los resultados menos variables, establece Top-P como 0.
    • Habilitar fundamentos: Los fundamentos no son compatibles con las instrucciones multimodales.
  5. Para subir contenido multimedia, como archivos PNG, haz lo siguiente:
    1. Haz clic en Insertar medios y selecciona una fuente.

      Si eliges Google Drive como tu fuente, debes elegir una cuenta y dar consentimiento a Vertex AI Studio para acceder a tu cuenta la primera vez que selecciones esta opción. Puedes subir varios archivos multimedia con un tamaño total de hasta 10 MB. Un solo archivo no puede superar los 7 MB.

    2. Haz clic en el archivo que quieras agregar.
    3. Haz clic en Seleccionar.

      La miniatura del archivo se muestra en el panel Instrucción. También se muestra la cantidad total de tokens. Si los datos de la instrucción superan el límite de tokens, los tokens se truncan y no se incluyen en el procesamiento de tus datos.

    4. Opcional: Para mostrar la cantidad de tokens calculados en tus imágenes y la suma de todos los tokens, haz clic en Ver tokens.

      El recuento de tokens puede tardar hasta 15 segundos en calcularse para los archivos multimedia. Las vistas ID de token a texto e ID de token no muestran ningún resultado valioso porque no se admiten tokens multimedia.

      Para cerrar el panel de herramientas del tokenizador, haz clic en X o haz clic fuera del panel.

  6. Ingresa tu mensaje de texto en el panel Mensaje. El modelo usa las instrucciones anteriores como contexto para las respuestas nuevas.
  7. Opcional: Para mostrar la cantidad de tokens calculados en tus imágenes y la suma de todos los tokens, haz clic en Ver tokens. Puedes ver los tokens o los IDs de token de tu mensaje de texto.
    • Para ver los tokens en el mensaje de texto que están destacados con diferentes colores que marcan el límite de cada ID de token, haz clic en ID de token a texto. No se admiten tokens multimedia.
    • Para ver los IDs de los tokens, haz clic en ID de token.

      Para cerrar el panel de herramientas del tokenizador, haz clic en X o haz clic fuera del panel.

  8. Haz clic en Enviar.
  9. Opcional: Para guardar el mensaje en Mis mensajes, haz clic en Guardar.
  10. Opcional: Para obtener el código de Python o un comando curl para tu mensaje, haz clic en Obtener código.
  11. Opcional: Para borrar todos los mensajes anteriores, haz clic en Borrar conversación.

Establece parámetros de modelo

Los siguientes parámetros del modelo se pueden establecer en modelos multimodales:

Top-P

P superior cambia la manera en la que el modelo selecciona tokens para la salida. Los tokens se seleccionan desde el más alto (consulta K superior) hasta el menos probable, hasta que la suma de sus probabilidades sea igual al valor de P superior. Por ejemplo, si los tokens A, B y C tienen una probabilidad de 0.3, 0.2 y 0.1, y el valor P superior es 0.5, el modelo elegirá A o B como el siguiente token mediante la temperatura y excluirá a C como candidato.

Especifica un valor más bajo para respuestas menos aleatorias y un valor más alto para respuestas más aleatorias.

Top-K

El parámetro Top-K cambia la manera en la que el modelo selecciona los tokens para el resultado. K superior a 1 significa que el siguiente token seleccionado es el más probable entre todos los tokens en el vocabulario del modelo (también llamado decodificación voraz), mientras que el K superior a 3 significa que el siguiente token se selecciona de los tres tokens más probables mediante la temperatura.

Para cada paso de selección de tokens, se muestran los tokens de K superior con las probabilidades más altas. Luego, los tokens se filtran según el superior con el token final seleccionado mediante el muestreo de temperatura.

Especifica un valor más bajo para respuestas menos aleatorias y un valor más alto para respuestas más aleatorias.

Temperatura

La temperatura se usa para las muestras durante la generación de respuesta, que se genera cuando se aplican topP y topK. La temperatura controla el grado de aleatorización en la selección de tokens. Las temperaturas más bajas son buenas para los mensajes que requieren una respuesta menos abierta o de creativa, mientras que las temperaturas más altas pueden generar resultados más diversos o creativos. Una temperatura de 0 significa que siempre se seleccionan los tokens de probabilidad más alta. En este caso, las respuestas para un mensaje determinado son, en su mayoría, deterministas, pero es posible que haya una pequeña cantidad de variación.

Si el modelo muestra una respuesta demasiado genérica, demasiado corta o el modelo proporciona una respuesta de resguardo, intenta aumentar la temperatura.

Valores de parámetros válidos

Parámetro Gemini 1.0 Pro Vision Gemini 1.5 Pro Gemini 1.5 Flash
Top-K 1 - 40 (predeterminado 32) No compatible No compatible
Top-P 0 - 1.0 (predeterminado 1.0) 0 - 1.0 (predeterminado 0.95) 0 - 1.0 (predeterminado 0.95)
Temperatura 0 - 1.0 (predeterminado 0.4) 0 - 2.0 (predeterminado 1.0) 0 - 2.0 (predeterminado 1.0)

Requisitos de imagen

Los modelos multimodales de Gemini admiten los siguientes tipos de MIME de imagen:

Tipo MIME de imagen Gemini 1.5 Flash Gemini 1.5 Pro Gemini 1.0 Pro Vision
PNG - image/png
JPEG - image/jpeg

No hay un límite específico para la cantidad de píxeles en una imagen. Sin embargo, las imágenes más grandes se reducen y se rellenan para adaptarse a una resolución máxima de 3,072 x 3,072, a la vez que conservan su relación de aspecto original.

Esta es la cantidad máxima de archivos de imagen permitidos en una solicitud de instrucciones:

  • Gemini 1.0 Pro Vision: 16 imágenes
  • Gemini 1.5 Flash y Gemini 1.5 Pro: 3,000 imágenes

A continuación, se explica cómo se calculan los tokens para las imágenes:

  • Gemini 1.0 Pro Vision: cada imagen representa 258 tokens.
  • Gemini 1.5 Flash y Gemini 1.5 Pro:
    • Si ambas dimensiones de una imagen son menores o iguales que 384 píxeles, se usan 258 tokens.
    • Si una dimensión de una imagen es superior a 384 píxeles, la imagen se corta en mosaicos. El tamaño de cada mosaico se establece de forma predeterminada en la dimensión más pequeña (ancho o alto) dividida por 1.5. Si es necesario, cada mosaico se ajusta para que no sea inferior a 256 píxeles ni mayor que 768 píxeles. Luego, cada tarjeta cambia de tamaño a 768 × 768 y usa 258 tokens.

Prácticas recomendadas

Cuando uses imágenes, usa la siguiente información y prácticas recomendadas para obtener los mejores resultados.

  • Si deseas detectar texto en una imagen, usa mensajes con una sola imagen para producir mejores resultados que los mensajes con varias imágenes.
  • Si la instrucción contiene una sola imagen, colócala antes de la instrucción de texto en tu solicitud.
  • Si tu instrucción contiene varias imágenes y quieres consultarlas más adelante en la instrucción o hacer que el modelo haga referencia a ellas en la respuesta del modelo, puede ser útil darle a cada imagen un índice antes de que aparezca. Usa a b c or image 1 image 2 image 3 para tu índice. El siguiente es un ejemplo del uso de imágenes indexadas en un mensaje: 
    image 1 
image 2 
image 3 

Write a blogpost about my day using image 1 and image 2. Then, give me ideas
for tomorrow based on image 3.
  • Usa imágenes con mayor resolución, ya que producen mejores resultados.
  • Incluye algunos ejemplos en el mensaje.
  • Rota las imágenes a su orientación adecuada antes de agregarlas al mensaje.
  • Evita las imágenes borrosas.

Limitaciones

Si bien los modelos multimodales de Gemini son potentes en muchos casos de usuarios multimodales, es importante comprender las limitaciones de los modelos:

  • Moderación de contenido: Los modelos se niegan a proporcionar respuestas en las imágenes que infringen nuestras políticas de seguridad.
  • Razonamiento espacial: Los modelos no son precisos para ubicar texto u objetos en imágenes. Es posible que solo devuelvan los recuentos aproximados de los objetos.
  • Usos médicos: Los modelos no son adecuados para interpretar imágenes médicas (por ejemplo, radiografías y TC) ni brindar asesoramiento médico.
  • Reconocimiento de personas: Los modelos no están diseñados para identificar a personas que no son celebridades en las imágenes.
  • Exactitud: Los modelos pueden tener alucinaciones o cometer errores cuando se interpretan imágenes de baja calidad, rotadas o muy baja resolución. Los modelos también pueden tener alucinaciones cuando se interpreta texto escrito a mano en documentos de imágenes.

¿Qué sigue?