האפליקציה של Vertex AI Vision Queue לזיהוי

1. מטרות

סקירה כללית

ה-Codelab הזה יתמקד ביצירת אפליקציה של Vertex AI Vision מקצה לקצה כדי לעקוב אחרי גודל התור באמצעות קטעי וידאו מתחום הקמעונאות. אנחנו נשתמש בתכונות המובנות של ניתוח נתוני תפוסה במודל שעבר אימון מראש כדי להתמקד בנושאים הבאים:

  • ספירת האנשים שעומדים בתור.
  • ספירת האנשים שמקבלים שירות בדלפק.

מה תלמדו

  • איך ליצור אפליקציה ב-Vertex AI Vision ולפרוס אותה
  • איך להגדיר שידור RTSP באמצעות קובץ וידאו ולהטמיע את הסטרימינג ב-Vertex AI Vision באמצעות vaictl מ-Jupyter Notebook.
  • איך משתמשים במודל 'ניתוח תפוסה' ובתכונות השונות שלו.
  • איך מחפשים סרטונים באחסון שלכם ב-Vertex AI Vision's Media Warehouse.
  • איך לחבר פלט ל-BigQuery, לכתוב שאילתת SQL כדי לחלץ תובנות מפלט ה-JSON של המודל ולהשתמש בפלט כדי להוסיף תוויות לסרטון המקורי ולהוסיף לו הערות.

עלות:

העלות הכוללת של הפעלת שיעור ה-Lab הזה ב-Google Cloud היא כ-2$.

2. לפני שתתחיל

יוצרים פרויקט ומפעילים ממשקי API:

  1. במסוף Google Cloud, בדף בורר הפרויקטים, בוחרים או יוצרים פרויקט ב-Google Cloud. הערה: אם אתם לא מתכננים לשמור את המשאבים שאתם יוצרים בתהליך, צריך ליצור פרויקט במקום לבחור פרויקט קיים. לאחר השלמת השלבים האלה, תוכלו למחוק את הפרויקט ולהסיר את כל המשאבים שמשויכים לפרויקט. מעבר אל בורר הפרויקטים
  2. הקפידו לוודא שהחיוב מופעל בפרויקט שלכם ב-Cloud. איך בודקים אם החיוב מופעל בפרויקט
  3. תפעילו את Compute Engine, Vertex API, Notebook API ו-Vision AI API. הפעלת ממשקי ה-API

יוצרים חשבון שירות:

  1. במסוף Google Cloud, נכנסים לדף Create service account. מעבר לדף Create service account
  2. בוחרים את הפרויקט הרצוי.
  3. כותבים שם בשדה Service account name. השדה Service account ID ימולא במסוף Google Cloud בהתאם לשם הזה. מזינים תיאור בשדה Service account description. לדוגמה, 'חשבון שירות' במדריך למתחילים.
  4. לוחצים על יצירה והמשך.
  5. כדי לתת גישה לפרויקט, מקצים לחשבון השירות את התפקידים הבאים:
  • Vision AI > הכלי Vision AI Editor
  • Compute Engine > אדמין מכונות של Compute (בטא)
  • BigQuery > אדמין ב-BigQuery .

בוחרים תפקיד מהרשימה Select a role. כדי להוסיף תפקידים, לוחצים על Add another role ומוסיפים את כולם.

  1. לוחצים על המשך.
  2. לוחצים על Done כדי לסיים ליצור את חשבון השירות. חשוב לא לסגור את חלון הדפדפן. תשתמשו בה בשלב הבא.

3. הגדרה של Jupyter Notebook

לפני שיוצרים אפליקציה ב'ניתוח תפוסה', צריך לרשום מקור נתונים שאפשר להשתמש בו מאוחר יותר באפליקציה.

