Pegasus 1.5 de TwelveLabs ya está disponible en Amazon Bedrock

El 9 de octubre de 2026 anunciamos la disponibilidad de Pegasus 1.5 de TwelveLabs en Amazon Bedrock. Pegasus 1.5 es un modelo de lenguaje de video que convierte videos largos en metadatos estructurados con marcas de tiempo. Tú describes los momentos que importan para tu flujo de trabajo, y el modelo devuelve cada segmento coincidente como JSON.

El video representa una categoría significativa y compleja de datos no estructurados; sin embargo, la mayoría permanece sin búsqueda y subutilizada. Extraer información estructurada y accionable de ese contenido históricamente ha requerido una revisión manual laboriosa o cadenas de herramientas fragmentadas.

Con versiones anteriores de Pegasus, puedes apuntar el modelo a un clip, hacer una pregunta y obtener una respuesta. Ahora, Pegasus 1.5 analiza el video completo, encuentra cada segmento que coincide con criterios definidos por el usuario y devuelve metadatos estructurados con marcas de tiempo. También introduce segmentación de video, prompting multimodal con imágenes de referencia y procesamiento sobre la marcha.

Con Pegasus 1.5 en Amazon Bedrock, puedes analizar videos directamente desde un URI de Amazon Simple Storage Service (Amazon S3) o una cadena base64 sin necesidad de preindexación, y tus datos permanecen dentro del límite de datos de AWS.

En esta publicación, cubrimos las novedades de Pegasus 1.5, cómo se empaqueta el modelo en Amazon Bedrock y cómo enviar tu primera solicitud. Luego repasamos la segmentación de video, la salida JSON estructurada y el prompting multimodal.

Novedades de Pegasus 1.5

Pegasus 1.5 tiene los siguientes cambios en comparación con versiones anteriores:

• Generación de metadatos basada en el tiempo. Tú defines los segmentos, eventos o señales específicas del dominio que importan para tu flujo de trabajo, como segmentos editoriales, jugadas deportivas, cambios de orador o apariciones de marca. Pegasus 1.5 devuelve cada segmento coincidente como JSON, con horas de inicio y fin y los campos solicitados completados.
• Prompting multimodal. Una definición de segmento puede combinar una descripción de texto con una referencia visual. Esto hace posible ubicar un producto, logotipo o persona específica, junto con lo que está haciendo en pantalla.
• Procesamiento sobre la marcha. No se requiere ningún pipeline de ingesta ni paso de preindexación. Los videos se envían directamente desde Amazon S3 y los resultados se devuelven en la respuesta.
• Capacidad de procesamiento ampliada. Pegasus 1.5 analiza videos de hasta dos horas de duración en una sola solicitud, frente a una hora en Pegasus 1.2.

Pegasus 1.5 conserva y mejora las capacidades principales que hicieron de Pegasus 1.2 una herramienta poderosa para la comprensión de video, incluyendo:

• Generación de texto a partir de video: Crea descripciones textuales detalladas basadas en el contenido del video.
• Comprensión visual granular: Analiza objetos, texto en pantalla y contenido numérico dentro de los fotogramas del video.
• Anclaje temporal: Identifica con precisión las marcas de tiempo de eventos específicos dentro de los videos.
• Comprensión multimodal: Combina información visual, auditiva y textual para un análisis integral.
• Soporte multilingüe: Soporte completo para inglés, con soporte parcial para árabe, chino, francés, alemán, italiano, japonés, coreano, portugués, ruso, español, tailandés y vietnamita.

Cómo funciona Pegasus 1.5 en Amazon Bedrock

Pegasus 1.5 toma un video y una indicación de texto o un conjunto de definiciones de segmentos, y devuelve texto o JSON. Lo llamas en el bedrock-runtime endpoint con la InvokeModel API, o con InvokeModelWithResponseStream cuando quieres que la respuesta se transmita a medida que se genera.

Cada solicitud se ejecuta en uno de dos modos de análisis, que se elige con el analysisMode campo:

Puedes apuntar el modelo al video de dos maneras. Una ubicación de S3 (s3Location) toma el uri del objeto y el ID de la cuenta de bucketOwner , y es adecuada para videos largos. Una cadena base64 (base64String) incrusta el video en el cuerpo de la solicitud, hasta 25 MB, y es adecuada para clips cortos.

Para rastrear el costo por aplicación, crea un perfil de inferencia de aplicación a partir del modelo Pegasus 1.5, etiquétalo y llámalo por su Amazon Resource Name (ARN) en lugar del ID del modelo.

