കോഡ് ജനറേഷൻ: പൈത്തൺ (പാണ്ടകൾ), SQL എന്നിവയ്‌ക്കൊപ്പമുള്ള AI-അസിസ്റ്റഡ് അനാലിസിസ്

നേട്ടങ്ങൾ:

• ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസിന് വ്യക്തമായ സ്കീമയും ലക്ഷ്യവും നൽകിക്കൊണ്ട് ശക്തമായ SQL, പാണ്ടസ് കോഡ് എന്നിവ എടുത്ത് വരി വരിയായി വായിക്കാനും പരിശോധിക്കാനുമുള്ള കഴിവ്
• വരികളുടെ എണ്ണം, ഫിറ്റിംഗ് ഫംഗ്‌ഷൻ, ലയിപ്പിച്ചതിന് ശേഷമുള്ള ത്രൂപുട്ട് എന്നിവ പോലുള്ള നിശബ്ദ പിശകുകൾ പിടിക്കാനുള്ള കഴിവ്
• നിശബ്‌ദമാക്കാതെ തന്നെ ഡീബഗ്ഗിലെ പ്രശ്‌നം പരിഹരിക്കാനും ഉൽപാദന പരിതസ്ഥിതിയിൽ പരീക്ഷിക്കാതെ കോഡ് പ്രവർത്തിപ്പിക്കുന്നത് ഒഴിവാക്കാനുമുള്ള കഴിവ്

ഡാറ്റാ സയൻസിന് രണ്ട് പ്രാഥമിക ഭാഷകളുണ്ട്: SQL (സ്ട്രക്ചേർഡ് ക്വറി ലാംഗ്വേജ് - ഡാറ്റാബേസുകളിൽ നിന്ന് ഡാറ്റ അന്വേഷിക്കുന്നതിനുള്ള ഭാഷ), പൈത്തൺ (പ്രത്യേകിച്ച്, പാണ്ടാസ് ലൈബ്രറി - ടേബിളുകൾ പ്രോഗ്രമാറ്റിക്കായി കൈകാര്യം ചെയ്യുന്നതിനുള്ള സ്റ്റാൻഡേർഡ് ടൂൾ). ഈ യൂണിറ്റിൽ, AI ഒരു കോഡ് പങ്കാളിയായി ഉപയോഗിക്കാൻ ഞങ്ങൾ പഠിക്കും: അതിൽ നിന്ന് സോളിഡ് SQL, പാണ്ടസ് കോഡ് എന്നിവ ശരിയായ ചോദ്യങ്ങളോടെ നേടുക, ആ കോഡ് വായിച്ച് സാധൂകരിക്കുക, ഡീബഗ്ഗിംഗ് ചെയ്യുക, ഒരിക്കലും അന്ധമായി പ്രവർത്തിപ്പിക്കുക. AI മിനിറ്റുകൾക്ക് പകരം സെക്കൻഡുകൾക്കുള്ളിൽ ആവർത്തന കോഡ് എഴുതുന്നു; എന്നാൽ അത് ഉത്പാദിപ്പിക്കുന്ന കോഡ് ശരിയായ ലോജിക്കിനൊപ്പം ശരിയായ കോളം പ്രോസസ്സ് ചെയ്യുന്നുണ്ടെന്ന് ഉറപ്പാക്കേണ്ടത് നിങ്ങളുടെ ജോലിയാണ്. വർക്കിംഗ് കോഡ് എന്നാൽ ശരിയായ കോഡ് അർത്ഥമാക്കുന്നില്ല.

എന്തുകൊണ്ടാണ് AI ഉപയോഗിച്ച് കോഡ് നിർമ്മിക്കുന്നത് ശക്തവും എന്നാൽ അപകടകരവുമാണ്

