Pegasus 1.5 von TwelveLabs ist jetzt in Amazon Bedrock verfügbar

Am 9. Oktober 2026 haben wir die Verfügbarkeit von TwelveLabs' Pegasus 1.5 auf Amazon Bedrockangekündigt. Pegasus 1.5 ist ein Video-Sprachmodell, das Langform-Videos in strukturierte, mit Zeitstempeln versehene Metadaten umwandelt. Sie beschreiben die Momente, die für Ihren Workflow relevant sind, und das Modell liefert jedes passende Segment als JSON zurück.

Video stellt eine bedeutende und komplexe Kategorie unstrukturierter Daten dar, doch der Großteil davon bleibt un durchsuchbar und wird kaum genutzt. Die Gewinnung strukturierter, umsetzbarer Erkenntnisse aus diesen Inhalten erforderte bisher arbeitsintensive manuelle Prüfung oder fragmentierte Toolchains.

Mit früheren Versionen von Pegasus können Sie das Modell auf einen Clip richten, eine Frage stellen und eine Antwort erhalten. Jetzt analysiert Pegasus 1.5 das gesamte Video, findet jedes Segment, das benutzerdefinierte Kriterien erfüllt, und liefert strukturierte, mit Zeitstempeln versehene Metadaten zurück. Es führt zudem Videosegmentierung, multimodales Prompting mit Referenzbildern und On-the-fly-Verarbeitung ein.

Mit Pegasus 1.5 auf Amazon Bedrock können Sie Videos direkt über einen Amazon Simple Storage Service (Amazon S3)-URI oder einen Base64-String analysieren, ohne vorherige Indizierung, und Ihre Daten verbleiben innerhalb der AWS-Datengrenze.

In diesem Beitrag behandeln wir, was in Pegasus 1.5 neu ist, wie das Modell auf Amazon Bedrock verpackt ist und wie Sie Ihre erste Anfrage senden. Anschließend gehen wir auf Videosegmentierung, strukturierte JSON-Ausgabe und multimodales Prompting ein.

Was ist neu in Pegasus 1.5

Pegasus 1.5 weist im Vergleich zu früheren Versionen die folgenden Änderungen auf:

• Zeitbasierte Metadatenerstellung. Sie definieren die Segmente, Ereignisse oder domänenspezifischen Signale, die für Ihren Workflow relevant sind, z. B. redaktionelle Segmente, Sportspielzüge, Sprecherwechsel oder Markenauftritte. Pegasus 1.5 liefert jedes passende Segment als JSON zurück, mit Start- und Endzeiten sowie den angeforderten Feldern.
• Multimodales Prompting. Eine Segmentdefinition kann eine Textbeschreibung mit einer visuellen Referenz kombinieren. Dadurch ist es möglich, ein bestimmtes Produkt, Logo oder eine bestimmte Person zu finden – zusammen mit dem, was sie auf dem Bildschirm tun.
• On-the-fly-Verarbeitung. Es ist keine Ingestion-Pipeline und kein vorheriger Indizierungsschritt erforderlich. Videos werden direkt aus Amazon S3 gesendet, und die Ergebnisse werden in der Antwort zurückgegeben.
• Erweiterte Verarbeitungskapazität. Pegasus 1.5 analysiert Videos mit einer Länge von bis zu zwei Stunden in einer einzigen Anfrage, zuvor waren es eine Stunde bei Pegasus 1.2.

Pegasus 1.5 behält die Kernfunktionen bei und erweitert sie, die Pegasus 1.2 zu einem leistungsfähigen Werkzeug für das Videoverständnis gemacht haben, darunter:

• Video-zu-Text-Generierung: Erstellt detaillierte Textbeschreibungen auf Grundlage des Videoinhalts.
• Detailliertes visuelles Verständnis: Analysiert Objekte, Bildschirmtext und numerische Inhalte innerhalb von Videobildern.
• Temporale Verortung: Identifiziert präzise die Zeitstempel bestimmter Ereignisse innerhalb von Videos.
• Multimodales Verständnis: Kombiniert visuelle, audio- und textliche Informationen für eine umfassende Analyse.
• Mehrsprachige Unterstützung: Volle Unterstützung für Englisch, mit teilweiser Unterstützung für Arabisch, Chinesisch, Französisch, Deutsch, Italienisch, Japanisch, Koreanisch, Portugiesisch, Russisch, Spanisch, Thailändisch und Vietnamesisch.

