โมเดล Gemini สามารถประมวลผลวิดีโอได้ ซึ่งช่วยให้ผู้พัฒนาที่อยู่แถวหน้าสามารถใช้กรณีการใช้งานต่างๆ ที่ในอดีตต้องใช้โมเดลเฉพาะโดเมน ความสามารถด้านการมองเห็นของ Gemini บางส่วนรวมถึงความสามารถในการทำสิ่งต่อไปนี้
- อธิบาย แบ่งกลุ่ม และดึงข้อมูลจากวิดีโอ
- ตอบคำถามเกี่ยวกับเนื้อหาวิดีโอ
- อ้างอิงการประทับเวลาที่เฉพาะเจาะจงภายในวิดีโอ
เราสร้าง Gemini ให้ทำงานได้หลายรูปแบบตั้งแต่ต้น และยังคงมุ่งมั่นที่จะขยายขีดจำกัดของสิ่งที่เป็นไปได้ต่อไป คู่มือนี้แสดงวิธีใช้ Gemini API เพื่อสร้างคำตอบที่เป็นข้อความโดยอิงตามอินพุตวิดีโอ
วิดีโออินพุต
คุณสามารถระบุวิดีโอเป็นอินพุตให้กับ Gemini ได้ด้วยวิธีต่อไปนี้
- อัปโหลดไฟล์วิดีโอโดยใช้ File API ก่อนส่งคำขอไปยัง
generateContent
ใช้วิธีนี้สำหรับไฟล์ที่มีขนาดใหญ่กว่า 20 MB วิดีโอที่ยาวกว่าประมาณ 1 นาที หรือเมื่อต้องการนำไฟล์ไปใช้ซ้ำในคำขอหลายรายการ - ส่งข้อมูลวิดีโอในหน้าพร้อมคำขอไปยัง
generateContent
ใช้วิธีนี้กับไฟล์ขนาดเล็ก (<20 MB) และระยะเวลาสั้นๆ - ส่ง URL ของ YouTube เป็นส่วนหนึ่งของ
generateContent
คำขอ
อัปโหลดไฟล์วิดีโอ
คุณใช้ Files API เพื่ออัปโหลดไฟล์วิดีโอได้ ใช้ Files API เสมอเมื่อขนาดคำขอทั้งหมด (รวมถึงไฟล์ ข้อความพรอมต์ คำสั่งของระบบ ฯลฯ) ใหญ่กว่า 20 MB, ระยะเวลาของวิดีโอมีความสำคัญ หรือหากคุณต้องการใช้วิดีโอเดียวกันในพรอมต์หลายรายการ File API ยอมรับรูปแบบไฟล์วิดีโอโดยตรง
โค้ดต่อไปนี้จะดาวน์โหลดวิดีโอตัวอย่าง อัปโหลดโดยใช้ File API
รอให้ประมวลผล แล้วใช้การอ้างอิงไฟล์ในgenerateContent
คำขอ
Python
from google import genai
client = genai.Client()
myfile = client.files.upload(file="path/to/sample.mp4")
response = client.models.generate_content(
model="gemini-2.5-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({});
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.5-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();
Go
uploadedFile, _ := client.Files.UploadFromPath(ctx, "path/to/sample.mp4", nil)
parts := []*genai.Part{
genai.NewPartFromText("Summarize this video. Then create a quiz with an answer key based on the information in this video."),
genai.NewPartFromURI(uploadedFile.URI, uploadedFile.MIMEType),
}
contents := []*genai.Content{
genai.NewContentFromParts(parts, genai.RoleUser),
}
result, _ := client.Models.GenerateContent(
ctx,
"gemini-2.5-flash",
contents,
nil,
)
fmt.Println(result.Text())
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" \
-H "x-goog-api-key: $GEMINI_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.5-flash:generateContent" \
-H "x-goog-api-key: $GEMINI_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
ดูข้อมูลเพิ่มเติมเกี่ยวกับการทำงานกับไฟล์สื่อได้ที่ Files API
ส่งข้อมูลวิดีโอแบบอินไลน์
คุณสามารถส่งวิดีโอขนาดเล็กกว่า
ในคำขอไปยัง generateContent
ได้โดยตรงแทนที่จะอัปโหลดไฟล์วิดีโอโดยใช้ File API วิธีนี้เหมาะสำหรับ
วิดีโอสั้นๆ ที่มีขนาดคำขอรวมไม่เกิน 20 MB
ตัวอย่างการระบุข้อมูลวิดีโอในหน้าเว็บมีดังนี้
Python
from google import genai
from google.genai import types
# Only for videos of size <20Mb
video_file_name = "/path/to/your/video.mp4"
video_bytes = open(video_file_name, 'rb').read()
client = genai.Client()
response = client.models.generate_content(
model='models/gemini-2.5-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({});
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.5-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.5-flash:generateContent" \
-H "x-goog-api-key: $GEMINI_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
ส่ง URL ของ YouTube
คุณส่ง URL ของ YouTube ไปยัง Gemini API ได้โดยตรงโดยเป็นส่วนหนึ่งของgenerateContent
คำขอตามรูปแบบต่อไปนี้
Python
response = client.models.generate_content(
model='models/gemini-2.5-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-2.5-flash" });
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());
Go
package main
import (
"context"
"fmt"
"os"
"google.golang.org/genai"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
parts := []*genai.Part{
genai.NewPartFromText("Please summarize the video in 3 sentences."),
genai.NewPartFromURI("https://www.youtube.com/watch?v=9hE5-98ZeCg","video/mp4"),
}
contents := []*genai.Content{
genai.NewContentFromParts(parts, genai.RoleUser),
}
result, _ := client.Models.GenerateContent(
ctx,
"gemini-2.5-flash",
contents,
nil,
)
fmt.Println(result.Text())
}
REST
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent" \
-H "x-goog-api-key: $GEMINI_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
ข้อจำกัด:
- สำหรับแพ็กเกจฟรี คุณจะอัปโหลดวิดีโอ YouTube ได้ไม่เกิน 8 ชั่วโมงต่อวัน
- สำหรับแพ็กเกจแบบชำระเงิน จะไม่มีการจำกัดตามความยาวของวิดีโอ
- สำหรับโมเดลก่อน Gemini 2.5 คุณจะอัปโหลดวิดีโอได้เพียง 1 รายการต่อคำขอ สำหรับโมเดล Gemini 2.5 ขึ้นไป คุณจะอัปโหลดวิดีโอได้สูงสุด 10 รายการต่อคำขอ
- คุณอัปโหลดได้เฉพาะวิดีโอสาธารณะ (ไม่ใช่ส่วนตัวหรือที่ไม่เป็นสาธารณะ)
อ้างอิงการประทับเวลาในเนื้อหา
คุณถามคำถามเกี่ยวกับช่วงเวลาที่เฉพาะเจาะจงภายในวิดีโอได้โดยใช้
การประทับเวลาในรูปแบบ MM:SS
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?";
Go
prompt := []*genai.Part{
genai.NewPartFromURI(currentVideoFile.URI, currentVideoFile.MIMEType),
// Adjusted timestamps for the NASA video
genai.NewPartFromText("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?"
ถอดเสียงวิดีโอและใส่คำอธิบายภาพ
โมเดล Gemini สามารถถอดเสียงและให้คำอธิบายภาพของเนื้อหาวิดีโอ ได้โดยการประมวลผลทั้งแทร็กเสียงและเฟรมภาพ สำหรับคำอธิบายภาพ โมเดลจะสุ่มตัวอย่างวิดีโอที่อัตรา 1 เฟรมต่อวินาที อัตราการสุ่มตัวอย่างนี้อาจส่งผลต่อระดับรายละเอียดในคำอธิบาย โดยเฉพาะอย่างยิ่งสำหรับวิดีโอที่มีภาพที่เปลี่ยนแปลงอย่างรวดเร็ว
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.";
Go
prompt := []*genai.Part{
genai.NewPartFromURI(currentVideoFile.URI, currentVideoFile.MIMEType),
genai.NewPartFromText("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."
ปรับแต่งการประมวลผลวิดีโอ
คุณปรับแต่งการประมวลผลวิดีโอใน Gemini API ได้โดยการตั้งค่าช่วงการตัด หรือระบุการสุ่มตัวอย่างอัตราเฟรมที่กำหนดเอง
ตั้งค่าช่วงการตัด
คุณตัดคลิปวิดีโอได้โดยระบุ videoMetadata
พร้อมออฟเซ็ตเริ่มต้นและสิ้นสุด
Python
from google import genai
from google.genai import types
client = genai.Client()
response = client.models.generate_content(
model='models/gemini-2.5-flash',
contents=types.Content(
parts=[
types.Part(
file_data=types.FileData(file_uri='https://www.youtube.com/watch?v=XEzRZ35urlk'),
video_metadata=types.VideoMetadata(
start_offset='1250s',
end_offset='1570s'
)
),
types.Part(text='Please summarize the video in 3 sentences.')
]
)
)
JavaScript
import { GoogleGenAI } from '@google/genai';
const ai = new GoogleGenAI({});
const model = 'gemini-2.5-flash';
async function main() {
const contents = [
{
role: 'user',
parts: [
{
fileData: {
fileUri: 'https://www.youtube.com/watch?v=9hE5-98ZeCg',
mimeType: 'video/*',
},
videoMetadata: {
startOffset: '40s',
endOffset: '80s',
}
},
{
text: 'Please summarize the video in 3 sentences.',
},
],
},
];
const response = await ai.models.generateContent({
model,
contents,
});
console.log(response.text)
}
await main();
ตั้งค่าอัตราเฟรมที่กำหนดเอง
คุณตั้งค่าการสุ่มตัวอย่างอัตราเฟรมที่กำหนดเองได้โดยส่งอาร์กิวเมนต์ fps
ไปยัง
videoMetadata
Python
from google import genai
from google.genai import types
# Only for videos of size <20Mb
video_file_name = "/path/to/your/video.mp4"
video_bytes = open(video_file_name, 'rb').read()
client = genai.Client()
response = client.models.generate_content(
model='models/gemini-2.5-flash',
contents=types.Content(
parts=[
types.Part(
inline_data=types.Blob(
data=video_bytes,
mime_type='video/mp4'),
video_metadata=types.VideoMetadata(fps=5)
),
types.Part(text='Please summarize the video in 3 sentences.')
]
)
)
โดยค่าเริ่มต้น ระบบจะสุ่มตัวอย่าง 1 เฟรมต่อวินาที (FPS) จากวิดีโอ คุณอาจต้อง ตั้งค่า FPS ต่ำ (< 1) สำหรับวิดีโอขนาดยาว ซึ่งจะมีประโยชน์อย่างยิ่งสำหรับวิดีโอที่ส่วนใหญ่เป็นภาพนิ่ง (เช่น การบรรยาย) หากต้องการบันทึกรายละเอียดเพิ่มเติมในภาพที่เปลี่ยนแปลงอย่างรวดเร็ว ให้พิจารณาตั้งค่า FPS ให้สูงขึ้น
รูปแบบวิดีโอที่รองรับ
Gemini รองรับประเภท MIME ของรูปแบบวิดีโอต่อไปนี้
video/mp4
video/mpeg
video/mov
video/avi
video/x-flv
video/mpg
video/webm
video/wmv
video/3gpp
รายละเอียดทางเทคนิคเกี่ยวกับวิดีโอ
- โมเดลและบริบทที่รองรับ: โมเดล Gemini 2.0 และ 2.5 ทั้งหมดสามารถประมวลผลข้อมูลวิดีโอได้
- โมเดลที่มีหน้าต่างบริบทขนาด 2 ล้านสามารถประมวลผลวิดีโอที่มีความยาวสูงสุด 2 ชั่วโมงที่ความละเอียดสื่อเริ่มต้นหรือ 6 ชั่วโมงที่ความละเอียดสื่อต่ำ ส่วนโมเดลที่มีหน้าต่างบริบทขนาด 1 ล้านสามารถประมวลผลวิดีโอที่มีความยาวสูงสุด 1 ชั่วโมงที่ความละเอียดสื่อเริ่มต้นหรือ 3 ชั่วโมงที่ความละเอียดสื่อต่ำ
- การประมวลผล File API: เมื่อใช้ File API ระบบจะจัดเก็บวิดีโอที่ 1
เฟรมต่อวินาที (FPS) และประมวลผลเสียงที่ 1 Kbps (ช่องเดียว)
ระบบจะเพิ่มการประทับเวลาทุกวินาที
- โดยอัตราเหล่านี้อาจมีการเปลี่ยนแปลงในอนาคตเพื่อปรับปรุงการอนุมาน
- คุณลบล้างอัตราการสุ่มตัวอย่าง 1 FPS ได้โดยตั้งค่าอัตราเฟรมที่กำหนดเอง
- การคำนวณโทเค็น: ระบบจะแปลงวิดีโอแต่ละวินาทีเป็นโทเค็นดังนี้
- เฟรมแต่ละเฟรม (สุ่มตัวอย่างที่ 1 FPS)
- หากตั้งค่า
mediaResolution
เป็นต่ำ ระบบจะแปลงเฟรมเป็นโทเค็นที่ 66 โทเค็นต่อเฟรม - ไม่เช่นนั้น ระบบจะแปลงเฟรมเป็นโทเค็นที่ 258 โทเค็นต่อเฟรม
- หากตั้งค่า
- เสียง: 32 โทเค็นต่อวินาที
- รวมถึงข้อมูลเมตาด้วย
- ทั้งหมด: ประมาณ 300 โทเค็นต่อวินาทีของวิดีโอที่ความละเอียดสื่อเริ่มต้น หรือ 100 โทเค็นต่อวินาทีของวิดีโอที่ความละเอียดสื่อต่ำ
- เฟรมแต่ละเฟรม (สุ่มตัวอย่างที่ 1 FPS)
- รูปแบบการประทับเวลา: เมื่ออ้างอิงถึงช่วงเวลาที่เฉพาะเจาะจงในวิดีโอภายในพรอมต์ ให้ใช้รูปแบบ
MM:SS
(เช่น01:15
เป็นเวลา 1 นาที 15 วินาที) - แนวทางปฏิบัติแนะนำ
- ใช้เพียงวิดีโอเดียวต่อคำขอพรอมต์เพื่อให้ได้ผลลัพธ์ที่ดีที่สุด
- หากรวมข้อความและวิดีโอเดียว ให้วางพรอมต์ข้อความหลังส่วนวิดีโอในอาร์เรย์
contents
- โปรดทราบว่าลำดับการดำเนินการที่รวดเร็วอาจสูญเสียรายละเอียดเนื่องจากอัตราการสุ่มตัวอย่าง 1 FPS พิจารณาการลดความเร็วคลิปดังกล่าวหากจำเป็น
ขั้นตอนถัดไป
คู่มือนี้แสดงวิธีอัปโหลดไฟล์วิดีโอและสร้างเอาต์พุตข้อความจากอินพุตวิดีโอ ดูข้อมูลเพิ่มเติมได้ที่แหล่งข้อมูลต่อไปนี้
- คำสั่งของระบบ: คำสั่งของระบบช่วยให้คุณกำหนดลักษณะการทำงานของโมเดลตามความต้องการและกรณีการใช้งานเฉพาะของคุณได้
- Files API: ดูข้อมูลเพิ่มเติมเกี่ยวกับการอัปโหลดและจัดการ ไฟล์เพื่อใช้กับ Gemini
- กลยุทธ์การแจ้งไฟล์: Gemini API รองรับการแจ้งด้วยข้อมูลข้อความ รูปภาพ เสียง และวิดีโอ ซึ่งเรียกอีกอย่างว่าการแจ้งแบบมัลติโมดัล
- คำแนะนำด้านความปลอดภัย: บางครั้งโมเดล Generative AI อาจสร้างเอาต์พุตที่ไม่คาดคิด เช่น เอาต์พุตที่ไม่ถูกต้อง มีอคติ หรือไม่เหมาะสม การประมวลผลภายหลังและการประเมินโดยเจ้าหน้าที่เป็นสิ่งจำเป็นเพื่อ จำกัดความเสี่ยงที่จะเกิดอันตรายจากเอาต์พุตดังกล่าว