സങ്കീർണ പ്രാമ്പ് സൃഷ്ടിക്കൽ

മുന്നുള്ള അധ്യായത്തിൽ നിന്നും ചില പഠനങ്ങൾ നമുക്ക് സംക്ഷേപിച്ചു നോക്കാം:

പ്രാമ്പ് എഞ്ചിനീയറിംഗ് എന്നത് മോഡലിനെ കൂടുതൽ പ്രസക്തിയുള്ള പ്രതികരണങ്ങളിലേക്കു നയിക്കുന്ന പ്രക്രിയയാണ്, കൂടുതൽ ഉപകാരപ്രദമായ നിർദേശങ്ങളും കണ്ടക്സ്റ്റുകളും നൽകിക്കൊണ്ട്.

പ്രാമ്പുകൾ എഴുതുന്നതിന് രണ്ടു ഘട്ടങ്ങളുണ്ട്: പ്രസക്തമായ കണ്ടക്സ്റ്റ് നൽകി പ്രാമ്പ് നിർമ്മിക്കൽ, കൂടാതെ പ്രാമ്പ് ക്രമീകരിക്കുന്നതും (optimization), പ്രാമ്പ് ക്രമാതീതമായി മെച്ചപ്പെടുത്തുന്നതും.

ഈ ഘട്ടത്തിൽ, നമ്മക്ക് പ്രാമ്പുകൾ എങ്ങനെ എഴുതാൻ എന്ന് അടിസ്ഥാനമായ അറിവുണ്ട്, എന്നാൽ നാം കൂടുതൽ ആഴത്തിൽ പോകേണ്ടതാണ്. ഈ അധ്യായത്തിൽ നിങ്ങൾ വിവിധ പ്രാമ്പുകൾ പരീക്ഷിക്കുന്നതു മുതൽ ഒരു പ്രാമ്പ് മറ്റുള്ളവയ്ക്കു വച്ച് എങ്ങനെ മെച്ചമാണ് എന്നത് മനസിലാക്കുന്നതുവരെ പോകും. ബേസിക്ക് ചില സാങ്കേതിക മുറകങ്ങൾ പിന്തുടർന്ന് പ്രാമ്പുകൾ എങ്ങനെ ഒരുക്കാമെന്നു പഠിക്കും, ഇത് ഏതു LLM에도 പ്രയോഗിക്കാവുന്നതാണ്.

പരിചയം

ഈ അധ്യായത്തിൽ ഞങ്ങൾ താഴെപ്പറയുന്ന വിഷയങ്ങൾ ഉൾകൊള്ളിക്കും:

വിവിധ സാങ്കേതിക മുറകങ്ങൾ പ്രയോഗിച്ച് നിങ്ങളുടെ പ്രാമ്പ് എഞ്ചിനീയറിങ്ങിന്റെ അറിവ് വിപുലീകരിക്കുക.
നിങ്ങളുടെ പ്രാമ്പുകൾ ക്രമീകരിച്ച് ഔട്ട്പുട്ട് വ്യത്യസ്തമാക്കുക.

പഠന ലക്ഷ്യങ്ങൾ

ഈ പാഠം പൂർത്തിയാക്കിയ ശേഷം, നിങ്ങൾക്ക് കഴിയും:

പ്രാമ്പുകളുടെ ഫലം മെച്ചപ്പെടുത്തുന്ന പ്രാമ്പ് എഞ്ചിനീയറിംഗ് സാങ്കേതികമുറകങ്ങൾ പ്രയോഗിക്കുക.
വ്യത്യസ്തമോ നിർണ്ണായകമോ ആയ പ്രാമ്പിംഗ് നിർവഹിക്കുക.

പ്രാമ്പ് എഞ്ചിനീയറിംഗ്

പ്രാമ്പ് എഞ്ചിനീയറിംഗ് എന്നത് ആഗ്രഹിക്കുന്ന ഫലം നൽകുന്ന പ്രാമ്പുകൾ സൃഷ്ടിക്കുന്ന പ്രക്രിയയാണ്. വെറും ടെക്സ്റ്റ് പ്രാമ്പ് എഴുതുന്നതിൽ കൂടുതൽ പ്രശ്നമാണ് ഇതിൽ. പ്രാമ്പ് എഞ്ചിനീയറിംഗ് ഒരു എഞ്ചിനീയറിംഗ് ശാസ്ത്രമല്ല, എന്നാല്‍ നിങ്ങൾക്ക് ആഗ്രഹിക്കുന്ന ഫലം നേടാൻ പ്രയോഗിക്കാൻ കഴിയുന്ന ചില സാങ്കേതികതകളുടെ ഒരു സമാഹാരമാണ്.

ഒരു പ്രാമ്പിന്റെ ഉദാഹരണം

ഇങ്ങനെയാണ് ഒരു അടിസ്ഥാന പ്രാമ്പ്:

ഭൂഗോളത്തെക്കുറിച്ച് 10 ചോദ്യങ്ങൾ സൃഷ്ടിക്കുക.

ഈ പ്രാമ്പിൽ, നിങ്ങൾ വിവിധ പ്രാമ്പ് സാങ്കേതികതകളുടെ ഒരു സമാഹാരം പ്രയോഗിക്കുകയാണ്.

ഇതിനെ ഫലിച്ചുകൊണ്ട് വായിച്ചു നോക്കാം.

കണ്ടക്സ്റ്റ്, "ഭൂഗോൾ" ആയിരിക്കണം എന്ന് നിർദ്ദേശിക്കുന്നു.
ഔട്ട്പുട്ട് പരിധി, 10 ൽ അധികം ചോദ്യങ്ങൾ വേണമെന്നില്ല.

ലളിതമായ പ്രാമ്പിങ്ങിന്റെ പരിമിതികൾ

ആഗ്രഹിക്കുന്ന ഫലം ലഭിക്കാമാകാമെന്നും, ഇല്ലയാകാമെന്നും വെളിപ്പെടുന്നു. നിങ്ങൾക്ക് ചോദ്യങ്ങൾ ഉണ്ടാകും, എന്നാൽ ഭൂഗോൾ വലിയ വിഷയം ആയതിനാൽ നിങ്ങൾ അഗ്രഹിക്കുന്നത് ലഭിക്കാത്ത സാധ്യതകൾ ഇവയാണ്:

വലിയ വിഷയം, രാജ്യങ്ങൾ, തലസ്ഥാനങ്ങൾ, നദികൾ എന്നിവയേക്കുറിച്ച് ആകാമോ എന്നുറപ്പില്ല.
ഫോർമാറ്റ്, ചോദ്യങ്ങൾ ഒരു നിർതിഷ്ടപ്പെട്ട രീതിയിൽ വേണമെങ്കിൽ?

നിങ്ങള്ക്ക് കാണാമല്ലോ, പ്രാമ്പുകൾ സൃഷ്ടിക്കുമ്പോൾ പരിഗണിക്കേണ്ട കാര്യങ്ങൾ 많습니다.