במדריך הזה, יוצרים מכונה של Jupyter Notebook שמארחת סרטון, ושולחים את נתוני הווידאו בסטרימינג מה-notebook. אנחנו משתמשים ב-notebook של jupyter כי היא מאפשרת לנו לבצע פקודות מעטפת וגם להריץ קוד מותאם אישית לפני/post-post – במקום אחד שמתאים מאוד לניסויים מהירים. אנחנו נשתמש ב-notebook הזה כדי:

  1. הרצת שרת rtsp כתהליך ברקע
  2. הרצה של פקודת vaictl כתהליך ברקע
  3. הרצת שאילתות וקוד עיבוד כדי לנתח את הפלט של ניתוח התפוסה

יצירת notebook של Jupyter

השלב הראשון בשליחת סרטון ממכונה של Jupyter Notebook הוא יצירת ה-notebook באמצעות חשבון השירות שלנו שנוצר בשלב הקודם.

  1. נכנסים לדף של Vertex AI במסוף. כניסה ל-Vertex AI Workbench
  2. לוחצים על 'notebooks בניהול המשתמש'

65b7112822858dce.png

  1. לוחצים על New Notebook > (מחברת חדשה >) Tensorflow Enterprise 2.6 (עם LTS) > ללא מעבדי GPU

dc156f20b14651d7.png

  1. צריך להזין את השם של notebook של jupyter. מידע נוסף זמין במאמר מוסכמה למתן שמות למשאבים.

b4dbc5fddc37e8d9.png

  1. לוחצים על אפשרויות מתקדמות.
  2. גוללים למטה אל קטעי הרשאות.
  3. מבטלים את הסימון של האפשרות שימוש בחשבון השירות שמוגדר כברירת מחדל ב-Compute Engine
  4. מוסיפים את כתובת האימייל של חשבון השירות שנוצרה בשלב הקודם. ולוחצים על Create.

ec0b9ef00f0ef470.png

  1. אחרי שהמכונה נוצרה, לוחצים על Open JUPYTERLAB.

4. מגדירים מחברת כדי לשדר סרטון בסטרימינג

לפני שיוצרים אפליקציה ב'ניתוח תפוסה', צריך לרשום מקור נתונים שאפשר להשתמש בו מאוחר יותר באפליקציה.

במדריך הזה נשתמש במופע של Jupyter Notebook כדי לארח סרטון, ותשלחו את נתוני הווידאו בסטרימינג מהטרמינל של Notebook.

להורדת כלי שורת הפקודה vaictl

  1. במופע Jupyterlab הפתוח, פותחים את Notebook במרכז האפליקציות.

a6d182923ae4ada3.png

  1. מורידים את כלי שורת הפקודה Vertex AI Vision (vaictl), כלי שורת הפקודה rtsp של השרת rtsp, כלי open-cv באמצעות הפקודה הבאה בתא ה-notebook:
!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. הטמעת קובץ וידאו בסטרימינג

אחרי שמגדירים את סביבת ה-notebook עם כלי שורת הפקודה הנדרשים, אפשר להעתיק קובץ וידאו לדוגמה ואז להשתמש ב-vaictl כדי להעביר את נתוני הסרטון בסטרימינג לאפליקציה לניתוח נתוני תפוסה.

רישום שידור חדש

  1. לוחצים על הכרטיסייה 'שידורים' בחלונית השמאלית של Vertex AI Vision.
  2. לוחצים על לחצן הרישום בחלק העליון של המסך eba418e723916514.png
  3. בשם מקור הנתונים, מזינים 'queue-stream'.
  4. באזור, בוחרים את אותו האזור שנבחר במהלך יצירת ה-notebook בשלב הקודם.
  5. לוחצים על Register

העתקת סרטון לדוגמה ל-VM

  1. ב-notebook, מעתיקים סרטון לדוגמה באמצעות פקודת ה-wget הבאה.
!wget -q https://github.com/vagrantism/interesting-datasets/raw/main/video/collective_activity/seq25_h264.mp4

סטרימינג של סרטונים מ-VM והטמעת הנתונים בסטרימינג

  1. כדי לשלוח את קובץ הווידאו המקומי הזה לזרם הקלט של האפליקציה, משתמשים בפקודה הבאה בתא ה-notebook. צריך להחליף את המשתנים הבאים בערכים:
  • PROJECT_ID: מזהה הפרויקט ב-Google Cloud.
  • LOCATION: מזהה המיקום שלך. לדוגמה, us-central1. למידע נוסף, קראו את המאמר מיקומים ב-Cloud.
  • LOCAL_FILE: שם הקובץ של קובץ וידאו מקומי. לדוגמה, seq25_h264.mp4.
