ഉള്ളടക്ക പട്ടിക[മറയ്ക്കുക][കാണിക്കുക]
കമ്മ്യൂണിക്കേഷൻ മേഖലയിൽ ടെക്സ്റ്റിനും ദൃശ്യങ്ങൾക്കും അനുകൂലമായി വോയ്സ് കോളുകൾ ഘട്ടംഘട്ടമായി നിർത്തലാക്കുന്നു. ഒരു ഫേസ്ബുക്ക് വോട്ടെടുപ്പ് അനുസരിച്ച്, വാങ്ങുന്നവരിൽ പകുതിയിലധികം പേരും തങ്ങൾക്ക് സംസാരിക്കാൻ കഴിയുന്ന ഒരു കമ്പനിയിൽ നിന്ന് വാങ്ങാൻ താൽപ്പര്യപ്പെടുന്നു. സാമൂഹികമായി സ്വീകാര്യമായ ആശയവിനിമയ രീതിയായി ചാറ്റിംഗ് മാറിയിരിക്കുന്നു.
ഏത് സമയത്തും ഏത് സ്ഥലത്തുനിന്നും അവരുടെ ക്ലയന്റുകളുമായി ആശയവിനിമയം നടത്താൻ ഇത് ബിസിനസ്സുകളെ പ്രാപ്തമാക്കുന്നു. ചാറ്റ്ബോട്ടുകളുടെ ഉപയോഗ എളുപ്പവും കുറഞ്ഞ കാത്തിരിപ്പ് സമയവും കാരണം കമ്പനികൾക്കും ഉപഭോക്താക്കൾക്കുമിടയിൽ കൂടുതൽ പ്രചാരം നേടുന്നു.
ചാറ്റ്ബോട്ടുകൾ, അല്ലെങ്കിൽ ഓട്ടോമേറ്റഡ് സംഭാഷണ പ്രോഗ്രാമുകൾ, ഒരു ടെക്സ്റ്റ് അധിഷ്ഠിത ഇന്റർഫേസിലൂടെ സേവനങ്ങൾ ആക്സസ് ചെയ്യുന്നതിന് ക്ലയന്റുകൾക്ക് കൂടുതൽ ഇഷ്ടാനുസൃതമാക്കിയ രീതി നൽകുന്നു. ഏറ്റവും പുതിയ AI-പവർ ചാറ്റ്ബോട്ടുകൾക്ക് ഒരു പ്രത്യേക പരിതസ്ഥിതിയിൽ ഒരു വ്യക്തി (അല്ലെങ്കിൽ മറ്റൊരു ബോട്ട്, തുടക്കം) നടത്തിയ ഒരു ചോദ്യം (ചോദ്യം, കമാൻഡ്, ഓർഡർ മുതലായവ) തിരിച്ചറിയാനും ഉചിതമായ രീതിയിൽ പ്രതികരിക്കാനും കഴിയും (ഉത്തരം, പ്രവർത്തനം മുതലായവ).
ഈ പോസ്റ്റിൽ, ചാറ്റ്ബോട്ടുകൾ എന്തൊക്കെയാണ്, അവയുടെ പ്രയോജനങ്ങൾ, ഉപയോഗ കേസുകൾ, നിങ്ങളുടേത് എങ്ങനെ നിർമ്മിക്കാം എന്നിവയെക്കുറിച്ച് ഞങ്ങൾ പരിശോധിക്കും. ആഴത്തിലുള്ള പഠനം മറ്റ് കാര്യങ്ങൾക്കൊപ്പം പൈത്തണിലെ ചാറ്റ്ബോട്ട്.
നമുക്ക് തുടങ്ങാം.
അപ്പോൾ, എന്താണ് ചാറ്റ്ബോട്ടുകൾ?
മനുഷ്യ-യന്ത്ര ഇടപെടലിന്റെ ഏറ്റവും വികസിതവും വാഗ്ദാനപ്രദവുമായ ഒരു രൂപമായി ചാറ്റ്ബോട്ട് പലപ്പോഴും പരാമർശിക്കപ്പെടുന്നു. ആളുകളും സേവനങ്ങളും തമ്മിലുള്ള ആശയവിനിമയം കാര്യക്ഷമമാക്കുന്നതിലൂടെ ഈ ഡിജിറ്റൽ അസിസ്റ്റന്റുകൾ ഉപഭോക്തൃ അനുഭവം മെച്ചപ്പെടുത്തുന്നു.
അതേ സമയം, കാര്യക്ഷമതയ്ക്കായി ഉപഭോക്തൃ കോൺടാക്റ്റ് പ്രക്രിയ ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിന് അവർ ബിസിനസുകൾക്ക് പുതിയ ഓപ്ഷനുകൾ നൽകുന്നു, ഇത് പരമ്പരാഗത പിന്തുണാ ചെലവുകൾ കുറയ്ക്കും.
ചുരുക്കത്തിൽ, മനുഷ്യരുമായി അവരുടെ സ്വാഭാവിക ഭാഷകളിൽ ആശയവിനിമയം നടത്താൻ ഉദ്ദേശിച്ചുള്ള AI- അധിഷ്ഠിത സോഫ്റ്റ്വെയറാണിത്. ഈ ചാറ്റ്ബോട്ടുകൾ പലപ്പോഴും ഓഡിയോ അല്ലെങ്കിൽ രേഖാമൂലമുള്ള സാങ്കേതിക വിദ്യകൾ വഴി സംവദിക്കുന്നു, കൂടാതെ മനുഷ്യരുമായി മനുഷ്യരുമായി ബന്ധപ്പെടുന്നതിന് അവയ്ക്ക് മനുഷ്യ ഭാഷകളെ എളുപ്പത്തിൽ അനുകരിക്കാനാകും.
ചാറ്റ്ബോട്ടുകൾ ഉപയോക്താക്കളുമായുള്ള ആശയവിനിമയത്തിൽ നിന്ന് പഠിക്കുന്നു, കാലക്രമേണ കൂടുതൽ യാഥാർത്ഥ്യവും കാര്യക്ഷമവുമാകുന്നു. ചെലവ് അംഗീകരിക്കൽ, ഓൺലൈനിൽ ഉപഭോക്താക്കളുമായി ഇടപഴകൽ, ലീഡുകൾ സൃഷ്ടിക്കൽ തുടങ്ങിയ വിപുലമായ ബിസിനസ്സ് പ്രവർത്തനങ്ങൾ അവർക്ക് കൈകാര്യം ചെയ്യാൻ കഴിയും.
പൈത്തൺ ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം ആഴത്തിലുള്ള പഠന ചാറ്റ്ബോട്ട് സൃഷ്ടിക്കുന്നു
ഈ മേഖലയിൽ നിരവധി വ്യത്യസ്ത തരം ചാറ്റ്ബോട്ടുകൾ ഉണ്ട് മെഷീൻ ലേണിംഗ് കൂടാതെ AI. ചില ചാറ്റ്ബോട്ടുകൾ വെർച്വൽ അസിസ്റ്റന്റുമാരാണ്, മറ്റുള്ളവ അവരുമായി സംസാരിക്കാൻ മാത്രമുള്ളവയാണ്, മറ്റുള്ളവ ഉപഭോക്തൃ സേവന ഏജന്റുമാരാണ്.
അന്വേഷണങ്ങൾക്ക് ഉത്തരം നൽകാൻ ബിസിനസ്സുകൾ ജോലി ചെയ്യുന്ന ചിലരെ നിങ്ങൾ കണ്ടിരിക്കാം. പതിവായി അഭ്യർത്ഥിക്കുന്ന ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകാൻ ഞങ്ങൾ ഈ ട്യൂട്ടോറിയലിൽ ഒരു ചെറിയ ചാറ്റ്ബോട്ട് ഉണ്ടാക്കും.
1. പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു
ഇനിപ്പറയുന്ന പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക എന്നതാണ് ഞങ്ങളുടെ ആദ്യപടി.
2. പരിശീലന ഡാറ്റ
നമ്മുടെ ചാറ്റ്ബോട്ടിന് എന്ത് തരത്തിലുള്ള വിവരമാണ് നൽകേണ്ടതെന്ന് കണ്ടെത്താനുള്ള സമയമാണിത്. ഇതൊരു ലളിതമായ ചാറ്റ്ബോട്ട് ആയതിനാൽ ഞങ്ങൾക്ക് വലിയ ഡാറ്റാസെറ്റുകളൊന്നും ഡൗൺലോഡ് ചെയ്യേണ്ടതില്ല.
ഞങ്ങൾ സ്വയം സൃഷ്ടിച്ച വിവരങ്ങൾ മാത്രമേ ഞങ്ങൾ ഉപയോഗിക്കൂ. പാഠത്തോടൊപ്പം ഫലപ്രദമായി പിന്തുടരുന്നതിന്, താഴെ കാണുന്ന അതേ ഫോർമാറ്റിലുള്ള ഒരു .JSON ഫയൽ നിങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്. എന്റെ ഫയലിന്റെ പേര് "intents.json" എന്നാണ്.
പ്രസക്തമായ ഉത്തരങ്ങളുടെ ഒരു കൂട്ടം ഇൻപുട്ട് ചെയ്യാനും മാപ്പ് ചെയ്യാനും സാധ്യതയുള്ള ഒരു കൂട്ടം സന്ദേശങ്ങൾ സൃഷ്ടിക്കാൻ JSON ഫയൽ ഉപയോഗിക്കുന്നു. ഫയലിലെ ഓരോ നിഘണ്ടുവിലും ഓരോ സന്ദേശവും ഏത് ഗ്രൂപ്പിൽ പെട്ടതാണെന്ന് തിരിച്ചറിയുന്ന ഒരു ടാഗ് ഉണ്ട്.
ഒരു പരിശീലിപ്പിക്കാൻ ഞങ്ങൾ ഈ വിവരങ്ങൾ ഉപയോഗിക്കും ന്യൂറൽ നെറ്റ്വർക്ക് ഞങ്ങളുടെ ഫയലിലെ ടാഗുകളിൽ ഒന്നായി വാക്കുകളുടെ ഒരു വാക്യം വർഗ്ഗീകരിക്കാൻ.
അപ്പോൾ നമുക്ക് ആ ഗ്രൂപ്പുകളിൽ നിന്ന് ഒരു പ്രതികരണം എടുത്ത് അത് ഉപയോക്താവിന് നൽകാം. അധിക ടാഗുകൾ, മറുപടികൾ, പാറ്റേണുകൾ എന്നിവയ്ക്കൊപ്പം ചാറ്റ്ബോട്ട് ഓഫർ ചെയ്യുകയാണെങ്കിൽ അത് കൂടുതൽ മികച്ചതും സങ്കീർണ്ണവുമാകും.
3. JSON ഡാറ്റ ലോഡിംഗ്
ഞങ്ങളുടെ .json ഡാറ്റ ലോഡുചെയ്ത് ചില മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്ത് ഞങ്ങൾ ആരംഭിക്കും. നിങ്ങളുടെ അതേ ഡയറക്ടറിയിൽ your.json ഫയൽ കൂട്ടിച്ചേർക്കുക പൈത്തൺ സ്ക്രിപ്റ്റ്. ഞങ്ങളുടെ .json ഡാറ്റ ഇപ്പോൾ ഡാറ്റ വേരിയബിളിൽ സംരക്ഷിക്കപ്പെടും.
4. ഡാറ്റ എക്സ്ട്രാക്ഷൻ
ഞങ്ങളുടെ JSON ഫയലിൽ നിന്ന് ആവശ്യമായ വിവരങ്ങൾ എക്സ്ട്രാക്റ്റുചെയ്യാനുള്ള സമയമാണിത്. എല്ലാ പാറ്റേണുകളും അവ ഉൾപ്പെടുന്ന ക്ലാസ്/ടാഗും ആവശ്യമാണ്.
ഞങ്ങളുടെ പാറ്റേണുകളിലെ എല്ലാ അദ്വിതീയ പദങ്ങളുടെയും ഒരു ലിസ്റ്റ് ആവശ്യമാണ് (കാരണങ്ങളാൽ ഞങ്ങൾ പിന്നീട് വിശദീകരിക്കും), അതിനാൽ ഈ മൂല്യങ്ങളുടെ ട്രാക്ക് സൂക്ഷിക്കാൻ നമുക്ക് കുറച്ച് ശൂന്യമായ ലിസ്റ്റുകൾ സൃഷ്ടിക്കാം.
ഇപ്പോൾ ഞങ്ങൾ ഞങ്ങളുടെ JSON ഡാറ്റയിലൂടെ ലൂപ്പ് ചെയ്യുകയും ഞങ്ങൾക്ക് ആവശ്യമായ വിവരങ്ങൾ വീണ്ടെടുക്കുകയും ചെയ്യും. അവ സ്ട്രിംഗുകളായി ഉപയോഗിക്കുന്നതിനുപകരം, ഓരോ പാറ്റേണും വാക്കുകളുടെ ഒരു ലിസ്റ്റാക്കി മാറ്റാൻ ഞങ്ങൾ nltk.word ടോക്കനൈസർ ഉപയോഗിക്കും.
തുടർന്ന്, ഞങ്ങളുടെ docs_x ലിസ്റ്റിൽ, ഞങ്ങൾ ഓരോ പാറ്റേണും അതിൻറെ അനുബന്ധ ടാഗിനൊപ്പം docs_y ലിസ്റ്റിലേക്ക് ചേർക്കും.
5. വേഡ് സ്റ്റെമ്മിംഗ്
ഒരു വാക്കിന്റെ റൂട്ട് കണ്ടെത്തുന്നത് സ്റ്റെമ്മിംഗ് എന്നറിയപ്പെടുന്നു. ഉദാഹരണത്തിന്, "അത്" എന്ന വാക്കിന്റെ തണ്ട് "അത്" ആയിരിക്കാം, അതേസമയം "സംഭവിക്കുന്നത്" എന്ന വാക്കിന്റെ തണ്ട് "സംഭവിക്കുക" ആകാം.
ഞങ്ങളുടെ മോഡലിന്റെ പദാവലി ട്രിം ചെയ്യാനും വാക്യങ്ങൾ പൊതുവായി എന്താണ് സൂചിപ്പിക്കുന്നതെന്ന് മനസിലാക്കാനും ഞങ്ങൾ ഈ സ്റ്റെമ്മിംഗ് ടെക്നിക് ഉപയോഗിക്കും. ഈ കോഡ് ഞങ്ങളുടെ ഡാറ്റ തയ്യാറാക്കലിന്റെ അടുത്ത ഘട്ടത്തിൽ ഉപയോഗിക്കപ്പെടുന്ന പദങ്ങളുടെ ഒരു അദ്വിതീയ ലിസ്റ്റ് സൃഷ്ടിക്കും.
6. വാക്കുകളുടെ ബാഗ്
ഞങ്ങൾ ഞങ്ങളുടെ ഡാറ്റ ഇറക്കുമതി ചെയ്യുകയും ഒരു പദാവലി സൃഷ്ടിക്കുകയും ചെയ്തതിനാൽ വാക്കുകളുടെ ഒരു ബാഗിനെക്കുറിച്ച് സംസാരിക്കേണ്ട സമയമാണിത്. ന്യൂറൽ നെറ്റ്വർക്കുകൾ കൂടാതെ മെഷീൻ ലേണിംഗ് അൽഗോരിതങ്ങൾക്ക്, നമുക്കെല്ലാവർക്കും അറിയാവുന്നതുപോലെ, സംഖ്യാപരമായ ഇൻപുട്ട് ആവശ്യമാണ്. അതിനാൽ ഞങ്ങളുടെ സ്ട്രിംഗ് ലിസ്റ്റ് അത് മുറിക്കാൻ പോകുന്നില്ല. നമ്മുടെ വാക്യങ്ങളിൽ അക്കങ്ങളെ പ്രതിനിധീകരിക്കാൻ ഒരു സംവിധാനം ആവശ്യമാണ്, അവിടെയാണ് വാക്കുകളുടെ ഒരു ബാഗ് വരുന്നത്.
ഓരോ വാക്യവും ഞങ്ങളുടെ മോഡലിന്റെ പദാവലിയിലെ പദങ്ങളുടെ ദൈർഘ്യത്തിന്റെ ഒരു ലിസ്റ്റ് പ്രതിനിധീകരിക്കും. ഞങ്ങളുടെ പദാവലിയിലെ ഓരോ വാക്കും പട്ടികയിലെ ഒരു സ്ഥലം പ്രതിനിധീകരിക്കും. പട്ടികയിലെ സ്ഥാനം 1 ആണെങ്കിൽ, ഈ വാക്ക് ഞങ്ങളുടെ പ്രസ്താവനയിൽ ദൃശ്യമാകും; അത് 0 ആണെങ്കിൽ, ഈ വാക്ക് നമ്മുടെ വാക്യത്തിൽ ദൃശ്യമാകില്ല.
പദസഞ്ചിയിൽ പദങ്ങൾ പ്രത്യക്ഷപ്പെടുന്ന ക്രമം അറിയാത്തതിനാൽ ഞങ്ങൾ അതിനെ വാക്കുകളുടെ ഒരു ബാഗ് എന്ന് വിളിക്കുന്നു; ഞങ്ങളുടെ മോഡലിന്റെ പദാവലിയിൽ അവ നിലവിലുണ്ടെന്ന് മാത്രം.
നമ്മുടെ ഇൻപുട്ട് സ്ട്രക്ചർ ചെയ്യുന്നതിനൊപ്പം, ന്യൂറൽ നെറ്റ്വർക്ക് അത് മനസ്സിലാക്കുന്ന തരത്തിൽ ഔട്ട്പുട്ട് ഫോർമാറ്റ് ചെയ്യുകയും വേണം. വാക്കുകളുടെ ഒരു ബാഗിന് സമാനമായി, ഞങ്ങളുടെ ഡാറ്റാസെറ്റിലെ ലേബലുകളുടെ/ടാഗുകളുടെ എണ്ണത്തിന്റെ ദൈർഘ്യമുള്ള ഔട്ട്പുട്ട് ലിസ്റ്റുകൾ ഞങ്ങൾ നിർമ്മിക്കും. ലിസ്റ്റിലെ ഓരോ സ്ഥലവും ഒരു അദ്വിതീയ ലേബൽ/ടാഗ് പ്രതിനിധീകരിക്കുന്നു, കൂടാതെ ആ ലൊക്കേഷനുകളിലേതെങ്കിലും 1 എന്നത് ഏത് ലേബൽ/ടാഗിനെയാണ് പ്രതിനിധീകരിക്കുന്നതെന്ന് സൂചിപ്പിക്കുന്നു.
അവസാനമായി, ഞങ്ങളുടെ പരിശീലന ഡാറ്റയും ഔട്ട്പുട്ടും സംഭരിക്കുന്നതിന് ഞങ്ങൾ NumPy അറേകൾ ഉപയോഗിക്കും.
7. മാതൃകാ വികസനം
ഞങ്ങളുടെ എല്ലാ ഡാറ്റയും മുൻകൂട്ടി പ്രോസസ്സ് ചെയ്തതിനാൽ ഒരു മോഡൽ നിർമ്മിക്കാനും പരിശീലിപ്പിക്കാനും ഞങ്ങൾ തയ്യാറാണ്. ഞങ്ങളുടെ ലക്ഷ്യങ്ങൾക്കായി രണ്ട് മറഞ്ഞിരിക്കുന്ന പാളികളുള്ള വളരെ അടിസ്ഥാനപരമായ ഫീഡ് ഫോർവേഡ് ന്യൂറൽ നെറ്റ്വർക്ക് ഞങ്ങൾ ഉപയോഗിക്കും.
ഞങ്ങളുടെ നെറ്റ്വർക്കിന്റെ ഉദ്ദേശ്യം വാക്കുകളുടെ ഒരു ശേഖരം നോക്കി അവയെ ഒരു ക്ലാസിലേക്ക് അസൈൻ ചെയ്യുക (JSON ഫയലിൽ നിന്നുള്ള ഞങ്ങളുടെ ടാഗുകളിൽ ഒന്ന്). ഞങ്ങളുടെ മോഡലിന്റെ വാസ്തുവിദ്യ സ്ഥാപിച്ചുകൊണ്ട് ഞങ്ങൾ ആരംഭിക്കും. ഒരു മികച്ച മോഡൽ കൊണ്ടുവരാൻ നിങ്ങൾക്ക് ചില നമ്പറുകൾ ഉപയോഗിച്ച് കളിക്കാനാകുമെന്ന് ഓർമ്മിക്കുക! യന്ത്ര പഠനം കൂടുതലും ട്രയലും പിശകും അടിസ്ഥാനമാക്കിയുള്ളതാണ്.
8. മോഡൽ ട്രെയിനിംഗ് & സേവിംഗ്
ഞങ്ങൾ അത് സജ്ജീകരിച്ചതിനാൽ, ഞങ്ങളുടെ ഡാറ്റയിൽ ഞങ്ങളുടെ മോഡലിനെ പരിശീലിപ്പിക്കാനുള്ള സമയമാണിത്! ഞങ്ങളുടെ ഡാറ്റ മോഡലിൽ ഘടിപ്പിച്ചുകൊണ്ട് ഞങ്ങൾ ഇത് നേടും. പരിശീലന വേളയിൽ ഒരേ ഡാറ്റയിലേക്ക് മോഡൽ എത്ര തവണ തുറന്നുകാട്ടപ്പെടും എന്നതാണ് ഞങ്ങൾ നൽകുന്ന യുഗങ്ങളുടെ എണ്ണം.
പരിശീലനം പൂർത്തിയാക്കിക്കഴിഞ്ഞാൽ നമുക്ക് മോഡൽ ഫയൽ മോഡലിലേക്ക് സംരക്ഷിക്കാൻ കഴിയും. മറ്റ് സ്ക്രിപ്റ്റുകളിൽ ഉപയോഗിക്കാവുന്ന ഒരു സ്ക്രിപ്റ്റാണ് tflearn.
9. ഒരു ചാറ്റ്ബോട്ട് ഉപയോഗിക്കുന്നത്
ഇപ്പോൾ നിങ്ങൾക്ക് നിങ്ങളുടെ ബോട്ടുമായി ചാറ്റ് ചെയ്യാൻ തുടങ്ങാം.
ചാറ്റ്ബോട്ടിന്റെ പ്രയോജനങ്ങൾ
- ബോട്ടുകൾ വർഷത്തിൽ 365 ദിവസവും, 24 മണിക്കൂറും, ശമ്പളമില്ലാതെ പ്രവർത്തിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നതിനാൽ, ലഭ്യതയും പ്രതികരണ വേഗതയും വർദ്ധിപ്പിക്കുന്നു.
- ഈ ബോട്ടുകൾ വലിയ ഡാറ്റയുടെ മൂന്ന് കീ Vs കൈകാര്യം ചെയ്യുന്നതിനുള്ള മികച്ച ഉപകരണങ്ങളാണ്: വോളിയം, വേഗത, വൈവിധ്യം.
- ഒരു കമ്പനിയുടെ ഉപഭോക്താക്കളെ കുറിച്ച് പഠിക്കാനും മനസ്സിലാക്കാനും ഉപയോഗിക്കാവുന്ന സോഫ്റ്റ്വെയറാണ് ചാറ്റ്ബോട്ടുകൾ.
- മികച്ച ആനുകൂല്യങ്ങൾ ലഭിച്ചതിന് ശേഷം വിലകുറഞ്ഞ പരിപാലനച്ചെലവ് ഇതിന് ഉയർന്ന ശക്തിയുണ്ട്.
- ചാറ്റ്ബോട്ട് ആപ്ലിക്കേഷനുകൾ, അനലിറ്റിക്സിനും പ്രവചനങ്ങൾക്കുമായി സംരക്ഷിച്ച് ഉപയോഗിക്കാവുന്ന ഡാറ്റ സൃഷ്ടിക്കുന്നു.
കേസ്
- ഉപഭോക്തൃ ചോദ്യങ്ങൾ പരിഹരിക്കുന്നു
- പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുന്നു
- പിന്തുണാ ടീമിലേക്ക് ഉപഭോക്താക്കളെ നിയോഗിക്കുന്നു
- ഉപഭോക്തൃ ഫീഡ്ബാക്ക് ശേഖരിക്കുന്നു
- പുതിയ ഓഫറുകൾ ശുപാർശ ചെയ്യുന്നു
- സംഭാഷണ വാണിജ്യം ഉപയോഗിച്ച് ഷോപ്പുചെയ്യുക
- ഐടി ഹെൽപ്പ്ഡെസ്ക്
- താമസ സൗകര്യങ്ങൾ ബുക്കിംഗ്
- പണം കൈമാറ്റം
തീരുമാനം
മറ്റ് AI സാങ്കേതികവിദ്യകളെപ്പോലെ ചാറ്റ്ബോട്ടുകളും, മനുഷ്യരുടെ കഴിവുകൾ വർധിപ്പിക്കുന്നതിനും, തന്ത്രപരമായ ജോലികളേക്കാൾ കൂടുതൽ സമയം ചെലവഴിക്കാൻ അനുവദിക്കുന്നതിലൂടെ കൂടുതൽ സർഗ്ഗാത്മകവും ഭാവനാസമ്പന്നരുമായി മനുഷ്യരെ സ്വതന്ത്രരാക്കാനും ഉപയോഗിക്കും.
ബിസിനസ്സുകൾക്കും ജീവനക്കാർക്കും ഉപഭോക്താക്കൾക്കും വേഗത്തിലുള്ള ശുപാർശകളും പ്രവചനങ്ങളും പോലെയുള്ള മെച്ചപ്പെടുത്തിയ ചാറ്റ്ബോട്ട് സവിശേഷതകളിൽ നിന്ന് പ്രയോജനം നേടാൻ സാധ്യതയുണ്ട്, കൂടാതെ ഒരു സംഭാഷണത്തിനുള്ളിൽ നിന്ന് ഹൈ-ഡെഫനിഷൻ വീഡിയോ കോൺഫറൻസിംഗിലേക്കുള്ള എളുപ്പത്തിലുള്ള ആക്സസ്, സമീപഭാവിയിൽ, AI വികസനവുമായി സംയോജിപ്പിക്കുമ്പോൾ. 5G സാങ്കേതികവിദ്യ.
ഇവയും മറ്റ് സാധ്യതകളും ഇപ്പോഴും അന്വേഷിക്കുന്നുണ്ട്, എന്നാൽ ഇന്റർനെറ്റ് കണക്റ്റിവിറ്റി, AI, NLP, മെഷീൻ ലേണിംഗ് എന്നിവ പുരോഗമിക്കുമ്പോൾ, അവ കൂടുതൽ വ്യാപകമാകും.
ച്വൂ
ഹലോ,
ഈ പ്രോഗ്രാമിന് നന്ദി.
എനിക്കൊരു ചോദ്യമുണ്ട്.
“bag_of_words” നിർവചിച്ചിട്ടില്ല. എനിക്ക് ഈ തെറ്റ് മനസ്സിലാക്കാൻ കഴിയുന്നില്ല.
ഈ തെറ്റ് എങ്ങനെ പരിഹരിക്കാം എന്ന് പറയാമോ??
ഈ പ്രോഗ്രാമിന് നന്ദി!! ഒരു നല്ല ദിനം ആശംസിക്കുന്നു
ജയ്
ചാറ്റ്ബോട്ട് വിഭാഗം ഉപയോഗിക്കുന്നതിന് മുമ്പ് ദയവായി ഒരു ഫംഗ്ഷൻ ചേർക്കുക:
////////////////////////////////////////////// ////////////////////////////
def bag_of_words(കൾ, വാക്കുകൾ):
ബാഗ് = [0 for _ എന്ന പരിധിയിൽ (len(പദങ്ങൾ))]
s_words = nltk.word_tokenize(s)
s_words = [s_words-ലെ വാക്കിന് stemmer.stem(word.lower())
s_words ൽ വേണ്ടി:
for i, w in enumerate(വാക്കുകൾ):
എങ്കിൽ w == se:
ബാഗ്[i] = 1
തിരികെ numpy.array(bag)
// ഇത് തീർച്ചയായും നിങ്ങളുടെ പ്രശ്നം പരിഹരിക്കും. //
//////////////////////////////////////////////// //////////////////////////
ഞാൻ പൂർണ്ണമായ കോഡ് നിങ്ങളുമായി പങ്കിടുന്നു, അതിനാൽ നിങ്ങൾക്ക് അതിന്റെ വ്യക്തമായ ചിത്രം ലഭിക്കും.
//////////////////////////////////////////////// ////////
nltk ഇറക്കുമതി ചെയ്യുക
nltk.stem.lancaster ഇറക്കുമതി LancasterStemmer-ൽ നിന്ന്
സ്റ്റെമ്മർ = ലാൻകാസ്റ്റർ സ്റ്റെമ്മർ()
നംപി ഇറക്കുമതി ചെയ്യുക
ഇറക്കുമതി tflearn
ഇറക്കുമതി ടെൻസർഫ്ലോ
ക്രമരഹിതമായി ഇറക്കുമതി ചെയ്യുക
json ഇറക്കുമതി ചെയ്യുക
അച്ചാർ ഇറക്കുമതി ചെയ്യുക
ഫയലായി തുറന്ന (“intents.json”) ഉപയോഗിച്ച്:
ഡാറ്റ = json.load(ഫയൽ)
ശ്രമിക്കുക:
f: ആയി ഓപ്പൺ ("data.pickle", "rb")
വാക്കുകൾ, ലേബലുകൾ, പരിശീലനം, ഔട്ട്പുട്ട് = pickle.load(f)
ഒഴികെ:
വാക്കുകൾ = []
ലേബലുകൾ = []
docs_x = []
docs_y = []
ഡാറ്റയിലെ ഉദ്ദേശ്യത്തിനായി [“ഉദ്ദേശ്യങ്ങൾ”]:
പാറ്റേണിന്റെ ഉദ്ദേശ്യത്തിനായി [“പാറ്റേണുകൾ”]:
wrds = nltk.word_tokenize(പാറ്റേൺ)
words.extend(wrds)
docs_x.append(wrds)
docs_y.append(ഉദ്ദേശ്യം[“ടാഗ്”])
ഉദ്ദേശം [“ടാഗ്”] ലേബലുകളിൽ ഇല്ലെങ്കിൽ:
labels.append(ഉദ്ദേശ്യം[“ടാഗ്”])
വാക്കുകൾ = [stemmer.stem(w.lower()) for w എന്നതിന് വാക്കിൽ w != “?”]
വാക്കുകൾ = അടുക്കിയത് (ലിസ്റ്റ് (സെറ്റ് (പദങ്ങൾ)))
ലേബലുകൾ = അടുക്കിയത് (ലേബലുകൾ)
പരിശീലനം = []
ഔട്ട്പുട്ട് = []
out_empty = [0 for _ in range(len(ലേബലുകൾ))]
x-ന്, ഡോക് ഇൻ എനുമറേറ്റ്(docs_x):
ബാഗ് = []
wrds = [stemmer.stem(w.lower()) for w in doc]
വാക്കുകളിൽ w എന്നതിന്:
wrds ൽ w എങ്കിൽ:
bag.append(1)
വേറെ:
bag.append(0)
output_row = out_empty[:]
output_row[labels.index(docs_y[x])] = 1
training.append(bag)
output.append(output_row)
പരിശീലനം = numpy.array(പരിശീലനം)
ഔട്ട്പുട്ട് = numpy.array(ഔട്ട്പുട്ട്)
f: ആയി ഓപ്പൺ (“data.pickle”, “wb”)
pickle.dump((വാക്കുകൾ, ലേബലുകൾ, പരിശീലനം, ഔട്ട്പുട്ട്), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(ആകാരം=[ഒന്നുമില്ല, ലെൻ(പരിശീലനം[0])])
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, len (ഔട്ട്പുട്ട്[0]), ആക്ടിവേഷൻ=”softmax”)
നെറ്റ് = tflearn.regression(net)
മോഡൽ = tflearn.DNN(net)
ശ്രമിക്കുക:
model.load("model.tflearn")
ഒഴികെ:
model.fit(പരിശീലനം, ഔട്ട്പുട്ട്, n_epoch=1500, batch_size=8, show_metric=True)
model.save (“model.tflearn”)
def bag_of_words(കൾ, വാക്കുകൾ):
ബാഗ് = [0 for _ എന്ന പരിധിയിൽ (len(പദങ്ങൾ))]
s_words = nltk.word_tokenize(s)
s_words = [s_words-ലെ വാക്കിന് stemmer.stem(word.lower())
s_words ൽ വേണ്ടി:
for i, w in enumerate(വാക്കുകൾ):
എങ്കിൽ w == se:
ബാഗ്[i] = 1
തിരികെ numpy.array(bag)
ഡെഫ് ചാറ്റ്():
പ്രിന്റ് (“ബോട്ടുമായി സംസാരിക്കാൻ തുടങ്ങുക (നിർത്താൻ ക്വിറ്റ് എന്ന് ടൈപ്പ് ചെയ്യുക)!”)
ശരി:
inp = ഇൻപുട്ട് ("നിങ്ങൾ:")
inp.lower() == "പുറത്തിറങ്ങുക" ആണെങ്കിൽ:
ഇടവേള
ഫലങ്ങൾ = model.predict([bag_of_words(inp, words)])
results_index = numpy.argmax(ഫലങ്ങൾ)
ടാഗ് = ലേബലുകൾ[results_index]
ഡാറ്റയിലെ tg-യ്ക്ക് [“ഉദ്ദേശ്യങ്ങൾ”]:
എങ്കിൽ tg['tag'] == ടാഗ്:
പ്രതികരണങ്ങൾ = tg['പ്രതികരണങ്ങൾ']
പ്രിന്റ് (random.choice(പ്രതികരണങ്ങൾ))
ചാറ്റ്()
////////////////////////////////////////////// //////////////
നന്ദി,
സന്തോഷകരമായ കോഡിംഗ്!
Lu
ഹലോ,
പൈത്തണിൽ ഒരു ചാറ്റ്ബോട്ട് സൃഷ്ടിക്കാൻ ആഗ്രഹിക്കുന്ന സാഹചര്യത്തിൽ നടപ്പിലാക്കേണ്ട പ്രക്രിയയെക്കുറിച്ച് നിങ്ങൾക്ക് ഒരു ആശയം നൽകാമോ, എന്നാൽ എക്സലിലെ ഒരു സർവേയിൽ നിന്നാണ് വിവരങ്ങൾ ലഭിച്ചത്. നന്ദി!