LiteRT.js, TensorFlow.js కంటే మెరుగైన పనితీరును కనబరుస్తోంది

WebGPUతో కూడిన LiteRT.js, MobileNetV2 ఇన్‌ఫరెన్స్‌ను 0.41 msలో పూర్తి చేస్తుంది, ఇది M2 Max డెస్క్‌టాప్ GPUపై 2,439 FPS వేగాన్ని అందిస్తుంది—ఇది అదే హార్డ్‌వేర్‌పై ఉన్న TensorFlow.js కంటే 25 × కంటే ఎక్కువ వేగవంతమైనది. పెద్ద మోడల్స్ విషయంలో ఈ వ్యత్యాసం ఇంకా పెరుగుతుంది, దీనివల్ల వెబ్ ఆధారిత మెషిన్ లెర్నింగ్ (machine learning) ఒకప్పుడు నేటివ్ యాప్‌లకే పరిమితమైన అత్యున్నత పనితీరు స్థాయికి చేరుకుంటుంది.

ఈ బెంచ్‌మార్క్ ఎందుకు ముఖ్యమైనది

డెవలపర్లు సాధారణంగా WebGL బ్యాకెండ్ ద్వారా ఆన్-డివైస్ ఇన్‌ఫరెన్స్ కోసం TensorFlow.jsని ఉపయోగిస్తున్నారు. WebGL టెన్సర్ ఆపరేషన్లను (tensor ops) బ్రౌజర్ యొక్క 2-D గ్రాఫిక్స్ పైప్‌లైన్‌కు మ్యాప్ చేస్తుంది; ఇది అన్ని చోట్లా పనిచేస్తుంది కానీ డీప్-లెర్నింగ్ మోడల్స్‌కు అవసరమైన భారీ సమాంతరత (parallelism) కోసం దీనిని రూపొందించలేదు. తదుపరి తరం గ్రాఫిక్స్ API అయిన WebGPU, GPU కంప్యూట్ యూనిట్‌లకు నేరుగా ప్రాప్యతను అందిస్తుంది. TensorFlow-Lite మోడల్స్ కోసం WebGPU-బ్యాక్డ్ ఇన్‌ఫరెన్స్ ఇంజిన్‌ను అందించిన మొదటి లైబ్రరీ LiteRT.js, మరియు Google ప్రకారం ఇది మూడు రెట్లు వేగవంతమైనది. స్వతంత్ర పరీక్షలు ఇంకా ఎక్కువ లాభాన్ని చూపుతున్నాయి, దీనివల్ల వెబ్ ML కోసం WebGPU డిఫాల్ట్ మార్గంగా మారుతుందా అనే ప్రశ్న తలెత్తుతోంది.

పరీక్ష ఎలా నిర్వహించబడింది

మేము రెండు ఇమేజ్-క్లాసిఫికేషన్ మోడల్స్—MobileNetV2 మరియు EfficientNet-Lite4—రెండింటినీ TensorFlow-Liteకి మార్చి బెంచ్‌మార్క్ చేశాము. ఈ పరీక్షలు Apple-silicon M2 Max చిప్‌పై నిర్వహించబడ్డాయి. ప్రతి మోడల్ కోసం, మేము అనేక ఇటరేషన్ల ద్వారా ఒకే ఫార్వర్డ్ పాస్ యొక్క లాటెన్సీని (latency) కొలిచి, ఫ్రేమ్స్-పర్-సెకండ్ (FPS) ని నివేదించాము. మేము అదే మోడల్స్‌ను WebGL బ్యాకెండ్‌తో TensorFlow.js ద్వారా రన్ చేసి, ప్రతి లైబ్రరీ యొక్క కోల్డ్-స్టార్ట్ (cold-start) సమయాన్ని నమోదు చేశాము.

ఫలితాలు: వేగం మరియు స్టార్టప్

  • 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× లాభాన్ని చూపుతోంది.