ഇതുവരെയുള്ള ഒരു ലളിതമായ പ്രാമ്പ് ഉദാഹരണം കണ്ടു, എന്നാൽ ജനറേറ്റീവ് AI പല വ്യവസായങ്ങളിലെയും പല സംഭാവനകളും നൽകുന്നതിൽ കഴിവുള്ളതാണ്. നമുക്ക് ശേഷം ചില അടിസ്ഥാന സാങ്കേതികങ്ങൾ പരിഗണിക്കാം.

പ്രാമ്പിങ്ങിനുള്ള സാങ്കേതിക പടികൾ

ആദ്യം, പ്രാമ്പിംഗ് ഒരു LLMയിൽ ഉള്ള ഉത്ഭവമായ സ്വഭാവമാണെന്ന് മനസ്സിലാക്കണം, അതായത് മോഡലിൽ നിർമ്മിച്ച ഒരു ഫീച്ചർ അല്ല, പക്ഷേ ആണ് ഉപയോഗിക്കുമ്പോൾ കണ്ടെത്തുന്ന കാര്യമായതാണ്.

പ്രാമ്പ് ചെയ്യാൻ ചില അടിസ്ഥാന സാങ്കേതികതകൾ ഉണ്ട്. അവ പരിശോധിക്കാം.

സീറോ-ഷോട്ട് പ്രാമ്പിംഗ്, ഏറ്റവും ലളിതമായ പ്രാമ്പിംഗ് രൂപമാണ്. അതിൽ മോഡൽ പരിശീലന ഡേറ്റ അടിസ്ഥാനമാക്കി ഒറ്റ പ്രാമ്പ് മാത്രം നൽകുന്നു.
ഫ്യൂ-ഷോട്ട് പ്രാമ്പിംഗ്, ഇതുപ്രകാരമുള്ള പ്രാമ്പിംഗിൽ മോഡലിന് 1 അല്ലെങ്കിൽ കൂടുതൽ ഉദാഹരണങ്ങൾ നൽകുകയും അവയാൽ മറുപടി നിർമ്മിക്കാൻ സഹായിക്കുകയും ചെയ്യും.
ചേക്ക്-ഓഫ്-തോട്ട്സ് (Chain-of-thought), ഈ രീതിയിൽ മോഡലിനെ ഒരു പ്രശ്നം ഘട്ടങ്ങളായി വിഭജിച്ച് പരിഹരിക്കാൻ പഠിപ്പിക്കുന്നു.
ജനറേറ്റഡ് നോളേജ്, ഒരു പ്രാമ്പിന്റെ മറുപടി മെച്ചപ്പെടുത്താൻ, പ്രാമ്പിനൊപ്പം നിർമ്മിതമായ വസ്തുതകളും അറിവും നൽകാം.
ലീസ്റ്റ്-ടു-മോസ്റ്റ്, ചേക്ക്-ഓഫ്-തോട്ട്സ് പോലെയാണ് ഇത്, ഒരു പ്രശ്നം ഘട്ടങ്ങളായി വിഭജിച്ച് ഓരോ ഘട്ടങ്ങളും സമയക്രമത്തിൽ നിർവഹിക്കാൻ ആവശ്യപ്പെടുന്നു.
സ്വയം-പരിഷ്കരണം (Self-refine), മോഡലിന്റെ ഔട്ട്പുട്ട് വിമർശിച്ച് സുധാരണം ആവശ്യപ്പെടുന്ന സാങ്കേതികതയാണ്.
മൈയേറ്റിക് പ്രാമ്പിംഗ് (Maieutic prompting). ഇതിൽ മോഡലിന്റെ മറുപടി ശരിയാണെന്ന് ഉറപ്പാക്കാൻ ഓരോ ഭാഗവും വിശദീകരിക്കാൻ ആവശ്യപ്പെടുന്നു. സ്വയം-പരിഷ്കരണത്തിന്റെ ഒരു രൂപമാണ്.

സീറോ-ഷോട്ട് പ്രാമ്പിംഗ്

ഈ പ്രാമ്പിംഗ് വളരെ ലളിതമാണ്, ഒറ്റ പ്രാമ്പടങ്ങിയതാണ്. നിങ്ങൾ LLM പഠിക്കാൻ തുടങ്ങുമ്പോൾ ഇതുപയോഗിക്കുന്നതായിരിക്കാം. ഉദാഹരണം:

പ്രാമ്പ്: "ആൽജിബ്ര എന്താണ്?"
മറുപടി: "ആൽജിബ്രയെ കുറിച്ച് പഠിക്കുന്ന ഗണിത ശാഖയാണ്, ഇതിൽ ഗണിത ചിഹ്നങ്ങളും അവ കൈകാര്യം ചെയ്‌തുകൊണ്ടും നിയമങ്ങളും പഠിക്കുന്നു."

ഫ്യൂ-ഷോട്ട് പ്രാമ്പിംഗ്

ഈ രീതി മോഡലിന് കുറച്ച് ഉദാഹരണങ്ങൾ നൽകിയാണ് സഹായിക്കുക. ഒരു പ്രാമ്പുമായിട്ടാണ് ഇത് ചെയ്യുന്നത്, ടാസ্কിനോട് അനുയോജ്യമായ ഉള്ളടക്കം കൂടി നൽകുന്നു. ഉദാഹരണം:

പ്രാമ്പ്: "ഷേക്‌സ്പിയറിന്റെ ശൈലിയിൽ ഒരു കവിത എഴുതുക. ഇതാ ഷേക്‌സ്പിയറിന്റെ സോനെറ്റ് ഉദ്ധരണികൾ: സോനെറ്റ് 18: 'നാളെ ഒരു വേനൽക്കാല ദിനം പോലെയാണോ നിന്നെ ഞാൻ കാണുക? നീ കൂടുതൽ മനോഹരവും കൂടുതൽ സമതലവുമാണ്...' സോനെറ്റ് 116: 'ശുദ്ധ മനസ്സുകളുടെ വിവാഹത്തിൽ തടസ്സങ്ങൾ വരുത്താൻ ഞാൻ അനുവദിക്കില്ല. സ്നേഹം സ്നേഹം അല്ല മറുപടി കാണുമ്പോൾ മാറുന്ന...' സോനെറ്റ് 132: 'നിന്റെ കണ്ണുകൾ ഞാൻ സ്നേഹിക്കുന്നു, അവ എന്നെ കരുണയായി കാണുന്നു, ഹൃദയം വേദനിപ്പിക്കുന്നുണ്ടു,...' ഇപ്പോൾ, ചന്ദ്രന്റെ സൗന്ദര്യത്തെക്കുറിച്ച് ഒരു സോനെറ്റ് എഴുതുക."
മറുപടി: "ആകാശത്തിൽ, ചന്ദ്രൻ മൃദുവായി തെളിഞ്ഞു, വെള്ളിംഗ് പ്രകാശത്തിൽ കരുണയുടെ ആനന്ദം തരുന്നു,..."

