Vertex AI Vision Queue Detection App

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 integrierten Funktionen des vorab trainierten spezialisierten Modells Belegungsanalyse, um Folgendes zu erfassen:

• Zählen Sie die Anzahl der Personen in der Schlange.
• Zählen Sie die Anzahl der Personen, die an der Theke bedient werden.

Aufgaben in diesem Lab

• Anwendung in Vertex AI Vision erstellen und bereitstellen
• Hier erfahren Sie, wie Sie einen RTSP-Stream mit einer Videodatei einrichten und den Stream mithilfe von vaictl aus einem Jupyter-Notebook in Vertex AI Vision aufnehmen.
• Informationen zur Verwendung des Modells für Belegung und die verschiedenen Funktionen
• So suchen Sie im Media Warehouse von Vertex AI Vision nach Videos in Ihrem Speicher.
• Wie du die Ausgabe mit BigQuery verbindest, eine SQL-Abfrage schreibst, um Statistiken aus der JSON-Ausgabe des Modells zu extrahieren, und die Ausgabe verwendest, um das Originalvideo zu labeln und zu annotieren.

Kosten:

Die Gesamtkosten für die Ausführung dieses Labs in Google Cloud belaufen sich auf etwa 2 $.

2. Vorbereitung

Erstellen Sie ein Projekt und aktivieren Sie die APIs:

1. 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
2. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.
3. Aktivieren Sie die Compute Engine, die Vertex API, die Notebook API und die Vision AI API. APIs aktivieren

So erstellen Sie ein Dienstkonto:

1. Wechseln Sie in der Google Cloud Console zur Seite Dienstkonto erstellen. Zur Seite „Dienstkonto erstellen“
2. Wählen Sie Ihr Projekt aus.
3. 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 Beschreibung des Dienstkontos eine Beschreibung ein. Beispiel: Dienstkonto für die Kurzanleitung
4. Klicken Sie auf Erstellen und fortfahren.
5. Um Zugriff auf Ihr Projekt zu gewähren, weisen Sie Ihrem Dienstkonto die folgenden Rollen zu:

• Vision AI > Vision AI-Bearbeiter
• Compute Engine > Compute-Instanzadministrator (Beta)
• BigQuery > BigQuery Admin

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.

Hinweis: Das Feld „Rolle“ hat Einfluss darauf, auf welche Ressourcen in Ihrem Projekt das Dienstkonto zugreifen kann. Sie können diese Rollen später widerrufen oder zusätzliche Rollen erteilen. In Produktionsumgebungen sollten Sie die Inhaber-, Bearbeiter- und Betrachterrolle nicht zuweisen. Weisen Sie stattdessen eine vordefinierte Rolle oder eine benutzerdefinierte Rolle zu, die Ihren Anforderungen entspricht.

6. Klicken Sie auf Weiter.
7. 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 auszuführen und benutzerdefinierten Code für die Vor-/Nachbereitung an einem einzigen Ort auszuführen. Das ist sehr gut für schnelle Tests geeignet. Wir verwenden dieses Notebook für Folgendes:

1. rtsp-Server als Hintergrundprozess ausführen
2. Befehl vaictl als Hintergrundprozess ausführen
3. Abfragen und Verarbeitungscode ausführen, um die Ausgabe der Belegung analysieren zu lassen

Jupyter-Notebook erstellen

Der erste Schritt zum Senden von Video von einer Jupyter-Notebook-Instanz besteht darin, das Notebook mit dem im vorherigen Schritt erstellten Dienstkonto zu erstellen.

1. Rufen Sie in der Console die Seite „Vertex AI“ auf. Zu Vertex AI Workbench
2. Klicken Sie auf „Nutzerverwaltete Notebooks“.

3. Klicken Sie auf Neues Notebook > Tensorflow Enterprise 2.6 (mit LTS) > Ohne GPUs.

4. Geben Sie den Namen für das Jupyter-Notebook ein. Weitere Informationen finden Sie unter Namenskonvention für Ressourcen.

5. Klicken Sie auf ERWEITERTE OPTIONEN.
6. Scrollen Sie nach unten zu Berechtigungsbereiche.
7. Entfernen Sie das Häkchen bei der Option Compute Engine-Standarddienstkonto verwenden.
8. Fügen Sie die E-Mail-Adresse des Dienstkontos hinzu, die Sie im vorherigen Schritt erstellt haben. Klicken Sie auf Erstellen.

9. Nachdem die Instanz erstellt wurde, klicken Sie auf JUPYTERLAB ÖFFNEN.

