Vertex AI की मदद से, विज़न की सूची का पता लगाने वाला ऐप्लिकेशन

1. मकसद

खास जानकारी

यह कोडलैब, Vertex AI Vision ऐप्लिकेशन बनाने पर फ़ोकस करेगा. इससे रीटेल वीडियो फ़ुटेज का इस्तेमाल करके, सूची के साइज़ को मॉनिटर किया जा सकेगा. हम इन चीज़ों को कैप्चर करने के लिए, खास तौर पर ट्रेन किए गए खास मॉडल के लिए ऑक्यूपेंसी Analytics की पहले से मौजूद सुविधाओं का इस्तेमाल करेंगे:

  • सूची में खड़े लोगों की संख्या गिनें.
  • काउंटर पर सेवा पाने वाले लोगों की संख्या गिनें.

आपको इनके बारे में जानकारी मिलेगी

  • Vertex AI Vision में ऐप्लिकेशन बनाने और उसे डिप्लॉय करने का तरीका
  • वीडियो फ़ाइल का इस्तेमाल करके आरटीएसपी स्ट्रीम सेट अप करने और Jupyter Notebook से vaictl पर स्ट्रीम को Vertex AI Vision में डालने का तरीका.
  • व्यस्तता की दर के Analytics मॉडल और इसकी अलग-अलग सुविधाओं को इस्तेमाल करने का तरीका.
  • अपने स्टोरेज Vertex AI Vision के मीडिया वेयरहाउस में वीडियो खोजने का तरीका.
  • आउटपुट को BigQuery से कनेक्ट करने, मॉडल के json आउटपुट से अहम जानकारी निकालने के लिए SQL क्वेरी लिखने, और ओरिजनल वीडियो को लेबल करने और उसकी व्याख्या करने के लिए आउटपुट का इस्तेमाल करने का तरीका.

कीमत:

Google Cloud पर इस लैब को चलाने की कुल लागत करीब 2 डॉलर है.

2. शुरू करने से पहले

प्रोजेक्ट बनाएं और एपीआई चालू करें:

  1. Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर, Google Cloud प्रोजेक्ट चुनें या बनाएं. ध्यान दें: अगर इस प्रोसेस में बनाए गए संसाधनों का इस्तेमाल नहीं करना है, तो मौजूदा प्रोजेक्ट चुनने के बजाय कोई प्रोजेक्ट बनाएं. इन चरणों को पूरा करने के बाद, प्रोजेक्ट से जुड़े सभी संसाधनों को हटाकर, प्रोजेक्ट को मिटाया जा सकता है. प्रोजेक्ट सिलेक्टर पर जाएं
  2. पक्का करें कि आपके Cloud प्रोजेक्ट के लिए बिलिंग की सुविधा चालू हो. किसी प्रोजेक्ट के लिए बिलिंग की सुविधा चालू है या नहीं, यह देखने का तरीका जानें.
  3. Compute Engine, Vertex API, Notebook API, और Vision AI API चालू करें. एपीआई चालू करना

सेवा खाता बनाएं:

  1. Google Cloud Console में, सेवा खाता बनाएं पेज पर जाएं. 'सेवा खाता बनाएं' पर जाएं
  2. अपना प्रोजेक्ट चुनें.
  3. सेवा खाते का नाम फ़ील्ड में, कोई नाम डालें. Google Cloud Console, इस नाम के आधार पर सेवा खाता आईडी फ़ील्ड में जानकारी भरता है. सेवा खाते की जानकारी फ़ील्ड में, ब्यौरा डालें. उदाहरण के लिए, क्विकस्टार्ट के लिए सेवा खाता.
  4. बनाएं और जारी रखें पर क्लिक करें.
  5. अपने प्रोजेक्ट का ऐक्सेस देने के लिए, अपने सेवा खाते को ये भूमिकाएं दें:
  • विज़न एआई > विज़न एआई एडिटर
  • कंप्यूट इंजन > कंप्यूट इंस्टेंस एडमिन (बीटा वर्शन)
  • BigQuery > BigQuery एडमिन .

भूमिका चुनें सूची में, कोई भूमिका चुनें. अन्य भूमिकाओं के लिए, कोई अन्य भूमिका जोड़ें पर क्लिक करें और हर अतिरिक्त भूमिका को जोड़ें.

  1. जारी रखें पर क्लिक करें.
  2. सेवा खाता बनाने के लिए, हो गया पर क्लिक करें. अपनी ब्राउज़र विंडो बंद न करें. इसका इस्तेमाल अगले चरण में किया जाएगा.