ഉദാഹരണങ്ങൾ മോഡലിന് കൃത്യമായ ടീമും ഫോർമാറ്റും ഉണ്ടെന്ന് അറിയിച്ച് കൂടുതൽ ശരിയായ മറുപടികൾ ലഭിക്കാൻ സഹായിക്കുന്നു.

ചൈനോഫ്-തോട്ട്സ്

ചൈനോഫ്-തോട്ട്സ് ഒരു അത്യന്തം രസകരമായ സാങ്കേതികതയാണ്, കാരണം മോഡലിനെ ഘട്ടങ്ങളായി നിർദ്ദേശിക്കുന്നു. ഇത് മോഡലിന് പ്രവർത്തനം പഠിപ്പിക്കുന്ന ഒരു രീതിയാണ്. ചുവടെയുള്ള ഉദാഹരണം നോക്കാം, ചൈനോഫ്-തോട്ട്സ് ഉപയോഗിച്ച്, കൂടാതെ ഉപയോഗിക്കാത്തതും:

- പ്രാമ്പ്: "അലീസ് وٽ 5 ആപ്പിൾസ് ഉണ്ട്, 3 എറിയുന്നു, 2 ബോബിനു കൊടുക്കുന്നു, ബോബ് ഒന്നു തിരികെ നൽകുന്നു, അപ്പോൾ അലീസിനും എത്ര ആപ്പിൾസ്?"
- മറുപടി: 5

മോഡൽ 5 എന്ന ഉത്തരം നൽകിയിട്ടുണ്ട്, ശരിയല്ല. ശരിയായ ഉത്തരം 1 ആപ്പ്ൾ ആണ്, കണക്കു പ്രകാരം (5 -3 -2 + 1 = 1).

മോഡലിനെ ഇത് ശരിയായി ചെയ്യാൻ എങ്ങനെ പഠിപ്പിക്കാം?

ചൈനോഫ്-തോട്ട്സ് പരീക്ഷിക്കാം. ഇതിൽ:

മോഡലിന് സമാനമായ ഉദാഹരണം നൽകുക.
കണക്കു കാണിക്കുകയും ശരിയായ കണക്കു കാണിക്കുകയും ചെയ്യുക.
യഥാർത്ഥ പ്രാമ്പ് നൽകുക.

ഇങ്ങനെ:

പ്രാമ്പ്: "ലിസയ്ക്ക് 7 ആപ്പിൾസ് ഉണ്ട്, 1 എറിയുന്നു, 4 ബാർട്ടിന് കൊടുക്കുന്നു, ബാർട്ട് ഒന്നു തിരികെ കൊടുക്കുന്നു: 7 -1 = 6 6 -4 = 2 2 +1 = 3
അലീസിനു 5 ആപ്പിൾസ് ഉണ്ട്, 3 എറിയുന്നു, 2 ബോബിനു കൊടുക്കുന്നു, ബോബ് ഒന്നു തിരികെ നൽകുന്നു, എത്ര ആപ്പിൾസ് ഉണ്ട്?" മറുപടി: 1

ഇവിടെ നമ്മുടെ പ്രാമ്പുകൾ വിസ്തൃതമായതാണ്, മറ്റൊരു ഉദാഹരണം, കണക്കു, പിന്നീട് യഥാർത്ഥ പ്രാമ്പ്; ശരിയായ ഉത്തരം 1 ലഭിച്ചു.

കാണാമല്ലോ, ചൈനോഫ്-തോട്ട്സ് ഒരു ശക്തিশാലിയായ സാങ്കേതികതയാണ്.

ജനറേറ്റഡ് നോളേജ്

കള്ളികെ, നിങ്ങളുടെ സ്വന്തം കമ്പനി ഡേറ്റ ഉപയോഗിച്ച് പ്രാമ്പ് രൂപപ്പെടുത്താനാണ് താല്പര്യം. പ്രാമ്പിന്റെ ഒരു ഭാഗം കമ്പനിയുടേതായിരിക്കണം, മറ്റൊന്ന് നിങ്ങൾ വർണം ചെയ്യാൻ ആഗ്രഹിക്കുന്ന പ്രാമ്പ് ആകണം.

ഉദാഹരണത്തിന്, ഇൻഷുറൻസ് ബിസിനസ്സിൽ നിങ്ങൾ എല്ലാം ഇങ്ങനെ കാണാം:

{{company}}: {{company_name}}
{{products}}:
{{products_list}}
Please suggest an insurance given the following budget and requirements:
Budget: {{budget}}
Requirements: {{requirements}}

മുകളിൽ, ഒരു ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് പ്രാമ്പ് എങ്ങനെ നിർമ്മിക്കാമെന്ന് കാണിക്കുന്നു. ടെംപ്ലേറ്റിൽ {{variable}} എന്ന പലവ്യത്യാസം അടങ്ങിയിട്ടുണ്ട്, അവ കമ്പനി API എനിക്കുള്ള യഥാർത്ഥ മൂല്യങ്ങളാൽ മാറ്റപ്പെടും.

കമ്പനി ഉള്ളടക്കം കൊണ്ട് വേരിയബിളുകൾ മാറ്റി പ്രാമ്പ് ഇങ്ങനെ കാണാം:

Insurance company: ACME Insurance
Insurance products (cost per month):
- Car, cheap, 500 USD
- Car, expensive, 1100 USD
- Home, cheap, 600 USD
- Home, expensive, 1200 USD
- Life, cheap, 100 USD

Please suggest an insurance given the following budget and requirements:
Budget: $1000
Requirements: Car, Home, and Life insurance

ഈ പ്രാമ്പ് LLM-ൽ ഓടിച്ചാൽ ഇങ്ങനെ മറുപടി ലഭിക്കും:

Given the budget and requirements, we suggest the following insurance package from ACME Insurance:
- Car, cheap, 500 USD
- Home, cheap, 600 USD
- Life, cheap, 100 USD
Total cost: $1,200 USD

കാണാമല്ലോ, ലൈഫ് ഇൻഷുറൻസ് സൂചിപ്പിക്കുന്നു, ഇത് വേണ്ടതല്ല. ഇത് സൂചിപ്പിക്കുന്നത്, പ്രാമ്പ് മോഡലിന് അനുസരിക്കാനുള്ള വിധം കൂടുതൽ വ്യക്തമായും പരിഷ്കരിക്കേണ്ടതുണ്ടെന്ന് ആണ്. ചില പരീക്ഷണാത്മക പരിശ്രമങ്ങൾക്കു ശേഷം, ഇങ്ങനെ പ്രാമ്പ് ക്രമീകരിച്ചു:

