Envía solicitudes de mensajes multimodales

La familia de modelos de Gemini incluye modelos que funcionan con solicitudes de instrucciones multimodales. El término multimodal indica que puedes usar más de una modalidad, o tipo de entrada, en una instrucción. Los modelos que no son multimodales aceptan instrucciones solo con texto. Las modalidades pueden incluir texto, audio, video y mucho más.

Hay varias formas de implementar soluciones multimodales con la API de Gemini, incluidos los SDK de Python, Node.js, Java y Go, la consola de Google Cloud y la API de REST. En las muestras de código que aparecen más adelante en este documento, se demuestra cómo crear soluciones multimodales con estas opciones.

Los modelos multimodales de Gemini son los siguientes:

Gemini 1.0 Pro Vision
Gemini 1.5 Pro (Versión preliminar)

En la siguiente tabla, se indica con qué modalidades funciona cada API de Gemini multimodal en una solicitud de instrucciones.

Modelo	Texto	Código	Imágenes	Audio	Video	Video/audio	PDF
Gemini 1.0 Pro
Gemini 1.0 Pro Vision
Gemini 1.5 Pro (Versión preliminar)

Para explorar modelos multimodales en la consola de Google Cloud, selecciona la tarjeta de modelo gemini-1.0-pro-vision o gemini-1.5-pro en Model Garden.

Ir a Model Garden

Para obtener una lista de los idiomas compatibles con los modelos de Gemini, consulta en la información del modelo los Idiomas admitidos. 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 para dispositivos móviles, consulta los SDK de IA de Google para Android, Swift y Web.

Diferencias del modelo multimodal

Las diferencias entre los modelos multimodales de Gemini se especifican en las siguientes tablas. Puedes usar esta información para decidir qué modelo es mejor para ti.

Texto

A continuación, se muestran algunas de las diferencias en la modalidad de texto entre los modelos multimodales de Gemini:

Modelo	Detalles de la modalidad de texto
Gemini 1.0 Pro Vision	La cantidad máxima de tokens es 16,384 o un libro de alrededor de 128 páginas suponiendo 250 palabras por página. Este máximo incluye tokens de entrada y salida. La cantidad máxima de tokens de salida es 2,048.
Gemini 1.5 Pro (Versión preliminar)	La longitud del contexto es de 1 millón de tokens, lo que equivale a aproximadamente un libro de 4,000 páginas. Esto permite que el modelo genere texto de formato largo, como libros, varios archivos PDF o manuales de usuario.

Código

A continuación, se muestran algunas de las diferencias entre los modelos multimodales de Gemini cuando se trabaja con código:

Modelo	Detalles de la modalidad de código
Gemini 1.0 Pro Vision	La cantidad máxima de tokens es 16,384 o un libro de alrededor de 128 páginas suponiendo 250 palabras por página. Este máximo incluye tokens de entrada y salida. La cantidad máxima de tokens de salida es 2,048.
Gemini 1.5 Pro (Versión preliminar)	La longitud del contexto es de 1 millón de tokens, lo que permite que el modelo funcione con una base de código completa o con una base de código de la aplicación completa.

De imagen

A continuación, se muestran algunas de las diferencias en la modalidad de imagen entre los modelos multimodales de Gemini:

Modelo	Detalles de la modalidad de imagen
Gemini 1.0 Pro Vision	La cantidad máxima de imágenes por instrucción es de 16.
Gemini 1.5 Pro (Versión preliminar)	La cantidad máxima de imágenes por instrucción es de 3,000.

Audio (solo voz)

A continuación, se muestran algunas de las diferencias en la modalidad de audio entre los modelos multimodales de Gemini:

Modelo	Detalles de la modalidad de audio
Gemini 1.0 Pro Vision	No se admite el audio.
Gemini 1.5 Pro (Versión preliminar)	La cantidad máxima de horas de audio por instrucción es de aproximadamente 8.4 horas o hasta 1 millón de tokens. La voz se puede comprender para el resumen de audio, la transcripción y la traducción.

Video

A continuación, se muestran algunas de las diferencias en la modalidad de video entre los modelos multimodales de Gemini:

