1. วัตถุประสงค์
ภาพรวม
Codelab นี้จะมุ่งเน้นที่การสร้างแอปพลิเคชัน Vertex AI Vision จากต้นทางถึงปลายทางเพื่อตรวจสอบขนาดคิวโดยใช้ฟุตเทจวิดีโอสำหรับร้านค้าปลีก เราจะใช้ฟีเจอร์ในตัวของโมเดลเฉพาะทางที่ฝึกไว้ล่วงหน้าข้อมูลวิเคราะห์อัตราการเข้าพักเพื่อบันทึกสิ่งต่อไปนี้
- นับจำนวนคนที่อยู่ในคิว
- นับจำนวนคนที่จะรับบริการหน้าเคาน์เตอร์
สิ่งที่คุณจะได้เรียนรู้
- วิธีสร้างแอปพลิเคชันใน Vertex AI Vision และทำให้ใช้งานได้
- วิธีตั้งค่าสตรีม RTSP โดยใช้ไฟล์วิดีโอและส่งผ่านข้อมูลสตรีมไปยัง Vertex AI Vision โดยใช้ Vaictl จากสมุดบันทึก Jupyter
- วิธีใช้โมเดลการวิเคราะห์อัตราการเข้าพักและฟีเจอร์ต่างๆ
- วิธีค้นหาวิดีโอใน Media Warehouse ของ Vertex AI Vision ในพื้นที่เก็บข้อมูล
- วิธีเชื่อมต่อเอาต์พุตไปยัง BigQuery ให้เขียนการค้นหา SQL เพื่อดึงข้อมูลเชิงลึกจากเอาต์พุต JSON ของโมเดล และใช้เอาต์พุตเพื่อติดป้ายกำกับและใส่คำอธิบายประกอบวิดีโอต้นฉบับ
ต้นทุน:
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองบน Google Cloud นี้อยู่ที่ประมาณ $2
2. ก่อนที่คุณจะเริ่มต้น
สร้างโปรเจ็กต์และเปิดใช้ API โดยทำดังนี้
- ในคอนโซล Google Cloud ให้เลือกหรือสร้างโปรเจ็กต์ Google Cloud ในหน้าตัวเลือกโปรเจ็กต์ หมายเหตุ: หากไม่มีแผนที่จะเก็บทรัพยากรที่สร้างในกระบวนการนี้ ให้สร้างโปรเจ็กต์แทนการเลือกโปรเจ็กต์ที่มีอยู่ หลังจากเสร็จสิ้นขั้นตอนเหล่านี้แล้ว คุณจะลบโปรเจ็กต์ซึ่งเป็นการนำทรัพยากรทั้งหมดที่เชื่อมโยงกับโปรเจ็กต์ออกได้ ไปที่ตัวเลือกโปรเจ็กต์
- ตรวจสอบว่าเปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ที่อยู่ในระบบคลาวด์แล้ว ดูวิธีตรวจสอบว่าเปิดใช้การเรียกเก็บเงินในโปรเจ็กต์แล้ว
- เปิดใช้ Compute Engine, Vertex API, Notebook API และ Vision AI API เปิดใช้ API
สร้างบัญชีบริการ
- ในคอนโซล Google Cloud ให้ไปที่หน้าสร้างบัญชีบริการ ไปที่ "สร้างบัญชีบริการ"
- เลือกโปรเจ็กต์
- ป้อนชื่อลงในช่องชื่อบัญชีบริการ คอนโซล Google Cloud จะกรอกข้อมูลในช่องรหัสบัญชีบริการตามชื่อนี้ กรอกคำอธิบายในช่องคำอธิบายบัญชีบริการ เช่น บัญชีบริการสำหรับการเริ่มต้นอย่างรวดเร็ว
- คลิกสร้างและต่อไป
- หากต้องการให้สิทธิ์เข้าถึงโปรเจ็กต์ โปรดมอบบทบาทต่อไปนี้ให้กับบัญชีบริการของคุณ
- AI ด้านการมองเห็น > ผู้แก้ไข Vision AI
- Compute Engine > ผู้ดูแลระบบอินสแตนซ์คอมพิวเตอร์ (เบต้า)
- BigQuery > ผู้ดูแลระบบ BigQuery
เลือกบทบาทในรายการเลือกบทบาท สําหรับบทบาทเพิ่มเติม ให้คลิกเพิ่มบทบาทอื่น แล้วเพิ่มบทบาทอื่น
- คลิกต่อไป
- คลิกเสร็จสิ้นเพื่อสร้างบัญชีบริการให้เสร็จสิ้น อย่าปิดหน้าต่างเบราว์เซอร์ของคุณ ซึ่งคุณจะต้องใช้ในขั้นตอนถัดไป
3. ตั้งค่าสมุดบันทึก Jupyter
ก่อนที่จะสร้างแอปในข้อมูลวิเคราะห์อัตราการเข้าพัก คุณต้องลงทะเบียนสตรีมซึ่งแอปจะใช้ในภายหลังได้
ในบทแนะนำนี้ คุณจะสร้างอินสแตนซ์สมุดบันทึก Jupyter ที่โฮสต์วิดีโอ แล้วส่งข้อมูลสตรีมวิดีโอนั้นจากสมุดบันทึก เราใช้สมุดบันทึก Jupyter เนื่องจากมอบความยืดหยุ่นในการเรียกใช้คำสั่ง Shell รวมถึงเรียกใช้โค้ดประมวลผลก่อน/หลังที่กำหนดเองได้ในที่เดียวซึ่งเหมาะสำหรับการทดสอบที่รวดเร็ว เราจะใช้สมุดบันทึกนี้เพื่อทำสิ่งต่อไปนี้
- เรียกใช้เซิร์ฟเวอร์ rtsp เป็นกระบวนการเบื้องหลัง
- เรียกใช้คำสั่ง vaictl เป็นกระบวนการเบื้องหลัง
- เรียกใช้การค้นหาและประมวลผลโค้ดเพื่อวิเคราะห์เอาต์พุตของข้อมูลวิเคราะห์เกี่ยวกับการเข้าใช้
สร้างสมุดบันทึก Jupyter
ขั้นตอนแรกในการส่งวิดีโอจากอินสแตนซ์สมุดบันทึก Jupyter คือการสร้างสมุดบันทึกด้วยบัญชีบริการของเราซึ่งสร้างในขั้นตอนก่อนหน้า
- ในคอนโซล ให้ไปที่หน้า Vertex AI ไปที่ Vertex AI Workbench
- คลิกสมุดบันทึกที่จัดการโดยผู้ใช้
- คลิกสมุดบันทึกใหม่ > Tensorflow Enterprise 2.6 (มี LTS) > ไม่ใช้ GPU
- ป้อนชื่อสมุดบันทึก Jupyter ดูข้อมูลเพิ่มเติมได้ที่แบบแผนการตั้งชื่อทรัพยากร
- คลิกตัวเลือกขั้นสูง
- เลื่อนลงไปที่ส่วนสิทธิ์
- ยกเลิกการเลือกใช้บัญชีบริการเริ่มต้นของ Compute Engine
- เพิ่มอีเมลบัญชีบริการที่สร้างขึ้นในขั้นตอนก่อนหน้า แล้วคลิกสร้าง
- เมื่อสร้างอินสแตนซ์แล้ว ให้คลิกเปิด JUPYTERLAB
4. ตั้งค่าสมุดบันทึกเพื่อสตรีมวิดีโอ
ก่อนที่จะสร้างแอปในข้อมูลวิเคราะห์อัตราการเข้าพัก คุณต้องลงทะเบียนสตรีมซึ่งแอปจะใช้ในภายหลังได้
ในบทแนะนำนี้ เราจะใช้อินสแตนซ์ของสมุดบันทึก Jupyter เพื่อโฮสต์วิดีโอ แล้วคุณส่งข้อมูลสตรีมวิดีโอนั้นจากเทอร์มินัลของสมุดบันทึก
ดาวน์โหลดเครื่องมือบรรทัดคำสั่ง vaictl
- ในอินสแตนซ์ Jupyterlab ที่เปิดอยู่ ให้เปิด Notebook จาก Launcher
- ดาวน์โหลดเครื่องมือบรรทัดคำสั่ง Vertex AI Vision (vaictl), เครื่องมือบรรทัดคำสั่งของเซิร์ฟเวอร์ RTSP, เครื่องมือ open-cv โดยใช้คำสั่งต่อไปนี้ในเซลล์สมุดบันทึก
!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. นำเข้าไฟล์วิดีโอสำหรับสตรีมมิง
หลังจากตั้งค่าสภาพแวดล้อมสมุดบันทึกด้วยเครื่องมือบรรทัดคำสั่งที่จำเป็นแล้ว คุณจะคัดลอกไฟล์วิดีโอตัวอย่างแล้วใช้ vaictl เพื่อสตรีมข้อมูลวิดีโอไปยังแอปข้อมูลวิเคราะห์เกี่ยวกับการเข้าใช้ได้
ลงทะเบียนสตรีมใหม่
- คลิกแท็บสตรีมในแผงด้านซ้ายของ Vertex AI Vision
- คลิกปุ่มลงทะเบียนที่ด้านบน
- ป้อน ‘queue-stream' ในชื่อสตรีม
- ในภูมิภาค ให้เลือกภูมิภาคเดียวกันที่เลือกไว้ระหว่างการสร้างสมุดบันทึกในขั้นตอนก่อนหน้า
- คลิกลงทะเบียน
คัดลอกวิดีโอตัวอย่างไปยัง VM
- ในสมุดบันทึก ให้คัดลอกวิดีโอตัวอย่างด้วยคำสั่ง wget ต่อไปนี้
!wget -q https://github.com/vagrantism/interesting-datasets/raw/main/video/collective_activity/seq25_h264.mp4
สตรีมวิดีโอจาก VM และนำเข้าข้อมูลไปยังสตรีม
- หากต้องการส่งไฟล์วิดีโอในเครื่องนี้ไปยังสตรีมอินพุตแอป ให้ใช้คำสั่งต่อไปนี้ในเซลล์สมุดบันทึก คุณต้องแทนที่ตัวแปรต่อไปนี้
- PROJECT_ID: รหัสโครงการ Google Cloud
- สถานที่ตั้ง: รหัสสถานที่ตั้งของคุณ เช่น us-central1 ดูข้อมูลเพิ่มเติมได้ที่ตำแหน่งระบบคลาวด์
- 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'
- เริ่ม rtsp-simple-server ที่เราสตรีมไฟล์วิดีโอด้วยโปรโตคอล 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)
- ใช้เครื่องมือบรรทัดคำสั่ง 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)
- ใช้เครื่องมือบรรทัดคำสั่ง vaictl เพื่อสตรีมวิดีโอจาก URI ของเซิร์ฟเวอร์ RTSP ไปยังสตรีม "queue-stream" สำหรับ 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 วินาทีระหว่างที่เริ่มดำเนินการนำเข้าข้อมูลส่วนวิดีโอกับวิดีโอที่ปรากฏในแดชบอร์ด
หลังจากการส่งผ่านข้อมูลสตรีมพร้อมใช้งานแล้ว คุณจะดูฟีดวิดีโอในแท็บสตรีมของแดชบอร์ด Vertex AI Vision ได้โดยเลือกสตรีมคิวสตรีม
6. สร้างแอปพลิเคชัน
ขั้นตอนแรกคือการสร้างแอปที่ประมวลผลข้อมูล แอปอาจเรียกได้ว่าเป็นไปป์ไลน์อัตโนมัติที่เชื่อมต่อสิ่งต่างๆ ต่อไปนี้
- การนำเข้าข้อมูล: จะมีการส่งผ่านข้อมูลฟีดวิดีโอไปยังสตรีม
- การวิเคราะห์ข้อมูล: คุณจะเพิ่มโมเดล AI(คอมพิวเตอร์วิทัศน์) ได้หลังจากการส่งผ่านข้อมูล
- พื้นที่เก็บข้อมูล: ฟีดวิดีโอทั้ง 2 เวอร์ชัน (สตรีมดั้งเดิมและสตรีมที่ประมวลผลโดยโมเดล AI) สามารถจัดเก็บในคลังสื่อได้
ในคอนโซล Google Cloud แอปจะแสดงเป็นกราฟ
สร้างแอปเปล่า
ก่อนที่จะใส่ข้อมูลกราฟของแอป คุณต้องสร้างแอปเปล่าก่อน
สร้างแอปในคอนโซล Google Cloud
- ไปที่คอนโซล Google Cloud
- เปิดแท็บ Applications ของแดชบอร์ด Vertex AI Vision ไปที่แท็บแอปพลิเคชัน
- คลิกปุ่มสร้าง
- ป้อน "queue-app" เป็นชื่อแอปและเลือกภูมิภาค
- คลิกสร้าง
เพิ่มโหนดคอมโพเนนต์แอป
หลังจากสร้างแอปพลิเคชันเปล่าแล้ว คุณเพิ่มโหนด 3 โหนดดังกล่าวลงในกราฟแอปได้โดยทำดังนี้
- โหนดการส่งผ่านข้อมูล: ทรัพยากรของสตรีมที่นำเข้าข้อมูลที่ส่งจากเซิร์ฟเวอร์วิดีโอ RTSP ที่คุณสร้างในสมุดบันทึก
- โหนดการประมวลผล: โมเดลข้อมูลวิเคราะห์เกี่ยวกับการเข้าใช้ที่ดำเนินการกับข้อมูลที่นำเข้า
- โหนดพื้นที่เก็บข้อมูล: คลังสื่อที่จัดเก็บวิดีโอที่ประมวลผลแล้วและทำหน้าที่เป็นที่เก็บข้อมูลเมตา ข้อมูลเมตาที่จัดเก็บประกอบด้วยข้อมูลวิเคราะห์เกี่ยวกับข้อมูลวิดีโอที่นำเข้า และข้อมูลที่อนุมานโดยโมเดล AI
เพิ่มโหนดคอมโพเนนต์ลงในแอปในคอนโซล
- เปิดแท็บ Applications ของแดชบอร์ด Vertex AI Vision ไปที่แท็บแอปพลิเคชัน
ระบบจะนำคุณไปยังภาพกราฟของไปป์ไลน์การประมวลผล
เพิ่มโหนดการนำเข้าข้อมูล
- หากต้องการเพิ่มโหนดสตรีมอินพุต ให้เลือกตัวเลือกสตรีมในส่วนเครื่องมือเชื่อมต่อของเมนูด้านข้าง
- ในส่วนแหล่งที่มาของเมนูสตรีมที่เปิดขึ้น ให้เลือกเพิ่มสตรีม
- ในเมนูเพิ่มสตรีม ให้เลือกคิว-สตรีม
- หากต้องการเพิ่มสตรีมลงในกราฟของแอป ให้คลิกเพิ่มสตรีม
เพิ่มโหนดการประมวลผลข้อมูล
- หากต้องการเพิ่มโหนดโมเดลจำนวนการเข้าใช้ ให้เลือกตัวเลือกข้อมูลวิเคราะห์เกี่ยวกับอัตราการเข้าพักในส่วนโมเดลเฉพาะทางของเมนูด้านข้าง
- คงการเลือกบุคคลซึ่งเป็นค่าเริ่มต้นไว้ ยกเลิกการเลือกยานพาหนะหากเลือกไว้แล้ว
- ในส่วนตัวเลือกขั้นสูง ให้คลิกที่ Create Active Zones/Lines
- วาดโซนที่มีการใช้งานโดยใช้เครื่องมือรูปหลายเหลี่ยมเพื่อนับผู้คนในโซนนั้น ติดป้ายกำกับโซนให้สอดคล้องกัน
- คลิกลูกศรย้อนกลับที่ด้านบน
- เพิ่มการตั้งค่าสำหรับเวลาที่ไม่มีการขยับเมาส์เพื่อตรวจหาความคับคั่งโดยคลิกช่องทำเครื่องหมาย
เพิ่มโหนดพื้นที่เก็บข้อมูล
- หากต้องการเพิ่มโหนดปลายทางเอาต์พุต (พื้นที่เก็บข้อมูล) ให้เลือกตัวเลือก VIsion AI Warehouse ในส่วน เครื่องมือเชื่อมต่อ ของเมนูด้านข้าง
- คลิก Vertex AI Warehouse Connector เพื่อเปิดเมนู คลิกเชื่อมต่อคลังสินค้า
- ในเมนูเชื่อมต่อคลังสินค้า ให้เลือกสร้างคลังสินค้าใหม่ ตั้งชื่อคลังสินค้าว่า queue-warehouse และคงระยะเวลา TTL ไว้ที่ 14 วัน
- คลิกปุ่มสร้างเพื่อเพิ่มคลังสินค้า
7. เชื่อมต่อเอาต์พุตไปยังตาราง BigQuery
เมื่อเพิ่มเครื่องมือเชื่อมต่อ BigQuery ลงในแอป Vertex AI Vision แล้ว ระบบจะนำเข้าเอาต์พุตของโมเดลแอปที่เชื่อมต่อทั้งหมดไปยังตารางเป้าหมาย
คุณจะสร้างตาราง BigQuery ของคุณเองและระบุตารางดังกล่าวเมื่อเพิ่มเครื่องมือเชื่อมต่อ BigQuery ลงในแอป หรือจะให้แพลตฟอร์มแอป Vertex AI Vision สร้างตารางให้โดยอัตโนมัติก็ได้
การสร้างตารางอัตโนมัติ
หากอนุญาตให้แพลตฟอร์มแอป Vertex AI Vision สร้างตารางโดยอัตโนมัติ คุณจะระบุตัวเลือกนี้ได้เมื่อเพิ่มโหนดเครื่องมือเชื่อมต่อ BigQuery
ระบบจะใช้ชุดข้อมูลและเงื่อนไขตารางต่อไปนี้หากคุณต้องการใช้การสร้างตารางอัตโนมัติ
- ชุดข้อมูล: ชื่อชุดข้อมูลที่สร้างโดยอัตโนมัติคือ visionai_dataset
- ตาราง: ชื่อตารางที่สร้างโดยอัตโนมัติคือ visionai_dataset.APPLICATION_ID
- การจัดการข้อผิดพลาด:
- หากมีตารางที่มีชื่อเดียวกันภายใต้ชุดข้อมูลเดียวกัน จะไม่มีการสร้างอัตโนมัติเกิดขึ้น
- เปิดแท็บ Applications ของแดชบอร์ด Vertex AI Vision ไปที่แท็บแอปพลิเคชัน
- เลือกดูแอปถัดจากชื่อแอปพลิเคชันจากรายการ
- ในหน้าเครื่องมือสร้างแอปพลิเคชัน ให้เลือก BigQuery จากส่วนเครื่องมือเชื่อมต่อ
- เว้นช่องเส้นทาง BigQuery ว่างไว้
- ในข้อมูลเมตาของร้านค้าจาก: ให้เลือกเฉพาะ "ข้อมูลวิเคราะห์อัตราการเข้าพัก" แล้วยกเลิกการเลือกสตรีม
กราฟแอปขั้นสุดท้ายควรมีลักษณะดังนี้
8. ทำให้แอปใช้งานได้เพื่อการใช้งาน
หลังจากสร้างแอปแบบต้นทางถึงปลายทางพร้อมคอมโพเนนต์ที่จำเป็นทั้งหมดแล้ว ขั้นตอนสุดท้ายในการใช้แอปก็คือการทำให้แอปใช้งานได้
- เปิดแท็บ Applications ของแดชบอร์ด Vertex AI Vision ไปที่แท็บแอปพลิเคชัน
- เลือกดูแอปถัดจากแอป queue-app ในรายการ
- จากหน้า Studio ให้คลิกปุ่มทำให้ใช้งานได้
- ในกล่องโต้ตอบการยืนยันต่อไปนี้ ให้คลิกทำให้ใช้งานได้ การดำเนินการทำให้ใช้งานได้อาจใช้เวลาหลายนาทีจึงจะเสร็จสมบูรณ์ หลังจากการทำให้ใช้งานได้เสร็จสิ้นแล้ว เครื่องหมายถูกสีเขียวจะปรากฏขึ้นข้างโหนด
9. ค้นหาเนื้อหาวิดีโอในคลังพื้นที่เก็บข้อมูล
หลังจากนำเข้าข้อมูลวิดีโอลงในแอปการประมวลผลแล้ว คุณจะดูข้อมูลวิดีโอที่วิเคราะห์แล้ว และค้นหาข้อมูลตามข้อมูลการวิเคราะห์อัตราการเข้าพักได้
- เปิดแท็บ Warehouses ของแดชบอร์ด Vertex AI Vision ไปที่แท็บคลังสินค้า
- ค้นหาคลังสินค้าคลังคิวในรายการ แล้วคลิกดูเนื้อหา
- ในส่วนจำนวนผู้คน ให้ตั้งค่าต่ำสุดเป็น 1 และค่าสูงสุดเป็น 5
- หากต้องการกรองข้อมูลวิดีโอที่ประมวลผลแล้วที่จัดเก็บไว้ใน Media Warehouse ของ Vertex AI Vision ให้คลิกค้นหา
มุมมองข้อมูลวิดีโอที่จัดเก็บไว้ซึ่งตรงกับเกณฑ์การค้นหาในคอนโซล Google Cloud
10. ใส่คำอธิบายประกอบและวิเคราะห์เอาต์พุตโดยใช้ตาราง BigQuery
- ในสมุดบันทึก ให้เริ่มต้นตัวแปรต่อไปนี้ในเซลล์
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'
- ตอนนี้เราจะจับเฟรมจากสตรีม 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')
- ดึงข้อมูลการประทับเวลาและข้อมูลคำอธิบายประกอบจากตาราง 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)
- อธิบายเฟรมโดยใช้โค้ดต่อไปนี้
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')
- หยุดงานคำอธิบายประกอบโดยใช้ปุ่มหยุดในแถบเมนูสมุดบันทึก
- คุณสามารถกลับไปที่เฟรมแต่ละเฟรมได้โดยใช้โค้ดต่อไปนี้
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. ขอแสดงความยินดี
ยินดีด้วย คุณใช้งานห้องทดลองเสร็จแล้ว
ล้างข้อมูล
เพื่อหลีกเลี่ยงไม่ให้เกิดการเรียกเก็บเงินกับบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ในบทแนะนำนี้ โปรดลบโปรเจ็กต์ที่มีทรัพยากรดังกล่าวหรือเก็บโปรเจ็กต์ไว้และลบทรัพยากรแต่ละรายการ
ลบโปรเจ็กต์
ลบทรัพยากรแต่ละรายการ
แหล่งข้อมูล
https://cloud.google.com/vision-ai/docs/overview
https://cloud.google.com/vision-ai/docs/occupancy-count-tutorial