Insurance company: ACME Insurance
Insurance products (cost per month):
- type: Car, cheap, cost: 500 USD
- type: Car, expensive, cost: 1100 USD
- type: Home, cheap, cost: 600 USD
- type: Home, expensive, cost: 1200 USD
- type: Life, cheap, cost: 100 USD

Please suggest an insurance given the following budget and requirements:
Budget: $1000 restrict choice to types: Car, Home

_type_, _cost_ കൂട്ടിച്ചേർക്കുകയും restrict എന്ന കീവേഡ് ഉപയോഗിച്ച് മോഡലിനെ ഞങ്ങൾ ആഗ്രഹിക്കുന്നതിന്റെ വ്യക്തത നൽകുകയും ചെയ്തതിന്റെ കാര്യം ശ്രദ്ധിക്കുക.

ഇപ്പോൾ ഇതാ ലഭിച്ച മറുപടി:

Given the budget and requirements, we suggest the Car, Cheap insurance product which costs 500 USD per month.

ഈ ഉദാഹരണത്തിന്റെ ഉദ്ദേശം, ഒരു അടിസ്ഥാന സാങ്കേതികതയായ ജനറേറ്റഡ് നോളേജ് ഉപയോഗിച്ചെങ്കിലും, പലപ്പോഴും പ്രാമ്പ് മെച്ചപ്പെടുത്തേണ്ടതുണ്ട് എന്ന് കാണിക്കുക മാത്രമാണ്.

Least-to-most

Least-to-most പ്രാമ്പിങ്ങിന്റെ ആശയം ഒരു വലിയ പ്രശ്നം ഉപപ്രശ്നങ്ങളായി വേര്ക്കുക എന്നതാണ്. ഇതിലൂടെ LLM-നെ വലിയ പ്രശ്നം എങ്ങനെ "വിജയിക്കുക" എന്ന് നയിക്കുന്നു. ഡാറ്റാ സയൻസിനായി ഒരു നല്ല ഉദാഹരണം:

പ്രാമ്പ്: ഡാറ്റാ സയൻസ് എങ്ങനെ 5 ഘട്ടത്തിൽ നടത്താം?

AI-ഉത്തരം:

ഡാറ്റ ശേഖരിക്കുക
ഡാറ്റ ശുചീകരിക്കുക
ഡാറ്റ വിശകലനം ചെയ്യുക
ഡാറ്റ ചിത്രീകരിക്കുക
ഡാറ്റ അവതരിപ്പിക്കുക

സ്വയം-പരിഷ്കരണം, പ്രതികരണങ്ങൾ വിമർശിക്കുക

ജനറേറ്റീവ് AIകളും LLM-കളും ഉള്ളപ്പോൾ, ഔട്ട്പുട്ട് വിട്ടുനൽകാൻ വിശ്വാസം വയ്ക്കുന്നത് പ്രായോഗികമല്ല. LLM അടുത്ത ശക്തമയിരിക്കാവുന്ന വാക്ക് പറയുന്നുണ്ട്, ശരിയല്ല. അതിനാൽ, മോഡലിനെ സ്വയം വിമർശനം നടത്താനും മികച്ചിത്തരം ആവശ്യപ്പെടാനും പറയുന്നത് നല്ല ഒരു സമർത്ഥനയാണ്, അതു സ്വയം-പരിഷ്കരണ തന്ത്രം.

കൈയിലുള്ള നടപടിക്രമം:

ആദി പ്രാമ്പ് മോഡലിന് പ്രശ്നം പരിഹരിക്കാൻ ആവശ്യപ്പെടുക.
മോഡൽ മറുപടി നൽകുക.
നിങ്ങൾ മറുപടി വിമർശിച്ച് AI-ൽ മെച്ചപ്പെടുത്താൻ ആവശ്യപ്പെടുക.
മോഡൽ വീണ്ടും മറുപടി നൽകുന്നു, വിമർശനം പരിഗണിച്ച് പരിഹാരങ്ങൾ നിർദ്ദേശിക്കുന്നു.

ഈ പ്രക്രിയ എത്ര തവണ വേണമെങ്കിലും ആവർത്തിക്കാം.

ഈ സാങ്കേതികത ഉപയോഗിച്ചുള്ള ഉദാഹരണം:

പ്രാമ്പ്: "ഉൽപ്പന്നങ്ങൾക്കും ഉപഭോക്താക്കൾക്കും റൂട്ടുകളുള്ള Python വെബ് API സൃഷ്ടിക്കുക"

AI മറുപടി:

import flask
app = Flask(__name__)

@app.route('/products')
def products():
    return 'Products'

@app.route('/customers')
def customers():
    return 'Customers'

പ്രാമ്പ്: മുകളിൽ കൊടുത്ത കോഡിലെ 3 മെച്ചപ്പെടുത്തലുകൾ നിർദ്ദേശിക്കുക

AI മറുപടി:

Sure, here are three suggestions to improve the code:

Import the correct module: The first line should import Flask instead of flask. The correct import statement should be from flask import Flask.

Add a main function: Add a if __name__ == '__main__': block to the end of the file to run the application when the file is executed.

Use f-strings: Use f-strings to format the return statements in the route functions. For example, return 'Products' can be changed to return f'This is the {request.path} page'.

from flask import Flask, request

app = Flask(__name__)

@app.route('/products')
def products():
    return f'This is the {request.path} page'

@app.route('/customers')
def customers():
    return f'This is the {request.path} page'

if __name__ == '__main__':
    app.run()

കാണാമല്ലോ, മേൽപ്പറഞ്ഞ AI മറുപടി ആദ്യം നിർദ്ദേശിച്ച കോഡ് മെച്ചപ്പെടുത്തുന്നു, ആദ്യത്തെ മറുപടി വിമർശിച്ചതുകൊണ്ട്.

മൈയേറ്റിക് പ്രാമ്പിംഗ്

സ്വയം-പരിഷ്കരണത്തിന്‍റെ സമാനമായ സാങ്കേതികതയാണ് മൈയേറ്റിക് പ്രാമ്പിംഗ്, എന്നാൽ ഇതിൽ LLM-നോട് സ്വയം വിശദീകരിക്കാൻ ആവശ്യപ്പെടുന്നു. ലക്ഷ്യം LLM-ന്റെ മറുപടിയിലുള്ള അസമ്മതങ്ങൾ കുറയ്ക്കുകയും ശരിയായ ഉത്തരത്തിലെത്താൻ ഉറപ്പാക്കുകയും ചെയ്യുക എന്നതാണ്. പ്രവൃത്തി പടികൾ:

LLM-നോട് ഒരു ചോദ്യത്തിന് മറുപടി പറയാൻ ആവശ്യപ്പെടുക.
ഉത്തരം ഉള്ള ഓരോ ഭാഗത്തെയും വിശദീകരിക്കാൻ LLM-നെ ആവശ്യപ്പെടുക.
അസമ്മതങ്ങൾ ഉണ്ടെങ്കിൽ, അവ ഭാഗങ്ങൾ ഒഴിവാക്കുക.