കോഡ് ജനറേഷനിൽ AI മൂന്ന് വലിയ നേട്ടങ്ങൾ നൽകുന്നു: വേഗത (സെക്കൻഡുകൾക്കുള്ളിൽ 30-ലൈൻ ഗ്രൂപ്പ്-ബൈ-പിവറ്റ് ഓപ്പറേഷൻ എഴുതുന്നു), ഓർമ്മപ്പെടുത്തൽ (നിങ്ങൾ മറന്നുപോയ ഒരു പാണ്ടസ് ഫംഗ്‌ഷനെ ഓർമ്മിപ്പിക്കുന്നു), അദ്ധ്യാപനം (കോഡ് വരി വരിയായി വിശദീകരിക്കുന്നു). എന്നാൽ ഇത് മൂന്ന് അപകടസാധ്യതകൾ വഹിക്കുന്നു: സൈലൻ്റ് ലോജിക് പിശക് (തെറ്റായ കോളം പിശകുകളില്ലാതെ പ്രവർത്തിക്കുന്ന കോഡ്), ഫിറ്റഡ് ഫംഗ്ഷൻ (നിലവിലില്ലാത്ത ഒരു രീതി നിർദ്ദേശിക്കുന്നു), യീൽഡ് ട്രാപ്പ് (ചെറിയ ഡാറ്റയിൽ പ്രവർത്തിക്കുന്ന, എന്നാൽ 10 ദശലക്ഷം വരികളിൽ ക്രാഷാകുന്ന കോഡ്). അതിനാൽ സുവർണ്ണ നിയമം: AI യുടെ കോഡ് നിങ്ങൾ സ്വയം എഴുതിയതുപോലെ വായിക്കുക. നിങ്ങൾക്ക് മനസ്സിലാകാത്ത വരി ഓടരുത്.

SQL: ഉറവിടത്തിൽ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുക

ഡാറ്റാബേസിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കാനും അവിടെ പ്രോസസ്സ് ചെയ്യാനും SQL നിങ്ങളെ അനുവദിക്കുന്നു; ദശലക്ഷക്കണക്കിന് വരികൾ പൈത്തണിലേക്ക് വലിക്കാതെ തന്നെ നിങ്ങൾക്ക് സംഗ്രഹിക്കാം. അടിസ്ഥാന നിർമ്മാണ ബ്ലോക്കുകൾ: തിരഞ്ഞെടുക്കുക (ഏത് നിരകൾ), എവിടെ (ഏത് വരികൾ), ഗ്രൂപ്പ് ബൈ (ഗ്രൂപ്പും സംഗ്രഹവും), ചേരുക (പട്ടികകളിൽ ചേരുക), ഉണ്ടായിരിക്കുക (പോസ്റ്റ് ഗ്രൂപ്പ് ഫിൽട്ടർ). സങ്കീർണ്ണമായ ജോയിനുകളും വിൻഡോ ഫംഗ്‌ഷനുകളും എഴുതുന്നതിൽ AI വളരെ സഹായകരമാണ്, എന്നാൽ രണ്ട് കാര്യങ്ങൾ പരിശോധിക്കുന്നത് ഉറപ്പാക്കുക: ശരിയായ കീ (തെറ്റായ കീ ഡ്യൂപ്ലിക്കേറ്റ് വരികൾ) വഴിയുള്ള ജോയിൻ, ഫിൽട്ടർ ലോജിക് ശരിയാണോ (പ്രത്യേകിച്ച് NULL സ്വഭാവവും തീയതി ശ്രേണികളും).

മുന്നറിയിപ്പ്: പ്രൊഡക്ഷൻ ഡാറ്റാബേസിനെതിരെ നേരിട്ട് AI- ജനറേറ്റഡ് SQL അന്വേഷണം റൺ ചെയ്യരുത്. ആദ്യം ഒരു ചെറിയ പകർപ്പ് അല്ലെങ്കിൽ LIMIT ഉപയോഗിച്ച് പരിശോധിക്കുക. WHERE അവസ്ഥ സാധൂകരിക്കാതെ ഒരിക്കലും അപ്‌ഡേറ്റ്/ഇല്ലാതാക്കുക എന്ന ചോദ്യം റൺ ചെയ്യരുത്; എവിടെ എന്ന തെറ്റിന് മുഴുവൻ പട്ടികയും ഇല്ലാതാക്കാം.

പൈത്തൺ/പാണ്ടകൾ: വഴക്കമുള്ള വിശകലനം