మొదటి ఇన్‌ఫరెన్స్‌కు ముందు తన WebGL షేడర్‌లను (shaders) కంపైల్ చేయడానికి TensorFlow.js సుమారు 10 సెకన్లు (10,014 ms) తీసుకుంది. LiteRT.js కేవలం 4.3 ms లోనే సిద్ధమైంది, ఇది ఇంటరాక్టివ్ యాప్‌ల కోసం కోల్డ్-స్టార్ట్ పెనాల్టీని దాదాపుగా తొలగించింది.

మేము మోడల్ పరిమాణాన్ని ఐదు రెట్లు పెంచినప్పుడు, లాటెన్సీ కేవలం 50% మాత్రమే పెరిగింది, దీనివల్ల GPU యొక్క సమాంతరత (parallelism) అదనపు పనిని ఎక్కువగా తట్టుకుంటుందని నిర్ధారించబడింది. దీని ఫలితంగా, సర్వర్ రౌండ్-ట్రిప్స్ (server round-trips) లేకుండానే బ్రౌజర్ రియల్-టైమ్ వీడియో స్ట్రీమ్‌లు, AR ఓవర్‌లేలు లేదా విజన్ మోడల్స్ యొక్క వేగవంతమైన ప్రోటోటైపింగ్‌ను నిర్వహించగలిగే పనితీరు స్థాయి అందుబాటులోకి వచ్చింది.

ఈ గణాంకాలు దాచే అంశాలు

  • Batching – చాలా TensorFlow-Lite మోడల్స్ బ్యాచ్ డైమెన్షన్‌ను 1కి లాక్ చేస్తాయి. ఒకే కాల్‌లో బహుళ చిత్రాలను అందించడం (feeding multiple images) నేరుగా సపోర్ట్ చేయబడదు, దీనివల్ల డెవలపర్లు Web Workersలను సృష్టించాల్సి రావడం లేదా మాన్యువల్‌గా ఇన్‌పుట్‌లను పైప్‌లైన్ చేయాల్సి రావడం వంటివి చేయాల్సి ఉంటుంది.
  • Memory management – LiteRT.js GPU టెన్సర్లను (tensors) ఆటోమేటిక్‌గా గార్బేజ్-కలెక్ట్ చేయదు. డెవలపర్లు తాము సృష్టించిన ప్రతి టెన్సర్‌పై .delete()ని పిలవాలి, లేకపోతే కొన్ని వందల ఇన్‌ఫరెన్స్‌ల తర్వాత GPU మెమరీ అయిపోయే ప్రమాదం ఉంది.
  • Hardware reach – డెస్క్‌టాప్ Chrome మరియు Firefoxలలో WebGPU స్థిరంగా ఉంది. ఆండ్రాయిడ్‌లో Chrome మరియు iOSలో Safariతో సహా మొబైల్ బ్రౌజర్‌లు ఈ APIని కేవలం ప్రయోగాత్మక ఫ్లాగ్‌ల (experimental flags) ద్వారా మాత్రమే అందిస్తాయి లేదా అసలు అందించవు. ఆ ప్లాట్‌ఫారమ్‌లలో WASM బ్యాకెండ్ మాత్రమే విశ్వవ్యాప్తంగా అందుబాటులో ఉన్న మార్గం, కానీ పెద్ద మోడల్స్ కోసం ఇది గణనీయంగా నెమ్మదిగా ఉంటుంది.

ఈ పరిమితుల వల్ల, ముడి వేగం (raw speed) ఆకట్టుకున్నప్పటికీ, దానిని సాధించడానికి అవసరమైన ఇంజనీరింగ్ ప్రయత్నం తక్కువ కాదు.

పరిమితులు మరియు లాభనష్టాలు

TensorFlow.js యొక్క WebGL బ్యాకెండ్ ఇప్పటికీ దాదాపు విశ్వవ్యాప్త అనుకూలతను (universal compatibility) అందిస్తుంది. డెస్క్‌టాప్, ఆండ్రాయిడ్, iOS వంటి వివిధ రకాల వినియోగదారులను లక్ష్యంగా చేసుకునే డెవలపర్, తక్కువ త్రూపుట్ (throughput) ఉన్నప్పటికీ, అన్ని చోట్లా నడిచే ఒకే కోడ్ పాత్‌పై ఆధారపడవచ్చు. WASM బ్యాకెండ్ దాదాపు ఏ హార్డ్‌వేర్‌లోనైనా నడుస్తుంది కానీ ఇక్కడ కొలిచిన పెద్ద మోడల్స్ విషయంలో WebGPU కంటే వెనుకబడి ఉంటుంది.