So funktioniert Pegasus 1.5 auf Amazon Bedrock

Pegasus 1.5 nimmt ein Video und entweder einen Text-Prompt oder eine Reihe von Segmentdefinitionen entgegen und gibt Text oder JSON zurück. Man ruft es auf dem bedrock-runtime Endpunkt mit der InvokeModel API auf, oder mit InvokeModelWithResponseStream , wenn die Antwort bereits während der Generierung gestreamt werden soll.

Jede Anfrage läuft in einem von zwei Analysemodi, die mit dem Feld analysisMode gewählt werden:

Sie können das Modell auf zwei Arten auf ein Video verweisen. Ein S3-Speicherort (s3Location) verwendet den uri des Objekts und die bucketOwner Konto-ID und eignet sich für Langvideos. Ein Base64-String (base64String) bettet das Video direkt in den Anfragekörper ein, bis zu 25 MB, und eignet sich für kurze Clips.

Um Kosten pro Anwendung nachzuverfolgen, erstellen Sie ein Anwendungs-Inferenzprofil aus dem Modell Pegasus 1.5, versehen es mit Tags und rufen es über seinen Amazon Resource Name (ARN) anstelle der Modell-ID auf.

Erste Schritte mit Pegasus 1.5

Der folgende Abschnitt beschreibt, wie Sie mit Pegasus 1.5 beginnen.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

1. Ein aktives AWS-Konto mit Zugriff auf Amazon Bedrock.
2. Python 3.10 oder höher, mit dem installierten AWS SDK for Python (Boto3).
3. AWS Identity and Access Management (IAM)-Berechtigungen für bedrock:InvokeModel und bedrock:InvokeModelWithResponseStream.
4. Aktivierten Modellzugriff für TwelveLabs Pegasus 1.5 in der Amazon Bedrock-Konsole.
5. Videos, die in einem Amazon S3-Bucket gespeichert sind, oder kurze Clips, die Sie inline senden können.

Die folgende Richtlinie gewährt beide invoke-Aktionen auf 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 signiert Anfragen mit Ihren üblichen AWS-Anmeldeinformationen. Sie können sich auch mit einem Amazon Bedrock API-Schlüssel authentifizieren, indem Sie ihn in der AWS_BEARER_TOKEN_BEDROCK Umgebungsvariable setzen. Für die Produktion bevorzugen Sie einen kurzfristigen Schlüssel, der aus Ihren IAM-Anmeldeinformationen mit dem aws-bedrock-token-generator Paket generiert wird, da er automatisch abläuft. Die Bearer-Token-Authentifizierung erfordert außerdem die bedrock:CallWithBearerToken Berechtigung.

Senden Sie Ihre erste Anfrage

Installieren Sie Boto3:

pip install boto3

Das folgende Beispiel analysiert ein in Amazon S3 gespeichertes Video im general-Modus. Dieses Beispiel verwendet den globalen Cross Region Inference (CRIS)-Endpunkt. Um stattdessen den geografischen US-Endpunkt anzusprechen, ersetzen Sie „global.“ durch „us.“ in der Endpunkt-URL.

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

Die Antwort enthält die Antwort in message, die Token-Zahlen in input_tokens und output_tokens, und den Grund, warum die Generierung endete, in stopReason. Ein stopReason von length bedeutet, dass die Antwort maxOutputTokens erreicht hat, bevor sie fertig war, daher überprüfen Sie sie, bevor Sie sich auf die Ausgabe verlassen:

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

Anfragefelder für den general-Modus:

Bei einem kurzen Clip können Sie das Video inline statt aus S3 senden:

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

Beachten Sie, dass das vorherige Beispiel das optionale Attribut includeMetering verwendet. includeMetering: True veranlasst Pegasus 1.5, der Nicht-Streaming-Antwort zwei Abrechnungsfelder hinzuzufügen: outputTokenCount und inputVideoSecond (die Dauer des analysierten Videos in Sekunden).

Antwort streamen

