Se usó la API de Cloud Translation para traducir esta página.

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.5 Flash
Gemini 1.5 Pro
Gemini 1.0 Pro Vision

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.5 Flash
Gemini 1.5 Pro
Gemini 1.0 Pro Vision
Gemini 1.0 Pro

Para explorar un modelo multimodal en la consola de Google Cloud, selecciona su tarjeta del modelo en 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.5 Flash, Gemini 1.5 Pro	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.
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.

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.5 Flash, Gemini 1.5 Pro	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.
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.

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.5 Flash, Gemini 1.5 Pro	La cantidad máxima de imágenes por instrucción es de 3,000.
Gemini 1.0 Pro Vision	La cantidad máxima de imágenes por instrucción es de 16.

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.5 Flash, Gemini 1.5 Pro	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.
Gemini 1.0 Pro Vision	No se admite el audio.

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.5 Flash, Gemini 1.5 Pro	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, puede resumir un video usando tanto el contenido visual como la voz del 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.

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.5 Flash, Gemini 1.5 Pro	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 30 MB.
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 30 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. 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

En las muestras de código, se explica cómo identificar el contenido de una imagen.

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

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

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

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

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

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

Java

Antes de 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

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-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.

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.5-flash-001',
  image = 'gs://generativeai-downloads/images/scones.jpg',
  mimeType = 'image/jpeg'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

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

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

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

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

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

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

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

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

  console.log(fullTextResponse);
}

REST

Puedes usar REST para probar un mensaje de texto mediante la API de Vertex AI para 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, PDF o el video que se incluirá intercalada en el mensaje. Cuando incluyas contenido multimedia intercalado, 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 aleatoriedad 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: Top-P cambia la manera en la que el modelo selecciona los tokens para el resultado. Los tokens se seleccionan del más (consulta top-K) al 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. Un top-K de 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 codiciosa), mientras que un top-K de 3 significa que el siguiente token se selecciona de los tres tokens más probables con 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 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.
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: En 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 . 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,
  }
}'

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:
- 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 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.
Habilitar fundamentos: Si habilitas esta opción, esta opción te brinda respuestas del modelo basadas en hechos. Los fundamentos solo admiten entrada de texto y salida de texto. Para obtener más información, consulta Descripción general de los fundamentos.

Selecciona Habilitar fundamentación.
Haz clic en Personalizar.
Especifica la fuente y la ruta de acceso de los fundamentos.
Haz clic en Guardar.

Respuestas de transmisión: Esta opción no está habilitada. La consola de Google Cloud solo admite la transmisión, lo que implica recibir respuestas a las instrucciones a medida que se generan las respuestas.

Para subir archivos multimedia, como archivos PDF, MP4, WAV y JPG, haz lo siguiente:

Ingresa tu mensaje de texto en el panel Mensaje. El modelo usa los mensajes anteriores como contexto para las respuestas nuevas.
Haz clic en Insertar contenido multimedia 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. Para subir varios archivos, repite este paso. Puedes subir varias imágenes que tengan un tamaño de mensaje total de 10 MB. Un solo archivo no puede superar los 7 MB.
Navega al archivo que deseas subir, haz clic en el archivo y, luego, en Seleccionar. La miniatura del archivo se muestra en el panel Mensaje.
Haz clic en Enviar y se generará la respuesta.

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.

PDF único

Las muestras de código demuestran cómo incluir un PDF en una solicitud de instrucción mediante el SDK de Vertex AI para Python.

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

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

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

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

Java

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 PdfInput {

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

    pdfInput(projectId, location, modelName);
  }

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

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

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

Node.js

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 analyze_pdf(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

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

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

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

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

C#

Antes de 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.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

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

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

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

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

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

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

        return responseText;
    }
}

Console

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:
- 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 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.
Habilitar fundamentos: Si habilitas esta opción, esta opción te brinda respuestas del modelo basadas en hechos. Los fundamentos solo admiten entrada de texto y salida de texto. Para obtener más información, consulta Descripción general de los fundamentos.

Selecciona Habilitar fundamentación.
Haz clic en Personalizar.
Especifica la fuente y la ruta de acceso de los fundamentos.
Haz clic en Guardar.

Respuestas de transmisión: Esta opción no está habilitada. La consola de Google Cloud solo admite la transmisión, lo que implica recibir respuestas a las instrucciones a medida que se generan las respuestas.

Para subir archivos multimedia, como archivos PDF, MP4, WAV y JPG, haz lo siguiente:

Ingresa tu mensaje de texto en el panel Mensaje. El modelo usa los mensajes anteriores como contexto para las respuestas nuevas.
Haz clic en Insertar contenido multimedia 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. Para subir varios archivos, repite este paso. Puedes subir varias imágenes que tengan un tamaño de mensaje total de 10 MB. Un solo archivo no puede superar los 7 MB.
Navega al archivo que deseas subir, haz clic en el archivo y, luego, en Seleccionar. La miniatura del archivo se muestra en el panel Mensaje.
Haz clic en Enviar y se generará la respuesta.

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.