2, 3 പടികൾ ആവർത്തിച്ച് എല്ലാ ഭാഗങ്ങളും പരിശോധിച്ചു പുതിയ ഉത്തരം തൃപ്തിപെടുന്നതുവരേക് തുടരുക.

ഉദാഹരണ പ്രാമ്പ്:

പ്രാമ്പ്: പെരുമാറ്റം വൈറസിനെ തടയാനായി 5 ഘട്ടത്തിൽ പ്രതിസന്ധി പദ്ധതികരിക്കുക? LLM മറുപടി:

1. Identify the risks
1. Identify the stakeholders
1. Identify the resources
1. Identify the actions
1. Identify the communication channels

5 ഘട്ടങ്ങൾ കണ്ടെടുത്തു, എന്നാൽ ഇത് ശരിയാണോ? ഓരോ ഘട്ടവും വിശദീകരിക്കാൻ LLM-നെ ചോദിക്കാം:

പ്രാമ്പ്: ആദ്യ ഘട്ടം കൂടുതൽ വിശദമായി വിശദീകരിക്കുക, പാൻഡെമിക് സംബന്ധിച്ചുള്ള അപകടങ്ങൾ എന്തെല്ലാം?

The risks are the following:

- Loss of life
- Loss of business
- Loss of reputation
- Loss of customers
- Loss of employees

ഇപ്പോൾ LLM ശരിയാണെന്ന് ഉറപ്പ് വരുത്താൻ, ആദ്യആപത്ത് കൂടുതൽ വിശദീകരിക്കാൻ ആവശ്യപ്പെടാം:

പ്രാമ്പ്: പാൻഡെമിക് സമയത്ത് ഏറ്റവും വലിയ അപകടം ഏതാണ്, എന്തുകൊണ്ടാണ്?

The biggest risk is loss of life because it's the most important thing to protect.

പാൻഡെമിക് സമയത്തെ 2 വളരെ വലിയ അപകടങ്ങൾ എന്തെല്ലാം?

The two biggest risks are loss of life and loss of business.

ഇപ്പോൾ LLM സംവേദനീയമാണ്, "ജീവിതം"യും "ബിസിനസ്സ്" എന്നും ഏറ്റവും പ്രധാനപ്പെട്ട അപകടങ്ങൾ ആയി പറയുന്നു. ഇനി അടുത്ത ഘട്ടത്തിലേക്ക് സുഖമായി മുന്നോട്ട് പോകാം. എങ്കിലും LLM-നെ അন্ধമായി വിശ്വസിക്കരുത്, ഔട്ട്പുട്ട് എപ്പോഴും പരിശോധിക്കണം.

നിങ്ങളുടെ ഔട്ട്പുട്ട് വ്യത്യസ്തമാക്കുക

LLM-കൾ സ്വാഭാവികമായി നിർണ്ണായകമല്ലാത്തവയാണ്, അതായത് ഒരേ പ്രാമ്പ് വീണ്ടും ഓടിച്ചതിൽ വ്യത്യസ്ത ഫലങ്ങൾ ലഭ്യം. ഈ പ്രാമ്പ് പരീക്ഷിക്കൂ:

"Python വെബ് API-ക്ക് കോഡ് നിർമ്മിക്കുക"

# ആവശ്യമായ മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്യുക
import flask
from flask import request, jsonify

# ഒരു ഫ്ലാസ്‌ക് ആപ്പ് സൃഷ്ടിക്കുക
app = flask.Flask(__name__)

# APIയ്ക്ക് വേണ്ടി ഒരു റൂട്ടു സൃഷ്ടിക്കുക
@app.route('/api', methods=['GET'])
def api():
    # അഭ്യർത്ഥനയിൽനിന്ന് ഡാറ്റ നേടുക
    data = request.args

    # ഡാറ്റ പ്രോസസ് ചെയ്യുക
    result = process_data(data)

    # ഫലം JSON ആകൃതിയിൽ നല്‍കുക
    return jsonify(result)

# ഡാറ്റ പ്രോസസ് ചെയ്യാനുള്ള ഫങ്ഷന്
def process_data(data):
    # ഡാറ്റ ഉപയോഗിച്ച് എന്തെങ്കിലും ചെയ്യുക
    result = data + 1

    # ഫലം തിരിച്ചു നൽകുക
    return result

# ആപ്പ് നടത്തുക
if __name__ == '__main__':
    app.run()

ഒരേ പ്രാമ്പ് വീണ്ടും ഓടിച്ചതിൽ ചെറിയ വ്യത്യാസമുള്ള മറുപടി ലഭിച്ചു:

#ആവശ്യമായ പാക്കേജുകൾ ഇറക്കുമതി ചെയ്യുക
import flask
from flask import request, jsonify

#Flask അപ്ലിക്കേഷൻ സൃഷ്ടിക്കുക
app = flask.Flask(__name__)
app.config["DEBUG"] = True

#പുസ്തകങ്ങളുടെ ഒരു പട്ടിക സൃഷ്ടിക്കുക
books = [
    {'id': 0,
     'title': 'A Fire Upon the Deep',
     'author': 'Vernor Vinge',
     'first_sentence': 'The coldsleep itself was dreamless.',
     'year_published': '1992'},
    {'id': 1,
     'title': 'The Ones Who Walk Away From Omelas',
     'author': 'Ursula K. Le Guin',
     'first_sentence': 'With a clamor of bells that set the swallows soaring, the Festival of Summer came to the city Omelas, bright-towered by the sea.',
     'published': '1973'},
    {'id': 2,
     'title': 'Dhalgren',
     'author': 'Samuel R. Delany',
     'first_sentence': 'to wound the autumnal city.',
     'published': '1975'}
]

#APIയ്ക്കായി ഒരു എന്ഡ്പോയിന്റ് സൃഷ്ടിക്കുക
@app.route('/', methods=['GET'])
def home():
    return '''<h1>Books API</h1>
<p>A prototype API for retrieving books.</p>'''

#എല്ലാ പുസ്തകങ്ങളും തിരിച്ചുകൊടുക്കാൻ ഒരു എന്ഡ്പോയിന്റ് സൃഷ്ടിക്കുക
@app.route('/api/v1/resources/books/all', methods=['GET'])
def api_all():
    return jsonify(books)

