ડિબગીંગ અને રુટ કોઝ એનાલિસિસ

નફો:

• બગને નાનામાં નાના પુનઃઉત્પાદન કરી શકાય તેવા દાખલામાં ઘટાડવાની અને તેને સંપૂર્ણ પુરાવા સાથે AI માં ખસેડવાની ક્ષમતા
• સસ્તા નિયંત્રણ સાથે પુરાવા-આધારિત પૂર્વધારણાઓનું પરીક્ષણ કરવાની અને મૂળ કારણ શોધવાની ક્ષમતા
• મૂળ કારણને ઉકેલવાની ક્ષમતા અને લક્ષણને પેચ કરવાને બદલે રીગ્રેશન ટેસ્ટ સાથે સુરક્ષિત

ડીબગીંગ એ સોફ્ટવેર શા માટે અનપેક્ષિત રીતે વર્તે છે તે શોધવાની અને તેને ઠીક કરવાની પ્રક્રિયા છે. તે એવી નોકરી છે જ્યાં વિકાસકર્તા સૌથી વધુ સમય વિતાવે છે અને સૌથી વધુ થાકી જાય છે; કારણ કે મોટાભાગે ભૂલ એ નથી કે જ્યાં તે દેખાય છે, પરંતુ થોડા ડગલાં પાછળ છુપાયેલી હોય છે. AI એ એક શક્તિશાળી વિચાર ભાગીદાર છે જે આ સંશોધનને વેગ આપે છે — પણ જો તમે તેને યોગ્ય પુરાવા આપો તો જ. પુરાવા વિના ડીબગીંગ એ વિસ્તાર છે જ્યાં AI સૌથી વધુ આભાસ ઉત્પન્ન કરે છે.

આ એકમમાં, અમે ભૂલ પેદા કરવાથી લઈને મૂળ કારણ સુધી પહોંચવા માટે એક શિસ્તબદ્ધ પ્રવાહ સ્થાપિત કરીએ છીએ: લક્ષણની સ્પષ્ટતા કરવી, પુરાવા એકત્ર કરવા (ભૂલ સંદેશ, સ્ટેક ટ્રેસ, લોગ, એન્ટ્રી), પૂર્વધારણા જનરેટ કરવી, પૂર્વધારણાનું પરીક્ષણ કરવું અને સુધારણાને માન્ય કરવી. AI દરેક પગલામાં મદદ કરે છે; પરંતુ "નિશ્ચિત" નિર્ણય એ જોઈને લેવામાં આવે છે કે ભૂલ ખરેખર દૂર થઈ ગઈ છે.

શા માટે પુરાવા એ બધું છે?

તમે જે રીતે કરો છો તે રીતે એલએલએમમાં ​​ભૂલ દેખાતી નથી; તે ફક્ત તે જ જાણે છે કે તમે તેને શું કહો છો. “ધી એપ્લીકેશન ક્રેશ” જેવું વાક્ય મોડલને લગભગ કોઈ માહિતી આપતું નથી, અને મોડલ એ ગેપને આગાહીથી ભરે છે — એટલે કે આભાસ. બદલામાં, સંપૂર્ણ ભૂલ સંદેશો, સ્ટેક ટ્રેસ — જે ફંક્શન દ્વારા ભૂલ થઈ છે, તે ઇનપુટ કે જે ભૂલને ટ્રિગર કરે છે, અને શું અપેક્ષિત હતું, વગેરેનું ભંગાણ. અવલોકન કરેલ વર્તનને જોતાં, મોડેલ સાચી સંભાવનાઓને ક્રમ આપી શકે છે.

ડીબગીંગમાં, AI ને ડિટેક્ટીવના સહાયક તરીકે વિચારો: તમે જેટલા વધુ પુરાવા રજૂ કરશો, તેટલી વધુ સચોટ પૂર્વધારણા તે પેદા કરશે. જો કોઈ પુરાવા ન હોય, તો સહાયક માત્ર અનુમાન લગાવશે અને તમને ખોટા માર્ગ પર લઈ જશે.