Für interaktive Anwendungen gibt InvokeModelWithResponseStream die Antwort in Abschnitten zurück, während sie generiert wird. Jeder Abschnitt enthält den nächsten Textteil in 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()

Strukturiertes JSON zurückgeben

Im allgemeinen Modus können Sie die Antwort auf ein JSON-Schema beschränken, damit nachgelagerter Code sie direkt parsen kann. Setzen Sie responseFormat.type auf json_schema und legen Sie das Schema unter jsonSchemaab. Die Antwort trifft ein in message als JSON-String:

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)

Videosegmentierung: Video in strukturierte Daten umwandeln

Die zeitbasierte Metadatengenerierung ist der Bereich, in dem sich Pegasus 1.5 am stärksten von früheren Versionen unterscheidet. Statt eines Prompts senden Sie eine oder mehrere Segmentdefinitionen, und das Modell gibt jedes Segment des Videos zurück, das zu jeder Definition passt.

Setzen Sie analysisMode auf time_based_metadata und responseFormat.type auf segment_definitions. Die Definitionen nehmen den Platz von inputPromptein, lassen Sie dieses Feld also weg. Jede Definition hat:

• id: einen Namen für die Definition, der bei jedem passenden Segment zurückgegeben wird.
• description: wie ein passendes Segment aussieht.
• fields: die Werte, die für jedes Segment extrahiert werden sollen, jeweils mit einem name, einem type (string, boolean, number, integer, arrayoder timestamp) und einem description.

Das folgende Beispiel identifiziert jede redaktionlle Rubrik in einer Nachrichtensendung und gibt für jede einen Titel, eine Zusammenfassung und die wichtigsten Themen zurück:

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

Der vorherige Beispielcode kann, getestet gegen einen Sportclip, eine Ausgabe wie das folgende Beispiel erzeugen.

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

Jedes Segment enthält start_sec, end_sec, und das fields , das Sie definiert haben. segmentTimeFormat steuert, wie die Zeiten geschrieben werden: seconds liefert Zahlen, mit denen Sie rechnen können, während hh:mm:ss und hh:mm:ss.fff lesbare Zeitstempel als Zeichenketten zurückgeben. Die Antwort enthält außerdem eine definition_errors -Liste, die leer ist, wenn jede Definition verarbeitet wurde.

Eine einzelne Anfrage kann mehrere Segmentdefinitionen enthalten, zum Beispiel eine für redaktionlle Rubriken und eine weitere für Markenauftritte auf dem Bildschirm. Pegasus 1.5 gibt die Treffer für alle in einer einzigen segments -Liste zurück und versieht jedes Segment mit _definition_id , damit Sie sie unterscheiden können. Das folgende Beispiel fügt der vorherigen Anfrage eine zweite Definition hinzu und gruppiert die Ergebnisse:

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

Da das Schema einmalig definiert wird, können dieselben Definitionen auf eine gesamte Videobibliothek angewendet werden, was konsistente Metadaten für jedes Asset erzeugt.

Multimodales Prompting: Visueller Kontext für Ihre Abfragen

Pegasus 1.5 führt multimodales Prompting ein, sodass Sie Referenzbilder zusammen mit Ihren Text-Prompts einbinden können. Dies ist nützlich, wenn Sie dem Modell Fragen zu bestimmten Objekten, Personen oder Szenen stellen möchten, die sich leichter zeigen als beschreiben lassen.

Beispielsweise können Sie ein Produktbild bereitstellen und das Modell bitten, jeden Moment zu identifizieren, in dem dieses Produkt in einem Video erscheint. Oder Sie können ein Referenzbild eines bestimmten Logos bereitstellen und das Modell bitten, Markenauftritte und deren Zeitstempel zu erkennen. Diese Fähigkeit erhöht die Präzision der Videoanalyse und eröffnet Anwendungsfälle wie visuelles Markenmonitoring, Product-Placement-Analyse und bildgestützte Inhaltssuche.

