Gemini Omni Flash (gemini-omni-flash-preview) es un modelo multimodal de alto rendimiento diseñado para la generación, edición y control cinematográfico de videos de alta velocidad.
Gemini Omni se basa en las siguientes capacidades principales que lo distinguen de los modelos de video anteriores:
- Multimodalidad nativa: Procesa texto, imágenes, audio y video de forma simultánea, lo que te brinda un resultado más cohesivo, coherente y controlable.
- Edición conversacional: Habilitada por la API de Interactions, te permite refinar y editar tus videos de forma iterativa a través de una conversación en lenguaje natural. Describe lo que quieres cambiar y el modelo aplicará la edición mientras conserva las partes del video que deseas mantener.
- Conocimiento del mundo: Gemini Omni combina la comprensión de la física con el conocimiento de la historia, la ciencia y el contexto cultural de Gemini, lo que cierra la brecha entre el fotorrealismo y la narración significativa.
Generación de texto a video
Genera un video a partir de una instrucción de texto. El modelo genera un video con audio basado en tu descripción de texto. Para obtener los mejores resultados, escribe instrucciones con detalles como la descripción de la escena, el movimiento de la cámara, la iluminación y el ambiente.
Python
import base64
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-omni-flash-preview",
input="A marble rolling fast on a chain reaction style track, continuous smooth shot."
)
with open("marble.mp4", "wb") as f:
f.write(base64.b64decode(interaction.output_video.data))
JavaScript
import { GoogleGenAI } from '@google/genai';
import * as fs from 'fs';
const ai = new GoogleGenAI({});
const interaction = await ai.interactions.create({
model: 'gemini-omni-flash-preview',
input: 'A marble rolling fast on a chain reaction style track, continuous smooth shot.',
});
if (interaction.output_video?.data) {
fs.writeFileSync('marble.mp4', Buffer.from(interaction.output_video.data, 'base64'));
}
REST
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions?key=$API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-omni-flash-preview",
"input": "A marble rolling fast on a chain reaction style track, continuous smooth shot."
}'
Esquema de respuesta de REST
El campo de conveniencia interaction.output_video es solo para SDK.
Obtén el resultado de video del array steps cuando uses la API de REST directamente.
Estructura JSON de REST sin procesar:
{
"steps": [
{ "type": "user_input", "content": [{"type": "text", "text": "..."}] },
{ "type": "thought", "content": [{"text": "...", "type": "thought"}] },
{
"type": "model_output",
"content": [
{
"type": "video",
"mime_type": "video/mp4",
"data": "AAAAIGZ0eXBpc29t..." // Base64 encoded video data
}
]
}
],
"id": "v1_...",
"status": "completed",
"model": "gemini-omni-flash-preview",
"object": "interaction"
}
Controlar la relación de aspecto
Establece aspect_ratio en "9:16" para crear videos verticales. El formato horizontal (16:9) es el predeterminado.
Python
import base64
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-omni-flash-preview",
input="A futuristic city with neon lights and flying cars, cyberpunk style",
response_format={
"type": "video", # optional
"aspect_ratio": "9:16" # Supported values: "9:16", "16:9"
}
)
with open("example.mp4", "wb") as f:
f.write(base64.b64decode(interaction.output_video.data))
JavaScript
import { GoogleGenAI } from '@google/genai';
import * as fs from 'fs';
const ai = new GoogleGenAI({});
const interaction = await ai.interactions.create({
model: 'gemini-omni-flash-preview',
input: 'A futuristic city with neon lights and flying cars, cyberpunk style',
response_format: {
type: 'video', // optional
aspect_ratio: '9:16' // Supported values: '9:16', '16:9'
},
});
if (interaction.output_video?.data) {
fs.writeFileSync('example.mp4', Buffer.from(interaction.output_video.data, 'base64'));
}
REST
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions?key=$API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-omni-flash-preview",
"input": "A futuristic city with neon lights and flying cars, cyberpunk style",
"response_format": {
"type": "video",
"aspect_ratio": "9:16"
}
}'
Generación de video a partir de imágenes
Puedes proporcionar una imagen de referencia con tu instrucción de texto. Según tu instrucción, el modelo decidirá cómo usar la imagen. Esto es útil para dar vida a tomas de productos, ilustraciones o fotografías.
En el siguiente ejemplo, se muestra cómo usar la imagen de referencia de un dibujo de un pez que salta del agua:
Con la siguiente instrucción:
turn this into realistic footage, using the drawing only as a guide for movement, do not show the drawing in the final video
Para generar un video realista del dibujo.
Python
import base64
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-omni-flash-preview",
input=[
{"type": "image", "data": base64_image, "mime_type": "image/jpeg"},
{"type": "text", "text": "turn this into realistic footage, using the drawing only as a guide for movement, do not show the drawing in the final video"}
],
)
with open("clownfish.mp4", "wb") as f:
f.write(base64.b64decode(interaction.output_video.data))
JavaScript
import { GoogleGenAI } from '@google/genai';
import * as fs from 'fs';
const ai = new GoogleGenAI({});
const interaction = await ai.interactions.create({
model: 'gemini-omni-flash-preview',
input: [
{ type: 'image', data: base64Image, mime_type: 'image/jpeg' },
{ type: 'text', text: 'turn this into realistic footage, using the drawing only as a guide for movement, do not show the drawing in the final video' }
]
});
if (interaction.output_video?.data) {
fs.writeFileSync('clownfish.mp4', Buffer.from(interaction.output_video.data, 'base64'));
}
REST
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions?key=$API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-omni-flash-preview",
"input": [
{"type": "image", "data": "'"$BASE64_IMAGE"'", "mime_type": "image/jpeg"},
{"type": "text", "text": "turn this into realistic footage, using the drawing only as a guide for movement, do not show the drawing in the final video"}
]
}'
Referencia del sujeto
Puedes generar un video que incorpore sujetos específicos proporcionados como imágenes de referencia. Por ejemplo, el siguiente código muestra cómo proporcionar 2 imágenes de un gato y un hilo para generar un video del gato jugando con el hilo.
Python
import base64
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-omni-flash-preview",
input=[
{"type": "image", "data": cat_b64, "mime_type": "image/png"},
{"type": "image", "data": yarn_b64, "mime_type": "image/png"},
{"type": "text", "text": "A cat playfully batting at a ball of yarn."}
],
)
with open("cat.mp4", "wb") as f:
f.write(base64.b64decode(interaction.output_video.data))
JavaScript
import { GoogleGenAI } from '@google/genai';
import * as fs from 'fs';
const ai = new GoogleGenAI({});
const interaction = await ai.interactions.create({
model: 'gemini-omni-flash-preview',
input: [
{ type: 'image', data: catData, mime_type: 'image/png' },
{ type: 'image', data: yarnData, mime_type: 'image/png' },
{ type: 'text', text: 'A cat playfully batting at a ball of yarn.' }
]
});
if (interaction.output_video?.data) {
fs.writeFileSync('cat.mp4', Buffer.from(interaction.output_video.data, 'base64'));
}
REST
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions?key=$API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-omni-flash-preview",
"input": [
{"type": "image", "data": "'"$CAT_B64"'", "mime_type": "image/png"},
{"type": "image", "data": "'"$YARN_B64"'", "mime_type": "image/png"},
{"type": "text", "text": "A cat playfully batting at a ball of yarn."}
]
}'
Parámetro de tareas
Usa el parámetro task en video-config para indicar claramente el comportamiento deseado. Por ejemplo, si quieres que el modelo genere un video a partir de una imagen, puedes establecer el parámetro en image_to_video. Si no se establece, el modelo inferirá lo que quieres de la instrucción.
Se permiten los siguientes valores:
text_to_videoimage_to_videoreference_to_videoedit
En el siguiente ejemplo, se muestra cómo configurar esto para el ejemplo de imagen a video que se mostró anteriormente.
Python
import base64
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-omni-flash-preview",
input=[
{"type": "image", "data": base64_image, "mime_type": "image/jpeg"},
{"type": "text", "text": "turn this into realistic footage, using the drawing only as a guide for movement, do not show the drawing in the final video"}
],
generation_config={
"video_config": {
"task": "image_to_video",
}
},
)
with open("example.mp4", "wb") as f:
f.write(base64.b64decode(interaction.output_video.data))
JavaScript
import { GoogleGenAI } from "@google/genai";
import * as fs from 'fs';
const ai = new GoogleGenAI({});
const interaction = await ai.interactions.create({
model: 'gemini-omni-flash-preview',
input: [
{ type: 'image', data: base64Image, mime_type: 'image/jpeg' },
{ type: 'text', text: 'turn this into realistic footage, using the drawing only as a guide for movement, do not show the drawing in the final video' }
],
generationConfig: {
videoConfig: {
task: 'image_to_video',
}
}
});
if (interaction.output_video?.data) {
fs.writeFileSync('example.mp4', Buffer.from(interaction.output_video.data, 'base64'));
}
REST
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-omni-flash-preview",
"input": [
{
"type": "image",
"data": "'"$BASE64_IMAGE"'",
"mime_type": "image/jpeg"
},
{
"type": "text",
"text": "turn this into realistic footage, using the drawing only as a guide for movement, do not show the drawing in the final video"
}
],
"generation_config": {
"video_config": {
"task": "image_to_video"
}
}
}'
Edición de video con estado
Genera un video y edítalo de forma iterativa con instrucciones de seguimiento. Cada turno se basa en el resultado anterior. El modelo recuerda el contexto del video, aplica los cambios y conserva los elementos que no mencionaste. Usa previous_interaction_id para hacer un seguimiento del historial de conversaciones y el estado del video generado sin volver a subir el video anterior.
En el siguiente ejemplo, se muestra cómo generar un primer video y, luego, editarlo:
Python
import base64
from google import genai
client = genai.Client()
# Turn 1: Generate initial video
res1 = client.interactions.create(model="gemini-omni-flash-preview", input="A woman playing violin outdoors.")
# Turn 2: Edit the previous video
res2 = client.interactions.create(
model="gemini-omni-flash-preview",
previous_interaction_id=res1.id,
input="Make the violin invisible."
)
with open("example.mp4", "wb") as f:
f.write(base64.b64decode(res2.output_video.data))
JavaScript
import { GoogleGenAI } from '@google/genai';
import * as fs from 'fs';
const ai = new GoogleGenAI({});
// Turn 1: Generate initial video
const res1 = await ai.interactions.create({
model: 'gemini-omni-flash-preview',
input: 'A woman playing violin outdoors.',
});
// Turn 2: Edit the previous video
const res2 = await ai.interactions.create({
model: 'gemini-omni-flash-preview',
previous_interaction_id: res1.id,
input: 'Make the violin invisible.',
});
if (res2.output_video?.data) {
fs.writeFileSync('example.mp4', Buffer.from(res2.output_video.data, 'base64'));
}
REST
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions?key=$API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-omni-flash-preview",
"previous_interaction_id": "'"$PREVIOUS_ID"'",
"input": "Make the violin invisible."
}'
Ejemplo de un video inicial:
Ejemplo de un video editado:
Cada turno de la conversación produce un video nuevo. El modelo comprende el contexto de los turnos anteriores, lo que te permite realizar cambios incrementales, como ajustar la iluminación y cambiar los fondos, sin volver a describir toda la escena.
Edita tus propios videos
Sube tus videos con la API de Files para editarlos con Gemini Omni Flash.
En el siguiente ejemplo, se muestra cómo editar el siguiente video original:
Python
import time
import base64
from google import genai
client = genai.Client()
# Upload video using the file API
video_file = client.files.upload(file="Video.mp4")
while video_file.state == "PROCESSING":
print('Waiting for video to be processed.')
time.sleep(10)
video_file = client.files.get(name=video_file.name)
if video_file.state == "FAILED":
raise ValueError(video_file.state)
print(f'Video processing complete: ' + video_file.uri)
# Edit your video
interaction = client.interactions.create(
model="gemini-omni-flash-preview",
input=[
{"type": "document", "uri": video_file.uri},
{"type": "text", "text": "When the person touches the mirror, make the mirror ripple beautifully like liquid, and the person's arm turns into reflective mirror material"}
],
)
with open("example.mp4", "wb") as f:
f.write(base64.b64decode(interaction.output_video.data))
JavaScript
import { GoogleGenAI } from '@google/genai';
import * as fs from 'fs';
const ai = new GoogleGenAI({});
// Upload video using the file API
let videoFile = await ai.files.upload({
file: 'Video.mp4',
});
while (videoFile.state === 'PROCESSING') {
console.log('Waiting for video to be processed.');
await new Promise(r => setTimeout(r, 10000));
videoFile = await ai.files.get({ name: videoFile.name });
}
if (videoFile.state === 'FAILED') {
throw new Error(videoFile.state);
}
console.log('Video processing complete: ' + videoFile.uri);
// Edit your video
const interaction = await ai.interactions.create({
model: 'gemini-omni-flash-preview',
input: [
{ type: 'document', uri: videoFile.uri },
{ type: 'text', text: "When the person touches the mirror, make the mirror ripple beautifully like liquid, and the person's arm turns into reflective mirror material" }
],
});
if (interaction.output_video?.data) {
fs.writeFileSync('example.mp4', Buffer.from(interaction.output_video.data, 'base64'));
}
REST
#!/bin/bash
VIDEO_B64=$(encode_file "$VIDEO_FILE")
curl -sS -w "\n[HTTP %{http_code}]\n" "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: ${API_KEY}" \
-H "Content-Type: application/json" \
-d @- <<EOF > video_editing_response.json
{
"model": "gemini-omni-flash-preview",
"input": [
{
"type": "user_input",
"content": [
{
"type": "video",
"mime_type": "video/mp4",
"data": "$VIDEO_B64"
},
{
"type": "text",
"text": "When the person touches the mirror, make the mirror ripple beautifully like liquid, and the person's arm turns into reflective mirror material"
}
]
}
],
"response_format": { "type": "video" }
}
EOF
Ejemplo de un video editado:
Cómo recuperar videos con un URI
Usa el delivery="uri" parámetro en
response_format para recuperar videos generados que tengan más de 4 MB.
Esto muestra un URI alojado en Google que puedes sondear hasta que el video esté ACTIVE antes de descargarlo.
Python
import time
from google import genai
client = genai.Client()
# 1. Request video via URI delivery
interaction = client.interactions.create(
model="gemini-omni-flash-preview",
input="A beautiful sunset.",
response_format={"type": "video", "delivery": "uri"}
)
# 2. Extract file name and poll for ACTIVE state
video_output = interaction.output_video
file_name = video_output.uri.split("/")[-1] # Extract ID
print("Waiting for video processing...")
while True:
f_info = client.files.get(name=f"files/{file_name}")
if f_info.state.name == "ACTIVE":
break
elif f_info.state.name == "FAILED":
raise RuntimeError("Generation failed.")
time.sleep(5)
# 3. Download the final video
video_bytes = client.files.download(file=video_output.uri)
with open("output.mp4", "wb") as f:
f.write(video_bytes)
JavaScript
import { GoogleGenAI } from '@google/genai';
const ai = new GoogleGenAI({});
// 1. Request video via URI delivery
const interaction = await ai.interactions.create({
model: 'gemini-omni-flash-preview',
input: 'A beautiful sunset.',
response_format: { type: 'video', delivery: 'uri' },
});
// 2. Extract file name and poll for ACTIVE state
const videoOutput = interaction.output_video;
const fileId = videoOutput.uri.match(/files\/([a-zA-Z0-9]+)/)[1];
const name = `files/${fileId}`;
console.log("Waiting for video processing...");
while (true) {
const fInfo = await ai.files.get({ name });
if (fInfo.state.name === 'ACTIVE') break;
if (fInfo.state.name === 'FAILED') throw new Error("Generation failed.");
await new Promise(r => setTimeout(r, 5000));
}
// 3. Download the final video
await ai.files.download({
file: videoOutput,
downloadPath: 'output.mp4',
});
console.log("💾 Saved video to output.mp4");
REST
#!/bin/bash
# 1. Initial request to generate the video
RESPONSE=$(curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions?key=$API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-omni-flash-preview",
"input": "A beautiful sunset over a calm ocean.",
"response_format": {"type": "video", "delivery": "uri"}
}')
# Extract FILE_ID from the URI (e.g., "files/abc-123" -> "abc-123")
FILE_URI=$(echo $RESPONSE | jq -r '.output_video.uri')
FILE_ID=$(echo $FILE_URI | cut -d'/' -f2)
echo "Video requested (ID: $FILE_ID). Waiting for processing..."
# 2. Polling loop
while true; do
# Get current file status
STATUS_JSON=$(curl -s -X GET "https://generativelanguage.googleapis.com/v1beta/files/$FILE_ID?key=$API_KEY")
STATE=$(echo $STATUS_JSON | jq -r '.state')
if [ "$STATE" == "ACTIVE" ]; then
echo "Processing complete! Downloading..."
break
elif [ "$STATE" == "FAILED" ]; then
echo "Error: Generation failed."
exit 1
else
echo "Current state: $STATE... (waiting 5s)"
sleep 5
fi
done
# 3. Final download
curl -L -X GET "https://generativelanguage.googleapis.com/v1beta/files/$FILE_ID:download?alt=media&key=$API_KEY" \
--output "output.mp4"
echo "Done! Video saved to output.mp4"
Estructura JSON de REST sin procesar (URI):
{
"steps": [
{ "type": "user_input", "content": [{"type": "text", "text": "..."}] },
{ "type": "thought", "content": [{"text": "...", "type": "thought"}] },
{
"type": "model_output",
"content": [
{
"type": "video",
"mime_type": "video/mp4",
"uri": "https://generativelanguage.googleapis.com/v1beta/files/...:download?alt=media"
}
]
}
],
"id": "v1_...",
"status": "completed",
"model": "gemini-omni-flash-preview",
"object": "interaction"
}
Prácticas recomendadas
- Usa la entrega de URI para videos grandes: Para videos de más de 4 MB (>720p
cuando estén disponibles), usa
delivery="uri"enresponse_formatpara evitar los límites de tamaño de la carga útil. - Rendimiento optimizado: Establece
background=false,store=falseystream=falsepara una generación unaria más rápida y síncrona. Ten en cuenta que, si establecesstore=false, el video generado no se podrá editar en turnos posteriores conprevious_interaction_id. - Precisión de las instrucciones: Consulta la sección de orientación sobre las instrucciones para obtener más detalles.
Limitaciones
- No se admite la carga ni la edición de imágenes que contengan menores en el Espacio Económico Europeo, Suiza ni el Reino Unido.
- No se admite la carga ni la edición de imágenes que contengan ciertas personas reconocibles.
- Por el momento, la edición de videos subidos no está disponible para los usuarios del Espacio Económico Europeo (EEE), Suiza ni el Reino Unido (se admite la edición de videos generados por el modelo).
- No se admite la carga de referencias de audio en la versión actual de la API.
- El esquema de la API acepta referencias de video de hasta 3 segundos de duración, pero el modelo no las procesa correctamente en este momento.
- No se admite la referencia ni el razonamiento en varios videos. Si intentas crear instrucciones para varios videos, es posible que se degrade el rendimiento del modelo o que se generen resultados inesperados.
- No se admiten la extensión de video ni la interpolación de video (generación de video entre un primer y un último fotograma).
- No se admite la edición de voz.
- No se admite el rendimiento aprovisionado.
- No se admiten las instrucciones del sistema, la temperatura,
top_p, las secuencias de detención ni las instrucciones negativas (puedes colocar tus negativos en la instrucción normal, p.ej., "No hagas X"). - No se admite el uso de videos de YouTube como fuente de contenido multimedia.
Detalles técnicos
- Todos los videos generados incluyen marcas de agua de SynthID, que son invisibles para los usuarios, pero se pueden detectar de forma programática para la verificación de la procedencia.
- Los tiempos de generación de video varían según la duración, la resolución y la carga actual de la API. Los videos más largos y de mayor resolución tardan más en generarse.
- Los filtros de seguridad del contenido se aplican a las instrucciones de entrada y al video generado (y dependen de tu región). Se bloquearán las instrucciones que infrinjan las políticas de uso.
- El inglés (EN) es totalmente compatible, pero no se evaluaron otros idiomas, por lo que pueden funcionar, pero los resultados pueden variar.
Guía de instrucciones de Gemini Omni Flash
En esta sección, se incluyen sugerencias y ejemplos sobre cómo crear instrucciones de Gemini Omni Flash de manera eficaz.
Escena única
De forma predeterminada, Omni Flash intentará crear un video con algunas tomas diferentes. Intentará crear una narración interesante basada en la instrucción.
Si necesitas que el video de salida contenga una sola escena, debes crear una instrucción para ello:
- En una sola escena ininterrumpida
- En un solo plano secuencia
- Sin cortes de escena
Por ejemplo:
Continuous, unbroken handheld shot of a fluffy tabby cat sitting on a sunny windowsill, looking out into a leafy garden. The cat's tail twitches slowly, and its ears rotate slightly toward ambient noises. Sunbeams illuminate dust motes in the air. Sound design: Gentle breeze, distant bird chirps. No dialogue.
Quitar elementos no deseados
Si el video generado contiene elementos que no quieres, incluye instrucciones negativas simples para evitarlos:
- Sin diálogo
- Sin adornos
- Sin efectos de sonido adicionales
Instrucciones para la edición
Las instrucciones simples funcionan mejor para la edición de video. Las instrucciones demasiado descriptivas pueden provocar cambios no deseados.
Los siguientes son más ejemplos de instrucciones de edición simples:
- Haz que este video sea de anime
- Ponle un sombrero de moda a esta persona
- Cambia la iluminación para que sea más dramática
- Cambia el texto del cartel para que diga "Omni Flash"
Cuando edites un aspecto específico del video, incluye "Keep everything else the same" para mantener la coherencia visual.
Los siguientes son algunos ejemplos para mostrar cómo aplicar esta técnica:
- Qué debes evitar:
In the video of the man sitting on the sofa, please add a small black cat that runs from the right side of the screen, jumps onto his lap, and then he starts to stroke its head while looking down.- Simplificar:
Add a cat that jumps onto his lap, he begins to pet it. Keep everything else the same.
- Simplificar:
- Qué debes evitar:
Please remove the cell phone that the person is holding in their hand and fill in the background so it looks like they are just holding their hand empty.- Simplificar:
Make the phone invisible. Keep everything else the same.
- Simplificar:
Instrucciones de audio
De forma predeterminada, el modelo intentará generar una pista de audio adecuada para un video. Es posible que esto no siempre sea lo que quieres. Puedes usar tu instrucción para describir el tipo de audio que deseas. Esto es muy importante si quieres música en tu video:
- Incluye música de fondo tranquila
- El video tiene un ritmo tecno de alta energía
- El audio es una transmisión de radio baja y metálica en segundo plano que reproduce una canción
Eventos de sincronización
Puedes crear instrucciones para que sucedan cosas en momentos específicos del video. No se necesita una sintaxis precisa y puedes usar lenguaje natural. Esto es muy útil para crear tus propios cortes de escena, ritmo o secuencias de disparos rápidos. Consulta lo siguiente para ver ejemplos:
- Después de 3 segundos, una mujer entra en la escena.
- A los 5 segundos, comienza el coro en el audio de fondo.
- Cada 2 segundos, corta a un fotograma nuevo.
- En una secuencia de disparos rápidos, cada medio segundo (12 fotogramas a 24 fps), cambia la escena a una ubicación nueva.
También puedes usar una sintaxis de código de tiempo:
[0-3s] A person is walking
[3-6s] They stop and turn around
[6-10s] They start running
Metainstrucciones
Puedes pedirle a Gemini Omni Flash que preste atención a las cualidades o principios generales de la generación de video:
- Considera los microdetalles, la expresión y la sincronización para crear una escena muy rica, detallada, pero completamente natural.
- Sé muy detallado en tus descripciones de personajes y entornos. Aplica los principios de diseño de vestuario a los personajes. Sé muy específico sobre las personas, los elementos y los objetos de la escena.
- Incluye muchos detalles adecuados en los elementos de fondo para que la escena se vea realista y natural.
- Crea un video de disparos rápidos que muestre un
[thing]raro diferente cada 1 segundo, música alegre y texto para etiquetar el elemento.
Texto en videos
Puedes crear instrucciones para incluir texto en tu video, y Gemini Omni lo renderizará de una manera correcta y legible. Si habrá texto natural en tu video, incluso en los elementos de fondo, puede ser útil definir lo que debería decir.
- Una palabra en la pantalla a la vez: "¿sabías que Omni puede hacer texto increíble?" Cada palabra aparece durante 1 segundo con un estilo animado diferente. Sin diálogo.
- Hay un letrero que dice: "Esta es una generación de IA de Omni", hay un escaparate que dice: "Todo lo que necesitas de IA", hay un automóvil con la placa: "OMN111".
Usa etiquetas en las instrucciones para establecer roles de imagen
Puedes usar etiquetas para vincular contenido multimedia subido a roles de generación específicos. Esto te permite especificar si cada imagen es un fotograma inicial o una referencia.
1. Etiquetas simples (recomendado)
En casos simples en los que los roles de imagen son claros a partir de la instrucción, puedes vincular imágenes a roles directamente:
<FIRST_FRAME>: Usa la imagen como el fotograma inicial del video, para ejemplo:<FIRST_FRAME> a woman is walking<IMAGE_REF_N>: Usa la imagen como referencia, por ejemplo:in the style of <IMAGE_REF_0> a woman <IMAGE_REF_1> is walking(combina la referencia de estilo de la primera imagen y la referencia del sujeto de la segunda imagen). Las referencias de imágenes comienzan desde 0.
El siguiente es un ejemplo con 6 imágenes de referencia:
[0-3s] A studio fashion sequence. Starting with woman <IMAGE_REF_0>, she is holding <IMAGE_REF_1>
[3-6s] Then we see the man <IMAGE_REF_2> holding <IMAGE_REF_3>
[6-10s] And finally another woman <IMAGE_REF_4> who is holding <IMAGE_REF_5> while walking.
2. Declaraciones explícitas
Para casos más complejos con varias imágenes y varios roles, puedes usar etiquetas de prefijo explícitas combinadas con sufijos de instrucciones en lenguaje natural.
- Declaración de fuentes e imágenes de referencia:
[# Sources <FIRST_FRAME>@Image1]usará la primera imagen como el fotograma inicial.[# References <IMAGE_REF_0>@Image1]usará la primera imagen como referencia.[# References <IMAGE_REF_1>@Image2]usará la segunda imagen como referencia.[# References <IMAGE_REF_0>@Image1 <IMAGE_REF_1>@Image2]usará ambas imágenes como referencias.[# Sources <FIRST_FRAME>@Image1] [# References <IMAGE_REF_0>@Image2]usará la primera imagen como el fotograma inicial y la segunda imagen como referencia.
- Instrucciones de guía: Agrega instrucciones de guía al final de la instrucción:
- Para el fotograma inicial:
"Use this image as the starting frame." - Para imágenes de referencia:
"Use the given image(s) as references for video generation. The images should not be used as literal initial frames."
- Para el fotograma inicial:
Ejemplo de instrucción expandida:
[# Sources <FIRST_FRAME>@Image1] [# References <IMAGE_REF_0>@Image2] a woman <IMAGE_REF_0> is walking. Use Image1 as the starting frame. Use Image2 as a reference for the video generation.
¿Qué sigue?
- Para comenzar a usar Gemini Omni Flash, experimenta en el Colab de inicio rápido de Omni.
- Obtén información para escribir instrucciones aún mejores con nuestra Introducción al diseño de instrucciones.