Modelo	Detalles de la modalidad de video
Gemini 1.0 Pro Vision	La duración máxima del video es de 2 minutos. La cantidad máxima de videos por instrucción es 1. Se ignorará el audio en el video.
Gemini 1.5 Pro (Versión preliminar)	La duración máxima del video si incluye audio es de aproximadamente 50 minutos. La duración máxima de video sin audio es de 1 hora. La cantidad máxima de videos por instrucción es de 10. El modelo puede usar datos de video y audio para responder a la instrucción. Por ejemplo, resume el video usando el contenido visual y la voz.

PDF

A continuación, se muestran algunas de las diferencias en la modalidad PDF entre los modelos multimodales de Gemini:

Modelo	Detalles de la modalidad PDF
Gemini 1.0 Pro Vision	La cantidad máxima de páginas por instrucción es 16. El tamaño máximo del archivo para un PDF es de 50 MB.
Gemini 1.5 Pro (Versión preliminar)	La cantidad máxima de páginas por instrucción es de 300. El tamaño máximo del archivo para un PDF es de 50 MB.

Guía de inicio rápido

Usa las siguientes muestras de código para comenzar a usar la API de Gemini. En cada muestra de código, se demuestra que funciona con una modalidad diferente. Algunas muestras de código de este documento funcionan con todos los modelos multimodales de Gemini, y otras solo funcionan con Gemini 1.5 Pro (versión preliminar). Cada muestra de código especifica con qué modelos funciona.

Para probar y, luego, iterar las instruccines multimodales, recomendamos usar la consola de Google Cloud. Para enviar instrucciones de manera programática al modelo, puedes usar la API de REST, el SDK de Vertex AI para Python o una de las otras bibliotecas y SDK compatibles que se muestran en las siguientes pestañas.

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 una respuesta de transmisión o una respuesta sin transmisión. La transmisión implica recibir respuestas a las instrucciones a medida que se generan. Es decir, en cuanto el modelo genere tokens de salida, estos se enviarán. Una respuesta a los mensajes sin transmisión se envía solo 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

# Initialize Vertex AI
vertexai.init(project=project_id, location=location)

# Load the model
model = GenerativeModel(model_name="gemini-1.0-pro-vision-001")

# Load example image
image_url = "gs://generativeai-downloads/images/scones.jpg"
image_content = Part.from_uri(image_url, "image/jpeg")

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

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

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.0-pro-vision',
  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);
}

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.

Respuestas de transmisión y sin transmisión

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

  public ResponseStream 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.0-pro-vision";
    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/jpg", imageBytes)
          ));

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

REST

Puedes usar REST para probar un mensaje de texto mediante la API de Vertex AI a fin de enviar una solicitud POST al extremo del modelo del publicador.

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

GENERATE_RESPONSE_METHOD: El tipo de respuesta que quieres que genere el modelo. Elige un método que genere cómo quieres que se muestre la respuesta del modelo:
- streamGenerateContent: La respuesta se transmite a medida que se genera para reducir la percepción de latencia para un público humano.
- generateContent: La respuesta se muestra después de que se genera por completo.
LOCATION: La región para procesar la solicitud. Las opciones disponibles incluyen las siguientes:
Haz clic para expandir las regiones disponibles.
- us-central1
- us-west4
- northamerica-northeast1
- us-east4
- us-west1
- asia-northeast3
- asia-southeast1
- asia-northeast1
PROJECT_ID: El ID del proyecto.
MODEL_ID: el ID del modelo multimodal que deseas usar. Las opciones son las siguientes:
- gemini-1.0-pro-vision
ROLE: el rol en una conversación asociada con el contenido. Especificar un rol es obligatorio incluso en casos de uso de un solo turno. Los valores aceptables son los siguientes:
- USER: especifica el contenido que envías.
TEXT: las instrucciones de texto que se incluirán en el mensaje.
B64_BASE: La codificación en base64 de la imagen o el video que se incluirá intercalada en el mensaje. Cuando incluyas contenido multimedia Dintercalado, también debes especificar MIMETYPE.
FILE_URI: el URI de Cloud Storage de la imagen o el video que se incluirá en el mensaje. El bucket que almacena el archivo debe estar en el mismo proyecto de Google Cloud que envía la solicitud. También debes especificar MIMETYPE.
MIME_TYPE: el tipo de medio de la imagen o el video especificados 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
SAFETY_CATEGORY: la categoría de seguridad para la que se configura un umbral. Los valores aceptables son los siguientes:
Haz clic para expandir las categorías de seguridad
- HARM_CATEGORY_SEXUALLY_EXPLICIT
- HARM_CATEGORY_HATE_SPEECH
- HARM_CATEGORY_HARASSMENT
- HARM_CATEGORY_DANGEROUS_CONTENT
THRESHOLD: el umbral para bloquear respuestas que podrían pertenecer a la categoría de seguridad especificada según la probabilidad. Los valores aceptables son los siguientes:
Haz clic para expandir los umbrales de bloqueo
- BLOCK_NONE
- BLOCK_ONLY_HIGH
- BLOCK_MEDIUM_AND_ABOVE (predeterminada)
- BLOCK_LOW_AND_ABOVE
BLOCK_LOW_AND_ABOVE bloquea más, mientras que BLOCK_ONLY_HIGH bloquea menos.
TEMPERATURE: 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.
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: K superior 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.
MAX_OUTPUT_TOKENS: Cantidad máxima de tokens que se pueden generar en la respuesta. Un token tiene aproximadamente 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.
STOP_SEQUENCES: especifica una lista de cadenas que le indica al modelo que deje de generar texto si se encuentra una de las cadenas en la respuesta. Si una cadena aparece varias veces en la respuesta, la respuesta trunca el lugar en que se encontró por primera vez. Las cadenas distinguen entre mayúsculas y minúsculas.

