1. Übersicht
Mit der Video Intelligence API können Sie die Videoanalysetechnologie von Google in Ihren Anwendungen nutzen.
In diesem Lab konzentrieren Sie sich auf die Verwendung der Video Intelligence API mit Python.
Lerninhalte
- Umgebung einrichten
- Python einrichten
- Szenenwechsel erkennen
- Labels erkennen
- Anstößige Inhalte erkennen
- Sprache transkribieren
- Text erkennen und verfolgen
- Objekte erkennen und verfolgen
- Logos erkennen und verfolgen
Voraussetzungen
Umfrage
Wie werden Sie diese Anleitung verwenden?
Wie würden Sie Ihre Erfahrung mit Python bewerten?
Wie würden Sie Ihre Erfahrungen mit Google Cloud-Diensten bewerten?
2. Einrichtung und Anforderungen
Umgebung zum selbstbestimmten Lernen einrichten
- Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.
- Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird. Sie können sie jederzeit aktualisieren.
- Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich (kann nach dem Festlegen nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser String aussieht. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (in der Regel als
PROJECT_IDangegeben). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige ID generieren. Alternativ können Sie es mit einem eigenen Namen versuchen und sehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen. - Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten
- Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs zu verwenden. Die Durchführung dieses Codelabs kostet wenig oder gar nichts. Wenn Sie Ressourcen herunterfahren möchten, um Kosten zu vermeiden, die über diese Anleitung hinausgehen, können Sie die erstellten Ressourcen oder das Projekt löschen. Neue Google Cloud-Nutzer können am kostenlosen Testzeitraum mit einem Guthaben von 300$ teilnehmen.
Cloud Shell starten
Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.
Cloud Shell aktivieren
- Klicken Sie in der Cloud Console auf Cloud Shell aktivieren
.
Wenn Sie die Cloud Shell zum ersten Mal starten, wird ein Fenster mit einer Beschreibung eingeblendet. Klicken Sie in diesem Fall einfach auf Weiter.
Das Herstellen der Verbindung mit der Cloud Shell sollte nur wenige Augenblicke dauern.
Auf dieser virtuellen Maschine sind alle erforderlichen Entwicklungstools installiert. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Die meisten, wenn nicht sogar alle Aufgaben in diesem Codelab können mit einem Browser erledigt werden.
Sobald die Verbindung mit der Cloud Shell hergestellt ist, sehen Sie, dass Sie authentifiziert sind und für das Projekt Ihre Projekt-ID eingestellt ist.
- Führen Sie in der Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:
gcloud auth list
Befehlsausgabe
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Führen Sie den folgenden Befehl in Cloud Shell aus, um zu bestätigen, dass der gcloud-Befehl Ihr Projekt kennt:
gcloud config list project
Befehlsausgabe
[core] project = <PROJECT_ID>
Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:
gcloud config set project <PROJECT_ID>
Befehlsausgabe
Updated property [core/project].
3. Umgebung einrichten
Bevor Sie die Video Intelligence API verwenden können, müssen Sie sie aktivieren. Führen Sie dazu den folgenden Befehl in Cloud Shell aus:
gcloud services enable videointelligence.googleapis.com
Auf dem Bildschirm sollte Folgendes zu sehen sein:
Operation "operations/..." finished successfully.
Sie können jetzt die Video Intelligence API verwenden.
Wechseln Sie zu Ihrem Basisverzeichnis:
cd ~
Erstellen Sie eine virtuelle Python-Umgebung, um die Abhängigkeiten zu isolieren:
virtualenv venv-videointel
Aktivieren Sie die virtuelle Umgebung:
source venv-videointel/bin/activate
Installieren Sie IPython und die Video Intelligence API-Clientbibliothek:
pip install ipython google-cloud-videointelligence
Auf dem Bildschirm sollte Folgendes zu sehen sein:
... Installing collected packages: ..., ipython, google-cloud-videointelligence Successfully installed ... google-cloud-videointelligence-2.11.0 ...
Jetzt können Sie die Video Intelligence API-Clientbibliothek verwenden.
In den nächsten Schritten verwenden Sie einen interaktiven Python-Interpreter namens IPython, den Sie im vorherigen Schritt installiert haben. Starten Sie eine Sitzung, indem Sie ipython in Cloud Shell ausführen:
ipython
Auf dem Bildschirm sollte Folgendes zu sehen sein:
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. Beispielvideo
Mit der Video Intelligence API können Sie Videos mit Annotationen versehen, die in Cloud Storage gespeichert sind oder als Datenbytes bereitgestellt werden.
In den nächsten Schritten verwenden Sie ein Beispielvideo, das in Cloud Storage gespeichert ist. Video im Browser ansehen
Auf die Plätze, fertig, los!
5. Szenenwechsel erkennen
Mit der Video Intelligence API können Sie Szenenwechsel in einem Video erkennen. Eine Aufnahme ist ein Segment des Videos, eine Reihe von Frames mit visueller Kontinuität.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
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
Sehen Sie sich den Code an und achten Sie darauf, wie die annotate_video-Clientbibliotheksmethode mit dem SHOT_CHANGE_DETECTION-Parameter verwendet wird, um ein Video zu analysieren und Szenenwechsel zu erkennen.
Rufen Sie die Funktion auf, um das Video zu analysieren:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
results = detect_shot_changes(video_uri)
Warten Sie, bis das Video verarbeitet wurde:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Fügen Sie diese Funktion hinzu, um die Video-Shots auszugeben:
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}")
Funktion aufrufen:
print_video_shots(results)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
----------- 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
Wenn Sie den mittleren Frame jeder Aufnahme extrahieren und in einer Wand aus Frames anordnen, können Sie eine visuelle Zusammenfassung des Videos erstellen:
Zusammenfassung
In diesem Schritt haben Sie die Erkennung von Aufnahmeänderungen in einem Video mithilfe der Video Intelligence API durchgeführt. Weitere Informationen zum Erkennen von Szenenwechseln
6. Labels erkennen
Mit der Video Intelligence API können Sie Labels in einem Video erkennen. Labels beschreiben das Video anhand seiner visuellen Inhalte.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
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
Sehen Sie sich den Code an und achten Sie darauf, wie die annotate_video-Clientbibliotheksmethode mit dem LABEL_DETECTION-Parameter verwendet wird, um ein Video zu analysieren und Labels zu erkennen.
Rufen Sie die Funktion auf, um die ersten 37 Sekunden des Videos zu analysieren:
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])
Warten Sie, bis das Video verarbeitet wurde:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Fügen Sie diese Funktion hinzu, um die Labels auf Videoebene auszugeben:
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})"
Funktion aufrufen:
print_video_labels(results)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
------------------------------- 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)
Anhand dieser Labels auf Videoebene können Sie erkennen, dass es zu Beginn des Videos hauptsächlich um Natur und Vegetation geht.
Fügen Sie diese Funktion hinzu, um die Labels auf Aufnahmeebene auszugeben:
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)
Funktion aufrufen:
print_shot_labels(results)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
------------------------------- 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 ...
Dank dieser Shot-Labels können Sie nachvollziehen, dass das Video mit einer Aufnahme eines Planeten (wahrscheinlich der Erde) beginnt, dass in der 34.760-36.960s-Aufnahme ein Schmetterling zu sehen ist usw.
Zusammenfassung
In diesem Schritt haben Sie die Labelerkennung für ein Video mit der Video Intelligence API durchgeführt. Weitere Informationen zum Erkennen von Labels
7. Anstößige Inhalte erkennen
Mit der Video Intelligence API können Sie anstößige Inhalte in einem Video erkennen. Explizite Inhalte sind Inhalte nur für Erwachsene, die im Allgemeinen für Personen unter 18 Jahren ungeeignet sind, darunter die Darstellung von Nacktheit sowie sexuelle Aktivitäten und Pornografie. Die Erkennung erfolgt nur anhand visueller Signale pro Frame. Audio wird nicht verwendet. Die Antwort enthält Wahrscheinlichkeitswerte im Bereich von VERY_UNLIKELY bis VERY_LIKELY.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
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
Sehen Sie sich den Code an und achten Sie darauf, wie die annotate_video-Clientbibliothek mit dem Parameter EXPLICIT_CONTENT_DETECTION verwendet wird, um ein Video zu analysieren und explizite Inhalte zu erkennen.
Rufen Sie die Funktion auf, um die ersten 10 Sekunden des Videos zu analysieren:
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])
Warten Sie, bis das Video verarbeitet wurde:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Fügen Sie diese Funktion hinzu, um die verschiedenen Wahrscheinlichkeitszählungen auszugeben:
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}")
Funktion aufrufen:
print_explicit_content(results)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
----- Explicit content frames: 10 ------ LIKELIHOOD_UNSPECIFIED: 0 VERY_UNLIKELY : 10 UNLIKELY : 0 POSSIBLE : 0 LIKELY : 0 VERY_LIKELY : 0
Fügen Sie diese Funktion hinzu, um Framedetails auszugeben:
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)
Funktion aufrufen:
print_frames(results, vi.Likelihood.VERY_UNLIKELY)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
------- 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
Zusammenfassung
In diesem Schritt haben Sie mithilfe der Video Intelligence API anstößige Inhalte in einem Video erkannt. Weitere Informationen zum Erkennen expliziter Inhalte
8. Sprache transkribieren
Mit der Video Intelligence API können Sie Sprache in Videos in Text transkribieren.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
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
Sehen Sie sich den Code an und achten Sie darauf, wie die annotate_video-Clientbibliotheksmethode mit dem SPEECH_TRANSCRIPTION-Parameter verwendet wird, um ein Video zu analysieren und Sprache zu transkribieren.
Rufen Sie die Funktion auf, um das Video von Sekunde 55 bis 80 zu analysieren:
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])
Warten Sie, bis das Video verarbeitet wurde:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Fügen Sie diese Funktion hinzu, um transkribierte Sprache auszugeben:
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()}")
Funktion aufrufen:
print_video_speech(results)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
--------------------------- 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.
Fügen Sie diese Funktion hinzu, um die Liste der erkannten Wörter und deren Zeitstempel auszugeben:
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}")
Funktion aufrufen:
print_word_timestamps(results)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
------------------------------- 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.
Zusammenfassung
In diesem Schritt haben Sie die Sprache in einem Video mithilfe der Video Intelligence API transkribiert. Weitere Informationen zum Transkribieren von Audio
9. Text erkennen und verfolgen
Mit der Video Intelligence API können Sie Text in einem Video erkennen und verfolgen.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
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
Sehen Sie sich den Code an und achten Sie darauf, wie die annotate_video-Clientbibliothek mit dem Parameter TEXT_DETECTION verwendet wird, um ein Video zu analysieren und Text zu erkennen.
Rufen Sie die Funktion auf, um das Video von Sekunde 13 bis 27 zu analysieren:
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])
Warten Sie, bis das Video verarbeitet wurde:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Fügen Sie diese Funktion hinzu, um den erkannten Text auszugeben:
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
Funktion aufrufen:
print_video_text(results)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
-------------------------------- 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.
Fügen Sie diese Funktion hinzu, um die Liste der erkannten Textrahmen und Begrenzungsrahmen auszugeben:
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=" | ",
)
Rufen Sie die Funktion auf, um zu prüfen, in welchen Frames der Name des Erzählers angezeigt wird:
contained_text = "Goodall"
print_text_frames(results, contained_text)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
--------------------------------- 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)
Wenn Sie die Begrenzungsrahmen über die entsprechenden Frames zeichnen, erhalten Sie Folgendes:
Zusammenfassung
In diesem Schritt haben Sie die Texterkennung und ‑verfolgung in einem Video mithilfe der Video Intelligence API durchgeführt. Weitere Informationen zum Erkennen und Verfolgen von Text
10. Objekte erkennen und verfolgen
Mit der Video Intelligence API können Sie Objekte in einem Video erkennen und verfolgen.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
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
Sehen Sie sich den Code an und achten Sie darauf, wie die annotate_video-Clientbibliotheksmethode mit dem OBJECT_TRACKING-Parameter verwendet wird, um ein Video zu analysieren und Objekte zu erkennen.
Rufen Sie die Funktion auf, um das Video von Sekunde 98 bis Sekunde 112 zu analysieren:
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])
Warten Sie, bis das Video verarbeitet wurde:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Fügen Sie diese Funktion hinzu, um die Liste der erkannten Objekte auszugeben:
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=" | ",
)
Funktion aufrufen:
print_detected_objects(results)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
------------------- 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.
Fügen Sie diese Funktion hinzu, um die Liste der erkannten Objektrahmen und Begrenzungsrahmen auszugeben:
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=" | ",
)
Rufen Sie die Funktion mit der Entitäts-ID für Insekten auf:
insect_entity_id = "/m/03vt0"
print_object_frames(results, insect_entity_id)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
--------------------- 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)
Wenn Sie die Begrenzungsrahmen über die entsprechenden Frames zeichnen, erhalten Sie Folgendes:
Zusammenfassung
In diesem Schritt haben Sie die Objekterkennung und das Objekt-Tracking für ein Video mit der Video Intelligence API durchgeführt. Weitere Informationen zum Erkennen und Verfolgen von Objekten
11. Logos erkennen und verfolgen
Mit der Video Intelligence API können Sie Logos in einem Video erkennen und verfolgen. Es können über 100.000 Marken und Logos erkannt werden.
Kopieren Sie den folgenden Code in Ihre IPython-Sitzung:
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
Sehen Sie sich den Code an und achten Sie darauf, wie die annotate_video-Clientbibliotheksmethode mit dem LOGO_RECOGNITION-Parameter verwendet wird, um ein Video zu analysieren und Logos zu erkennen.
Rufen Sie die Funktion auf, um die vorletzte Sequenz des Videos zu analysieren:
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])
Warten Sie, bis das Video verarbeitet wurde:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Fügen Sie diese Funktion hinzu, um die Liste der erkannten Logos auszugeben:
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=" | ",
)
Funktion aufrufen:
print_detected_logos(results)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
------------------------------ Detected logos: 1 ------------------------------- 92% | 150.680 | 155.720 | 43 fr. | /m/055t58 | Google Maps
Fügen Sie diese Funktion hinzu, um die Liste der erkannten Logobilder und Begrenzungsrahmen auszugeben:
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=" | ",
)
Rufen Sie die Funktion mit der Entity-ID des Google Maps-Logos auf:
maps_entity_id = "/m/055t58"
print_logo_frames(results, maps_entity_id)
Auf dem Bildschirm sollte Folgendes zu sehen sein:
------------------- 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)
Wenn Sie die Begrenzungsrahmen über die entsprechenden Frames zeichnen, erhalten Sie Folgendes:
Zusammenfassung
In diesem Schritt haben Sie die Logoerkennung und ‑verfolgung in einem Video mithilfe der Video Intelligence API durchgeführt. Weitere Informationen zum Erkennen und Tracking von Logos
12. Mehrere Elemente erkennen
So können Sie alle Statistiken auf einmal abrufen:
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. Glückwunsch!
Sie haben gelernt, wie Sie die Video Intelligence API mit Python verwenden.
Bereinigen
So bereinigen Sie Ihre Entwicklungsumgebung über Cloud Shell:
- Wenn Sie sich noch in Ihrer IPython-Sitzung befinden, kehren Sie zur Shell zurück:
exit - Beenden Sie die Verwendung der virtuellen Python-Umgebung:
deactivate - Löschen Sie den Ordner für die virtuelle Umgebung:
cd ~ ; rm -rf ./venv-videointel
So löschen Sie Ihr Google Cloud-Projekt über Cloud Shell:
- Rufen Sie Ihre aktuelle Projekt-ID ab:
PROJECT_ID=$(gcloud config get-value core/project) - Prüfen Sie, ob dies das Projekt ist, das Sie löschen möchten:
echo $PROJECT_ID - Projekt löschen:
gcloud projects delete $PROJECT_ID
Weitere Informationen
- Testen Sie die Demo in Ihrem Browser: https://zackakil.github.io/video-intelligence-api-visualiser.
- Video Intelligence-Dokumentation: https://cloud.google.com/video-intelligence/docs
- Betafunktionen: https://cloud.google.com/video-intelligence/docs/beta
- Python in Google Cloud: https://cloud.google.com/python
- Cloud-Clientbibliotheken für Python: https://github.com/googleapis/google-cloud-python
Lizenz
Dieser Text ist mit einer Creative Commons Attribution 2.0 Generic License lizenziert.