3. Jupyter Notebook को सेट अप करना

व्यस्तता के आंकड़े में ऐप्लिकेशन बनाने से पहले, आपको एक ऐसी स्ट्रीम रजिस्टर करनी होगी जिसे ऐप्लिकेशन बाद में इस्तेमाल कर सके.

इस ट्यूटोरियल में, आपने Jupyter Notebook इंस्टेंस बनाया है. यह वीडियो होस्ट करता है और notebook से स्ट्रीमिंग वाले वीडियो डेटा को भेजा जाता है. हम jupyter notebook का इस्तेमाल कर रहे हैं, क्योंकि यह हमें शेल कमांड लागू करने और कस्टम प्री/पोस्ट प्रोसेसिंग कोड को एक ही जगह पर चलाने की सुविधा देता है. यह प्रोसेस, तेज़ी से एक्सपेरिमेंट करने के लिए बहुत अच्छी है. हम इस नोटबुक का इस्तेमाल इन कामों के लिए करेंगे:

  1. rtsp सर्वर को बैकग्राउंड प्रोसेस के तौर पर चलाएं
  2. vaictl कमांड को बैकग्राउंड प्रोसेस के तौर पर चलाएं
  3. व्यस्तता की दर से जुड़े आंकड़ों के आउटपुट का विश्लेषण करने के लिए, क्वेरी और प्रोसेसिंग कोड चलाएं

Jupyter Notebook बनाना

Jupyter Notebook इंस्टेंस से वीडियो भेजने का पहला चरण है, पिछले चरण में बनाए गए हमारे सेवा खाते का इस्तेमाल करके नोटबुक बनाना.

  1. कंसोल में, Vertex AI पेज पर जाएं. Vertex AI Workbench पर जाएं
  2. उपयोगकर्ता की ओर से प्रबंधित नोटबुक पर क्लिक करें

65b7112822858dce.png

  1. नई नोटबुक > पर क्लिक करें Tensorflow Enterprise 2.6 (एलटीएस के साथ) > जीपीयू के बिना

dc156f20b14651d7.png

  1. jupyter notebook का नाम डालें. ज़्यादा जानकारी के लिए, संसाधन का नाम रखने की कन्वेंशन देखें.

b4dbc5fddc37e8d9.png

  1. ऐडवांस विकल्प पर क्लिक करें
  2. नीचे की ओर स्क्रोल करके, अनुमतियों के सेक्शन पर जाएं
  3. Compute Engine के डिफ़ॉल्ट सेवा खाते का इस्तेमाल करें विकल्प से सही का निशान हटाएं
  4. पिछले चरण में बनाया गया सेवा खाते का ईमेल पता जोड़ें. इसके बाद, बनाएं पर क्लिक करें.

ec0b9ef00f0ef470.png

  1. इंस्टेंस बनने के बाद, JUPYTERLAB खोलें पर क्लिक करें.

4. वीडियो स्ट्रीम करने के लिए, नोटबुक सेट अप करें

व्यस्तता के आंकड़े में ऐप्लिकेशन बनाने से पहले, आपको एक ऐसी स्ट्रीम रजिस्टर करनी होगी जिसे ऐप्लिकेशन बाद में इस्तेमाल कर सके.

इस ट्यूटोरियल में, वीडियो होस्ट करने के लिए हम अपने Jupyter Notebook इंस्टेंस का इस्तेमाल करेंगे. साथ ही, आपको Notebook टर्मिनल से यह स्ट्रीमिंग वीडियो डेटा भेजा जाएगा.

vaictl कमांड-लाइन टूल डाउनलोड करें

  1. खुले हुए Jupyterlab इंस्टेंस में, लॉन्चर से Notebook खोलें.

a6d182923ae4ada3.png

  1. notebook के सेल में दिए गए इन कमांड का इस्तेमाल करके, 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 का इस्तेमाल किया जा सकता है.

नई स्ट्रीम रजिस्टर करना

  1. Vertex AI Vision के बाएं पैनल में, स्ट्रीम टैब पर क्लिक करें.
  2. सबसे ऊपर मौजूद eba418e723916514.png में रजिस्टर करें बटन पर क्लिक करें
  3. स्ट्रीम के नाम में, ‘queue-stream' डालें
  4. क्षेत्र में, उसी क्षेत्र को चुनें जिसे पिछले चरण में Notebook बनाते समय चुना गया था.
  5. रजिस्टर करें पर क्लिक करें

वीएम में सैंपल वीडियो कॉपी करना

  1. अपनी नोटबुक में, नीचे दिए गए wget कमांड के साथ एक सैंपल वीडियो कॉपी करें.
