સ્પાર્સ સર્કિટ્સ દ્વારા ન્યુરલ નેટવર્ક્સને સમજવું
અમે મોડલોને વધુ સરળ અને વધુ અનુસરવા યોગ્ય પગલાંમાં વિચારવા માટે તાલીમ આપી—જેથી તેઓ કેવી રીતે કાર્ય કરે છે તે અમે વધુ સારી રીતે સમજી શકીએ.
ન્યુરલ નેટવર્ક્સ આજની સૌથી ક્ષમતા ધરાવતી AI સિસ્ટમોને શક્તિ આપે છે, પરંતુ તેઓને સમજવું હજી પણ મુશ્કેલ છે. અમે આ મોડલોને સ્પષ્ટ, પગલું-દર-પગલું સૂચનાઓથી લખતા નથી. તેના બદલે, તેઓ અબજો આંતરિક જોડાણો, અથવા “weights,” સમાયોજિત કરીને શીખે છે, જ્યાં સુધી તેઓ કોઈ કાર્યમાં નિપુણ ન बने. અમે તાલીમના નિયમો રચીએ છીએ, પરંતુ ઊભરતા ચોક્કસ વર્તનો નહીં, અને પરિણામે જોડાણોનું એવું ઘન જાળ બને છે જેને કોઈ માનવી સરળતાથી સમજી શકતો નથી.
જેમ જેમ AI સિસ્ટમો વધુ ક્ષમતા ધરાવતી બને છે અને વિજ્ઞાન, શિક્ષણ અને આરોગ્યસંભાળના નિર્ણયો પર વાસ્તવિક અસર કરે છે, તેમ તેમ તેઓ કેવી રીતે કામ કરે છે તે સમજવું આવશ્યક છે. Interpretability એ એવી પદ્ધતિઓને સૂચવે છે જે અમને સમજવામાં મદદ કરે છે કે કોઈ મોડલે આપેલ output શા માટે ઉત્પન્ન કર્યું. આ હાંસલ કરવાની ઘણી રીતો હોઈ શકે છે.
ઉદાહરણ તરીકે, રિઝનિંગ મોડલને અંતિમ જવાબ સુધી પહોંચતા માર્ગમાં પોતાનું કાર્ય સમજાવવા માટે પ્રોત્સાહન આપવામાં આવે છે. Chain of thought interpretability મોડલના વર્તન પર નજર રાખવા માટે આ સમજણોનો ઉપયોગ કરે છે. આ તરત જ ઉપયોગી છે: હાલના રિઝનિંગ મોડલની chains of thought છેતરપિંડી જેવા ચિંતાજનક વર્તન અંગે માહિતગાર જણાય છે. જોકે, સંપૂર્ણપણે આ ગુણધર્મ પર નિર્ભર રહેવું નાજુક વ્યૂહરચના છે, અને સમય જતાં આ તૂટી પડી શકે છે.
બીજી તરફ, mechanistic interpretability, જે આ કાર્યનું કેન્દ્ર છે, મોડલની ગણતરીઓને સંપૂર્ણપણે reverse engineer કરવાની કોશિશ કરે છે. અત્યાર સુધી તે તરત ઉપયોગી ઓછું રહ્યું છે, પરંતુ સિદ્ધાંત મુજબ, તે મોડલના વર્તનની વધુ સંપૂર્ણ સમજૂતી આપી શકે છે. મોડલના વર્તનને સૌથી સૂક્ષ્મ સ્તરે સમજાવવાનો પ્રયાસ કરીને, mechanistic interpretability ઓછા અનુમાનો પર આધાર રાખી શકે છે અને અમને વધુ વિશ્વાસ આપી શકે છે. પરંતુ નીચલા સ્તરની વિગતોમાંથી જટિલ વર્તનની સમજૂતી સુધીનો માર્ગ ઘણો લાંબો અને વધુ મુશ્કેલ છે.
Interpretability અનેક મુખ્ય લક્ષ્યોને સમર્થન આપે છે, ઉદાહરણ તરીકે વધુ સારું oversight શક્ય બનાવે છે અને અસુરક્ષિત અથવા વ્યૂહાત્મક રીતે અસંગત વર્તનના પ્રારંભિક ચેતવણી સંકેતો આપે છે. તે અમારા અન્ય safety પ્રયત્નોને પણ પૂરક છે, જેમ કે scalable oversight, adversarial training, અને red-teaming.
આ કાર્યમાં, અમે બતાવીએ છીએ કે ઘણી વાર અમે મોડલોને એવી રીતે તાલીમ આપી શકીએ છીએ કે જેથી તેમને સમજવું વધુ સરળ બને. અમે અમારા કાર્યને dense નેટવર્ક્સના post-hoc analysis માટે આશાસ્પદ પૂરક તરીકે જોીએ છીએ.
આ ખૂબ મહત્ત્વાકાંક્ષી દાવ છે; અમારા કાર્યથી લઈને અમારા સૌથી શક્તિશાળી મોડલોના જટિલ વર્તનને સંપૂર્ણપણે સમજવા સુધીનો માર્ગ લાંબો છે. છતાં, સરળ વર્તન માટે, અમે શોધ્યું છે કે અમારી પદ્ધતિથી તાલીમ પામેલા sparse મોડલોમાં નાના, disentangled સર્કિટ્સ હોય છે જે સમજવા યોગ્ય પણ છે અને તે વર્તન કરવા માટે પૂરતા પણ છે. આ સૂચવે છે કે મોટી સિસ્ટમોને એવી રીતે તાલીમ આપવા તરફ વ્યવહારૂ માર્ગ હોઈ શકે છે જેના મિકેનિઝમ્સ અમે સમજી શકીએ.
પહેલાના mechanistic interpretability કાર્યમાં dense, ગૂંચવાયેલા નેટવર્ક્સથી શરૂઆત કરવામાં આવી હતી અને તેમને ઉકેલવાનો પ્રયાસ થયો હતો. આ નેટવર્ક્સમાં, દરેક અલગ neuron હજારો અન્ય neurons સાથે જોડાયેલો હોય છે. મોટાભાગના neurons ઘણા જુદા કાર્યો કરતાં લાગે છે, જેને કારણે તેમને સમજવું જાણે અશક્ય લાગે છે.
પણ શું થાય જો અમે ગૂંચવણમુક્ત ન્યુરલ નેટવર્ક્સને તાલીમ આપીએ, જેમાં ઘણા વધુ neurons હોય, પરંતુ દરેક neuron પાસે માત્ર થોડા ડઝન જોડાણો હોય? તો કદાચ પરિણામે મળતું નેટવર્ક વધુ સરળ અને વધુ સમજવા યોગ્ય હશે. આ અમારા કાર્યનો કેન્દ્રીય સંશોધન દાવ છે.
આ સિદ્ધાંતને ધ્યાનમાં રાખીને, અમે GPT‑2 જેવા અસ્તિત્વમાં રહેલા language models જેવી બહુ સમાન architecture ધરાવતા language modelsને તાલીમ આપી, એક નાનો ફેરફાર સાથે: અમે મોડલના બહુમતી weightsને શૂન્ય હોવા માટે મજબૂર કરીએ છીએ. આથી મોડલને તેના neurons વચ્ચેના શક્ય જોડાણોમાંથી બહુ થોડાં જ જોડાણો વાપરવા મર્યાદિત કરવામાં આવ્યું. આ એક સરળ ફેરફાર છે, જે અમારી દલીલ મુજબ મોડલની આંતરિક ગણતરીઓને નોંધપાત્ર રીતે disentangle કરે છે.
સામાન્ય dense ન્યુરલ નેટવર્ક્સમાં, દરેક neuron આગળની layerના દરેક neuron સાથે જોડાયેલો હોય છે. અમારા sparse મોડલોમાં, દરેક neuron આગળની layerમાં માત્ર થોડા neurons સાથે જ જોડાય છે. અમને આશા છે કે આથી neuronsને, અને સમગ્ર નેટવર્કને, સમજવું વધુ સરળ બનશે.
અમે માપવા માંગીએ છીએ કે અમારા sparse મોડલની ગણતરીઓ કેટલા અંશે disentangled છે. અમે મોડલના વિવિધ સરળ વર્તનો પર વિચાર કર્યો અને તપાસ્યું કે શું અમે દરેક વર્તન માટે જવાબદાર મોડલના ભાગોને અલગ કરી શકીએ છીએ—જેનને અમે circuits કહીએ છીએ.
અમે સરળ algorithmic કાર્યોનો હાથેથી પસંદ કરેલો સમૂહ તૈયાર કર્યો. દરેક માટે, અમે મોડલને એ સૌથી નાના સર્કિટ સુધી prune કર્યું જે હજી પણ કાર્ય કરી શકે, અને તે સર્કિટ કેટલું સરળ છે તે તપાસ્યું. (વિગતો માટે, અમારો paper(નવી વિન્ડોમાં ખૂલે છે) જુઓ.) અમે શોધ્યું કે મોટા અને વધુ sparse મોડલોને તાલીમ આપીને, અમે વધતી ક્ષમતા ધરાવતા અને વધુને વધુ સરળ સર્કિટ્સવાળા મોડલો બનાવી શકીએ.
અમે મોડલો વચ્ચે interpretability સામે capabilityનું પ્લોટ કરીએ છીએ (નીચે-ડાબી દિશા વધુ સારી છે). નક્કી sparse મોડલ કદ માટે, sparsity વધારવાથી—વધુ weightsને શૂન્ય ગોઠવવાથી—capability ઘટે છે પરંતુ interpretability વધે છે. મોડલ કદ વધારવાથી આ અત્યાધુનિક સીમા બહાર ખસે છે, જે સૂચવે છે કે આપણે એવા મોટા મોડલો બનાવી શકીએ જે ક્ષમતા ધરાવતા પણ હોય અને સમજાય એવા પણ હોય.
આને સ્પષ્ટ કરવા માટે, એવી કામગીરી વિચારો જ્યાં Python code પર તાલીમ પામેલા મોડલને યોગ્ય પ્રકારના quoteથી string પૂર્ણ કરવી પડે. Pythonમાં, ‘hello’ એકલ quoteથી પૂર્ણ થવું જોઈએ, અને “hello” ડબલ quoteથી પૂર્ણ થવું જોઈએ. મોડલ string કયા quoteથી શરૂ થઈ હતી તે યાદ રાખીને અને અંતે તે જ ફરી ઉત્પન્ન કરીને આ ઉકેલી શકે છે.
અમારા સૌથી વધુ સમજવા યોગ્ય મોડલો એવા disentangled સર્કિટ્સ ધરાવતા લાગે છે જે બિલ્કુલ એ જ algorithm અમલમાં મૂકે છે.
Single અથવા double quoteથી string સમાપ્ત કરવી કે નહીં તેનું અનુમાન કરતું sparse transformerનું ઉદાહરણરૂપ સર્કિટ. આ સર્કિટ માત્ર પાંચ residual channels (ઊભી રાખોડી રેખાઓ), layer 0માં બે MLP neurons, અને layer 10માં એક attention query-key channel તથા એક value channelનો ઉપયોગ કરે છે. મોડલ (1) એક residual channelમાં single quotes અને બીજામાં double quotes encode કરે છે; (2) એક MLP layerનો ઉપયોગ કરીને તેને એવા એક channelમાં ફેરવે છે જે કોઈપણ quote શોધે છે અને બીજા channelમાં જે single અને double quotes વચ્ચે વર્ગીકરણ કરે છે; (3) એક attention operationનો ઉપયોગ કરીને વચ્ચે આવેલા tokensને અવગણે છે, અગાઉનો quote શોધે છે, અને તેનો પ્રકાર અંતિમ tokenમાં નકલ કરે છે; અને (4) મેળ ખાતો closing quote અનુમાન કરે છે.
અમારી વ્યાખ્યા મુજબ, ઉપર બતાવેલા ચોક્કસ જોડાણો કાર્ય કરવા માટે પૂરતા છે—જો અમે બાકીના મોડલને દૂર કરી દઈએ, તો પણ આ નાનું સર્કિટ કાર્ય કરે છે. તેઓ આવશ્યક પણ છે—આ થોડાં edges કાઢી નાખવાથી મોડલ નિષ્ફળ જાય છે.
અમે કેટલાક વધુ જટિલ વર્તનો પણ જોયા. આ વર્તનો માટેના અમારા સર્કિટ્સ (ઉદાહરણ તરીકે નીચે બતાવેલી variable binding) સંપૂર્ણ રીતે સમજાવવું વધુ મુશ્કેલ છે. તેમ છતાં, અમે હજી પણ તુલનાત્મક રીતે સરળ આંશિક સમજૂતીઓ પ્રાપ્ત કરી શકીએ છીએ જે મોડલના વર્તનની આગાહી કરે છે.
ઓછી વિગત સાથેનું સર્કિટનું બીજું ઉદાહરણ. current નામના ચલનો પ્રકાર નક્કી કરવા માટે, એક attention operation ચલનું નામ વ્યાખ્યાયિત થાય ત્યારે set() ટોકનમાં નકલ કરે છે, અને બીજી પછીની operation set() ટોકનમાંથી પ્રકારને ચલના આગળના ઉપયોગમાં નકલ કરે છે, જેથી મોડલ યોગ્ય આગામી ટોકન અનુમાન કરી શકે.
આ કાર્ય એક મોટા લક્ષ્ય તરફનું પ્રારંભિક પગલું છે: મોડલની ગણતરીઓને સમજવામાં સરળ બનાવવું. પરંતુ હજી ઘણો લાંબો રસ્તો બાકી છે. અમારા sparse મોડલો અત્યાધુનિક મોડલો કરતાં ઘણાં નાના છે, અને તેમની ગણતરીના મોટા ભાગો હજી પણ uninterpreted છે.
આગળ, અમે અમારી તકનીકોને વધુ મોટા મોડલો સુધી scale કરવાની અને મોડલના વધુ વર્તન સમજાવવાની આશા રાખીએ છીએ. ક્ષમતા ધરાવતા sparse મોડલોમાં વધુ જટિલ રિઝનિંગના આધારભૂત circuit motifsને યાદીબદ્ધ કરીને, અમે એવી સમજણ વિકસાવી શકીએ કે જે અમને અત્યાધુનિક મોડલોની તપાસોને વધુ સારી રીતે લક્ષિત કરવામાં મદદ કરે.
Sparse મોડલોને તાલીમ આપવાની અકાર્યક્ષમતાને દૂર કરવા માટે, અમે બે માર્ગો જોઈએ છીએ. એક માર્ગ એ છે કે sparse મોડલોને શરૂઆતથી તાલીમ આપવાના બદલે અસ્તિત્વમાં રહેલા dense મોડલોમાંથી sparse circuits કાઢવા. Dense મોડલો તૈનાત કરવા માટે મૂળભૂત રીતે sparse મોડલો કરતાં વધુ કાર્યક્ષમ છે. બીજો માર્ગ એ છે કે interpretability માટે મોડલોને તાલીમ આપવા વધુ કાર્યક્ષમ તકનીકો વિકસાવવી, જેને ઉત્પાદન ક્ષેત્રે લાગુ કરવું કદાચ વધુ સરળ હોઈ શકે.
નોંધો કે અહીં અમારા નિષ્કર્ષો એ કોઈ ખાતરી નથી કે આ અભિગમ વધુ ક્ષમતા ધરાવતી સિસ્ટમો સુધી વિસ્તરશે, પરંતુ આ પ્રારંભિક પરિણામો આશાજનક છે. અમારો ઉદ્દેશ ધીમે ધીમે એ વિસ્તારવાનો છે કે મોડલનો કેટલો ભાગ અમે વિશ્વસનીય રીતે સમજાવી શકીએ, અને એવા સાધનો બનાવવાનો છે જે ભવિષ્યની સિસ્ટમોને વિશ્લેષણ, debug, અને મૂલ્યાંકન કરવા વધુ સરળ બનાવે.
લેખકો
Leo Gao, Achyuta Rajaram, Jacob Coxon, Soham V. Govande, Bowen Baker, Dan Mossing
