1. วัตถุประสงค์
ภาพรวม
Codelab นี้จะมุ่งเน้นที่การสร้างแอปพลิเคชัน Vertex AI Vision จากต้นทางถึงปลายทางเพื่อตรวจสอบขนาดคิวโดยใช้ฟุตเทจวิดีโอสำหรับร้านค้าปลีก เราจะใช้ฟีเจอร์ข้อมูลวิเคราะห์อัตราการเข้าพักในตัวของโมเดลเฉพาะทางที่ผ่านการฝึกล่วงหน้าเพื่อบันทึกข้อมูลต่อไปนี้
- นับจํานวนผู้ที่รอคิว
- นับจํานวนลูกค้าที่รับบริการที่เคาน์เตอร์
สิ่งที่คุณจะได้เรียนรู้
- วิธีสร้างแอปพลิเคชันใน Vertex AI Vision และติดตั้งใช้งาน
- วิธีตั้งค่าสตรีม RTSP โดยใช้ไฟล์วิดีโอและส่งผ่านข้อมูลสตรีมไปยัง Vertex AI Vision โดยใช้ vaictl จาก Jupyter Notebook
- วิธีใช้รูปแบบข้อมูลวิเคราะห์อัตราการเข้าพักและฟีเจอร์ต่างๆ
- วิธีค้นหาวิดีโอในพื้นที่เก็บข้อมูล Media Warehouse ของ Vertex AI Vision
- วิธีเชื่อมต่อเอาต์พุตกับ BigQuery, เขียนการค้นหา SQL เพื่อดึงข้อมูลเชิงลึกจากเอาต์พุต JSON ของโมเดล และใช้เอาต์พุตเพื่อติดป้ายกำกับและกำกับวิดีโอต้นฉบับ
ต้นทุน:
ค่าใช้จ่ายทั้งหมดในการใช้งานห้องทดลองนี้ใน Google Cloud อยู่ที่ประมาณ 60 บาท
2. ก่อนที่คุณจะเริ่มต้น
สร้างโปรเจ็กต์และเปิดใช้ API
- ในคอนโซล Google Cloud ให้เลือกหรือสร้างโปรเจ็กต์ Google Cloud ในหน้าตัวเลือกโปรเจ็กต์ หมายเหตุ: หากไม่มีแผนที่จะเก็บทรัพยากรที่สร้างในกระบวนการนี้ ให้สร้างโปรเจ็กต์แทนการเลือกโปรเจ็กต์ที่มีอยู่ หลังจากทำตามขั้นตอนเหล่านี้แล้ว คุณจะลบโปรเจ็กต์ซึ่งเป็นการนำทรัพยากรทั้งหมดที่เชื่อมโยงกับโปรเจ็กต์นี้ออกได้ ไปที่ตัวเลือกโปรเจ็กต์
- ตรวจสอบว่าเปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ Cloud แล้ว ดูวิธีตรวจสอบว่าเปิดใช้การเรียกเก็บเงินในโปรเจ็กต์แล้ว
- เปิดใช้ Compute Engine, Vertex API, Notebook API และ Vision AI API เปิดใช้ API
สร้างบัญชีบริการ
- ในคอนโซล Google Cloud ให้ไปที่หน้าสร้างบัญชีบริการ ไปที่ "สร้างบัญชีบริการ"
- เลือกโปรเจ็กต์
- ป้อนชื่อในช่องชื่อบัญชีบริการ คอนโซล Google Cloud จะกรอกข้อมูลในช่องรหัสบัญชีบริการตามชื่อนี้ ป้อนคำอธิบายในช่องคำอธิบายบัญชีบริการ เช่น บัญชีบริการสำหรับการเริ่มต้นอย่างรวดเร็ว
- คลิกสร้างและต่อไป
- หากต้องการให้สิทธิ์เข้าถึงโปรเจ็กต์ ให้มอบหมายบทบาทต่อไปนี้ให้กับบัญชีบริการ
- Vision AI > Vision AI Editor
- Compute Engine > ผู้ดูแลระบบอินสแตนซ์ Compute (เบต้า)
- BigQuery > ผู้ดูแลระบบ BigQuery
เลือกบทบาทในรายการเลือกบทบาท หากต้องการเพิ่มบทบาท ให้คลิกเพิ่มบทบาทอื่น แล้วเพิ่มบทบาทเพิ่มเติมแต่ละบทบาท
- คลิกต่อไป
- คลิกเสร็จสิ้นเพื่อสร้างบัญชีบริการให้เสร็จสมบูรณ์ อย่าปิดหน้าต่างเบราว์เซอร์ของคุณ คุณจะต้องใช้รหัสนี้ในขั้นตอนถัดไป
3. ตั้งค่าสมุดบันทึก Jupyter
ก่อนสร้างแอปในข้อมูลวิเคราะห์อัตราการเข้าพัก คุณต้องลงทะเบียนสตรีมที่แอปจะใช้ในภายหลังได้
ในบทแนะนำนี้ คุณจะได้สร้างอินสแตนซ์ Jupyter Notebook ที่โฮสต์วิดีโอ และส่งข้อมูลสตรีมมิงวิดีโอจากสมุดบันทึก เราใช้ Jupyter Notebook เนื่องจากมีความยืดหยุ่นในการเรียกใช้คำสั่งเชลล์ รวมถึงเรียกใช้โค้ดการประมวลผลก่อน/หลังการประมวลผลที่กำหนดเองในที่เดียว ซึ่งเหมาะอย่างยิ่งสำหรับการทดลองอย่างรวดเร็ว เราจะใช้โน้ตบุ๊กนี้เพื่อดำเนินการต่อไปนี้
- เรียกใช้เซิร์ฟเวอร์ rtsp เป็นกระบวนการทำงานเบื้องหลัง
- เรียกใช้คำสั่ง vaictl เป็นกระบวนการทำงานเบื้องหลัง
- เรียกใช้การค้นหาและประมวลผลโค้ดเพื่อวิเคราะห์เอาต์พุตของข้อมูลวิเคราะห์เกี่ยวกับการเข้าใช้
สร้าง Jupyter Notebook
ขั้นตอนแรกในการส่งวิดีโอจากอินสแตนซ์ Jupyter Notebook คือการสร้างโน้ตบุ๊กด้วยบัญชีบริการที่เราสร้างขึ้นในขั้นตอนก่อนหน้า
- ในคอนโซล ให้ไปที่หน้า Vertex AI ไปที่ Vertex AI Workbench
- คลิกสมุดบันทึกที่ผู้ใช้จัดการ
- คลิกสมุดบันทึกใหม่ > Tensorflow Enterprise 2.6 (มี LTS) > ไม่มี GPU
- ป้อนชื่อสำหรับ Jupyter Notebook ดูข้อมูลเพิ่มเติมได้ที่แบบแผนการตั้งชื่อทรัพยากร
- คลิกตัวเลือกขั้นสูง
- เลื่อนลงไปที่ส่วนสิทธิ์
- ยกเลิกการเลือกตัวเลือกใช้บัญชีบริการเริ่มต้นของ Compute Engine
- เพิ่มอีเมลบัญชีบริการที่สร้างไว้ในขั้นตอนก่อนหน้า แล้วคลิกสร้าง
- เมื่อสร้างอินสแตนซ์แล้ว ให้คลิกเปิด JUPYTERLAB
4. ตั้งค่าโน้ตบุ๊กเพื่อสตรีมวิดีโอ
ก่อนสร้างแอปในข้อมูลวิเคราะห์อัตราการเข้าพัก คุณต้องลงทะเบียนสตรีมที่แอปจะใช้ในภายหลังได้
ในบทแนะนำนี้ เราจะใช้อินสแตนซ์ Jupyter Notebook เพื่อโฮสต์วิดีโอ และคุณส่งข้อมูลวิดีโอสตรีมมิงจากเทอร์มินัลของ Notebook
ดาวน์โหลดเครื่องมือบรรทัดคำสั่ง 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
- LOCATION: รหัสสถานที่ตั้งของคุณ เช่น 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 ไปยังสตรีม Vertex AI Vision "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)
ระบบอาจใช้เวลาประมาณ 100 วินาทีระหว่างที่เริ่มดำเนินการนำเข้าข้อมูลส่วนวิดีโอกับวิดีโอที่ปรากฏในแดชบอร์ด
หลังจากการส่งผ่านข้อมูลสตรีมพร้อมใช้งานแล้ว คุณจะเห็นฟีดวิดีโอในแท็บสตรีมของแดชบอร์ด Vertex AI Vision โดยเลือกสตรีมคิวสตรีม
6. สร้างแอปพลิเคชัน
ขั้นตอนแรกคือการสร้างแอปที่ประมวลผลข้อมูล คุณอาจมองแอปเป็นไปป์ไลน์อัตโนมัติที่เชื่อมต่อสิ่งต่อไปนี้
- การนำเข้าข้อมูล: ระบบจะนำเข้าฟีดวิดีโอไปยังสตรีม
- การวิเคราะห์ข้อมูล: เพิ่มโมเดล AI(Computer Vision) ได้หลังจากการนำเข้า
- พื้นที่เก็บข้อมูล: ฟีดวิดีโอ 2 เวอร์ชัน (สตรีมต้นฉบับและสตรีมที่โมเดล AI ประมวลผล) สามารถจัดเก็บไว้ในคลังสื่อ
ในคอนโซล Google Cloud แอปจะแสดงเป็นกราฟ
สร้างแอปว่าง
ก่อนที่จะใส่ข้อมูลกราฟของแอป คุณต้องสร้างแอปเปล่าก่อน
สร้างแอปในคอนโซล Google Cloud
- ไปที่คอนโซล Google Cloud
- เปิดแท็บแอปพลิเคชันของแดชบอร์ด Vertex AI Vision ไปที่แท็บแอปพลิเคชัน
- คลิกปุ่มสร้าง
- ป้อน "queue-app' เป็นชื่อแอป แล้วเลือกภูมิภาค
- คลิกสร้าง
เพิ่มโหนดคอมโพเนนต์แอป
หลังจากสร้างแอปพลิเคชันว่างแล้ว คุณสามารถเพิ่มโหนด 3 รายการลงในกราฟแอปได้ดังนี้
- โหนดการส่งผ่านข้อมูล: ทรัพยากรสตรีมที่ส่งผ่านข้อมูลที่ส่งจากเซิร์ฟเวอร์วิดีโอ RTSP ที่คุณสร้างในโน้ตบุ๊ก
- โหนดการประมวลผล: โมเดลการวิเคราะห์อัตราการเข้าพักที่ดำเนินการกับข้อมูลที่นำเข้า
- โหนดพื้นที่เก็บข้อมูล: คลังสื่อที่จัดเก็บวิดีโอที่ประมวลผลแล้ว และทำหน้าที่เป็นพื้นที่เก็บข้อมูลเมตา พื้นที่เก็บข้อมูลเมตาประกอบด้วยข้อมูลวิเคราะห์เกี่ยวกับข้อมูลวิดีโอที่ส่งผ่านข้อมูล และข้อมูลที่ได้จากโมเดล AI
เพิ่มโหนดคอมโพเนนต์ลงในแอปในคอนโซล
- เปิดแท็บ Applications ของแดชบอร์ด Vertex AI Vision ไปที่แท็บแอปพลิเคชัน
ซึ่งจะนำคุณไปยังการแสดงภาพกราฟของไปป์ไลน์การประมวลผล
เพิ่มโหนดการส่งผ่านข้อมูล
- หากต้องการเพิ่มโหนดสตรีมอินพุต ให้เลือกตัวเลือกสตรีมในส่วนเครื่องมือเชื่อมต่อของเมนูด้านข้าง
- ในส่วนแหล่งที่มาของเมนูสตรีมที่เปิดขึ้น ให้เลือกเพิ่มสตรีม
- ในเมนูเพิ่มสตรีม ให้เลือก queue-stream
- หากต้องการเพิ่มสตรีมลงในกราฟของแอป ให้คลิกเพิ่มสตรีม
เพิ่มโหนดการประมวลผลข้อมูล
- หากต้องการเพิ่มโหนดโมเดลจำนวนการเข้าใช้ ให้เลือกตัวเลือกข้อมูลวิเคราะห์เกี่ยวกับอัตราการเข้าพักในส่วนโมเดลเฉพาะทางของเมนูด้านข้าง
- เลือกผู้คนตามค่าเริ่มต้น ยกเลิกการเลือกยานพาหนะหากเลือกไว้แล้ว
- ในส่วนตัวเลือกขั้นสูง ให้คลิกสร้างโซน/เส้นที่ทำงานอยู่
- วาดโซนที่ใช้งานอยู่โดยใช้เครื่องมือรูปหลายเหลี่ยมเพื่อนับผู้คนในโซนนั้น ติดป้ายกำกับโซนให้สอดคล้องกัน
- คลิกลูกศรย้อนกลับที่ด้านบน
- เพิ่มการตั้งค่าสำหรับเวลาที่ไม่มีการขยับเมาส์เพื่อตรวจหาความคับคั่งโดยคลิกช่องทำเครื่องหมาย
เพิ่มโหนดพื้นที่เก็บข้อมูล
- หากต้องการเพิ่มโหนดปลายทางเอาต์พุต (พื้นที่เก็บข้อมูล) ให้เลือกตัวเลือก VIsion AI Warehouse ในส่วน Connectors ของเมนูด้านข้าง
- คลิกตัวเชื่อมต่อ Vertex AI Warehouse เพื่อเปิดเมนู แล้วคลิกเชื่อมต่อคลังสินค้า
- ในเมนูเชื่อมต่อคลังสินค้า ให้เลือกสร้างคลังสินค้าใหม่ ตั้งชื่อคลังสินค้าเป็น 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 path ว่างไว้
- ในจัดเก็บข้อมูลเมตาจาก: ให้เลือกเฉพาะ "ข้อมูลวิเคราะห์อัตราการเข้าพัก" และยกเลิกการเลือกสตรีม
กราฟแอปสุดท้ายควรมีลักษณะดังนี้
8. ทำให้แอปใช้งานได้
หลังจากสร้างแอปแบบต้นทางถึงปลายทางพร้อมคอมโพเนนต์ที่จำเป็นทั้งหมดแล้ว ขั้นตอนสุดท้ายในการใช้แอปก็คือการทำให้แอปใช้งานได้
- เปิดแท็บแอปพลิเคชันของแดชบอร์ด Vertex AI Vision ไปที่แท็บแอปพลิเคชัน
- เลือกดูแอปข้างแอป queue-app ในรายการ
- จากหน้า Studio ให้คลิกปุ่มทำให้ใช้งานได้
- ในกล่องโต้ตอบการยืนยันต่อไปนี้ ให้คลิกทำให้ใช้งานได้ การดำเนินการทำให้ใช้งานได้อาจใช้เวลาหลายนาทีจึงจะเสร็จสมบูรณ์ หลังจากการทําให้ใช้งานได้เสร็จสิ้นแล้ว เครื่องหมายถูกสีเขียวจะปรากฏข้างโหนด
9. ค้นหาเนื้อหาวิดีโอในคลังพื้นที่เก็บข้อมูล
หลังจากนำเข้าข้อมูลวิดีโอลงในแอปประมวลผลแล้ว คุณจะดูข้อมูลวิดีโอที่วิเคราะห์และค้นหาข้อมูลตามข้อมูลวิเคราะห์อัตราการเข้าพักได้
- เปิดแท็บคลังสินค้าของหน้าแดชบอร์ด Vertex AI Vision ไปที่แท็บคลังสินค้า
- ค้นหาคลังสินค้าคลังคิวในรายการ แล้วคลิกดูเนื้อหา
- ในส่วนจํานวนคน ให้กําหนดค่าต่ำสุดเป็น 1 และค่าสูงสุดเป็น 5
- หากต้องการกรองข้อมูลวิดีโอที่ประมวลผลแล้วซึ่งจัดเก็บไว้ในคลังสื่อของ 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