Menggunakan Video Intelligence API dengan Python

1. Ringkasan

cfaa6ffa7bc5ca70.png

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

  • Project Google Cloud
  • Browser, seperti Chrome atau Firefox
  • Pemahaman dalam menggunakan Python

Survei

Bagaimana Anda akan menggunakan tutorial ini?

Hanya membacanya Membacanya dan menyelesaikan latihan

Bagaimana penilaian Anda terhadap pengalaman dengan Python?

Pemula Menengah Mahir

Bagaimana Anda menilai pengalaman Anda dengan layanan Google Cloud?

Pemula Menengah Mahir

2. Penyiapan dan persyaratan

Penyiapan lingkungan mandiri

  1. 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.

b35bf95b8bf3d5d8.png

a99b7ace416376c4.png

bd84a6d3004737c5.png

  • 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.
  1. 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

  1. Dari Cloud Console, klik Aktifkan Cloud Shell 853e55310c205094.pngS.

55efc1aaa7a4d3ad.png

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.

9c92662c6a846a5c.pngS

Perlu waktu beberapa saat untuk penyediaan dan terhubung ke Cloud Shell.

9f0e51b578fecce5.pngS

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.

  1. 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`
  1. 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.

afe058b29c480d42.png

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:

25bbffa59f7ed71d.pngS

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:

7e530d3d25f2f40e.gif

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:

8f5796f6e73d1a46.gif

c195a2dca4573f95.gif

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:

554743aff6d8824c.gif

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!

cfaa6ffa7bc5ca70.png

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

Lisensi

Karya ini dilisensikan berdasarkan Lisensi Umum Creative Commons Attribution 2.0.