#ഒരു ഏകദേശം പുസ്തകം തിരിച്ചുകൊടുക്കാൻ ഒരു എന്ഡ്പോയിന്റ് സൃഷ്ടിക്കുക
@app.route('/api/v1/resources/books', methods=['GET'])
def api_id():
    #URL ന്റെ ഭാഗമായായി ഒരു ID നൽകിയിട്ടുണ്ടോ എന്ന് പരിശോധന നടത്തുക
    #ID നൽകിയിട്ടുണ്ടെങ്കിൽ, അത് ഒരു വേരിയബിളിൽ നിയോഗിക്കുക
    #ID നൽകിയിട്ടില്ലെങ്കിൽ, ഒരു പിശക് പ്രദർശിപ്പിക്കുക
    if 'id' in request.args:
        id = int(request.args['id'])
    else:
        return "Error: No id field provided. Please specify an id."

    #ഞങ്ങളുടെ ഫലങ്ങൾക്കായി ഒരു ശൂന്യ പಟ್ಟಿ സൃഷ്ടിക്കുക
    results = []

    #ഡാറ്റയുടെ വഴി സഞ്ചരിച്ചു ആവശ്യപ്പെട്ട ID ന് ഫിറ്റ് ചെയ്യുന്ന ഫലങ്ങൾ കണ്ടെത്തുക
    #IDകൾ ഏകീകൃതമാണ്, പക്ഷേ മറ്റ് ഫീൽഡുകൾ പല ഫലങ്ങളും നൽകാം
    for book in books:
        if book['id'] == id:
            results.append(book)

    #Python ന്റെ ഡിക്ഷണറികൾ JSON ഫോർമേറ്റിലേക്ക് മാറ്റാൻ Flask ൽ നിന്നുള്ള jsonify ഫംഗ്ഷൻ ഉപയോഗിക്കുക
    #Python ഡിക്ഷണറികളുടെ പട്ടിക JSON ഫോർമാറ്റിലേക്ക് മാറ്റാൻ jsonify ഫംഗ്ഷൻ ഉപയോഗിക്കുക
    return jsonify(results)

app.run()

വ്യത്യസ്തമായ ഔട്ട്പുട്ട് പ്രശ്നമാണോ?

നിങ്ങൾ ചെയ്യാനുള്ള കാര്യത്തിനനുസരിച്ച് വ്യത്യസ്തമാകും. ഒരു കൃത്യ മറുപടി വേണമെങ്കിൽ പ്രശ്നമാണ്. "ഭൂഗോളത്തിലേക്കുള്ള എളുപ്പം 3 ചോദ്യങ്ങൾ സൃഷ്ടിക്കുക" പോലുള്ള വ്യത്യസ്ത ഔട്ട്പുട്ട് താങ്കൾക്ക് ആസ്വദ്യമാണെങ്കിൽ പ്രശ്നമല്ല.

###OUTPUT വ്യത്യസ്തമാക്കാൻ ടേംപറേച്ചർ ഉപയോഗിക്കുക

അതായത്, നാം ഔട്ട്പുട്ട് കൂടുതൽ പ്രവചിക്കാൻ കഴിയുന്നത് (ധാരാളം നിർണ്ണായകമാക്കലായ) ആക്കണമെന്ന് തീരുമാനിച്ചു. എങ്ങനെ ചെയ്യാം?

ടേംപറേച്ചർ 0 മുതൽ 1 വരെ ഒരു മൂല്യമാണ്, 0 ഏറ്റവും നിർണ്ണായകവും 1 ഏറ്റവും വ്യത്യസ്തവുമാണ്. ഡീഫോൾട്ട് 0.7 ആണ്. ടേംപറേച്ചർ 0.1 ആയി സമാന പ്രാമ്പ് രണ്ട് പ്രാവശ്യം ഓടിക്കുമ്പോൾ എന്താകും കാണുന്നത് നോക്കാം:

"Python വെബ് API-ക്ക് കോഡ് നിർമ്മിക്കുക"

#ആവശ്യമായ ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുക
import flask
from flask import request, jsonify

#Flask ക്ലാസിന്റെ ഒരു ഇനം സൃഷ്ടിക്കുക
app = flask.Flask(__name__)

#API-യ്ക്ക് ഒരു എന്റ്പോയിന്റ് സൃഷ്ടിക്കുക
@app.route('/api/v1/endpoint', methods=['GET'])
def api_endpoint():
    #അഭ്യർത്ഥന ഡാറ്റ നേടുക
    data = request.get_json()

    #ഡാറ്റ പ്രോസസ്സ് ചെയ്യുക
    result = process_data(data)

    #ഫലം തിരിച്ചയയ്‌ക്കുക
    return jsonify(result)

#ഡാറ്റ പ്രോസസ്സ് ചെയ്യാനുള്ള ഫംഗ്ഷൻ
def process_data(data):
    #ഡാറ്റ പ്രോസസ്സ് ചെയ്യുക
    result = {'result': 'success'}

    #ഫലം തിരിച്ചയയ്‌ക്കുക
    return result

#Flask ആപ്പ് പ്രവർത്തിപ്പിക്കുക
if __name__ == '__main__':
    app.run()

ഇനി വീണ്ടും ഓടിച്ചപ്പോൾ ഈ ഫലം വാങ്ങി:

#ആവശ്യമായ ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുക
import flask
from flask import request, jsonify

#ഒരു ഫ്ലാസ്‌ക് ആപ്പ് ഉണ്ടാക്കുക
app = flask.Flask(__name__)

#API യ്ക്ക് ഒരു റൂട്ടു സൃഷ്ടിക്കുക
@app.route('/api', methods=['GET'])
def api_call():
    #അഭ്യർത്ഥനയിൽ നിന്ന് ഡാറ്റ ലഭിക്കുക
    data = request.get_json()

    #ഡാറ്റ പ്രോസസ്സുചെയ്യുക
    result = process_data(data)

    #ഫലം തിരിച്ച് നൽകുക
    return jsonify(result)

#process_data ഫംഗ്ഷൻ നിർവചിക്കുക
def process_data(data):
    #ഡാറ്റയുമായി ഒന്നുകൂടെ ചെയ്യുക
    result = data + 1

    #ഫലം തിരിച്ച് നൽകുക
    return result

#ആപ്പ് നടത്തുക
if __name__ == '__main__':
    app.run()

ഈ രണ്ട് ഫലങ്ങൾക്കിടയിൽ ചെറുതൊരു വ്യത്യാസം മാത്രമാണ്. മറുവശം, ടേംപറേച്ചർ 0.9 ആയി നിന്ന് നോക്കാം:

# ആവശ്യമായ ലൈബ്രറികൾ ഇംപോർട്ട് ചെയ്യുക
import flask
from flask import request, jsonify

# ഒരു Flask ആപ്പ് സൃഷ്ടിക്കുക
app = flask.Flask(__name__)

# API-യ്ക്ക് ഒരു റൂട്ടു സൃഷ്ടിക്കുക
@app.route('/api', methods=['GET'])
def api_call():
    # അഭ്യർത്ഥനയിൽ നിന്നുള്ള ഡാറ്റ നേടുക
    data = request.args

    # ഡാറ്റ പ്രോസസ് ചെയ്യുക
    result = process_data(data)

    # ഫലം റിട്ടേൺ ചെയ്യുക
    return jsonify(result)