Referenzbilder werden je nach Modus unterschiedlich angehängt. Im allgemeinen Modus fügen Sie sie in promptV2.mediaSources, zusammen mit der Frage in promptV2.inputText. Im Segmentierungsmodus (analysisMode: time_based_metadata) hängen Sie sie an die mediaSources jeder Segmentdefinition innerhalb von responseFormat.segmentDefinitionsan. Eine Definition kann dann sowohl eine visuelle Referenz als auch eine Textbeschreibung abgleichen. Jedes Bild benötigt eine name, ein media_type von imageund genau eine Quelle: entweder ein Inline- base64String oder ein s3Location mit uri und bucketOwner. Eine einzelne Anfrage kann bis zu 30 Referenzbilder enthalten.

Eine Anfrage im Allgemeinen Modus fragt das Modell nach einem Objekt, das in einem Referenzbild gezeigt wird. Die folgende Beispielnutzlast und -antwort liefern ein Beispiel im Allgemeinen Modus.

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

Im Segmentierungsmodus befindet sich das Referenzbild innerhalb der Definition, sodass Pegasus nur die Segmente zurückgibt, in denen dieses Produkt erscheint. Die folgende Beispielnutzlast und -antwort liefern ein Beispiel im Segmentierungsmodus.

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

Nutzungsüberwachung

Pegasus 1.5 veröffentlicht Amazon CloudWatch-Metriken im AWS/Bedrock Namespace unter seiner Modell-ID, einschließlich Invocations, OutputTokenCount, InvocationLatencyund InvocationClientErrors. Verwenden Sie diese, um Volumen und Latenz zu verfolgen. Kombinieren Sie sie mit Anwendungs-Inferenz-Profilen, wenn Sie die Nutzung nach Anwendung aufgeschlüsselt benötigen.

Anwendungsfälle

Pegasus 1.5 ist für Organisationen konzipiert, die große Mengen an Langform-Videos verwalten:

• Nachrichten- und Rundfunkarchive: Teams könnenredaktionelle Segmente, Themen und Sprecherwechsel einmal definieren und dann jahrelanges Material katalogisieren, das zuvor nur über Transkript-Schlüsselwörter durchsuchbar war.
• Sportsender und Ligen: Erkennung von Spielzügen, Torereignissen und anderen Schlüsselmomenten über vollständige Spielaufnahmen hinweg, was die Highlight-Produktion beschleunigt.
• Streaming-Anwendungen: Szenenbasierte Metadaten unterstützen momentenbasierte Empfehlungen, kontextbezogene Werbeplatzierung und Überprüfung der Markensicherheit auf Segmentebene.

In jedem Fall bleiben Menschen Teil des Workflows. Ihre Arbeit verlagert sich davon, jeden Moment von Hand zu finden und zu verschlagworten, hin zur Überprüfung und Verfeinerung der vom Modell generierten Metadaten.

Eingabeanforderungen

Pegasus 1.5 unterstützt die folgenden Videospezifikationen:

• Dauer: Bis zu 2 Stunden.
• Dateigröße: Bis zu 2 GB aus Amazon S3 oder bis zu 25 MB als Base64-String.
• Auflösung: Von 360×360 bis 5184×2160.
• Seitenverhältnis: Zwischen 1:1 und 2.4:1 oder deren Kehrseiten.
• Formate: Von FFmpeg unterstützte Formate.

Jetzt verfügbar

TwelveLabs Pegasus 1.5 ist ab heute auf Amazon Bedrock in der AWS-Region US West (Oregon) verfügbar. Prüfen Sie die vollständige Regionsliste für künftige Updates und besuchen Sie die Preisseite von Amazon Bedrock für Preisinformationen. Pegasus 1.5 wird über den AWS Marketplace abgerechnet, daher erscheinen die Gebühren auf Ihrer AWS-Rechnung und in AWS Cost Explorer unter TwelveLabs und nicht unter Amazon Bedrock.

So legen Sie los:

• Besuchen Sie die TwelveLabs-Modelleseite auf Amazon Bedrock um mehr über die Modellfamilie zu erfahren.
• Sehen Sie sich die Pegasus 1.5-Modellkarte für Funktionsunterstützung, Regionsverfügbarkeit und Beispielcode an.
• Senden Sie uns Feedback über AWS re:Post for Amazon Bedrock oder über Ihre üblichen AWS-Support-Kontakte.

Wir sind gespannt, was Sie mit TwelveLabs Pegasus 1.5 in Amazon Bedrock entwickeln werden.

Über die Autoren