Google Colab में वेब एआई (AI) मॉडल की टेस्टिंग

Jason Mayes

François Beaufort

जीपीयू के साथ, टेस्टिंग का एक जैसा एनवायरमेंट सेट अप करना, उम्मीद से ज़्यादा मुश्किल हो सकता है. क्लाइंट-साइड, ब्राउज़र पर आधारित एआई मॉडल को असल ब्राउज़र एनवायरमेंट में टेस्ट करने का तरीका यहां बताया गया है. साथ ही, यह भी बताया गया है कि मॉडल को स्केल किया जा सकता है, अपने-आप काम कर सकता है, और इसे स्टैंडर्ड हार्डवेयर सेटअप में इस्तेमाल किया जा सकता है.

इस मामले में, ब्राउज़र एक असल Chrome ब्राउज़र है, जिसमें हार्डवेयर की सुविधा है. यह सॉफ़्टवेयर इम्यूलेशन के बजाय है.

भले ही, आप वेब एआई, वेब गेमिंग या ग्राफ़िक्स डेवलपर हों या वेब एआई मॉडल की जांच में दिलचस्पी रखते हों, यह गाइड आपके लिए है.

पहला चरण: Google Colab की नई नोटबुक बनाना

दूसरा चरण: T4 जीपीयू की सुविधा वाले सर्वर से कनेक्ट करना

1. नोटबुक के सबसे ऊपर दाईं ओर, कनेक्ट करें arrow_drop_down पर क्लिक करें.
2. रनटाइम टाइप बदलें चुनें:

   

3. मॉडल विंडो में, हार्डवेयर एक्सेलरेटर के तौर पर T4 जीपीयू चुनें. कनेक्ट करने पर, Colab किसी ऐसे Linux इंस्टेंस का इस्तेमाल करेगा जिसमें NVIDIA T4 जीपीयू जुड़ा हो.

   

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

बहुत बढ़िया, आपने अभी-अभी एक ऐसा सर्वर बनाया है जिसमें GPU अटैच है.

तीसरा चरण: सही ड्राइवर और डिपेंडेंसी इंस्टॉल करना

1. कोड की नीचे दी गई दो लाइनों को कॉपी करके, नोटबुक की पहली कोड सेल में चिपकाएं. Colab एनवायरमेंट में, कमांड लाइन के एक्ज़ीक्यूशन के शुरू में विस्मयादिबोधक चिह्न होता है.

   !git clone https://github.com/jasonmayes/headless-chrome-nvidia-t4-gpu-support.git
   !cd headless-chrome-nvidia-t4-gpu-support && chmod +x scriptyMcScriptFace.sh && ./scriptyMcScriptFace.sh
   

   • GitHub पर स्क्रिप्ट की जांच करके, यह देखा जा सकता है कि स्क्रिप्ट कौनसा रॉ कमांड लाइन कोड लागू करती है.

   # Update, install correct drivers, and remove the old ones.
   apt-get install -y vulkan-tools libnvidia-gl-525
   
   # Verify NVIDIA drivers can see the T4 GPU and that vulkan is working correctly.
   nvidia-smi
   vulkaninfo --summary
   
   # Now install latest version of Node.js
   npm install -g n
   n lts
   node --version
   npm --version
   
   # Next install Chrome stable
   curl -fsSL https://dl.google.com/linux/linux_signing_key.pub | sudo gpg --dearmor -o /usr/share/keyrings/googlechrom-keyring.gpg
   echo "deb [arch=amd64 signed-by=/usr/share/keyrings/googlechrom-keyring.gpg] http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee /etc/apt/sources.list.d/google-chrome.list
   sudo apt update
   sudo apt install -y google-chrome-stable
   
   # Start dbus to avoid warnings by Chrome later.
   export DBUS_SESSION_BUS_ADDRESS="unix:path=/var/run/dbus/system_bus_socket"
   /etc/init.d/dbus start
   

2. कोड लागू करने के लिए, सेल के बगल में मौजूद play_circle पर क्लिक करें.

   