4. Notebook für das 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, um ein Video zu hosten. Sie senden die Streaming-Videodaten vom Notebook-Terminal aus.

Befehlszeilentool „vaictl“ herunterladen

1. Öffnen Sie in der geöffneten JupyterLab-Instanz ein Notebook im Launcher.

2. Laden Sie das Vertex AI Vision-Befehlszeilentool (vaictl), das RTSP-Server-Befehlszeilentool und das OpenCV-Tool mit dem folgenden Befehl in die Notebookzelle 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 das Streaming aufnehmen

Nachdem Sie Ihre Notebookumgebung mit den erforderlichen Befehlszeilentools eingerichtet haben, können Sie eine Beispielvideodatei kopieren und dann mit vaictl die Videodaten an Ihre App für die Belegung analysieren streamen.

Neuen Stream registrieren

1. Klicken Sie im linken Bereich von Vertex AI Vision auf den Tab „Streams“.
2. Klicken Sie oben auf die Schaltfläche „Registrieren“.
3. Gib als Streamnamen „queue-stream“ ein.
4. Wählen Sie unter „Region“ dieselbe Region aus, die Sie beim Erstellen des Notebooks im vorherigen Schritt ausgewählt haben.
5. Klicken Sie auf Registrieren.

Hol dir einen Kaffee, es kann bis zu einer Stunde dauern, bis der Stream registriert ist.

Beispielvideo auf die VM kopieren

1. 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

Video von der VM streamen und Daten in den Stream aufnehmen

1. Um diese lokale Videodatei an den App-Eingabestream zu senden, verwenden Sie in Ihrer Notebookzelle den folgenden Befehl. 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 Cloudstandorte.
• 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'

2. Starten Sie einen rtsp-simple-server, über den wir die Videodatei mit dem rtsp-Protokoll streamen.

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)

3. Video in einem RTSP-Stream mit dem Befehlszeilentool ffmpeg in einer Schleife abspielen

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)

4. Streamen Sie das Video mit dem Befehlszeilentool „vaictl“ von der RTSP-Server-URI zum im vorherigen Schritt erstellten Vertex AI Vision-Stream „queue-stream“.

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.

Zum Tab „Streams“

Videoquelle: Frames-Dataset, Videoquelle

6. Anwendung erstellen

Im ersten Schritt erstellen Sie eine App, die Ihre Daten verarbeitet. Eine App kann als automatisierte Pipeline betrachtet werden, 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 ursprüngliche Stream und der vom KI-Modell verarbeitete Stream) können in einem Media Warehouse gespeichert werden.

In der Google Cloud Console wird eine App 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

1. Rufen Sie die Google Cloud Console auf.
2. Öffnen Sie im Vertex AI Vision-Dashboard den Tab Anwendungen. Gehen Sie zum Tab „Anwendungen“.
3. Klicken Sie auf die Schaltfläche Erstellen.
4. Gib als App-Namen „queue-app“ ein und wähle deine Region aus.
5. Klicken Sie auf Erstellen.

Knoten für Anwendungskomponenten hinzufügen

Nachdem Sie die leere Anwendung erstellt haben, können Sie der App-Graph die drei Knoten hinzufügen:

1. Aufnahmeknoten: Die Streamressource, die Daten aufnimmt, die von einem RTSP-Videoserver gesendet werden, den Sie im Notebook erstellt haben.
2. Verarbeitungsknoten: Das Modell für die Belegungsanalyse, das auf aufgenommene Daten angewendet wird.
3. 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 App in der Konsole Komponentenknoten hinzu.

1. Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. Gehen Sie zum Tab „Anwendungen“.

Daraufhin wird die Grafikvisualisierung der Verarbeitungspipeline angezeigt.

Datenaufnahmeknoten hinzufügen

1. Wenn Sie einen Eingabestreamknoten hinzufügen möchten, wählen Sie im seitlichen Menü im Abschnitt Connectors die Option Streams aus.
2. Wählen Sie im Menü Stream im Bereich Quelle die Option Streams hinzufügen aus.
3. Wähle im Menü Streams hinzufügen die Option queue-stream aus.
4. Klicken Sie auf Streams hinzufügen, um den Stream der App-Grafik hinzuzufügen.

Datenverarbeitungsknoten hinzufügen

1. Wenn Sie den Knoten für das Belegungszählermodell hinzufügen möchten, wählen Sie im seitlichen Menü im Abschnitt Spezielle Modelle die Option Belegungsanalyse aus.
2. Lassen Sie die Standardauswahl Personen. Entfernen Sie das Häkchen bei Fahrzeuge, wenn es bereits ausgewählt ist.