പൈത്തണിൽ ടേബിളുകൾ (ഡാറ്റഫ്രെയിം) കൈകാര്യം ചെയ്യുന്നതിനുള്ള സാധാരണ മാർഗമാണ് പാണ്ടകൾ. AI-യുടെ ഏറ്റവും കാര്യക്ഷമമായ ഉപയോഗം അതിന് വ്യക്തമായ പദ്ധതിയും ലക്ഷ്യവും നൽകുക എന്നതാണ്. ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന പ്രവർത്തനങ്ങൾ: ഫിൽട്ടർ, ഗ്രൂപ്പ്ബൈ, ലയനം, പിവറ്റ്_ടേബിൾ, പ്രയോഗിക്കുക. AI ഇവ വേഗത്തിൽ എഴുതുന്നു; നിങ്ങൾ പരിശോധിക്കേണ്ടത് ലോജിക്കാണ്: ശരിയായ കോളത്തിലെ ഗ്രൂപ്പിംഗ് ആണോ, ലയനം അപ്രതീക്ഷിതമായി വരികളുടെ എണ്ണം മാറ്റിയിട്ടുണ്ടോ (ലയിപ്പിച്ചതിന് ശേഷം എല്ലായ്‌പ്പോഴും വരികളുടെ എണ്ണം പരിശോധിക്കുക), ശൃംഖല പ്രവർത്തനങ്ങൾ യഥാർത്ഥമായത് മാറ്റുന്നുണ്ടോ.

ഇടപാട്

SQL

പാണ്ടകൾ

ചെക്ക് പോയിൻ്റ്

ഫിൽട്ടറിംഗ്

എവിടെ

df[df.x > 5]

NULL/NaN പെരുമാറ്റം

ഗ്രൂപ്പിംഗ്

ഗ്രൂപ്പ് പ്രകാരം

df.groupby()

ഇത് ശരിയായ കോളമാണോ?

ലയിപ്പിക്കുക

ചേരുക

df.merge()

വരി എണ്ണത്തിൽ മാറ്റം

സംഗ്രഹം

AVG(), SUM()

.അർത്ഥം(), .തുക()

ഏത് കോളമാണ് ശേഖരിച്ചത്

അടുക്കുക

ഓർഡർ പ്രകാരം

.sort_values()

ദിശ (ആരോഹണം/അവരോഹണം)

ഡ്യൂപ്ലിക്കേഷൻ

വ്യതിരിക്തം

.drop_duplicates()

ഏത് കോളങ്ങളിൽ?

ഡീബഗ്ഗിംഗ്: AI ഉപയോഗിച്ച്

കോഡ് പരാജയപ്പെടുമ്പോൾ, AI ഒരു മികച്ച ഡീബഗ്ഗിംഗ് പങ്കാളിയാണ്. അതിന് പൂർണ്ണമായ പിശക് സന്ദേശവും പ്രസക്തമായ കോഡ് സ്‌നിപ്പറ്റും നൽകുക. എന്നാൽ രണ്ട് കെണികൾ സൂക്ഷിക്കുക. ആദ്യം, പിശക് "നിശബ്ദമാക്കുന്ന" ഒരു പരിഹാരം AI നിർദ്ദേശിച്ചേക്കാം (ഉദാ. അലേർട്ടുകൾ മറയ്ക്കൽ) - ഇത് പിശക് പരിഹരിക്കില്ല, അത് മറയ്ക്കുന്നു. രണ്ടാമതായി, ഒരു പ്രശ്നം "പരിഹരിക്കുന്ന" സമയത്ത് AI ചിലപ്പോൾ നിശബ്ദമായി മറ്റൊരു സ്വഭാവം മാറ്റുന്നു. നിയമം: പരിഹരിക്കൽ മനസ്സിലാക്കുക, നിശബ്‌ദമാക്കാതിരിക്കുക, പരിഹരിക്കുന്നതിന് ശേഷവും ഔട്ട്‌പുട്ട് ശരിയാണോയെന്ന് പരിശോധിക്കുക.

വ്യാഖ്യാനിക്കാവുന്നതും പരിപാലിക്കാവുന്നതുമായ കോഡ് വേണം

