1. Übersicht
Mit der Video Intelligence API können Sie die Videoanalysetechnologie von Google als Teil Ihrer Anwendungen nutzen.
In diesem Lab konzentrieren Sie sich auf die Verwendung der Video Intelligence API mit Python.
Aufgaben in diesem Lab
- Umgebung einrichten
- Python einrichten
- Szenenwechsel erkennen
- Labels erkennen
- So erkennen Sie anstößige Inhalte
- Gesprochenes transkribieren
- Text erkennen und verfolgen
- Objekte erkennen und verfolgen
- Logos erkennen und nachverfolgen
Voraussetzungen
- Ein Google Cloud-Projekt
- Ein Browser wie Chrome oder Firefox
- Vertrautheit bei der Verwendung von Python
Umfrage
Wie möchten Sie diese Anleitung nutzen?
<ph type="x-smartling-placeholder">Wie würden Sie Ihre Erfahrung mit Python bewerten?
<ph type="x-smartling-placeholder">Wie würden Sie Ihre Erfahrung mit Google Cloud-Diensten bewerten?
<ph type="x-smartling-placeholder">2. Einrichtung und Anforderungen
Umgebung für das selbstbestimmte Lernen einrichten
- Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.
- Der Projektname ist der Anzeigename für die Projektteilnehmer. Es handelt sich um eine Zeichenfolge, die von Google APIs nicht verwendet wird. Sie können sie jederzeit aktualisieren.
- Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich. Sie kann nach dem Festlegen nicht mehr geändert werden. Die Cloud Console generiert automatisch einen eindeutigen String. ist Ihnen meist egal, was es ist. In den meisten Codelabs musst du auf deine Projekt-ID verweisen, die üblicherweise als
PROJECT_IDbezeichnet wird. Wenn Ihnen die generierte ID nicht gefällt, können Sie eine weitere zufällige ID generieren. Alternativ können Sie einen eigenen verwenden und nachsehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts erhalten. - Zur Information gibt es noch einen dritten Wert, die Projektnummer, die von manchen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.
- Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/APIs verwenden zu können. Dieses Codelab ist kostengünstig. Sie können die von Ihnen erstellten Ressourcen oder das Projekt löschen, um Ressourcen herunterzufahren, um zu vermeiden, dass über diese Anleitung hinaus Kosten anfallen. Neue Google Cloud-Nutzer haben Anspruch auf das kostenlose Testprogramm mit 300$Guthaben.
Cloud Shell starten
Sie können Google Cloud zwar von Ihrem Laptop aus der Ferne bedienen, in diesem Codelab verwenden Sie jedoch Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.
Cloud Shell aktivieren
- Klicken Sie in der Cloud Console auf Cloud Shell aktivieren
.
Wenn Sie Cloud Shell zum ersten Mal starten, wird ein Zwischenbildschirm mit einer Beschreibung der Funktion angezeigt. Wenn ein Zwischenbildschirm angezeigt wird, klicken Sie auf Weiter.
Die Bereitstellung und Verbindung mit Cloud Shell dauert nur einen Moment.
Diese virtuelle Maschine verfügt über alle erforderlichen Entwicklertools. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt. Dadurch werden die Netzwerkleistung und die Authentifizierung erheblich verbessert. Viele, wenn nicht sogar alle Arbeiten in diesem Codelab können mit einem Browser erledigt werden.
Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie authentifiziert sind und das Projekt auf Ihre Projekt-ID eingestellt ist.
- Führen Sie in 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 in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob 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, führen Sie den folgenden Befehl in Cloud Shell aus, um die API zu aktivieren:
gcloud services enable videointelligence.googleapis.com
Auf dem Bildschirm sollte Folgendes zu sehen sein:
Operation "operations/..." finished successfully.
Jetzt können Sie 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 Clientbibliothek der Video Intelligence API 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
Sie können die Video Intelligence API verwenden, um in Cloud Storage gespeicherte oder als Datenbyte bereitgestellte Videos mit Anmerkungen zu versehen.
In den nächsten Schritten verwenden Sie ein in Cloud Storage gespeichertes Beispielvideo. Du kannst das Video in deinem Browser ansehen.
Auf die Plätze, fertig, los!
5. Szenenwechsel erkennen
Sie können die Video Intelligence API verwenden, um Szenenwechsel in einem Video zu erkennen. Eine Einstellung ist ein Ausschnitt des Videos, eine Folge 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
Nehmen Sie sich einen Moment Zeit, um sich den Code anzusehen und zu sehen, wie er die Clientbibliotheksmethode annotate_video mit dem Parameter SHOT_CHANGE_DETECTION verwendet, 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 Videoaufnahmen auszudrucken:
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}")
Rufen Sie die folgende Funktion auf:
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 konnten Sie mithilfe der Video Intelligence API Szenenwechsel in einem Video erkennen. Weitere Informationen zum Erkennen von Szenenwechseln
6. Labels erkennen
Sie können die Video Intelligence API verwenden, um Labels in einem Video zu erkennen. Labels beschreiben das Video basierend auf seinem visuellen Inhalt.
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
Nehmen Sie sich einen Moment Zeit, um sich den Code anzusehen und zu sehen, wie er die Methode annotate_video-Clientbibliothek mit dem Parameter LABEL_DETECTION verwendet, 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 Beschriftungen auf Videoebene auszudrucken:
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})"
Rufen Sie die folgende Funktion auf:
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)
Dank dieser Labels auf Videoebene können Sie nachvollziehen, dass es am Anfang des Videos hauptsächlich um Natur und Vegetation geht.
Fügen Sie diese Funktion hinzu, um die Beschriftungen auf Aufnahmeebene auszudrucken:
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)
Rufen Sie die folgende Funktion auf:
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 Labels auf Einstellungsebene können Sie erkennen, dass das Video mit einer Aufnahme eines Planeten (wahrscheinlich die Erde) beginnt, dass in der Aufnahme 34.760-36.960s ein Schmetterling zu sehen ist...
Zusammenfassung
In diesem Schritt konnten Sie mithilfe der Video Intelligence API eine Labelerkennung für ein Video durchführen. 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 nicht für Personen unter 18 Jahren geeignet sind. Dazu zählen unter anderem Nacktheit, sexuelle Aktivitäten und Pornografie. Die Erkennung erfolgt ausschließlich auf Grundlage der visuellen Signale pro Frame (kein Ton). Die Antwort enthält Wahrscheinlichkeitswerte zwischen VERY_UNLIKELY und 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
Nehmen Sie sich einen Moment Zeit, um sich den Code anzusehen und zu sehen, wie er die Clientbibliotheksmethode annotate_video mit dem Parameter EXPLICIT_CONTENT_DETECTION verwendet, um ein Video zu analysieren und anstößige 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 unterschiedlichen Wahrscheinlichkeitszahlen 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}")
Rufen Sie die folgende Funktion auf:
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 Frame-Details auszudrucken:
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)
Rufen Sie die folgende Funktion auf:
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 konnten Sie mithilfe der Video Intelligence API explizite Inhalte in einem Video erkennen. Weitere Informationen zum Erkennen anstößiger Inhalte
8. Sprache transkribieren
Mit der Video Intelligence API können Sie Videosprache 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
Nehmen Sie sich einen Moment Zeit, um sich den Code anzusehen und zu sehen, wie er die Clientbibliotheksmethode annotate_video mit dem Parameter SPEECH_TRANSCRIPTION verwendet, um ein Video zu analysieren und Sprache zu transkribieren.
Rufen Sie die Funktion auf, um das Video von den Sekunden 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 die transkribierte Sprache auszudrucken:
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()}")
Rufen Sie die folgende Funktion auf:
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 ihrer Zeitstempel auszudrucken:
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}")
Rufen Sie die folgende Funktion auf:
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 konnten Sie mithilfe der Video Intelligence API Sprachtranskriptionen für ein Video ausführen. Weitere Informationen zum Transkribieren von Audio
9. Text erkennen und verfolgen
Sie können die Video Intelligence API verwenden, um Text in einem Video zu erkennen und zu 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
Nehmen Sie sich einen Moment Zeit, um sich den Code anzusehen und zu sehen, wie er die Clientbibliotheksmethode annotate_video mit dem Parameter TEXT_DETECTION verwendet, um ein Video zu analysieren und Text zu erkennen.
Rufen Sie die Funktion auf, um das Video von den Sekunden 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 erkannten Text auszudrucken:
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
Rufen Sie die folgende Funktion auf:
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 Textframes und Begrenzungsrahmen auszudrucken:
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 Sprechers 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 konnten Sie mithilfe der Video Intelligence API eine Texterkennung und ein Tracking für ein Video durchführen. Weitere Informationen zum Erkennen und Verfolgen von Text
10. Objekte erkennen und verfolgen
Sie können die Video Intelligence API verwenden, um Objekte in einem Video zu erkennen und zu 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
Nehmen Sie sich einen Moment Zeit, um sich den Code anzusehen und zu sehen, wie er die Clientbibliotheksmethode annotate_video mit dem Parameter OBJECT_TRACKING verwendet, um ein Video zu analysieren und Objekte zu erkennen.
Rufen Sie die Funktion auf, um das Video von den Sekunden 98 bis 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=" | ",
)
Rufen Sie die folgende Funktion auf:
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 Objektframes und Begrenzungsrahmen auszudrucken:
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 konnten Sie mithilfe der Video Intelligence API eine Objekterkennung und ein Objekt-Tracking an einem Video durchführen. Weitere Informationen zum Erkennen und Tracking von Objekten
11. Logos erkennen und verfolgen
Sie können die Video Intelligence API verwenden, um Logos in einem Video zu erkennen und zu beobachten. 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
Nehmen Sie sich einen Moment Zeit, um sich den Code anzusehen und zu sehen, wie er die Clientbibliotheksmethode annotate_video mit dem Parameter LOGO_RECOGNITION verwendet, 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 auszudrucken:
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=" | ",
)
Rufen Sie die folgende Funktion auf:
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 Logoframes und Begrenzungsrahmen auszudrucken:
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 Entitäts-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 konnten Sie mithilfe der Video Intelligence API eine Logoerkennung und ein Tracking für ein Video durchführen. Weitere Informationen zum Erkennen und Verfolgen von Logos
12. Mehrere Funktionen erkennen
Mit den folgenden Anfragen erhalten Sie alle Informationen auf einmal:
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 die Entwicklungsumgebung in Cloud Shell:
- Wenn Sie sich noch in Ihrer IPython-Sitzung befinden, gehen Sie zurück zur Shell:
exit - Verwendung der virtuellen Python-Umgebung beenden:
deactivate - Löschen Sie den Ordner der virtuellen Umgebung:
cd ~ ; rm -rf ./venv-videointel
So löschen Sie Ihr Google Cloud-Projekt in Cloud Shell:
- Rufen Sie Ihre aktuelle Projekt-ID ab:
PROJECT_ID=$(gcloud config get-value core/project) - Achten Sie darauf, dass 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.