1. ওভারভিউ
ভিডিও ইন্টেলিজেন্স API আপনাকে আপনার অ্যাপ্লিকেশনের অংশ হিসাবে Google ভিডিও বিশ্লেষণ প্রযুক্তি ব্যবহার করতে সক্ষম করে।
এই ল্যাবে, আপনি পাইথনের সাথে ভিডিও ইন্টেলিজেন্স API ব্যবহার করার উপর ফোকাস করবেন।
আপনি কি শিখবেন
- আপনার পরিবেশ কিভাবে সেট আপ করবেন
- কিভাবে Python সেট আপ করবেন
- শট পরিবর্তনগুলি কীভাবে সনাক্ত করবেন
- কিভাবে লেবেল সনাক্ত করতে হয়
- স্পষ্ট বিষয়বস্তু সনাক্ত কিভাবে
- বক্তৃতা প্রতিলিপি কিভাবে
- কিভাবে টেক্সট সনাক্ত এবং ট্র্যাক
- কিভাবে বস্তু সনাক্ত এবং ট্র্যাক
- কিভাবে লোগো সনাক্ত এবং ট্র্যাক
আপনি কি প্রয়োজন হবে
- একটি Google ক্লাউড প্রকল্প
- একটি ব্রাউজার, যেমন ক্রোম বা ফায়ারফক্স
- পাইথন ব্যবহার করে পরিচিতি
সমীক্ষা
আপনি কিভাবে এই টিউটোরিয়াল ব্যবহার করবেন?
পাইথনের সাথে আপনার অভিজ্ঞতাকে আপনি কীভাবে মূল্যায়ন করবেন?
আপনি Google ক্লাউড পরিষেবাগুলির সাথে আপনার অভিজ্ঞতাকে কীভাবে মূল্যায়ন করবেন?
2. সেটআপ এবং প্রয়োজনীয়তা
স্ব-গতিসম্পন্ন পরিবেশ সেটআপ
- Google ক্লাউড কনসোলে সাইন-ইন করুন এবং একটি নতুন প্রকল্প তৈরি করুন বা বিদ্যমান একটি পুনরায় ব্যবহার করুন৷ আপনার যদি ইতিমধ্যেই একটি Gmail বা Google Workspace অ্যাকাউন্ট না থাকে, তাহলে আপনাকে অবশ্যই একটি তৈরি করতে হবে।
- প্রকল্পের নাম এই প্রকল্পের অংশগ্রহণকারীদের জন্য প্রদর্শনের নাম। এটি একটি অক্ষর স্ট্রিং যা Google API দ্বারা ব্যবহৃত হয় না। আপনি সবসময় এটি আপডেট করতে পারেন.
- প্রোজেক্ট আইডি সমস্ত Google ক্লাউড প্রোজেক্ট জুড়ে অনন্য এবং অপরিবর্তনীয় (সেট করার পরে পরিবর্তন করা যাবে না)। ক্লাউড কনসোল স্বয়ংক্রিয়ভাবে একটি অনন্য স্ট্রিং তৈরি করে; সাধারণত আপনি এটা কি যত্ন না. বেশিরভাগ কোডল্যাবে, আপনাকে আপনার প্রকল্প আইডি উল্লেখ করতে হবে (সাধারণত
PROJECT_IDহিসাবে চিহ্নিত)। আপনি যদি জেনারেট করা আইডি পছন্দ না করেন, তাহলে আপনি অন্য একটি এলোমেলো আইডি তৈরি করতে পারেন। বিকল্পভাবে, আপনি নিজের চেষ্টা করতে পারেন, এবং এটি উপলব্ধ কিনা দেখতে পারেন। এই ধাপের পরে এটি পরিবর্তন করা যাবে না এবং প্রকল্পের সময়কালের জন্য থাকে। - আপনার তথ্যের জন্য, একটি তৃতীয় মান আছে, একটি প্রকল্প নম্বর , যা কিছু API ব্যবহার করে। ডকুমেন্টেশনে এই তিনটি মান সম্পর্কে আরও জানুন।
- এরপরে, ক্লাউড রিসোর্স/এপিআই ব্যবহার করতে আপনাকে ক্লাউড কনসোলে বিলিং সক্ষম করতে হবে। এই কোডল্যাবের মাধ্যমে চালানোর জন্য খুব বেশি খরচ হবে না, যদি কিছু হয়। এই টিউটোরিয়ালের বাইরে বিলিং এড়াতে সংস্থানগুলি বন্ধ করতে, আপনি আপনার তৈরি করা সংস্থানগুলি মুছতে বা প্রকল্প মুছতে পারেন। নতুন Google ক্লাউড ব্যবহারকারীরা $300 USD বিনামূল্যের ট্রায়াল প্রোগ্রামের জন্য যোগ্য৷
ক্লাউড শেল শুরু করুন
যদিও Google ক্লাউড আপনার ল্যাপটপ থেকে দূরবর্তীভাবে পরিচালিত হতে পারে, এই কোডল্যাবে আপনি ক্লাউড শেল ব্যবহার করবেন, ক্লাউডে চলমান একটি কমান্ড লাইন পরিবেশ।
ক্লাউড শেল সক্রিয় করুন
- ক্লাউড কনসোল থেকে, ক্লাউড শেল সক্রিয় করুন ক্লিক করুন
.
যদি এটি আপনার প্রথমবার ক্লাউড শেল শুরু হয়, তাহলে এটি কী তা বর্ণনা করে আপনাকে একটি মধ্যবর্তী স্ক্রীন উপস্থাপন করা হবে। যদি আপনি একটি মধ্যবর্তী স্ক্রীনের সাথে উপস্থাপিত হন, তবে চালিয়ে যান ক্লিক করুন।
ক্লাউড শেলের সাথে সংযোগ করতে এবং সংযোগ করতে এটির মাত্র কয়েক মুহূর্ত লাগবে৷
এই ভার্চুয়াল মেশিনটি প্রয়োজনীয় সমস্ত বিকাশের সরঞ্জাম দিয়ে লোড করা হয়েছে। এটি একটি ক্রমাগত 5 GB হোম ডিরেক্টরি অফার করে এবং Google ক্লাউডে চলে, যা নেটওয়ার্ক কর্মক্ষমতা এবং প্রমাণীকরণকে ব্যাপকভাবে উন্নত করে। এই কোডল্যাবে আপনার অনেক কাজ, যদি সব না হয়, ব্রাউজার দিয়ে করা যেতে পারে।
একবার ক্লাউড শেলের সাথে সংযুক্ত হয়ে গেলে, আপনি দেখতে পাবেন যে আপনি প্রমাণীকৃত হয়েছেন এবং প্রকল্পটি আপনার প্রকল্প আইডিতে সেট করা আছে।
- আপনি প্রমাণীকৃত কিনা তা নিশ্চিত করতে ক্লাউড শেলে নিম্নলিখিত কমান্ডটি চালান:
gcloud auth list
কমান্ড আউটপুট
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- gcloud কমান্ড আপনার প্রকল্প সম্পর্কে জানে তা নিশ্চিত করতে ক্লাউড শেলে নিম্নলিখিত কমান্ডটি চালান:
gcloud config list project
কমান্ড আউটপুট
[core] project = <PROJECT_ID>
যদি এটি না হয়, আপনি এই কমান্ড দিয়ে এটি সেট করতে পারেন:
gcloud config set project <PROJECT_ID>
কমান্ড আউটপুট
Updated property [core/project].
3. পরিবেশ সেটআপ
আপনি ভিডিও ইন্টেলিজেন্স API ব্যবহার শুরু করার আগে, 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 ...
এখন, আপনি ভিডিও ইন্টেলিজেন্স API ক্লায়েন্ট লাইব্রেরি ব্যবহার করার জন্য প্রস্তুত!
পরবর্তী ধাপে, আপনি IPython নামে একটি ইন্টারেক্টিভ পাইথন ইন্টারপ্রেটার ব্যবহার করবেন, যা আপনি আগের ধাপে ইনস্টল করেছেন। ক্লাউড শেলে 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. নমুনা ভিডিও
আপনি ক্লাউড স্টোরেজে সঞ্চিত বা ডেটা বাইট হিসাবে সরবরাহ করা ভিডিওগুলিকে টীকা করতে ভিডিও ইন্টেলিজেন্স API ব্যবহার করতে পারেন৷
পরবর্তী ধাপে, আপনি ক্লাউড স্টোরেজে সঞ্চিত একটি নমুনা ভিডিও ব্যবহার করবেন। আপনি আপনার ব্রাউজারে ভিডিওটি দেখতে পারেন।
প্রস্তুত, স্থির, যান!
5. শট পরিবর্তন সনাক্ত করুন
আপনি একটি ভিডিওতে শট পরিবর্তন সনাক্ত করতে ভিডিও ইন্টেলিজেন্স 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
আপনি যদি প্রতিটি শটের মধ্যবর্তী ফ্রেমটি বের করেন এবং ফ্রেমের দেয়ালে সাজান, তাহলে আপনি ভিডিওটির একটি ভিজ্যুয়াল সারাংশ তৈরি করতে পারেন:
সারাংশ
এই ধাপে, আপনি ভিডিও ইন্টেলিজেন্স API ব্যবহার করে একটি ভিডিওতে শট পরিবর্তন সনাক্তকরণ করতে সক্ষম হয়েছেন। শট পরিবর্তন সনাক্তকরণ সম্পর্কে আপনি আরও পড়তে পারেন।
6. লেবেল সনাক্ত করুন
আপনি ভিডিওতে লেবেল সনাক্ত করতে ভিডিও ইন্টেলিজেন্স 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 শটে একটি প্রজাপতি আছে,...
সারাংশ
এই ধাপে, আপনি ভিডিও ইন্টেলিজেন্স API ব্যবহার করে একটি ভিডিওতে লেবেল সনাক্তকরণ করতে সক্ষম হয়েছেন। আপনি লেবেল সনাক্তকরণ সম্পর্কে আরও পড়তে পারেন।
7. স্পষ্ট বিষয়বস্তু সনাক্ত করুন
আপনি একটি ভিডিওতে স্পষ্ট বিষয়বস্তু সনাক্ত করতে ভিডিও ইন্টেলিজেন্স 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
সারাংশ
এই ধাপে, আপনি ভিডিও ইন্টেলিজেন্স API ব্যবহার করে একটি ভিডিওতে স্পষ্ট বিষয়বস্তু সনাক্তকরণ করতে সক্ষম হয়েছেন। আপনি স্পষ্ট বিষয়বস্তু সনাক্তকরণ সম্পর্কে আরও পড়তে পারেন৷
8. বক্তৃতা প্রতিলিপি
আপনি ভিডিও স্পীচ টেক্সটে প্রতিলিপি করতে ভিডিও ইন্টেলিজেন্স 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.
সারাংশ
এই ধাপে, আপনি ভিডিও ইন্টেলিজেন্স API ব্যবহার করে একটি ভিডিওতে স্পিচ ট্রান্সক্রিপশন করতে সক্ষম হয়েছেন। আপনি অডিও প্রতিলিপি সম্পর্কে আরো পড়তে পারেন.
9. পাঠ্য সনাক্ত করুন এবং ট্র্যাক করুন
আপনি একটি ভিডিওতে পাঠ্য সনাক্ত এবং ট্র্যাক করতে ভিডিও ইন্টেলিজেন্স 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)
আপনি যদি সংশ্লিষ্ট ফ্রেমের উপরে বাউন্ডিং বাক্সগুলি আঁকেন, তাহলে আপনি এটি পাবেন:
সারাংশ
এই ধাপে, আপনি ভিডিও ইন্টেলিজেন্স API ব্যবহার করে একটি ভিডিওতে পাঠ্য সনাক্তকরণ এবং ট্র্যাকিং করতে সক্ষম হয়েছেন। আপনি পাঠ্য সনাক্তকরণ এবং ট্র্যাকিং সম্পর্কে আরও পড়তে পারেন।
10. বস্তু সনাক্ত এবং ট্র্যাক
আপনি একটি ভিডিওতে বস্তু সনাক্ত এবং ট্র্যাক করতে ভিডিও ইন্টেলিজেন্স 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)
আপনি যদি সংশ্লিষ্ট ফ্রেমের উপরে বাউন্ডিং বাক্সগুলি আঁকেন, তাহলে আপনি এটি পাবেন:
সারাংশ
এই ধাপে, আপনি ভিডিও ইন্টেলিজেন্স API ব্যবহার করে একটি ভিডিওতে অবজেক্ট ডিটেকশন এবং ট্র্যাকিং করতে সক্ষম হয়েছেন। আপনি বস্তু সনাক্তকরণ এবং ট্র্যাকিং সম্পর্কে আরও পড়তে পারেন।
11. লোগো সনাক্ত করুন এবং ট্র্যাক করুন
আপনি একটি ভিডিওতে লোগো সনাক্ত করতে এবং ট্র্যাক করতে ভিডিও ইন্টেলিজেন্স API ব্যবহার করতে পারেন৷ 100,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 Map লোগো সত্তা আইডি সহ ফাংশনটি কল করুন:
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)
আপনি যদি সংশ্লিষ্ট ফ্রেমের উপরে বাউন্ডিং বাক্সগুলি আঁকেন, তাহলে আপনি এটি পাবেন:
সারাংশ
এই ধাপে, আপনি ভিডিও ইন্টেলিজেন্স 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. অভিনন্দন!
আপনি পাইথন ব্যবহার করে ভিডিও ইন্টেলিজেন্স API ব্যবহার করতে শিখেছেন!
পরিষ্কার করুন
ক্লাউড শেল থেকে আপনার উন্নয়ন পরিবেশ পরিষ্কার করতে:
- আপনি যদি এখনও আপনার IPython সেশনে থাকেন, তাহলে শেল এ ফিরে যান:
exit - পাইথন ভার্চুয়াল পরিবেশ ব্যবহার বন্ধ করুন:
deactivate - আপনার ভার্চুয়াল পরিবেশ ফোল্ডার মুছুন:
cd ~ ; rm -rf ./venv-videointel
ক্লাউড শেল থেকে আপনার Google ক্লাউড প্রকল্প মুছে ফেলতে:
- আপনার বর্তমান প্রকল্প আইডি পুনরুদ্ধার করুন:
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
- Google ক্লাউডে পাইথন: https://cloud.google.com/python
- পাইথনের জন্য ক্লাউড ক্লায়েন্ট লাইব্রেরি: https://github.com/googleapis/google-cloud-python
লাইসেন্স
এই কাজটি ক্রিয়েটিভ কমন্স অ্যাট্রিবিউশন 2.0 জেনেরিক লাইসেন্সের অধীনে লাইসেন্সপ্রাপ্ত।