Por ejemplo, si la siguiente es la respuesta que se muestra cuando no se especifica stopSequences:

public static string reverse(string myString)

Luego, la respuesta que se muestra con stopSequences configurada como ["Str", "reverse"] es la siguiente:

public static string

HTTP method and URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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

PowerShell

Nota: El siguiente comando supone que accediste a la CLI de gcloud con tu cuenta de usuario mediante la ejecución de gcloud init o gcloud auth login. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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

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

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

Respuesta

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " Yes the animal in the picture is a cat."
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 263,
    "candidatesTokenCount": 10,
    "totalTokenCount": 273
  }
}

Ejemplo del comando curl

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

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

PDF único

En la siguiente pestaña, se muestra cómo incluir un PDF en una solicitud de instrucción mediante el SDK de Python. Esta muestra de PDF funciona con todos los modelos multimodales de Gemini.

Python

Respuestas de transmisión y sin transmisión

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 and un-comment below lines
# project_id = "PROJECT_ID"

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

model = GenerativeModel(model_name="gemini-1.5-pro-preview-0409")

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

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

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

Video único

En cada una de las siguientes pestañas, se muestra una manera diferente de incluir un video en una solicitud de instrucciones. Estas muestras de PDF funcionan con todos los modelos multimodales de Gemini.

Python

Respuestas de transmisión y sin transmisión

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

# Initialize Vertex AI
vertexai.init(project=project_id, location=location)
# Load the model
vision_model = GenerativeModel(model_name="gemini-1.0-pro-vision-001")
# Generate text
response = vision_model.generate_content(
    [
        Part.from_uri(
            "gs://cloud-samples-data/video/animals.mp4", mime_type="video/mp4"
        ),
        "What is in the video?",
    ]
)
print(response)

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI C#.


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

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

        // Prompt
        string prompt = "What's in the video?";
        string videoUri = "gs://cloud-samples-data/video/animals.mp4";

        // Initialize request argument(s)
        var content = new Content
        {
            Role = "USER"
        };
        content.Parts.AddRange(new List<Part>()
        {
            new() {
                Text = prompt
            },
            new() {
                FileData = new() {
                    MimeType = "video/mp4",
                    FileUri = videoUri
                }
            }
        });

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}"
        };
        generateContentRequest.Contents.Add(content);

        // 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();
    }
}

Node.js

Respuestas de transmisión y sin transmisión

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 sendMultiModalPromptWithVideo(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

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

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

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

  console.log(fullTextResponse);
}

Java

Respuestas de transmisión y sin transmisión

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

  public ResponseStream 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.io.IOException;

public class MultimodalVideoInput {

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

    multimodalVideoInput(projectId, location, modelName);
  }

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

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

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

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 Vertex para Go de Vertex AI para Gemini.

Respuestas de transmisión y sin transmisión

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"
	"errors"
	"fmt"
	"io"
	"mime"
	"path/filepath"

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

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

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

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

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

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

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

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

REST

Puedes usar REST para probar un mensaje de texto mediante la API de Vertex AI a fin de enviar una solicitud POST al extremo del modelo del publicador.

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