Introducción a Pegasus 1.5

La siguiente sección describe cómo empezar con Pegasus 1.5.

Requisitos previos

Antes de comenzar, asegúrate de tener:

1. Una cuenta de AWS activa con acceso a Amazon Bedrock.
2. Python 3.10 o posterior, con el AWS SDK for Python (Boto3) instalado.
3. Permisos de AWS Identity and Access Management (IAM) para bedrock:InvokeModel y bedrock:InvokeModelWithResponseStream.
4. Acceso al modelo habilitado para TwelveLabs Pegasus 1.5 en la consola de Amazon Bedrock.
5. Videos almacenados en un bucket de Amazon S3, o clips cortos que puedas enviar en línea.

La siguiente política otorga tanto permisos para invocar acciones en Pegasus 1.5.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel",
                "bedrock:InvokeModelWithResponseStream"
            ],
            "Resource": [
                "arn:aws:bedrock:us-west-2::foundation-model/twelvelabs.pegasus-1-5-v1:0"
            ]
        }
    ]
}

Boto3 firma las solicitudes con sus credenciales habituales de AWS. También puede autenticarse con una clave de API de Amazon Bedrock configurándola en la AWS_BEARER_TOKEN_BEDROCK variable de entorno. Para producción, se prefiere una clave de corto plazo generada a partir de sus credenciales de IAM con el aws-bedrock-token-generator paquete, porque caduca automáticamente. La autenticación con token Bearer también requiere el bedrock:CallWithBearerToken permiso.

Envíe su primera solicitud

Instale Boto3:

pip install boto3

El siguiente ejemplo analiza un video almacenado en Amazon S3 en modo general. Este ejemplo utiliza el punto de enlace global de Cross Region Inference (CRIS). Para dirigirse al punto de enlace geográfico de EE. UU. en su lugar, reemplace “global.” por “us.” en la URL del punto de enlace.

import boto3
import json
from botocore.config import Config

AWS_REGION = "us-west-2"
MODEL_ID = "global.twelvelabs.pegasus-1-5-v1:0"

bedrock_runtime = boto3.client(
    service_name="bedrock-runtime",
    region_name=AWS_REGION,
    config=Config(
        # keep a longer read_timeout for lengthier invocations such as video segmentation
        read_timeout=900,
        retries={"max_attempts": 0},
        connect_timeout=10,
    ),
)

# Analyze a video stored in Amazon S3
payload = {
    "inputPrompt": "Summarize this video and identify the key topics discussed.",
    "mediaSource": {
        "s3Location": {
            "uri": "s3://amzn-s3-demo-pegasus-15/your-video.mp4",
            "bucketOwner": "your-account-id"
        }
    },
    "temperature": 0.2,
    "maxOutputTokens": 4096,
    "includeMetering": True
}

response = bedrock_runtime.invoke_model(
    modelId=MODEL_ID,
    body=json.dumps(payload)
)
result = json.loads(response["body"].read())
print(result["message"])

La respuesta contiene la respuesta en message, los recuentos de tokens en input_tokens y output_tokens, y el motivo por el que terminó la generación en stopReason. Un stopReason de length significa que la respuesta alcanzó maxOutputTokens antes de finalizar, así que verifíquela antes de confiar en la salida:

if result["stopReason"] == "length":
    print("The answer was cut off. Raise maxOutputTokens and try again.")
print("Tokens in:", result["input_tokens"], "out:", result["output_tokens"])

Campos de solicitud para el modo general:

Para un clip corto, puedes enviar el video en línea en lugar de desde S3:

import base64

with open("your-video.mp4", "rb") as f:
    video_b64 = base64.b64encode(f.read()).decode("utf-8")

payload["mediaSource"] = {"base64String": video_b64}
response = bedrock_runtime.invoke_model(modelId=MODEL_ID, body=json.dumps(payload))
print(json.loads(response["body"].read())["message"])

Ten en cuenta que el ejemplo anterior usa el atributo opcional includeMetering . includeMetering: True hace que Pegasus 1.5 añada dos campos de facturación a la respuesta no transmitida: outputTokenCount y inputVideoSecond (la duración del video analizado en segundos).

Transmitir la respuesta

Para aplicaciones interactivas, InvokeModelWithResponseStream devuelve la respuesta en fragmentos a medida que se genera. Cada fragmento contiene la siguiente parte del texto en message:

response = bedrock_runtime.invoke_model_with_response_stream(
    modelId=MODEL_ID,
    body=json.dumps(payload)
)
for event in response["body"]:
    chunk = json.loads(event["chunk"]["bytes"])
    print(chunk.get("message", ""), end="", flush=True)
print()

Devolver JSON estructurado

En modo general, puedes limitar la respuesta a un JSON Schema para que el código posterior pueda analizarla directamente. Establece responseFormat.type en json_schema y coloca el esquema bajo jsonSchema. La respuesta llega en message como una cadena JSON:

payload = {
    "inputPrompt": "Analyze this video and return a structured summary.",
    "mediaSource": {
        "s3Location": {
            "uri": "s3://amzn-s3-demo-pegasus-15/your-video.mp4",
            "bucketOwner": "your-account-id"
        }
    },
    "temperature": 0,
    "maxOutputTokens": 2048,
    "includeMetering": True,
    "responseFormat": {
        "type": "json_schema",
        "jsonSchema": {
            "type": "object",
            "properties": {
                "summary": {"type": "string"},
                "key_scenes": {"type": "array", "items": {"type": "string"}},
                "setting": {"type": "string"}
            },
            "required": ["summary", "key_scenes", "setting"]
        }
    }
}
response = bedrock_runtime.invoke_model(modelId=MODEL_ID, body=json.dumps(payload))
summary = json.loads(json.loads(response["body"].read())["message"])
print(summary["summary"])
for scene in summary["key_scenes"]:
    print(" -", scene)

Segmentación de video: convertir el video en datos estructurados

La generación de metadatos basada en el tiempo es donde Pegasus 1.5 difiere más de las versiones anteriores. En lugar de un prompt, envías una o más definiciones de segmento, y el modelo devuelve cada segmento del video que coincide con cada una.

Establece analysisMode a time_based_metadata y responseFormat.type a segment_definitions. Las definiciones ocupan el lugar de inputPrompt, así que omite ese campo. Cada definición tiene:

• id: un nombre para la definición, que se devuelve en cada segmento que coincida.
• description: cómo es un segmento que coincide.
• fields: los valores a extraer para cada segmento, cada uno con un name, un type (string, boolean, number, integer, array, o timestamp), y un description.

El siguiente ejemplo identifica cada sección editorial en un noticiero y devuelve un título, un resumen y los temas clave de cada una:

payload = {
    "analysisMode": "time_based_metadata",
    "mediaSource": {
        "s3Location": {
            "uri": "s3://amzn-s3-demo-pegasus-15/news-broadcast.mp4",
            "bucketOwner": "your-account-id"
        }
    },
    "responseFormat": {
        "type": "segment_definitions",
        "segmentTimeFormat": "hh:mm:ss",
        "segmentDefinitions": [
            {
                "id": "editorial_section",
                "description": "A distinct editorial section of the broadcast, "
                "such as a new story, topic, or segment of the program.",
                "fields": [
                    {"name": "segment_title", "type": "string",
                     "description": "A descriptive title"},
                    {"name": "summary", "type": "string",
                     "description": "A brief summary of the segment content"},
                    {"name": "key_topics", "type": "array", "items": {"type": "string"},
                     "description": "Main topics discussed"}
                ]
            }
        ]
    },
    "temperature": 0,
    "maxOutputTokens": 32768,
    "includeMetering": True
}
response = bedrock_runtime.invoke_model(
    modelId=MODEL_ID,
    contentType="application/json",
    accept="application/json",
    body=json.dumps(payload)
)
result = json.loads(response["body"].read())
for segment in result["segments"]:
    print(segment["start_sec"], "-", segment["end_sec"], segment["segment_title"])
    print(" ", segment["summary"])
    print(" topics:", ", ".join(segment["key_topics"]))

El código de ejemplo anterior, al probarse con un clip deportivo, puede producir una salida como la del siguiente ejemplo.

