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

1. मकसद

खास जानकारी

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

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

आपको क्या सीखने को मिलेगा

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

लागत:

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

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, इस नाम के आधार पर सेवा खाता आईडी फ़ील्ड में जानकारी भरता है. सेवा खाते की जानकारी फ़ील्ड में, जानकारी डालें. उदाहरण के लिए, Quickstart के लिए सेवा खाता.
  4. बनाएं और जारी रखें पर क्लिक करें.
  5. अपने प्रोजेक्ट का ऐक्सेस देने के लिए, अपने सेवा खाते को ये भूमिकाएं असाइन करें:
  • Vision AI > Vision AI Editor
  • Compute Engine > Compute Instance Admin (beta)
  • BigQuery > BigQuery एडमिन .

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

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

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

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

इस ट्यूटोरियल में, आपको वीडियो होस्ट करने वाला Jupyter 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. वीडियो स्ट्रीम करने के लिए नोटबुक सेट अप करना

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

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

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

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

a6d182923ae4ada3.png

  1. नोटबुक सेल में यह कमांड इस्तेमाल करके, 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. रीजन में, वही रीजन चुनें जिसे आपने पिछले चरण में नोटबुक बनाते समय चुना था.
  5. रजिस्टर करें पर क्लिक करें

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

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

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

  1. इस लोकल वीडियो फ़ाइल को ऐप्लिकेशन की इनपुट स्ट्रीम में भेजने के लिए, अपनी नोटबुक सेल में यह कमांड इस्तेमाल करें. आपको वैरिएबल के ये सब्सिट्यूशन करने होंगे:
  • 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'
  1. 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)
  1. आरटीएसपी स्ट्रीम में वीडियो को लूप करने के लिए, 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. vaictl कमांड लाइन टूल का इस्तेमाल करके, 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)

vaictl ingest ऑपरेशन शुरू करने और वीडियो के डैशबोर्ड में दिखने के बीच ~100 सेकंड लग सकते हैं.

स्ट्रीम का डेटा उपलब्ध होने के बाद, Vertex AI Vision के डैशबोर्ड के स्ट्रीम टैब में जाकर, वीडियो फ़ीड देखा जा सकता है. इसके लिए, queue-stream स्ट्रीम को चुनें.

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

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. डेटा पाने वाला नोड: यह स्ट्रीम रिसॉर्स, नोटबुक में बनाए गए आरटीएसपी वीडियो सर्वर से भेजे गए डेटा को प्रोसेस करता है.
  2. प्रोसेसिंग नोड: यह ऑक्यूपेंसी ऐनलिटिक्स मॉडल है, जो इकट्ठा किए गए डेटा के आधार पर काम करता है.
  3. स्टोरेज नोड: यह एक मीडिया वेयरहाउस होता है, जिसमें प्रोसेस किए गए वीडियो स्टोर किए जाते हैं. साथ ही, यह मेटाडेटा स्टोर के तौर पर भी काम करता है. मेटाडेटा स्टोर में, वीडियो के इस्तेमाल किए गए डेटा के बारे में आंकड़ों की जानकारी शामिल होती है. साथ ही, इसमें एआई मॉडल से मिली जानकारी भी शामिल होती है.

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

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

इससे आपको प्रोसेसिंग पाइपलाइन का ग्राफ़ विज़ुअलाइज़ेशन दिखेगा.

डेटा इंटेक नोड जोड़ना

  1. इनपुट स्ट्रीम नोड जोड़ने के लिए, साइड मेन्यू के कनेक्टर सेक्शन में जाकर, स्ट्रीम विकल्प चुनें.
  2. खुलने वाले स्ट्रीम मेन्यू के सोर्स सेक्शन में जाकर, स्ट्रीम जोड़ें को चुनें.
  3. स्ट्रीम जोड़ें मेन्यू में जाकर, queue-stream चुनें.
  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. वेयरहाउस कनेक्ट करें मेन्यू में जाकर, नया वेयरहाउस बनाएं चुनें. वेयरहाउस का नाम queue-warehouse रखें और टीटीएल की अवधि को 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. स्टोर का मेटाडेटा यहां से लें: में जाकर, सिर्फ़ ‘ऑक्यूपेंसी Analytics' को चुनें और स्ट्रीम से सही का निशान हटाएं.

ऐप्लिकेशन का फ़ाइनल ग्राफ़ ऐसा दिखना चाहिए:

da0a1a049843572f.png

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

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

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

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

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

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

a0e5766262443d6c.png

Google Cloud Console में, खोज के मानदंड से मेल खाने वाले सेव किए गए वीडियो डेटा का व्यू.

10. BigQuery टेबल का इस्तेमाल करके, आउटपुट में एनोटेशन जोड़ना और उसका विश्लेषण करना

  1. नोटबुक में, सेल में इन वैरिएबल को शुरू करें.
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. नोटबुक मेन्यू बार में मौजूद बंद करें बटन का इस्तेमाल करके, एनोटेशन टास्क को बंद करें

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

लाइसेंस

सर्वे

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

सिर्फ़ पढ़ा पढ़ा और एक्सरसाइज़ पूरी की

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

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

इस कोडलैब को फ़ॉलो करना कितना आसान था?

आसान सामान्य मुश्किल