GENERATE_RESPONSE_METHOD: El tipo de respuesta que quieres que genere el modelo. Elige un método que genere cómo quieres que se muestre la respuesta del modelo:
- streamGenerateContent: La respuesta se transmite a medida que se genera para reducir la percepción de latencia para un público humano.
- generateContent: La respuesta se muestra después de que se genera por completo.
LOCATION: La región para procesar la solicitud. Las opciones disponibles incluyen las siguientes:
Haz clic para expandir las regiones disponibles.
- us-central1
- us-west4
- northamerica-northeast1
- us-east4
- us-west1
- asia-northeast3
- asia-southeast1
- asia-northeast1
PROJECT_ID: El ID del proyecto.
MODEL_ID: el ID del modelo multimodal que deseas usar. Las opciones son las siguientes:
- gemini-1.0-pro-vision
ROLE: el rol en una conversación asociada con el contenido. Especificar un rol es obligatorio incluso en casos de uso de un solo turno. Los valores aceptables son los siguientes:
- USER: especifica el contenido que envías.
TEXT: las instrucciones de texto que se incluirán en el mensaje.
B64_BASE: La codificación en base64 de la imagen o el video que se incluirá intercalada en el mensaje. Cuando incluyas contenido multimedia Dintercalado, también debes especificar MIMETYPE.
FILE_URI: el URI de Cloud Storage de la imagen o el video que se incluirá en el mensaje. El bucket que almacena el archivo debe estar en el mismo proyecto de Google Cloud que envía la solicitud. También debes especificar MIMETYPE.
MIME_TYPE: el tipo de medio de la imagen o el video especificados 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
SAFETY_CATEGORY: la categoría de seguridad para la que se configura un umbral. Los valores aceptables son los siguientes:
Haz clic para expandir las categorías de seguridad
- HARM_CATEGORY_SEXUALLY_EXPLICIT
- HARM_CATEGORY_HATE_SPEECH
- HARM_CATEGORY_HARASSMENT
- HARM_CATEGORY_DANGEROUS_CONTENT
THRESHOLD: el umbral para bloquear respuestas que podrían pertenecer a la categoría de seguridad especificada según la probabilidad. Los valores aceptables son los siguientes:
Haz clic para expandir los umbrales de bloqueo
- BLOCK_NONE
- BLOCK_ONLY_HIGH
- BLOCK_MEDIUM_AND_ABOVE (predeterminada)
- BLOCK_LOW_AND_ABOVE
BLOCK_LOW_AND_ABOVE bloquea más, mientras que BLOCK_ONLY_HIGH bloquea menos.
TEMPERATURE: 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.
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: K superior 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.
MAX_OUTPUT_TOKENS: Cantidad máxima de tokens que se pueden generar en la respuesta. Un token tiene aproximadamente 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.
STOP_SEQUENCES: especifica una lista de cadenas que le indica al modelo que deje de generar texto si se encuentra una de las cadenas en la respuesta. Si una cadena aparece varias veces en la respuesta, la respuesta trunca el lugar en que se encontró por primera vez. Las cadenas distinguen entre mayúsculas y minúsculas.

Por ejemplo, si la siguiente es la respuesta que se muestra cuando no se especifica stopSequences:

public static string reverse(string myString)

Luego, la respuesta que se muestra con stopSequences configurada como ["Str", "reverse"] es la siguiente:

public static string

HTTP method and URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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

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

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

Respuesta

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " Yes the animal in the picture is a cat."
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 263,
    "candidatesTokenCount": 10,
    "totalTokenCount": 273
  }
}

Ejemplo del comando curl

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

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

Consola

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

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
En Prompt design (single turn), haz clic en Abrir.
Configura el modelo y los parámetros:
- Región: selecciona la región que deseas usar.
- Modelo: selecciona Gemini Pro Vision.
- 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 token: Usa el control deslizante o el cuadro de texto con el fin de 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.
- Agregar una secuencia de detención: ingresa una secuencia de detención, que es una serie de caracteres (incluidos los espacios) que detiene la generación de respuesta si el modelo la encuentra. La secuencia no se incluye como parte de la respuesta. Puedes agregar hasta cinco secuencias de detención.
Opcional: Para configurar parámetros avanzados, haz clic en Avanzada y establece la configuración de la siguiente manera:

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.
K superior cambia la manera en que el modelo selecciona tokens para la salida. 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.

