1. Genel Bakış
Video Intelligence API, uygulamalarınızda Google video analiz teknolojisini kullanmanıza olanak tanır.
Bu laboratuvarda, Video Intelligence API'yi Python ile kullanmaya odaklanacaksınız.
Neler öğreneceksiniz?
- Ortamınızı ayarlama
- Python'ı ayarlama
- Çekim değişiklikleri nasıl algılanır?
- Etiketleri algılama
- Uygunsuz içerikleri algılama
- Konuşmayı metne dönüştürme
- Metin algılama ve izleme
- Nesneleri algılama ve izleme
- Logoları algılama ve izleme
Gerekenler
- Google Cloud projesi
- Chrome veya Firefox gibi bir tarayıcı
- Python kullanma konusunda bilgi sahibi olma
Anket
Bu eğitimi nasıl kullanacaksınız?
Python ile ilgili deneyiminizi nasıl değerlendirirsiniz?
Google Cloud hizmetleriyle ilgili deneyiminizi nasıl değerlendirirsiniz?
2. Kurulum ve şartlar
Yönlendirmesiz ortam kurulumu
- Google Cloud Console'da oturum açın ve yeni bir proje oluşturun veya mevcut bir projeyi yeniden kullanın. Gmail veya Google Workspace hesabınız yoksa hesap oluşturmanız gerekir.
- Proje adı, bu projenin katılımcıları için görünen addır. Google API'leri tarafından kullanılmayan bir karakter dizesidir. Bu bilgiyi istediğiniz zaman güncelleyebilirsiniz.
- Proje kimliği, tüm Google Cloud projelerinde benzersizdir ve sabittir (ayarlandıktan sonra değiştirilemez). Cloud Console, benzersiz bir dizeyi otomatik olarak oluşturur. Genellikle bu dizenin ne olduğuyla ilgilenmezsiniz. Çoğu codelab'de proje kimliğinize (genellikle
PROJECT_IDolarak tanımlanır) başvurmanız gerekir. Oluşturulan kimliği beğenmezseniz başka bir rastgele kimlik oluşturabilirsiniz. Dilerseniz kendi adınızı deneyerek kullanılabilir olup olmadığını kontrol edebilirsiniz. Bu adım tamamlandıktan sonra değiştirilemez ve proje süresince geçerli kalır. - Bazı API'lerin kullandığı üçüncü bir değer olan Proje Numarası da vardır. Bu üç değer hakkında daha fazla bilgiyi belgelerde bulabilirsiniz.
- Ardından, Cloud kaynaklarını/API'lerini kullanmak için Cloud Console'da faturalandırmayı etkinleştirmeniz gerekir. Bu codelab'i tamamlamak neredeyse hiç maliyetli değildir. Bu eğitimin ötesinde faturalandırılmayı önlemek için kaynakları kapatmak üzere oluşturduğunuz kaynakları veya projeyi silebilirsiniz. Yeni Google Cloud kullanıcıları 300 ABD doları değerinde ücretsiz deneme programından yararlanabilir.
Cloud Shell'i başlatma
Google Cloud, dizüstü bilgisayarınızdan uzaktan çalıştırılabilir ancak bu codelab'de bulutta çalışan bir komut satırı ortamı olan Cloud Shell'i kullanacaksınız.
Cloud Shell'i etkinleştirme
- Cloud Console'da Cloud Shell'i etkinleştir 'i
tıklayın.
Cloud Shell'i ilk kez başlatıyorsanız ne olduğunu açıklayan bir ara ekran gösterilir. Ara ekran gösterildiyse Devam'ı tıklayın.
Cloud Shell'in temel hazırlığı ve bağlanması yalnızca birkaç dakikanızı alır.
Bu sanal makineye, ihtiyaç duyacağınız tüm geliştirme araçları yüklenmiştir. 5 GB boyutunda kalıcı bir ana dizin bulunur ve Google Cloud'da çalışır. Bu sayede ağ performansı ve kimlik doğrulama önemli ölçüde güçlenir. Bu codelab'deki çalışmalarınızın neredeyse tamamını tarayıcıyla yapabilirsiniz.
Cloud Shell'e bağlandıktan sonra kimliğinizin doğrulandığını ve projenin, proje kimliğinize ayarlandığını görürsünüz.
- Kimliğinizin doğrulandığını onaylamak için Cloud Shell'de şu komutu çalıştırın:
gcloud auth list
Komut çıkışı
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- gcloud komutunun projeniz hakkında bilgi sahibi olduğunu onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:
gcloud config list project
Komut çıkışı
[core] project = <PROJECT_ID>
Değilse şu komutla ayarlayabilirsiniz:
gcloud config set project <PROJECT_ID>
Komut çıkışı
Updated property [core/project].
3. Ortam kurulumu
Video Intelligence API'yi kullanmaya başlamadan önce API'yi etkinleştirmek için Cloud Shell'de aşağıdaki komutu çalıştırın:
gcloud services enable videointelligence.googleapis.com
Aşağıdakine benzer bir tablo görürsünüz:
Operation "operations/..." finished successfully.
Artık Video Intelligence API'yi kullanabilirsiniz.
Ana dizininize gidin:
cd ~
Bağımlılıkları izole etmek için Python sanal ortamı oluşturun:
virtualenv venv-videointel
Sanal ortamı etkinleştirin:
source venv-videointel/bin/activate
IPython'ı ve Video Intelligence API istemci kitaplığını yükleyin:
pip install ipython google-cloud-videointelligence
Aşağıdakine benzer bir tablo görürsünüz:
... Installing collected packages: ..., ipython, google-cloud-videointelligence Successfully installed ... google-cloud-videointelligence-2.11.0 ...
Artık Video Intelligence API istemci kitaplığını kullanmaya hazırsınız.
Sonraki adımlarda, önceki adımda yüklediğiniz IPython adlı etkileşimli bir Python yorumlayıcısı kullanacaksınız. Cloud Shell'de ipython komutunu çalıştırarak bir oturum başlatın:
ipython
Aşağıdakine benzer bir tablo görürsünüz:
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. Örnek video
Cloud Storage'da depolanan veya veri baytları olarak sağlanan videolara açıklama eklemek için Video Intelligence API'yi kullanabilirsiniz.
Sonraki adımlarda, Cloud Storage'da depolanan örnek bir videoyu kullanacaksınız. Videoyu tarayıcınızda görüntüleyebilirsiniz.
Hazır, başla!
5. Çekim değişikliklerini algılama
Bir videodaki çekim değişikliklerini algılamak için Video Intelligence API'yi kullanabilirsiniz. Çekim, videonun bir bölümü, görsel sürekliliği olan bir dizi karedir.
Aşağıdaki kodu IPython oturumunuza kopyalayın:
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
Kodu inceleyerek bir videoyu analiz etmek ve çekim değişikliklerini algılamak için annotate_video istemci kitaplığı yönteminin SHOT_CHANGE_DETECTION parametresiyle nasıl kullanıldığını görün.
Videoyu analiz etmek için işlevi çağırın:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
results = detect_shot_changes(video_uri)
Videonun işlenmesini bekleyin:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Video çekimlerini yazdırmak için aşağıdaki işlevi ekleyin:
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}")
İşlevi çağırın:
print_video_shots(results)
Aşağıdakine benzer bir tablo görürsünüz:
----------- 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
Her çekimin orta karesini çıkarıp kare duvarı şeklinde düzenlerseniz videonun görsel özetini oluşturabilirsiniz:
Özet
Bu adımda, Video Intelligence API'yi kullanarak bir videoda çekim değişikliği algılama işlemi gerçekleştirdiniz. Çekim değişikliklerini algılama hakkında daha fazla bilgi edinebilirsiniz.
6. Etiketleri algılama
Bir videodaki etiketleri algılamak için Video Intelligence API'yi kullanabilirsiniz. Etiketler, görsel içeriğine göre videoyu tanımlar.
Aşağıdaki kodu IPython oturumunuza kopyalayın:
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
Kodu inceleyerek bir videoyu analiz etmek ve etiketleri algılamak için annotate_video istemci kitaplığı yönteminin LABEL_DETECTION parametresiyle nasıl kullanıldığını öğrenin.
Videonun ilk 37 saniyesini analiz etmek için işlevi çağırın:
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])
Videonun işlenmesini bekleyin:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Etiketleri video düzeyinde yazdırmak için aşağıdaki işlevi ekleyin:
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})"
İşlevi çağırın:
print_video_labels(results)
Aşağıdakine benzer bir tablo görürsünüz:
------------------------------- 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)
Bu video düzeyindeki etiketler sayesinde, videonun başlangıcının çoğunlukla doğa ve bitki örtüsüyle ilgili olduğunu anlayabilirsiniz.
Etiketleri çekim düzeyinde yazdırmak için aşağıdaki işlevi ekleyin:
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)
İşlevi çağırın:
print_shot_labels(results)
Aşağıdakine benzer bir tablo görürsünüz:
------------------------------- 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 ...
Bu çekim düzeyindeki etiketler sayesinde videonun bir gezegen (muhtemelen Dünya) çekimiyle başladığını, 34.760-36.960s çekiminde bir kelebek olduğunu,...
Özet
Bu adımda, Video Intelligence API'yi kullanarak bir videoda etiket algılama işlemi gerçekleştirdiniz. Etiketleri algılama hakkında daha fazla bilgi edinebilirsiniz.
7. Uygunsuz içerikleri tespit edin
Bir videodaki uygunsuz içeriği algılamak için Video Intelligence API'yi kullanabilirsiniz. Uygunsuz içerikler, genellikle 18 yaşından küçükler için uygun olmayan yetişkinlere yönelik içeriklerdir. Bu içerikler çıplaklık, cinsel aktiviteler ve pornografi gibi unsurları içerir ancak bunlarla sınırlı değildir. Algılama yalnızca kare başına görsel sinyallere göre yapılır (ses kullanılmaz). Yanıtta VERY_UNLIKELY ile VERY_LIKELY arasında değişen olasılık değerleri yer alıyor.
Aşağıdaki kodu IPython oturumunuza kopyalayın:
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
Kodu inceleyerek bir videoyu analiz etmek ve uygunsuz içerikleri tespit etmek için annotate_video istemci kitaplığı yönteminin EXPLICIT_CONTENT_DETECTION parametresiyle nasıl kullanıldığını öğrenin.
Videonun ilk 10 saniyesini analiz etmek için işlevi çağırın:
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])
Videonun işlenmesini bekleyin:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Farklı olasılık sayılarını yazdırmak için bu işlevi ekleyin:
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}")
İşlevi çağırın:
print_explicit_content(results)
Aşağıdakine benzer bir tablo görürsünüz:
----- Explicit content frames: 10 ------ LIKELIHOOD_UNSPECIFIED: 0 VERY_UNLIKELY : 10 UNLIKELY : 0 POSSIBLE : 0 LIKELY : 0 VERY_LIKELY : 0
Kare ayrıntılarını yazdırmak için şu işlevi ekleyin:
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)
İşlevi çağırın:
print_frames(results, vi.Likelihood.VERY_UNLIKELY)
Aşağıdakine benzer bir tablo görürsünüz:
------- 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
Özet
Bu adımda, Video Intelligence API'yi kullanarak bir videoda uygunsuz içerik algılama işlemi gerçekleştirdiniz. Uygunsuz içerikleri tespit etme hakkında daha fazla bilgi edinebilirsiniz.
8. Konuşmayı metne dönüştürme
Video Intelligence API'yi kullanarak videodaki konuşmaları metne dönüştürebilirsiniz.
Aşağıdaki kodu IPython oturumunuza kopyalayın:
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
Kodu inceleyerek videoyu analiz etmek ve konuşmayı yazıya dökmek için annotate_video istemci kitaplığı yönteminin SPEECH_TRANSCRIPTION parametresiyle nasıl kullanıldığını görün.
Videoyu 55. saniyeden 80. saniyeye kadar analiz etmek için işlevi çağırın:
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])
Videonun işlenmesini bekleyin:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Transkribe edilen konuşmayı yazdırmak için bu işlevi ekleyin:
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()}")
İşlevi çağırın:
print_video_speech(results)
Aşağıdakine benzer bir tablo görürsünüz:
--------------------------- 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.
Algılanan kelimelerin ve zaman damgalarının listesini yazdırmak için şu işlevi ekleyin:
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}")
İşlevi çağırın:
print_word_timestamps(results)
Aşağıdakine benzer bir tablo görürsünüz:
------------------------------- 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.
Özet
Bu adımda, Video Intelligence API'yi kullanarak bir videoda konuşma transkripsiyonu gerçekleştirdiniz. Sesi metne dönüştürme hakkında daha fazla bilgi edinebilirsiniz.
9. Metin algılama ve izleme
Bir videodaki metni algılamak ve izlemek için Video Intelligence API'yi kullanabilirsiniz.
Aşağıdaki kodu IPython oturumunuza kopyalayın:
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
Kodu inceleyerek bir videoyu analiz etmek ve metin algılamak için annotate_video istemci kitaplığı yönteminin TEXT_DETECTION parametresiyle nasıl kullanıldığını öğrenin.
Videoyu 13. saniyeden 27. saniyeye kadar analiz etmek için işlevi çağırın:
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])
Videonun işlenmesini bekleyin:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Algılanan metni yazdırmak için bu işlevi ekleyin:
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
İşlevi çağırın:
print_video_text(results)
Aşağıdakine benzer bir tablo görürsünüz:
-------------------------------- 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.
Algılanan metin çerçevelerinin ve sınırlayıcı kutuların listesini yazdırmak için şu işlevi ekleyin:
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=" | ",
)
Hangi karelerde anlatıcının adının gösterildiğini kontrol etmek için işlevi çağırın:
contained_text = "Goodall"
print_text_frames(results, contained_text)
Aşağıdakine benzer bir tablo görürsünüz:
--------------------------------- 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)
Sınırlayıcı kutuları ilgili çerçevelerin üzerine çizerseniz şu sonucu elde edersiniz:
Özet
Bu adımda, Video Intelligence API'yi kullanarak bir videoda metin algılama ve izleme işlemi gerçekleştirdiniz. Metin algılama ve izleme hakkında daha fazla bilgi edinebilirsiniz.
10. Nesneleri algılama ve izleme
Bir videodaki nesneleri algılamak ve izlemek için Video Intelligence API'yi kullanabilirsiniz.
Aşağıdaki kodu IPython oturumunuza kopyalayın:
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
Kodu inceleyerek bir videoyu analiz etmek ve nesneleri algılamak için annotate_video istemci kitaplığı yönteminin OBJECT_TRACKING parametresiyle nasıl kullanıldığını öğrenin.
Videoyu 98. saniyeden 112. saniyeye kadar analiz etmek için işlevi çağırın:
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])
Videonun işlenmesini bekleyin:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Algılanan nesnelerin listesini yazdırmak için şu işlevi ekleyin:
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=" | ",
)
İşlevi çağırın:
print_detected_objects(results)
Aşağıdakine benzer bir tablo görürsünüz:
------------------- 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.
Algılanan nesne çerçevelerinin ve sınırlayıcı kutuların listesini yazdırmak için şu işlevi ekleyin:
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=" | ",
)
İşlevi böceklerin varlık kimliğiyle çağırın:
insect_entity_id = "/m/03vt0"
print_object_frames(results, insect_entity_id)
Aşağıdakine benzer bir tablo görürsünüz:
--------------------- 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)
Sınırlayıcı kutuları ilgili çerçevelerin üzerine çizerseniz şu sonucu elde edersiniz:
Özet
Bu adımda, Video Intelligence API'yi kullanarak bir videoda nesne algılama ve izleme işlemleri gerçekleştirdiniz. Nesneleri algılama ve izleme hakkında daha fazla bilgi edinebilirsiniz.
11. Logoları algılama ve izleme
Bir videodaki logoları algılamak ve izlemek için Video Intelligence API'yi kullanabilirsiniz. 100.000'den fazla marka ve logo tespit edilebilir.
Aşağıdaki kodu IPython oturumunuza kopyalayın:
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
Kodu inceleyerek bir videoyu analiz etmek ve logoları algılamak için annotate_video parametresiyle LOGO_RECOGNITION istemci kitaplığı yönteminin nasıl kullanıldığını öğrenin.
Videonun sondan bir önceki dizisini analiz etmek için işlevi çağırın:
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])
Videonun işlenmesini bekleyin:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Algılanan logoların listesini yazdırmak için şu işlevi ekleyin:
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=" | ",
)
İşlevi çağırın:
print_detected_logos(results)
Aşağıdakine benzer bir tablo görürsünüz:
------------------------------ Detected logos: 1 ------------------------------- 92% | 150.680 | 155.720 | 43 fr. | /m/055t58 | Google Maps
Algılanan logo çerçevelerinin ve sınırlayıcı kutuların listesini yazdırmak için şu işlevi ekleyin:
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 Harita logosu varlık kimliğiyle işlevi çağırın:
maps_entity_id = "/m/055t58"
print_logo_frames(results, maps_entity_id)
Aşağıdakine benzer bir tablo görürsünüz:
------------------- 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)
Sınırlayıcı kutuları ilgili çerçevelerin üzerine çizerseniz şu sonucu elde edersiniz:
Özet
Bu adımda, Video Intelligence API'yi kullanarak bir videoda logo algılama ve izleme işlemi gerçekleştirdiniz. Logoları algılama ve izleme hakkında daha fazla bilgi edinebilirsiniz.
12. Birden fazla özelliği algılama
Tüm analizleri tek seferde almak için yapabileceğiniz istek türü aşağıda verilmiştir:
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. Tebrikler!
Python kullanarak Video Intelligence API'yi nasıl kullanacağınızı öğrendiniz.
Temizleme
Geliştirme ortamınızda yer açmak için Cloud Shell'de:
- IPython oturumunuz hâlâ açıksa kabuğa geri dönün:
exit - Python sanal ortamını kullanmayı durdurun:
deactivate - Sanal ortam klasörünüzü silin:
cd ~ ; rm -rf ./venv-videointel
Google Cloud projenizi silmek için Cloud Shell'de:
- Mevcut proje kimliğinizi alın:
PROJECT_ID=$(gcloud config get-value core/project) - Silmek istediğiniz projenin
echo $PROJECT_IDolduğundan emin olun. - Projeyi silme:
gcloud projects delete $PROJECT_ID
Daha fazla bilgi
- Tarayıcınızda demoyu test edin: https://zackakil.github.io/video-intelligence-api-visualiser
- Video Intelligence belgeleri: https://cloud.google.com/video-intelligence/docs
- Beta özellikleri: https://cloud.google.com/video-intelligence/docs/beta
- Google Cloud'da Python: https://cloud.google.com/python
- Python için Cloud İstemci Kitaplıkları: https://github.com/googleapis/google-cloud-python
Lisans
Bu çalışma, Creative Commons Attribution 2.0 Genel Amaçlı Lisans ile lisans altına alınmıştır.