AI-ൽ നിന്ന് കോഡ് വാങ്ങുമ്പോൾ, "പ്രവർത്തിക്കുന്ന" കോഡ് മാത്രമല്ല, വായിക്കാനും പരിപാലിക്കാനും കഴിയുന്ന കോഡ് ആവശ്യപ്പെടുക. മാസങ്ങൾക്ക് ശേഷം നിങ്ങളോ സഹപ്രവർത്തകനോ ആ കോഡ് തുറക്കുമ്പോൾ, അത് എന്താണ് ചെയ്യുന്നതെന്ന് മനസിലാക്കാൻ അതിന് കഴിയണം. ഇത് ചെയ്യുന്നതിന്, AI മൂന്ന് കാര്യങ്ങൾ ഉൾപ്പെടുത്തുന്നത് ഒരു ശീലമാക്കുക: അർത്ഥവത്തായ വേരിയബിൾ പേരുകൾ (orders_temiz, df2 അല്ല), നിർണായക ഘട്ടങ്ങളിലെ ഹ്രസ്വ കമൻ്റ് ലൈനുകൾ (എന്തുകൊണ്ടാണ്, എന്താണ് ചെയ്യുന്നതെന്ന് വിശദീകരിക്കുന്നു), ഒരു മാജിക് നമ്പറിന് പകരം ഒരു സ്ഥിരാങ്കം (ACCEPT_ESIGI = 0.85 കോഡിന് പകരം 0.85 അടക്കം). നീളമുള്ള ഒറ്റ-ലൈൻ ശൃംഖലകൾ ഒഴിവാക്കുക (ഒരു വരിയിൽ അഞ്ച് പ്രവർത്തനങ്ങൾ ബന്ധിപ്പിക്കുന്നു); ഇവ ഡീബഗ്ഗിംഗ് ബുദ്ധിമുട്ടാക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, 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). പട്ടികകൾ:- ഓർഡറുകൾ (ഐഡി, കസ്റ്റമർ_ഐഡി, തീയതി ടൈംസ്റ്റാമ്പ്, തുക സംഖ്യകൾ)- ഉപഭോക്താക്കൾ (ഐഡി, നഗര വാചകം) ടാസ്‌ക്: 2024-ൽ ഒരു നഗരത്തിലെ മൊത്തം വിറ്റുവരവും ഓർഡറുകളുടെ എണ്ണവും അവരോഹണ ക്രമത്തിൽ വിറ്റുവരവ് അനുസരിച്ച് അടുക്കുക. നിങ്ങൾ NULL നഗരങ്ങളെ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്ന് വിശദീകരിക്കുക. ഞാൻ ആദ്യം LIMIT ഉപയോഗിച്ച് ചോദ്യം പരിശോധിക്കും; ജനറേഷൻ അപ്ഡേറ്റ് ചെയ്യുക/ഇല്ലാതാക്കുക.

2) ചെക്ക് പോയിൻ്റ് ഉപയോഗിച്ച് പാണ്ടകൾ പ്രക്രിയ:

എനിക്ക് DataFrames df (ഓർഡറുകൾ), df_customers (ഉപഭോക്താക്കൾ) എന്നിവയുണ്ട്. ഓരോ നഗരത്തിനും ശരാശരി തുക കണക്കാക്കുക. പ്രധാനം: ലയിപ്പിക്കുന്നതിന് മുമ്പും ശേഷവുമുള്ള വരികളുടെ എണ്ണം പ്രിൻ്റ് ചെയ്യുക, അതുവഴി തനിപ്പകർപ്പ് ഉണ്ടോ എന്ന് എനിക്ക് കാണാൻ കഴിയും. ഏത് കോളത്തിലാണ് നിങ്ങൾ ലയിപ്പിച്ചതെന്നും എന്തുകൊണ്ടാണ് നിങ്ങൾ അകം/ഇടത് തിരഞ്ഞെടുത്തതെന്നും വിശദീകരിക്കുക.

3) കോഡ് വിശദീകരണവും സ്ഥിരീകരണവും:

ഇനിപ്പറയുന്ന പാണ്ടകളുടെ കോഡ് വരി വരിയായി വിശദീകരിക്കുക: ഓരോ വരിയും എന്താണ് ചെയ്യുന്നത്, അത് എന്ത് അനുമാനങ്ങൾ ഉണ്ടാക്കുന്നു, ഏത് സാഹചര്യങ്ങളിൽ ഇത് തെറ്റായ ഫലങ്ങൾ നൽകാം? ഞാൻ ഒരു ഫഡ്ജ് ഫംഗ്ഷൻ ഉപയോഗിച്ചിരുന്നെങ്കിൽ എന്നെ അറിയിക്കുക. കോഡ്: [ഒട്ടിക്കുക]

4) ഡീബഗ്ഗിംഗ്:

ഈ കോഡ് ഈ പിശക് നൽകുന്നു. പൂർണ്ണ പിശക് സന്ദേശം: [ഒട്ടിക്കുക]. കോഡ്: [ഒട്ടിക്കുക]. പിശകിൻ്റെ റൂട്ട് കാരണം വിശദീകരിച്ച് അത് പരിഹരിക്കുക. അലേർട്ടിനെ നിശബ്ദമാക്കുന്നതിലൂടെയല്ല, യഥാർത്ഥത്തിൽ പ്രശ്നം പരിഹരിച്ചുകൊണ്ട് അത് പരിഹരിക്കുക. ഫിക്സ് ഔട്ട്പുട്ട് മാറ്റിയിട്ടുണ്ടോ എന്നും സൂചിപ്പിക്കുക.

ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്