# ഡാറ്റ പ്രോസസ് ചെയ്യാനുള്ള ഫംഗ്ഷൻ
def process_data(data):
    # ഡാറ്റ ഉപയോഗിച്ച് എന്തെങ്കിലും ചെയ്യുക
    result = data + 1

    # ഫലം റിട്ടേൺ ചെയ്യുക
    return result

# ആപ്പ് ഓടിക്കുക
if __name__ == '__main__':
    app.run()

ഇനി 0.9 ടേംപറേച്ചർ ഉപയോഗിച്ച് രണ്ടാമത്തെ ശ്രമം:

import flask
from flask import request, jsonify

# ഫ്ലസ്ക് ആപ്പ് സൃഷ്ടിക്കുക
app = flask.Flask(__name__)
app.config['DEBUG'] = True

# ചില ടെസ്റ്റ് ഡേറ്റാ സൃഷ്ടിക്കുക
books = [
    {'id': 0, 'title': 'A Fire Upon The Deep', 'author': 'Vernor Vinge', 'first_sentence': 'The coldsleep itself was dreamless.', 'year_published': '1992'},
    {'id': 1, 'title': 'The Ones Who Walk Away From Omelas', 'author': 'Ursula K. Le Guin', 'first_sentence': 'With a clamor of bells that set the swallows soaring, the Festival of Summer came to the city Omelas, bright-towered by the sea.', 'published': '1973'},
    {'id': 2, 'title': 'Dhalgren', 'author': 'Samuel R. Delany', 'first_sentence': 'to wound the autumnal city.', 'published': '1975'}
]

# ഒരു എന്റ്പോയിന്റ് സൃഷ്ടിക്കുക
@app.route('/', methods=['GET'])
def home():
    return '''<h1>Welcome to our book API!</h1>'''