ટીપ: બગને AI માં પોર્ટ કરતા પહેલા, તેને સૌથી નાના પુનઃઉત્પાદન કરી શકાય તેવા ઉદાહરણ સુધી ઘટાડો. સૌથી નાનો કોડ અને ઇનપુટ જે ભૂલને ટ્રિગર કરે છે તે તમારા અને મોડેલ બંને માટે વસ્તુઓને ધરમૂળથી સરળ બનાવે છે; મોટાભાગે આ ઘટાડા દરમિયાન તમે જાતે જ કારણ શોધો છો.

સ્ટેપ બાય સ્ટેપ: રુટ કોઝ એનાલિસિસ ફ્લો

1. લક્ષણ સ્પષ્ટ કરો. "શું થઈ રહ્યું છે, તમે શું થવાની અપેક્ષા રાખી હતી?" બંનેને એક વાક્યમાં લખો.
2. પુરાવા ભેગા કરો. સંપૂર્ણ ભૂલ સંદેશ, સ્ટેક ટ્રેસ, સંબંધિત લોગ લાઇન્સ, ટ્રિગરિંગ એન્ટ્રી, સંસ્કરણ માહિતી.
3. પૂર્વધારણા જનરેટ કરો. AI થી "3 સંભવિત કારણો જે આ લક્ષણને સમજાવે છે અને હું દરેક માટે કેવી રીતે પરીક્ષણ કરું?" પૂછો
4. પહેલા સૌથી સસ્તી પૂર્વધારણાનું પરીક્ષણ કરો. લોગ ઉમેરો, મૂલ્ય છાપો, પરીક્ષણ ચલાવો. શું પુરાવા પૂર્વધારણાની પુષ્ટિ કરે છે?
5. મૂળ કારણને ઠીક કરો, લક્ષણને નહીં. પેચ સાથે લક્ષણને શાંત કરવાને બદલે, મૂળ કારણને સંબોધિત કરો.
6. માન્ય કરો અને રીગ્રેશન પરીક્ષણ ઉમેરો. ભૂલ અદૃશ્ય થઈ જુઓ; પછી એક પરીક્ષણ લખો જે તે ભૂલને પકડશે જેથી તે પાછી ન આવે.

ત્રણ મિની કેસ

કેસ 1 - સ્ટેક ટ્રેસ યોગ્ય ફાઇલ તરફ દોરી ગયું. એપ્લિકેશન ચોક્કસ વિનંતીઓ પર 500 ભૂલ પરત કરી રહી હતી. વિકાસકર્તાએ એઆઈને સંપૂર્ણ સ્ટેક ટ્રેસ અને ટ્રિગરિંગ વિનંતી આપી; મોડેલે અનુમાન કર્યું હતું કે તારીખ પાર્સિંગ લેયરમાં કોઈ નહીં મૂલ્યને કારણે ભૂલ થઈ હતી. વિકાસકર્તાએ તે લાઇનમાં એક લોગ ઉમેર્યો, તેની ચકાસણી કરી અને તેને 15 મિનિટમાં હલ કરી; એક દિવસ પહેલા અપ્રુવિત પ્રયોગો સાથે 2 કલાક વેડફાઈ ગયા હતા.

કેસ 2 - આભાસ ખોટા માર્ગ તરફ દોરી ગયો. અન્ય ડેવલપરે ખાલી લખ્યું હતું કે "ડેટાબેઝ કનેક્શન ઘટી રહ્યું છે". એઆઈએ કોઈપણ પુરાવા વિના કનેક્શન પૂલ સેટિંગનો આરોપ લગાવ્યો; વિકાસકર્તાએ આ સેટિંગ સાથે ટિંકરિંગ કરવામાં 40 મિનિટ ગાળી. વાસ્તવિક કારણ નેટવર્ક બાજુ પર સમયસમાપ્તિ હતું અને ફક્ત લોગ જોઈને જ જાહેર થયું હતું. પાઠ: પુરાવા વિના લેવાયેલી પૂર્વધારણા માત્ર સંભવિત છે, વિશ્વસનીય નથી.

