LiteRT.js, TensorFlow.js-ஐ முந்துகிறது

LiteRT.js (WebGPU உடன்) ஒரு MobileNetV2 அனுமானத்தை (inference) 0.41 ms-இல் இயக்குகிறது, இது M2 Max டெஸ்க்டாப் GPU-வில் 2,439 FPS வேகத்தை வழங்குகிறது—இது அதே வன்பொருளில் இயங்கும் TensorFlow.js-ஐ விட 25 மடங்குக்கும் அதிகமான வேகமாகும். பெரிய மாடல்களுக்கு இந்த இடைவெளி இன்னும் அதிகமாகிறது, இது இணைய அடிப்படையிலான இயந்திரக் கற்றலை (machine learning) ஒரு காலத்தில் நேட்டிவ் செயலிகளுக்கு (native apps) மட்டுமே இருந்த செயல்திறன் நிலைக்குக் கொண்டு செல்கிறது.

இந்த பெஞ்ச்மார்க் ஏன் முக்கியமானது

டெவலப்பர்கள் சாதனத்திலேயே (on-device) அனுமானங்களைச் செய்ய TensorFlow.js-ஐப் பயன்படுத்தி வருகின்றனர், பொதுவாக WebGL பேக்எண்ட் (backend) மூலம் இது செய்யப்படுகிறது. WebGL, டென்சர் செயல்பாடுகளை (tensor ops) உலாவியின் (browser) 2-D கிராபிக்ஸ் பைப்லைனுடன் இணைக்கிறது; இது எல்லா இடங்களிலும் வேலை செய்யும், ஆனால் டீப்-லேர்னிங் மாடல்களுக்குத் தேவையான மிகப்பெரிய இணையாகச் செயல்படும் திறனுக்காக (parallelism) இது உருவாக்கப்படவில்லை. அடுத்த தலைமுறை கிராபிக்ஸ் API-யான WebGPU, GPU கணக்கீட்டு அலகுகளுக்கு (compute units) நேரடி அணுகலை வழங்குகிறது. TensorFlow-Lite மாடல்களுக்காக WebGPU-ஆதரவு கொண்ட அனுமான இயந்திரத்தை (inference engine) வழங்கும் முதல் லைப்ரரி LiteRT.js ஆகும், மேலும் கூகுள் (Google) இதில் மூன்று மடங்கு வேக அதிகரிப்பைக் குறிப்பிட்டுள்ளது. சுயாதீன சோதனைகள் இன்னும் பெரிய முன்னேற்றத்தைக் காட்டுகின்றன, இது WebGPU இணைய இயந்திரக் கற்றலுக்கான (web ML) இயல்புநிலை பாதையாக இருக்குமா என்ற கேள்வியை எழுப்புகிறது.

சோதனை எவ்வாறு நடத்தப்பட்டது

நாங்கள் இரண்டு பட வகைப்பாடு (image-classification) மாடல்களை—MobileNetV2 மற்றும் EfficientNet-Lite4—பெஞ்ச்மார்க் செய்தோம், இவை இரண்டும் TensorFlow-Lite-ஆக மாற்றப்பட்டவை. சோதனைகள் Apple-silicon M2 Max சிப்பில் நடத்தப்பட்டன. ஒவ்வொரு மாடலுக்கும், பல சுழற்சிகளில் (iterations) ஒரு ஒற்றை ஃபார்வர்ட் பாஸின் (forward pass) தாமதத்தை (latency) அளந்து, வினாடிக்கு எத்தனை பிரேம்கள் (FPS) என்பதைப் பதிவு செய்தோம். அதே மாடல்களை WebGL பேக்எண்டில் TensorFlow.js மூலம் இயக்கி, ஒவ்வொரு லைப்ரரியின் கோல்ட்-ஸ்டார்ட் (cold-start) நேரத்தையும் பதிவு செய்தோம்.

முடிவுகள்: வேகம் மற்றும் தொடக்கம் (startup)

  • MobileNetV2

    • LiteRT.js (WebGPU): 0.41 ms தாமதம் → 2,439 FPS
    • TensorFlow.js (WebGL): 10.82 ms தாமதம் → 92 FPS

  • EfficientNet-Lite4

    • LiteRT.js (WebGPU): 0.62 ms தாமதம் → 1,623 FPS
    • TensorFlow.js (WebGL): தெரிவிக்கப்படவில்லை, ஆனால் MobileNetV2 ஏற்கனவே >25× முன்னிலையைக் காட்டுகிறது.

