1. Panoramica
L'API Video Intelligence ti consente di utilizzare la tecnologia di analisi video di Google nelle tue applicazioni.
In questo lab ti concentrerai sull'utilizzo dell'API Video Intelligence con Python.
Cosa imparerai a fare
- Come configurare l'ambiente
- Come configurare Python
- Come rilevare i cambi di inquadratura
- Come rilevare le etichette
- Come rilevare i contenuti espliciti
- Come trascrivere la voce
- Come rilevare e monitorare il testo
- Come rilevare e monitorare gli oggetti
- Come rilevare e monitorare i loghi
Che cosa ti serve
- Un progetto Google Cloud
- Un browser, ad esempio Chrome o Firefox
- Familiarità con l'utilizzo di Python
Sondaggio
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con Python?
Come valuteresti la tua esperienza con i servizi Google Cloud?
2. Configurazione e requisiti
Configurazione dell'ambiente autonomo
- Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.
- Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
- L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come
PROJECT_ID). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto. - Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.
Avvia Cloud Shell
Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.
Attiva Cloud Shell
- Nella console Cloud, fai clic su Attiva Cloud Shell
.
Se è la prima volta che avvii Cloud Shell, viene visualizzata una schermata intermedia che ne descrive le funzionalità. Se è stata visualizzata una schermata intermedia, fai clic su Continua.
Bastano pochi istanti per eseguire il provisioning e connettersi a Cloud Shell.
Questa macchina virtuale è caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Gran parte del lavoro per questo codelab, se non tutto, può essere svolto con un browser.
Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è autenticato e il progetto è impostato sul tuo ID progetto.
- Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:
gcloud auth list
Output comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Esegui questo comando in Cloud Shell per verificare che il comando gcloud conosca il tuo progetto:
gcloud config list project
Output comando
[core] project = <PROJECT_ID>
In caso contrario, puoi impostarlo con questo comando:
gcloud config set project <PROJECT_ID>
Output comando
Updated property [core/project].
3. Configurazione dell'ambiente
Prima di poter iniziare a utilizzare l'API Video Intelligence, esegui il seguente comando in Cloud Shell per abilitare l'API:
gcloud services enable videointelligence.googleapis.com
Il risultato dovrebbe essere simile a questo:
Operation "operations/..." finished successfully.
Ora puoi utilizzare l'API Video Intelligence.
Vai alla home directory:
cd ~
Crea un ambiente virtuale Python per isolare le dipendenze:
virtualenv venv-videointel
Attiva l'ambiente virtuale:
source venv-videointel/bin/activate
Installa IPython e la libreria client dell'API Video Intelligence:
pip install ipython google-cloud-videointelligence
Il risultato dovrebbe essere simile a questo:
... Installing collected packages: ..., ipython, google-cloud-videointelligence Successfully installed ... google-cloud-videointelligence-2.11.0 ...
Ora puoi utilizzare la libreria client dell'API Video Intelligence.
Nei passaggi successivi, utilizzerai un interprete Python interattivo chiamato IPython, che hai installato nel passaggio precedente. Avvia una sessione eseguendo ipython in Cloud Shell:
ipython
Il risultato dovrebbe essere simile a questo:
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. Video di esempio
Puoi utilizzare l'API Video Intelligence per annotare i video archiviati in Cloud Storage o forniti come byte di dati.
Nei passaggi successivi, utilizzerai un video di esempio archiviato in Cloud Storage. Puoi visualizzare il video nel browser.
Pronti, partenza, via!
5. Rilevamento dei cambi di inquadratura
Puoi utilizzare l'API Video Intelligence per rilevare i cambi di inquadratura in un video. Una ripresa è un segmento del video, una serie di frame con continuità visiva.
Copia il seguente codice nella sessione 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
Prenditi un momento per studiare il codice e vedere come utilizza il metodo della libreria client annotate_video con il parametro SHOT_CHANGE_DETECTION per analizzare un video e rilevare i cambi di inquadratura.
Chiama la funzione per analizzare il video:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
results = detect_shot_changes(video_uri)
Attendi che il video venga elaborato:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Aggiungi questa funzione per stampare le inquadrature del video:
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}")
Chiama la funzione:
print_video_shots(results)
Il risultato dovrebbe essere simile a questo:
----------- 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
Se estrai il fotogramma centrale di ogni inquadratura e li disponi in una griglia, puoi generare un riepilogo visivo del video:
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento del cambio di inquadratura su un video utilizzando l'API Video Intelligence. Scopri di più sul rilevamento dei cambi di inquadratura.
6. Rilevamento delle etichette
Puoi utilizzare l'API Video Intelligence per rilevare le etichette in un video. Le etichette descrivono il video in base ai suoi contenuti visivi.
Copia il seguente codice nella sessione 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
Prenditi un momento per studiare il codice e vedere come utilizza il metodo della libreria client annotate_video con il parametro LABEL_DETECTION per analizzare un video e rilevare le etichette.
Chiama la funzione per analizzare i primi 37 secondi del video:
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])
Attendi che il video venga elaborato:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Aggiungi questa funzione per stampare le etichette a livello di video:
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})"
Chiama la funzione:
print_video_labels(results)
Il risultato dovrebbe essere simile a questo:
------------------------------- 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)
Grazie a queste etichette a livello di video, puoi capire che l'inizio del video riguarda principalmente la natura e la vegetazione.
Aggiungi questa funzione per stampare le etichette a livello di scatto:
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)
Chiama la funzione:
print_shot_labels(results)
Il risultato dovrebbe essere simile a questo:
------------------------------- 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 ...
Grazie a queste etichette a livello di inquadratura, puoi capire che il video inizia con un'inquadratura di un pianeta (probabilmente la Terra), che c'è una farfalla nell'inquadratura 34.760-36.960s…
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento delle etichette su un video utilizzando l'API Video Intelligence. Scopri di più sul rilevamento delle etichette.
7. Rilevamento di contenuti espliciti
Puoi utilizzare l'API Video Intelligence per rilevare contenuti espliciti in un video. I contenuti espliciti sono contenuti per adulti generalmente inappropriati per i minori di 18 anni e includono, a titolo esemplificativo, nudità, attività sessuali e pornografia. Il rilevamento viene eseguito solo in base agli indicatori visivi per fotogramma (l'audio non viene utilizzato). La risposta include valori di probabilità compresi tra VERY_UNLIKELY e VERY_LIKELY.
Copia il seguente codice nella sessione 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
Prenditi un momento per studiare il codice e vedere come utilizza il metodo della libreria client annotate_video con il parametro EXPLICIT_CONTENT_DETECTION per analizzare un video e rilevare contenuti espliciti.
Chiama la funzione per analizzare i primi 10 secondi del video:
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])
Attendi che il video venga elaborato:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Aggiungi questa funzione per stampare i diversi conteggi di probabilità:
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}")
Chiama la funzione:
print_explicit_content(results)
Il risultato dovrebbe essere simile a questo:
----- Explicit content frames: 10 ------ LIKELIHOOD_UNSPECIFIED: 0 VERY_UNLIKELY : 10 UNLIKELY : 0 POSSIBLE : 0 LIKELY : 0 VERY_LIKELY : 0
Aggiungi questa funzione per stampare i dettagli del frame:
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)
Chiama la funzione:
print_frames(results, vi.Likelihood.VERY_UNLIKELY)
Il risultato dovrebbe essere simile a questo:
------- 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
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento di contenuti espliciti in un video utilizzando l'API Video Intelligence. Puoi leggere di più sul rilevamento di contenuti espliciti.
8. Trascrivere l'input vocale
Puoi utilizzare l'API Video Intelligence per trascrivere il parlato dei video in testo.
Copia il seguente codice nella sessione 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
Prenditi un momento per studiare il codice e vedere come utilizza il metodo della libreria client annotate_video con il parametro SPEECH_TRANSCRIPTION per analizzare un video e trascrivere il parlato.
Chiama la funzione per analizzare il video dal secondo 55 all'80:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
language_code = "en-GB"
segment = vi.VideoSegment(
start_time_offset=timedelta(seconds=55),
end_time_offset=timedelta(seconds=80),
)
results = transcribe_speech(video_uri, language_code, [segment])
Attendi che il video venga elaborato:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Aggiungi questa funzione per stampare il discorso trascritto:
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()}")
Chiama la funzione:
print_video_speech(results)
Il risultato dovrebbe essere simile a questo:
--------------------------- 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.
Aggiungi questa funzione per stampare l'elenco delle parole rilevate e i relativi timestamp:
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}")
Chiama la funzione:
print_word_timestamps(results)
Il risultato dovrebbe essere simile a questo:
------------------------------- 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.
Riepilogo
In questo passaggio, hai eseguito la trascrizione vocale di un video utilizzando l'API Video Intelligence. Scopri di più sulla trascrizione dell'audio.
9. Rilevare e monitorare il testo
Puoi utilizzare l'API Video Intelligence per rilevare e monitorare il testo in un video.
Copia il seguente codice nella sessione 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
Prenditi un momento per studiare il codice e vedere come utilizza il metodo della libreria client annotate_video con il parametro TEXT_DETECTION per analizzare un video e rilevare il testo.
Chiama la funzione per analizzare il video dal secondo 13 al secondo 27:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
segment = vi.VideoSegment(
start_time_offset=timedelta(seconds=13),
end_time_offset=timedelta(seconds=27),
)
results = detect_text(video_uri, segments=[segment])
Attendi che il video venga elaborato:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Aggiungi questa funzione per stampare il testo rilevato:
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
Chiama la funzione:
print_video_text(results)
Il risultato dovrebbe essere simile a questo:
-------------------------------- 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.
Aggiungi questa funzione per stampare l'elenco dei riquadri di testo e dei riquadri di delimitazione rilevati:
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=" | ",
)
Chiama la funzione per controllare in quali frame viene visualizzato il nome del narratore:
contained_text = "Goodall"
print_text_frames(results, contained_text)
Il risultato dovrebbe essere simile a questo:
--------------------------------- 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)
Se disegni i riquadri di selezione sopra i frame corrispondenti, otterrai questo risultato:
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento e il monitoraggio del testo in un video utilizzando l'API Video Intelligence. Scopri di più sul rilevamento e sul monitoraggio del testo.
10. Rilevamento e tracciamento di oggetti
Puoi utilizzare l'API Video Intelligence per rilevare e monitorare gli oggetti in un video.
Copia il seguente codice nella sessione 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
Prenditi un momento per studiare il codice e vedere come utilizza il metodo della libreria client annotate_video con il parametro OBJECT_TRACKING per analizzare un video e rilevare gli oggetti.
Chiama la funzione per analizzare il video dal secondo 98 al secondo 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])
Attendi che il video venga elaborato:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Aggiungi questa funzione per stampare l'elenco degli oggetti rilevati:
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=" | ",
)
Chiama la funzione:
print_detected_objects(results)
Il risultato dovrebbe essere simile a questo:
------------------- 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.
Aggiungi questa funzione per stampare l'elenco dei frame e dei riquadri di delimitazione degli oggetti rilevati:
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=" | ",
)
Chiama la funzione con l'ID entità per gli insetti:
insect_entity_id = "/m/03vt0"
print_object_frames(results, insect_entity_id)
Il risultato dovrebbe essere simile a questo:
--------------------- 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)
Se disegni i riquadri di selezione sopra i frame corrispondenti, otterrai questo risultato:
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento e il monitoraggio degli oggetti in un video utilizzando l'API Video Intelligence. Puoi leggere di più sul rilevamento e sul monitoraggio degli oggetti.
11. Rilevare e monitorare i loghi
Puoi utilizzare l'API Video Intelligence per rilevare e monitorare i loghi in un video. È possibile rilevare oltre 100.000 brand e loghi.
Copia il seguente codice nella sessione 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
Prenditi un momento per studiare il codice e vedere come utilizza il metodo della libreria client annotate_video con il parametro LOGO_RECOGNITION per analizzare un video e rilevare i loghi.
Chiama la funzione per analizzare la penultima sequenza del video:
video_uri = "gs://cloud-samples-data/video/JaneGoodall.mp4"
segment = vi.VideoSegment(
start_time_offset=timedelta(seconds=146),
end_time_offset=timedelta(seconds=156),
)
results = detect_logos(video_uri, [segment])
Attendi che il video venga elaborato:
Processing video: "gs://cloud-samples-data/video/JaneGoodall.mp4"...
Aggiungi questa funzione per stampare l'elenco dei loghi rilevati:
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=" | ",
)
Chiama la funzione:
print_detected_logos(results)
Il risultato dovrebbe essere simile a questo:
------------------------------ Detected logos: 1 ------------------------------- 92% | 150.680 | 155.720 | 43 fr. | /m/055t58 | Google Maps
Aggiungi questa funzione per stampare l'elenco dei frame e dei riquadri di delimitazione del logo rilevati:
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=" | ",
)
Chiama la funzione con l'ID entità del logo di Google Maps:
maps_entity_id = "/m/055t58"
print_logo_frames(results, maps_entity_id)
Il risultato dovrebbe essere simile a questo:
------------------- 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)
Se disegni i riquadri di selezione sopra i frame corrispondenti, otterrai questo risultato:
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento e il monitoraggio del logo in un video utilizzando l'API Video Intelligence. Scopri di più sul rilevamento e sul monitoraggio dei loghi.
12. Rilevare più funzionalità
Ecco il tipo di richiesta che puoi fare per ottenere tutti gli approfondimenti contemporaneamente:
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. Complimenti!
Hai imparato a utilizzare l'API Video Intelligence utilizzando Python.
Esegui la pulizia
Per pulire l'ambiente di sviluppo, da Cloud Shell:
- Se sei ancora nella sessione IPython, torna alla shell:
exit - Interrompi l'utilizzo dell'ambiente virtuale Python:
deactivate - Elimina la cartella dell'ambiente virtuale:
cd ~ ; rm -rf ./venv-videointel
Per eliminare il progetto Google Cloud, da Cloud Shell:
- Recupera l'ID progetto corrente:
PROJECT_ID=$(gcloud config get-value core/project) - Assicurati che sia il progetto che vuoi eliminare:
echo $PROJECT_ID - Elimina il progetto:
gcloud projects delete $PROJECT_ID
Scopri di più
- Prova la demo nel tuo browser: https://zackakil.github.io/video-intelligence-api-visualiser
- Documentazione di Video Intelligence: https://cloud.google.com/video-intelligence/docs
- Funzionalità beta: https://cloud.google.com/video-intelligence/docs/beta
- Python su Google Cloud: https://cloud.google.com/python
- Librerie client di Cloud per Python: https://github.com/googleapis/google-cloud-python
Licenza
Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.