Video único

En las muestras de código, se explica cómo incluir un video en una solicitud de instrucción.

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 line
# project_id = "PROJECT_ID"

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

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

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

Java

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

    multimodalVideoInput(projectId, location, modelName);
  }

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

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

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

Node.js

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-001'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

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

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

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

  console.log(fullTextResponse);
}

Go

Antes de 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-001"
	ctx := context.Background()

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

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

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

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

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

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

C#


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

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

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

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

        StringBuilder fullText = new();

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

REST

Puedes usar REST para probar un mensaje de texto mediante la API de Vertex AI para 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, PDF o el video que se incluirá intercalada en el mensaje. Cuando incluyas contenido multimedia intercalado, 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 aleatoriedad 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: Top-P cambia la manera en la que el modelo selecciona los tokens para el resultado. Los tokens se seleccionan del más (consulta top-K) al 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. Un top-K de 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 codiciosa), mientras que un top-K de 3 significa que el siguiente token se selecciona de los tres tokens más probables con 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 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.
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:
- 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 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.
Habilitar fundamentos: Si habilitas esta opción, esta opción te brinda respuestas del modelo basadas en hechos. Los fundamentos solo admiten entrada de texto y salida de texto. Para obtener más información, consulta Descripción general de los fundamentos.

Selecciona Habilitar fundamentación.
Haz clic en Personalizar.
Especifica la fuente y la ruta de acceso de los fundamentos.
Haz clic en Guardar.

Respuestas de transmisión: Esta opción no está habilitada. La consola de Google Cloud solo admite la transmisión, lo que implica recibir respuestas a las instrucciones a medida que se generan las respuestas.

Para subir archivos multimedia, como archivos PDF, MP4, WAV y JPG, haz lo siguiente:

Ingresa tu mensaje de texto en el panel Mensaje. El modelo usa los mensajes anteriores como contexto para las respuestas nuevas.
Haz clic en Insertar contenido multimedia 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. Para subir varios archivos, repite este paso. Puedes subir varias imágenes que tengan un tamaño de mensaje total de 10 MB. Un solo archivo no puede superar los 7 MB.
Navega al archivo que deseas subir, haz clic en el archivo y, luego, en Seleccionar. La miniatura del archivo se muestra en el panel Mensaje.
Haz clic en Enviar y se generará la respuesta.

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

En las muestras de código, se explica cómo usar un archivo de audio para resumir un podcast. Esta muestra solo funciona con Gemini 1.5 Pro.

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

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

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

  contents = [audio_file, prompt]

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

Console

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:
- 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 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.
Habilitar fundamentos: Si habilitas esta opción, esta opción te brinda respuestas del modelo basadas en hechos. Los fundamentos solo admiten entrada de texto y salida de texto. Para obtener más información, consulta Descripción general de los fundamentos.

Selecciona Habilitar fundamentación.
Haz clic en Personalizar.
Especifica la fuente y la ruta de acceso de los fundamentos.
Haz clic en Guardar.

Respuestas de transmisión: Esta opción no está habilitada. La consola de Google Cloud solo admite la transmisión, lo que implica recibir respuestas a las instrucciones a medida que se generan las respuestas.

Para subir archivos multimedia, como archivos PDF, MP4, WAV y JPG, haz lo siguiente:

Ingresa tu mensaje de texto en el panel Mensaje. El modelo usa los mensajes anteriores como contexto para las respuestas nuevas.
Haz clic en Insertar contenido multimedia 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. Para subir varios archivos, repite este paso. Puedes subir varias imágenes que tengan un tamaño de mensaje total de 10 MB. Un solo archivo no puede superar los 7 MB.
Navega al archivo que deseas subir, haz clic en el archivo y, luego, en Seleccionar. La miniatura del archivo se muestra en el panel Mensaje.
Haz clic en Enviar y se generará la respuesta.

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.

Muestras avanzadas

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

Varias imágenes

Las muestras de código demuestran cómo incluir varias imágenes en una solicitud de instrucciones.

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 line
# project_id = "PROJECT_ID"

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

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

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

Java

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-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

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-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

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
}

C#


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

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

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

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

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

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

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

        StringBuilder fullText = new();

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

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

REST

Puedes usar REST para probar un mensaje de texto mediante la API de Vertex AI para 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, PDF o el video que se incluirá intercalada en el mensaje. Cuando incluyas contenido multimedia intercalado, 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 aleatoriedad 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: Top-P cambia la manera en la que el modelo selecciona los tokens para el resultado. Los tokens se seleccionan del más (consulta top-K) al 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. Un top-K de 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 codiciosa), mientras que un top-K de 3 significa que el siguiente token se selecciona de los tres tokens más probables con 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 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.
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:
- 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 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.
Habilitar fundamentos: Si habilitas esta opción, esta opción te brinda respuestas del modelo basadas en hechos. Los fundamentos solo admiten entrada de texto y salida de texto. Para obtener más información, consulta Descripción general de los fundamentos.

