Python के साथ Video Intelligence API का इस्तेमाल करना

1. खास जानकारी

cfaa6ffa7bc5ca70.png

Video Intelligence API की मदद से, अपने ऐप्लिकेशन के हिस्से के तौर पर Google की वीडियो विश्लेषण टेक्नोलॉजी का इस्तेमाल किया जा सकता है.

इस लैब में, आपको Python के साथ Video Intelligence API के इस्तेमाल पर ध्यान देना होगा.

आपको इनके बारे में जानकारी मिलेगी

  • अपना एनवायरमेंट सेट अप करने का तरीका
  • Python सेट अप करने का तरीका
  • शॉट में हुए बदलावों का पता लगाने का तरीका
  • लेबल का पता लगाने का तरीका
  • अश्लील कॉन्टेंट का पता लगाने का तरीका
  • बोली को टेक्स्ट में बदलने का तरीका
  • टेक्स्ट का पता लगाने और उसे ट्रैक करने का तरीका
  • ऑब्जेक्ट का पता लगाने और उन्हें ट्रैक करने का तरीका
  • लोगो का पता लगाने और उन्हें ट्रैक करने का तरीका

आपको इन चीज़ों की ज़रूरत होगी

  • Google Cloud प्रोजेक्ट
  • Chrome या Firefox जैसा ब्राउज़र
  • Python का इस्तेमाल करना

सर्वे

इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?

इसे सिर्फ़ पढ़ें इसे पढ़ें और कसरतों को पूरा करें

Python के साथ अपने अनुभव को आप कितनी रेटिंग देंगे?

शुरुआती इंटरमीडिएट कुशल

Google Cloud की सेवाओं का इस्तेमाल करने का आपका अनुभव कैसा रहा?

शुरुआती इंटरमीडिएट कुशल

2. सेटअप और ज़रूरी शर्तें

अपने हिसाब से एनवायरमेंट सेटअप करना

  1. Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से Gmail या Google Workspace खाता नहीं है, तो आपको नया खाता बनाना होगा.

b35bf95b8bf3d5d8.png

a99b7ace416376c4.png

bd84a6d3004737c5.png

  • प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों का डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करता. इसे कभी भी अपडेट किया जा सकता है.
  • प्रोजेक्ट आईडी, Google Cloud के सभी प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. इसे सेट करने के बाद बदला नहीं जा सकता. Cloud Console, एक यूनीक स्ट्रिंग अपने-आप जनरेट करता है; आम तौर पर, आपको उसके होने की कोई परवाह नहीं होती. ज़्यादातर कोडलैब में, आपको अपना प्रोजेक्ट आईडी बताना होगा. आम तौर पर, इसकी पहचान PROJECT_ID के रूप में की जाती है. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो किसी भी क्रम में एक और आईडी जनरेट किया जा सकता है. दूसरा तरीका यह है कि आप खुद भी आज़माकर देखें कि वह उपलब्ध है या नहीं. इस चरण के बाद, इसे बदला नहीं जा सकता. साथ ही, यह प्रोजेक्ट के खत्म होने तक बना रहता है.
  • आपकी जानकारी के लिए, प्रोजेक्ट नंबर नाम की एक तीसरी वैल्यू दी गई है. इसका इस्तेमाल कुछ एपीआई करते हैं. दस्तावेज़ में इन तीनों वैल्यू के बारे में ज़्यादा जानें.
  1. इसके बाद, आपको क्लाउड संसाधनों/एपीआई का इस्तेमाल करने के लिए, Cloud Console में बिलिंग चालू करनी होगी. इस कोडलैब का इस्तेमाल करने पर, आपको ज़्यादा पैसे नहीं चुकाने होंगे. इस ट्यूटोरियल के अलावा, बिलिंग से बचने के लिए संसाधनों को बंद करें. इसके लिए, अपने बनाए गए संसाधनों को मिटाएं या प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ता, 300 डॉलर के मुफ़्त ट्रायल वाले प्रोग्राम में हिस्सा ले सकते हैं.

