Googleનું Tunix સિસ્ટમ એ અવરોધ (choke point) ને દૂર કરે છે જે મોટા પાયે એજન્ટિક રિઇન્ફોર્સમેન્ટ લર્નિંગ (RL) ને TPUs નો કાર્યક્ષમ ઉપયોગ કરતા રોકી રહ્યું હતું. ઇન્ટરેક્શન ડેટા જનરેટ કરવાના કાર્યને પોલિસી અપડેટ કરવાના કાર્યથી અલગ કરીને, Tunix TPU ઉપયોગિતાને સિંગલ-ડિજિટ ટકાવારીથી વધારીને લગભગ પૂર્ણ ક્ષમતા સુધી લઈ જાય છે, જેનાથી કમ્પ્યુટ વેસ્ટ (compute waste) માં મોટો ઘટાડો થાય છે.
એજન્ટિક RL માં બોટલનેક (અવરોધ)
એજન્ટિક RL એ વધુ જાણીતા "next-token" લેંગ્વેજ-મોડેલ ટ્રેનિંગ કરતા અલગ છે. એક એજન્ટને API કોલ્સ મોકલવા જોઈએ, કોડ એક્ઝિક્યુટ કરવો જોઈએ, અથવા સિમ્યુલેટેડ એન્વાયરમેન્ટમાં સ્ટેપ લેવો જોઈએ, અને પછી પરિણામ પર પ્રતિક્રિયા આપવી જોઈએ. તેથી ટ્રેનિંગ લૂપ સિંક્રોનસ (synchronous) હોય છે: મોડેલ એક એક્શન બનાવે છે, એન્વાયરમેન્ટ ચાલે છે, પરિણામ પાછું આવે છે, અને ત્યાર પછી જ મોડેલને ગ્રેડિયન્ટ અપડેટ મળે છે. જ્યારે એક સિંગલ એન્વાયરમેન્ટ સ્ટેપ લેવામાં કેટલાક સેકન્ડ લાગે છે, ત્યારે કિંમતી TPU હાર્ડવેર નવરું (idle) બેસી રહે છે, અને રિપોર્ટેડ ઉપયોગિતા 10% થી નીચે જઈ શકે છે. આ બિનકાર્યક્ષમતા સીધી રીતે ઊંચા ક્લાઉડ બિલ અને ધીમા રિસર્ચ સાયકલના રૂપમાં પરિણમે છે.
Tunix નું ડિકપલ્ડ (decoupled) આર્કિટેક્ચર
Tunix આ સમસ્યાને બે તબક્કાઓ—ટ્રેજેક્ટરી જનરેશન અને પોલિસી ઓપ્ટિમાઇઝેશન—ને અલગ હાર્ડવેર પૂલ પર ખસેડીને હલ કરે છે.
- Asynchronous actors સસ્તા CPUs અથવા GPUs પર ચાલે છે. દરેક એક્ટર સતત તેના નિર્ધારિત એન્વાયરમેન્ટ સાથે ઇન્ટરેક્ટ કરે છે, એક્શન્સ અને અવલોકનો રેકોર્ડ કરે છે, અને પરિણામી ટ્રેજેક્ટરીઝને શેર કરેડ સ્ટોરમાં સ્ટ્રીમ કરે છે.
- Continuous learners સમર્પિત TPU Pods નો ઉપયોગ કરે છે. લર્નર સેન્ટ્રલ બફર પરથી બેચ ખેંચે છે અને કોઈપણ સિંગલ એક્ટર તેના રોલઆઉટ (rollout) પૂર્ણ કરવાની રાહ જોયા વિના ગ્રેડિયન્ટ અપડેટ્સ કરે છે.
- High-throughput buffer વચ્ચે સ્થિત છે, જે ટ્રેજેક્ટરીઝ માટે સ્ટેજિંગ એરિયા તરીકે કામ કરે છે. કારણ કે લર્નર બફર જેટલી ઝડપથી ડેટા સપ્લાય કરી શકે છે તેટલી જ ઝડપથી વાંચી શકે છે, તેથી TPU ક્યારેય અટકી પડતું નથી.
આનો ચોખ્ખો અસરમાં એવું ટ્રેનિંગ પાઇપલાઇન છે જ્યાં TPUs લગભગ દરેક સમયે વ્યસ્ત રહે છે, જે ઉપયોગિતાને 100% તરફ લઈ જાય છે.
ટેકનિકલ અવરોધો અને Tunix તેને કેવી રીતે દૂર કરે છે
વેરિયેબલ-લેન્થ એપિસોડ્સ અને XLA recompilation
JAX નું XLA કમ્પાઈલર ફિક્સ્ડ ટેન્સર શેપ્સ (fixed tensor shapes) માટે ઓપ્ટિમાઇઝ કરે છે. જોકે, એજન્ટિક કાર્યો અલગ-અલગ લંબાઈના સિક્વન્સ બનાવે છે, જે સામાન્ય રીતે ખર્ચાળ recompilations ટ્રિગર કરે છે. Tunix ટૂંકા સિક્વન્સને એકસાથે પેક કરે છે અને સમાન લંબાઈના એપિસોડ્સને બકેટ્સમાં ગ્રુપ કરે છે, જેથી XLA લાંબા સમય સુધી કમ્પાઈલ કરેલા કર્નલ્સનો ફરીથી ઉપયોગ કરી શકે તે માટે શેપ્સ સ્થિર રહે. પરિણામ એ છે કે કમ્પાઈલર ઓવરહેડ વગર સ્ટેડી થ્રુપુટ મળે છે, જે અન્યથા પર્ફોર્મન્સને નબળું પાડી શકે છે.
ઘણા TPU ચિપ્સ પર વિશાળ મોડેલ્સનું સ્કેલિંગ
70 બિલિયનથી વધુ પેરામીટર્સ ધરાવતા એજન્ટ્સને ટ્રેન કરવા માટે વજન (weights) અને ડેટાને મલ્ટિપલ TPU નોડ્સ પર ફેલાવવાની જરૂર છે. Tunix મોડેલ પેરામીટર્સ અને એક્ટિવેશન્સ બંનેને શાર્ડ (shard) કરવા માટે JAX ના ShardMap પ્રિમીટિવનો ઉપયોગ કરે છે, જે લર્નરને હાઈ સ્પીડ સાથે ડેટા ફીડ કરતી વખતે આખું મોડેલ મેમરીમાં રાખવાની મંજૂરી આપે છે. આ શાર્ડિંગ વ્યૂહરચના એવા મોડેલ્સને ટ્રેન કરવાનું શક્ય બનાવે છે જે અગાઉ સિંગલ TPU પોડ માટે પહોંચની બહાર હતા.
ડિકપલ્ડ પાઇપલાઇન્સમાંથી સ્ટેલ (stale) ગ્રેડિયન્ટ્સ
જ્યારે એક્ટર્સ લર્નર કરતા આગળ ચાલે છે, ત્યારે તેઓ જે ડેટા સપ્લાય કરે છે તે વર્તમાન પોલિસીના સંદર્ભમાં "stale" (જૂનો) બની શકે છે. Tunix આ ડ્રિફ્ટને બે પદ્ધતિઓ દ્વારા ઘટાડે છે: importance-sampling જૂના સેમ્પલ્સને તેમની સુસંગતતા દર્શાવવા માટે રીવેઇટ (reweight) કરે છે, અને એક કન્ફિગરેબલ સ્ટેલનેસ થ્રેશોલ્ડ (staleness threshold) એવા ટ્રેજેક્ટરીઝને ડિસ્કાર્ડ કરે છે જે પૂર્વ-નિર્ધારિત વય કરતાં વધી જાય છે. સાથે મળીને તેઓ પાઇપલાઇન અસિંક્રોનસ રીતે ચાલતી હોવા છતાં લર્નિંગને સ્થિર રાખે છે.
અડોપ્ટર્સ (ઉપયોગકર્તાઓ) એ શું ધ્યાન રાખવું જોઈએ
- Latency audit – ડિકપલિંગનો ફાયદો એન્વાયરમેન્ટના રિસ્પોન્સ ટાઈમ પર આધારિત છે. ટીમોએ એન્ડ-ટુ-એન્ડ લેટન્સી માપવી જોઈએ અને ખાતરી કરવી જોઈએ કે એક્ટર પૂલ બફરને સારી રીતે ભરેલું રાખવા માટે યોગ્ય કદના હોય.
- Worker pool design – સસ્તા CPUs અથવા GPUs ઘણા એક્ટર્સ હોસ્ટ કરી શકે છે, પરંતુ તેમનો વધુ પડતો ઉપયોગ (oversubscribing) નેટવર્ક અથવા સ્ટોરેજ પર સંઘર્ષ (contention) પેદા કરી શકે છે. બફરના ઇન્જેસ્ટ રેટ સાથે મેળ ખાતો સંતુલિત પૂલ આવશ્યક છે.
- Buffer robustness – સેન્ટ્રલ સ્ટોરે નવું બોટલનેક બન્યા વિના હાઈ રાઈટ અને રીડ રેટ હેન્ડલ કરવા જોઈએ. લો ટેલ લેટન્સી (low tail latency) અને પૂરતા બેન્ડવિડ્થ ધરાવતી સ્ટોરેજ સિસ્ટમ પસંદ કરવી એ આર્કિટેક્ચરનો અનિવાર્ય ભાગ છે.
સંભવિત ગેરફાયદા
સ્પ્લિટ આર્કિટેક્ચર વધુ કાર્યકારી ભાગો (moving parts) રજૂ કરે છે: અલગ હાર્ડવેર ફ્લીટ્સ, એક પર્સિસ્ટન્ટ બફર, અને સ્ટેલનેસ લિમિટ્સ લાગુ કરવા માટે કોઓર્ડિનેશન લોજિક.
નિષ્કર્ષ
Tunix દર્શાવે છે કે એજન્ટિક RL માં મુખ્ય ખર્ચ મોડેલનો નથી પરંતુ સિંક્રોનસ ઇન્ટરેક્શન લૂપ્સને કારણે થતા આઈડલ ટાઈમનો છે. રોલઆઉટ કાર્યને સસ્તા હાર્ડવેર પર ઓફલોડ કરીને અને હાઈ-થ્રુપુટ બફર દ્વારા સતત શીખતા TPU પોડને ફીડ કરીને, Google એ 10% થી ઓછી ઉપયોગિતાની સમસ્યાને લગભગ પૂર્ણ-ક્ષમતાના વર્કફ્લોમાં ફેરવી દીધી છે.