TensorFlow.js தனது முதல் அனுமானத்திற்கு முன்னதாக WebGL ஷேடர்களை (shaders) கம்பைல் செய்ய சுமார் 10 வினாடிகள் (10,014 ms) எடுத்துக்கொண்டது. LiteRT.js வெறும் 4.3 ms-இல் தயாராகிவிட்டது, இது ஊடாடும் செயலிகளுக்கு (interactive apps) ஏற்படும் கோல்ட்-ஸ்டார்ட் பாதிப்பை அடிப்படையில் நீக்கிவிடுகிறது.

நாங்கள் மாடலின் அளவை ஐந்து மடங்கு அதிகரித்தபோது, தாமதம் 50% மட்டுமே அதிகரித்தது, இது GPU-வின் இணையாகச் செயல்படும் திறன் (parallelism) கூடுதல் வேலையைத் தாங்கிக்கொள்கிறது என்பதை உறுதிப்படுத்துகிறது. இதன் விளைவாக, ஒரு உலாவியே (browser) சர்வர் தொடர்புகள் (server round-trips) இன்றி நிகழ்நேர வீடியோ ஸ்ட்ரீம்கள், AR ஓவர்லேக்கள் அல்லது விஷன் மாடல்களின் விரைவான முன்மாதிரிகளை (rapid prototyping) கையாளும் அளவுக்குச் செயல்திறன் கிடைக்கிறது.

எண்கள் மறைக்கும் விஷயங்கள்

  • Batching – பெரும்பாலான TensorFlow-Lite மாடல்கள் பேட்ச் பரிமாணத்தை (batch dimension) 1 ஆகக் கட்டுப்படுத்துகின்றன. ஒரே அழைப்பில் பல படங்களை வழங்குவது நேரடியாக ஆதரிக்கப்படவில்லை, இதனால் டெவலப்பர்கள் Web Workers-களை உருவாக்க வேண்டியுள்ளது அல்லது உள்ளீடுகளை (inputs) கைமுறையாகப் பைப்லைன் செய்ய வேண்டியுள்ளது.
  • Memory management – LiteRT.js தானாகவே GPU டென்சர்களை (tensors) கேரேஜ்-கலெக்ட் (garbage-collect) செய்வதில்லை. டெவலப்பர்கள் தாங்கள் உருவாக்கும் ஒவ்வொரு டென்சருக்கும் .delete() என்பதை அழைக்க வேண்டும், இல்லையெனில் சில நூறு அனுமானங்களுக்குப் பிறகு GPU நினைவகம் (memory) தீர்ந்துபோகும் அபாயம் உள்ளது.
  • Hardware reach – டெஸ்க்டாப் Chrome மற்றும் Firefox ஆகியவற்றில் WebGPU நிலையானது. ஆண்ட்ராய்டில் Chrome மற்றும் iOS-இல் Safari உள்ளிட்ட மொபைல் உலாவிகள், இந்த API-யை சோதனை ரீதியான ஃபிளாக்ஸ் (experimental flags) மூலம் மட்டுமே வழங்குகின்றன அல்லது வழங்கவே இல்லை. அந்தத் தளங்களில் WASM பேக்எண்ட் மட்டுமே உலகளாவிய ரீதியில் கிடைக்கும் வழியாக உள்ளது, ஆனால் பெரிய மாடல்களுக்கு இது குறிப்பிடத்தக்க அளவு மெதுவாக உள்ளது.

இந்தக் கட்டுப்பாடுகள் என்ன சொல்கின்றனவென்றால், அதன் வேகம் வியக்கத்தக்கதாக இருந்தாலும், அதை அடைவதற்கான பொறியியல் முயற்சி (engineering effort) எளிதானது அல்ல.

வரம்புகள் மற்றும் சமரசங்கள் (trade-offs)

