Pegasus 1.5 de TwelveLabs est désormais disponible dans Amazon Bedrock

Le 9 octobre 2026, nous avons annoncé la disponibilité de Pegasus 1.5 de TwelveLabs sur Amazon Bedrock. Pegasus 1.5 est un modèle de langage vidéo qui transforme les vidéos longues en métadonnées structurées et horodatées. Vous décrivez les moments qui comptent pour votre flux de travail, et le modèle renvoie chaque segment correspondant en JSON.

La vidéo représente une catégorie importante et complexe de données non structurées, mais la plupart restent introuvables et sous-exploitées. Extraire des insights structurés et exploitables de ce contenu a historiquement nécessité une revue manuelle fastidieuse ou des chaînes d'outils fragmentées.

Avec les versions précédentes de Pegasus, vous pouviez pointer le modèle vers un clip, poser une question et obtenir une réponse. Désormais, Pegasus 1.5 analyse l'intégralité de la vidéo, trouve chaque segment correspondant aux critères définis par l'utilisateur et renvoie des métadonnées structurées et horodatées. Il introduit également la segmentation vidéo, l'invite multimodale avec images de référence et le traitement à la volée.

Avec Pegasus 1.5 sur Amazon Bedrock, vous pouvez analyser des vidéos directement depuis un URI Amazon Simple Storage Service (Amazon S3) ou une chaîne base64 sans pré-indexation préalable, et vos données restent dans la limite des données AWS.

Dans cet article, nous couvrons les nouveautés de Pegasus 1.5, comment le modèle est empaqueté sur Amazon Bedrock et comment envoyer votre première requête. Nous passons ensuite en revue la segmentation vidéo, la sortie JSON structurée et l'invite multimodale.

Nouveautés de Pegasus 1.5

Pegasus 1.5 présente les changements suivants par rapport aux versions précédentes :

• Génération de métadonnées basée sur le temps. Vous définissez les segments, événements ou signaux propres à votre domaine qui comptent pour votre flux de travail, tels que des segments éditoriaux, des actions sportives, des changements de locuteur ou des apparitions de marque. Pegasus 1.5 renvoie chaque segment correspondant en JSON, avec les heures de début et de fin ainsi que les champs demandés remplis.
• Invite multimodale. Une définition de segment peut combiner une description textuelle avec une référence visuelle. Cela permet de localiser un produit, un logo ou une personne spécifique, ainsi que ce qu'elle fait à l'écran.
• Traitement à la volée. Aucun pipeline d'ingestion ni étape de pré-indexation n'est requis. Les vidéos sont envoyées directement depuis Amazon S3 et les résultats sont renvoyés dans la réponse.
• Capacité de traitement étendue. Pegasus 1.5 analyse des vidéos allant jusqu'à deux heures en une seule requête, contre une heure pour Pegasus 1.2.

Pegasus 1.5 conserve et améliore les capacités principales qui ont fait de Pegasus 1.2 un outil puissant pour la compréhension vidéo, notamment :

• Génération vidéo-texte: Crée des descriptions textuelles détaillées à partir du contenu vidéo.
• Compréhension visuelle granulaire: Analyse les objets, le texte à l'écran et le contenu numérique dans les images vidéo.
• Ancrage temporel: Identifie avec précision les horodatages d'événements spécifiques dans les vidéos.
• Compréhension multimodale: Combine les informations visuelles, audio et textuelles pour une analyse complète.
• Prise en charge multilingue: Prise en charge complète de l'anglais, avec prise en charge partielle de l'arabe, du chinois, du français, de l'allemand, de l'italien, du japonais, du coréen, du portugais, du russe, de l'espagnol, du thaï et du vietnamien.

Fonctionnement de Pegasus 1.5 sur Amazon Bedrock

Pegasus 1.5 prend en entrée une vidéo et soit une invite textuelle, soit un ensemble de définitions de segments, et renvoie du texte ou du JSON. Vous l'appelez sur le bedrock-runtime endpoint avec l' InvokeModel API, ou avec InvokeModelWithResponseStream lorsque vous souhaitez que la réponse soit diffusée en continu au fur et à mesure de sa génération.

Chaque requête s'exécute dans l'un des deux modes d'analyse, choisi avec le champ analysisMode :

Vous pouvez pointer le modèle vers une vidéo de deux manières. Un emplacement S3 (s3Location) prend le uri de l'objet et l'identifiant de compte bucketOwner , et convient aux vidéos longues. Une chaîne base64 (base64String) intègre la vidéo dans le corps de la requête, jusqu'à 25 Mo, et convient aux clips courts.

Pour suivre les coûts par application, créez un profil d'inférence d'application à partir du modèle Pegasus 1.5, étiquetez-le et appelez-le via son Amazon Resource Name (ARN) à la place de l'identifiant du modèle.

Premiers pas avec Pegasus 1.5