La consola de Google Cloud solo admite la transmisión, lo que implica recibir respuestas a las instrucciones a medida que se generan. Estás listo para ingresar un mensaje en el cuadro de mensaje para iniciar una conversación con el modelo.

El modelo usa los mensajes anteriores como contexto para las respuestas nuevas. Para incluir una imagen, PDF o un video en el mensaje, haz clic en el ícono .

Para obtener información sobre los mensajes multimodales, consulta Diseña mensajes multimodales.
Opcional: Para guardar el mensaje en Mis mensajes, haz clic en Guardar.
Opcional: Para obtener el código de Python o un comando curl para tu mensaje, haz clic en Obtener código.
Opcional: Para borrar todos los mensajes anteriores, haz clic en Borrar conversación .

Audio único

A continuación, se muestra cómo usar un archivo de audio para resumir un podcast. Esta muestra solo funciona con Gemini 1.5 Pro (versión preliminar).

Python

Respuestas de transmisión y sin transmisión

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 and un-comment below lines
  # project_id = "PROJECT_ID"

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

  model = GenerativeModel(model_name="gemini-1.5-pro-preview-0409")

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

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

  contents = [audio_file, prompt]

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

Muestras avanzadas

Los siguientes ejemplos son más complejos que los ejemplos anteriores.

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. Estas muestras de imágenes funcionan con todos los modelos multimodales de Gemini.

Python

Respuestas de transmisión y sin transmisión

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 http.client
import typing
import urllib.request
import vertexai

from vertexai.generative_models import GenerativeModel, Image

# Initialize Vertex AI
vertexai.init(project=project_id, location=location)

# create helper function
def load_image_from_url(image_url: str) -> Image:
    with urllib.request.urlopen(image_url) as response:
        response = typing.cast(http.client.HTTPResponse, response)
        image_bytes = response.read()
    return Image.from_bytes(image_bytes)

# Load images from Cloud Storage URI
landmark1 = load_image_from_url(
    "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png"
)
landmark2 = load_image_from_url(
    "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png"
)
landmark3 = load_image_from_url(
    "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png"
)

# Pass multimodal prompt
model = GenerativeModel(model_name="gemini-1.0-pro-vision-001")
response = model.generate_content(
    [
        landmark1,
        "city: Rome, Landmark: the Colosseum",
        landmark2,
        "city: Beijing, Landmark: Forbidden City",
        landmark3,
    ]
)
print(response)

C#


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

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

        // Images
        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");

        // Initialize request argument(s)
        var content = new Content
        {
            Role = "USER"
        };
        content.Parts.AddRange(new List<Part>()
        {
            new()
            {
                InlineData = new()
                {
                    MimeType = "image/png",
                    Data = colosseum

                }
            },
            new()
            {
                Text = "city: Rome, Landmark: the Colosseum"
            },
            new()
            {
                InlineData = new()
                {
                    MimeType = "image/png",
                    Data = forbiddenCity
                }
            },
            new()
            {
                Text = "city: Beijing, Landmark: Forbidden City"
            },
            new()
            {
                InlineData = new()
                {
                    MimeType = "image/png",
                    Data = christRedeemer
                }
            }
        });

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}"
        };
        generateContentRequest.Contents.Add(content);

        // 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();
    }

    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);
    }
}

Node.js

Respuestas de transmisión y sin transmisión

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.0-pro-vision'
) {
  // 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);
}

Java

Respuestas de transmisión y sin transmisión

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

  public ResponseStream 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.0-pro-vision";

    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);
    }
  }
}

Go

Respuestas de transmisión y sin transmisión

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"
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"

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

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

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

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

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

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

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

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

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

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

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

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

	return nil
}

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

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

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

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

REST

Puedes usar REST para probar un mensaje de texto mediante la API de Vertex AI a fin de enviar una solicitud POST al extremo del modelo del publicador.

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

