Videoinhalte erkennen

Gemini-Modelle können Videos verarbeiten und ermöglichen so viele neue Anwendungsfälle für Entwickler, für die bisher domänenspezifische Modelle erforderlich waren. Zu den Funktionen von Gemini gehören:

  • Videos mit einer Länge von bis zu 90 Minuten beschreiben, segmentieren und Informationen daraus extrahieren
  • Fragen zu Videoinhalten beantworten
  • Auf bestimmte Zeitstempel in einem Video verweisen

Gemini wurde von Grund auf als multimodales Modell entwickelt und wir erweitern ständig die Grenzen des Möglichen. In diesem Leitfaden wird gezeigt, wie Sie mit der Gemini API Textantworten auf der Grundlage von Videoinputs generieren.

Hinweis

Bevor Sie die Gemini API aufrufen, müssen Sie das von Ihnen ausgewählte SDK installiert und einen Gemini API-Schlüssel konfiguriert und einsatzbereit haben.

Videoeingang

Sie haben folgende Möglichkeiten, Videos als Eingabe für Gemini bereitzustellen:

Videodatei hochladen

Sie können die Files API verwenden, um eine Videodatei hochzuladen. Verwenden Sie immer die Files API, wenn die Gesamtgröße der Anfrage (einschließlich Datei, Textprompt, Systemanweisungen usw.) mehr als 20 MB beträgt, die Videodauer erheblich ist oder Sie dasselbe Video in mehreren Prompts verwenden möchten.

Die File API akzeptiert Videodateiformate direkt. In diesem Beispiel wird der kurze NASA-Film „Jupiter's Great Red Spot Shrinks and Grows“ (Der Große Rote Fleck des Jupiters schrumpft und wächst) verwendet. Quelle: Goddard Space Flight Center (GSFC)/David Ladd (2018).

„Jupiter's Great Red Spot Shrinks and Grows“ ist gemeinfrei und zeigt keine erkennbaren Personen. (Richtlinien für die Nutzung von NASA-Bildern und -Medien)

Im folgenden Code wird das Beispielvideo heruntergeladen, mit der File API hochgeladen, auf die Verarbeitung gewartet und dann die Dateireferenz in einer generateContent-Anfrage verwendet.

Python

from google import genai

client = genai.Client(api_key="GOOGLE_API_KEY")

myfile = client.files.upload(file="path/to/sample.mp4")

response = client.models.generate_content(
    model="gemini-2.0-flash", contents=[myfile, "Summarize this video. Then create a quiz with an answer key based on the information in this video."]
)

print(response.text)

JavaScript

import {
  GoogleGenAI,
  createUserContent,
  createPartFromUri,
} from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const myfile = await ai.files.upload({
    file: "path/to/sample.mp4",
    config: { mimeType: "video/mp4" },
  });

  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash",
    contents: createUserContent([
      createPartFromUri(myfile.uri, myfile.mimeType),
      "Summarize this video. Then create a quiz with an answer key based on the information in this video.",
    ]),
  });
  console.log(response.text);
}

await main();

Ok

file, err := client.UploadFileFromPath(ctx, "path/to/sample.mp4", nil)
if err != nil {
    log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

model := client.GenerativeModel("gemini-2.0-flash")
resp, err := model.GenerateContent(ctx,
    genai.FileData{URI: file.URI},
    genai.Text("Summarize this video. Then create a quiz with an answer key based on the information in this video."))
if err != nil {
    log.Fatal(err)
}

printResponse(resp)

REST

VIDEO_PATH="path/to/sample.mp4"
MIME_TYPE=$(file -b --mime-type "${VIDEO_PATH}")
NUM_BYTES=$(wc -c < "${VIDEO_PATH}")
DISPLAY_NAME=VIDEO

tmp_header_file=upload-header.tmp

echo "Starting file upload..."
curl "https://generativelanguage.googleapis.com/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
  -D ${tmp_header_file} \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

echo "Uploading video data..."
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${VIDEO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq -r ".file.uri" file_info.json)
echo file_uri=$file_uri

echo "File uploaded successfully. File URI: ${file_uri}"

# --- 3. Generate content using the uploaded video file ---
echo "Generating content from video..."
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"file_data":{"mime_type": "'"${MIME_TYPE}"'", "file_uri": "'"${file_uri}"'"}},
          {"text": "Summarize this video. Then create a quiz with an answer key based on the information in this video."}]
        }]
      }' 2> /dev/null > response.json

jq -r ".candidates[].content.parts[].text" response.json