{
    "segments": [
        {
            "start_sec": "00:04:24",
            "end_sec": "00:05:22",
            "segment_title": "Substitutions and Added Time",
            "summary": "The referee announces three minutes of added time, and both teams make substitutions in preparation for a potential penalty shootout.",
            "key_topics": ["Substitutions", "Added time", "Penalty shootout preparation", "Tactical changes"]
        },
        {
            "start_sec": "00:05:22",
            "end_sec": "00:08:57",
            "segment_title": "Last Gasp Attempts and Final Whistle",
            "summary": "The final minutes of the match see intense action from both sides, with several close calls before the referee blows the final whistle, ending the game in a 3-3 draw.",
            "key_topics": ["Final whistle", "Draw"]
        },
        {
            "start_sec": "00:08:57",
            "end_sec": "00:09:29",
            "segment_title": "Match Conclusion and Penalty Shootout Setup",
            "summary": "The match concludes with a 3-3 draw, leading to a penalty shootout. Players from both teams shake hands and prepare for the decisive moments.",
            "key_topics": ["Match conclusion", "Penalty shootout", "Player handshakes", "Final"]
        }
    ],
    "definition_errors": [],
    "input_tokens": 249408,
    "output_tokens": 802,
    "stopReason": "stop",
    "finish_reason": "stop"
}

Cada segmento incluye start_sec, end_sec, y el fields que definiste. segmentTimeFormat controla cómo se escriben los tiempos: seconds devuelve números sobre los que puedes hacer aritmética, mientras que hh:mm:ss y hh:mm:ss.fff devuelven marcas de tiempo legibles como cadenas. La respuesta también incluye una definition_errors lista, que está vacía cuando todas las definiciones fueron procesadas.

Una sola solicitud puede incluir múltiples definiciones de segmento, por ejemplo una para secciones editoriales y otra para apariciones de marcas en pantalla. Pegasus 1.5 devuelve las coincidencias de todas ellas en una sola segments lista, y etiqueta cada segmento con _definition_id para que puedas distinguirlas. El siguiente ejemplo añade una segunda definición a la solicitud anterior y agrupa los resultados:

from collections import defaultdict

payload["responseFormat"]["segmentDefinitions"].append({
    "id": "brand_appearance",
    "description": "A shot where a company logo or branded product "
    "is clearly visible on screen.",
    "fields": [
        {"name": "brand", "type": "string", "description": "The brand shown"},
        {"name": "is_prominent", "type": "boolean",
         "description": "Whether the brand is the main focus of the shot"}
    ]
})
response = bedrock_runtime.invoke_model(modelId=MODEL_ID, body=json.dumps(payload))
result = json.loads(response["body"].read())
by_definition = defaultdict(list)
for segment in result["segments"]:
    by_definition[segment["_definition_id"]].append(segment)
for definition_id, segments in by_definition.items():
    print(definition_id, len(segments), "segments")

Como el esquema se define una sola vez, las mismas definiciones pueden aplicarse en toda una biblioteca de videos, produciendo metadatos consistentes para cada recurso.

Prompting multimodal: añadir contexto visual a tus consultas

Pegasus 1.5 introduce el prompting multimodal, por lo que puedes incluir imágenes de referencia junto con tus prompts de texto. Esto es útil cuando quieres preguntarle al modelo sobre objetos, personas o escenas específicas que son más fáciles de mostrar que de describir.

Por ejemplo, puedes proporcionar la imagen de un producto y pedirle al modelo que identifique cada momento en el que ese producto aparece en un video. O puedes proporcionar una imagen de referencia de un logotipo específico y pedirle al modelo que detecte las apariciones de la marca y sus marcas de tiempo. Esta capacidad mejora la precisión del análisis de video y abre casos de uso como la monitorización visual de marcas, el análisis de product placement y la búsqueda de contenido guiada por imágenes.

Las imágenes de referencia se adjuntan de manera diferente según el modo. En el modo general, colócalas en promptV2.mediaSources, junto con la pregunta en promptV2.inputText. En modo de segmentación (analysisMode: time_based_metadata), adjúntelos al mediaSources de cada definición de segmento dentro de responseFormat.segmentDefinitions. Una definición puede entonces coincidir con una referencia visual así como con una descripción de texto. Cada imagen necesita un name, un media_type de image, y exactamente una fuente: ya sea un base64String en línea o un s3Location con uri y bucketOwner. Una sola solicitud puede contener hasta 30 imágenes de referencia.

Una solicitud en modo general le pregunta al modelo sobre un objeto mostrado en una imagen de referencia. La siguiente carga útil y respuesta de ejemplo proporcionan un ejemplo en modo general.

payload = {
    "analysisMode": "general",
    "mediaSource": {"s3Location": {"uri": "s3://...", "bucketOwner": "..."}},
    "promptV2": {
        "inputText": "Does the object in the reference image appear in this video?",
        "mediaSources": [
            {"name": "ref1", "media_type": "image", "base64String": "..."}
        ]
    }
    …
}

