1. Ringkasan
Video Intelligence API memungkinkan Anda menggunakan teknologi analisis video Google sebagai bagian dari aplikasi Anda.
Di lab ini, Anda akan fokus pada penggunaan Video Intelligence API dengan Python.
Yang akan Anda pelajari
- Cara menyiapkan lingkungan Anda
- Cara menyiapkan Python
- Cara mendeteksi perubahan shot
- Cara mendeteksi label
- Cara mendeteksi konten vulgar
- Cara mentranskripsikan ucapan
- Cara mendeteksi dan melacak teks
- Cara mendeteksi dan melacak objek
- Cara mendeteksi dan melacak logo
Yang Anda butuhkan
Survei
Bagaimana Anda akan menggunakan tutorial ini?
Bagaimana penilaian Anda terhadap pengalaman dengan Python?
Bagaimana Anda menilai pengalaman Anda dengan layanan Google Cloud?
2. Penyiapan dan persyaratan
Penyiapan lingkungan mandiri
- Login ke Google Cloud Console dan buat project baru atau gunakan kembali project yang sudah ada. Jika belum memiliki akun Gmail atau Google Workspace, Anda harus membuatnya.
- Project name adalah nama tampilan untuk peserta project ini. String ini adalah string karakter yang tidak digunakan oleh Google API. Anda dapat memperbaruinya kapan saja.
- Project ID bersifat unik di semua project Google Cloud dan tidak dapat diubah (tidak dapat diubah setelah ditetapkan). Cloud Console otomatis membuat string unik; biasanya Anda tidak mementingkan kata-katanya. Di sebagian besar codelab, Anda harus merujuk Project ID-nya (umumnya diidentifikasi sebagai
PROJECT_ID
). Jika tidak suka dengan ID yang dibuat, Anda dapat membuat ID acak lainnya. Atau, Anda dapat mencobanya sendiri, dan lihat apakah ID tersebut tersedia. ID tidak dapat diubah setelah langkah ini dan tersedia selama durasi project. - Sebagai informasi, ada nilai ketiga, Project Number, yang digunakan oleh beberapa API. Pelajari lebih lanjut ketiga nilai ini di dokumentasi.
- Selanjutnya, Anda harus mengaktifkan penagihan di Konsol Cloud untuk menggunakan resource/API Cloud. Menjalankan operasi dalam codelab ini tidak akan memakan banyak biaya, bahkan mungkin tidak sama sekali. Guna mematikan resource agar tidak menimbulkan penagihan di luar tutorial ini, Anda dapat menghapus resource yang dibuat atau menghapus project-nya. Pengguna baru Google Cloud memenuhi syarat untuk mengikuti program Uji Coba Gratis senilai $300 USD.
Mulai Cloud Shell
Meskipun Google Cloud dapat dioperasikan secara jarak jauh dari laptop Anda, dalam codelab ini Anda akan menggunakan Cloud Shell, yakni lingkungan command line yang berjalan di Cloud.
Mengaktifkan Cloud Shell
- Dari Cloud Console, klik Aktifkan Cloud Shell
.
Jika ini pertama kalinya Anda memulai Cloud Shell, Anda akan melihat layar perantara yang menjelaskan apa itu Cloud Shell. Jika Anda melihat layar perantara, klik Lanjutkan.
Perlu waktu beberapa saat untuk penyediaan dan terhubung ke Cloud Shell.
Mesin virtual ini dimuat dengan semua alat pengembangan yang diperlukan. Layanan ini menawarkan direktori beranda tetap sebesar 5 GB dan beroperasi di Google Cloud, sehingga sangat meningkatkan performa dan autentikasi jaringan. Sebagian besar pekerjaan Anda dalam codelab ini dapat dilakukan dengan browser.
Setelah terhubung ke Cloud Shell, Anda akan melihat bahwa Anda telah diautentikasi dan project sudah ditetapkan ke project ID Anda.
- Jalankan perintah berikut di Cloud Shell untuk mengonfirmasi bahwa Anda telah diautentikasi:
gcloud auth list
Output perintah
Credentialed Accounts ACTIVE ACCOUNT * <my_account>@<my_domain.com> To set the active account, run: $ gcloud config set account `ACCOUNT`
- Jalankan perintah berikut di Cloud Shell untuk mengonfirmasi bahwa perintah gcloud mengetahui project Anda:
gcloud config list project
Output perintah
[core] project = <PROJECT_ID>
Jika tidak, Anda dapat menyetelnya dengan perintah ini:
gcloud config set project <PROJECT_ID>
Output perintah
Updated property [core/project].
3. Penyiapan lingkungan
Sebelum Anda dapat mulai menggunakan Video Intelligence API, jalankan perintah berikut di Cloud Shell untuk mengaktifkan API:
gcloud services enable videointelligence.googleapis.com
Anda akan melihat sesuatu seperti ini:
Operation "operations/..." finished successfully.
Sekarang Anda dapat menggunakan Video Intelligence API.
Buka direktori utama Anda:
cd ~
Buat lingkungan virtual Python untuk mengisolasi dependensi:
virtualenv venv-videointel
Aktifkan lingkungan virtual:
source venv-videointel/bin/activate
Instal IPython dan library klien Video Intelligence API:
pip install ipython google-cloud-videointelligence
Anda akan melihat sesuatu seperti ini:
... Installing collected packages: ..., ipython, google-cloud-videointelligence Successfully installed ... google-cloud-videointelligence-2.11.0 ...
Sekarang Anda siap menggunakan library klien Video Intelligence API.
Pada langkah berikutnya, Anda akan menggunakan penafsir Python interaktif yang disebut IPython, yang Anda instal di langkah sebelumnya. Mulai sesi dengan menjalankan ipython
di Cloud Shell:
ipython
Anda akan melihat sesuatu seperti ini:
Python 3.9.2 (default, Feb 28 2021, 17:03:44) Type 'copyright', 'credits' or 'license' for more information IPython 8.12.0 -- An enhanced Interactive Python. Type '?' for help. In [1]:
4. Video sampel
Anda dapat menggunakan Video Intelligence API untuk menganotasi video yang disimpan di Cloud Storage atau disediakan sebagai byte data.
Pada langkah berikutnya, Anda akan menggunakan video sampel yang disimpan di Cloud Storage. Anda dapat melihat video di browser.
Bersedia, stabil, mulai!
5. Mendeteksi pergantian shot
Anda dapat menggunakan Video Intelligence API untuk mendeteksi perubahan shot dalam video. Shot adalah segmen video, serangkaian frame dengan kontinuitas visual.
Salin kode berikut ke dalam sesi IPython:
from typing import cast
from google.cloud import videointelligence_v1 as vi
def detect_shot_changes(video_uri: str) -> vi.VideoAnnotationResults:
video_client = vi.VideoIntelligenceServiceClient()
features = [vi.Feature.SHOT_CHANGE_DETECTION]
request = vi.AnnotateVideoRequest(input_uri=video_uri, features=features)
print(f'Processing video: "{video_uri}"...')
operation = video_client.annotate_video(request)
# Wait for operation to complete
response = cast(vi.AnnotateVideoResponse, operation.result())
# A single video is processed
results = response.annotation_results[0]
return results
Luangkan waktu untuk mempelajari kode tersebut dan lihat cara kode tersebut menggunakan metode library klien annotate_video
dengan parameter SHOT_CHANGE_DETECTION
untuk menganalisis video dan mendeteksi perubahan shot.
Panggil fungsi untuk menganalisis video:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
results = detect_shot_changes(video_uri)
Tunggu hingga video diproses:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Tambahkan fungsi berikut untuk mencetak rekaman video:
def print_video_shots(results: vi.VideoAnnotationResults):
shots = results.shot_annotations
print(f" Video shots: {len(shots)} ".center(40, "-"))
for i, shot in enumerate(shots):
t1 = shot.start_time_offset.total_seconds()
t2 = shot.end_time_offset.total_seconds()
print(f"{i+1:>3} | {t1:7.3f} | {t2:7.3f}")
Memanggil fungsi:
print_video_shots(results)
Anda akan melihat sesuatu seperti ini:
----------- Video shots: 34 ------------ 1 | 0.000 | 12.880 2 | 12.920 | 21.680 3 | 21.720 | 27.880 ... 32 | 135.160 | 138.320 33 | 138.360 | 146.200 34 | 146.240 | 162.520
Jika mengekstrak bingkai tengah dari setiap foto dan mengaturnya di dinding bingkai, Anda dapat membuat ringkasan visual video:
Ringkasan
Pada langkah ini, Anda dapat melakukan deteksi pergantian shot pada video menggunakan Video Intelligence API. Anda dapat membaca selengkapnya tentang mendeteksi perubahan shot.
6. Mendeteksi label
Anda dapat menggunakan Video Intelligence API untuk mendeteksi label dalam video. Label mendeskripsikan video berdasarkan konten visualnya.
Salin kode berikut ke dalam sesi IPython:
from datetime import timedelta
from typing import Optional, Sequence, cast
from google.cloud import videointelligence_v1 as vi
def detect_labels(
video_uri: str,
mode: vi.LabelDetectionMode,
segments: Optional[Sequence[vi.VideoSegment]] = None,
) -> vi.VideoAnnotationResults:
video_client = vi.VideoIntelligenceServiceClient()
features = [vi.Feature.LABEL_DETECTION]
config = vi.LabelDetectionConfig(label_detection_mode=mode)
context = vi.VideoContext(segments=segments, label_detection_config=config)
request = vi.AnnotateVideoRequest(
input_uri=video_uri,
features=features,
video_context=context,
)
print(f'Processing video "{video_uri}"...')
operation = video_client.annotate_video(request)
# Wait for operation to complete
response = cast(vi.AnnotateVideoResponse, operation.result())
# A single video is processed
results = response.annotation_results[0]
return results
Luangkan waktu untuk mempelajari kode tersebut dan lihat cara kode tersebut menggunakan metode library klien annotate_video
dengan parameter LABEL_DETECTION
untuk menganalisis video dan mendeteksi label.
Panggil fungsi untuk menganalisis 37 detik pertama video:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
mode = vi.LabelDetectionMode.SHOT_MODE
segment = vi.VideoSegment(
start_time_offset=timedelta(seconds=0),
end_time_offset=timedelta(seconds=37),
)
results = detect_labels(video_uri, mode, [segment])
Tunggu hingga video diproses:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Tambahkan fungsi ini untuk mencetak label di tingkat video:
def print_video_labels(results: vi.VideoAnnotationResults):
labels = sorted_by_first_segment_confidence(results.segment_label_annotations)
print(f" Video labels: {len(labels)} ".center(80, "-"))
for label in labels:
categories = category_entities_to_str(label.category_entities)
for segment in label.segments:
confidence = segment.confidence
t1 = segment.segment.start_time_offset.total_seconds()
t2 = segment.segment.end_time_offset.total_seconds()
print(
f"{confidence:4.0%}",
f"{t1:7.3f}",
f"{t2:7.3f}",
f"{label.entity.description}{categories}",
sep=" | ",
)
def sorted_by_first_segment_confidence(
labels: Sequence[vi.LabelAnnotation],
) -> Sequence[vi.LabelAnnotation]:
def first_segment_confidence(label: vi.LabelAnnotation) -> float:
return label.segments[0].confidence
return sorted(labels, key=first_segment_confidence, reverse=True)
def category_entities_to_str(category_entities: Sequence[vi.Entity]) -> str:
if not category_entities:
return ""
entities = ", ".join([e.description for e in category_entities])
return f" ({entities})"
Memanggil fungsi:
print_video_labels(results)
Anda akan melihat sesuatu seperti ini:
------------------------------- Video labels: 10 ------------------------------- 96% | 0.000 | 36.960 | nature 74% | 0.000 | 36.960 | vegetation 59% | 0.000 | 36.960 | tree (plant) 56% | 0.000 | 36.960 | forest (geographical feature) 49% | 0.000 | 36.960 | leaf (plant) 43% | 0.000 | 36.960 | flora (plant) 38% | 0.000 | 36.960 | nature reserve (geographical feature) 38% | 0.000 | 36.960 | woodland (forest) 35% | 0.000 | 36.960 | water resources (water) 32% | 0.000 | 36.960 | sunlight (light)
Berkat label di tingkat video ini, Anda dapat memahami bahwa bagian awal video sebagian besar adalah tentang alam dan vegetasi.
Tambahkan fungsi ini untuk mencetak label di tingkat foto:
def print_shot_labels(results: vi.VideoAnnotationResults):
labels = sorted_by_first_segment_start_and_confidence(
results.shot_label_annotations
)
print(f" Shot labels: {len(labels)} ".center(80, "-"))
for label in labels:
categories = category_entities_to_str(label.category_entities)
print(f"{label.entity.description}{categories}")
for segment in label.segments:
confidence = segment.confidence
t1 = segment.segment.start_time_offset.total_seconds()
t2 = segment.segment.end_time_offset.total_seconds()
print(f"{confidence:4.0%} | {t1:7.3f} | {t2:7.3f}")
def sorted_by_first_segment_start_and_confidence(
labels: Sequence[vi.LabelAnnotation],
) -> Sequence[vi.LabelAnnotation]:
def first_segment_start_and_confidence(label: vi.LabelAnnotation):
first_segment = label.segments[0]
ms = first_segment.segment.start_time_offset.total_seconds()
return (ms, -first_segment.confidence)
return sorted(labels, key=first_segment_start_and_confidence)
Memanggil fungsi:
print_shot_labels(results)
Anda akan melihat sesuatu seperti ini:
------------------------------- Shot labels: 29 -------------------------------- planet (astronomical object) 83% | 0.000 | 12.880 earth (planet) 53% | 0.000 | 12.880 water resources (water) 43% | 0.000 | 12.880 aerial photography (photography) 43% | 0.000 | 12.880 vegetation 32% | 0.000 | 12.880 92% | 12.920 | 21.680 83% | 21.720 | 27.880 77% | 27.920 | 31.800 76% | 31.840 | 34.720 ... butterfly (insect, animal) 84% | 34.760 | 36.960 ...
Berkat label tingkat bidikan ini, Anda dapat memahami bahwa video dimulai dengan bidikan sebuah planet (kemungkinan Bumi), dan ada kupu-kupu dalam gambar 34.760-36.960s
,...
Ringkasan
Pada langkah ini, Anda dapat melakukan deteksi label pada video menggunakan Video Intelligence API. Anda dapat membaca selengkapnya tentang mendeteksi label.
7. Mendeteksi konten vulgar
Anda dapat menggunakan Video Intelligence API untuk mendeteksi konten vulgar dalam video. Konten vulgar adalah konten khusus dewasa yang umumnya tidak pantas bagi pengguna berusia di bawah 18 tahun dan termasuk, tetapi tidak terbatas pada, ketelanjangan, aktivitas seksual, dan pornografi. Deteksi dilakukan hanya berdasarkan sinyal visual per frame (audio tidak digunakan). Respons mencakup nilai kemungkinan yang berkisar dari VERY_UNLIKELY
hingga VERY_LIKELY
.
Salin kode berikut ke dalam sesi IPython:
from datetime import timedelta
from typing import Optional, Sequence, cast
from google.cloud import videointelligence_v1 as vi
def detect_explicit_content(
video_uri: str,
segments: Optional[Sequence[vi.VideoSegment]] = None,
) -> vi.VideoAnnotationResults:
video_client = vi.VideoIntelligenceServiceClient()
features = [vi.Feature.EXPLICIT_CONTENT_DETECTION]
context = vi.VideoContext(segments=segments)
request = vi.AnnotateVideoRequest(
input_uri=video_uri,
features=features,
video_context=context,
)
print(f'Processing video "{video_uri}"...')
operation = video_client.annotate_video(request)
# Wait for operation to complete
response = cast(vi.AnnotateVideoResponse, operation.result())
# A single video is processed
results = response.annotation_results[0]
return results
Luangkan waktu untuk mempelajari kode tersebut dan lihat cara kode tersebut menggunakan metode library klien annotate_video
dengan parameter EXPLICIT_CONTENT_DETECTION
untuk menganalisis video dan mendeteksi konten vulgar.
Panggil fungsi untuk menganalisis 10 detik pertama video:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
segment = vi.VideoSegment(
start_time_offset=timedelta(seconds=0),
end_time_offset=timedelta(seconds=10),
)
results = detect_explicit_content(video_uri, [segment])
Tunggu hingga video diproses:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Tambahkan fungsi ini untuk mencetak berbagai jumlah kemungkinan:
def print_explicit_content(results: vi.VideoAnnotationResults):
from collections import Counter
frames = results.explicit_annotation.frames
likelihood_counts = Counter([f.pornography_likelihood for f in frames])
print(f" Explicit content frames: {len(frames)} ".center(40, "-"))
for likelihood in vi.Likelihood:
print(f"{likelihood.name:<22}: {likelihood_counts[likelihood]:>3}")
Memanggil fungsi:
print_explicit_content(results)
Anda akan melihat sesuatu seperti ini:
----- Explicit content frames: 10 ------ LIKELIHOOD_UNSPECIFIED: 0 VERY_UNLIKELY : 10 UNLIKELY : 0 POSSIBLE : 0 LIKELY : 0 VERY_LIKELY : 0
Tambahkan fungsi ini untuk mencetak detail frame:
def print_frames(results: vi.VideoAnnotationResults, likelihood: vi.Likelihood):
frames = results.explicit_annotation.frames
frames = [f for f in frames if f.pornography_likelihood == likelihood]
print(f" {likelihood.name} frames: {len(frames)} ".center(40, "-"))
for frame in frames:
print(frame.time_offset)
Memanggil fungsi:
print_frames(results, vi.Likelihood.VERY_UNLIKELY)
Anda akan melihat sesuatu seperti ini:
------- VERY_UNLIKELY frames: 10 ------- 0:00:00.365992 0:00:01.279206 0:00:02.268336 0:00:03.289253 0:00:04.400163 0:00:05.291547 0:00:06.449558 0:00:07.452751 0:00:08.577405 0:00:09.554514
Ringkasan
Pada langkah ini, Anda dapat melakukan deteksi konten vulgar pada video menggunakan Video Intelligence API. Anda dapat membaca selengkapnya tentang cara mendeteksi konten vulgar.
8. Transkripsikan ucapan
Anda dapat menggunakan Video Intelligence API untuk mentranskripsikan ucapan video menjadi teks.
Salin kode berikut ke dalam sesi IPython:
from datetime import timedelta
from typing import Optional, Sequence, cast
from google.cloud import videointelligence_v1 as vi
def transcribe_speech(
video_uri: str,
language_code: str,
segments: Optional[Sequence[vi.VideoSegment]] = None,
) -> vi.VideoAnnotationResults:
video_client = vi.VideoIntelligenceServiceClient()
features = [vi.Feature.SPEECH_TRANSCRIPTION]
config = vi.SpeechTranscriptionConfig(
language_code=language_code,
enable_automatic_punctuation=True,
)
context = vi.VideoContext(
segments=segments,
speech_transcription_config=config,
)
request = vi.AnnotateVideoRequest(
input_uri=video_uri,
features=features,
video_context=context,
)
print(f'Processing video "{video_uri}"...')
operation = video_client.annotate_video(request)
# Wait for operation to complete
response = cast(vi.AnnotateVideoResponse, operation.result())
# A single video is processed
results = response.annotation_results[0]
return results
Luangkan waktu untuk mempelajari kode tersebut dan lihat cara kode tersebut menggunakan metode library klien annotate_video
dengan parameter SPEECH_TRANSCRIPTION
untuk menganalisis video dan mentranskripsikan ucapan.
Panggil fungsi untuk menganalisis video dari detik 55 hingga 80:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
language_code = "en-GB"
segment = vi.VideoSegment(
start_time_offset=timedelta(seconds=55),
end_time_offset=timedelta(seconds=80),
)
results = transcribe_speech(video_uri, language_code, [segment])
Tunggu hingga video diproses:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Tambahkan fungsi ini untuk mencetak ucapan yang ditranskripsi:
def print_video_speech(results: vi.VideoAnnotationResults, min_confidence: float = 0.8):
def keep_transcription(transcription: vi.SpeechTranscription) -> bool:
return min_confidence <= transcription.alternatives[0].confidence
transcriptions = results.speech_transcriptions
transcriptions = [t for t in transcriptions if keep_transcription(t)]
print(f" Speech transcriptions: {len(transcriptions)} ".center(80, "-"))
for transcription in transcriptions:
first_alternative = transcription.alternatives[0]
confidence = first_alternative.confidence
transcript = first_alternative.transcript
print(f" {confidence:4.0%} | {transcript.strip()}")
Memanggil fungsi:
print_video_speech(results)
Anda akan melihat sesuatu seperti ini:
--------------------------- Speech transcriptions: 2 --------------------------- 91% | I was keenly aware of secret movements in the trees. 92% | I looked into his large and lustrous eyes. They seem somehow to express his entire personality.
Tambahkan fungsi ini untuk mencetak daftar kata yang terdeteksi dan stempel waktunya:
def print_word_timestamps(
results: vi.VideoAnnotationResults,
min_confidence: float = 0.8,
):
def keep_transcription(transcription: vi.SpeechTranscription) -> bool:
return min_confidence <= transcription.alternatives[0].confidence
transcriptions = results.speech_transcriptions
transcriptions = [t for t in transcriptions if keep_transcription(t)]
print(" Word timestamps ".center(80, "-"))
for transcription in transcriptions:
first_alternative = transcription.alternatives[0]
confidence = first_alternative.confidence
for word in first_alternative.words:
t1 = word.start_time.total_seconds()
t2 = word.end_time.total_seconds()
word = word.word
print(f"{confidence:4.0%} | {t1:7.3f} | {t2:7.3f} | {word}")
Memanggil fungsi:
print_word_timestamps(results)
Anda akan melihat sesuatu seperti ini:
------------------------------- Word timestamps -------------------------------- 93% | 55.000 | 55.700 | I 93% | 55.700 | 55.900 | was 93% | 55.900 | 56.300 | keenly 93% | 56.300 | 56.700 | aware 93% | 56.700 | 56.900 | of ... 94% | 76.900 | 77.400 | express 94% | 77.400 | 77.600 | his 94% | 77.600 | 78.200 | entire 94% | 78.200 | 78.500 | personality.
Ringkasan
Pada langkah ini, Anda dapat membuat transkripsi ucapan pada video menggunakan Video Intelligence API. Anda dapat membaca lebih lanjut cara mentranskripsikan audio.
9. Mendeteksi dan melacak teks
Anda dapat menggunakan Video Intelligence API untuk mendeteksi dan melacak teks dalam video.
Salin kode berikut ke dalam sesi IPython:
from datetime import timedelta
from typing import Optional, Sequence, cast
from google.cloud import videointelligence_v1 as vi
def detect_text(
video_uri: str,
language_hints: Optional[Sequence[str]] = None,
segments: Optional[Sequence[vi.VideoSegment]] = None,
) -> vi.VideoAnnotationResults:
video_client = vi.VideoIntelligenceServiceClient()
features = [vi.Feature.TEXT_DETECTION]
config = vi.TextDetectionConfig(
language_hints=language_hints,
)
context = vi.VideoContext(
segments=segments,
text_detection_config=config,
)
request = vi.AnnotateVideoRequest(
input_uri=video_uri,
features=features,
video_context=context,
)
print(f'Processing video "{video_uri}"...')
operation = video_client.annotate_video(request)
# Wait for operation to complete
response = cast(vi.AnnotateVideoResponse, operation.result())
# A single video is processed
results = response.annotation_results[0]
return results
Luangkan waktu untuk mempelajari kode tersebut dan lihat cara kode tersebut menggunakan metode library klien annotate_video
dengan parameter TEXT_DETECTION
untuk menganalisis video dan mendeteksi teks.
Panggil fungsi untuk menganalisis video dari detik 13 hingga 27:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
segment = vi.VideoSegment(
start_time_offset=timedelta(seconds=13),
end_time_offset=timedelta(seconds=27),
)
results = detect_text(video_uri, segments=[segment])
Tunggu hingga video diproses:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Tambahkan fungsi ini untuk mencetak teks yang terdeteksi:
def print_video_text(results: vi.VideoAnnotationResults, min_frames: int = 15):
annotations = sorted_by_first_segment_end(results.text_annotations)
print(" Detected text ".center(80, "-"))
for annotation in annotations:
for text_segment in annotation.segments:
frames = len(text_segment.frames)
if frames < min_frames:
continue
text = annotation.text
confidence = text_segment.confidence
start = text_segment.segment.start_time_offset
seconds = segment_seconds(text_segment.segment)
print(text)
print(f" {confidence:4.0%} | {start} + {seconds:.1f}s | {frames} fr.")
def sorted_by_first_segment_end(
annotations: Sequence[vi.TextAnnotation],
) -> Sequence[vi.TextAnnotation]:
def first_segment_end(annotation: vi.TextAnnotation) -> int:
return annotation.segments[0].segment.end_time_offset.total_seconds()
return sorted(annotations, key=first_segment_end)
def segment_seconds(segment: vi.VideoSegment) -> float:
t1 = segment.start_time_offset.total_seconds()
t2 = segment.end_time_offset.total_seconds()
return t2 - t1
Memanggil fungsi:
print_video_text(results)
Anda akan melihat sesuatu seperti ini:
-------------------------------- Detected text --------------------------------- GOMBE NATIONAL PARK 99% | 0:00:15.760000 + 1.7s | 15 fr. TANZANIA 100% | 0:00:15.760000 + 4.8s | 39 fr. With words and narration by 100% | 0:00:23.200000 + 3.6s | 31 fr. Jane Goodall 99% | 0:00:23.080000 + 3.8s | 33 fr.
Tambahkan fungsi ini untuk mencetak daftar bingkai teks dan kotak pembatas yang terdeteksi:
def print_text_frames(results: vi.VideoAnnotationResults, contained_text: str):
# Vertex order: top-left, top-right, bottom-right, bottom-left
def box_top_left(box: vi.NormalizedBoundingPoly) -> str:
tl = box.vertices[0]
return f"({tl.x:.5f}, {tl.y:.5f})"
def box_bottom_right(box: vi.NormalizedBoundingPoly) -> str:
br = box.vertices[2]
return f"({br.x:.5f}, {br.y:.5f})"
annotations = results.text_annotations
annotations = [a for a in annotations if contained_text in a.text]
for annotation in annotations:
print(f" {annotation.text} ".center(80, "-"))
for text_segment in annotation.segments:
for frame in text_segment.frames:
frame_ms = frame.time_offset.total_seconds()
box = frame.rotated_bounding_box
print(
f"{frame_ms:>7.3f}",
box_top_left(box),
box_bottom_right(box),
sep=" | ",
)
Panggil fungsi untuk memeriksa frame mana yang menampilkan nama narator:
contained_text = "Goodall"
print_text_frames(results, contained_text)
Anda akan melihat sesuatu seperti ini:
--------------------------------- Jane Goodall --------------------------------- 23.080 | (0.39922, 0.49861) | (0.62752, 0.55888) 23.200 | (0.38750, 0.49028) | (0.62692, 0.56306) ... 26.800 | (0.36016, 0.49583) | (0.61094, 0.56048) 26.920 | (0.45859, 0.49583) | (0.60365, 0.56174)
Jika Anda menggambar kotak pembatas di atas bingkai yang sesuai, Anda akan mendapatkannya:
Ringkasan
Pada langkah ini, Anda dapat melakukan deteksi dan pelacakan teks pada video menggunakan Video Intelligence API. Anda dapat membaca selengkapnya tentang mendeteksi dan melacak teks.
10. Deteksi dan lacak objek
Anda dapat menggunakan Video Intelligence API untuk mendeteksi dan melacak objek dalam video.
Salin kode berikut ke dalam sesi IPython:
from datetime import timedelta
from typing import Optional, Sequence, cast
from google.cloud import videointelligence_v1 as vi
def track_objects(
video_uri: str, segments: Optional[Sequence[vi.VideoSegment]] = None
) -> vi.VideoAnnotationResults:
video_client = vi.VideoIntelligenceServiceClient()
features = [vi.Feature.OBJECT_TRACKING]
context = vi.VideoContext(segments=segments)
request = vi.AnnotateVideoRequest(
input_uri=video_uri,
features=features,
video_context=context,
)
print(f'Processing video "{video_uri}"...')
operation = video_client.annotate_video(request)
# Wait for operation to complete
response = cast(vi.AnnotateVideoResponse, operation.result())
# A single video is processed
results = response.annotation_results[0]
return results
Luangkan waktu untuk mempelajari kode tersebut dan lihat cara kode tersebut menggunakan metode library klien annotate_video
dengan parameter OBJECT_TRACKING
untuk menganalisis video dan mendeteksi objek.
Panggil fungsi untuk menganalisis video dari detik 98 hingga 112:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
segment = vi.VideoSegment(
start_time_offset=timedelta(seconds=98),
end_time_offset=timedelta(seconds=112),
)
results = track_objects(video_uri, [segment])
Tunggu hingga video diproses:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Tambahkan fungsi ini untuk mencetak daftar objek yang terdeteksi:
def print_detected_objects(
results: vi.VideoAnnotationResults,
min_confidence: float = 0.7,
):
annotations = results.object_annotations
annotations = [a for a in annotations if min_confidence <= a.confidence]
print(
f" Detected objects: {len(annotations)}"
f" ({min_confidence:.0%} <= confidence) ".center(80, "-")
)
for annotation in annotations:
entity = annotation.entity
description = entity.description
entity_id = entity.entity_id
confidence = annotation.confidence
t1 = annotation.segment.start_time_offset.total_seconds()
t2 = annotation.segment.end_time_offset.total_seconds()
frames = len(annotation.frames)
print(
f"{description:<22}",
f"{entity_id:<10}",
f"{confidence:4.0%}",
f"{t1:>7.3f}",
f"{t2:>7.3f}",
f"{frames:>2} fr.",
sep=" | ",
)
Memanggil fungsi:
print_detected_objects(results)
Anda akan melihat sesuatu seperti ini:
------------------- Detected objects: 3 (70% <= confidence) -------------------- insect | /m/03vt0 | 87% | 98.840 | 101.720 | 25 fr. insect | /m/03vt0 | 71% | 108.440 | 111.080 | 23 fr. butterfly | /m/0cyf8 | 91% | 111.200 | 111.920 | 7 fr.
Tambahkan fungsi ini untuk mencetak daftar frame objek dan kotak pembatas yang terdeteksi:
def print_object_frames(
results: vi.VideoAnnotationResults,
entity_id: str,
min_confidence: float = 0.7,
):
def keep_annotation(annotation: vi.ObjectTrackingAnnotation) -> bool:
return (
annotation.entity.entity_id == entity_id
and min_confidence <= annotation.confidence
)
annotations = results.object_annotations
annotations = [a for a in annotations if keep_annotation(a)]
for annotation in annotations:
description = annotation.entity.description
confidence = annotation.confidence
print(
f" {description},"
f" confidence: {confidence:.0%},"
f" frames: {len(annotation.frames)} ".center(80, "-")
)
for frame in annotation.frames:
t = frame.time_offset.total_seconds()
box = frame.normalized_bounding_box
print(
f"{t:>7.3f}",
f"({box.left:.5f}, {box.top:.5f})",
f"({box.right:.5f}, {box.bottom:.5f})",
sep=" | ",
)
Panggil fungsi dengan ID entitas untuk serangga:
insect_entity_id = "/m/03vt0"
print_object_frames(results, insect_entity_id)
Anda akan melihat sesuatu seperti ini:
--------------------- insect, confidence: 87%, frames: 25 ---------------------- 98.840 | (0.49327, 0.19617) | (0.69905, 0.69633) 98.960 | (0.49559, 0.19308) | (0.70631, 0.69671) ... 101.600 | (0.46668, 0.19776) | (0.76619, 0.69371) 101.720 | (0.46805, 0.20053) | (0.76447, 0.68703) --------------------- insect, confidence: 71%, frames: 23 ---------------------- 108.440 | (0.47343, 0.10694) | (0.63821, 0.98332) 108.560 | (0.46960, 0.10206) | (0.63033, 0.98285) ... 110.960 | (0.49466, 0.05102) | (0.65941, 0.99357) 111.080 | (0.49572, 0.04728) | (0.65762, 0.99868)
Jika Anda menggambar kotak pembatas di atas bingkai yang sesuai, Anda akan mendapatkannya:
Ringkasan
Pada langkah ini, Anda dapat melakukan deteksi dan pelacakan objek pada video menggunakan Video Intelligence API. Anda dapat membaca selengkapnya tentang cara mendeteksi dan melacak objek.
11. Mendeteksi dan melacak logo
Anda dapat menggunakan Video Intelligence API untuk mendeteksi dan melacak logo dalam video. Lebih dari 100.000 merek dan logo dapat dideteksi.
Salin kode berikut ke dalam sesi IPython:
from datetime import timedelta
from typing import Optional, Sequence, cast
from google.cloud import videointelligence_v1 as vi
def detect_logos(
video_uri: str, segments: Optional[Sequence[vi.VideoSegment]] = None
) -> vi.VideoAnnotationResults:
video_client = vi.VideoIntelligenceServiceClient()
features = [vi.Feature.LOGO_RECOGNITION]
context = vi.VideoContext(segments=segments)
request = vi.AnnotateVideoRequest(
input_uri=video_uri,
features=features,
video_context=context,
)
print(f'Processing video "{video_uri}"...')
operation = video_client.annotate_video(request)
# Wait for operation to complete
response = cast(vi.AnnotateVideoResponse, operation.result())
# A single video is processed
results = response.annotation_results[0]
return results
Luangkan waktu untuk mempelajari kode tersebut dan lihat cara kode tersebut menggunakan metode library klien annotate_video
dengan parameter LOGO_RECOGNITION
untuk menganalisis video dan mendeteksi logo.
Panggil fungsi untuk menganalisis urutan dari belakang video:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
segment = vi.VideoSegment(
start_time_offset=timedelta(seconds=146),
end_time_offset=timedelta(seconds=156),
)
results = detect_logos(video_uri, [segment])
Tunggu hingga video diproses:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Tambahkan fungsi ini untuk mencetak daftar logo yang terdeteksi:
def print_detected_logos(results: vi.VideoAnnotationResults):
annotations = results.logo_recognition_annotations
print(f" Detected logos: {len(annotations)} ".center(80, "-"))
for annotation in annotations:
entity = annotation.entity
entity_id = entity.entity_id
description = entity.description
for track in annotation.tracks:
confidence = track.confidence
t1 = track.segment.start_time_offset.total_seconds()
t2 = track.segment.end_time_offset.total_seconds()
logo_frames = len(track.timestamped_objects)
print(
f"{confidence:4.0%}",
f"{t1:>7.3f}",
f"{t2:>7.3f}",
f"{logo_frames:>3} fr.",
f"{entity_id:<15}",
f"{description}",
sep=" | ",
)
Memanggil fungsi:
print_detected_logos(results)
Anda akan melihat sesuatu seperti ini:
------------------------------ Detected logos: 1 ------------------------------- 92% | 150.680 | 155.720 | 43 fr. | /m/055t58 | Google Maps
Tambahkan fungsi ini untuk mencetak daftar bingkai logo dan kotak pembatas yang terdeteksi:
def print_logo_frames(results: vi.VideoAnnotationResults, entity_id: str):
def keep_annotation(annotation: vi.LogoRecognitionAnnotation) -> bool:
return annotation.entity.entity_id == entity_id
annotations = results.logo_recognition_annotations
annotations = [a for a in annotations if keep_annotation(a)]
for annotation in annotations:
description = annotation.entity.description
for track in annotation.tracks:
confidence = track.confidence
print(
f" {description},"
f" confidence: {confidence:.0%},"
f" frames: {len(track.timestamped_objects)} ".center(80, "-")
)
for timestamped_object in track.timestamped_objects:
t = timestamped_object.time_offset.total_seconds()
box = timestamped_object.normalized_bounding_box
print(
f"{t:>7.3f}",
f"({box.left:.5f}, {box.top:.5f})",
f"({box.right:.5f}, {box.bottom:.5f})",
sep=" | ",
)
Panggil fungsi dengan ID entitas logo Google Maps:
maps_entity_id = "/m/055t58"
print_logo_frames(results, maps_entity_id)
Anda akan melihat sesuatu seperti ini:
------------------- Google Maps, confidence: 92%, frames: 43 ------------------- 150.680 | (0.42024, 0.28633) | (0.58192, 0.64220) 150.800 | (0.41713, 0.27822) | (0.58318, 0.63556) ... 155.600 | (0.41775, 0.27701) | (0.58372, 0.63986) 155.720 | (0.41688, 0.28005) | (0.58335, 0.63954)
Jika Anda menggambar kotak pembatas di atas bingkai yang sesuai, Anda akan mendapatkannya:
Ringkasan
Pada langkah ini, Anda dapat melakukan deteksi dan pelacakan logo pada video menggunakan Video Intelligence API. Anda dapat membaca selengkapnya tentang mendeteksi dan melacak logo.
12. Mendeteksi banyak fitur
Berikut jenis permintaan yang dapat Anda buat untuk mendapatkan semua wawasan sekaligus:
from google.cloud import videointelligence_v1 as vi
video_client = vi.VideoIntelligenceServiceClient()
video_uri = "gs://..."
features = [
vi.Feature.SHOT_CHANGE_DETECTION,
vi.Feature.LABEL_DETECTION,
vi.Feature.EXPLICIT_CONTENT_DETECTION,
vi.Feature.SPEECH_TRANSCRIPTION,
vi.Feature.TEXT_DETECTION,
vi.Feature.OBJECT_TRACKING,
vi.Feature.LOGO_RECOGNITION,
vi.Feature.FACE_DETECTION, # NEW
vi.Feature.PERSON_DETECTION, # NEW
]
context = vi.VideoContext(
segments=...,
shot_change_detection_config=...,
label_detection_config=...,
explicit_content_detection_config=...,
speech_transcription_config=...,
text_detection_config=...,
object_tracking_config=...,
face_detection_config=..., # NEW
person_detection_config=..., # NEW
)
request = vi.AnnotateVideoRequest(
input_uri=video_uri,
features=features,
video_context=context,
)
# video_client.annotate_video(request)
13. Selamat!
Anda telah mempelajari cara menggunakan Video Intelligence API dengan Python!
Pembersihan
Untuk membersihkan lingkungan pengembangan Anda, dari Cloud Shell:
- Jika Anda masih berada dalam sesi IPython, kembali ke shell:
exit
- Berhenti menggunakan lingkungan virtual Python:
deactivate
- Hapus folder lingkungan virtual Anda:
cd ~ ; rm -rf ./venv-videointel
Untuk menghapus project Google Cloud Anda dari Cloud Shell:
- Ambil project ID Anda saat ini:
PROJECT_ID=$(gcloud config get-value core/project)
- Pastikan project ini yang ingin Anda hapus:
echo $PROJECT_ID
- Hapus project:
gcloud projects delete $PROJECT_ID
Pelajari lebih lanjut
- Uji demo di browser Anda: https://zackakil.github.io/video-intelligence-api-visualiser
- Dokumentasi Video Intelligence: https://cloud.google.com/video-intelligence/docs
- Fitur beta: https://cloud.google.com/video-intelligence/docs/beta
- Python di Google Cloud: https://cloud.google.com/python
- Library Klien Cloud untuk Python: https://github.com/googleapis/google-cloud-python
Lisensi
Karya ini dilisensikan berdasarkan Lisensi Umum Creative Commons Attribution 2.0.