!wget -q https://github.com/vagrantism/interesting-datasets/raw/main/video/collective_activity/seq25_h264.mp4

वीएम से वीडियो स्ट्रीम करें और अपनी स्ट्रीम में डेटा डालें

  1. इस लोकल वीडियो फ़ाइल को ऐप्लिकेशन की इनपुट स्ट्रीम पर भेजने के लिए, अपने notebook सेल में नीचे दिए गए निर्देश का इस्तेमाल करें. आपको नीचे दिए गए वैरिएबल के सब्सिट्यूशन बनाने होंगे:
  • PROJECT_ID: आपका Google Cloud प्रोजेक्ट आईडी.
  • Places: आपकी जगह का आईडी. उदाहरण के लिए, 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'
  1. एक rtsp-सरल-सर्वर शुरू करें, जहां हम 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. rtsp स्ट्रीम में वीडियो को लूप में चलाने के लिए, ffmpeg कमांड लाइन टूल इस्तेमाल करें
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. वीडियो को rtsp सर्वर uri से Vertex AI Vision स्ट्रीम 'क्यू-स्ट्रीम' में स्ट्रीम करने के लिए, vaictl कमांड लाइन टूल का इस्तेमाल करें पिछले चरण में बनाया गया था.
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 डैशबोर्ड में मौजूद स्ट्रीम टैब में वीडियो फ़ीड देखा जा सकता है. इसके लिए, क्यू-स्ट्रीम स्ट्रीम को चुनें.

'स्ट्रीम' टैब पर जाएं

1b7aac7d36552f29.png

6. एक ऐप्लिकेशन बनाएं

सबसे पहले एक ऐसा ऐप्लिकेशन बनाएं जो आपके डेटा को प्रोसेस करे. ऐप्लिकेशन को एक ऑटोमेटेड पाइपलाइन माना जा सकता है, जो इन्हें कनेक्ट करती है:

  • डेटा डालना: वीडियो फ़ीड को स्ट्रीम में डाला जाता है.
  • डेटा का विश्लेषण: डेटा डालने के बाद, एआई(कंप्यूटर विज़न) मॉडल जोड़ा जा सकता है.
  • डेटा स्टोरेज: वीडियो फ़ीड के दो वर्शन (ओरिजनल स्ट्रीम और एआई मॉडल से प्रोसेस की जाने वाली स्ट्रीम) को मीडिया वेयरहाउस में सेव किया जा सकता है.

Google Cloud Console में, ऐप्लिकेशन को ग्राफ़ के तौर पर दिखाया जाता है.

खाली ऐप्लिकेशन बनाना

ऐप्लिकेशन ग्राफ़ भरने से पहले, आपको एक खाली ऐप्लिकेशन बनाना होगा.

Google Cloud Console में कोई ऐप्लिकेशन बनाएं.

  1. Google Cloud console पर जाएं.
  2. Vertex AI Vision डैशबोर्ड का ऐप्लिकेशन टैब खोलें. ऐप्लिकेशन टैब पर जाएं
  3. बनाएं बटन पर क्लिक करें. 21ecba7a23e9979e.png
  4. ऐप्लिकेशन के नाम के तौर पर ‘queue-app' डालें और अपना क्षेत्र चुनें.
  5. बनाएं पर क्लिक करें.

ऐप्लिकेशन कॉम्पोनेंट नोड जोड़ना

खाली ऐप्लिकेशन बनाने के बाद, ऐप्लिकेशन ग्राफ़ में ये तीन नोड जोड़े जा सकते हैं:

  1. डेटा डालना नोड: वह स्ट्रीम संसाधन जो आपके notebook में बनाए गए rtsp वीडियो सर्वर से भेजे गए डेटा का डेटा डालता है.
  2. प्रोसेसिंग नोड: व्यस्तता के आंकड़े का मॉडल, जो डाले गए डेटा पर काम करता है.
  3. स्टोरेज नोड: वह मीडिया वेयरहाउस जहां प्रोसेस किए गए वीडियो सेव किए जाते हैं. साथ ही, यहां मेटाडेटा स्टोर भी होता है. मेटाडेटा स्टोर में, डाले गए वीडियो डेटा के आंकड़ों की जानकारी और एआई मॉडल से मिली अनुमानित जानकारी शामिल होती है.

कंसोल में, अपने ऐप्लिकेशन के लिए कॉम्पोनेंट नोड जोड़ें.

  1. Vertex AI Vision डैशबोर्ड का ऐप्लिकेशन टैब खोलें. ऐप्लिकेशन टैब पर जाएं