PROJECT_ID='<Your Google Cloud project ID>'
LOCATION='<Your stream location>'
LOCAL_FILE='seq25_h264.mp4'
STREAM_NAME='queue-stream'
  1. הפעלת שרת rtsp-simple- שבו אנחנו משדרים את קובץ הווידאו באמצעות פרוטוקול rtsp
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)
  1. שימוש בכלי שורת הפקודה ffmpeg כדי להפעיל את הסרטון בלופ בזרם rtsp
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)
  1. שימוש בכלי שורת הפקודה vaictl כדי לשדר את הסרטון מ-URI של שרת rtsp אל ׳Vertex AI Vision׳ שלנו שנוצר בשלב הקודם.
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)

עשויות לחלוף כ-100 שניות בין ההתחלה של פעולת הטמעת הנתונים של לפחות רגע לבין הצגת הסרטון במרכז השליטה.

אחרי שהטמעת הנתונים של השידור תהיה זמינה, תוכלו לראות את פיד הווידאו בכרטיסייה Streams במרכז הבקרה של Vertex AI Vision, על ידי בחירה של השידור הרצוי.

כניסה לכרטיסייה 'עדכונים'

1b7aac7d36552f29.png

6. יצירת אפליקציה

השלב הראשון הוא ליצור אפליקציה שמעבדת את הנתונים שלכם. אפשר להתייחס לאפליקציה כצינור עיבוד נתונים אוטומטי שמחבר בין:

  • הטמעת נתונים: הטמעת פיד וידאו מתבצעת בשידור.
  • ניתוח נתונים: אפשר להוסיף מודל AI(ראיית מחשב) אחרי הטמעת הנתונים.
  • אחסון נתונים: אפשר לאחסן במחסן מדיה את שתי הגרסאות של פיד הווידאו (השידור המקורי והשידור שעבר עיבוד על ידי מודל ה-AI).

במסוף Google Cloud, אפליקציה מיוצגת כתרשים.

יצירת אפליקציה ריקה

כדי שאפשר יהיה לאכלס את תרשים האפליקציה, קודם צריך ליצור אפליקציה ריקה.

יוצרים אפליקציה במסוף Google Cloud.

  1. נכנסים למסוף Google Cloud.
  2. פותחים את הכרטיסייה Applications במרכז הבקרה של Vertex AI Vision. עוברים לכרטיסייה 'אפליקציות'.
  3. לוחצים על הלחצן Create. 21ecba7a23e9979e.png
  4. מזינים תור-אפליקציה בתור בתור שם האפליקציה ובוחרים את האזור שלכם.
  5. לוחצים על יצירה.

הוספת צמתים של רכיבי אפליקציה

אחרי שיוצרים את האפליקציה הריקה, אפשר להוסיף את שלושת הצמתים לתרשים האפליקציה:

  1. צומת של הטמעת נתונים: משאב הסטרימינג שמטמיע נתונים שנשלחים משרת וידאו rtsp שיצרתם ב-notebook.
  2. צומת של עיבוד: מודל ניתוח התפוסה שפועל על נתונים שהוטמעו.
  3. צומת של אחסון: מחסן המדיה שבו מאוחסנים סרטונים מעובדים ומשמש כמאגר מטא-נתונים. מאגרי המטא-נתונים כוללים ניתוח נתונים על הטמעת נתוני וידאו, ומידע שהמודלים של ה-AI מסיקים.

אפשר להוסיף צמתים של רכיבים לאפליקציה במסוף.

  1. פותחים את הכרטיסייה Applications במרכז הבקרה של Vertex AI Vision. עוברים לכרטיסייה 'אפליקציות'.

פעולה זו תעביר אתכם לתצוגה חזותית של צינור עיבוד הנתונים.