ദുർബലമായ പ്രോംപ്റ്റ്:

ഓരോ നഗരത്തിലും എനിക്ക് വിൽപ്പന നൽകുന്ന ഒരു ചോദ്യം എഴുതുക.

പട്ടികയുടെ പേരുകൾ, കോളങ്ങൾ, ഡാറ്റാബേസ് തരം, NULL സ്വഭാവം എന്നിവ വ്യക്തമല്ല. AI സാധാരണമാണ്, അത് നിങ്ങളുടെ ടേബിളിന് അനുയോജ്യമല്ലാത്ത ഒരു ചോദ്യം ഉണ്ടാക്കിയേക്കാം.

ശക്തമായ നിർദ്ദേശം:

നിങ്ങളുടെ റോൾ: SQL അസിസ്റ്റൻ്റ് (MySQL 8). പട്ടിക: വിൽപ്പന (ഐഡി, സിറ്റി വാർചാർ, തുക ദശാംശം, തീയതി തീയതി). ടാസ്‌ക്ക്: 2024-ലെ മൊത്തം, ശരാശരി തുക, ഓരോ നഗരത്തിൻ്റെയും ഓർഡറുകളുടെ എണ്ണം എന്നിവ നേടുക; മൊത്തം തുക അനുസരിച്ച് അടുക്കുക; 100-ലധികം ഓർഡറുകളുള്ള നഗരങ്ങൾ മാത്രം കാണിക്കുക (ഉണ്ട്). NULL നഗരം ഒഴിവാക്കുക. ചോദ്യം വിശദീകരിക്കുക; ഞാൻ LIMIT ഉപയോഗിച്ച് പരീക്ഷിക്കും.

ഇവിടെ ഡാറ്റാബേസ്, സ്കീമ, ഫിൽട്ടർ, സോർട്ടിംഗ്, NULL റൂൾ എന്നിവ വ്യക്തമാണ്.

സാധാരണ തെറ്റുകൾ

• കോഡ് വായിക്കാതെ പ്രവർത്തിപ്പിക്കുന്നു. പ്രവർത്തന കോഡ് ശരിയായ കോഡല്ല; തെറ്റായ കോളം കൈകാര്യം ചെയ്യുന്ന കോഡും പിശകുകളില്ലാതെ പ്രവർത്തിക്കുന്നു.
• ലയിപ്പിച്ചതിന് ശേഷം വരികളുടെ എണ്ണം പരിശോധിക്കുന്നില്ല/ചേരുക. തെറ്റായ കീ നിശ്ശബ്ദമായി വരികൾ ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യുകയും ടോട്ടൽ വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു.
• ഫിറ്റിംഗ് ഫംഗ്‌ഷൻ പരിശോധിക്കുന്നില്ല. AI നിലവിലില്ലാത്ത രീതികൾ നിർദ്ദേശിച്ചേക്കാം; നിങ്ങൾ തിരിച്ചറിയുന്നില്ലെന്ന് പ്രമാണത്തിൽ നിന്ന് സ്ഥിരീകരിക്കുക.
• കാര്യക്ഷമതയെക്കുറിച്ച് ചിന്തിക്കുന്നില്ല. ദശലക്ഷക്കണക്കിന് വരികളിലെ ചെറിയ ഡാറ്റ ക്രാഷുകളിൽ പ്രയോഗിക്കുക/ലൂപ്പ് ചെയ്യുക; വെക്റ്ററൈസ് ചെയ്യുക.
• പ്രൊഡക്ഷൻ ഡാറ്റാബേസിൽ നേരിട്ട് പ്രവർത്തിപ്പിക്കുക. പ്രത്യേകിച്ച് എവിടെയോ പരിശോധനയോ ഇല്ലാതെ അപ്‌ഡേറ്റ്/ഇല്ലാതാക്കൽ പ്രവർത്തിപ്പിക്കുന്നത് വിനാശകരമാണ്.

നുറുങ്ങ്: AI-യിൽ നിന്ന് നിങ്ങൾക്ക് ലഭിക്കുന്ന ഓരോ കോഡിലേക്കും ഒരു "വാലിഡേഷൻ ലൈൻ" ചേർക്കുന്നത് ശീലമാക്കുക: പ്രോസസ്സിംഗിന് മുമ്പും ശേഷവുമുള്ള വരികളുടെ എണ്ണം, കുറച്ച് സാമ്പിൾ ലൈനുകൾ, കൂടാതെ കൈകൊണ്ട് നിർണായകമായ ആകെത്തുക. ഈ മൂന്ന് പരിശോധനകൾ മിക്ക സൈലൻ്റ് ലോജിക് പിശകുകളും പിടിക്കുന്നു.