यह आपको प्रोसेस करने वाले पाइपलाइन के ग्राफ़ विज़ुअलाइज़ेशन पर ले जाता है.

डेटा डालने का नोड जोड़ना

  1. इनपुट स्ट्रीम नोड जोड़ने के लिए, साइड मेन्यू के कनेक्टर सेक्शन में स्ट्रीम विकल्प चुनें.
  2. इसके बाद, स्ट्रीम मेन्यू के सोर्स सेक्शन में, स्ट्रीम जोड़ें को चुनें.
  3. स्ट्रीम जोड़ें मेन्यू में, लाइन-स्ट्रीम चुनें.
  4. स्ट्रीम को ऐप्लिकेशन के ग्राफ़ में जोड़ने के लिए, स्ट्रीम जोड़ें पर क्लिक करें.

डेटा प्रोसेसिंग नोड जोड़ना

  1. बुकिंग के हिसाब से वयस्कों और बच्चों की संख्या वाला मॉडल नोड जोड़ने के लिए, साइड मेन्यू के खास मॉडल सेक्शन में, व्यस्तता की दर के आंकड़े का विकल्प चुनें.
  2. डिफ़ॉल्ट रूप से चुना गया लोग छोड़ें. अगर वाहन पहले से चुना हुआ है, तो उससे सही का निशान हटाएं.

618b0c9dc671bae3.png

  1. बेहतर विकल्प सेक्शन में, ऐक्टिव ज़ोन/लाइन बनाएं 5b2f31235603e05d.png पर क्लिक करें
  2. उस ज़ोन में लोगों की गिनती करने के लिए, पॉलीगॉन टूल का इस्तेमाल करके ऐक्टिव ज़ोन बनाएं. ज़ोन को उसी हिसाब से लेबल करें

50281a723650491f.png

  1. सबसे ऊपर, बैक ऐरो पर क्लिक करें.

2bf0ff4d029d29eb.png

  1. चेकबॉक्स पर क्लिक करके, कंजेशन का पता लगाने के लिए, ड्वेल टाइम की सेटिंग जोड़ें.

c067fa256ca5bb96.png

डेटा स्टोरेज नोड जोड़ना

  1. आउटपुट डेस्टिनेशन (स्टोरेज) नोड जोड़ने के लिए, साइड मेन्यू के कनेक्टर सेक्शन में VIsion AI Warehouse विकल्प चुनें.
  2. Vertex AI Warehouse कनेक्टर का मेन्यू खोलने के लिए, उस पर क्लिक करें. इसके बाद, वेयरहाउस कनेक्ट करें पर क्लिक करें.
  3. वेयरहाउस कनेक्ट करें मेन्यू में जाकर, नया वेयरहाउस बनाएं को चुनें. वेयरहाउस को सूची-वेयरहाउस नाम दें और TTL की अवधि 14 दिन पर छोड़ दें.
  4. वेयरहाउस जोड़ने के लिए, बनाएं बटन पर क्लिक करें.

7. आउटपुट को BigQuery टेबल से कनेक्ट करें

Vertex AI Vision ऐप्लिकेशन में BigQuery कनेक्टर जोड़ने पर, कनेक्ट किए गए ऐप्लिकेशन मॉडल के सभी आउटपुट, टारगेट टेबल में डाले जाएंगे.

ऐप्लिकेशन में BigQuery कनेक्टर जोड़ते समय, खुद की BigQuery टेबल बनाई जा सकती है और उस टेबल को चुना जा सकता है. इसके अलावा, Vertex AI Vision ऐप्लिकेशन प्लैटफ़ॉर्म को अपने-आप टेबल बनाने की अनुमति भी दी जा सकती है.

अपने-आप टेबल बनने की सुविधा

अगर आपने Vertex AI Vision ऐप्लिकेशन प्लैटफ़ॉर्म को अपने-आप टेबल बनाने की अनुमति दी है, तो BigQuery कनेक्टर नोड जोड़ते समय यह विकल्प तय किया जा सकता है.

अगर आपको टेबल अपने-आप बनने की सुविधा का इस्तेमाल करना है, तो यहां दिए गए डेटासेट और टेबल की शर्तें लागू होंगी:

  • डेटासेट: अपने-आप बने डेटासेट का नाम visionai_dataset है.
  • टेबल: अपने-आप बनने वाली टेबल का नाम visionai_dataset.APPLICATION_ID है.
  • गड़बड़ी ठीक करना:
  • अगर एक ही डेटासेट में, एक ही नाम वाली टेबल मौजूद है, तो अपने-आप कोई टेबल नहीं बनती.
  1. Vertex AI Vision डैशबोर्ड का ऐप्लिकेशन टैब खोलें. ऐप्लिकेशन टैब पर जाएं
  2. सूची में से अपने ऐप्लिकेशन के नाम के आगे, ऐप्लिकेशन देखें चुनें.
  3. ऐप्लिकेशन बिल्डर पेज पर, कनेक्टर सेक्शन से BigQuery चुनें.
  4. BigQuery पाथ फ़ील्ड को खाली छोड़ दें.