הוספת צומת הטמעת נתונים

  1. כדי להוסיף צומת של מקור קלט, בוחרים באפשרות סטרימינג בקטע מחברים בתפריט הצד.
  2. בקטע מקור בתפריט סטרימינג שנפתח, בוחרים באפשרות הוספת מקורות נתונים.
  3. בתפריט הוספת סטרימינג, בוחרים באפשרות סטרימינג בתור.
  4. כדי להוסיף את מקור הנתונים לתרשים האפליקציה, לוחצים על הוספת מקורות נתונים.

הוספת צומת לעיבוד נתונים

  1. כדי להוסיף את הצומת של מודל מספר התפוסה, בוחרים באפשרות ניתוח תפוסה בקטע מודלים מיוחדים בתפריט הצד.
  2. משאירים את בחירות ברירת המחדל אנשים. מבטלים את הסימון של האפשרות Vehicles (כלי רכב) אם האפשרות הזו כבר מסומנת.

618b0c9dc671bae3.png

  1. בקטע Advanced options (אפשרויות מתקדמות), לוחצים על Create Active Zones/Lines (יצירת Zones/Lines)5b2f31235603e05d.png.
  2. משרטטים את האזורים הפעילים באמצעות כלי הפוליגון כדי לספור אנשים שנמצאים בתחום זה. מסמנים את האזור בהתאם.

50281a723650491f.png

  1. לוחצים על 'חץ חזרה' למעלה.

2bf0ff4d029d29eb.png

  1. מוסיפים הגדרות לזמן שהייה כדי לזהות גודש בלחיצה על תיבת הסימון.

c067fa256ca5bb96.png

הוספת צומת של מאגר נתונים

  1. כדי להוסיף את צומת יעד הפלט (אחסון), בוחרים באפשרות VIsion AI Warehouse בקטע מחברים בתפריט הצד.
  2. לוחצים על Vertex AI warehouse כדי לפתוח את התפריט שלו ולוחצים על Connect warehouse.
  3. בתפריט קישור מחסן, בוחרים באפשרות יצירת מחסן חדש. נותנים למחסן את השם מחסן בתור (תור המחסן), ומשאירים את משך ה-TTL אחרי 14 ימים.
  4. לוחצים על הלחצן יצירה כדי להוסיף את המחסן.

7. חיבור פלט לטבלה ב-BigQuery

כשמוסיפים מחבר BigQuery לאפליקציית Vertex AI Vision, כל הפלט של המודלים של האפליקציות המקושרות יוטמע בטבלת היעד.

אתם יכולים ליצור טבלה משלכם ב-BigQuery ולציין אותה כשמוסיפים מחבר BigQuery לאפליקציה, או מאפשרים לפלטפורמת האפליקציה Vertex AI Vision ליצור את הטבלה באופן אוטומטי.

יצירת טבלה באופן אוטומטי

אם מאפשרים לפלטפורמת האפליקציה Vertex AI Vision ליצור את הטבלה באופן אוטומטי, אפשר להגדיר את האפשרות הזו כשמוסיפים את הצומת של מחבר BigQuery.

אם רוצים להשתמש ביצירת טבלה באופן אוטומטי, התנאים הבאים של מערך הנתונים והטבלה חלים:

  • מערך נתונים: השם של מערך הנתונים שנוצר באופן אוטומטי הוא visionai_dataset.
  • טבלה: שם הטבלה שנוצרת באופן אוטומטי הוא visionai_dataset.APPLICATION_ID.
  • טיפול בשגיאות:
  • אם קיימת טבלה עם אותו שם לאותו מערך נתונים, לא תתבצע יצירה אוטומטית.
  1. פותחים את הכרטיסייה Applications במרכז הבקרה של Vertex AI Vision. עוברים לכרטיסייה 'אפליקציות'.
  2. בוחרים באפשרות הצגת האפליקציה לצד שם האפליקציה מהרשימה.
  3. בדף של יוצר האפליקציות, בוחרים באפשרות BigQuery בקטע Connectors (מחברים).
  4. משאירים את השדה BigQuery path (נתיב BigQuery).

