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

François Beaufort
François Beaufort

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

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

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

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

1. नई Colab notebook बनाने के लिए, colab.new पर जाएं. यह पहली इमेज की तरह दिखना चाहिए. 2. अपने Google खाते में साइन इन करने के लिए दिए गए निर्देश का पालन करें.
नए Colab का स्क्रीनशॉट
पहली इमेज: एक नई Colab notebook.

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

  1. नोटबुक के सबसे ऊपर दाईं ओर मौजूद, कनेक्ट करें पर क्लिक करें.
  2. रनटाइम टाइप बदलें चुनें:
    रनटाइम बदलने का तरीका बताने वाला क्लोज़अप स्क्रीनशॉट.
    दूसरी इमेज. Colab इंटरफ़ेस में रनटाइम बदलें.
  3. मॉडल विंडो में, हार्डवेयर एक्सेलरेटर के तौर पर T4 जीपीयू चुनें. कनेक्ट करने पर, Colab किसी ऐसे Linux इंस्टेंस का इस्तेमाल करेगा जिसमें NVIDIA T4 जीपीयू जुड़ा हो.
    रनटाइम टाइप बदलें मॉड्यूल का स्क्रीनशॉट.
    तीसरा इलस्ट्रेशन: हार्डवेयर एक्सेलरेटर में जाकर, T4 GPU चुनें.
  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
    
    # 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. कोड को लागू करने के लिए, सेल के बगल में मौजूद पर क्लिक करें.

    नए Colab का स्क्रीनशॉट
    चौथी इमेज.

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

    पांचवां चित्र: "NVIDIA-SMI" से शुरू होने वाला आउटपुट देखें.

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

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

पहला भाग: कमांड लाइन में बिना ग्राफ़िक यूज़र इंटरफ़ेस वाले 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 में सेव किया है. उस फ़ाइल को देखने के लिए, कॉन्टेंट को बड़ा करें. इसके बाद, पीडीएफ़ फ़ाइल को अपनी लोकल मशीन पर डाउनलोड करने के लिए, पर क्लिक करें.

नए Colab का स्क्रीनशॉट
छठी इमेज: Colab इंटरफ़ेस के इस स्क्रीन कैप्चर में, पीडीएफ़ डाउनलोड करने का तरीका देखें.

दूसरा चरण: 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 बाइनरी को उसी तरीके से चलाया जा सकता है जिससे हमें 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 क्लासिफ़ायर, ब्राउज़र में क्लाइंट-साइड प्रोसेसिंग के साथ, जीपीयू का इस्तेमाल करके, किसी इमेज में पैंट को सही तरीके से पहचान सकता है.

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

नए Colab का स्क्रीनशॉट
सातवां इलस्ट्रेशन: जीपीयू की मदद से तेज़ी से काम करने वाले TensorFlow.js मॉडल का कैप्चर, जो क्लाइंट साइड पर ब्राउज़र में कपड़ों को रीयल टाइम में पहचान सकता है

संसाधन

आगे के अपडेट पाने के लिए, GitHub रेपो पर एक स्टार जोड़ें.