@app.route('/api/v1/resources/books

കാണാമല്ലോ, ഫലങ്ങൾ വളരെ വ്യത്യസ്തമാണ്.

ദയവായി ശ്രദ്ധിക്കുക, output വ്യത്യസ്തമാക്കാൻ നിങ്ങൾ മാറ്റിക്കொள்ளാവുന്ന മറ്റും നിരവധി പാരാമീറ്ററുകൾ ഉണ്ട്, ഉദാ: top-k, top-p, repetition penalty, length penalty, diversity penalty എന്നിങ്ങനെ, പക്ഷേ ഇവ ഈ പാഠ്യപദ്ധതിയുടെ പരിധിക്കിനപ്പെടുന്നില്ല.

നല്ല പ്രയോഗങ്ങൾ

നിങ്ങൾക്ക് നിങ്ങൾക്കിഷ്ടമായ ഫലം നേടാൻ പരീക്ഷിക്കാവുന്ന നിരവധി പ്രയോഗങ്ങൾ ഉണ്ട്. നിങ്ങൾ കൂടുതൽ കൂടുതൽ prompting ഉപയോഗിക്കുമ്പോൾ നിങ്ങളുടെ സ്വന്തം ശൈലി കണ്ടെത്തും.

നമുക്ക് പരിചയപ്പെടുത്തിയ സൂത്രങ്ങളോട് കൂടാതെ, ഒരു LLM പ്രോട്ട് ചെയ്യുമ്പോൾ പരിഗണിക്കേണ്ട ചില നല്ല പ്രയോഗങ്ങൾ ഉണ്ട്.

ഇവിടെ ചില നല്ല പ്രയോഗങ്ങൾ പരിഗണിക്കാം:

സന്ദർഭം വ്യക്തമാക്കുക. അതിവശ്യമാണ്, ഡൊമെയിൻ, വിഷയം തുടങ്ങിയവ ആവശ്യത്തിന് നിർവ്വചിക്കാൻ കഴിയുവെങ്കിൽ ഫലം ആതിരം മെച്ചപ്പെടും.
output ലെ ഒളു് നിമിഷം വെക്കുക. നിങ്ങൾക്ക് ഒരു നിശ്ചിത എണ്ണം ഐറ്റങ്ങൾ വേണമെങ്കിൽ അല്ലെങ്കിൽ നിശ്ചിത ദൈർഘ്യം വേണമെങ്കിൽ, അതിനെ വ്യക്തമാക്കുക.
ആവശ്യവും എങ്ങനെ വേണമെന്നുമെന്താണെന്നും ഒരുകൂട്ടം വ്യക്തമാക്കുക. ഉദാഹരണത്തിന് "Create a Python Web API with routes products and customers, divide it into 3 files" എന്നിങ്ങനെ എന്താണെന്നും എങ്ങനെ വേണമെന്നുമെന്താണെന്നും പറയുക.
ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുക. വ്യവസായത്തിൽ നിന്നുള്ള ഡാറ്റ ഉപയോഗിച്ച് നിങ്ങളുടെ പ്രോംപ്റ്റുകൾ സമ്പന്നമാക്കാന്‍ നിങ്ങൾ സാധാരണ ഇച്ഛിക്കും. ഇത് ടേംപ്ലേറ്റുകൾ ഉപയോഗിച്ച് ചെയ്യുക. ടെംപ്ലേറ്റുകളിൽ 변수를 റിplaസ്ചിരിക്കാൻ കഴിയും.
ശുദ്ധമായി ഒപ്പിടുക. LLM കൾ ശരിയായ മറുപടി നൽകാൻ ഇരിക്കും, എന്നാൽ നിങ്ങൾ ശുദ്ധമായി ഒപ്പിയിടുന്നതിനാൽ മികച്ച മറുപടി ലഭിക്കും.

അസ്സൈൻമെന്റ്

Flask ഉപയോഗിച്ച് ഒരു ലളിതമായ API എങ്ങനെ ഉണ്ടാക്കാമെന്ന് കാണിക്കുന്ന Python കോഡ് ഇതാ:

from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def hello():
    name = request.args.get('name', 'World')
    return f'Hello, {name}!'

if __name__ == '__main__':
    app.run()

GitHub Copilot അല്ലെങ്കിൽ ChatGPT പോലൊരു AI അസിസ്റ്റന്റിനെ ഉപയോഗിച്ച് "സ്വയം മെച്ചപ്പെടുത്തൽ" സാങ്കേതിക വിദ്യ പ്രയോഗിച്ച് കോഡ് മെച്ചപ്പെടുത്തുക.

പരിഹാരം

കരുണയായി, കോഡിൽ അനുയോജ്യമായ പ്രോംപ്റ്റുകൾ ചേർത്ത് അസ്സൈൻമെന്റ് നിർവഹിക്കാൻ ശ്രമിക്കുക.

Tip

മികച്ച പ്രോംപ്റ്റ് രൂപപ്പെടുത്തുക. മെച്ചപ്പെടുത്തലുകളുടെ എണ്ണം നിയന്ത്രിക്കുന്നത് നല്ല ആശയമാണ്. നിങ്ങൾക്ക് ആർക്കിടെചർ, പ്രകടനം, സുരക്ഷ തുടങ്ങിയ രീതിയിൽ മെച്ചപ്പെടുത്താൻ ആവശ്യപ്പെടാനും കഴിയും.

Solution

അറിവ് പരിശോധന

Chain-of-thought prompting എന്തിന് ഉപയോഗിക്കാറുണ്ടോ? ശരിയായ ഒരു മറുപടി ഉം തെറ്റായ രണ്ട് മറുപടികളും കാണിക്കുക.

പ്രശ്നം എങ്ങനെ പരിഹരിക്കാമെന്ന് LLM-ന് പഠിപ്പിക്കാൻ.
B, കോഡിലുള്ള പിഴവുകൾ കണ്ടെത്താനായി LLM-ന് പഠിപ്പിക്കാൻ.
C, LLM-ന് വ്യത്യസ്ത പരിഹാരങ്ങൾ കണ്ടെത്താൻ നിർദ്ദേശിക്കാൻ.

A: 1, കാരണം chain-of-thought prompting LLM-ന് ഒരു പ്രശ്നം പരിഹരിക്കുന്നതിന് വേണ്ട സംവിധാനം ഒരു സീരീസ് വഴികളോടും സമാന പ്രശ്നങ്ങളും അവ എങ്ങനെ പരിഹരിച്ചു എന്നതും കാണിക്കുന്നതാണ്.

🚀 വെല്ലുവിളി

നിങ്ങൾ ഇപ്പോൾ അസ്സൈൻമെന്റിൽ self-refine സാങ്കേതിക വിദ്യ ഉപയോഗിച്ചു. നിങ്ങൾ നിർമ്മിച്ച ഏതെങ്കിലും പ്രോഗ്രാമും എടുത്ത് അതിൽ നിങ്ങൾക്ക് ഏത് മെച്ചപ്പെടുത്തലുകൾ ആഗ്രഹിക്കുന്നു എന്നത് പരിഗണിക്കുക. ഇപ്പോൾ self-refine സാങ്കേതിക വിദ്യ ഉപയോഗിച്ച് നിർദ്ദേശിച്ച മാറ്റങ്ങൾ നടപ്പിലാക്കുക. ഫലം നിങ്ങൾക്ക് പാകം തോന്നിയോ, മെച്ചപ്പെട്ടു ഇരിക്കുമോ?

വളരെ നല്ല ജോലി! നിങ്ങളുടെ പഠനം തുടരാൻ

ഈ പാഠം പൂർത്തിയാക്കിയതിന് ശേഷം, നമ്മുടെ Generative AI Learning collection പരിശോധിച്ച് Generative AI അറിവ് വർദ്ധിപ്പിക്കുക!

Lesson 6-ലേക്ക് പോകൂ, അപ്പോൾ നാം Prompt Engineering ന്റെ അറിവ് ഉപയോഗിച്ച് text generation apps നിർമ്മിക്കുന്നു

അറിയിപ്പ്: ഈ രേഖ AI പരിഭാഷാ സേവനം Co-op Translator ഉപയോഗിച്ച് പരിഭാഷപ്പെടുത്തിയതാണ്. ഞങ്ങൾ കൃത്യതയ്ക്കായി ശ്രമിക്കുന്നുവെങ്കിലും, ഓട്ടോമേറ്റഡ് പരിഭാഷകളിൽ പിഴവുകൾ അല്ലെങ്കിൽ തെറ്റായ വിവരങ്ങൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്. അതിന്റെ സ്വാഭാവിക ഭാഷയിലുള്ള അസൽ രേഖയാണ് പ്രാമാണികമായ ഉറവിടമായി പരിഗണിക്കേണ്ടത്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ പരിഭാഷ ശുപാർശ ചെയ്യുന്നു. ഈ പരിഭാഷ ഉപയോഗിച്ച് ഉണ്ടാകുന്ന തെറ്റിദ്ധാരണകൾ അല്ലെങ്കിൽ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കായി ഞങ്ങൾ ഉത്തരവാദികളല്ല.

Navigation Menu

Uh oh!

സങ്കീർണ പ്രാമ്പ് സൃഷ്ടിക്കൽ

പരിചയം

പഠന ലക്ഷ്യങ്ങൾ

പ്രാമ്പ് എഞ്ചിനീയറിംഗ്

ഒരു പ്രാമ്പിന്റെ ഉദാഹരണം

ലളിതമായ പ്രാമ്പിങ്ങിന്റെ പരിമിതികൾ

പ്രാമ്പിങ്ങിനുള്ള സാങ്കേതിക പടികൾ

സീറോ-ഷോട്ട് പ്രാമ്പിംഗ്

ഫ്യൂ-ഷോട്ട് പ്രാമ്പിംഗ്

ചൈനോഫ്-തോട്ട്സ്

ജനറേറ്റഡ് നോളേജ്

Least-to-most

സ്വയം-പരിഷ്കരണം, പ്രതികരണങ്ങൾ വിമർശിക്കുക

മൈയേറ്റിക് പ്രാമ്പിംഗ്

നിങ്ങളുടെ ഔട്ട്പുട്ട് വ്യത്യസ്തമാക്കുക

നല്ല പ്രയോഗങ്ങൾ

അസ്സൈൻമെന്റ്

പരിഹാരം

അറിവ് പരിശോധന

🚀 വെല്ലുവിളി

വളരെ നല്ല ജോലി! നിങ്ങളുടെ പഠനം തുടരാൻ

Uh oh!

FilesExpand file tree

README.md

Latest commit

History

README.md

File metadata and controls

സങ്കീർണ പ്രാമ്പ് സൃഷ്ടിക്കൽ

പരിചയം

പഠന ലക്ഷ്യങ്ങൾ

പ്രാമ്പ് എഞ്ചിനീയറിംഗ്

ഒരു പ്രാമ്പിന്റെ ഉദാഹരണം

ലളിതമായ പ്രാമ്പിങ്ങിന്റെ പരിമിതികൾ

പ്രാമ്പിങ്ങിനുള്ള സാങ്കേതിക പടികൾ

സീറോ-ഷോട്ട് പ്രാമ്പിംഗ്

ഫ്യൂ-ഷോട്ട് പ്രാമ്പിംഗ്

ചൈനോഫ്-തോട്ട്സ്

ജനറേറ്റഡ് നോളേജ്

Least-to-most

സ്വയം-പരിഷ്കരണം, പ്രതികരണങ്ങൾ വിമർശിക്കുക

മൈയേറ്റിക് പ്രാമ്പിംഗ്

നിങ്ങളുടെ ഔട്ട്പുട്ട് വ്യത്യസ്തമാക്കുക

നല്ല പ്രയോഗങ്ങൾ

അസ്സൈൻമെന്റ്

പരിഹാരം

അറിവ് പരിശോധന

🚀 വെല്ലുവിളി

വളരെ നല്ല ജോലി! നിങ്ങളുടെ പഠനം തുടരാൻ