Cloud Shell शुरू करना

Google Cloud को आपके लैपटॉप से, कहीं से भी ऑपरेट किया जा सकता है. हालांकि, इस कोडलैब में Cloud Shell का इस्तेमाल किया जा रहा है. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

Cloud Shell चालू करें

  1. Cloud Console में, Cloud Shell चालू करें 853e55310c205094.png पर क्लिक करें.

55efc1aaa7a4d3ad.png

अगर आपने Cloud Shell का इस्तेमाल पहली बार किया है, तो आपको बीच में आने वाली स्क्रीन दिखेगी. इसमें यह बताया जाएगा कि यह क्या है. अगर आपको बीच के लेवल पर मिलने वाली स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

9c92662c6a846a5c.png

प्रावधान करने और Cloud Shell से कनेक्ट होने में कुछ ही समय लगेगा.

9f0e51b578fecce5.png

इस वर्चुअल मशीन में डेवलपमेंट के सभी ज़रूरी टूल मौजूद हैं. इसमें लगातार पांच जीबी की होम डायरेक्ट्री मिलती है और यह Google Cloud में काम करती है. यह नेटवर्क की परफ़ॉर्मेंस और ऑथेंटिकेशन को बेहतर बनाने में मदद करती है. अगर सभी नहीं, तो इस कोडलैब में आपका बहुत सारा काम ब्राउज़र से किया जा सकता है.

Cloud Shell से कनेक्ट करने के बाद, आपको दिखेगा कि आपकी पुष्टि हो चुकी है और प्रोजेक्ट आपके प्रोजेक्ट आईडी पर सेट है.

  1. यह पुष्टि करने के लिए Cloud Shell में नीचे दिया गया कमांड चलाएं कि आपकी पुष्टि हो गई है:
gcloud auth list