ee0b67d4ab2263d.png

  1. בשדה המטא-נתונים של החנות מ:, בוחרים רק את 'תפוסה Analytics' ומבטלים את הסימון של עדכוני התוכן.

תרשים האפליקציה הסופי אמור להיראות כך:

da0a1a049843572f.png

8. פריסת האפליקציה לשימוש

אחרי שיוצרים אפליקציה מקצה לקצה שכוללת את כל הרכיבים הדרושים, השלב האחרון בשימוש באפליקציה הוא לפרוס אותה.

  1. פותחים את הכרטיסייה Applications במרכז הבקרה של Vertex AI Vision. עוברים לכרטיסייה 'אפליקציות'.
  2. בוחרים באפשרות הצגת האפליקציה לצד האפליקציה אפליקציה לתור ברשימה.
  3. בדף Studio, לוחצים על הלחצן פריסה.
  4. בתיבת הדו-שיח הבאה לאישור, לוחצים על Deploy (פריסה). פעולת הפריסה עשויה להימשך מספר דקות. בסיום הפריסה יופיעו סימני וי ירוקים ליד הצמתים. dc514d9b9f35099d.png

9. חיפוש תוכן סרטונים במחסן האחסון

אחרי שמטמיעים נתוני וידאו באפליקציית העיבוד, אפשר לראות את נתוני הסרטונים שנותחו ולחפש בנתונים על סמך ניתוח נתוני תפוסה.

  1. פותחים את הכרטיסייה Warehouses במרכז הבקרה של Vertex AI Vision. כניסה לכרטיסייה 'מחסנים'
  2. מאתרים את מחסן המחסנים בתור ברשימה ולוחצים על הצגת נכסים.
  3. בקטע ספירת אנשים, מגדירים את הערך המינימום ל-1, ואת הערך המקסימלי ל-5.
  4. כדי לסנן נתוני סרטונים מעובדים שמאוחסנים ב-Media warehouse של Vertex AI Vision, לוחצים על חיפוש.

a0e5766262443d6c.png

תצוגה של נתוני סרטונים מאוחסנים שתואמים לקריטריוני החיפוש במסוף Google Cloud.

10. הוספת הערות וניתוח הפלט באמצעות טבלה ב-BigQuery

  1. מאתחלים את המשתנים הבאים בתא ב-notebook.
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'
  1. עכשיו נצלם את הפריימים מהזרם rtsp באמצעות הקוד הבא:
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')
  1. מושכים את חותמת הזמן של הנתונים ואת פרטי ההערות מטבלת ה-BigQuery ויוצרים ספרייה שבה יאוחסנו התמונות של המסגרת:
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)
  1. מוסיפים הערות למסגרות באמצעות הקוד הבא:
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')

9426ffe2376f0a7d.png

  1. כדי להפסיק את משימת ההערות, לוחצים על Stop (עצירה) בסרגל התפריטים של ה-notebook.

6c19cb00dcb28894.png

  1. ניתן לחזור למסגרות ספציפיות באמצעות הקוד הבא:
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%')))

78b63b546a4c883b.png

11. מזל טוב

כל הכבוד, סיימת את שיעור ה-Lab

פינוי מקום

כדי להימנע מצבירת חיובים בחשבון Google Cloud על המשאבים שנעשה בהם שימוש במדריך הזה, צריך למחוק את הפרויקט שמכיל את המשאבים או לשמור את הפרויקט ולמחוק את המשאבים הספציפיים.

מחיקת הפרויקט

מחיקת משאבים בודדים

מקורות מידע

https://cloud.google.com/vision-ai/docs/overview

https://cloud.google.com/vision-ai/docs/occupancy-count-tutorial

רישיון

סקר

איך השתמשת במדריך הזה?

לקריאה בלבד קראתי אותו והשלמת את התרגילים

עד כמה ה-Codelab הזה היה שימושי?

מועיל מאוד מועיל במידה בינונית לא מועיל

עד כמה היה קל לעקוב אחרי ה-Codelab הזה?

קל בינונית קשה