નફો:
- કૃત્રિમ બુદ્ધિમત્તાને સ્પષ્ટ સ્કીમા અને હેતુ આપીને મજબૂત એસક્યુએલ અને પાંડા કોડ લેવાની ક્ષમતા અને તેને વાક્ય દ્વારા વાંચવા અને ચકાસવાની ક્ષમતા
- મર્જ/જોઇન પછી પંક્તિની ગણતરી, ફિટિંગ ફંક્શન અને થ્રુપુટ જેવી સાયલન્ટ ભૂલોને પકડવાની ક્ષમતા
- તેને મૌન કર્યા વિના ડીબગમાં સમસ્યા હલ કરવાની ક્ષમતા અને ઉત્પાદન પર્યાવરણમાં કોડને પરીક્ષણ કર્યા વિના ચલાવવાનું ટાળો
ડેટા સાયન્સમાં બે પ્રાથમિક ભાષાઓ છે: એસક્યુએલ (સ્ટ્રક્ચર્ડ ક્વેરી લેંગ્વેજ — ડેટાબેસેસમાંથી ડેટાને ક્વેરી કરવા માટેની ભાષા) અને પાયથોન (ખાસ કરીને, પાન્ડાસ લાઇબ્રેરી — કોષ્ટકોને પ્રોગ્રામેટિક રીતે મેનિપ્યુલેટ કરવા માટેનું પ્રમાણભૂત સાધન). આ એકમમાં, અમે કોડ પાર્ટનર તરીકે AI નો ઉપયોગ કરવાનું શીખીશું: યોગ્ય પ્રશ્નો સાથે તેમાંથી નક્કર SQL અને પાન્ડાસ કોડ મેળવવો, તે કોડને વાંચવો અને માન્ય કરવો, તેને ડીબગ કરવું અને તેને ક્યારેય આંખ આડા કાન કરવા નહીં. AI મિનિટને બદલે સેકન્ડોમાં પુનરાવર્તિત કોડ લખે છે; પરંતુ તે જે કોડ બનાવે છે તે સાચા તર્ક સાથે યોગ્ય કૉલમ પર પ્રક્રિયા કરે છે તેની ખાતરી કરવાનું તમારું કામ છે. વર્કિંગ કોડનો અર્થ સાચો કોડ નથી.
શા માટે AI સાથે કોડ બનાવવો શક્તિશાળી પરંતુ જોખમી છે
AI કોડ જનરેશનમાં ત્રણ મોટા ફાયદાઓ પૂરા પાડે છે: સ્પીડ (સેકન્ડમાં 30-લાઇન ગ્રૂપબાય-પીવોટ ઑપરેશન લખે છે), રિમાઇન્ડર (તમે ભૂલી ગયા છો તે પાંડા ફંક્શનની યાદ અપાવે છે), અને શિક્ષણ (કોડ લાઇન બાય લાઇન સમજાવે છે). પરંતુ તે ત્રણ જોખમો ધરાવે છે: સાયલન્ટ લોજિક એરર (કોડ જે ખોટા કૉલમનો સરવાળો કરે છે તે ભૂલો વિના ચાલે છે), ફીટ ફંક્શન (અસ્તિત્વમાં ન હોય તેવી પદ્ધતિ સૂચવે છે), અને યીલ્ડ ટ્રેપ (કોડ જે નાના ડેટા પર કામ કરે છે પરંતુ 10 મિલિયન પંક્તિઓ પર ક્રેશ થાય છે). તેથી સુવર્ણ નિયમ: AI નો કોડ વાંચો જાણે તમે તેને જાતે લખ્યો હોય. તમે સમજી શકતા નથી તે લાઇન ચલાવશો નહીં.
એસક્યુએલ: સ્ત્રોત પર ડેટાની પ્રક્રિયા કરો
SQL તમને ડેટાબેઝમાંથી ડેટા પુનઃપ્રાપ્ત કરવા અને ત્યાં તેની પ્રક્રિયા કરવાની મંજૂરી આપે છે; તમે તેમને પાયથોનમાં ખેંચ્યા વિના લાખો લીટીઓનો સારાંશ આપી શકો છો. મૂળભૂત બિલ્ડીંગ બ્લોક્સ: SELECT (કયા કૉલમ), ક્યાં (કઈ પંક્તિઓ), GROUP BY (જૂથ અને સારાંશ), JOIN (કોષ્ટકોમાં જોડાઓ), HAVING (પોસ્ટ-ગ્રુપ ફિલ્ટર). જટિલ JOIN અને વિન્ડો ફંક્શન્સ લખવામાં AI ખૂબ જ મદદરૂપ છે, પરંતુ બે બાબતો તપાસવાની ખાતરી કરો: શું સાચી કી (ખોટી કી ડુપ્લિકેટ પંક્તિઓ) દ્વારા જોડાય છે અને શું ફિલ્ટર તર્ક સાચો છે (ખાસ કરીને NULL વર્તન અને તારીખ શ્રેણીઓ).
સાવધાન: ઉત્પાદન ડેટાબેઝની સામે AI-જનરેટેડ SQL ક્વેરી સીધી ચલાવશો નહીં. પ્રથમ એક નાની નકલ અથવા LIMIT સાથે પરીક્ષણ કરો. WHERE શરતને માન્ય કર્યા વિના ક્યારેય અપડેટ/ડિલીટ ક્વેરી ચલાવશો નહીં; ખોટું જ્યાં સમગ્ર કોષ્ટક કાઢી શકે છે.
પાયથોન/પાંડા: લવચીક વિશ્લેષણ
pandas એ પાયથોનમાં કોષ્ટકો (ડેટાફ્રેમ) ને ચાલાકી કરવાની પ્રમાણભૂત રીત છે. AI નો સૌથી કાર્યક્ષમ ઉપયોગ તેને સ્પષ્ટ યોજના અને હેતુ આપવાનો છે. સૌથી વધુ ઉપયોગમાં લેવાતી કામગીરી: ફિલ્ટર, ગ્રૂપબાય, મર્જ, પિવટ_ટેબલ, લાગુ કરો. AI આ ઝડપથી લખે છે; તમે જે તપાસવા માંગો છો તે તર્ક છે: શું સાચા સ્તંભમાં જૂથીકરણ છે, શું મર્જથી પંક્તિઓની સંખ્યા અણધારી રીતે બદલાઈ ગઈ છે (મર્જ કર્યા પછી હંમેશા પંક્તિઓની સંખ્યા તપાસો), શું ચેઈન ઑપરેશન્સ મૂળને બદલી રહ્યા છે.
વ્યવહાર
એસક્યુએલ
પાંડા
ચેકપોઇન્ટ
ફિલ્ટરિંગ
જ્યાં
df[df.x > 5]
NULL/NaN વર્તન
જૂથ
જૂથ દ્વારા
df.groupby()
શું તે યોગ્ય કૉલમ છે?
મર્જ
જોડાઓ
df.merge()
પંક્તિની ગણતરીમાં ફેરફાર
સારાંશ
AVG(), SUM()
.મીન(), .સમ()
જે કોલમ એકત્રિત કરવામાં આવી હતી
દ્વારા સૉર્ટ કરો
દ્વારા ઓર્ડર
.sort_values()
દિશા (ચડતા/ઉતરતા)
ડુપ્લિકેશન
DISTINCT
.ડ્રોપ_ડુપ્લિકેટ્સ()
કઈ કૉલમમાં?
ડીબગીંગ: AI સાથે
જ્યારે કોડ નિષ્ફળ થાય છે, ત્યારે AI ઉત્તમ ડિબગીંગ ભાગીદાર છે. તેને સંપૂર્ણ ભૂલ સંદેશ અને સંબંધિત કોડ સ્નિપેટ આપો. પરંતુ બે જાળથી સાવધ રહો. પ્રથમ, AI એ ઉકેલ સૂચવી શકે છે જે ભૂલને "મૌન" કરે છે (દા.ત. ચેતવણીઓ છુપાવવી) — આ ભૂલને ઠીક કરતું નથી, તે છુપાવે છે. બીજું, AI કેટલીકવાર સમસ્યાનું "ઉકેલ" કરતી વખતે શાંતિપૂર્વક અન્ય વર્તનમાં ફેરફાર કરે છે. નિયમ: ફિક્સને સમજો, મ્યૂટ ન કરો અને ચકાસો કે ફિક્સ કર્યા પછી પણ આઉટપુટ સાચું છે.
અર્થઘટન કરી શકાય તેવા અને જાળવી શકાય તેવા કોડ જોઈએ છે
AI થી કોડ ખરીદતી વખતે, વાંચી શકાય તેવા અને જાળવણી કરી શકાય તેવા કોડ માટે પૂછો, માત્ર "કાર્ય કરે છે" એવા કોડ માટે નહીં. જ્યારે તમે અથવા કોઈ સહકર્મી તે કોડ મહિનાઓ પછી ખોલે છે, ત્યારે તે સમજી શકશે કે તે શું કરે છે. આ કરવા માટે, AI માં ત્રણ બાબતોનો સમાવેશ કરવાની આદત બનાવો: અર્થપૂર્ણ ચલ નામો (orders_temiz, df2 નહીં), નિર્ણાયક પગલાઓ પર ટૂંકી ટિપ્પણી રેખાઓ (શા માટે, શું થઈ રહ્યું છે તે સમજાવવું), અને જાદુઈ નંબરને બદલે નામાંકિત સ્થિરાંક (ACCEPT_ESIGI = 0.85 eduri b the code ની જગ્યાએ). લાંબી સિંગલ-લાઇન સાંકળો પણ ટાળો (એક લાઇનમાં પાંચ ક્રિયાઓને જોડવી); આ ડિબગીંગને મુશ્કેલ બનાવે છે. મૂળભૂત રીતે, AI ઘણીવાર સંક્ષિપ્ત અને "સ્માર્ટ" કોડ બનાવે છે; જો તમે સ્પષ્ટપણે કહો કે "વાંચવા યોગ્ય, અર્થઘટન કરી શકાય તેવું, જાળવવા યોગ્ય લખો", તો તમને વધુ જાળવવા યોગ્ય આઉટપુટ મળશે. આ પુનઃઉત્પાદનક્ષમતા (યુનિટ 10) નો પણ આધાર છે: જે કોડ સમજી શકાયો નથી તે કોડ છે જે સુરક્ષિત રીતે ફરીથી ચલાવી શકાતો નથી.
ત્રણ નાના કેસો
કેસ 1 - જોડાઓ પ્રતિકૃતિ. એક વિશ્લેષકે ઓર્ડરને પ્રોડક્ટ ટેબલ સાથે જોડ્યો અને કુલ ટર્નઓવર 3 ગણું વધારે જણાયું. કારણ: ઉત્પાદન કોષ્ટકમાં દરેક ઉત્પાદનની બહુવિધ પંક્તિઓ (વિવિધ રંગો) હતી; JOIN દરેક ઓર્ડર ડુપ્લિકેટ. AI નો કોડ "કાર્યશીલ" હતો, પરંતુ લાઇનની સંખ્યા 240 હજારથી વધીને 690 હજાર થઈ ગઈ હતી. પાઠ: મર્જ/જોઈન પછી હંમેશા લાઈનોની સંખ્યા તપાસો.
કેસ 2 - ફિટિંગ કાર્ય. તેણે ઈન્ટર્નને AI df.groupby('x').summarize() સૂચવ્યું; પાંડામાં આવી કોઈ પદ્ધતિ નથી (ત્યાં .agg() છે). કોડ કામ કરતો ન હતો, ઇન્ટર્ન 20 મિનિટ માટે ખોવાઈ ગયો હતો. પાઠ: દસ્તાવેજમાંથી તમે ઓળખતા નથી તેવા કાર્યને ચકાસો; AI પદ્ધતિઓ બનાવી શકે છે.
કેસ 3 - ઉપજ પતન. એક કોડ દરેક પંક્તિ માટે અરજીમાં ડેટાબેઝને પૂછતો હતો; તે 5,000 લાઈનો પર ચાલી હતી, 4 મિલિયન લાઈનો પર 9 કલાક લાગી હતી અને બંધ થઈ ગઈ હતી. જ્યારે AI એ વેક્ટરાઇઝ્ડ (બેચ) સોલ્યુશન સૂચવ્યું, ત્યારે સમય ઘટાડીને 40 સેકન્ડ કરવામાં આવ્યો. પાઠ: નાના ડેટા પર કામ કરતો કોડ મોટા ડેટા પર ક્રેશ થઈ શકે છે; કાર્યક્ષમતા ધ્યાનમાં લો.
ચાર નકલ કરી શકાય તેવા નમૂનાઓ
1) સ્કીમા સાથે SQL ની વિનંતી કરવી:
તમારી ભૂમિકા: SQL સહાયક (PostgreSQL). કોષ્ટકો:- ઓર્ડર્સ(id, customer_id, તારીખ ટાઈમસ્ટેમ્પ, રકમ સંખ્યાત્મક)- ગ્રાહકો(id, શહેરનું લખાણ) કાર્ય: 2024 માં કુલ ટર્નઓવર મેળવો અને શહેર દીઠ ઓર્ડરની સંખ્યા, ટર્નઓવર દ્વારા ઉતરતા ક્રમમાં સૉર્ટ કરેલ. તમે NULL શહેરોને કેવી રીતે હેન્ડલ કરો છો તે સમજાવો. હું પહેલા LIMIT સાથે ક્વેરીનું પરીક્ષણ કરીશ; જનરેશન અપડેટ/ડિલીટ કરો.
2) ચેકપોઇન્ટ સાથે પાંડા પ્રક્રિયા:
મારી પાસે DataFrames df (ઓર્ડર) અને df_customers (ગ્રાહકો) છે. શહેર દીઠ સરેરાશ રકમની ગણતરી કરો. મહત્વપૂર્ણ: મર્જ કરતા પહેલા અને પછી પંક્તિઓની સંખ્યા છાપો જેથી હું જોઈ શકું કે ડુપ્લિકેશન છે કે નહીં. સમજાવો કે તમે કઈ કૉલમમાં ભળી ગયા છો અને શા માટે તમે આંતરિક/ડાબે પસંદ કર્યું છે.
3) કોડ સમજૂતી અને ચકાસણી:
નીચેની પાન્ડાસ કોડ લાઇનને લીટી દ્વારા સમજાવો: દરેક લીટી શું કરે છે, તે શું ધારણાઓ બનાવે છે, કયા કિસ્સામાં તે ખોટા પરિણામો આપી શકે છે? જો મેં લવારો ફંક્શનનો ઉપયોગ કર્યો હોય તો મને જણાવો. કોડ: [પેસ્ટ કરો]
4) ડીબગીંગ:
આ કોડ આ ભૂલ આપે છે. સંપૂર્ણ ભૂલ સંદેશ: [પેસ્ટ કરો]. કોડ: [પેસ્ટ કરો]. ભૂલનું મૂળ કારણ સમજાવો અને તેને ઠીક કરો. વાસ્તવમાં સમસ્યા હલ કરીને તેને ઠીક કરો, ચેતવણીને શાંત કરીને નહીં. ફિક્સે આઉટપુટ બદલ્યું છે કે કેમ તે પણ સૂચવો.
નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ
નબળા પ્રોમ્પ્ટ:
એક ક્વેરી લખો જે મને શહેર દીઠ વેચાણ આપે.
કોષ્ટકના નામ, કૉલમ, ડેટાબેઝ પ્રકાર, NULL વર્તન અસ્પષ્ટ છે. AI સામાન્ય છે, તે સંભવતઃ એક ક્વેરી પેદા કરશે જે તમારા ટેબલને બંધબેસતું નથી.
શક્તિશાળી પ્રોમ્પ્ટ:
તમારી ભૂમિકા: SQL સહાયક (MySQL 8). કોષ્ટક: વેચાણ(id, શહેર વર્ચર, રકમ દશાંશ, તારીખ તારીખ). કાર્ય: વર્ષ 2024 માટે શહેર દીઠ કુલ અને સરેરાશ રકમ, ઓર્ડરની સંખ્યા મેળવો; કુલ રકમ દ્વારા સૉર્ટ કરો; 100 થી વધુ ઓર્ડર ધરાવતા શહેરો જ બતાવો (HAVING).NULL શહેરને બાકાત રાખો. પ્રશ્ન સમજાવો; હું LIMIT સાથે પરીક્ષણ કરીશ.
અહીં ડેટાબેઝ, સ્કીમા, ફિલ્ટર, સોર્ટિંગ અને NULL નિયમ સ્પષ્ટ છે.
સામાન્ય ભૂલો
- કોડ વાંચ્યા વિના ચલાવી રહ્યા છીએ. વર્કિંગ કોડ સાચો કોડ નથી; કોડ કે જે ખોટા કૉલમમાં ચાલાકી કરે છે તે પણ ભૂલો વિના ચાલે છે.
- મર્જ/જોઈન પછી પંક્તિઓની સંખ્યા તપાસી નથી. ખોટી કી ચુપચાપ પંક્તિઓનું ડુપ્લિકેટ કરે છે અને ટોટલને વધારે છે.
- ફિટિંગ ફંક્શનને ચકાસી રહ્યાં નથી. AI એવી પદ્ધતિઓ સૂચવી શકે છે જે અસ્તિત્વમાં નથી; દસ્તાવેજમાંથી પુષ્ટિ કરો કે તમે તેને ઓળખતા નથી.
- કાર્યક્ષમતા વિશે વિચારતા નથી. લાખો પંક્તિઓ પર નાના ડેટા ક્રેશ પર કામ કરતા લાગુ/લૂપ; વેક્ટરાઇઝ કરો
- સીધા ઉત્પાદન ડેટાબેઝ પર ચલાવો. ખાસ કરીને WHERE અથવા પરીક્ષણ વિના અપડેટ/ડિલીટ ચલાવવું વિનાશક છે.
ટીપ: તમે AI થી મેળવતા કોડના દરેક ભાગમાં "માન્યતા લાઇન" ઉમેરવાની આદત પાડો: લાઇનની પૂર્વ- અને પોસ્ટ-પ્રોસેસિંગ સંખ્યા, થોડા નમૂના રેખાઓ અને હાથથી જટિલ કુલ. આ ત્રણ તપાસમાં સૌથી સાયલન્ટ લોજિક ભૂલો પકડાય છે.
સારાંશમાં
AI એક શક્તિશાળી ભાગીદાર છે જે ઝડપથી SQL અને pandas કોડ બનાવે છે, પરંતુ તે અંધ સત્તા નથી. તેને સ્પષ્ટ રીતે યોજના અને હેતુ આપો; તે બનાવેલ કોડને વાંચો જાણે કે તમે તેને જાતે જ લખ્યું હોય; મર્જ/જોઇન પછી પંક્તિઓની સંખ્યા, ફિટિંગ ફંક્શન અને થ્રુપુટ તપાસો; ઉત્પાદન ડેટાબેઝ પર પરીક્ષણ કર્યા વિના તેને ચલાવશો નહીં. ડિબગીંગ કરતી વખતે, સમસ્યાને હલ કરવાનું લક્ષ્ય રાખો, તેને શાંત ન કરો. જે કોડ કામ કરે છે તે સાચો કોડ નથી; માત્ર તમે જ ચોકસાઈની ખાતરી આપી શકો છો.
એપ્લિકેશન કાર્ય
વિશ્લેષણ પ્રશ્ન પસંદ કરો (દા.ત. "ચૅનલ દીઠ માસિક ટર્નઓવર") અને SQL અને પાંડા બંને સાથે AI તરફથી કોડની વિનંતી કરો. બંને કોડ લાઇન બાય લાઇન વાંચો, મર્જ/જોઇન કર્યા પછી લાઇનની સંખ્યા તપાસો અને ઓછામાં ઓછી એક મહત્વપૂર્ણ રકમ મેન્યુઅલી ચકાસો. બે કોડ સમાન પરિણામ આપે છે કે કેમ તેની તુલના કરો; જો અલગ હોય, તો તેનું કારણ જાણો.
ચેકલિસ્ટ
- [ ] શું મેં AI ને ટેબલ/સ્કીમા અને હેતુ સ્પષ્ટ રીતે આપ્યા છે?
- [ ] શું મેં તે કોડને વાંચ્યો અને સમજી શક્યો કે જે તેણે લીટી દ્વારા બનાવવામાં આવ્યો હતો?
- [ ] શું મેં મર્જ/જોઈન પછી લાઈનોની સંખ્યા તપાસી?
- [ ] શું મેં દસ્તાવેજોમાંથી મને ઓળખતા ન હોય તેવા કાર્યોની ચકાસણી કરી છે?
- [ ] શું મેં પ્રોડક્શન એન્વાયર્નમેન્ટમાં નહીં પણ પહેલા સુરક્ષિત/નાના ડેટા પર કોડનું પરીક્ષણ કર્યું છે?