1. Ziele
Übersicht
In diesem Codelab wird eine End-to-End-Anwendung für Vertex AI Vision erstellt, um die Warteschlangengröße anhand von Einzelhandelsvideos zu überwachen. Wir verwenden die integrierten Funktionen des vortrainierten spezialisierten Modells Occupancy analytics (Belegungsanalyse), um Folgendes zu erfassen:
- Zähle die Anzahl der Personen, die in der Schlange stehen.
- Zählen Sie die Anzahl der Personen, die am Schalter bedient werden.
Lerninhalte
- Anwendung in Vertex AI Vision erstellen und bereitstellen
- So richten Sie einen RTSP-Stream mit einer Videodatei ein und nehmen den Stream mit vaictl aus einem Jupyter-Notebook in Vertex AI Vision auf.
- Verwendung des Modells für die Analyse der Belegung und seiner verschiedenen Funktionen.
- So suchen Sie nach Videos in Ihrem Media Warehouse von Vertex AI Vision.
- So verbinden Sie die Ausgabe mit BigQuery, schreiben eine SQL-Abfrage, um Statistiken aus der JSON-Ausgabe des Modells zu extrahieren, und verwenden die Ausgabe, um das Originalvideo zu kennzeichnen und mit Anmerkungen zu versehen.
Kosten:
Die Gesamtkosten für die Ausführung dieses Labs in Google Cloud betragen etwa 2 $.
2. Vorbereitung
Projekt erstellen und APIs aktivieren:
- Wählen Sie in der Google Cloud Console auf der Seite der 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 mit dem Projekt verknüpften Ressourcen entfernen. Zur Projektauswahl
- Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.
- Aktivieren Sie die Compute Engine API, die Vertex API, die Notebook API und die 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. Die Google Cloud Console füllt das Feld Dienstkonto-ID anhand dieses Namens aus. Geben Sie im Feld Dienstkontobeschreibung eine Beschreibung ein. Beispiel: „Dienstkonto für die Kurzanleitung“.
- Klicken Sie auf Erstellen und fortfahren.
- Um Zugriff auf Ihr Projekt zu gewähren, weisen Sie Ihrem Dienstkonto die folgenden Rollen zu:
- Vision AI > Vision AI-Bearbeiter
- Compute Engine > Compute Instance Admin (Beta)
- BigQuery > BigQuery-Administrator.
Wählen Sie in der Liste Rolle auswählen eine Rolle aus. Klicken Sie auf Weitere Rolle hinzufügen, um weitere Rollen hinzuzufügen.
- 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, auf der ein Video gehostet wird, und senden die Streamingvideodaten aus dem Notebook. Wir verwenden Jupyter Notebook, da es uns die Flexibilität bietet, Shell-Befehle auszuführen und benutzerdefinierten Vor- und Nachbearbeitungscode an einem einzigen Ort auszuführen, was sich sehr gut für schnelle Tests eignet. In diesem Notebook werden wir:
- rtsp-Server als Hintergrundprozess ausführen
- vaictl-Befehl als Hintergrundprozess ausführen
- Abfragen und Verarbeitungscode ausführen, um die Ausgabe der Belegungsanalyse zu analysieren
Jupyter-Notebook erstellen
Der erste Schritt beim Senden von Videos über eine Jupyter-Notebook-Instanz besteht darin, das Notebook mit dem Dienstkonto zu erstellen, das im vorherigen Schritt erstellt wurde.
- Rufen Sie in der Console die Seite „Vertex AI“ auf. Zu Vertex AI Workbench
- Klicken Sie auf „Nutzerverwaltete Notebooks“.
- Klicken Sie auf Neues Notebook > Tensorflow Enterprise 2.6 (mit LTS) > Ohne GPUs.
- Geben Sie einen 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 Berechtigungsabschnitte.
- Entfernen Sie das Häkchen aus dem Kästchen 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.
- Klicken Sie nach dem Erstellen der Instanz 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 Streaming-Videodaten vom Notebook-Terminal aus.
vaictl-Befehlszeilentool herunterladen
- Öffnen Sie in der geöffneten JupyterLab-Instanz über den Launcher ein Notebook.
- Laden Sie das Befehlszeilentool für Vertex AI Vision (vaictl), das Befehlszeilentool für den RTSP-Server und das OpenCV-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 Notebookumgebung mit den erforderlichen Befehlszeilentools eingerichtet haben, können Sie eine Beispielvideodatei kopieren und dann „vaictl“ verwenden, um die Videodaten an Ihre App für die Analyse der Belegung zu streamen.
Neuen Stream registrieren
- Klicken Sie im linken Bereich von Vertex AI Vision auf den Tab „Streams“.
- Klicken Sie oben auf die Schaltfläche „Registrieren“
. - Geben Sie als Streamname queue-stream ein.
- Wählen Sie für die Region dieselbe Region aus, die Sie im vorherigen Schritt beim Erstellen des Notebooks ausgewählt haben.
- Klicken Sie auf Registrieren.
Beispielvideo auf Ihre VM kopieren
- Kopieren Sie in Ihrem Notebook ein Beispielvideo mit dem folgenden wget-Befehl.
!wget -q https://github.com/vagrantism/interesting-datasets/raw/main/video/collective_activity/seq25_h264.mp4
Video von VM streamen und Daten in Ihren Stream aufnehmen
- Verwenden Sie den folgenden Befehl in Ihrer Notebook-Zelle, um diese lokale Videodatei an den Eingabestream der App 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)
- ffmpeg-Befehlszeilentool verwenden, um das Video im RTSP-Stream zu wiederholen
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 Befehlszeilentool „vaictl“, um das Video vom RTSP-Server-URI in den in einem vorherigen Schritt erstellten Vertex AI Vision-Stream „queue-stream“ zu streamen.
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)
Es kann etwa 100 Sekunden dauern, bis das Video im Dashboard angezeigt wird, nachdem der vaictl-Aufnahmevorgang gestartet wurde.
Nachdem die Streamaufnahme verfügbar ist, können Sie den Videofeed auf dem Tab Streams des Vertex AI Vision-Dashboards ansehen, indem Sie den Queue-Stream auswählen.
6. Anwendung erstellen
Als Erstes müssen Sie eine App erstellen, die Ihre Daten verarbeitet. Eine App kann als automatisierte Pipeline betrachtet werden, die Folgendes verbindet:
- Datenaufnahme: Ein Videofeed wird in einen Stream aufgenommen.
- Datenanalyse: Nach der Aufnahme kann ein KI-Modell(Computer Vision) 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 App als Diagramm dargestellt.
Leere App erstellen
Bevor Sie den App-Graphen mit Daten füllen können, müssen Sie zuerst eine leere App erstellen.
Erstellen Sie eine App in der Google Cloud Console.
- Rufen Sie die Google Cloud Console auf.
- Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. Zum Tab „Anwendungen“
- Klicken Sie auf die Schaltfläche Erstellen.
- Geben Sie queue-app als App-Namen ein und wählen Sie Ihre Region aus.
- Klicken Sie auf Erstellen.
Knoten für Anwendungskomponenten hinzufügen
Nachdem Sie die leere Anwendung erstellt haben, können Sie dem App-Graphen die drei Knoten hinzufügen:
- Aufnahmeknoten: Die Streamressource, die Daten aufnimmt, die von einem RTSP-Videoserver gesendet werden, den Sie im Notebook erstellt haben.
- Verarbeitungsknoten: Das Modell für die Analyse der Belegung, das auf die aufgenommenen Daten angewendet wird.
- Speicherknoten: Das Media Warehouse, in dem verarbeitete Videos gespeichert werden und das als Metadatenspeicher dient. Die Metadatenspeicher enthalten Analysedaten zu aufgenommenen Videodaten und von den KI-Modellen abgeleitete Informationen.
Fügen Sie Ihrer App in der Konsole Knoten für Komponenten hinzu.
- Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. Zum Tab „Anwendungen“
Dadurch gelangen Sie zur grafischen Darstellung der Verarbeitungspipeline.
Knoten für die Datenaufnahme hinzufügen
- Wenn Sie einen Knoten für den Eingabestream hinzufügen möchten, wählen Sie im seitlichen Menü im Abschnitt Connectors die Option Streams aus.
- Wählen Sie im Abschnitt Quelle des sich öffnenden Menüs Stream die Option Streams hinzufügen aus.
- Wählen Sie im Menü Streams hinzufügen die Option queue-stream aus.
- Klicken Sie auf Streams hinzufügen, um den Stream dem App-Diagramm hinzuzufügen.
Knoten zur Datenverarbeitung hinzufügen
- Wenn Sie den Knoten für das Modell zur Berechnung der Belegung hinzufügen möchten, wählen Sie im seitlichen Menü im Abschnitt Spezialisierte Modelle die Option Belegungsanalyse aus.
- Behalten Sie die Standardauswahl Personen bei. Entfernen Sie das Häkchen bei Fahrzeuge, falls es bereits ausgewählt ist.
- Klicken Sie im Bereich „Erweiterte Optionen“ auf Aktive Zonen/Linien erstellen
. - Zeichnen Sie die aktiven Zonen mit dem Polygon-Tool, um Personen in dieser Zone zu zählen. Zone entsprechend kennzeichnen
- Klicken Sie oben auf den Zurückpfeil.
- Fügen Sie Einstellungen für die Verweildauer hinzu, um Staus zu erkennen. Klicken Sie dazu auf das Kästchen.
Datenspeicherknoten hinzufügen
- Wählen Sie im Abschnitt Connectors des Seitenmenüs die Option Vision AI Warehouse aus, um den Knoten für den Ausgabespeicherort (Speicher) hinzuzufügen.
- Klicken Sie auf den Vertex AI Warehouse-Connector, um das zugehörige Menü zu öffnen, und klicken Sie dann auf Warehouse verbinden.
- Wählen Sie im Menü Warehouse verbinden die Option Neues Warehouse erstellen aus. Geben Sie dem Warehouse den Namen 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-App einen BigQuery-Connector hinzufügen, werden alle verbundenen App-Modellausgaben in die Zieltabelle aufgenommen.
Sie können entweder eine eigene BigQuery-Tabelle erstellen und diese Tabelle angeben, wenn Sie der App einen BigQuery-Connector hinzufügen, oder die Tabelle automatisch von der Vertex AI Vision-App-Plattform erstellen lassen.
Automatische Tabellenerstellung
Wenn Sie die Tabelle automatisch von der Vertex AI Vision-App-Plattform 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 ist visionai_dataset.
- Tabelle: Der automatisch erstellte Tabellenname lautet visionai_dataset.APPLICATION_ID.
- Fehlerbehandlung:
- Wenn die Tabelle mit demselben Namen im selben Dataset vorhanden ist, wird sie nicht automatisch erstellt.
- Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. Zum Tab „Anwendungen“
- Wählen Sie in der Liste neben dem Namen Ihrer Anwendung App ansehen aus.
- Wählen Sie auf der Seite des Anwendungs-Builders im Bereich Connectors die Option BigQuery aus.
- Lassen Sie das Feld BigQuery-Pfad leer.
- Wählen Sie unter Metadaten speichern aus nur Belegungsanalyse aus und deaktivieren Sie Streams.
Das endgültige App-Diagramm sollte so aussehen:
8. Anwendung zur Verwendung bereitstellen
Nachdem Sie Ihre End-to-End-App mit allen erforderlichen Komponenten erstellt haben, müssen Sie sie als letzten Schritt bereitstellen, um sie verwenden zu können.
- Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. 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 Bestätigungsdialogfeld auf Bereitstellen. Die Bereitstellung kann mehrere Minuten dauern. Nach Abschluss des Deployments werden neben den Knoten grüne Häkchen angezeigt.
9. Videocontent im Speicher-Warehouse suchen
Nachdem Sie Videodaten in Ihre Verarbeitungs-App aufgenommen haben, können Sie analysierte Videodaten ansehen und die Daten anhand von Informationen zur Belegungsanalyse durchsuchen.
- Öffnen Sie den Tab Warehouses (Speicherorte) des Vertex AI Vision-Dashboards. Zum Tab „Warehouses“ (Lager)
- Suchen Sie in der Liste nach dem Lager für die Warteschlange und klicken Sie auf Assets ansehen.
- Legen Sie im Abschnitt Anzahl der Personen den Wert Min. auf 1 und den Wert Max. auf 5 fest.
- Wenn Sie verarbeitete Videodaten filtern möchten, die im Media Warehouse von Vertex AI Vision gespeichert sind, klicken Sie auf Suchen.
Eine Ansicht der gespeicherten Videodaten, die den Suchkriterien in der Google Cloud Console entsprechen.
10. Ausgabe mit 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 Zeitstempel der Daten und die Annotationsinformationen aus der BigQuery-Tabelle ab und erstellen Sie ein Verzeichnis zum Speichern der aufgenommenen 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 mit dem folgenden Code:
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