۱. مرور کلی
رابط برنامهنویسی کاربردی هوش ویدیویی (Video Intelligence API) شما را قادر میسازد تا از فناوری تحلیل ویدیوی گوگل به عنوان بخشی از برنامههای خود استفاده کنید.
در این آزمایش، شما بر استفاده از رابط برنامهنویسی کاربردی هوش ویدیویی (Video Intelligence API) با پایتون تمرکز خواهید کرد.
آنچه یاد خواهید گرفت
- چگونه محیط خود را تنظیم کنید
- نحوه راهاندازی پایتون
- چگونه تغییرات شات را تشخیص دهیم
- نحوه تشخیص برچسب ها
- نحوه تشخیص محتوای صریح
- نحوه رونویسی گفتار
- نحوه تشخیص و ردیابی متن
- نحوه تشخیص و ردیابی اشیاء
- نحوه شناسایی و ردیابی لوگوها
آنچه نیاز دارید
نظرسنجی
چگونه از این آموزش استفاده خواهید کرد؟
تجربه خود را با پایتون چگونه ارزیابی میکنید؟
تجربه خود را با خدمات ابری گوگل چگونه ارزیابی میکنید؟
۲. تنظیمات و الزامات
تنظیم محیط خودتنظیم
- وارد کنسول گوگل کلود شوید و یک پروژه جدید ایجاد کنید یا از یک پروژه موجود دوباره استفاده کنید. اگر از قبل حساب جیمیل یا گوگل ورک اسپیس ندارید، باید یکی ایجاد کنید .
- نام پروژه، نام نمایشی برای شرکتکنندگان این پروژه است. این یک رشته کاراکتری است که توسط APIهای گوگل استفاده نمیشود. شما همیشه میتوانید آن را بهروزرسانی کنید.
- شناسه پروژه در تمام پروژههای گوگل کلود منحصر به فرد است و تغییرناپذیر است (پس از تنظیم، قابل تغییر نیست). کنسول کلود به طور خودکار یک رشته منحصر به فرد تولید میکند؛ معمولاً برای شما مهم نیست که چه باشد. در اکثر آزمایشگاههای کد، باید شناسه پروژه خود را (که معمولاً با عنوان
PROJECT_IDشناخته میشود) ارجاع دهید. اگر شناسه تولید شده را دوست ندارید، میتوانید یک شناسه تصادفی دیگر ایجاد کنید. به عنوان یک جایگزین، میتوانید شناسه خودتان را امتحان کنید و ببینید که آیا در دسترس است یا خیر. پس از این مرحله قابل تغییر نیست و در طول پروژه باقی میماند. - برای اطلاع شما، یک مقدار سوم، شماره پروژه ، وجود دارد که برخی از APIها از آن استفاده میکنند. برای کسب اطلاعات بیشتر در مورد هر سه این مقادیر، به مستندات مراجعه کنید.
- در مرحله بعد، برای استفاده از منابع/API های ابری، باید پرداخت صورتحساب را در کنسول ابری فعال کنید . اجرای این آزمایشگاه کد هزینه زیادی نخواهد داشت، اگر اصلاً هزینهای داشته باشد. برای خاموش کردن منابع به منظور جلوگیری از پرداخت صورتحساب پس از این آموزش، میتوانید منابعی را که ایجاد کردهاید یا پروژه را حذف کنید. کاربران جدید Google Cloud واجد شرایط برنامه آزمایشی رایگان ۳۰۰ دلاری هستند.
شروع پوسته ابری
اگرچه میتوان گوگل کلود را از راه دور و از طریق لپتاپ شما مدیریت کرد، اما در این آزمایشگاه کد از Cloud Shell ، یک محیط خط فرمان که در فضای ابری اجرا میشود، استفاده خواهید کرد.
فعال کردن پوسته ابری
- از کنسول ابری، روی فعال کردن پوسته ابری کلیک کنید
.
اگر این اولین باری است که Cloud Shell را اجرا میکنید، یک صفحه میانی برای توضیح آن به شما نمایش داده میشود. اگر با یک صفحه میانی مواجه شدید، روی ادامه کلیک کنید.
آمادهسازی و اتصال به Cloud Shell فقط چند لحظه طول میکشد.
این ماشین مجازی مجهز به تمام ابزارهای توسعه مورد نیاز است. این ماشین یک دایرکتوری خانگی پایدار ۵ گیگابایتی ارائه میدهد و در فضای ابری گوگل اجرا میشود که عملکرد شبکه و احراز هویت را تا حد زیادی افزایش میدهد. بخش عمدهای از کار شما در این آزمایشگاه کد، اگر نگوییم همه، را میتوان با یک مرورگر انجام داد.
پس از اتصال به Cloud Shell، باید ببینید که احراز هویت شدهاید و پروژه روی شناسه پروژه شما تنظیم شده است.
- برای تأیید احراز هویت، دستور زیر را در 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`
- دستور زیر را در Cloud Shell اجرا کنید تا تأیید کنید که دستور gcloud از پروژه شما اطلاع دارد:
gcloud config list project
خروجی دستور
[core] project = <PROJECT_ID>
اگر اینطور نیست، میتوانید با این دستور آن را تنظیم کنید:
gcloud config set project <PROJECT_ID>
خروجی دستور
Updated property [core/project].
۳. تنظیمات محیطی
قبل از اینکه بتوانید از API مربوط به Video Intelligence استفاده کنید، دستور زیر را در Cloud Shell اجرا کنید تا API فعال شود:
gcloud services enable videointelligence.googleapis.com
شما باید چیزی شبیه به این را ببینید:
Operation "operations/..." finished successfully.
حالا میتوانید از API هوش ویدیویی استفاده کنید!
به دایرکتوری خانگی خود بروید:
cd ~
یک محیط مجازی پایتون برای جداسازی وابستگیها ایجاد کنید:
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 که در مرحله قبل نصب کردهاید، استفاده خواهید کرد. با اجرای ipython در Cloud Shell، یک جلسه را شروع کنید:
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]:
۴. نمونه ویدیو
شما میتوانید از API هوش ویدیویی برای حاشیهنویسی ویدیوهای ذخیرهشده در فضای ذخیرهسازی ابری یا ویدیوهایی که به صورت بایت داده ارائه میشوند، استفاده کنید.
در مراحل بعدی، از یک ویدیوی نمونه ذخیره شده در فضای ابری استفاده خواهید کرد. میتوانید ویدیو را در مرورگر خود مشاهده کنید .
آماده، ثابت، برو!
۵. تشخیص تغییرات شات
شما میتوانید از رابط برنامهنویسی کاربردی هوش ویدیویی (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
لحظهای وقت بگذارید و کد را مطالعه کنید و ببینید که چگونه از متد کتابخانه کلاینت annotate_video به همراه پارامتر SHOT_CHANGE_DETECTION برای تجزیه و تحلیل یک ویدیو و تشخیص تغییرات شات استفاده میکند.
برای تحلیل ویدیو، تابع را فراخوانی کنید:
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
اگر فریم میانی هر نما را جدا کنید و آنها را در دیواری از فریمها بچینید، میتوانید خلاصهای بصری از ویدیو ایجاد کنید:
خلاصه
در این مرحله، شما توانستید با استفاده از Video Intelligence API، تشخیص تغییر شات را روی یک ویدیو انجام دهید. میتوانید درباره تشخیص تغییرات شات بیشتر بخوانید.
۶. تشخیص برچسبها
شما میتوانید از رابط برنامهنویسی کاربردی هوش ویدیویی (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
لحظهای وقت بگذارید و کد را مطالعه کنید و ببینید که چگونه از متد کتابخانه کلاینت annotate_video به همراه پارامتر LABEL_DETECTION برای تجزیه و تحلیل یک ویدیو و تشخیص برچسبها استفاده میکند.
برای تحلیل ۳۷ ثانیه اول ویدیو، تابع را فراخوانی کنید:
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)
به لطف این برچسبهای سطح ویدیو، میتوانید متوجه شوید که ابتدای ویدیو بیشتر درباره طبیعت و پوشش گیاهی است.
این تابع را برای چاپ برچسبها در سطح shot اضافه کنید:
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، تشخیص برچسب را روی یک ویدیو انجام دهید. میتوانید درباره تشخیص برچسبها بیشتر بخوانید.
۷. تشخیص محتوای صریح
شما میتوانید از API هوش ویدیویی برای تشخیص محتوای صریح در یک ویدیو استفاده کنید. محتوای صریح، محتوای بزرگسالانهای است که عموماً برای افراد زیر ۱۸ سال نامناسب است و شامل برهنگی، فعالیتهای جنسی و پورنوگرافی میشود، اما محدود به این موارد نیست. تشخیص فقط بر اساس سیگنالهای بصری در هر فریم انجام میشود (صدا استفاده نمیشود). پاسخ شامل مقادیر احتمال از 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
لحظهای وقت بگذارید و کد را مطالعه کنید و ببینید که چگونه از متد کتابخانه کلاینت annotate_video به همراه پارامتر EXPLICIT_CONTENT_DETECTION برای تجزیه و تحلیل یک ویدیو و تشخیص محتوای صریح آن استفاده میکند.
برای تحلیل ۱۰ ثانیه اول ویدیو، تابع را فراخوانی کنید:
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، تشخیص محتوای صریح را روی یک ویدیو انجام دهید. میتوانید درباره تشخیص محتوای صریح بیشتر بخوانید.
۸. رونویسی گفتار
شما میتوانید از رابط برنامهنویسی کاربردی هوش ویدیویی (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
لحظهای وقت بگذارید و کد را مطالعه کنید و ببینید که چگونه از متد کتابخانه کلاینت annotate_video به همراه پارامتر SPEECH_TRANSCRIPTION برای تجزیه و تحلیل یک ویدیو و رونویسی گفتار استفاده میکند.
برای تحلیل ویدیو از ثانیه ۵۵ تا ۸۰، تابع را فراخوانی کنید:
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)، رونویسی گفتار را روی یک ویدیو انجام دهید. میتوانید درباره رونویسی صدا بیشتر بخوانید.
۹. تشخیص و ردیابی متن
شما میتوانید از 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
لحظهای وقت بگذارید و کد را مطالعه کنید و ببینید که چگونه از متد کتابخانه کلاینت annotate_video به همراه پارامتر TEXT_DETECTION برای تجزیه و تحلیل یک ویدیو و تشخیص متن استفاده میکند.
برای تحلیل ویدیو از ثانیه ۱۳ تا ۲۷، تابع را فراخوانی کنید:
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)
اگر کادرهای مرزی را روی فریمهای مربوطه رسم کنید، به شکل زیر خواهید رسید:
خلاصه
در این مرحله، شما توانستید با استفاده از Video Intelligence API، تشخیص و ردیابی متن را روی یک ویدیو انجام دهید. میتوانید درباره تشخیص و ردیابی متن بیشتر بخوانید.
۱۰. تشخیص و ردیابی اشیاء
شما میتوانید از رابط برنامهنویسی کاربردی هوش ویدیویی (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
لحظهای وقت بگذارید و کد را مطالعه کنید و ببینید که چگونه از متد کتابخانه کلاینت annotate_video به همراه پارامتر OBJECT_TRACKING برای تجزیه و تحلیل یک ویدیو و تشخیص اشیاء استفاده میکند.
برای تحلیل ویدیو از ثانیه ۹۸ تا ۱۱۲، تابع را فراخوانی کنید:
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)
اگر کادرهای مرزی را روی فریمهای مربوطه رسم کنید، به شکل زیر خواهید رسید:
خلاصه
در این مرحله، شما توانستید با استفاده از Video Intelligence API، تشخیص و ردیابی اشیاء را روی یک ویدیو انجام دهید. میتوانید درباره تشخیص و ردیابی اشیاء بیشتر بخوانید.
۱۱. شناسایی و ردیابی لوگوها
شما میتوانید از رابط برنامهنویسی کاربردی هوش ویدیویی (Video Intelligence API) برای شناسایی و ردیابی لوگوها در یک ویدیو استفاده کنید. بیش از ۱۰۰۰۰۰ برند و لوگو قابل شناسایی هستند.
کد زیر را در جلسه 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
لحظهای وقت بگذارید و کد را مطالعه کنید و ببینید که چگونه از متد کتابخانه کلاینت annotate_video به همراه پارامتر LOGO_RECOGNITION برای تجزیه و تحلیل یک ویدیو و تشخیص لوگوها استفاده میکند.
برای تحلیل سکانس ماقبل آخر ویدیو، تابع را فراخوانی کنید:
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=" | ",
)
تابع را با شناسه موجودیت لوگوی گوگل مپ فراخوانی کنید:
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)
اگر کادرهای مرزی را روی فریمهای مربوطه رسم کنید، به شکل زیر خواهید رسید:
خلاصه
در این مرحله، شما توانستید با استفاده از Video Intelligence API، تشخیص و ردیابی لوگو را روی یک ویدیو انجام دهید. میتوانید درباره تشخیص و ردیابی لوگوها بیشتر بخوانید.
۱۲. تشخیص چندین ویژگی
در اینجا نوع درخواستی که میتوانید برای دریافت همه بینشها به طور همزمان انجام دهید، آمده است:
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)
۱۳. تبریک میگویم!
شما یاد گرفتید که چگونه از API هوش ویدیویی با استفاده از پایتون استفاده کنید!
تمیز کردن
برای پاکسازی محیط توسعه خود، از Cloud Shell:
- اگر هنوز در جلسه IPython خود هستید، به پوسته برگردید:
exit - استفاده از محیط مجازی پایتون را متوقف کنید:
deactivate - پوشه محیط مجازی خود را حذف کنید:
cd ~ ; rm -rf ./venv-videointel
برای حذف پروژه Google Cloud خود، از Cloud Shell:
- شناسه پروژه فعلی خود را بازیابی کنید:
PROJECT_ID=$(gcloud config get-value core/project) - مطمئن شوید که این پروژهای است که میخواهید حذف کنید:
echo $PROJECT_ID - حذف پروژه:
gcloud projects delete $PROJECT_ID
بیشتر بدانید
- نسخه آزمایشی را در مرورگر خود امتحان کنید: https://zackakil.github.io/video-intelligence-api-visualiser
- مستندات هوش ویدیویی: https://cloud.google.com/video-intelligence/docs
- ویژگیهای بتا: https://cloud.google.com/video-intelligence/docs/beta
- پایتون در گوگل کلود: https://cloud.google.com/python
- کتابخانههای کلاینت ابری برای پایتون: https://github.com/googleapis/google-cloud-python
مجوز
این اثر تحت مجوز عمومی Creative Commons Attribution 2.0 منتشر شده است.