1. Omówienie
Interfejs Video Intelligence API pozwala korzystać w aplikacjach z technologii analizy wideo Google.
W tym module dowiesz się, jak używać interfejsu Video Intelligence API w języku Python.
Czego się nauczysz
- Jak skonfigurować środowisko
- Jak skonfigurować Pythona
- Jak wykrywać zmiany ujęć
- Jak wykrywać etykiety
- Jak wykrywać treści dla dorosłych
- Jak tworzyć transkrypcję mowy
- Jak wykrywać i śledzić tekst
- Jak wykrywać i śledzić obiekty
- Jak wykrywać i śledzić logo
Czego potrzebujesz
Ankieta
Jak wykorzystasz ten samouczek?
Jak oceniasz swoje doświadczenia z językiem Python?
Jak oceniasz usługi Google Cloud?
2. Konfiguracja i wymagania
Samodzielne konfigurowanie środowiska
- Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub wykorzystaj już istniejący. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.
- Nazwa projektu jest wyświetlaną nazwą uczestników tego projektu. To ciąg znaków, który nie jest używany przez interfejsy API Google. W każdej chwili możesz ją zaktualizować.
- Identyfikator projektu jest unikalny we wszystkich projektach Google Cloud i nie można go zmienić (po jego ustawieniu nie można go zmienić). Cloud Console automatycznie wygeneruje unikalny ciąg znaków. zwykle nieważne, co ona jest. W większości ćwiczeń w Codelabs musisz podać swój identyfikator projektu (zwykle identyfikowany jako
PROJECT_ID). Jeśli nie podoba Ci się wygenerowany identyfikator, możesz wygenerować kolejny losowy. Możesz też spróbować własnych sił i sprawdzić, czy jest dostępna. Po wykonaniu tej czynności nie można jej już zmienić. Pozostanie ona przez cały czas trwania projektu. - Jest jeszcze trzecia wartość, numer projektu, z którego korzystają niektóre interfejsy API. Więcej informacji o wszystkich 3 wartościach znajdziesz w dokumentacji.
- Następnie musisz włączyć płatności w Cloud Console, aby korzystać z zasobów Cloud/interfejsów API. Ukończenie tego ćwiczenia z programowania nic nie kosztuje. Aby wyłączyć zasoby w celu uniknięcia naliczania opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub projekt. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego o wartości 300 USD.
Uruchamianie Cloud Shell
Google Cloud można obsługiwać zdalnie z laptopa, ale w ramach tego ćwiczenia z programowania wykorzystasz Cloud Shell – środowisko wiersza poleceń działające w Cloud.
Aktywowanie Cloud Shell
- W konsoli Cloud kliknij Aktywuj Cloud Shell
.
Jeśli uruchamiasz Cloud Shell po raz pierwszy, zobaczysz ekran pośredni z opisem tej usługi. Jeśli wyświetlił się ekran pośredni, kliknij Dalej.
Uzyskanie dostępu do Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna ma wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelnianie. Większość zadań w ramach tego ćwiczenia z programowania można wykonać w przeglądarce.
Po nawiązaniu połączenia z Cloud Shell powinno pojawić się potwierdzenie, że użytkownik jest uwierzytelniony, a projekt jest ustawiony na identyfikator Twojego projektu.
- Uruchom to polecenie w Cloud Shell, aby potwierdzić, że jesteś uwierzytelniony:
gcloud auth list
Dane wyjściowe polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Uruchom to polecenie w Cloud Shell, aby sprawdzić, czy polecenie gcloud zna Twój projekt:
gcloud config list project
Dane wyjściowe polecenia
[core] project = <PROJECT_ID>
Jeśli tak nie jest, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Dane wyjściowe polecenia
Updated property [core/project].
3. Konfiguracja środowiska
Zanim zaczniesz korzystać z interfejsu Video Intelligence API, uruchom w Cloud Shell to polecenie, aby go włączyć:
gcloud services enable videointelligence.googleapis.com
Powinien pojawić się ekran podobny do tego:
Operation "operations/..." finished successfully.
Teraz możesz używać interfejsu Video Intelligence API.
Przejdź do katalogu głównego:
cd ~
Utwórz środowisko wirtualne Pythona, aby wyizolować zależności:
virtualenv venv-videointel
Aktywuj środowisko wirtualne:
source venv-videointel/bin/activate
Zainstaluj program IPython i bibliotekę klienta Video Intelligence API:
pip install ipython google-cloud-videointelligence
Powinien pojawić się ekran podobny do tego:
... Installing collected packages: ..., ipython, google-cloud-videointelligence Successfully installed ... google-cloud-videointelligence-2.11.0 ...
Teraz możesz już korzystać z biblioteki klienta interfejsu Video Intelligence API.
W następnych krokach użyjesz interaktywnego interpretera Pythona o nazwie IPython, który został zainstalowany w poprzednim kroku. Rozpocznij sesję od uruchomienia ipython w Cloud Shell:
ipython
Powinien pojawić się ekran podobny do tego:
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. Przykładowy film
Za pomocą interfejsu Video Intelligence API możesz dodawać adnotacje do filmów przechowywanych w Cloud Storage lub dostarczanych jako bajty danych.
W następnych krokach użyjesz przykładowego filmu zapisanego w Cloud Storage. Możesz obejrzeć film w przeglądarce.
Trzy, dwa, jeden, start!
5. Wykrywanie zmian ujęć
Do wykrywania zmian w ujęciach w filmie możesz używać interfejsu Video Intelligence API. Ujęcie to fragment filmu, seria klatek o ciągłości wizualnej.
Skopiuj ten kod do sesji 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
Poświęć chwilę na zapoznanie się z kodem i sprawdź, jak wykorzystuje on metodę biblioteki klienta annotate_video z parametrem SHOT_CHANGE_DETECTION do analizowania filmu i wykrywania zmian w ujęciach.
Wywołaj funkcję, aby przeanalizować film:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
results = detect_shot_changes(video_uri)
Poczekaj, aż film zostanie przetworzony:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Dodaj tę funkcję do drukowania ujęć wideo:
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}")
Wywołaj funkcję:
print_video_shots(results)
Powinien pojawić się ekran podobny do tego:
----------- 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
Wyodrębnij środkową klatkę każdego ujęcia i umieść je na ścianie składającej się z klatek, możesz wygenerować wizualne podsumowanie filmu:
Podsumowanie
W tym kroku udało Ci się wykryć zmianę ujęcia w filmie za pomocą interfejsu Video Intelligence API. Dowiedz się więcej o wykrywaniu zmian w ujęciu.
6. Wykrywanie etykiet
Do wykrywania etykiet w filmach możesz używać interfejsu Video Intelligence API. Etykiety opisują film na podstawie treści wizualnych.
Skopiuj ten kod do sesji 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
Poświęć chwilę na zapoznanie się z kodem i sprawdź, jak wykorzystuje on metodę biblioteki klienta annotate_video z parametrem LABEL_DETECTION do analizowania filmu i wykrywania etykiet.
Wywołaj funkcję, aby przeanalizować pierwsze 37 sekund filmu:
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])
Poczekaj, aż film zostanie przetworzony:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Dodaj tę funkcję, aby wydrukować etykiety na poziomie filmu:
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})"
Wywołaj funkcję:
print_video_labels(results)
Powinien pojawić się ekran podobny do tego:
------------------------------- 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)
Dzięki etykietom na poziomie filmu widać, że początek filmu dotyczy głównie przyrody i roślinności.
Dodaj tę funkcję, aby wydrukować etykiety na poziomie ujęcia:
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)
Wywołaj funkcję:
print_shot_labels(results)
Powinien pojawić się ekran podobny do tego:
------------------------------- 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 ...
Dzięki etykietom poziomu ujęć można zrozumieć, że film zaczyna się od ujęcia planety (prawdopodobnie Ziemi), a w ujęciu 34.760-36.960s widać motyla...
Podsumowanie
W tym kroku udało Ci się wykryć etykiety w filmach za pomocą interfejsu Video Intelligence API. Dowiedz się więcej o wykrywaniu etykiet.
7. Wykrywanie treści dla pełnoletnich
Do wykrywania treści dla pełnoletnich w filmach można używać interfejsu Video Intelligence API. Treści dla dorosłych to treści dla dorosłych, które są zasadniczo nieodpowiednie dla osób poniżej 18 roku życia. Obejmują m.in. nagość, czynności o charakterze seksualnym i pornografię. Wykrywanie jest wykonywane tylko na podstawie sygnałów wizualnych poszczególnych klatek (dźwięk nie jest używany). Odpowiedź zawiera wartości prawdopodobieństwa z zakresu od VERY_UNLIKELY do VERY_LIKELY.
Skopiuj ten kod do sesji 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
Poświęć chwilę na zapoznanie się z kodem i sprawdź, jak wykorzystuje on metodę biblioteki klienta annotate_video z parametrem EXPLICIT_CONTENT_DETECTION do analizowania filmów i wykrywania treści dla dorosłych.
Wywołaj funkcję, aby przeanalizować pierwsze 10 sekund filmu:
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])
Poczekaj, aż film zostanie przetworzony:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Dodaj tę funkcję, aby wydrukować różne liczby prawdopodobieństwa:
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}")
Wywołaj funkcję:
print_explicit_content(results)
Powinien pojawić się ekran podobny do tego:
----- Explicit content frames: 10 ------ LIKELIHOOD_UNSPECIFIED: 0 VERY_UNLIKELY : 10 UNLIKELY : 0 POSSIBLE : 0 LIKELY : 0 VERY_LIKELY : 0
Dodaj tę funkcję, aby wyświetlać szczegóły ramki:
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)
Wywołaj funkcję:
print_frames(results, vi.Likelihood.VERY_UNLIKELY)
Powinien pojawić się ekran podobny do tego:
------- 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
Podsumowanie
W tym kroku udało Ci się wykryć treści dla dorosłych w filmach za pomocą interfejsu Video Intelligence API. Dowiedz się więcej o wykrywaniu treści dla dorosłych.
8. Transkrybuj mowę
Interfejs Video Intelligence API umożliwia przekształcanie mowy w filmach w tekst za pomocą interfejsu Video Intelligence API.
Skopiuj ten kod do sesji 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
Poświęć chwilę na zapoznanie się z kodem i zobacz, jak wykorzystuje metodę biblioteki klienta annotate_video z parametrem SPEECH_TRANSCRIPTION do analizowania wideo i transkrybowania mowy.
Wywołaj funkcję, aby przeanalizować film od 55 do 80 sekund:
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])
Poczekaj, aż film zostanie przetworzony:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Dodaj tę funkcję, aby drukować transkrypcję mowy:
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()}")
Wywołaj funkcję:
print_video_speech(results)
Powinien pojawić się ekran podobny do tego:
--------------------------- 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.
Dodaj tę funkcję, aby wyświetlić listę wykrytych słów wraz z sygnaturami czasowymi:
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}")
Wywołaj funkcję:
print_word_timestamps(results)
Powinien pojawić się ekran podobny do tego:
------------------------------- 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.
Podsumowanie
W tym kroku udało Ci się utworzyć transkrypcję mowy do filmu za pomocą interfejsu Video Intelligence API. Dowiedz się więcej o transkrypcji dźwięku.
9. Wykrywaj i śledź tekst
Do wykrywania i śledzenia tekstu w filmie można używać interfejsu Video Intelligence API.
Skopiuj ten kod do sesji 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
Poświęć chwilę na zapoznanie się z kodem i zobacz, jak wykorzystuje metodę biblioteki klienta annotate_video z parametrem TEXT_DETECTION do analizowania filmu i wykrywania tekstu.
Wywołaj funkcję, aby przeanalizować film od 13 do 27 sekund:
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])
Poczekaj, aż film zostanie przetworzony:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Dodaj tę funkcję, aby wydrukować wykryty tekst:
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
Wywołaj funkcję:
print_video_text(results)
Powinien pojawić się ekran podobny do tego:
-------------------------------- 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.
Dodaj tę funkcję, aby wyświetlić listę wykrytych klatek tekstowych i ramek ograniczających:
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=" | ",
)
Wywołaj tę funkcję, aby sprawdzić, które ramki zawierają imię i nazwisko lektora:
contained_text = "Goodall"
print_text_frames(results, contained_text)
Powinien pojawić się ekran podobny do tego:
--------------------------------- 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)
Jeśli narysujesz ramki ograniczające na odpowiednich ramkach, otrzymasz następujący efekt:
Podsumowanie
Dzięki temu mogliśmy wykryć i śledzić tekst w filmie za pomocą interfejsu Video Intelligence API. Dowiedz się więcej o wykrywaniu i śledzeniu tekstu.
10. Wykrywaj i śledź obiekty
Do wykrywania i śledzenia obiektów w filmie można używać interfejsu Video Intelligence API.
Skopiuj ten kod do sesji 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
Poświęć chwilę na zapoznanie się z kodem i sprawdź, jak wykorzystuje on metodę biblioteki klienta annotate_video z parametrem OBJECT_TRACKING do analizowania filmów i wykrywania obiektów.
Wywołaj funkcję, aby przeanalizować film od sekund 98. do 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])
Poczekaj, aż film zostanie przetworzony:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Dodaj tę funkcję, aby wyświetlić listę wykrytych obiektów:
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=" | ",
)
Wywołaj funkcję:
print_detected_objects(results)
Powinien pojawić się ekran podobny do tego:
------------------- 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.
Dodaj tę funkcję, aby wyświetlić listę wykrytych ramek obiektu i ramek ograniczających:
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=" | ",
)
W przypadku owadów wywołaj funkcję z identyfikatorem jednostki:
insect_entity_id = "/m/03vt0"
print_object_frames(results, insect_entity_id)
Powinien pojawić się ekran podobny do tego:
--------------------- 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)
Jeśli narysujesz ramki ograniczające na odpowiednich ramkach, otrzymasz następujący efekt:
Podsumowanie
Udało Ci się też wykryć i śledzić obiekty na filmie za pomocą interfejsu Video Intelligence API. Dowiedz się więcej o wykrywaniu i śledzeniu obiektów.
11. Wykrywanie i śledzenie logo
Do wykrywania i śledzenia logo w filmach możesz używać interfejsu Video Intelligence API. Udało się wykryć ponad 100 000 marek i logo.
Skopiuj ten kod do sesji 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
Poświęć chwilę na zapoznanie się z kodem i zobacz, jak wykorzystuje metodę biblioteki klienta annotate_video z parametrem LOGO_RECOGNITION do analizowania filmów i wykrywania logo.
Wywołaj funkcję, aby przeanalizować przedostatnią sekwencję filmu:
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])
Poczekaj, aż film zostanie przetworzony:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Dodaj tę funkcję, aby wyświetlić listę wykrytych logo:
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=" | ",
)
Wywołaj funkcję:
print_detected_logos(results)
Powinien pojawić się ekran podobny do tego:
------------------------------ Detected logos: 1 ------------------------------- 92% | 150.680 | 155.720 | 43 fr. | /m/055t58 | Google Maps
Dodaj tę funkcję, aby wyświetlić listę wykrytych ramek logo i ramek ograniczających:
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=" | ",
)
Wywołaj funkcję z identyfikatorem jednostki logo Map Google:
maps_entity_id = "/m/055t58"
print_logo_frames(results, maps_entity_id)
Powinien pojawić się ekran podobny do tego:
------------------- 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)
Jeśli narysujesz ramki ograniczające na odpowiednich ramkach, otrzymasz następujący efekt:
Podsumowanie
Dzięki temu mogliśmy wykryć i śledzić logo w filmie za pomocą interfejsu Video Intelligence API. Dowiedz się więcej o wykrywaniu i śledzeniu logo.
12. Wykrywaj wiele obiektów
Możesz poprosić o zbieranie wszystkich statystyk jednocześnie:
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. Gratulacje!
Wiesz już, jak korzystać z interfejsu Video Intelligence API w języku Python.
Czyszczenie danych
Aby wyczyścić środowisko programistyczne, wykonaj te czynności w Cloud Shell:
- Jeśli nadal jesteś w sesji IPython, wróć do powłoki:
exit - Przestań używać środowiska wirtualnego Pythona:
deactivate - Usuń folder środowiska wirtualnego:
cd ~ ; rm -rf ./venv-videointel
Aby usunąć projekt Google Cloud z Cloud Shell:
- Pobierz bieżący identyfikator projektu:
PROJECT_ID=$(gcloud config get-value core/project) - Sprawdź, czy to jest projekt, który chcesz usunąć:
echo $PROJECT_ID - Usuń projekt:
gcloud projects delete $PROJECT_ID
Więcej informacji
- Przetestuj wersję demonstracyjną w przeglądarce: https://zackakil.github.io/video-intelligence-api-visualiser
- Dokumentacja Video Intelligence: https://cloud.google.com/video-intelligence/docs
- Funkcje w wersji beta: https://cloud.google.com/video-intelligence/docs/beta
- Python w Google Cloud: https://cloud.google.com/python
- Biblioteki klienta Cloud dla Pythona: https://github.com/googleapis/google-cloud-python
Licencja
To zadanie jest licencjonowane na podstawie ogólnej licencji Creative Commons Attribution 2.0.