Weitere Informationen zur Arbeit mit Mediendateien findest du unter Files API.

Videodaten inline übergeben

Anstatt eine Videodatei mit der File API hochzuladen, kannst du kleinere Videos direkt in der Anfrage an generateContent übergeben. Diese Option eignet sich für kürzere Videos mit einer Gesamtanfragegröße von weniger als 20 MB.

Hier ein Beispiel für die Bereitstellung von Inline-Videodaten:

Python

# Only for videos of size <20Mb
video_file_name = "/path/to/your/video.mp4"
video_bytes = open(video_file_name, 'rb').read()

response = client.models.generate_content(
    model='models/gemini-2.0-flash',
    contents=types.Content(
        parts=[
            types.Part(
                inline_data=types.Blob(data=video_bytes, mime_type='video/mp4')
            ),
            types.Part(text='Please summarize the video in 3 sentences.')
        ]
    )
)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });
const base64VideoFile = fs.readFileSync("path/to/small-sample.mp4", {
  encoding: "base64",
});

const contents = [
  {
    inlineData: {
      mimeType: "video/mp4",
      data: base64VideoFile,
    },
  },
  { text: "Please summarize the video in 3 sentences." }
];

const response = await ai.models.generateContent({
  model: "gemini-2.0-flash",
  contents: contents,
});
console.log(response.text);

REST

VIDEO_PATH=/path/to/your/video.mp4

if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
            {
              "inline_data": {
                "mime_type":"video/mp4",
                "data": "'$(base64 $B64FLAGS $VIDEO_PATH)'"
              }
            },
            {"text": "Please summarize the video in 3 sentences."}
        ]
      }]
    }' 2> /dev/null

YouTube-URL einfügen

Die Gemini API und AI Studio unterstützen YouTube-URLs als DateidatenPart. Sie können eine YouTube-URL mit einem Prompt angeben, in dem das Modell aufgefordert wird, die Videoinhalte zusammenzufassen, zu übersetzen oder anderweitig damit zu interagieren.

Beschränkungen:

  • Pro Tag kannst du nicht mehr als 8 Stunden an YouTube-Videos hochladen.
  • Sie können pro Anfrage nur ein Video hochladen.
  • Du kannst nur öffentliche Videos hochladen, keine privaten oder nicht gelisteten Videos.

Im folgenden Beispiel wird gezeigt, wie eine YouTube-URL in einen Prompt eingefügt wird:

Python

response = client.models.generate_content(
    model='models/gemini-2.0-flash',
    contents=types.Content(
        parts=[
            types.Part(
                file_data=types.FileData(file_uri='https://www.youtube.com/watch?v=9hE5-98ZeCg')
            ),
            types.Part(text='Please summarize the video in 3 sentences.')
        ]
    )
)

JavaScript

import { GoogleGenerativeAI } from "@google/generative-ai";

const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-1.5-pro" });
const result = await model.generateContent([
  "Please summarize the video in 3 sentences.",
  {
    fileData: {
      fileUri: "https://www.youtube.com/watch?v=9hE5-98ZeCg",
    },
  },
]);
console.log(result.response.text());

Ok

ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GOOGLE_API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-2.0-flash")
resp, err := model.GenerateContent(ctx,
  genai.FileData{URI: "https://www.youtube.com/watch?v=9hE5-98ZeCg"},
  genai.Text("Please summarize the video in 3 sentences."))
if err != nil {
  log.Fatal(err)
}

// Handle the response of generated text.
for _, c := range resp.Candidates {
  if c.Content != nil {
    fmt.Println(*c.Content)
  }
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
            {"text": "Please summarize the video in 3 sentences."},
            {
              "file_data": {
                "file_uri": "https://www.youtube.com/watch?v=9hE5-98ZeCg"
              }
            }
        ]
      }]
    }' 2> /dev/null

Zeitstempel in den Inhalten

Du kannst Fragen zu bestimmten Zeitpunkten im Video stellen, indem du Zeitstempel vom Typ MM:SS verwendest.

Python

prompt = "What are the examples given at 00:05 and 00:10 supposed to show us?" # Adjusted timestamps for the NASA video

JavaScript

const prompt = "What are the examples given at 00:05 and 00:10 supposed to show us?";

Ok

    prompt := []genai.Part{
        genai.FileData{URI: currentVideoFile.URI, MIMEType: currentVideoFile.MIMEType},
         // Adjusted timestamps for the NASA video
        genai.Text("What are the examples given at 00:05 and " +
            "00:10 supposed to show us?"),
    }