WebGPU ఎనేబుల్ చేయబడిన డెస్క్‌టాప్ ఎన్విరాన్‌మెంట్ లక్ష్యంగా ఉన్నప్పుడు LiteRT.js అద్భుతంగా పనిచేస్తుంది. ఇది .tflite మోడల్స్‌ను నేరుగా రన్ చేస్తుంది, దీనివల్ల డెవలపర్లు మోడల్స్‌ను కన్వర్షన్ లేకుండా Hugging Face లేదా Kaggle నుండి నేరుగా తీసుకోవచ్చు, తద్వారా అసలు క్వాంటైజేషన్ (quantization) మరియు పనితీరును కాపాడుకోవచ్చు. అయితే, దీని వల్ల డిప్లాయ్‌మెంట్ పరిధి తగ్గుతుంది మరియు వనరులను (resources) జాగ్రత్తగా నిర్వహించాల్సి ఉంటుంది.

డెవలపర్లు పరిగణించవలసిన అంశాలు

  • Target platform – వెబ్-ఓన్లీ డెస్క్‌టాప్ టూల్ (ఉదాహరణకు, రియల్ టైమ్‌లో స్టైల్ ట్రాన్స్‌ఫర్ చేసే డిజైన్ యాప్) కోసం, LiteRT.jsతో కూడిన WebGPU బహుశా ఉత్తమ ఎంపిక అవుతుంది.
  • Model size – పెద్దవి మరియు కంప్యూట్-హెవీ మోడల్స్ GPU సమాంతరత (parallelism) నుండి ఎక్కువ ప్రయోజనం పొందుతాయి; చిన్న మోడల్స్ కోసం అదనపు ఇంజనీరింగ్ అవసరం కాకపోవచ్చు.
  • Memory discipline – టెన్సర్లను స్పష్టంగా డిలీట్ చేయడం లేదా వనరులను ఆటోమేటిక్‌గా విడుదల చేసే స్కోప్‌లో ఇన్‌ఫరెన్స్ కాల్స్‌ను ఉంచడం వంటి ప్రణాళికలు సిద్ధం చేసుకోండి.
  • Fallback strategy – WebGPUని ఎనేబుల్ చేయలేని బ్రౌజర్‌ల కోసం WASM లేదా WebGL ఫాల్‌బ్యాక్ (fallback) అందించండి, తద్వారా ఎక్కువ మంది వినియోగదారులకు యాప్ అందుబాటులో ఉంటుంది.

ముగింపు

LiteRT.js, WebGPU వెబ్ ఆధారిత ఇన్‌ఫరెన్స్‌ను సబ్-మిలిసెకండ్ స్థాయికి తీసుకెళ్లగలదని నిరూపిస్తోంది, ఇది డెస్క్‌టాప్ GPUలపై TensorFlow.js కంటే 25 × కంటే ఎక్కువ వేగాన్ని అందిస్తుంది. ఈ సాంకేతికత ఇంకా పరిణతి చెందుతోంది, మరియు డెవలపర్లు బ్యాచింగ్ పరిమితులు, మాన్యువల్ మెమరీ క్లీనప్ మరియు పరిమిత మొబైల్ సపోర్ట్‌ను నిర్వహించాల్సి ఉంటుంది. రియల్-టైమ్ పనితీరు అవసరమయ్యే డెస్క్‌టాప్-ఫస్ట్ అనుభవాల కోసం, ఈ కొత్త లైబ్రరీ ఒక ఆకర్షణీయమైన మార్గాన్ని అందిస్తుంది; క్రాస్-ప్లాట్‌ఫారమ్ విస్తృతి కోసం, పాత WebGL మరియు WASM బ్యాకెండ్‌లు ఇప్పటికీ కీలకం.