3. Klicken Sie im Bereich „Erweiterte Optionen“ auf Aktive Zonen/Linien erstellen .
4. Zeichnen Sie die aktiven Zonen mit dem Polygon-Tool, um Personen in dieser Zone zu zählen. Beschriften Sie die Zone entsprechend.

5. Klicken Sie oben auf den Zurückpfeil.

6. Klicken Sie auf das Kästchen, um Einstellungen für die Verweildauer hinzuzufügen und Überlastungen zu erkennen.

Datenspeicherknoten hinzufügen

1. Wählen Sie im Abschnitt Connectors des seitlichen Menüs die Option Vision AI Warehouse aus, um den Knoten für den Ausgabespeicherort (Speicher) hinzuzufügen.
2. Klicken Sie auf den Vertex AI Warehouse-Connector, um das Menü zu öffnen, und dann auf Warehouse verbinden.
3. Wählen Sie im Menü Warehouse verbinden die Option Neues Warehouse erstellen aus. Benennen Sie das Warehouse in queue-warehouse um und belassen Sie die TTL-Dauer bei 14 Tagen.
4. 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 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 Name des Datasets lautet „visionai_dataset“.
• Tabelle: Der automatisch erstellte Tabellenname lautet visionai_dataset.APPLICATION_ID.
• Fehlerbehandlung:
• Wenn die Tabelle mit demselben Namen im selben Dataset bereits vorhanden ist, wird sie nicht automatisch erstellt.

1. Öffnen Sie im Vertex AI Vision-Dashboard den Tab Anwendungen. Gehen Sie zum Tab „Anwendungen“.
2. Wählen Sie in der Liste neben dem Namen Ihrer Anwendung die Option App ansehen aus.
3. Wählen Sie auf der Seite „Application Builder“ im Bereich Connectors die Option BigQuery aus.
4. Lassen Sie das Feld BigQuery-Pfad leer.

5. Wählen Sie unter Shop-Metadaten von nur Belegungsanalysen aus und deaktivieren Sie „Streams“.

Der endgültige App-Graph sollte so aussehen:

8. Anwendung zur Verwendung bereitstellen

Nachdem Sie Ihre End-to-End-App mit allen erforderlichen Komponenten erstellt haben, ist der letzte Schritt zur Verwendung der App die Bereitstellung.

1. Öffnen Sie den Tab Anwendungen des Vertex AI Vision-Dashboards. Gehen Sie zum Tab „Anwendungen“.
2. Wählen Sie in der Liste neben der App queue-app die Option App ansehen aus.
3. Klicken Sie auf der Seite Studio auf die Schaltfläche Bereitstellen.
4. Klicken Sie im folgenden Bestätigungsdialogfeld auf Bereitstellen. Die Bereitstellung 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 Ihre Verarbeitungs-App aufgenommen haben, können Sie analysierte Videodaten aufrufen und anhand von Informationen zur Belegung nach Daten suchen.

1. Öffnen Sie im Vertex AI Vision Dashboard den Tab Warehouses. Rufe den Tab „Lagerhäuser“ auf.
2. Suchen Sie in der Liste nach dem Lager „queue-warehouse“ und klicken Sie auf Assets ansehen.
3. Legen Sie im Abschnitt Personenanzahl den Wert Min. auf 1 und den Wert Max. auf 5 fest.
4. Klicken Sie auf Suchen, um verarbeitete Videodaten zu filtern, die im Media Warehouse von Vertex AI Vision gespeichert sind.

Eine Ansicht der gespeicherten Videodaten, die den Suchkriterien in der Google Cloud Console entsprechen.

10. Ausgabe mit BigQuery-Tabelle annotieren und analysieren

1. 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'

2. 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')

3. Rufen Sie den Datenzeitstempel und die Anmerkungsinformationen 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)

4. Fügen Sie die Frames mit dem folgenden Code an:

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>&nbsp;</p>
        '''))
except KeyboardInterrupt:
  print('Stopping Live Monitoring')

5. Beenden Sie die Annotationsaufgabe mit der Schaltfläche Beenden in der Notebook-Menüleiste.

6. Mit dem folgenden Code kannst du einzelne Frames 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

Lizenz

Umfrage

Wie haben Sie diese Anleitung verwendet?

Nur durchgelesen Durchgelesen und die Übungen abgeschlossen

Wie hilfreich war dieses Codelab?

Sehr nützlich Einigermaßen nützlich Nicht nützlich

Wie einfach war dieses Codelab?

Einfach Mittel Schwer