REST

PROMPT="What are the examples given at 00:05 and 00:10 supposed to show us?"

Video transkribieren und visuelle Beschreibungen hinzufügen

Die Gemini-Modelle können Videoinhalte transkribieren und visuelle Beschreibungen liefern, indem sie sowohl den Audiotrack als auch die visuellen Frames verarbeiten. Für visuelle Beschreibungen wird das Video vom Modell mit einer Rate von 1 Frame pro Sekunde abgetastet. Diese Abtastrate kann sich auf den Detaillierungsgrad der Beschreibungen auswirken, insbesondere bei Videos mit sich schnell ändernden Bildern.

Python

prompt = "Transcribe the audio from this video, giving timestamps for salient events in the video. Also provide visual descriptions."

JavaScript

const prompt = "Transcribe the audio from this video, giving timestamps for salient events in the video. Also provide visual descriptions.";

Ok

    prompt := []genai.Part{
        genai.FileData{URI: currentVideoFile.URI, MIMEType: currentVideoFile.MIMEType},
        genai.Text("Transcribe the audio from this video, giving timestamps for salient events in the video. Also " +
            "provide visual descriptions."),
    }

REST

PROMPT="Transcribe the audio from this video, giving timestamps for salient events in the video. Also provide visual descriptions."

Unterstützte Videoformate

Gemini unterstützt die folgenden MIME-Typen für Videoformate:

  • video/mp4
  • video/mpeg
  • video/mov
  • video/avi
  • video/x-flv
  • video/mpg
  • video/webm
  • video/wmv
  • video/3gpp

Technische Details zu Videos

  • Unterstützte Modelle und Kontext: Alle Gemini 2.0- und 2.5-Modelle können Videodaten verarbeiten.
    • Modelle mit einem Kontextfenster von 2 Millionen Tokens können Videos mit einer Länge von bis zu 2 Stunden verarbeiten. Modelle mit einem Kontextfenster von 1 Million Tokens können Videos mit einer Länge von bis zu 1 Stunde verarbeiten.
  • File API-Verarbeitung: Bei Verwendung der File API werden Videos mit 1 Frame pro Sekunde (FPS) abgetastet und Audio mit 1 Kbit/s (einzelner Kanal) verarbeitet. Zeitstempel werden jede Sekunde hinzugefügt.
    • Diese Preise können sich in Zukunft ändern, wenn die Inferenz verbessert wird.
  • Tokenberechnung: Jede Videosekunde wird so tokenisiert:
    • Einzelne Frames (gemessen bei 1 fps): 258 Tokens pro Frame.
    • Audio: 32 Tokens pro Sekunde.
    • Metadaten sind ebenfalls enthalten.
    • Gesamt: Etwa 300 Tokens pro Video-Sekunde.
  • Zeitstempelformat: Wenn du dich in deinem Prompt auf bestimmte Momente in einem Video beziehst, verwende das Format MM:SS (z.B. 01:15 für 1 Minute und 15 Sekunden).
  • Best Practices:
    • Verwenden Sie für optimale Ergebnisse nur ein Video pro Promptanfrage.
    • Wenn Sie Text und ein einzelnes Video kombinieren, platzieren Sie den Textprompt nach dem Videoteil im contents-Array.
    • Bei schnellen Action-Sequenzen können aufgrund der Abtastrate von 1 fps Details verloren gehen. Du kannst solche Clips bei Bedarf verlangsamen.

Nächste Schritte

In dieser Anleitung wird gezeigt, wie Sie Videodateien hochladen und Textausgaben aus Videoinputs generieren. Weitere Informationen finden Sie in den folgenden Ressourcen:

  • Systemanweisungen: Mit Systemanweisungen können Sie das Verhalten des Modells entsprechend Ihren spezifischen Anforderungen und Anwendungsfällen steuern.
  • Files API: Hier finden Sie weitere Informationen zum Hochladen und Verwalten von Dateien für die Verwendung mit Gemini.
  • Strategien für Prompts aus Dateien: Die Gemini API unterstützt Prompts mit Text-, Bild-, Audio- und Videodaten, auch als multimodale Prompts bezeichnet.
  • Sicherheitshinweise: Manchmal liefern generative KI-Modelle unerwartete Ergebnisse, z. B. ungenaue, voreingenommene oder anstößige Ergebnisse. Eine Nachbearbeitung und eine menschliche Bewertung sind unerlässlich, um das Risiko von Schäden durch solche Ausgaben zu begrenzen.