La section suivante décrit comment démarrer avec Pegasus 1.5.

Prérequis

Avant de commencer, assurez-vous de disposer de :

1. Un compte AWS actif avec accès à Amazon Bedrock.
2. Python 3.10 ou version ultérieure, avec le SDK AWS pour Python (Boto3) installé.
3. Des autorisations AWS Identity and Access Management (IAM) pour bedrock:InvokeModel et bedrock:InvokeModelWithResponseStream.
4. L'accès au modèle activé pour TwelveLabs Pegasus 1.5 dans la console Amazon Bedrock.
5. Des vidéos stockées dans un compartiment Amazon S3, ou des clips courts que vous pouvez envoyer en ligne.

La politique suivante accorde les deux autorisations d'invocation sur 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 signe les requêtes avec vos identifiants AWS habituels. Vous pouvez aussi vous authentifier avec une clé d'API Amazon Bedrock en la définissant dans la AWS_BEARER_TOKEN_BEDROCK variable d'environnement. En production, préférez une clé à court terme générée à partir de vos identifiants IAM avec le aws-bedrock-token-generator package, car elle expire automatiquement. L'authentification par jeton Bearer nécessite également l'autorisation bedrock:CallWithBearerToken .

Envoyez votre première requête

Installez Boto3 :

pip install boto3

L'exemple suivant analyse une vidéo stockée dans Amazon S3 en mode général. Cet exemple utilise le point de terminaison global Cross Region Inference (CRIS). Pour cibler le point de terminaison géographique US à la place, remplacez « global. » par « us. » dans l'URL du point de terminaison.

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 réponse contient la réponse dans message, les nombres de jetons dans input_tokens et output_tokens, et la raison de la fin de la génération dans stopReason. Un stopReason de length signifie que la réponse a atteint maxOutputTokens avant de se terminer, vérifiez-la donc avant de vous fier au résultat :

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"])

Champs de requête pour le mode général :

Pour un clip court, vous pouvez envoyer la vidéo en ligne au lieu de depuis 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"])

Notez que l'exemple précédent utilise l'attribut optionnel includeMetering . includeMetering: True fait en sorte que Pegasus 1.5 ajoute deux champs d'utilisation de facturation à la réponse non-streaming : outputTokenCount et inputVideoSecond (la durée de la vidéo analysée en secondes).

Streamer la réponse

Pour les applications interactives, InvokeModelWithResponseStream renvoie la réponse par morceaux au fur et à mesure de sa génération. Chaque morceau contient le prochain fragment de texte dans 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()

Renvoyer du JSON structuré

En mode général, vous pouvez contraindre la réponse à un JSON Schema afin que le code en aval puisse l'analyser directement. Définissez responseFormat.type sur json_schema et placez le schéma sous jsonSchema. La réponse arrive dans message sous forme de chaîne 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)

Segmentation vidéo : transformer la vidéo en données structurées

La génération de métadonnées temporelles est ce qui distingue le plus Pegasus 1.5 des versions précédentes. Au lieu d'une invite, vous envoyez une ou plusieurs définitions de segments, et le modèle renvoie chaque segment de la vidéo qui correspond à chacune d'elles.

Définissez analysisMode sur time_based_metadata et responseFormat.type sur segment_definitions. Les définitions remplacent inputPrompt, laissez donc ce champ de côté. Chaque définition contient :

• id: un nom pour la définition, renvoyé sur chaque segment auquel elle correspond.
• description: à quoi ressemble un segment correspondant.
• fields: les valeurs à extraire pour chaque segment, chacune avec un name, un type (string, boolean, number, integer, array, ou timestamp), et un description.

L'exemple suivant identifie chaque section éditoriale d'un journal télévisé et renvoie un titre, un résumé et les sujets clés pour chacune :

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"]))

Le code d'exemple précédent, testé sur un extrait sportif, peut produire une sortie semblable à l'exemple suivant.

{
    "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"
}

Chaque segment comporte start_sec, end_sec, ainsi que le fields que vous avez défini. segmentTimeFormat contrôle la manière dont les heures sont écrites : seconds renvoie des nombres sur lesquels vous pouvez faire des calculs, tandis que hh:mm:ss et hh:mm:ss.fff renvoient des horodatages lisibles sous forme de chaînes. La réponse inclut également une liste definition_errors , qui est vide lorsque toutes les définitions ont été traitées.

Une seule requête peut inclure plusieurs définitions de segments, par exemple une pour les sections éditoriales et une autre pour les apparitions de marques à l'écran. Pegasus 1.5 renvoie les correspondances pour toutes dans une seule liste segments , et marque chaque segment avec _definition_id afin que vous puissiez les distinguer. L'exemple suivant ajoute une seconde définition à la requête précédente et regroupe les résultats :

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

Comme le schéma est défini une seule fois, les mêmes définitions peuvent être appliquées à l'ensemble d'une vidéothèque, produisant des métadonnées cohérentes pour chaque actif.