Selecciona Habilitar fundamentación.
Haz clic en Personalizar.
Especifica la fuente y la ruta de acceso de los fundamentos.
Haz clic en Guardar.

Respuestas de transmisión: Esta opción no está habilitada. La consola de Google Cloud solo admite la transmisión, lo que implica recibir respuestas a las instrucciones a medida que se generan las respuestas.

Para subir archivos multimedia, como archivos PDF, MP4, WAV y JPG, haz lo siguiente:

Ingresa tu mensaje de texto en el panel Mensaje. El modelo usa los mensajes anteriores como contexto para las respuestas nuevas.
Haz clic en Insertar contenido multimedia 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. Para subir varios archivos, repite este paso. Puedes subir varias imágenes que tengan un tamaño de mensaje total de 10 MB. Un solo archivo no puede superar los 7 MB.
Navega al archivo que deseas subir, haz clic en el archivo y, luego, en Seleccionar. La miniatura del archivo se muestra en el panel Mensaje.
Haz clic en Enviar y se generará la respuesta.

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.

Transcripción de audio

En las muestras de código, se explica cómo usar un archivo de audio para transcribir una entrevista. Esta muestra solo funciona con Gemini 1.5 Pro.

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

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

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

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

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

	model := client.GenerativeModel(modelName)

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

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

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

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

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

C#


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

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

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

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

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

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

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

        return responseText;
    }
}

Video con audio

En las muestras de código, se explica cómo resumir un archivo de video con audio. En las muestras de código, también se muestran capítulos con marcas de tiempo. Estas muestras solo funcionan con Gemini 1.5 Pro.

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

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

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

contents = [video_file, prompt]

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

Java

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 VideoInputWithAudio {

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

    videoAudioInput(projectId, location, modelName);
  }

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

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

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

      return output;
    }
  }
}

Node.js

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 analyze_video_with_audio(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-flash-001',
  });

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

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

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

C#


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

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

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

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

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

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

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

        return responseText;
    }
}

Todas las modalidades

En las muestras de código, se explica cómo procesar imágenes, videos, audio y texto al mismo tiempo. Estas muestras funcionan con Gemini 1.5 Pro y Gemini 1.5 Flash.

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

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

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

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

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

  contents = [
      video_file,
      image_file,
      prompt,
  ]

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

Java

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 MultimodalAllInput {

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

    multimodalAllInput(projectId, location, modelName);
  }

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

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

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

      return output;
    }
  }
}

Node.js

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 analyze_all_modalities(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

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

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

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

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

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

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

C#


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

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

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

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

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

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

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

        return responseText;
    }
}

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	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 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

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.

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

Para Gemini 1.5 Flash y Gemini 1.5 Pro:

Si ambas dimensiones de la relación de aspecto de una imagen son menores o iguales que 384, se usan 258 tokens.
Si una dimensión de la relación de aspecto de una imagen es superior a 384, la imagen se recorta en mosaicos. Cada tamaño de mosaico se establece de forma predeterminada en la dimensión más pequeña (ancho o altura) dividida por 1.5. Si es necesario, cada mosaico se ajusta para que no sea menor que 256 ni mayor que 768. Cada mosaico se cambia de tamaño a 768 x 768 y usa 258 tokens.

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 Flash y Gemini 1.5 Pro

Requisitos de audio

Gemini 1.5 Flash y Gemini 1.5 Pro admiten los siguientes tipos de MIME de audio. Gemini 1.0 Pro Vision no es compatible con el audio.

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

Requisitos de video

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

En el caso de Gemini 1.5 Flash y Gemini 1.5 Pro, la pista de audio está codificada 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 del video 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.5 Flash	Gemini 1.5 Pro	Gemini 1.0 Pro Vision
FLV - `video/x-flv`
MOV - `video/mov`
MPEG - `video/mpeg`
MPEGPS - `video/mpegps`
MPG - `video/mpg`
MP4 - `video/mp4`
WEBM - `video/webm`
WMV - `video/wmv`
3GPP - `video/3gpp`

Requisitos de PDF

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 PDFs 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 y Gemini 1.5 Flash, 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 PDFs 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.
Marcas de tiempo de solo audio: Los modelos que admiten audio no pueden generar marcas de tiempo con precisión para solicitudes con archivos de audio. Esto incluye marcas de tiempo de segmentación y localización temporal. Las marcas de tiempo se pueden generar con precisión para entradas que incluyen un video que contiene audio.
Puntuación de transcripción: Es posible que las transcripciones que muestra Gemini 1.5 Flash no incluyan la puntuación.

¿Qué sigue?

Comienza a compilar con modelos multimodales de Gemini. Los clientes nuevos obtienen $300 en créditos gratuitos de Google Cloud para explorar lo que pueden hacer con Gemini.
Obtén más información sobre cómo diseñar instrucciones multimodales.
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.