TensorFlow.js-ன் WebGL பேக்எண்ட் இன்னும் கிட்டத்தட்ட உலகளாவிய இணக்கத்தன்மையை (compatibility) வழங்குகிறது. டெஸ்க்டாப், ஆண்ட்ராய்டு, iOS எனப் பல்வேறு பயனர்களைக் குறிவைக்கும் ஒரு டெவலப்பர், குறைந்த செயல்திறனில் இயங்கினாலும், எல்லா இடங்களிலும் இயங்கும் ஒரே குறியீட்டுப் பாதையை (code path) நம்பியிருக்கலாம். WASM பேக்எண்ட் கிட்டத்தட்ட எந்தவொரு வன்பொருளிலும் இயங்கும், ஆனால் இங்கே அளவிடப்பட்ட பெரிய மாடல்களுக்கு WebGPU-வை விடப் பின்தங்கியுள்ளது.

WebGPU இயக்கப்பட்ட டெஸ்க்டாப் சூழலை இலக்காகக் கொள்ளும்போது LiteRT.js சிறப்பாகச் செயல்படுகிறது. இது .tflite மாடல்களை நேரடியாக இயக்குகிறது, இதனால் டெவலப்பர்கள் மாடல்களை மாற்றாமல் (conversion) Hugging Face அல்லது Kaggle-லிருந்து நேரடியாகப் பெற முடியும், மேலும் இது அசல் குவாண்ட்டைசேஷன் (quantization) மற்றும் செயல்திறனைப் பாதுகாக்கிறது. இதன் சமரசம் என்னவென்றால், இது குறைந்த அளவிலான பயன்பாட்டுச் சூழலையே (deployment envelope) கொண்டது மற்றும் வளங்களை (resources) கவனமாக கையாள வேண்டிய அவசியம் உள்ளது.

டெவலப்பர்கள் எவற்றைக் கருத்தில் கொள்ள வேண்டும்

  • Target platform – இணைய அடிப்படையிலான டெஸ்க்டாப் கருவிக்காக (எ.கா. நிகழ்நேரத்தில் ஸ்டைல் டிரான்ஸ்பர் செய்யும் ஒரு டிசைன் ஆப்) என்றால், LiteRT.js உடன் WebGPU சிறந்த தேர்வாக இருக்கும்.
  • Model size – பெரிய மற்றும் கணக்கீட்டுத் திறன் அதிகம் தேவைப்படும் மாடல்கள் GPU இணையாகச் செயல்படும் திறனிலிருந்து அதிகப் பலனைப் பெறும்; சிறிய மாடல்களுக்கு கூடுதல் பொறியியல் முயற்சி தேவைப்படாது.
  • Memory discipline – டென்சர்களைத் திட்டமிட்டு நீக்குவதை உறுதி செய்யவும் அல்லது வளங்களை தானாகவே விடுவிக்கும் வகையில் அனுமான அழைப்புகளை (inference calls) ஒரு ஸ்கோப்பிற்குள் (scope) வைக்கவும்.
  • Fallback strategy – WebGPU-வை இயக்க முடியாத உலாவிகளுக்கு WASM அல்லது WebGL மாற்று வழியை (fallback) வழங்கவும், இதன் மூலம் அதிகப்படியான பயனர்களுக்குச் செயலி பயன்படும் வகையில் இருப்பதை உறுதி செய்யலாம்.

சுருக்கம்

LiteRT.js, WebGPU மூலம் இணைய அடிப்படையிலான inference-ஐ மில்லி விநாடிக்கும் குறைவான நிலைக்குக் கொண்டு செல்ல முடியும் என்பதை நிரூபிக்கிறது; இது டெஸ்க்டாப் GPUs-களில் TensorFlow.js-ஐ விட 25 × மடங்குக்கும் அதிகமான வேகத்தை வழங்குகிறது. இந்தத் தொழில்நுட்பம் இன்னும் வளர்ச்சியடைந்து வருகிறது, மேலும் டெவலப்பர்கள் batching வரம்புகள், manual memory cleanup மற்றும் மட்டுப்படுத்தப்பட்ட மொபைல் ஆதரவு ஆகியவற்றைச் சமாளிக்க வேண்டியுள்ளது. நிகழ்நேர செயல்திறன் தேவைப்படும் டெஸ்க்டாப் முன்னுரிமை கொண்ட அனுபவங்களுக்கு, இந்த புதிய library ஒரு சிறந்த பாதையை வழங்குகிறது; பல்வேறு தளங்களுக்குச் சென்றடைய, பழைய WebGL மற்றும் WASM backends அவசியமானவையாக உள்ளன.