Invitation multimodale : ajouter un contexte visuel à vos requêtes

Pegasus 1.5 introduit l'invitation multimodale, qui vous permet d'inclure des images de référence à côté de vos invites textuelles. C'est utile lorsque vous voulez interroger le modèle sur des objets, des personnes ou des scènes précis qu'il est plus facile de montrer que de décrire.

Par exemple, vous pouvez fournir l'image d'un produit et demander au modèle d'identifier chaque moment où ce produit apparaît dans une vidéo. Ou vous pouvez fournir une image de référence d'un logo spécifique et demander au modèle de détecter les apparitions de marques et leurs horodatages. Cette capacité renforce la précision de l'analyse vidéo et ouvre des cas d'usage tels que la surveillance visuelle de marques, l'analyse de placement de produits et la recherche de contenu guidée par l'image.

Les images de référence se joignent différemment selon le mode. En mode général, placez-les dans promptV2.mediaSources, aux côtés de la question dans promptV2.inputText. En mode segmentation (analysisMode: time_based_metadata), associez-les au mediaSources de chaque définition de segment dans responseFormat.segmentDefinitions. Une définition peut alors correspondre à la fois à une référence visuelle et à une description textuelle. Chaque image nécessite un name, un media_type de image, et exactement une source : soit un base64String en ligne, soit un s3Location avec uri et bucketOwner. Une seule requête peut contenir jusqu'à 30 images de référence.

Une requête en mode général pose une question au modèle au sujet d'un objet présenté dans une image de référence. L'exemple de charge utile et de réponse suivant fournit un exemple en mode général.

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 mode segmentation, l'image de référence se trouve à l'intérieur de la définition, de sorte que Pegasus ne renvoie que les segments où ce produit apparaît. L'exemple de charge utile et de réponse suivant fournit un exemple en mode segmentation.

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

Surveillance de l'utilisation

Pegasus 1.5 publie des métriques Amazon CloudWatch dans l'espace de noms AWS/Bedrock sous son identifiant de modèle, notamment Invocations, OutputTokenCount, InvocationLatency, et InvocationClientErrors. Utilisez-les pour suivre le volume et la latence. Associez-les à des profils d'inférence d'application lorsque vous avez besoin d'une utilisation répartie par application.

Cas d'utilisation

Pegasus 1.5 est conçu pour les organisations qui gèrent de grands volumes de vidéos longues :

• Archives d'actualités et de diffusion: Les équipes peuvent définir une fois les segments éditoriaux, les sujets et les changements de locuteur, puis cataloguer des années de séquences précédemment consultables uniquement par mots-clés de transcription.
• Diffuseurs et ligues sportives: Détecter les jeux, les événements de marquage de points et autres moments clés sur des séquences de matchs complets, accélérant la production de résumés.
• Applications de streaming: Les métadonnées au niveau des scènes prennent en charge les recommandations basées sur les moments, le placement publicitaire contextuel et l'examen de la sécurité de marque au niveau des segments.

Dans chaque cas, les humains restent partie prenante du flux de travail. Leur travail passe de la recherche et du balisage manuels de chaque moment à la révision et au raffinement des métadonnées générées par le modèle.

Exigences d'entrée

Pegasus 1.5 prend en charge les spécifications vidéo suivantes :

• Durée: Jusqu'à 2 heures.
• Taille du fichier: jusqu'à 2 Go depuis Amazon S3, ou jusqu'à 25 Mo sous forme de chaîne base64.
• Résolution: de 360×360 à 5184×2160.
• Format d'image: entre 1:1 et 2.4:1, ou leurs inverses.
• Formats: formats pris en charge par FFmpeg.

Désormais disponible

TwelveLabs Pegasus 1.5 est disponible dès aujourd'hui sur Amazon Bedrock dans la Région AWS US West (Oregon). Consultez la liste complète des Régions pour les futures mises à jour, et visitez la page de tarification d'Amazon Bedrock pour obtenir des informations sur les prix. Pegasus 1.5 est facturé via AWS Marketplace, ses frais apparaissent donc sur votre facture AWS et dans AWS Cost Explorer sous TwelveLabs plutôt que sous Amazon Bedrock.

Pour commencer :

• Visitez la page des modèles TwelveLabs sur Amazon Bedrock pour en savoir plus sur cette famille de modèles.
• Consultez la fiche du modèle Pegasus 1.5 pour la prise en charge des fonctionnalités, la disponibilité par Région et des exemples de code.
• Envoyez-nous vos commentaires sur AWS re:Post pour Amazon Bedrock ou par l'intermédiaire de vos contacts AWS Support habituels.

Nous avons hâte de découvrir ce que vous réaliserez avec TwelveLabs Pegasus 1.5 dans Amazon Bedrock.

À propos des auteurs