कमांड आउटपुट

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`
  1. Cloud Shell में यह कमांड चलाएं, ताकि यह पुष्टि की जा सके कि gcloud के लिए कमांड को आपके प्रोजेक्ट के बारे में जानकारी है:
gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

अगर ऐसा नहीं है, तो आप इसे इस निर्देश की मदद से सेट कर सकते हैं:

gcloud config set project <PROJECT_ID>

कमांड आउटपुट

Updated property [core/project].

3. एनवायरमेंट का सेटअप

Video Intelligence API का इस्तेमाल शुरू करने से पहले, एपीआई चालू करने के लिए, Cloud Shell में यह कमांड चलाएं:

gcloud services enable videointelligence.googleapis.com

आपको कुछ ऐसा दिखेगा:

Operation "operations/..." finished successfully.

अब Video Intelligence API का इस्तेमाल किया जा सकता है!

अपनी होम डायरेक्ट्री पर जाएं:

cd ~

डिपेंडेंसी को अलग करने के लिए, Python वर्चुअल एनवायरमेंट बनाएं:

virtualenv venv-videointel

वर्चुअल एनवायरमेंट चालू करें:

source venv-videointel/bin/activate

IPython और Video Intelligence API क्लाइंट लाइब्रेरी इंस्टॉल करें:

pip install ipython google-cloud-videointelligence

आपको कुछ ऐसा दिखेगा:

...
Installing collected packages: ..., ipython, google-cloud-videointelligence
Successfully installed ... google-cloud-videointelligence-2.11.0 ...

अब आप Video Intelligence API की क्लाइंट लाइब्रेरी का इस्तेमाल करने के लिए तैयार हैं!

अगले चरणों में, आपको IPython नाम के एक इंटरैक्टिव Python इंटरप्रेटर का इस्तेमाल करना होगा, जिसे आपने पिछले चरण में इंस्टॉल किया था. Cloud Shell में ipython चलाकर सेशन शुरू करें:

ipython

आपको कुछ ऐसा दिखेगा:

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. सैंपल वीडियो

Cloud Storage में सेव किए गए या डेटा बाइट के तौर पर उपलब्ध कराए गए वीडियो के बारे में बताने के लिए, Video Intelligence API का इस्तेमाल किया जा सकता है.

अगले चरणों में, आपको Cloud Storage में सेव किए गए सैंपल वीडियो का इस्तेमाल करना होगा. वीडियो को अपने ब्राउज़र में देखा जा सकता है.

afe058b29c480d42.png

तैयार रहें!

5. शॉट में किए गए बदलावों का पता लगाएं

किसी वीडियो के शॉट में हुए बदलावों का पता लगाने के लिए, Video Intelligence API का इस्तेमाल किया जा सकता है. शॉट, वीडियो का एक हिस्सा होता है. इसमें फ़्रेम की ऐसी सीरीज़ होती है जिसमें विज़ुअल लगातार दिखता रहता है.

यहां दिए गए कोड को अपने 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

कोड को अच्छी तरह से समझें और देखें कि यह SHOT_CHANGE_DETECTION पैरामीटर के साथ annotate_video क्लाइंट लाइब्रेरी वाले तरीके का इस्तेमाल करके, वीडियो का विश्लेषण करने और शॉट में होने वाले बदलावों का पता कैसे लगाता है.

वीडियो का विश्लेषण करने के लिए, फ़ंक्शन को कॉल करें:

video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"

results = detect_shot_changes(video_uri)

वीडियो प्रोसेस होने तक इंतज़ार करें:

Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...

वीडियो शॉट प्रिंट करने के लिए यह फ़ंक्शन जोड़ें:

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

फ़ंक्शन को कॉल करें:

print_video_shots(results)

आपको कुछ ऐसा दिखेगा:

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

अगर हर शॉट के बीच का फ़्रेम निकाला जाता है और उन्हें फ़्रेम की दीवार पर लगाया जाता है, तो वीडियो की खास जानकारी को विज़ुअल के रूप में जनरेट किया जा सकता है:

25bbffa59f7ed71d.png

खास जानकारी

इस चरण में, Video Intelligence API का इस्तेमाल करके, किसी वीडियो पर शॉट में बदलाव का पता लगाने की सुविधा मिली. शॉट में होने वाले बदलावों का पता लगाने के बारे में ज़्यादा जानें.

6. लेबल का पता लगाएं

वीडियो में लेबल का पता लगाने के लिए, Video Intelligence API का इस्तेमाल किया जा सकता है. लेबल, वीडियो के विज़ुअल कॉन्टेंट के आधार पर उसकी जानकारी देते हैं.

यहां दिए गए कोड को अपने 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

कोड को अच्छी तरह से समझें और देखें कि यह LABEL_DETECTION पैरामीटर के साथ किसी वीडियो का विश्लेषण करने और लेबल का पता लगाने के लिए, annotate_video क्लाइंट लाइब्रेरी वाले तरीके का इस्तेमाल कैसे करता है.

वीडियो के पहले 37 सेकंड का विश्लेषण करने के लिए फ़ंक्शन को कॉल करें:

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

वीडियो प्रोसेस होने तक इंतज़ार करें:

Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...

वीडियो लेवल पर लेबल को प्रिंट करने के लिए, यह फ़ंक्शन जोड़ें:

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

फ़ंक्शन को कॉल करें:

print_video_labels(results)

आपको कुछ ऐसा दिखेगा:

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

वीडियो के लेवल पर बनाए गए इन लेबल की मदद से, यह समझा जा सकता है कि वीडियो की शुरुआत ज़्यादातर प्रकृति और पेड़-पौधों के बारे में है.

शॉट स्तर पर लेबल को प्रिंट करने के लिए यह फ़ंक्शन जोड़ें:

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)

फ़ंक्शन को कॉल करें:

print_shot_labels(results)

आपको कुछ ऐसा दिखेगा:

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

इन शॉट-लेवल लेबल की मदद से, यह समझा जा सकता है कि वीडियो की शुरुआत ग्रह (जैसे कि पृथ्वी) के शॉट से होगी. साथ ही, 34.760-36.960s के शॉट में एक तितली मौजूद है,...

खास जानकारी

इस चरण में, Video Intelligence API का इस्तेमाल करके किसी वीडियो पर लेबल की पहचान की जा सकती है. लेबल का पता लगाने के बारे में ज़्यादा जानें.

7. अश्लील कॉन्टेंट का पता लगाएं

किसी वीडियो में अश्लील कॉन्टेंट का पता लगाने के लिए, Video Intelligence API का इस्तेमाल किया जा सकता है. अश्लील कॉन्टेंट, वयस्कों के लिए बना कॉन्टेंट होता है. आम तौर पर, यह 18 साल से कम उम्र के लोगों के लिए सही नहीं होता. इसमें नग्नता, सेक्शुअल ऐक्ट, और पोर्नोग्राफ़ी के अलावा, और भी चीज़ें शामिल हो सकती हैं. वीडियो की पहचान, हर फ़्रेम के विज़ुअल सिग्नल के आधार पर की जाती है. इसमें ऑडियो का इस्तेमाल नहीं किया जाता. रिस्पॉन्स में, VERY_UNLIKELY से VERY_LIKELY के बीच संभावित वैल्यू शामिल होती हैं.

यहां दिए गए कोड को अपने 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

कोड को अच्छी तरह समझें और देखें कि यह EXPLICIT_CONTENT_DETECTION पैरामीटर के साथ annotate_video क्लाइंट लाइब्रेरी वाले तरीके का इस्तेमाल करके, वीडियो का विश्लेषण करने और अश्लील कॉन्टेंट की पहचान कैसे करता है.

वीडियो के पहले 10 सेकंड का विश्लेषण करने के लिए फ़ंक्शन को कॉल करें:

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

वीडियो प्रोसेस होने तक इंतज़ार करें:

Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...

अलग-अलग संभावना वाली संख्याओं को प्रिंट करने के लिए इस फ़ंक्शन को जोड़ें:

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

फ़ंक्शन को कॉल करें:

print_explicit_content(results)

आपको कुछ ऐसा दिखेगा:

----- Explicit content frames: 10 ------
LIKELIHOOD_UNSPECIFIED:   0
VERY_UNLIKELY         :  10
UNLIKELY              :   0
POSSIBLE              :   0
LIKELY                :   0
VERY_LIKELY           :   0

फ़्रेम के विवरण प्रिंट करने के लिए यह फ़ंक्शन जोड़ें:

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)

फ़ंक्शन को कॉल करें:

print_frames(results, vi.Likelihood.VERY_UNLIKELY)

आपको कुछ ऐसा दिखेगा:

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

खास जानकारी

इस चरण में, Video Intelligence API का इस्तेमाल करके, किसी वीडियो में अश्लील कॉन्टेंट की पहचान की जा सकी. अश्लील कॉन्टेंट का पता लगाने के बारे में ज़्यादा जानें.

8. बोली को टेक्स्ट में बदलें

वीडियो में कही गई बातों को टेक्स्ट में बदलने के लिए, Video Intelligence API का इस्तेमाल किया जा सकता है.

यहां दिए गए कोड को अपने 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

कोड को अच्छी तरह से समझें और देखें कि यह SPEECH_TRANSCRIPTION पैरामीटर के साथ annotate_video क्लाइंट लाइब्रेरी वाले तरीके का इस्तेमाल, वीडियो का विश्लेषण करने और बोली को टेक्स्ट में बदलने के लिए कैसे करता है.

सेकंड 55 से 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])

वीडियो प्रोसेस होने तक इंतज़ार करें:

Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...

बोले जा रहे शब्दों को टेक्स्ट में बदलने की सुविधा को प्रिंट करने के लिए, इस फ़ंक्शन को जोड़ें:

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

फ़ंक्शन को कॉल करें:

print_video_speech(results)

आपको कुछ ऐसा दिखेगा:

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

पहचाने गए शब्दों और उनके टाइमस्टैंप को प्रिंट करने के लिए, इस फ़ंक्शन को जोड़ें:

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

फ़ंक्शन को कॉल करें:

print_word_timestamps(results)

आपको कुछ ऐसा दिखेगा:

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

खास जानकारी

इस चरण में, Video Intelligence API का इस्तेमाल करके, वीडियो पर बोली को लेख में बदला गया. ऑडियो को लेख में बदलने के बारे में ज़्यादा जानें.

9. टेक्स्ट का पता लगाना और उसे ट्रैक करना

किसी वीडियो में टेक्स्ट का पता लगाने और उसे ट्रैक करने के लिए, Video Intelligence API का इस्तेमाल किया जा सकता है.

यहां दिए गए कोड को अपने 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

कोड को अच्छी तरह से समझें और देखें कि यह TEXT_DETECTION पैरामीटर के साथ annotate_video क्लाइंट लाइब्रेरी वाले तरीके का इस्तेमाल करके, वीडियो का विश्लेषण करने और टेक्स्ट का पता लगाने का तरीका कैसे इस्तेमाल करता है.

13 से 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])

वीडियो प्रोसेस होने तक इंतज़ार करें:

Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...

पता लगाए गए टेक्स्ट को प्रिंट करने के लिए यह फ़ंक्शन जोड़ें:

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

फ़ंक्शन को कॉल करें:

print_video_text(results)

आपको कुछ ऐसा दिखेगा:

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

पहचाने गए टेक्स्ट फ़्रेम और बाउंडिंग बॉक्स की सूची को प्रिंट करने के लिए, इस फ़ंक्शन को जोड़ें:

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

फ़ंक्शन को कॉल करके देखें कि कौनसे फ़्रेम, नैरेटर का नाम दिखाते हैं:

contained_text = "Goodall"
print_text_frames(results, contained_text)

आपको कुछ ऐसा दिखेगा:

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

अगर अलग-अलग फ़्रेम के ऊपर बाउंडिंग बॉक्स बनाए जाते हैं, तो आपको यह दिखेगा:

7e530d3d25f2f40e.gif

खास जानकारी

इस चरण में, Video Intelligence API का इस्तेमाल करके, वीडियो पर टेक्स्ट की पहचान और उसे ट्रैक करने की सुविधा पाई गई. टेक्स्ट का पता लगाने और उसे ट्रैक करने के बारे में ज़्यादा जानें.

10. ऑब्जेक्ट का पता लगाएं और उन्हें ट्रैक करें

वीडियो में मौजूद चीज़ों का पता लगाने और उन्हें ट्रैक करने के लिए, Video Intelligence API का इस्तेमाल किया जा सकता है.

यहां दिए गए कोड को अपने 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

कोड को अच्छी तरह से समझें और देखें कि यह OBJECT_TRACKING पैरामीटर के साथ annotate_video क्लाइंट लाइब्रेरी वाले तरीके का इस्तेमाल करके, वीडियो का विश्लेषण करने और ऑब्जेक्ट का पता लगाने का तरीका कैसे इस्तेमाल करता है.

सेकंड 98 से 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])

वीडियो प्रोसेस होने तक इंतज़ार करें:

Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...

पता लगाए गए ऑब्जेक्ट की सूची को प्रिंट करने के लिए यह फ़ंक्शन जोड़ें:

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

फ़ंक्शन को कॉल करें:

print_detected_objects(results)

आपको कुछ ऐसा दिखेगा:

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

पता लगाए गए ऑब्जेक्ट फ़्रेम और बाउंडिंग बॉक्स की सूची को प्रिंट करने के लिए, इस फ़ंक्शन को जोड़ें:

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

कीड़ों के लिए, इकाई आईडी वाले फ़ंक्शन को कॉल करें:

insect_entity_id = "/m/03vt0"
print_object_frames(results, insect_entity_id)

आपको कुछ ऐसा दिखेगा:

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

अगर अलग-अलग फ़्रेम के ऊपर बाउंडिंग बॉक्स बनाए जाते हैं, तो आपको यह दिखेगा:

8f5796f6e73d1a46.gif

c195a2dca4573f95.gif

खास जानकारी

इस चरण में, Video Intelligence API का इस्तेमाल करके, किसी वीडियो पर ऑब्जेक्ट की पहचान और उसे ट्रैक किया जा सका. ऑब्जेक्ट का पता लगाने और उन्हें ट्रैक करने के बारे में ज़्यादा जानें.

11. लोगो का पता लगाना और उन्हें ट्रैक करना

किसी वीडियो में लोगो का पता लगाने और उन्हें ट्रैक करने के लिए, Video Intelligence API का इस्तेमाल किया जा सकता है. एक साथ 1,00,000 से ज़्यादा ब्रैंड और लोगो का पता लगाया जा सकता है.

यहां दिए गए कोड को अपने 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

कोड को अच्छी तरह से समझें और देखें कि यह LOGO_RECOGNITION पैरामीटर के साथ annotate_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])

वीडियो प्रोसेस होने तक इंतज़ार करें:

Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...

पता लगाए गए लोगो की सूची को प्रिंट करने के लिए यह फ़ंक्शन जोड़ें:

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

फ़ंक्शन को कॉल करें:

print_detected_logos(results)

आपको कुछ ऐसा दिखेगा:

------------------------------ Detected logos: 1 -------------------------------
 92% | 150.680 | 155.720 |  43 fr. | /m/055t58       | Google Maps

पता लगाए गए लोगो फ़्रेम और बाउंडिंग बॉक्स की सूची को प्रिंट करने के लिए, इस फ़ंक्शन को जोड़ें:

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

Google मैप लोगो इकाई आईडी के साथ फ़ंक्शन को कॉल करें:

maps_entity_id = "/m/055t58"
print_logo_frames(results, maps_entity_id)

आपको कुछ ऐसा दिखेगा:

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

अगर अलग-अलग फ़्रेम के ऊपर बाउंडिंग बॉक्स बनाए जाते हैं, तो आपको यह दिखेगा:

554743aff6d8824c.gif

खास जानकारी

इस चरण में, Video Intelligence API का इस्तेमाल करके, वीडियो पर लोगो की पहचान करने और उसे ट्रैक करने की सुविधा मिली. लोगो का पता लगाने और उन्हें ट्रैक करने के बारे में ज़्यादा जानें.

12. कई सुविधाओं का पता लगाएं

एक ही बार में सभी अहम जानकारी पाने के लिए, यह अनुरोध किया जा सकता है:

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. बधाई हो!

cfaa6ffa7bc5ca70.png

आपने Python का इस्तेमाल करके, Video Intelligence API को इस्तेमाल करने का तरीका सीखा!

व्यवस्थित करें

Cloud Shell की मदद से, अपने डेवलपमेंट एनवायरमेंट को खाली करने के लिए:

  • अगर आप अब भी अपने IPython सेशन में हैं, तो शेल पर वापस जाएं: exit
  • Python वर्चुअल एनवायरमेंट का इस्तेमाल बंद करें: deactivate
  • अपना वर्चुअल एनवायरमेंट फ़ोल्डर मिटाएं: cd ~ ; rm -rf ./venv-videointel

Cloud Shell से अपना Google Cloud प्रोजेक्ट मिटाने के लिए:

  • अपना मौजूदा प्रोजेक्ट आईडी वापस पाएं: PROJECT_ID=$(gcloud config get-value core/project)
  • पक्का करें कि यह वही प्रोजेक्ट है जिसे आपको मिटाना है: echo $PROJECT_ID
  • प्रोजेक्ट मिटाएं: gcloud projects delete $PROJECT_ID

ज़्यादा जानें

लाइसेंस

इस काम को क्रिएटिव कॉमंस एट्रिब्यूशन 2.0 जेनरिक लाइसेंस के तहत लाइसेंस मिला है.