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 resultados más cohesivos, coherentes y controlables.
- Edición conversacional: Esta función, habilitada por la API de Interactions, te permite mejorar y editar tus videos de forma iterativa a través de conversaciones en lenguaje natural. Describe lo que quieres cambiar, y el modelo aplicará la edición y conservará las partes del video que quieras mantener.
- Conocimiento del mundo: Gemini Omni combina la comprensión de la física con el conocimiento de Gemini sobre historia, ciencia y contexto cultural, lo que cierra la brecha entre el fotorrealismo y la narración significativa.
Generación de texto a video
Generar un video a partir de una instrucción de texto El modelo genera un video con audio basado en tu descripción de texto. Escribe instrucciones con detalles como la descripción de la escena, el movimiento de la cámara, la iluminación y el ambiente para obtener los mejores resultados.
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"
}
Control de la relación de aspecto
Configura 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 las ilustraciones, las fotografías o las tomas de productos.
En el siguiente ejemplo, se muestra cómo usar la imagen de referencia de un dibujo de un pez que salta fuera 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
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 temas 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 ovillo de lana para generar un video del gato jugando con la lana.
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 previsto. 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 configura, el modelo inferirá lo que quieres a partir de la instrucción.
Los siguientes son los valores permitidos:
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
Generar un video y editarlo de forma iterativa con instrucciones de seguimiento Cada turno se basa en el resultado anterior. El modelo recuerda el contexto del video y aplica los cambios a la vez que 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.
Cómo editar tus 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 parámetro delivery="uri" en response_format para recuperar los videos generados que superen los 4 MB.
Esto devuelve un URI alojado en Google que puedes sondear hasta que el video sea 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 los videos de más de 4 MB (más de 720 p 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 el parámetro de configuraciónstore=falsesignifica que el video generado no se podrá editar en turnos posteriores conprevious_interaction_id. - Precisión de la instrucción: Consulta la sección de orientación sobre 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 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 (sí se admite la edición de videos generados por el modelo).
- La carga de referencias de audio no se admite 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 hacer referencia a varios videos ni razonar sobre ellos. Si intentas usar 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 procesamiento aprovisionado.
- No se admiten las instrucciones del sistema, la temperatura,
top_p, las secuencias de detención ni las instrucciones negativas (puedes incluir tus instrucciones negativas en la instrucción normal, p.ej., "No hagas X"). - No se admite el uso de videos de YouTube como fuente de medios.
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 verificar 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 con 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) se admite por completo, pero no se evaluaron otros idiomas, por lo que es posible que funcionen, pero los resultados pueden variar.
Guía de instrucciones de Gemini Omni Flash
En esta sección, se incluyen sugerencias y ejemplos para escribir instrucciones eficaces para Gemini Omni Flash.
Escena única
De forma predeterminada, Omni Flash intentará crear un video con varias tomas diferentes. Intentará crear una narrativa interesante basada en la instrucción.
Si necesitas que el video de salida contenga una sola escena, debes indicarlo en la instrucción:
- En una sola escena continua
- 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.
Cómo 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
Mensajes para editar
Las instrucciones simples funcionan mejor para la edición de video. Las instrucciones demasiado descriptivas pueden generar cambios no deseados.
A continuación, se incluyen más ejemplos de instrucciones de edición simples:
- Convierte este video en anime
- Ponerle un sombrero moderno 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.
A continuación, se incluyen 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:
Cómo solicitar el 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 quieras. Puedes usar la instrucción para describir el tipo de audio que deseas. Esto es muy importante si quieres incluir música en tu video:
- Incluye música de fondo relajante
- El video tiene una base tecno enérgica
- El audio es una transmisión de radio de baja calidad en segundo plano, en la que se reproduce una canción.
Tiempos de eventos
Puedes solicitar que sucedan cosas en momentos específicos del video, no se necesita una sintaxis precisa y puedes usar lenguaje natural. Esto es especialmente útil para crear tus propios cortes de escena, ritmos o secuencias de disparos rápidos. Consulta los siguientes ejemplos:
- Después de 3 segundos, una mujer entra en escena.
- A los 5 s, el coro comienza en el audio de fondo.
- Cada 2 s, se corta a un nuevo fotograma.
- 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 los principios generales de la generación de videos:
- Ten en cuenta los microdetalles, la expresión y la sincronización para crear una escena muy detallada y enriquecida, pero completamente natural.
- Sé muy detallado en tus descripciones de personajes y entornos. Aplicar los principios del diseño de vestuario a los personajes Sé muy específico sobre las personas, los elementos y los objetos que aparecen en la escena.
- Incluye muchos detalles adecuados en los elementos de fondo para que la escena se vea realista y natural.
- Haz un video de preguntas rápidas que muestre un
[thing]diferente cada segundo, con música alegre y texto para etiquetar el objeto.
Texto en videos
Puedes solicitar que se incluya texto en tu video, y Gemini Omni lo renderizará de una manera correcta y legible. Si habrá texto que aparezca de forma natural en tu video, incluso en los elementos de fondo, puede ser útil definir lo que debería decir.
- Una palabra a la vez en la pantalla: "¿Sabías que Omni puede escribir textos increíbles?". Cada palabra aparece durante 1 s con un estilo animado diferente. Sin diálogo.
- Hay una señal de tránsito que dice: "Esta es una generación de IA de Omni", hay una tienda que dice: "Todo lo que necesitas IA", hay un automóvil con la matrícula: "OMN111".
Cómo usar etiquetas en instrucciones para establecer roles de imágenes
Puedes usar etiquetas para vincular el 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 (recomendadas)
En casos simples en los que los roles de las imágenes son claros a partir de la instrucción, puedes vincular las imágenes a los roles directamente:
<FIRST_FRAME>: Usa la imagen como el fotograma inicial del video, por 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 de sujeto de la segunda imagen). Las referencias de imágenes comienzan en 0.
A continuación, se muestra 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 junto 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 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 fotograma inicial y la segunda como referencia.
- Instrucciones de guía: Agrega instrucciones de guía al final de la instrucción:
- Para el fotograma de inicio:
"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 de inicio:
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?
- Comienza a usar Gemini Omni Flash experimentando en el Colab de inicio rápido de Omni.
- Obtén más información para escribir instrucciones aún mejores con nuestra Introducción al diseño de instrucciones.