કેસ 3 - ફ્લેકી ભૂલ પકડાઈ. એક કસોટી હતી જે ક્યારેક-ક્યારેક નિષ્ફળ જતી હતી. AI ને પરીક્ષણ કોડ, નિષ્ફળતા સંદેશ અને માહિતી આપવામાં આવી હતી "ક્યારેક તે પાસ થાય છે, ક્યારેક તે નિષ્ફળ જાય છે"; મોડેલ પરીક્ષણોની વહેંચાયેલ સમય/ઓર્ડર નિર્ભરતા દર્શાવે છે. સમીક્ષાએ પુષ્ટિ કરી કે પરીક્ષણ સિસ્ટમના સ્થાનિક સમય પર આધારિત હતું. એકવાર ઘડિયાળ નિશ્ચિત થઈ ગઈ (મશ્કરી થઈ), પરીક્ષણ સ્થિર થઈ ગયું.

ચાર નકલ કરી શકાય તેવા નમૂનાઓ

પુરાવા-આધારિત પૂર્વધારણા પેઢી:

હું બગ ડીબગ કરી રહ્યો છું. નીચે પુરાવા.- અપેક્ષિત વર્તન: {{અપેક્ષિત}}- અવલોકન કરેલ વર્તન: {{ અવલોકન કરેલ}}- ભૂલ સંદેશ / સ્ટેક ટ્રેસ: {{trace}}- ટ્રિગરિંગ ઇનપુટ: {{input}}- પર્યાવરણ/સંસ્કરણ: {{version}} 3 સૌથી વધુ સંભવિત મૂળ કારણોની સૂચિ બનાવો જે આને સમજાવે છે. દરેક માટે: હું કેવી રીતે પરીક્ષણ કરું (સસ્તી તપાસ) અને જો તે સાચું હોય તો તેને કેવી રીતે ઠીક કરવું. જો પુરાવા અપૂરતા હોય, તો મને કહો કે તમને કઈ વધારાની માહિતીની જરૂર છે.

સ્ટેક ટ્રેસનું અર્થઘટન:

આ સ્ટેક ટ્રેસ વાંચો. ભૂલ સંભવતઃ કઈ લીટી (રુટ) થી શરૂ થાય છે અને કઈ લીટીઓ માત્ર સાંકળની ચાલુ છે તે વચ્ચે તફાવત કરો. પ્રથમ જોવા માટે 1-2 સ્થાનો સૂચવો. સંબંધિત કોડ:{{code}}ટ્રેસ:{{trace}}

ન્યૂનતમ પુનઃ બાદબાકી:

નીચેનો કોડ ભૂલ પેદા કરે છે. તેને નાનામાં નાના દાખલામાં ઘટાડો કે જે હજુ પણ ભૂલને ટ્રિગર કરે છે પરંતુ બિનજરૂરી કંઈપણ કાઢી નાખે છે. એવું માનશો નહીં કે તમે દૂર કરો છો તે દરેક ભાગ ભૂલને અસર કરતું નથી, પરંતુ એક નોંધ ઉમેરો કે "જો તમે આને દૂર કરો ત્યારે ભૂલ અદૃશ્ય થઈ જાય, તેથી જ".{{code}}

સુધારણા પછીની માન્યતા અને રીગ્રેસન પરીક્ષણ:

ધારો કે મૂળ કારણ {{cause}} છે અને હું નીચેનો સુધારો કરું છું: {{fix}}.1) શું આ ફિક્સ વાસ્તવમાં લક્ષણને ઠીક કરે છે, શું તેની કોઈ આડઅસર થશે? 2) એક રીગ્રેશન ટેસ્ટ લખો જે ભવિષ્યમાં આ બગને પકડશે.

નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ

નબળા: "કોડ કામ કરતું નથી, શા માટે?"