ചുരുക്കത്തിൽ

AI എന്നത് SQL, പാണ്ടസ് കോഡ് എന്നിവ വേഗത്തിൽ നിർമ്മിക്കുന്ന ഒരു ശക്തമായ പങ്കാളിയാണ്, എന്നാൽ ഇത് ഒരു അന്ധമായ അധികാരമല്ല. അയാൾക്ക് പദ്ധതിയും ലക്ഷ്യവും വ്യക്തമായി നൽകുക; നിങ്ങൾ സ്വയം എഴുതിയതുപോലെ അത് നിർമ്മിക്കുന്ന കോഡ് വായിക്കുക; ലയിപ്പിക്കൽ/ജോയിന് ശേഷം വരികളുടെ എണ്ണം, ഫിറ്റിംഗ് ഫംഗ്‌ഷനുകൾ, ത്രൂപുട്ട് എന്നിവ പരിശോധിക്കുക; പ്രൊഡക്ഷൻ ഡാറ്റാബേസിൽ ഇത് പരീക്ഷിക്കാതെ പ്രവർത്തിപ്പിക്കരുത്. ഡീബഗ്ഗ് ചെയ്യുമ്പോൾ, പ്രശ്നം പരിഹരിക്കാൻ ലക്ഷ്യമിടുന്നു, അതിനെ നിശബ്ദമാക്കരുത്. പ്രവർത്തിക്കുന്ന കോഡ് ശരിയായ കോഡല്ല; നിങ്ങൾക്ക് മാത്രമേ കൃത്യത ഉറപ്പാക്കാൻ കഴിയൂ.

ആപ്ലിക്കേഷൻ ടാസ്ക്

ഒരു വിശകലന ചോദ്യം തിരഞ്ഞെടുക്കുക (ഉദാ. "ഒരു ചാനലിന് പ്രതിമാസ വിറ്റുവരവ്") കൂടാതെ SQL, പാണ്ടകൾ എന്നിവയിൽ നിന്ന് AI-യിൽ നിന്ന് കോഡ് അഭ്യർത്ഥിക്കുക. രണ്ട് കോഡും വരി വരിയായി വായിക്കുക, ലയിപ്പിക്കൽ/ജോയിൻ ചെയ്തതിന് ശേഷമുള്ള വരികളുടെ എണ്ണം പരിശോധിക്കുകയും ചുരുങ്ങിയത് ഒരു നിർണായക തുകയെങ്കിലും നേരിട്ട് പരിശോധിക്കുകയും ചെയ്യുക. രണ്ട് കോഡുകളും ഒരേ ഫലം നൽകുന്നുണ്ടോ എന്ന് താരതമ്യം ചെയ്യുക; വ്യത്യസ്തമാണെങ്കിൽ, എന്തുകൊണ്ടെന്ന് കണ്ടെത്തുക.

ചെക്ക്ലിസ്റ്റ്

• [ ] ഞാൻ പട്ടികയും സ്കീമയും ഉദ്ദേശ്യവും AI-ക്ക് വ്യക്തമായി നൽകിയിട്ടുണ്ടോ?
• [ ] അത് നിർമ്മിച്ച കോഡ് ഞാൻ വരി വരിയായി വായിച്ച് മനസ്സിലാക്കിയിട്ടുണ്ടോ?
• [ ] ലയിപ്പിക്കൽ/ചേരുക എന്നിവയ്ക്ക് ശേഷമുള്ള വരികളുടെ എണ്ണം ഞാൻ പരിശോധിച്ചോ?
• [ ] ഡോക്യുമെൻ്റേഷനിൽ നിന്ന് ഞാൻ തിരിച്ചറിയാത്ത പ്രവർത്തനങ്ങൾ ഞാൻ പരിശോധിച്ചിട്ടുണ്ടോ?
• [ ] ഞാൻ ആദ്യം സുരക്ഷിത/ചെറിയ ഡാറ്റയിൽ കോഡ് പരീക്ഷിച്ചിട്ടുണ്ടോ, പ്രൊഡക്ഷൻ പരിതസ്ഥിതിയിലല്ല?