1. मकसद
खास जानकारी
इस कोडलैब में, Vertex AI Vision का एंड-टू-एंड ऐप्लिकेशन बनाने पर फ़ोकस किया जाएगा. इससे रीटेल वीडियो फ़ुटेज का इस्तेमाल करके, कतार के साइज़ को मॉनिटर किया जा सकेगा. हम इन चीज़ों को कैप्चर करने के लिए, पहले से ट्रेन किए गए स्पेशलाइज़्ड मॉडल ऑक्यूपेंसी के आंकड़े की इनबिल्ट सुविधाओं का इस्तेमाल करेंगे:
- कतार में खड़े लोगों की संख्या गिनें.
- काउंटर पर सेवा पाने वाले लोगों की संख्या गिनें.
आपको इनके बारे में जानकारी मिलेगी
- Vertex AI Vision में ऐप्लिकेशन बनाने और उसे डिप्लॉय करने का तरीका
- वीडियो फ़ाइल का इस्तेमाल करके RTSP स्ट्रीम सेट अप करने और Jupyter Notebook से vaictl का इस्तेमाल करके स्ट्रीम को Vertex AI Vision में डालने का तरीका.
- बुकिंग के आंकड़े दिखाने वाले मॉडल और उसकी अलग-अलग सुविधाओं का इस्तेमाल करने का तरीका.
- अपने स्टोरेज Vertex AI Vision के मीडिया वेयरहाउस में वीडियो खोजने का तरीका.
- आउटपुट को BigQuery से कनेक्ट करने का तरीका. साथ ही, मॉडल के JSON आउटपुट से अहम जानकारी निकालने के लिए एसक्यूएल क्वेरी लिखना और ओरिजनल वीडियो को लेबल करने और एनोटेट करने के लिए आउटपुट का इस्तेमाल करना.
लागत:
Google Cloud पर इस लैब को चलाने की कुल लागत करीब 2 डॉलर है.
2. शुरू करने से पहले
प्रोजेक्ट बनाएं और एपीआई चालू करें:
- Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर, Google Cloud प्रोजेक्ट बनाएं या कोई मौजूदा प्रोजेक्ट चुनें. ध्यान दें: अगर इस प्रोसेस में बनाए गए संसाधनों का इस्तेमाल नहीं करना है, तो मौजूदा प्रोजेक्ट चुनने के बजाय कोई प्रोजेक्ट बनाएं. यह तरीका अपनाने के बाद, प्रोजेक्ट को मिटाया जा सकता है. इससे प्रोजेक्ट से जुड़े सभी संसाधन भी हट जाएंगे. प्रोजेक्ट सिलेक्टर पर जाएं
- पक्का करें कि आपके Cloud प्रोजेक्ट के लिए बिलिंग की सुविधा चालू हो. किसी प्रोजेक्ट के लिए बिलिंग की सुविधा चालू है या नहीं, यह देखने का तरीका जानें.
- Compute Engine, Vertex API, Notebook API, और Vision AI API चालू करें. एपीआई चालू करना
सेवा खाता बनाने के लिए:
- Google Cloud Console में, सेवा खाता बनाएं पेज पर जाएं. 'सेवा खाता बनाएं' पर जाएं
- अपना प्रोजेक्ट चुनें.
- सेवा खाते का नाम फ़ील्ड में, कोई नाम डालें. Google Cloud Console, इस नाम के आधार पर सेवा खाते का आईडी फ़ील्ड भर देता है. सेवा खाते की जानकारी फ़ील्ड में, जानकारी डालें. उदाहरण के लिए, तुरंत शुरू करने के लिए सेवा खाता.
- बनाएं और जारी रखें पर क्लिक करें.
- अपने प्रोजेक्ट का ऐक्सेस देने के लिए, अपने सेवा खाते को ये भूमिकाएं दें:
- विज़न एआई > विज़न एआई एडिटर
- Compute Engine > Compute इंस्टेंस एडमिन (बीटा वर्शन)
- BigQuery > BigQuery एडमिन .
भूमिका चुनें सूची में, कोई भूमिका चुनें. अन्य भूमिकाओं के लिए, अन्य भूमिका जोड़ें पर क्लिक करें और हर भूमिका जोड़ें.
- जारी रखें पर क्लिक करें.
- सेवा खाता बनाने की प्रोसेस पूरी करने के लिए, हो गया पर क्लिक करें. ब्राउज़र विंडो बंद न करें. इसका इस्तेमाल अगले चरण में किया जाएगा.
3. Jupyter Notebook को सेट अप करना
ऑक्युपेंसी आंकड़ों में ऐप्लिकेशन बनाने से पहले, आपको एक स्ट्रीम रजिस्टर करनी होगी. इसका इस्तेमाल, ऐप्लिकेशन बाद में कर सकता है.
इस ट्यूटोरियल में, एक Jupyter Notebook इंस्टेंस बनाया जाता है, जो वीडियो होस्ट करता है. साथ ही, उस स्ट्रीमिंग वीडियो का डेटा, Notebook से भेजा जाता है. हम jupyter notebook का इस्तेमाल कर रहे हैं, क्योंकि यह हमें शेल कमांड लागू करने और कस्टम प्री/पोस्ट प्रोसेसिंग कोड को एक ही जगह पर चलाने की सुविधा देता है. यह प्रोसेस, तेज़ी से एक्सपेरिमेंट करने के लिए बहुत अच्छी है. हम इस नोटबुक का इस्तेमाल इन कामों के लिए करेंगे:
- rtsp सर्वर को बैकग्राउंड प्रोसेस के तौर पर चलाना
- बैकग्राउंड प्रोसेस के तौर पर vaictl कमांड चलाना
- बुकिंग की संख्या के आंकड़ों के आउटपुट का विश्लेषण करने के लिए, क्वेरी चलाना और कोड प्रोसेस करना
Jupyter नोटबुक बनाना
Jupyter Notebook इंस्टेंस से वीडियो भेजने के लिए, सबसे पहले पिछले चरण में बनाए गए सेवा खाते से नोटबुक बनाएं.
- कंसोल में, Vertex AI पेज पर जाएं. Vertex AI Workbench पर जाएं
- उपयोगकर्ता की ओर से प्रबंधित नोटबुक पर क्लिक करें
- नई Notebook > Tensorflow Enterprise 2.6 (एलटीएस के साथ) > जीपीयू के बिना पर क्लिक करें
- jupyter नोटबुक के लिए कोई नाम डालें. ज़्यादा जानकारी के लिए, संसाधन के नाम तय करने का तरीका देखें.
- बेहतर विकल्प पर क्लिक करें
- नीचे की ओर स्क्रोल करके, अनुमतियां सेक्शन पर जाएं
- Compute Engine के डिफ़ॉल्ट सेवा खाते का इस्तेमाल करें विकल्प से सही का निशान हटाएं
- पिछले चरण में बनाया गया सेवा खाते का ईमेल पता जोड़ें. इसके बाद, बनाएं पर क्लिक करें.
- इंस्टेंस बन जाने के बाद, JUPYTERLAB खोलें पर क्लिक करें.
4. वीडियो स्ट्रीम करने के लिए नोटबुक सेट अप करना
ऑक्युपेंसी आंकड़ों में ऐप्लिकेशन बनाने से पहले, आपको एक स्ट्रीम रजिस्टर करनी होगी. इसका इस्तेमाल, ऐप्लिकेशन बाद में कर सकता है.
इस ट्यूटोरियल में, हम वीडियो होस्ट करने के लिए अपने Jupyter Notebook इंस्टेंस का इस्तेमाल करेंगे. साथ ही, Notebook टर्मिनल से स्ट्रीमिंग वीडियो का डेटा भेजेंगे.
vaictl कमांड-लाइन टूल डाउनलोड करना
- Jupyterlab इंस्टेंस खोलने के बाद, लॉन्चर से कोई नोटबुक खोलें.
- नोटबुक सेल में दिए गए इस कमांड का इस्तेमाल करके, 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
वीएम से वीडियो स्ट्रीम करना और अपनी स्ट्रीम में डेटा डालना
- इस लोकल वीडियो फ़ाइल को ऐप्लिकेशन की इनपुट स्ट्रीम पर भेजने के लिए, अपने notebook सेल में नीचे दिए गए निर्देश का इस्तेमाल करें. आपको वैरिएबल के लिए ये सबस्टिट्यूशन करने होंगे:
- 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)
- 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)
- rtsp सर्वर यूआरआई से वीडियो को स्ट्रीम करने के लिए, vaictl कमांड-लाइन टूल का इस्तेमाल करें. वीडियो को स्ट्रीम करने के लिए, पिछले चरण में बनाई गई 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 इंजेस्ट ऑपरेशन शुरू करने और डैशबोर्ड में वीडियो दिखने में करीब 100 सेकंड लग सकते हैं.
स्ट्रीम डालने की सुविधा उपलब्ध होने के बाद, Vertex AI Vision के डैशबोर्ड के स्ट्रीम टैब में जाकर, वीडियो फ़ीड देखा जा सकता है. इसके लिए, 'लाइन में लगाई गई स्ट्रीम' चुनें.
6. ऐप्लिकेशन बनाना
सबसे पहले, आपको ऐसा ऐप्लिकेशन बनाना होगा जो आपके डेटा को प्रोसेस करता हो. ऐप्लिकेशन को ऑटोमेटेड पाइपलाइन के तौर पर देखा जा सकता है, जो इन चीज़ों को जोड़ती है:
- डेटा डालना: किसी वीडियो फ़ीड को स्ट्रीम में डाला जाता है.
- डेटा का विश्लेषण: डेटा डालने के बाद, एआई(कंप्यूटर विज़न) मॉडल जोड़ा जा सकता है.
- डेटा स्टोरेज: वीडियो फ़ीड के दो वर्शन (ओरिजनल स्ट्रीम और एआई मॉडल से प्रोसेस की जाने वाली स्ट्रीम) को मीडिया वेयरहाउस में सेव किया जा सकता है.
Google Cloud Console में, किसी ऐप्लिकेशन को ग्राफ़ के तौर पर दिखाया जाता है.
खाली ऐप्लिकेशन बनाना
ऐप्लिकेशन ग्राफ़ में जानकारी भरने से पहले, आपको एक खाली ऐप्लिकेशन बनाना होगा.
Google Cloud Console में कोई ऐप्लिकेशन बनाएं.
- Google Cloud console पर जाएं.
- Vertex AI Vision के डैशबोर्ड में, ऐप्लिकेशन टैब खोलें. ऐप्लिकेशन टैब पर जाएं
- बनाएं बटन पर क्लिक करें.
- ऐप्लिकेशन के नाम के तौर पर ‘queue-app' डालें और अपना इलाका चुनें.
- बनाएं पर क्लिक करें.
ऐप्लिकेशन कॉम्पोनेंट नोड जोड़ना
खाली ऐप्लिकेशन बनाने के बाद, ऐप्लिकेशन ग्राफ़ में ये तीन नोड जोड़े जा सकते हैं:
- डेटा डालना नोड: वह स्ट्रीम संसाधन जो आपके notebook में बनाए गए rtsp वीडियो सर्वर से भेजे गए डेटा का डेटा डालता है.
- प्रोसेसिंग नोड: यह बुकिंग के डेटा पर काम करने वाला, बुकिंग के आंकड़े का विश्लेषण करने वाला मॉडल है.
- स्टोरेज नोड: वह मीडिया वेयरहाउस जहां प्रोसेस किए गए वीडियो सेव किए जाते हैं. साथ ही, यहां मेटाडेटा स्टोर भी होता है. मेटाडेटा स्टोर में, डाले गए वीडियो डेटा के आंकड़े और एआई मॉडल से अनुमानित जानकारी शामिल होती है.
कंसोल में अपने ऐप्लिकेशन में कॉम्पोनेंट नोड जोड़ें.
- Vertex AI Vision डैशबोर्ड का ऐप्लिकेशन टैब खोलें. ऐप्लिकेशन टैब पर जाएं
इससे, आपको प्रोसेसिंग पाइपलाइन का ग्राफ़ विज़ुअलाइज़ेशन दिखेगा.
डेटा डालने वाला नोड जोड़ना
- इनपुट स्ट्रीम नोड जोड़ने के लिए, साइड मेन्यू के कनेक्टर सेक्शन में जाकर, स्ट्रीम विकल्प चुनें.
- इसके बाद, खुलने वाले स्ट्रीम मेन्यू के सोर्स सेक्शन में, स्ट्रीम जोड़ें को चुनें.
- स्ट्रीम जोड़ें मेन्यू में, क्यू-स्ट्रीम चुनें.
- ऐप्लिकेशन ग्राफ़ में स्ट्रीम जोड़ने के लिए, स्ट्रीम जोड़ें पर क्लिक करें.
डेटा प्रोसेसिंग नोड जोड़ना
- बुकिंग की संख्या का मॉडल नोड जोड़ने के लिए, साइड मेन्यू के खास मॉडल सेक्शन में, बुकिंग की संख्या का आंकड़ा विकल्प चुनें.
- डिफ़ॉल्ट रूप से चुना गया लोग छोड़ें. अगर वाहन पहले से चुना हुआ है, तो उससे सही का निशान हटाएं.
- बेहतर विकल्प सेक्शन में, ऐक्टिव ज़ोन/लाइन बनाएं
पर क्लिक करें - पॉलीगॉन टूल का इस्तेमाल करके, ऐक्टिव ज़ोन बनाएं और उसमें मौजूद लोगों की संख्या देखें. ज़ोन को उसी हिसाब से लेबल करें
- सबसे ऊपर मौजूद, बैक ऐरो पर क्लिक करें.
- चेकबॉक्स पर क्लिक करके, वेबसाइट पर उपयोगकर्ताओं के रुकने के समय की सेटिंग जोड़ें, ताकि यह पता लगाया जा सके कि वेबसाइट पर कितने उपयोगकर्ता हैं.
डेटा स्टोरेज नोड जोड़ना
- आउटपुट डेस्टिनेशन (स्टोरेज) नोड जोड़ने के लिए, साइड मेन्यू के कनेक्टर सेक्शन में VIsion AI Warehouse विकल्प चुनें.
- Vertex AI वेयरहाउस कनेक्टर का मेन्यू खोलने के लिए, वेयरहाउस कनेक्ट करें पर क्लिक करें.
- वेयरहाउस कनेक्ट करें मेन्यू में, नया वेयरहाउस बनाएं चुनें. वेयरहाउस का नाम queue-warehouse रखें और टीटीएल की अवधि 14 दिन पर सेट करें.
- वेयरहाउस जोड़ने के लिए, बनाएं बटन पर क्लिक करें.
7. आउटपुट को BigQuery टेबल से कनेक्ट करना
Vertex AI Vision ऐप्लिकेशन में BigQuery कनेक्टर जोड़ने पर, कनेक्ट किए गए ऐप्लिकेशन मॉडल के सभी आउटपुट, टारगेट टेबल में डाल दिए जाएंगे.
आपके पास अपनी BigQuery टेबल बनाने का विकल्प है. साथ ही, ऐप्लिकेशन में BigQuery कनेक्टर जोड़ते समय, उस टेबल को तय किया जा सकता है. इसके अलावा, Vertex AI Vision ऐप्लिकेशन प्लैटफ़ॉर्म को टेबल अपने-आप बनाने की अनुमति भी दी जा सकती है.
टेबल अपने-आप बनना
अगर आपको Vertex AI Vision ऐप्लिकेशन प्लैटफ़ॉर्म को टेबल अपने-आप बनाने की अनुमति देनी है, तो BigQuery कनेक्टर नोड जोड़ते समय यह विकल्प चुना जा सकता है.
अगर आपको टेबल अपने-आप बनने की सुविधा का इस्तेमाल करना है, तो डेटासेट और टेबल के लिए ये शर्तें लागू होनी चाहिए:
- डेटासेट: अपने-आप जनरेट हुए डेटासेट का नाम visionai_dataset है.
- टेबल: अपने-आप जनरेट हुई टेबल का नाम visionai_dataset.APPLICATION_ID है.
- गड़बड़ी ठीक करना:
- अगर एक ही डेटासेट में, एक ही नाम वाली टेबल मौजूद है, तो अपने-आप कोई टेबल नहीं बनती.
- Vertex AI Vision के डैशबोर्ड में, ऐप्लिकेशन टैब खोलें. ऐप्लिकेशन टैब पर जाएं
- सूची में अपने ऐप्लिकेशन के नाम के बगल में मौजूद, ऐप्लिकेशन देखें को चुनें.
- ऐप्लिकेशन बिल्डर पेज पर, कनेक्टर सेक्शन से BigQuery चुनें.
- BigQuery पाथ फ़ील्ड को खाली छोड़ दें.
- स्टोर का मेटाडेटा इनसे लें: में जाकर, सिर्फ़ ‘बुकिंग की जानकारी का Analytics' चुनें और स्ट्रीम से सही का निशान हटाएं.
ऐप्लिकेशन का फ़ाइनल ग्राफ़ ऐसा दिखना चाहिए:
8. इस्तेमाल के लिए अपना ऐप्लिकेशन डिप्लॉय करना
सभी ज़रूरी कॉम्पोनेंट वाला एंड-टू-एंड ऐप्लिकेशन बनाने के बाद, उसे डिप्लॉय करने का आखिरी चरण, ऐप्लिकेशन को इस्तेमाल करना है.
- Vertex AI Vision के डैशबोर्ड में, ऐप्लिकेशन टैब खोलें. ऐप्लिकेशन टैब पर जाएं
- सूची में queue-app ऐप्लिकेशन के बगल में मौजूद, ऐप्लिकेशन देखें को चुनें.
- Studio पेज पर, डिप्लॉय करें बटन पर क्लिक करें.
- पुष्टि करने के लिए बने डायलॉग बॉक्स में, डिप्लॉय करें पर क्लिक करें. डिप्लॉय करने की प्रोसेस पूरी होने में कुछ मिनट लग सकते हैं. डिप्लॉयमेंट पूरा होने के बाद, नोड के बगल में हरे रंग के सही का निशान दिखते हैं.
9. स्टोरेज वेयरहाउस में वीडियो कॉन्टेंट खोजना
वीडियो डेटा को प्रोसेस करने वाले ऐप्लिकेशन में डालने के बाद, विश्लेषण किया गया वीडियो डेटा देखा जा सकता है. साथ ही, बुकिंग की संख्या के आंकड़ों की जानकारी के आधार पर डेटा खोजा जा सकता है.
- Vertex AI Vision के डैशबोर्ड में, वेयरहाउस टैब खोलें. वेयरहाउस टैब पर जाएं
- सूची में, queue-warehouse वेयरहाउस ढूंढें और ऐसेट देखें पर क्लिक करें.
- लोगों की संख्या सेक्शन में, कम से कम वैल्यू को 1 पर और ज़्यादा से ज़्यादा वैल्यू को 5 पर सेट करें.
- Vertex AI Vision के मीडिया वेयरहाउस में सेव किए गए, प्रोसेस किए गए वीडियो डेटा को फ़िल्टर करने के लिए, खोजें पर क्लिक करें.
Google Cloud console में, खोज के लिए इस्तेमाल की गई शर्तों से मैच करने वाले सेव किए गए वीडियो डेटा का व्यू.
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