GENERATE_RESPONSE_METHOD: El tipo de respuesta que quieres que genere el modelo. Elige un método que genere cómo quieres que se muestre la respuesta del modelo:
- streamGenerateContent: La respuesta se transmite a medida que se genera para reducir la percepción de latencia para un público humano.
- generateContent: La respuesta se muestra después de que se genera por completo.
LOCATION: La región para procesar la solicitud. Las opciones disponibles incluyen las siguientes:
Haz clic para expandir las regiones disponibles.
- us-central1
- us-west4
- northamerica-northeast1
- us-east4
- us-west1
- asia-northeast3
- asia-southeast1
- asia-northeast1
PROJECT_ID: El ID del proyecto.
MODEL_ID: el ID del modelo multimodal que deseas usar. Las opciones son las siguientes:
- gemini-1.0-pro-vision
ROLE: el rol en una conversación asociada con el contenido. Especificar un rol es obligatorio incluso en casos de uso de un solo turno. Los valores aceptables son los siguientes:
- USER: especifica el contenido que envías.
TEXT: las instrucciones de texto que se incluirán en el mensaje.
B64_BASE: La codificación en base64 de la imagen o el video que se incluirá intercalada en el mensaje. Cuando incluyas contenido multimedia Dintercalado, también debes especificar MIMETYPE.
FILE_URI: el URI de Cloud Storage de la imagen o el video que se incluirá en el mensaje. El bucket que almacena el archivo debe estar en el mismo proyecto de Google Cloud que envía la solicitud. También debes especificar MIMETYPE.
MIME_TYPE: el tipo de medio de la imagen o el video especificados 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
SAFETY_CATEGORY: la categoría de seguridad para la que se configura un umbral. Los valores aceptables son los siguientes:
Haz clic para expandir las categorías de seguridad
- HARM_CATEGORY_SEXUALLY_EXPLICIT
- HARM_CATEGORY_HATE_SPEECH
- HARM_CATEGORY_HARASSMENT
- HARM_CATEGORY_DANGEROUS_CONTENT
THRESHOLD: el umbral para bloquear respuestas que podrían pertenecer a la categoría de seguridad especificada según la probabilidad. Los valores aceptables son los siguientes:
Haz clic para expandir los umbrales de bloqueo
- BLOCK_NONE
- BLOCK_ONLY_HIGH
- BLOCK_MEDIUM_AND_ABOVE (predeterminada)
- BLOCK_LOW_AND_ABOVE
BLOCK_LOW_AND_ABOVE bloquea más, mientras que BLOCK_ONLY_HIGH bloquea menos.
TEMPERATURE: 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.
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: K superior 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.
MAX_OUTPUT_TOKENS: Cantidad máxima de tokens que se pueden generar en la respuesta. Un token tiene aproximadamente 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.
STOP_SEQUENCES: especifica una lista de cadenas que le indica al modelo que deje de generar texto si se encuentra una de las cadenas en la respuesta. Si una cadena aparece varias veces en la respuesta, la respuesta trunca el lugar en que se encontró por primera vez. Las cadenas distinguen entre mayúsculas y minúsculas.

Por ejemplo, si la siguiente es la respuesta que se muestra cuando no se especifica stopSequences:

public static string reverse(string myString)

Luego, la respuesta que se muestra con stopSequences configurada como ["Str", "reverse"] es la siguiente:

public static string

HTTP method and URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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

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

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

Respuesta

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " Yes the animal in the picture is a cat."
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 263,
    "candidatesTokenCount": 10,
    "totalTokenCount": 273
  }
}

Ejemplo del comando curl

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

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

Consola

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

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
En Prompt design (single turn), haz clic en Abrir.
Configura el modelo y los parámetros:
- Región: selecciona la región que deseas usar.
- Modelo: selecciona Gemini Pro Vision.
- 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 token: Usa el control deslizante o el cuadro de texto con el fin de 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.
- Agregar una secuencia de detención: ingresa una secuencia de detención, que es una serie de caracteres (incluidos los espacios) que detiene la generación de respuesta si el modelo la encuentra. La secuencia no se incluye como parte de la respuesta. Puedes agregar hasta cinco secuencias de detención.
Opcional: Para configurar parámetros avanzados, haz clic en Avanzada y establece la configuración de la siguiente manera:

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.
K superior cambia la manera en que el modelo selecciona tokens para la salida. 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.

La consola de Google Cloud solo admite la transmisión, lo que implica recibir respuestas a las instrucciones a medida que se generan. Estás listo para ingresar un mensaje en el cuadro de mensaje para iniciar una conversación con el modelo.

El modelo usa los mensajes anteriores como contexto para las respuestas nuevas. Para incluir una imagen, PDF o un video en el mensaje, haz clic en el ícono .

Para obtener información sobre los mensajes multimodales, consulta Diseña mensajes multimodales.
Opcional: Para guardar el mensaje en Mis mensajes, haz clic en Guardar.
Opcional: Para obtener el código de Python o un comando curl para tu mensaje, haz clic en Obtener código.
Opcional: Para borrar todos los mensajes anteriores, haz clic en Borrar conversación .