3. कोड पूरा होने के बाद, पुष्टि करें कि nvidia-smi ने नीचे दिए गए स्क्रीनशॉट जैसा कुछ प्रिंट किया है. इससे यह पक्का किया जा सकेगा कि आपके पास सचमुच एक GPU जुड़ा है और उसे आपके सर्वर पर पहचाना गया है. यह आउटपुट देखने के लिए, आपको लॉग में पहले की ओर स्क्रोल करना पड़ सकता है.

   

चौथा चरण: बिना ग्राफ़िक यूज़र इंटरफ़ेस वाले Chrome का इस्तेमाल करना और उसे ऑटोमेट करना

1. नई कोड सेल जोड़ने के लिए, add कोड बटन पर क्लिक करें.
2. इसके बाद, अपने पसंदीदा पैरामीटर के साथ Node.js प्रोजेक्ट को कॉल करने के लिए, अपना कस्टम कोड लिखा जा सकता है. इसके अलावा, सीधे कमांड लाइन में google-chrome-stable को कॉल किया जा सकता है. हमारे पास इन दोनों के उदाहरण हैं.

पहला चरण: सीधे कमांड लाइन में Headless Chrome का इस्तेमाल करना

# Directly call Chrome to dump a PDF of WebGPU testing page
# and store it in /content/gpu.pdf
!google-chrome-stable \
--no-sandbox \
--headless=new \
--use-angle=vulkan \
--enable-features=Vulkan \
--disable-vulkan-surface \
--enable-unsafe-webgpu \
--print-to-pdf=/content/gpu.pdf https://webgpureport.org

उदाहरण में, हमने कैप्चर किए गए PDF को /content/gpu.pdf में सेव किया है. उस फ़ाइल को देखने के लिए, कॉन्टेंट folder को बड़ा करें. इसके बाद, पीडीएफ़ फ़ाइल को अपनी लोकल मशीन पर डाउनलोड करने के लिए, more_vert पर क्लिक करें.

दूसरा चरण: Puppeteer की मदद से Chrome को निर्देश देना

हमने बिना ग्राफ़िक यूज़र इंटरफ़ेस वाले Chrome को कंट्रोल करने के लिए, Puppeteer का इस्तेमाल करने का एक छोटा सा उदाहरण दिया है. इसे इस तरह चलाया जा सकता है:

# Call example node.js project to perform any task you want by passing
# a URL as a parameter
!node headless-chrome-nvidia-t4-gpu-support/examples/puppeteer/jPuppet.js chrome://gpu

jPuppet के उदाहरण में, स्क्रीनशॉट बनाने के लिए, हम Node.js स्क्रिप्ट को कॉल कर सकते हैं. लेकिन यह कैसे काम करता है? jPuppet.js में मौजूद Node.js कोड के बारे में जानकारी देने वाली यह गाइड देखें.

jPuppet.js Node कोड का ब्रेकडाउन

सबसे पहले, Puppeteer इंपोर्ट करें. इससे, Node.js की मदद से Chrome को कहीं से भी कंट्रोल किया जा सकता है:

import puppeteer from 'puppeteer';

इसके बाद, देखें कि Node ऐप्लिकेशन को कौनसे कमांड लाइन आर्ग्युमेंट पास किए गए थे. पक्का करें कि तीसरा आर्ग्युमेंट सेट हो—यह उस यूआरएल को दिखाता है जिस पर नेविगेट करना है. आपको यहां तीसरे आर्ग्युमेंट की जांच करनी होगी, क्योंकि पहले दो आर्ग्युमेंट, Node और उस स्क्रिप्ट को कॉल करते हैं जिसे हम चला रहे हैं. तीसरे एलिमेंट में, नोड प्रोग्राम में पास किया गया पहला पैरामीटर होता है:

const url = process.argv[2];
if (!url) {
  throw "Please provide a URL as the first argument";
}

अब runWebpage() नाम का असाइनोक्रोनस फ़ंक्शन तय करें. इससे एक ब्राउज़र ऑब्जेक्ट बनता है, जिसे कमांड-लाइन आर्ग्युमेंट के साथ कॉन्फ़िगर किया जाता है. इससे, Chrome बाइनरी को उसी तरह से चलाया जा सकता है जिस तरह से हमें WebGL और WebGPU को काम करने के लिए चलाना है. इस बारे में WebGPU और WebGL की सुविधा चालू करना में बताया गया है.