મજબૂત: "નોડ 20 / એક્સપ્રેસ. જ્યારે આઇટમ્સ શરીરમાં ખાલી સ્ટ્રિંગ હોય ત્યારે POST/ઓર્ડર્સ 500 પરત કરે છે; 400 પરત કર્યા હોવા જોઈએ. સ્ટેક ટ્રેસ: TypeError: અવ્યાખ્યાયિત ('0' વાંચન) ના ગુણધર્મો વાંચી શકાતા નથી — જોડાયેલ સંપૂર્ણ ટ્રેસ અને સંકળાયેલ હેન્ડલર છે. મને જણાવો કે આ 3 અને સંભવિત પરીક્ષણો કેવી રીતે સમજાવે છે. + કોડ]"

શક્તિશાળી સંસ્કરણ; તે પર્યાવરણ, અંતિમ બિંદુ, ટ્રિગર ઇનપુટ, ચોક્કસ ભૂલ પ્રકાર અને અપેક્ષિત વર્તન આપે છે. મોડેલ હવે આગાહીઓ કરી શકશે નહીં, પરંતુ વિશ્લેષણ.

પગલું

AI નું યોગદાન

તમારું નિયંત્રણ

પુરાવા એકત્ર કરી રહ્યા છે

કયા પુરાવાની જરૂર છે, યાદ અપાવે છે

ખરેખર પુરાવા એકત્રિત કરે છે

પૂર્વધારણા પેઢી

સંભવિત કારણોની સૂચિ બનાવો

સંદર્ભ સાથે પ્રાથમિકતા આપે છે

પૂર્વધારણા પરીક્ષણ

પરીક્ષણ પદ્ધતિની ભલામણ કરે છે

સંચાલન કરે છે અને અંગત રીતે અવલોકન કરે છે

કરેક્શન

પેચ ભલામણ કરે છે

શું તે મૂળ કારણને હલ કરે છે? વાત સાચી છે.

રીગ્રેશન

ટેસ્ટ લખે છે

ચકાસે છે કે પરીક્ષણ તૂટી ગયું છે

મૂળ કારણનું નિરાકરણ, લક્ષણ નહીં

મોટાભાગે AI એક પેચ સૂચવે છે જે ઝડપથી લક્ષણને શાંત કરે છે: એક પ્રયાસ/કેચ ઉમેરો, નલ ચેક મૂકો, ભૂલને ગળી જાઓ. આ ક્યારેક સાચું છે, ઘણી વખત ખતરનાક છે; કારણ કે મૂળ કારણ સ્થાને રહે છે અને બીજી જગ્યાએથી ફરી ફૂટી નીકળે છે. દરેક સુધારા સાથે, તમારી જાતને પૂછો: "શું આ ભૂલના કારણને ઠીક કરે છે, અથવા તે તેને અદ્રશ્ય બનાવે છે?" એકવાર તમે મૂળ કારણ શોધી લો, તે સામાન્ય રીતે નાનું, વધુ મજબૂત અને કાયમી હોય છે.

સાવધાન: અપવાદ (ખાલી કેચ) ચૂપચાપ ગળી જવાથી ભૂલ ઉકેલાતી નથી; તે માત્ર છુપાવે છે અને ભવિષ્યના નિદાનને અશક્ય બનાવે છે. જો AI આવા "ઉકેલ" સૂચવે છે, તો મૂળ કારણ પર પ્રશ્ન કર્યા વિના તેને સ્વીકારશો નહીં.

સામાન્ય ભૂલો