Audio con marcas de tiempo

A continuación, se muestra cómo usar un archivo de audio para generar una transcripción de podcast con marcas de tiempo. Esta muestra solo funciona con Gemini 1.5 Pro (versión preliminar).

import vertexai
from vertexai.generative_models import GenerativeModel, Part

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

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

model = GenerativeModel("gemini-1.5-pro-preview-0409")

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

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

contents = [audio_file, prompt]

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

Video con audio

A continuación, se muestra cómo resumir un archivo de video con audio y mostrar capítulos con marcas de tiempo. Esta muestra solo funciona con Gemini 1.5 Pro (versión preliminar).

Python

Respuestas de transmisión y sin transmisión

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 and un-comment below lines
  # project_id = "PROJECT_ID"

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

  model = GenerativeModel(model_name="gemini-1.5-pro-preview-0409")

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

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

  contents = [video_file, prompt]

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

Todas las modalidades

A continuación, se muestra cómo procesar imágenes, video, audio y texto al mismo tiempo. Esta muestra solo funciona con Gemini 1.5 Pro (versión preliminar).

Python

Respuestas de transmisión y sin transmisión

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 and un-comment below lines
  # project_id = "PROJECT_ID"

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

  model = GenerativeModel(model_name="gemini-1.5-pro-preview-0409")

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

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

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

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

  contents = [
      video_file,
      image_file,
      prompt,
  ]

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

Establece parámetros de modelo

Los siguientes parámetros de 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 K superior 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 (Versión preliminar)
Top-K	1 - 40 (predeterminado 32)	No compatible
Top-P	0 - 1.0 (predeterminado 1.0)	0 - 1.0 (predeterminado 0.95)
Temperatura	0 - 1.0 (predeterminado 0.4)	0 - 2.0 (predeterminado 1.0)

Requisitos para el contenido multimedia

Cuando uses un archivo multimedia en las solicitudes de instrucciones, asegúrate de que cumpla con los siguientes requisitos:

Requisitos de imagen

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.

En el caso de Gemini 1.0 Pro Vision, cada imagen representa 258 tokens.

Para Gemini 1.5 Pro (versión preliminar):

Las imágenes con una relación de aspecto menor que 1.2 o con la dimensión más larga menor que 768 representan 258 tokens.
Las imágenes con la dimensión más larga mayor que 768 y una relación de aspecto superior a 1.2 se representan con mosaicos cuadrados que se separan de manera uniforme en la dimensión más larga. Los mosaicos se usan con la imagen original para representar la imagen en Gemini. Cada mosaico representa 258 tokens. Por ejemplo, para las imágenes con una resolución de 1,000 x 2,000, se usan tokens de 258 x 3 = 774 (1 para la imagen original y 2 para los mosaicos cuadrados de 1,000 x 1,000).

La cantidad máxima de imágenes que pueden aparecer en una solicitud de instrucciones es la siguiente:

16 para Gemini 1.0 Pro Vision
3,000 para Gemini 1.5 Pro (versión preliminar)

Requisitos de audio

Gemini 1.5 Pro (versión preliminar) es compatible con los siguientes tipos de MIME de audio. Gemini 1.0 Pro Vision no es compatible con audio.

audio/mp3
audio/wav

Requisitos de video

Los videos se muestrean a 1 FPS. Cada marco de video representa 258 tokens.

Solo para Gemini 1.5 Pro (versión preliminar), la pista de audio se codifica con fotogramas de video. La pista de audio también se desglosa en enlaces troncales de 1 segundo, cada uno de los cuales tiene 32 tokens. El fotograma y los tokens de audio se intercalan junto con sus marcas de tiempo. Las marcas de tiempo se representan como 7 tokens.

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

Tipo de MIME de video	Gemini 1.0 Pro Vision	Gemini 1.5 Pro (Versión preliminar)
MOV - `video/mov`
MPEG - `video/mpeg`
MP4 - `video/mp4`
MPG - `video/mpg`
AVI - `video/avi`
WMV - `video/wmv`
MPEGPS - `video/mpegps`
FLS - `video/flv`

Requisitos de PDF

El tipo de MIME requerido para un PDF es application/pdf.

prácticas recomendadas

En esta sección, se incluyen prácticas recomendadas para diferentes modalidades.

Prácticas recomendadas para las imágenes

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

