𝗧𝗿𝘂𝘀𝘁 𝗧𝗵𝗲 𝗛𝗮𝗿𝗻𝗲𝘀𝘀, 𝗡𝗼𝘁 𝗧𝗵𝗲 𝗠𝗼𝗱𝗲𝗹
મારા હોમ હાર્ડવેર પર ચાલતું લોકલ 27B કોડિંગ મોડેલ સિક્કા ઉછાળવા જેવું (અનિશ્ચિત) છે. ક્યારેક તે વીસ મિનિટમાં કોડ સુધારી દે છે. તો ક્યારેક તે ખોટી ફાઇલ એડિટ કરે છે અથવા એવો ટેસ્ટ લખે છે જે ગમે તે થાય તો પણ પાસ થઈ જાય છે.
LLMKube ના Foreman નો હેતુ એક સંપૂર્ણ મોડેલ શોધવાનો નથી. હેતુ એવો હાર્નેસ (harness) બનાવવાનો છે જેના પર તમે મોડેલ કરતા વધુ વિશ્વાસ કરી શકો.
આ વીકેન્ડમાં, હાર્નેસે પોતાના ગાર્ડરેલ્સ (guardrails) બનાવીને પોતાનું પરીક્ષણ કર્યું. અહીં શું થયું તે જુઓ:
• મારા લોકલ કોડરે પોતાના માટે ત્રણ નવા ગેટ્સ બનાવ્યા. • એક ગેટ એ જ ખામી સાથે આવ્યો જે તેને પકડવાની હતી. રિવ્યુ પ્રક્રિયાએ તેને પકડી લીધો. • જ્યારે મશીનો કામ કરી રહ્યા હતા, ત્યારે ત્રણ નવા માનવ સહયોગીઓએ ચાર ક્લીન પુલ રિક્વેસ્ટ્સ (pull requests) મોકલ્યા. • એ જ મોડેલ AMD બોક્સ અને Apple Silicon Mac પર ચાલ્યું. Mac એ એક એવો રાઉન્ડ જીત્યો જેની કોઈએ અપેક્ષા નહોતી રાખી. • કોઈ પણ ડેટા ક્લાઉડ API સુધી પહોંચ્યો નહીં.
લોકલ મોડેલ પર કોડિંગ એજન્ટ અનિશ્ચિત ગુણવત્તા આપે છે. પ્રોમ્પ્ટ ટ્યુનિંગ (prompt tuning) ગમે તેટલું કરો, તે નાના મોડેલને ફ્રન્ટિયર મોડેલ (frontier model) જેટલું વિશ્વસનીય બનાવી શકતું નથી.
Foreman મોડેલને વિશ્વસનીય બનવા માટે કહેતું નથી. તે મોડેલને એક પાઇપલાઇનમાં (pipeline) લપેટી દે છે:
- કોડર ક્લોન કરેલા વર્કસ્પેસમાં કામ કરે છે.
- એક ફાસ્ટ ગેટ gofmt, vet, build, lint, અને યુનિટ ટેસ્ટ ચલાવે છે.
- રિવ્યુઅર ઇશ્યુ સામેનો ડિફ (diff) વાંચે છે.
- કોઈપણ કોડ મંજૂર થાય તે પહેલાં એક ક્લીન-રૂમ Kubernetes Job આખી સૂટ ફરીથી ચલાવે છે.
- સ્કોપ ચેક્સ (scope checks) અને repo-map context જેવા ડિટરમિનિસ્ટિક રેલ્સ (deterministic rails) આખી પ્રક્રિયાની આસપાસ રહે છે.
મોડેલ એ સિસ્ટમનો એક અનિશ્ચિત ભાગ છે. સિસ્ટમનું કામ એ છે કે જ્યારે મોડેલ વિશ્વસનીય ન હોય ત્યારે પણ નિર્ણયને વિશ્વસનીય બનાવે.
સાચો પ્રશ્ન એ નથી કે "શું મોડેલ સારું છે." પ્રશ્ન એ છે કે "જ્યારે મોડેલ ખરાબ હોય ત્યારે શું હાર્નેસ તેને પકડી લે છે."
આ વીકેન્ડમાં, હાર્નેસે બે મોટા બગ્સ પકડ્યા. બંને સેલ્ફ-કન્ફર્મિંગ ટેસ્ટ હતા. ટેસ્ટ પાસ થયા કારણ કે ટેસ્ટ પોતે જ પાસ થવા માટે લખવામાં આવ્યા હતા. તેઓએ ખરેખર કોડનું પરીક્ષણ કર્યું નહોતું.
મેં આ નિષ્ફળતાઓ Foreman ને પાછી આપી દીધી. મેં હાર્નેસને તેને સુધારવા માટે ગેટ્સ બનાવવા દીધા:
- સ્કોપ ગાર્ડ (scope guard): તે કોઈપણ એડિટને નકારી દે છે જે ખોટી સબસિસ્ટમ (subsystem) ને સ્પર્શે છે.
- રિવ્યુઅર રુબ્રિક (reviewer rubric): તે સુનિશ્ચિત કરે છે કે ટેસ્ટ પ્લેસહોલ્ડર્સ (placeholders) ને બદલે વાસ્તવિક પ્રોડક્શન વેલ્યુઝનો ઉપયોગ કરે છે.
- બાઇટ ચેક (bite check): નવો ટેસ્ટ જૂના કોડ સામે નિષ્ફળ જવો જોઈએ. જો તે બંનેમાં પાસ થાય, તો તે સાચો ટેસ્ટ નથી.
બાઇટ ચેકે તેનો પોતાનો પહેલો ટેસ્ટ નિષ્ફળ બનાવ્યો. તેણે બનાવેલો ગેટ ખામીયુક્ત હતો. પરંતુ રિવ્યુ પ્રક્રિયાએ તે મર્જ (merge) થાય તે પહેલાં ભૂલ પકડી લીધી. આ ડિઝાઇનનું કામ કરી રહ્યું છે.
લોકલ એન્જિનિયરિંગ કામ કરવા માટે તમારે વિશાળ ફ્રન્ટિયર મોડેલની જરૂર નથી. તમારે એવા હાર્નેસની જરૂર છે જેના પર તમે વિશ્વાસ કરી શકો. તે બનાવો, અને એક નાનું મોડેલ ઉપયોગી સહકર્મચારી બની જશે. તે એક એવી સિસ્ટમ બની જશે જે ભૂલો પકડી લે છે, બદલે કે તમને મધ્યરાત્રિએ કોડની દરેક લાઇન વાંચવા માટે મજબૂર કરે.
Optional learning community: https://t.me/GyaanSetuAi