• પુરાવા વગર પ્રશ્નો પૂછવા. અસ્પષ્ટ વાક્યો મોડેલને આભાસમાં ધકેલે છે; સંપૂર્ણ ભૂલ, ટ્રેસ અને ઇનપુટ આપો.
• પ્રથમ પૂર્વધારણા પર લોકીંગ. AI નું પ્રથમ સૂચન કદાચ સૌથી વધુ સંભવ ન હોય; સૌથી સસ્તી નિયંત્રણક્ષમ પૂર્વધારણા સાથે પ્રારંભ કરો.
• લક્ષણનું પેચિંગ અને મૂળ કારણ ખૂટે છે. મૌન ભૂલ પાછી આવે છે.
• તેને ચકાસ્યા વિના ફિક્સ બંધ કરવું. ઉત્પાદન જેવી સ્થિતિમાં જુઓ કે ભૂલ ખરેખર અદૃશ્ય થઈ જાય છે.
• રીગ્રેશન પરીક્ષણો લખતા નથી. જો કોઈ પરીક્ષણો ઉમેરવામાં ન આવે, તો તે જ ભૂલ પછીના સંસ્કરણોમાં શાંતિપૂર્વક પરત આવશે.

સારાંશમાં

ડીબગીંગમાં, AI ની શક્તિ તમે જે પુરાવા આપો છો તેના સીધા પ્રમાણસર છે: સંપૂર્ણ ભૂલ સંદેશ, સ્ટેક ટ્રેસ, ટ્રિગરિંગ ઇનપુટ અને અપેક્ષિત વર્તન વિના, મોડેલ ફક્ત અનુમાન કરે છે. શિસ્તબદ્ધ પ્રવાહ-લક્ષણ સ્પષ્ટ કરો, પુરાવા ભેગા કરો, પૂર્વધારણા જનરેટ કરો, સસ્તા નિયંત્રણ સાથે પરીક્ષણ કરો, મૂળ કારણને ઠીક કરો, ચકાસો અને રીગ્રેશન પરીક્ષણ ઉમેરો-બગને ઝડપથી અને કાયમી ધોરણે બંધ કરે છે. AI એ પૂર્વધારણા જનરેટર છે; તમે એક છો જે નક્કી કરે છે કે ભૂલ ખરેખર હલ થઈ ગઈ છે.

એપ્લિકેશન કાર્ય

તમે તાજેતરમાં અનુભવેલ વાસ્તવિક બગ પસંદ કરો (અથવા પરીક્ષણ બગનું પુનઃઉત્પાદન કરો). પ્રથમ "લઘુત્તમ પ્રજનન" પગલું કરો; સૌથી નાનો કોડ અને ઇનપુટ દૂર કરો જે ભૂલને ટ્રિગર કરે છે. પછી "પુરાવા-આધારિત પૂર્વધારણા જનરેશન" ટેમ્પલેટ સાથે AI માંથી 3 સંભવિત કારણો અને પરીક્ષણ પદ્ધતિઓ મેળવો. સૌથી સસ્તી પૂર્વધારણાનું જાતે પરીક્ષણ કરો, મૂળ કારણ શોધો, તેને ઠીક કરો અને અંતે એક રીગ્રેસન ટેસ્ટ લખો જે ભવિષ્યમાં આ બગને પકડશે અને ચકાસો કે પરીક્ષણ ખરેખર તૂટી ગયું છે.

ચેકલિસ્ટ

• [ ] હું તેને AI માં ખસેડતા પહેલા સૌથી નાના પુનઃઉત્પાદનક્ષમ નમૂનામાં ભૂલને ઘટાડીશ.
• [ ] હું પ્રોમ્પ્ટમાં સંપૂર્ણ ભૂલ સંદેશ, સ્ટેક ટ્રેસ, ઇનપુટ અને અપેક્ષિત વર્તન ઉમેરી રહ્યો છું.
• [ ] હું એક પણ પૂર્વધારણામાં લૉક કર્યા વિના, સૌથી સસ્તી નિયંત્રણ કરી શકાય તેવી સાથે પ્રારંભ કરું છું.
• [ ] હું ચકાસો છું કે મેં લક્ષણને પેચ કરવાને બદલે મૂળ કારણનું નિરાકરણ કર્યું છે.
• [ ] હું અવલોકન કરું છું કે સુધારો વાસ્તવમાં ભૂલને સુધારે છે.
• [ ] હું દરેક ઉકેલાયેલ બગ માટે રીગ્રેશન ટેસ્ટ ઉમેરું છું.