{
    "input_tokens": 144,
    "output_tokens": 11,
    "message": "Yes, the green canoe appears in the video.",
    "stopReason": "stop"
}

En modo de segmentación, la imagen de referencia se encuentra dentro de la definición, por lo que Pegasus devuelve solo los segmentos donde aparece ese producto. La siguiente carga útil y respuesta de ejemplo proporcionan un ejemplo en modo de segmentación.

payload = {
    "analysisMode": "time_based_metadata",
    "mediaSource": {"s3Location": {"uri": "s3://...", "bucketOwner": "..."}},
    "responseFormat": {
        "type": "segment_definitions",
        "segmentTimeFormat": "hh:mm:ss",
        "segmentDefinitions": [
            {
                "id": "product_appearance",
                "description": "A shot showing the product in the reference image",
                "fields": [
                    {"name": "what", "type": "string", "description": "what is on screen"}
                ],
                "mediaSources": [
                    {"name": "ref1", "media_type": "image",
                     "s3Location": {"uri": "s3://...", "bucketOwner": "..."}}
                ]
            }
        ]
    }
}

{
    "segments": [
        {"start_sec": "00:00:00", "end_sec": "00:00:02",
         "what": "A family of four in a green canoe, paddling on a calm river surrounded by towering red rock formations."},
        {"start_sec": "00:00:09", "end_sec": "00:00:10",
         "what": "The family back in the canoe, paddling away from the shore, with the children smiling and enjoying the serene surroundings."}
    ],
    "definition_errors": [],
    "input_tokens": 4498,
    "output_tokens": 292,
    "stopReason": "stop",
    "finish_reason": "stop"
}

Monitoreo del uso

Pegasus 1.5 publica métricas de Amazon CloudWatch en el espacio de nombres AWS/Bedrock bajo su ID de modelo, incluyendo Invocations, OutputTokenCount, InvocationLatency, y InvocationClientErrors. Úselas para supervisar el volumen y la latencia. Combínelas con perfiles de inferencia de aplicación cuando necesite el uso desglosado por aplicación.

Casos de uso

Pegasus 1.5 está diseñado para organizaciones que gestionan grandes volúmenes de video de formato largo:

• Archivos de noticias y radiodifusión: Los equipos pueden definir segmentos editoriales, temas y cambios de orador una sola vez, y luego catalogar años de material que antes solo era buscable por palabras clave de transcripciones.
• Emisoras y ligas deportivas: Detectar jugadas, eventos de anotación y otros momentos clave en material de juegos completos, acelerando la producción de resúmenes.
• Aplicaciones de streaming: Los metadatos a nivel de escena admiten recomendaciones basadas en momentos, ubicación contextual de anuncios y revisión de seguridad de marca a nivel de segmento.

En cada caso, las personas siguen siendo parte del flujo de trabajo. Su trabajo pasa de encontrar y etiquetar cada momento a mano a revisar y refinar los metadatos generados por el modelo.

Requisitos de entrada

Pegasus 1.5 admite las siguientes especificaciones de video:

• Duración: Hasta 2 horas.
• Tamaño del archivo: Hasta 2 GB desde Amazon S3, o hasta 25 MB como cadena base64.
• Resolución: De 360×360 a 5184×2160.
• Relación de aspecto: Entre 1:1 y 2.4:1, o sus inversas.
• Formatos: Formatos compatibles con FFmpeg.

Ya disponible

TwelveLabs Pegasus 1.5 está disponible hoy en Amazon Bedrock en la Región de AWS US West (Oregon). Consulte la lista completa de Regiones para conocer futuras actualizaciones, y visite la página de precios de Amazon Bedrock para obtener información sobre precios. Pegasus 1.5 se factura a través de AWS Marketplace, por lo que sus cargos aparecen en su factura de AWS y en AWS Cost Explorer bajo TwelveLabs en lugar de Amazon Bedrock.

Para empezar:

• Visite la página de modelos de TwelveLabs en Amazon Bedrock para obtener más información sobre la familia de modelos.
• Revise la ficha del modelo Pegasus 1.5 para conocer la compatibilidad de funciones, la disponibilidad por Región y código de ejemplo.
• Envíenos sus comentarios en AWS re:Post para Amazon Bedrock o a través de sus contactos habituales de AWS Support.

Estamos deseando ver lo que construya con TwelveLabs Pegasus 1.5 en Amazon Bedrock.

Sobre los autores