Usa instrucciones con una sola imagen para producir mejores resultados que las instrucciones con varias imágenes cuando desees detectar texto en una imagen.
Si la instrucción contiene una sola imagen, colócala antes de la instrucción de texto.
Si hay varias imágenes en el mensaje y quieres consultarlas más tarde en el mensaje 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 o 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 <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.
```
Las imágenes con mayor resolución 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.

Prácticas recomendadas para videos

Cuando uses videos, usa la siguiente información y prácticas recomendadas para obtener los mejores resultados:

Usa no más de un video por instrucción.
Si la instrucción contiene un solo video, colócalo antes de la instrucción de texto.
Si usas Gemini 1.0 Pro Vision, el modelo procesa los videos como marcos de imagen no contiguos del video. No se incluye el audio. Si notas que al modelo le falta contenido del video, intenta acortarlo para que el modelo capture una mayor parte del contenido del video.
Si usas Gemini 1.0 Pro Vision, solo se procesa la información de los primeros dos minutos.
Si usas Gemini 1.0 Pro Vision, no se analiza la información de audio ni los metadatos de marca de tiempo. Debido a esto, es posible que el modelo no funcione bien en casos de uso que requieran entrada de audio, como audio de subtítulos, o información relacionada con el tiempo, como la velocidad o el ritmo.
Cuando se necesite la localización de marca de tiempo en un video con audio, pídele al modelo que genere marcas de tiempo en el formato MM:SS, en el que los dos primeros dígitos representan minutos y los dos últimos dígitos representan segundos. Usa el mismo formato para las preguntas que se hacen sobre una marca de tiempo.

Prácticas recomendadas para PDF

Cuando uses archivos PDF, usa la siguiente información y prácticas recomendadas para obtener los mejores resultados:

Los PDF se tratan como imágenes, por lo que una sola página de un PDF se considera una sola imagen.
- La cantidad de páginas admitidas se limita a la cantidad de imágenes que admite un modelo. Para Gemini 1.0 Pro Vision, el límite es de 16. Para Gemini 1.5 Pro, el límite es de 300. Si tienes un documento largo, considera dividirlo en varios archivos PDF para procesarlo.
- Cuando se usan archivos PDF como entrada, el costo sigue los precios de las imágenes de Gemini. Por ejemplo, si incluyes un PDF de dos páginas en una llamada a la API de Gemini, se te cobrará una tarifa de entrada por procesar dos imágenes.
Si tu instrucción contiene un solo PDF, colócalo antes de la instrucción de texto.
Usa archivos PDF creados con texto procesado como texto en lugar de usar texto en imágenes analizadas. Este formato garantiza que el texto sea legible para las máquinas, de modo que sea más fácil para el modelo editar, buscar y manipular en comparación con los PDF de las imágenes escaneadas. Esta práctica proporciona resultados óptimos cuando se trabaja con documentos con mucho texto, como los contratos.

Para obtener más sugerencias de mensajes multimodales, consulta Diseña mensajes multimodales.

Limitaciones multimodales

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

Razonamiento espacial: Los modelos no son precisos para ubicar texto u objetos en imágenes y PDF. Solo pueden mostrar los recuentos aproximados de objetos.
Usos médicos: los modelos no son adecuados para interpretar imágenes médicas (por ejemplo, radiografías y TC) ni proporcionar asesoramiento médico.
Reconocimiento de personas: Los modelos no están diseñados para usarse para identificar a personas que no son celebridades en imágenes.
Moderación de contenido: Los modelos se niegan a proporcionar respuestas en las imágenes o los videos que infringen nuestras políticas de seguridad.
Exactitud: Los modelos pueden alucinar o cometer errores cuando interpretan imágenes de baja calidad, rotadas o con muy baja resolución. Los modelos también pueden tener alucinaciones cuando se interpreta texto escrito a mano en imágenes o documentos PDF.
Reconocimiento de sonido sin voz: los modelos que admiten audio pueden cometer errores que reconozcan un sonido que no es una voz.
Movimiento de alta velocidad: Debido a la tasa de muestreo fija de 1 fotograma por segundo (fps), los modelos pueden cometer errores para comprender el movimiento de alta velocidad en videos.

¿Qué sigue?

Aprende a enviar solicitudes de mensaje de chat.
Obtén información sobre las prácticas recomendadas de IA responsable y los filtros de seguridad de Vertex AI.