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

Jason Mayes

François Beaufort

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

इस मामले में, ब्राउज़र हार्डवेयर समर्थन वाला एक वास्तविक Chrome ब्राउज़र है, यह सॉफ़्टवेयर एम्युलेटर पर निर्भर करता है.

चाहे आप वेब एआई हों, वेब गेमिंग हों या ग्राफ़िक्स डेवलपर हों या फिर आपने खुद को अगर आपको वेब एआई (AI) मॉडल की टेस्टिंग में दिलचस्पी है, तो यह गाइड आपके लिए है.

पहला चरण: एक नई Google Colab notebook बनाना

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

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

   

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

   

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

बहुत बढ़िया, आपने अभी-अभी जीपीयू से जुड़ा सर्वर बनाया है.

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

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 ने कुछ प्रिंट आउट कर दिया है नीचे दिए गए स्क्रीनशॉट की तरह ही, यह पुष्टि करता है कि आपके पास वाकई में जीपीयू है अटैच किया गया है और यह आपके सर्वर पर पहचाना जाता है. आपको पहले तक स्क्रोल करना पड़ सकता है इस आउटपुट को देखने के लिए लॉग में.

   

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

1. नया कोड जोड़ने के लिए, add कोड बटन पर क्लिक करें कोड सेल.
2. इसके बाद, अपने पसंदीदा पैरामीटर (या सिर्फ़ 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 में सेव किया है. यहां की यात्रा पर हूं उस फ़ाइल को देखने के लिए, कॉन्टेंट folder को बड़ा करें. इसके बाद, PDF डाउनलोड करने के लिए, more_vert पर क्लिक करें फ़ाइल को कंप्यूटर में सेव किया जा सकता है.

भाग B: Puppeteer के साथ Chrome को निर्देश दें

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

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

सबसे पहले, Puppeteer को इंपोर्ट करें. इससे हमें आप Chrome को Node.js के ज़रिए दूर से नियंत्रित करते हैं:

import puppeteer from 'puppeteer';

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

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();

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

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

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

संसाधन

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