1. Zielsetzungen
Übersicht
In diesem Codelab geht es um das Erstellen einer Vertex AI Vision-Anwendung. Dabei wird die Warteschlangengröße anhand von Videomaterial aus dem Einzelhandel überwacht. Wir verwenden die vortrainierten Features des Specialized-Modells Occupancy Analytics, um die folgenden Dinge zu erfassen:
- Zählt die Anzahl der Personen in der Warteschlange.
- Zählt, wie viele Personen am Tresen serviert werden.
Aufgaben in diesem Lab
- Anwendung in Vertex AI Vision erstellen und bereitstellen
- Hier erfahren Sie, wie Sie einen RTSP-Stream mithilfe einer Videodatei einrichten und den Stream mit vaictl aus einem Jupyter-Notebook in Vertex AI Vision aufnehmen.
- Verwendung des Occupancy Analytics-Modells und seiner verschiedenen Funktionen.
- So suchen Sie im Media Warehouse von Vertex AI Vision nach Videos in Ihrem Speicher.
- Hier erfahren Sie, wie Sie die Ausgabe mit BigQuery verbinden, eine SQL-Abfrage schreiben, um Informationen aus der JSON-Ausgabe des Modells zu extrahieren und anhand der Ausgabe das Originalvideo mit einem Label zu versehen und mit Anmerkungen zu versehen.
Kosten:
Die Gesamtkosten für dieses Lab in Google Cloud betragen etwa 2 $.
2. Vorbereitung
Erstellen Sie ein Projekt und aktivieren Sie APIs:
- Wählen Sie in der Google Cloud Console auf der Seite für die Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines. Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle damit verknüpften Ressourcen entfernen. Zur Projektauswahl
- Die Abrechnung für das Cloud-Projekt muss aktiviert sein. Hier erfahren Sie, wie Sie prüfen, ob die Abrechnung für ein Projekt aktiviert ist.
- Aktivieren Sie die Compute Engine, Vertex API, Notebook API und Vision AI API. APIs aktivieren
Dienstkonto erstellen:
- Wechseln Sie in der Google Cloud Console zur Seite Dienstkonto erstellen. Zur Seite „Dienstkonto erstellen“
- Wählen Sie Ihr Projekt aus.
- Geben Sie im Feld Dienstkontoname einen Namen ein. In der Google Cloud Console wird das Feld Dienstkonto-ID auf Grundlage dieses Namens ausgefüllt. Geben Sie im Feld Beschreibung des Dienstkontos eine Beschreibung ein. Beispiel: Dienstkonto für Kurzanleitung.
- Klicken Sie auf Erstellen und fortfahren.
- Weisen Sie Ihrem Dienstkonto die folgenden Rollen zu, um Zugriff auf Ihr Projekt zu gewähren:
- Vision AI > Vision AI-Bearbeiter
- Compute Engine > Compute-Instanzadministrator (Beta)
- BigQuery > BigQuery-Verwaltung .
Wählen Sie in der Liste Rolle auswählen eine Rolle aus. Wenn Sie weitere Rollen hinzufügen möchten, klicken Sie auf Weitere Rolle hinzufügen und fügen Sie jede weitere Rolle hinzu.
- Klicken Sie auf Weiter.
- Klicken Sie auf Fertig, um das Erstellen des Dienstkontos abzuschließen. Schließen Sie das Browserfenster nicht. Sie verwenden es in der nächsten Aufgabe.
3. Jupyter-Notebook einrichten
Bevor Sie eine App in Occupancy Analytics erstellen, müssen Sie einen Stream registrieren, der später von der App verwendet werden kann.
In dieser Anleitung erstellen Sie eine Jupyter Notebook-Instanz, die ein Video hostet, und senden die gestreamten Videodaten aus dem Notebook. Wir verwenden Jupyter Notebook, da es uns die Flexibilität bietet, Shell-Befehle sowie benutzerdefinierten Vor- und Nachbearbeitungscode an einem einzigen Ort auszuführen, was für schnelle Tests sehr gut geeignet ist. Wir werden dieses Notizbuch für Folgendes verwenden:
- rtsp-Server im Hintergrund ausführen
- Befehl vaictl als Hintergrundprozess ausführen
- Abfragen ausführen und Code verarbeiten, um die Ausgabe der Belegungsanalyse zu analysieren
Jupyter-Notebook erstellen
Der erste Schritt beim Senden von Videos von einer Jupyter Notebook-Instanz besteht darin, das Notebook mit dem im vorherigen Schritt erstellten Dienstkonto zu erstellen.
- Rufen Sie in der Console die Seite von Vertex AI auf. Zu Vertex AI Workbench
- Klicken Sie auf „Nutzerverwaltete Notebooks“.
- Klicken Sie auf Neues Notebook > Tensorflow Enterprise 2.6 (mit Langzeitsupport) > Ohne GPUs
- Geben Sie den Namen für das Jupyter-Notebook ein. Weitere Informationen finden Sie unter Namenskonvention für Ressourcen.
- Klicken Sie auf ERWEITERTE OPTIONEN.
- Scrollen Sie nach unten zu den Abschnitten für Berechtigungen.
- Entfernen Sie das Häkchen bei der Option Compute Engine-Standarddienstkonto verwenden.
- Fügen Sie die E-Mail-Adresse des Dienstkontos hinzu, die Sie im vorherigen Schritt erstellt haben. Klicken Sie auf Erstellen.
- Nachdem die Instanz erstellt wurde, klicken Sie auf JUPYTERLAB ÖFFNEN.
4. Notebook zum Streamen von Videos einrichten
Bevor Sie eine App in Occupancy Analytics erstellen, müssen Sie einen Stream registrieren, der später von der App verwendet werden kann.
In dieser Anleitung verwenden wir unsere Jupyter Notebook-Instanz zum Hosten eines Videos und Sie senden die gestreamten Videodaten vom Notebook-Terminal.
vaictl-Befehlszeilentool herunterladen
- Öffnen Sie in der geöffneten JupyterLab-Instanz ein Notebook im Launcher.
- Laden Sie das Vertex AI Vision-Befehlszeilentool (vaictl), das RTSP-Server-Befehlszeilentool und das open-cv-Tool mit dem folgenden Befehl in der Notebook-Zelle herunter:
!wget -q https://github.com/aler9/rtsp-simple-server/releases/download/v0.20.4/rtsp-simple-server_v0.20.4_linux_amd64.tar.gz
!wget -q https://github.com/google/visionai/releases/download/v0.0.4/visionai_0.0-4_amd64.deb
!tar -xf rtsp-simple-server_v0.20.4_linux_amd64.tar.gz
!pip install opencv-python --quiet
!sudo apt-get -qq remove -y visionai
!sudo apt-get -qq install -y ./visionai_0.0-4_amd64.deb
!sudo apt-get -qq install -y ffmpeg
5. Videodatei für Streaming aufnehmen
Nachdem Sie Ihre Notebook-Umgebung mit den erforderlichen Befehlszeilentools eingerichtet haben, können Sie eine Beispielvideodatei kopieren und dann mit vaictl die Videodaten in Ihre Belegungsanalyse-App streamen.
Neuen Stream registrieren
- Klicken Sie im linken Bereich von Vertex AI Vision auf den Tab „Streams“.
- Klicken Sie oben auf der Seite
auf die Schaltfläche „Registrieren“. - Geben Sie im Namen des Streams ‘queue-stream' ein.
- Wählen Sie dort dieselbe Region aus, die Sie im vorherigen Schritt bei der Notebook-Erstellung ausgewählt haben.
- Klicken Sie auf Registrieren.
Beispielvideo auf die VM kopieren
- Kopieren Sie mit dem folgenden wget-Befehl ein Beispielvideo in Ihr Notebook.
!wget -q https://github.com/vagrantism/interesting-datasets/raw/main/video/collective_activity/seq25_h264.mp4
Videos von einer VM streamen und Daten in den Stream aufnehmen
- Verwenden Sie den folgenden Befehl in Ihrer Notebook-Zelle, um diese lokale Videodatei an den App-Eingabestream zu senden. Sie müssen die folgenden Variablen ersetzen:
- PROJECT_ID: Ihre Google Cloud-Projekt-ID.
- LOCATION: Ihre Standort-ID. Beispiel: us-central1. Weitere Informationen finden Sie unter Cloud-Standorte.
- LOCAL_FILE: Der Dateiname einer lokalen Videodatei. Beispiel:
seq25_h264.mp4.
PROJECT_ID='<Your Google Cloud project ID>'
LOCATION='<Your stream location>'
LOCAL_FILE='seq25_h264.mp4'
STREAM_NAME='queue-stream'
- Starten Sie einen rtsp-simple-Server, auf dem die Videodatei mit dem RTSP-Protokoll gestreamt wird.
import os
import time
import subprocess
subprocess.Popen(["nohup", "./rtsp-simple-server"], stdout=open('rtsp_out.log', 'a'), stderr=open('rtsp_err.log', 'a'), preexec_fn=os.setpgrp)
time.sleep(5)
- Verwenden Sie das ffmpeg-Befehlszeilentool, um das Video im RTSP-Stream als Schleife wiederzugeben.
subprocess.Popen(["nohup", "ffmpeg", "-re", "-stream_loop", "-1", "-i", LOCAL_FILE, "-c", "copy", "-f", "rtsp", f"rtsp://localhost:8554/{LOCAL_FILE.split('.')[0]}"], stdout=open('ffmpeg_out.log', 'a'), stderr=open('ffmpeg_err.log', 'a'), preexec_fn=os.setpgrp)
time.sleep(5)
- Verwenden Sie das vaictl-Befehlszeilentool, um das Video vom RTSP-Server-URI in unseren Vertex AI Vision-Stream „queue-stream“ zu streamen die im vorherigen Schritt erstellt wurden.
subprocess.Popen(["nohup", "vaictl", "-p", PROJECT_ID, "-l", LOCATION, "-c", "application-cluster-0", "--service-endpoint", "visionai.googleapis.com", "send", "rtsp", "to", "streams", "queue-stream", "--rtsp-uri", f"rtsp://localhost:8554/{LOCAL_FILE.split('.')[0]}"], stdout=open('vaictl_out.log', 'a'), stderr=open('vaictl_err.log', 'a'), preexec_fn=os.setpgrp)
Nach dem Start der vaictl-Datenaufnahme kann es etwa 100 Sekunden dauern, bis das Video im Dashboard angezeigt wird.
Sobald die Streamaufnahme verfügbar ist, können Sie den Videofeed im Vertex AI Vision-Dashboard auf dem Tab Streams ansehen. Wählen Sie dazu den Warteschlangenstream aus.
6. Anwendung erstellen
Der erste Schritt besteht darin, eine App zu erstellen, die Ihre Daten verarbeitet. Stellen Sie sich eine Anwendung als automatisierte Pipeline vor, die Folgendes verbindet:
- Datenaufnahme: Ein Videofeed wird in einen Stream aufgenommen.
- Datenanalyse: Ein KI-Modell(Computer Vision) kann nach der Aufnahme hinzugefügt werden.
- Datenspeicher: Die beiden Versionen des Videofeeds (der Originalstream und der vom KI-Modell verarbeitete Stream) können in einem Media Warehouse gespeichert werden.
In der Google Cloud Console wird eine Anwendung als Grafik dargestellt.
Leere App erstellen
Bevor Sie das App-Diagramm füllen können, müssen Sie zuerst eine leere App erstellen.
Anwendung in der Google Cloud Console erstellen
- Rufen Sie die Google Cloud Console auf.
- Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. Gehen Sie zum Tab „Anwendungen“.
- Klicken Sie auf Erstellen.
- Geben Sie queue-app als Anwendungsnamen ein und wählen Sie Ihre Region aus.
- Klicken Sie auf Erstellen.
Knoten der App-Komponente hinzufügen
Nachdem Sie die leere Anwendung erstellt haben, können Sie die drei Knoten zum Anwendungsdiagramm hinzufügen:
- Aufnahmeknoten: Die Streamressource, die Daten aufnimmt, die von einem RTSP-Videoserver gesendet werden, den Sie im Notebook erstellt haben.
- Verarbeitungsknoten: Das Belegungsanalysemodell, das auf aufgenommene Daten angewendet wird.
- Speicherknoten: Das Media Warehouse, in dem verarbeitete Videos gespeichert werden und das als Metadatenspeicher dient. Die Metadatenspeicher enthalten Analyseinformationen über aufgenommene Videodaten und abgeleitete Informationen von den KI-Modellen.
Fügen Sie Ihrer Anwendung in der Console Komponentenknoten hinzu.
- Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. Gehen Sie zum Tab „Anwendungen“.
Dadurch gelangen Sie zur Diagrammvisualisierung der Verarbeitungspipeline.
Datenaufnahmeknoten hinzufügen
- Um einen Eingabestream-Knoten hinzuzufügen, wählen Sie im Abschnitt Connectors des seitlichen Menüs die Option Streams aus.
- Wählen Sie im angezeigten Menü Stream im Abschnitt Quelle die Option Streams hinzufügen aus.
- Wählen Sie im Menü Streams hinzufügen die Option Warteschlangenstream aus.
- Klicken Sie auf Streams hinzufügen, um den Stream zur App-Grafik hinzuzufügen.
Datenverarbeitungsknoten hinzufügen
- Wenn Sie den Knoten für das Belegungszahlmodell hinzufügen möchten, wählen Sie im Bereich Spezialisierte Modelle des seitlichen Menüs die Option Belegungsanalyse aus.
- Behalten Sie die Standardauswahl Personen bei. Entfernen Sie das Häkchen bei Fahrzeuge, wenn es bereits ausgewählt ist.
- Klicken Sie im Abschnitt Advanced Options (Erweiterte Optionen) auf Create Active Zones/Lines (Aktive Zonen/Linien erstellen).
- Zeichnen Sie mit dem Polygon-Tool die aktiven Bereiche, um die Personen in diesem Bereich zu zählen. Beschriften Sie die Zone entsprechend.
- Klicken Sie oben auf den Zurückpfeil.
- Klicken Sie auf das Kästchen, um Einstellungen für die Verweildauer hinzuzufügen, um Überlastungen zu erkennen.
Datenspeicherknoten hinzufügen
- Wählen Sie im Abschnitt Connectors des seitlichen Menüs die Option VIsion AI Warehouse aus, um den Ausgabezielknoten (Speicher) hinzuzufügen.
- Klicken Sie auf Vertex AI Warehouse-Connector, um das Menü zu öffnen, und dann auf Connect warehouse.
- Wählen Sie im Menü Warehouse verbinden die Option Neues Warehouse erstellen aus. Benennen Sie das Warehouse als queue-warehouse und belassen Sie die TTL-Dauer bei 14 Tagen.
- Klicken Sie auf die Schaltfläche Erstellen, um das Warehouse hinzuzufügen.
7. Ausgabe mit BigQuery-Tabelle verbinden
Wenn Sie Ihrer Vertex AI Vision-Anwendung einen BigQuery-Connector hinzufügen, werden alle Ausgaben des verbundenen Anwendungsmodells in die Zieltabelle aufgenommen.
Sie können entweder eine eigene BigQuery-Tabelle erstellen und diese angeben, wenn Sie der Anwendung einen BigQuery-Connector hinzufügen, oder sie von der Vertex AI Vision-Anwendungsplattform automatisch erstellen lassen.
Automatische Tabellenerstellung
Wenn Sie die Vertex AI Vision-App-Plattform automatisch die Tabelle erstellen lassen, können Sie diese Option beim Hinzufügen des BigQuery-Connector-Knotens angeben.
Die folgenden Dataset- und Tabellenbedingungen gelten, wenn Sie die automatische Tabellenerstellung verwenden möchten:
- Dataset: Der automatisch erstellte Dataset-Name lautet visionai_dataset.
- Tabelle: Der automatisch erstellte Tabellenname lautet visionai_dataset.APPLICATION_ID.
- Fehlerbehandlung:
- Wenn eine Tabelle mit demselben Namen unter demselben Dataset vorhanden ist, erfolgt keine automatische Erstellung.
- Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. Gehen Sie zum Tab „Anwendungen“.
- Wählen Sie in der Liste neben dem Namen der App die Option App ansehen aus.
- Wählen Sie auf der Seite „Application Builder“ im Bereich Connectors die Option BigQuery aus.
- Lassen Sie das Feld BigQuery-Pfad leer.
- Wählen Sie unter Shop-Metadaten von nur Belegungsanalysen aus und deaktivieren Sie „Streams“.
Die endgültige App-Grafik sollte so aussehen:
8. Anwendung zur Verwendung bereitstellen
Nachdem Sie Ihre End-to-End-Anwendung mit allen erforderlichen Komponenten erstellt haben, besteht der letzte Schritt zur Verwendung der Anwendung darin, sie bereitzustellen.
- Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. Gehen Sie zum Tab „Anwendungen“.
- Wählen Sie in der Liste neben der App queue-app die Option App ansehen aus.
- Klicken Sie auf der Seite Studio auf die Schaltfläche Bereitstellen.
- Klicken Sie im folgenden Bestätigungsdialogfeld auf Bereitstellen. Der Bereitstellungsvorgang kann einige Minuten dauern. Nach Abschluss der Bereitstellung werden neben den Knoten grüne Häkchen angezeigt.
9. Videoinhalte im Storage Warehouse suchen
Nachdem Sie Videodaten in die Verarbeitungs-App aufgenommen haben, können Sie analysierte Videodaten ansehen und die Daten basierend auf Informationen zur Belegungsanalyse durchsuchen.
- Öffnen Sie den Tab Warehouses des Vertex AI Vision-Dashboards. Zum Tab „Warehouses“
- Suchen Sie in der Liste nach dem Queue-Warehouse-Warehouse und klicken Sie auf Assets ansehen.
- Legen Sie im Abschnitt People count den Wert für Min auf 1 und für Max 5 fest.
- Klicken Sie auf Suchen, um verarbeitete Videodaten zu filtern, die im Media Warehouse von Vertex AI Vision gespeichert sind.
Eine Ansicht gespeicherter Videodaten, die den Suchkriterien in der Google Cloud Console entsprechen.
10. Ausgabe mit der BigQuery-Tabelle annotieren und analysieren
- Initialisieren Sie im Notebook die folgenden Variablen in der Zelle.
DATASET_ID='vision_ai_dataset'
bq_table=f'{PROJECT_ID}.{DATASET_ID}.queue-app'
frame_buffer_size=10000
frame_buffer_error_milliseconds=5
dashboard_update_delay_seconds=3
rtsp_url='rtsp://localhost:8554/seq25_h264'
- Jetzt erfassen wir die Frames aus dem RTSP-Stream mit dem folgenden Code:
import cv2
import threading
from collections import OrderedDict
from datetime import datetime, timezone
frame_buffer = OrderedDict()
frame_buffer_lock = threading.Lock()
stream = cv2.VideoCapture(rtsp_url)
def read_frames(stream):
global frames
while True:
ret, frame = stream.read()
frame_ts = datetime.now(timezone.utc).timestamp() * 1000
if ret:
with frame_buffer_lock:
while len(frame_buffer) >= frame_buffer_size:
_ = frame_buffer.popitem(last=False)
frame_buffer[frame_ts] = frame
frame_buffer_thread = threading.Thread(target=read_frames, args=(stream,))
frame_buffer_thread.start()
print('Waiting for stream initialization')
while not list(frame_buffer.keys()): pass
print('Stream Initialized')
- Rufen Sie den Datenzeitstempel und die Annotationsinformationen aus der BigQuery-Tabelle ab und erstellen Sie ein Verzeichnis zum Speichern der erfassten Frame-Bilder:
from google.cloud import bigquery
import pandas as pd
client = bigquery.Client(project=PROJECT_ID)
query = f"""
SELECT MAX(ingestion_time) AS ts
FROM `{bq_table}`
"""
bq_max_ingest_ts_df = client.query(query).to_dataframe()
bq_max_ingest_epoch = str(int(bq_max_ingest_ts_df['ts'][0].timestamp()*1000000))
bq_max_ingest_ts = bq_max_ingest_ts_df['ts'][0]
print('Preparing to pull records with ingestion time >', bq_max_ingest_ts)
if not os.path.exists(bq_max_ingest_epoch):
os.makedirs(bq_max_ingest_epoch)
print('Saving output frames to', bq_max_ingest_epoch)
- Annotieren Sie die Frames mithilfe des folgenden Codes:
import json
import base64
import numpy as np
from IPython.display import Image, display, HTML, clear_output
im_width = stream.get(cv2.CAP_PROP_FRAME_WIDTH)
im_height = stream.get(cv2.CAP_PROP_FRAME_HEIGHT)
dashdelta = datetime.now()
framedata = {}
cntext = lambda x: {y['entity']['labelString']: y['count'] for y in x}
try:
while True:
try:
annotations_df = client.query(f'''
SELECT ingestion_time, annotation
FROM `{bq_table}`
WHERE ingestion_time > TIMESTAMP("{bq_max_ingest_ts}")
''').to_dataframe()
except ValueError as e:
continue
bq_max_ingest_ts = annotations_df['ingestion_time'].max()
for _, row in annotations_df.iterrows():
with frame_buffer_lock:
frame_ts = np.asarray(list(frame_buffer.keys()))
delta_ts = np.abs(frame_ts - (row['ingestion_time'].timestamp() * 1000))
delta_tx_idx = delta_ts.argmin()
closest_ts_delta = delta_ts[delta_tx_idx]
closest_ts = frame_ts[delta_tx_idx]
if closest_ts_delta > frame_buffer_error_milliseconds: continue
image = frame_buffer[closest_ts]
annotations = json.loads(row['annotation'])
for box in annotations['identifiedBoxes']:
image = cv2.rectangle(
image,
(
int(box['normalizedBoundingBox']['xmin']*im_width),
int(box['normalizedBoundingBox']['ymin']*im_height)
),
(
int((box['normalizedBoundingBox']['xmin'] + box['normalizedBoundingBox']['width'])*im_width),
int((box['normalizedBoundingBox']['ymin'] + box['normalizedBoundingBox']['height'])*im_height)
),
(255, 0, 0), 2
)
img_filename = f"{bq_max_ingest_epoch}/{row['ingestion_time'].timestamp() * 1000}.png"
cv2.imwrite(img_filename, image)
binimg = base64.b64encode(cv2.imencode('.jpg', image)[1]).decode()
curr_framedata = {
'path': img_filename,
'timestamp_error': closest_ts_delta,
'counts': {
**{
k['annotation']['displayName'] : cntext(k['counts'])
for k in annotations['stats']["activeZoneCounts"]
},
'full-frame': cntext(annotations['stats']["fullFrameCount"])
}
}
framedata[img_filename] = curr_framedata
if (datetime.now() - dashdelta).total_seconds() > dashboard_update_delay_seconds:
dashdelta = datetime.now()
clear_output()
display(HTML(f'''
<h1>Queue Monitoring Application</h1>
<p>Live Feed of the queue camera:</p>
<p><img alt="" src="{img_filename}" style="float: left;"/></a></p>
<table border="1" cellpadding="1" cellspacing="1" style="width: 500px;">
<caption>Current Model Outputs</caption>
<thead>
<tr><th scope="row">Metric</th><th scope="col">Value</th></tr>
</thead>
<tbody>
<tr><th scope="row">Serving Area People Count</th><td>{curr_framedata['counts']['serving-zone']['Person']}</td></tr>
<tr><th scope="row">Queueing Area People Count</th><td>{curr_framedata['counts']['queue-zone']['Person']}</td></tr>
<tr><th scope="row">Total Area People Count</th><td>{curr_framedata['counts']['full-frame']['Person']}</td></tr>
<tr><th scope="row">Timestamp Error</th><td>{curr_framedata['timestamp_error']}</td></tr>
</tbody>
</table>
<p> </p>
'''))
except KeyboardInterrupt:
print('Stopping Live Monitoring')
- Beenden Sie die Annotationsaufgabe über die Schaltfläche Beenden in der Notebook-Menüleiste
- Mit dem folgenden Code können Sie einzelne Frames noch einmal aufrufen:
from IPython.html.widgets import Layout, interact, IntSlider
imgs = sorted(list(framedata.keys()))
def loadimg(frame):
display(framedata[imgs[frame]])
display(Image(open(framedata[imgs[frame]]['path'],'rb').read()))
interact(loadimg, frame=IntSlider(
description='Frame #:',
value=0,
min=0, max=len(imgs)-1, step=1,
layout=Layout(width='100%')))
11. Glückwunsch
Sie haben das Lab abgeschlossen.
Aufräumen
Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, können Sie entweder das Projekt löschen, das die Ressourcen enthält, oder das Projekt beibehalten und die einzelnen Ressourcen löschen.
Projekt löschen
Einzelne Ressourcen löschen
Ressourcen
https://cloud.google.com/vision-ai/docs/overview
https://cloud.google.com/vision-ai/docs/occupancy-count-tutorial