async function runWebpage() {
  const browser = await puppeteer.launch({
    headless: 'new',
    args:  [
        '--no-sandbox',
        '--headless=new',
        '--use-angle=vulkan',
        '--enable-features=Vulkan',
        '--disable-vulkan-surface',
        '--enable-unsafe-webgpu'
      ]
  });

एक नया ब्राउज़र पेज ऑब्जेक्ट बनाएं, जिसका इस्तेमाल बाद में किसी भी यूआरएल पर जाने के लिए किया जा सकता है:

const page = await browser.newPage();

इसके बाद, वेब पेज पर JavaScript लागू होने पर console.log इवेंट को सुनने के लिए, इवेंट की पहचान करने वाला टूल जोड़ें. इसकी मदद से, Node कमांड लाइन पर मैसेज को लॉग किया जा सकता है. साथ ही, कंसोल टेक्स्ट में किसी खास वाक्यांश (इस मामले में, captureAndEnd) की जांच की जा सकती है, जो स्क्रीनशॉट को ट्रिगर करता है और फिर Node में ब्राउज़र प्रोसेस को खत्म करता है. यह उन वेब पेजों के लिए फ़ायदेमंद है जिनका स्क्रीनशॉट लेने से पहले, कुछ काम करना ज़रूरी होता है. साथ ही, इनमें काम पूरा होने में लगने वाला समय तय नहीं होता.

page.on('console', async function(msg) {
  console.log(msg.text());
  if (msg.text() === 'captureAndEnd') {
    await page.screenshot({ path: '/content/screenshotEnd.png' });
    await browser.close();
  }
});

आखिर में, पेज को दिए गए यूआरएल पर जाने का निर्देश दें और पेज लोड होने पर, शुरुआती स्क्रीनशॉट लें.

अगर आपको chrome://gpu का स्क्रीनशॉट लेना है, तो किसी भी कंसोल आउटपुट का इंतज़ार करने के बजाय, ब्राउज़र सेशन को तुरंत बंद किया जा सकता है. ऐसा इसलिए, क्योंकि इस पेज को आपके कोड से कंट्रोल नहीं किया जाता.

  await page.goto(url,  { waitUntil: 'networkidle2' });
  await page.screenshot({path: '/content/screenshot.png'});
  if (url === 'chrome://gpu') {
    await browser.close();
  }
}
runWebpage();

package.json में बदलाव करना

आपने देखा होगा कि हमने jPuppet.js फ़ाइल की शुरुआत में, इंपोर्ट स्टेटमेंट का इस्तेमाल किया है. आपके package.json को टाइप वैल्यू को module के तौर पर सेट करना होगा. ऐसा न करने पर, आपको गड़बड़ी का मैसेज मिलेगा कि मॉड्यूल अमान्य है.

 {
    "dependencies":  {
      "puppeteer": "*"
    },
    "name": "content",
    "version": "1.0.0",
    "main": "jPuppet.js",
    "devDependencies": {},
    "keywords": [],
    "type": "module",
    "description": "Node.js Puppeteer application to interface with headless Chrome with GPU support to capture screenshots and get console output from target webpage"
}

बस इतना ही. Puppeteer का इस्तेमाल करके, प्रोग्राम के हिसाब से Chrome के साथ इंटरफ़ेस करना आसान हो जाता है.

काम हो गया

अब हम पुष्टि कर सकते हैं कि TensorFlow.js Fashion MNIST क्लासिफ़ायर, ब्राउज़र में क्लाइंट-साइड प्रोसेसिंग के साथ, जीपीयू का इस्तेमाल करके, किसी इमेज में पैंट को सही तरीके से पहचान सकता है.

इसका इस्तेमाल, क्लाइंट-साइड के जीपीयू पर आधारित किसी भी तरह के वर्कलोड के लिए किया जा सकता है. जैसे, मशीन लर्निंग मॉडल से लेकर ग्राफ़िक्स और गेम की जांच करना.

संसाधन

आने वाले समय में अपडेट पाने के लिए, GitHub repo पर स्टार का निशान जोड़ें.