ee0b67d4ab2263d.png

  1. स्टोर के मेटाडेटा में: सिर्फ़ ‘दर्शकों की जानकारी’ चुनें और स्ट्रीम से सही का निशान हटाएं.

अंतिम ऐप्लिकेशन ग्राफ़ कुछ ऐसा दिखना चाहिए:

da0a1a049843572f.png

8. ऐप्लिकेशन को इस्तेमाल के लिए डिप्लॉय करना

सभी ज़रूरी कॉम्पोनेंट वाला एंड-टू-एंड ऐप्लिकेशन बनाने के बाद, उसे डिप्लॉय करने का आखिरी चरण, ऐप्लिकेशन को इस्तेमाल करना है.

  1. Vertex AI Vision डैशबोर्ड का ऐप्लिकेशन टैब खोलें. ऐप्लिकेशन टैब पर जाएं
  2. सूची में queue-app ऐप्लिकेशन के बगल में मौजूद ऐप्लिकेशन देखें चुनें.
  3. Studio पेज पर, डिप्लॉय करें बटन पर क्लिक करें.
  4. नीचे दिए गए पुष्टि करने वाले डायलॉग में, डिप्लॉय करें पर क्लिक करें. डिप्लॉयमेंट की कार्रवाई पूरी होने में कुछ मिनट लग सकते हैं. डिप्लॉयमेंट पूरा होने के बाद, नोड के बगल में हरे रंग के सही के निशान दिखते हैं. dc514d9b9f35099d.png

9. स्टोरेज वेयरहाउस में वीडियो का कॉन्टेंट खोजना

डेटा प्रोसेस करने वाले ऐप्लिकेशन में वीडियो डेटा डालने के बाद, जांचे गए वीडियो का डेटा देखा जा सकता है. साथ ही, व्यस्तता की दर से जुड़े आंकड़ों की जानकारी के आधार पर डेटा खोजा जा सकता है.

  1. Vertex AI Vision डैशबोर्ड का वेयरहाउस टैब खोलें. वेयरहाउस टैब पर जाएं
  2. सूची में क्यू-वेयरहाउस वेयरहाउस ढूंढें और ऐसेट देखें पर क्लिक करें.
  3. लोगों की संख्या सेक्शन में, कम से कम वैल्यू को 1 और ज़्यादा से ज़्यादा वैल्यू को 5 पर सेट करें.
  4. Vertex AI Vision के मीडिया वेयरहाउस में सेव किए गए, प्रोसेस किए गए वीडियो डेटा को फ़िल्टर करने के लिए, खोजें पर क्लिक करें.

a0e5766262443d6c.png

सेव किए गए वीडियो के ऐसे डेटा का व्यू जो Google Cloud Console में, खोज के लिए ज़रूरी शर्तों से मेल खाता है.

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. अब हम इस कोड का इस्तेमाल करके, आरटीएसपी स्ट्रीम से फ़्रेम कैप्चर करेंगे:
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. 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. बधाई हो

बधाई हो, आपने लैब पूरा कर लिया है!

खाली करने के लिए जगह

इस ट्यूटोरियल में इस्तेमाल किए गए संसाधनों के लिए, आपके Google Cloud खाते पर शुल्क न लगे. इसके लिए, उस प्रोजेक्ट को मिटा दें जिसमें संसाधन शामिल हैं या प्रोजेक्ट को बनाए रखें और अलग-अलग संसाधनों को मिटाएं.

प्रोजेक्ट मिटाएं

एक-एक करके संसाधन मिटाएं

संसाधन

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

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

लाइसेंस

सर्वे

आपने इस ट्यूटोरियल का इस्तेमाल कैसे किया?

इसे सिर्फ़ पढ़ें इसे पढ़ें और कसरतें पूरी करें

यह कोडलैब आपके लिए कितने काम का था?

बहुत काम की है कुछ हद तक काम की है काम की नहीं है

कोडलैब के इस मॉड्यूल को फ़ॉलो करना कितना आसान था?

आसान मॉडरेट करें मुश्किल