സെർച്ച് ആപ്ലിക്കേഷനുകൾക്കുള്ള പാഠത്തിൽ, നിങ്ങളുടെ സ്വന്തം ഡാറ്റയെ വലിയ ഭാഷാ മോഡലുകളിലേക്ക് (LLMs) എങ്ങനെ സംയോജിപ്പിക്കാമെന്ന് ഞങ്ങൾ ചുരുക്കി പഠിച്ചു. ഈ പാഠത്തിൽ, നിങ്ങളുടെ ഡാറ്റയെ നിങ്ങളുടെ LLM ആപ്ലിക്കേഷനിൽ ഭൂതടിപ്പിക്കുന്നതിന്റെ ആശയങ്ങൾ, പ്രക്രിയയുടെ യന്ത്രശാസ്ത്രം, എൻബെഡിംഗുകളും വാചകവും ഉൾപ്പെടെ ഡാറ്റ സംഭരിക്കുന്ന രീതികൾ എന്നിവയെക്കുറിച്ച് കൂടുതൽ വിശദമായി പഠിക്കാം.
വീഡിയോ ഉടൻ വരുന്നു
ഈ പാഠത്തിൽ ഞങ്ങൾ രണ്ടു കാര്യങ്ങൾ കവറുചെയ്യും:
-
RAG എന്താണെന്നും എഐ (ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസ്)യിൽ അത് എന്തു വേണ്ടി ഉപയോഗിക്കുന്നുവെന്നും പരിചയം.
-
വക്ടർ ഡാറ്റാബേസുകൾ എന്താണെന്ന് മനസ്സിലാക്കൽ, അതിനെ ആപ്ലിക്കേഷനായി സൃഷ്ടിക്കൽ.
-
RAG ഒരു ആപ്ലിക്കേഷനിൽ എങ്ങനെ സംയോജിപ്പിക്കുന്നുവെന്ന് പ്രായോഗിക ഉദാഹരണം.
ഈ പാഠം പൂർത്തിയാക്കിയതിന് ശേഷം, നിങ്ങൾക്ക് കഴിയുന്നതെന്തെന്നാൽ:
-
ഡാറ്റ റിട്രീവലിലും പ്രോസസ്സിംഗിലും RAG ന്റെ പ്രാധാന്യം വിശദീകരിക്കുക.
-
RAG ആപ്ലിക്കേഷൻ സജ്ജമാക്കുക, നിങ്ങളുടെ ഡാറ്റയെ LLM-ലേക്ക് ഭൂതടിപ്പിക്കുക.
-
LLM ആപ്ലിക്കേഷനുകളിൽ RAG-ഉം വക്ടർ ഡാറ്റാബേസുകളും എഫക്ടീവായി സംയോജിപ്പിക്കുക.
ഈ പാഠത്തിനായി, ചാറ്റ്ബോട്ടിന് വിവിധ വിഷയങ്ങളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ നേടാൻ നമ്മുടെ സ്വന്തം കുറിപ്പുകൾ വിദ്യാഭ്യാസ സ്റ്റാർട്ടപ്പിൽ ചേർക്കാൻ ആഗ്രഹിക്കുന്നു. ഞങ്ങൾക്കുള്ള കുറിപ്പുകൾ ഉപയോഗിച്ച് പഠനാർത്ഥികൾ മികച്ച വിധം പഠിക്കാനും വിഷയങ്ങളെ മനസ്സിലാക്കാനും കഴിയുന്നതാകും, ഇത് അവരുടെ പരീക്ഷകൾക്കായി പുനഃപരിശോധന എളുപ്പമാക്കും. ഞങ്ങൾ ഈ സാഹചര്യത്തിന് ഉപയോഗിക്കുന്നവ:
-
Azure OpenAI:ഞങ്ങൾ ചാറ്റ്ബോട്ട് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന LLM -
AI for beginners' lesson on Neural Networks: നമ്മുടെ LLM ഭൂതടിപ്പിക്കുന്ന ഡാറ്റ -
Azure AI SearchandAzure Cosmos DB:നമ്മുടെ ഡാറ്റ സംഭരിക്കാൻ വക്ടർ ഡാറ്റാബേസ്, സെർച്ച് ഇൻഡെക്സ് സൃഷ്ടിക്കാൻ
ഉപഭോക്താക്കൾക്ക് കുറിപ്പുകളിൽ നിന്നുള്ള പ്രാക്ടീസ് ക്വിസുകൾ സൃഷ്ടിക്കാനും, റിവിഷൻ ഫ്ലാഷ് കാർഡുകൾ തയ്യാറാക്കാനുമായും എണ്ണിപ്പടിപ്പിച്ച് സംഗ്രഹങ്ങൾ ഉണ്ടാക്കാനുമാകും. തുടങ്ങാൻ, RAG എന്താണെന്നും അത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും നോക്കാം:
LLM അടിസ്ഥാനമാക്കിയുള്ള ചാറ്റ്ബോട്ട് ഉപയോക്തൃ പ്രാമ്പ്റ്റുകൾ പ്രോസസ്സ് ചെയ്ത് പ്രത്തിനിധാനങ്ങൾ സൃഷ്ടിക്കുന്നു. ഇതു ഇന്റരാക്ടീവ് ആകാനുള്ള വിധത്തിലായാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്, കൂടാതെ ഉപയോക്താക്കളുമായി വ്യാപക വിഷയങ്ങളിൽ ഇടപെടുന്നു. എന്നാൽ, ഇതിന്റെ മറുപടികൾ ഉള്ളടക്കം നൽകിയ പരിധിയിലും അടിസ്ഥാന പരിശീലന ഡാറ്റയിലുമാണ് നിയന്ത്രിതം. ഉദാഹരണത്തിന്, GPT-4 ന്റെ അറിവിന്റെ കാലഹരണ തീയതി സെപ്പ്റ്റംബർ 2021 ആണ്, അർത്ഥം ഇതിനു ശേഷം നടന്ന സംഭവങ്ങളുടെ അറിവ് അതിൽ ഇല്ല. കൂടാതെ, LLM പരിശീലിപ്പിക്കാൻ ഉപയോഗിച്ച ഡാറ്റയിൽ വ്യക്തിഗത കുറിപ്പുകൾ അല്ലെങ്കിൽ കമ്പനിയുടെ ഉത്പന്ന മാനുവൽ പോലുള്ള രഹസ്യ വിവരങ്ങൾ ഉൾപ്പെടുന്നില്ല.
നിങ്ങൾ നിങ്ങളുടെ കുറിപ്പുകളിൽ നിന്ന് ക്വിസുകൾ സൃഷ്ടിക്കുന്ന ഒരു ചാറ്റ്ബോട്ട് വിനിയോഗപ്പെടുത്തണമെന്ന് ധരിക്കുക, അതിനായി ജ്ഞാന വൃത്തത്തിലെ ഡാറ്റയുമായി ബന്ധം ആവശ്യമാണ്. ഇక్కడ RAG സഹായിക്കുന്നു. RAGs താഴെ പറയുന്നതുപോലെ പ്രവർത്തിക്കുന്നു:
-
ജ്ഞാന വൃത്തം: റിട്ട്രീവലിനു മുമ്പ്, ഈ രേഖകൾ സൗകര്യപ്രദമായി ഇൻഗ്രസ്റ്റ് ചെയ്ത് പ്രോസസ്സുചെയ്യണം, സാധാരണയായി വലിയ ഡോക്യുമെന്റ് ചങ്കുകളാക്കി വിഭജിച്ച് അവയെ ടെക്സ്റ്റ് എൻബെഡിംഗുകളാക്കി മാറ്റി ഡാറ്റാബേസിൽ സംഭരിക്കുന്നു.
-
ഉപയോക്തൃ ചോദ്യങ്ങൾ: ഉപയോക്താവ് ഒരു ചോദ്യം ചോദിക്കുന്നു.
-
റിട്ട്രീവൽ: ഉപയോക്താവ് ചോദ്യം ചോദിക്കുമ്പോൾ, എൻബെഡിംഗ് മോഡൽ യോഗ്യമായ വിവരങ്ങൾ ജ്ഞാന വൃത്തത്തിൽ നിന്നെടുത്തു കൂടുതൽ സാഹചര്യമായി പ്രാമ്പ്റ്റിൽ ഉൾപ്പെടുത്തുന്നു.
-
ബൃദ്ധിഗ്രാഹണം: LLM എടുത്ത വിവരങ്ങൾ അടിസ്ഥാനമാക്കി മറുപടി മെച്ചപ്പെടുത്തുന്നു. മുൻകൂട്ടി പരിശീലിപ്പിച്ച ഡാറ്റ മാത്രമല്ല, ചേർക്കപ്പെട്ട ശേഷികേന്ദ്രം നന്ദിയുള്ള പ്രാസക്തമായ വിവരങ്ങള് അടിസ്ഥാനമാക്കി മറുപടികള് സൃഷ്ടിക്കുന്നു. പിന്നീട് LLM ഉപയോക്താവിന്റെ ചോദ്യത്തിന് മറുപടി നൽകുന്നു.
RAGs മൾക്കൂട്ടം ട്രാൻസ്ഫോമറുകൾ കൊണ്ട് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നതാണ്, രണ്ട് ഭാഗങ്ങളുള്ളത്: എൻകോഡർ, ഡീകോഡർ. ഉദാഹരണത്തിന്, ഉപയോക്താവ് ചോദ്യമൊരുക്കുമ്പോൾ, ഇൻപുട്ട് വാചകങ്ങൾ വേങ്ങ്ളതിന് അനുസരിച്ച് এনകോഡ് ചെയ്ത്, വാക്യാർത്ഥം ഉൾക്കൊള്ളുന്ന വെക്ടറുകളായി മാറ്റുന്നു, തുടർന്ന് ഈ വെക്ടറുകൾ ഡീകോഡ് ചെയ്ത് ഡാറ്റാബേസ് ഇൻഡെക്സ് തിരഞ്ഞ് ഉപയോക്തൃ ചോദ്യത്തിന് അനുയോജ്യമായ പുതിയ വാചകം സൃഷ്ടിക്കുന്നു. LLM అవേറ്റ്പുട്ട് സൃഷ്ടിക്കാൻ രണ്ട് മോഡലുകളും ഉപയോഗിക്കുന്നു.
RAG നടപ്പിലാക്കുന്നതിന് നിർദ്ദേശിച്ച പത്രപ്രമാണം Retrieval-Augmented Generation for Knowledge intensive NLP (natural language processing software) Tasks അനുസരിച്ച് രണ്ട് സമീപനങ്ങൾ ഉണ്ട്:
-
RAG-Sequence ഉപയോക്തൃ ചോദ്യത്തിന് ഏറ്റവും നല്ല മറുപടി പ്രവചിക്കാൻ ഇൻഗ്രസ്റ്റുചെയ്ത രേഖകൾ ഉപയോഗിക്കുന്നു
-
RAG-Token രേഖകൾ ഉപയോഗിച്ച് അടുത്ത ടോക്കൺ ജനറേറ്റ് ചെയ്ത് പിന്നീട് ഉപയോക്തൃ ചോദ്യത്തിന് മറുപടി കണ്ടെത്തുന്നു
-
വിവര സമൃദ്ധി: ടെക്സ്റ്റ് മറുപടികൾ നേരത്തെ പകർന്നതിലും ഇപ്പോഴത്തെ വിവരത്തിലും പുതുക്കിയതും ആയിരിക്കും. അതിലൂടെ ക്ഷേമപ്രദമായ കൗശലപരമായ വഹിപ്പിച്ച ഉദ്യോഗങ്ങളിലും മെച്ചമുണ്ടാകുകയും ചെയ്യും.
-
കൃത്യത കുറയ്ക്കുന്നു: വിവര മത്സരങ്ങളിൽ ഉപയോക്തൃ ചോദ്യത്തിന് സാങ്കേതികമായി ശരിയായ വിവരങ്ങൾ ഉപയോഗിക്കുന്നതിനാൽ തെറ്റായ കല്പനകൾ കുറയുന്നു.
-
രംഭണ ചിലവ് കുറവ്: LLM ഫൈനട്യൂണിംഗ് ചെയ്യുന്നതൊക്കെക്കാൾ എക്കണോമിക് ആണ്.
ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ വ്യക്തിഗത ഡാറ്റ ആയ Neural Network പാഠം AI For Beginners പാഠ്യപദ്ധതിയിൽ അധികാരപരമായിരിക്കുന്നു.
സാമാന്യ ഡാറ്റാബേസുകളോട് വ്യത്യസ്തമായി, വക്ടർ ഡാറ്റാബേസ് എൻബെഡുചെയ്ത വെക്ടറുകൾ സേവ്, മാനേജ്, തേടുവാൻ നിർമിക്കപ്പെട്ട പ്രത്യേക ഡാറ്റാബേസാണ്. ഇത് രേഖകളുടെ സംഖ്യാനപരമായ പ്രതിനിധാനങ്ങൾ സംരക്ഷിക്കുന്നു. ഡാറ്റയെ സംഖ്യാനപ്രതീനത്തിൽ വിഭജിക്കുന്നതുവഴി AI സിസ്റ്റം ഡാറ്റ മനസ്സിലാക്കാനും പ്രോസസ്സ് ചെയ്യാനും എളുപ്പമാണ്.
LLM ഇന്പുട്ടായി സ്വീകരിക്കുന്ന ടോക്കണുകളുടെ പരിധി ഉള്ളതിനാൽ ഞങ്ങൾ എൻബെഡിംഗുകൾ വക്ടർ ഡാറ്റാബേസുകളിൽ സംഭരിക്കുന്നു. മുഴുവൻ എൻബെഡിംഗും LLM-ൽ പാസാക്കാൻ കഴിയാത്തതിനാൽ, അവയെ ചങ്കുകളാക്കി വേണം ചേർക്കൽ. ഉപയോക്താവ് ചോദ്യം ചോദിക്കുമ്പോൾ ചോദ്യവുമായി ചേർന്ന ഏറ്റവും അനുയോജ്യമായ എൻബെഡിംഗ്സ് ചോദ്യം മുൻപിൽ നൽകും. ചങ്കിംഗ് ടോക്കണുകളുടെ എണ്ണം കുറച്ച് ചെലവുകുറയ്ക്കാനും സഹായിക്കുന്നു.
പ്രസിദ്ധമായ ചില വക്ടർ ഡാറ്റാബേസുകൾ: Azure Cosmos DB, Clarifyai, Pinecone, Chromadb, ScaNN, Qdrant, DeepLake. താഴെ നൽകിയ കമാൻഡിലൂടെ Azure CLI ഉപയോഗിച്ച് Azure Cosmos DB മോഡൽ സൃഷ്ടിക്കാം:
az login
az group create -n <resource-group-name> -l <location>
az cosmosdb create -n <cosmos-db-name> -r <resource-group-name>
az cosmosdb list-keys -n <cosmos-db-name> -g <resource-group-name>ഡാറ്റ സംഭരിക്കുന്നതിനു മുമ്പ്, അത് വെക്ടർ എൻബെഡിംഗുകളായി മാറ്റണം. വലിയ ഡോക്യുമെന്റുകൾ അല്ലെങ്കിൽ ദൈർഘ്യമേറിയ വാചകങ്ങൾ ഉണ്ടായാൽ, മുൻകൂട്ടി പ്രതീക്ഷിക്കുന്ന ചോദ്യങ്ങളിൽ അടിസ്ഥാനമാക്കി അവയെ ചങ്കുകളായി വിഭജിക്കാം. ചങ്കിംഗ് വാചക തലത്തിൽ അല്ലെങ്കിൽ പാരഗ്രാഫ് തലത്തിൽ നടത്താം. ചങ്കുകൾക്ക് ചുറ്റുമുള്ള പദങ്ങളിൽ നിന്നുള്ള അർത്ഥം കരുതിപ്പരിചയപ്പെടുന്നതുകൊണ്ട്, ചങ്കിന് മറ്റൊരു സന്ദർഭം ക്കൂടി ചേർക്കാം, ഉദാഹരണത്തിന്, ഡോക്യുമെന്റ് തലക്കെട്ടോ ചങ്കിന് മുമ്പോ ശേഷമോ ചില വാചകങ്ങൾ ഉൾപ്പെടുത്താമെന്നു.
ഡാറ്റ ചങ്കുകളായി വിഭജിക്കാം:
def split_text(text, max_length, min_length):
words = text.split()
chunks = []
current_chunk = []
for word in words:
current_chunk.append(word)
if len(' '.join(current_chunk)) < max_length and len(' '.join(current_chunk)) > min_length:
chunks.append(' '.join(current_chunk))
current_chunk = []
# അവസാന ഭാഗം കുറഞ്ഞത് കുറഞ്ഞ നീളം എത്തിക്കാനായില്ലെങ്കിൽ പോലും അതിനെ ചേര്ക്കുക
if current_chunk:
chunks.append(' '.join(current_chunk))
return chunksചങ്ക് ചെയ്ത ശേഷം, വിവിധ എൻബെഡിംഗ് മോഡലുകൾ ഉപയോഗിച്ച് ടെക്സ്റ്റ് എൻബെഡ് ചെയ്യാം. ഉപയോഗിക്കാവുന്ന ചില മോഡലുകൾ: word2vec, OpenAI യുടെ ada-002, Azure Computer Vision തുടങ്ങി അനേകം. മോഡൽ തിരഞ്ഞെടുപ്പ് ഉപയോഗിക്കുന്ന ഭാഷ, എൻകോടിംഗ് ഉള്ളടക്കം (ടെക്സ്റ്റ്/ഇമേജ്/ഓഡിയോ), എൻകോടിംഗ് ഇൻപുട്ട് വലുപ്പം, എൻബെഡിംഗ് ഔട്ട്പുട്ട് നീളം എന്നിവയെ ആശ്രയിച്ചിരിക്കും.
OpenAI യുടെ text-embedding-ada-002 മോഡലിന്റെ ഉദാഹരണം:
ഉപയോക്താവ് ചോദ്യം ചോദിക്കുമ്പോൾ, റിട്ട്രീവർ ചോദ്യത്തെ വക്ടറിലായി മാറ്റാൻ query encoder ഉപയോഗിക്കുന്നു, പിന്നെ രേഖ യായ ഡാറ്റാബേസ് ഇൻഡെക്സ് വഴി ഉൾപ്പെട്ട വെക്ടറുകൾ തേടുന്നു. നിർബന്ധമായും ഉപയോക്തൃ ചോദ്യത്തിന്റെയും രേഖയിലുള്ള വക്ടറുകളുടെ മത്സരസാദൃശ്യമുള്ളതാണ് ഏകദേശം തിരയുന്നത്. ശേഷം ഇൻപുട്ട് വെക്ടറും ഡോക്യുമെന്റ് വെക്ടറും ടെക്സ്റ്റായി മാറ്റി LLM-നുള്ളിൽ കടത്തുന്നു.
റിട്ട്രീവൽ എന്നാൽ സിസ്റ്റം ഉടൻ അവരെ പ്രാപിക്കാൻ കഴിയുന്ന രേഖകൾ തിരയുന്നതാണ്. റിട്ട്രീവറിന്റെ പ്രധാന ലക്ഷ്യം ബന്ധപ്പെട്ട രേഖകൾ കണ്ടെത്തി അവ ഉപയോഗിച്ച് LLM-നെ ഉപയോക്തൃ ഡാറ്റയിൽ ഭൂതടിപ്പിക്കുക എന്നതാണ്.
നമ്മുടെ ഡാറ്റാബേസിൽ തെരച്ചിൽ നടത്താനുള്ള ചില മാർഗങ്ങൾ:
-
കീവേഡ്ഡ് സെർച്ച് - ടെക്സ്റ്റ് സെർച്ചുകൾക്കായി
-
വക്ടർ സെർച്ച് - ടെക്സ്റ്റ് രേഖകളെ എൻബെഡിംഗുകൾ ആയി മാറ്റി, വാക്കുകളുടെ അർഥം പരിഗണിച്ച് സെമാന്റിക് സെർച്ച് ചെയ്യുന്നു. ഉപയോഗം എൻബെഡിംഗ് വെക്ടറുകൾ ഉപയോക്തൃ ചോദ്യം ഏറ്റവും അടുത്ത രേഖകളെ തിരയുന്നതോടെ.
-
ഹൈബ്രിഡ് - കീവേഡ് സെർച്ച് & വക്ടർ സെർച്ച് രണ്ടും ചേർത്ത്.
റിട്ട്രീവൽ പ്രക്രിയയുടെ ഒരു വെല്ലുവിളി: ഡാറ്റാബേസിൽ ചോദ്യം നിറവേറ്റുന്ന സമാന മറുപടി ഇല്ലെങ്കിൽ, സിസ്റ്റം ലഭ്യമായ മികച്ച വിവരങ്ങൾ നൽകും. ഇത് കുറയ്ക്കാൻ സമീപനങ്ങൾ: പ്രസക്തി പരിധി ക്രമീകരിക്കൽ, അല്ലെങ്കിൽ ഹൈബ്രിഡ് സെർച്ച്, ഇരു കീവേഡ് & വക്ടർ സെർച്ചും ചേർത്തു ഉപയോഗിക്കുക. ഈ പാഠത്തിൽ ഹൈബ്രിഡ് സെർച്ചാകും ഉപയോഗിക്കുന്നത്. ഡാറ്റാ ചങ്കുകള ഉളള കോളങ്ങൾ കൂടിയ ഒരു ഡാറ്റാഫ്രെയിം സംഭരിക്കും.
റിട്ട്രീവർ ജ്ഞാന വൃത്തത്തിലെ എങ്ങനെ അടുത്തവരുമെന്നു നോക്കി സംബദ്ധിച്ച എൻബെഡിംഗുകൾ തിരയുന്നു, ഏറ്റവും അടുത്ത അയൽവാസി കണ്ടെത്തുന്നു, കാരണം അവ രചനാത്മകമായി സമാനമാണ്. ഒരാൾ ചോദ്യം ചോദിക്കുമ്പോൾ അത് ആദ്യമായി എൻബെഡ് ചെയ്ത് സമാന എൻബെഡിംഗുകളുമായി താരതമ്യപ്പെടുത്തുന്നു. വ്യത്യസ്ത വക്ടറുകൾ എത്രസമാനമാണെന്ന് അറിയാൻ സാധാരണ ഉപയോഗിക്കുന്ന അളവുകോശം കോസൈൻ സമാനതയാണ്, ഇത് വക്ടറുകൾ ഇടയിലെ കോണിനെ അടിസ്ഥാനമാക്കി.
സമാനത അളക്കാൻ മറ്റു ഉപായങ്ങൾ: യൂക്ലിഡിയൻ ദൂരം (വക്ടർ അവസാന ബിന്ദുക്കൾക്കിടയിലെ നേരിയ രേഖ) അല്ലെങ്കിൽ ഡോട്ട് പ്രോഡക്റ്റ് (രണ്ട് വക്ടറുകളിലെ തരംതിരിക്കുന്ന അംഗങ്ങളുടെ ഗുണിത ഫലം).
റിട്ട്രീവലിനു മുൻപ് നമ്മുടെ ജ്ഞാന വൃത്തത്തിനൊരു സെർച്ച് ഇൻഡക്സ് നിർമിക്കണം. ഇൻഡക്സ് എൻബെഡിംഗുകൾ സംഭരിച്ച് വേഗത്തിൽ ഏറ്റവും സമാനമായ ചങ്കുകൾ തിരയാൻ സഹായിക്കുന്നു. ഇൻഡക്സ് എങ്ങനെ നിർമിക്കാമെന്നു കാണാം:
from sklearn.neighbors import NearestNeighbors
embeddings = flattened_df['embeddings'].to_list()
# തിരഞ്ഞടുപ്പ് സൂചിക സൃഷ്ടിക്കുക
nbrs = NearestNeighbors(n_neighbors=5, algorithm='ball_tree').fit(embeddings)
# സൂചിക_QUERY ചെയ്യുന്നതിനായി, നിങ്ങൾക്ക് kneighbors നടപടിക്രമം ഉപയോഗിക്കാം
distances, indices = nbrs.kneighbors(embeddings)ഡാറ്റാബേസ് വിരചിച്ച ശേഷം, ഏറ്റവും പ്രസക്തമായ ഫലം ആദ്യം വരാൻ ഫലങ്ങളോഡ് ക്രമീകരണം ആവശ്യമായേക്കാം. റീ-റാങ്കിംഗ് LLM മെഷീൻ ലേണിംഗ് ഉപയോഗിച്ച് തെരച്ചിൽ ഫലങ്ങളുടെ പ്രസക്തി മെച്ചപ്പെടുത്തുന്നു. Azure AI Search ഉപയോഗിച്ച് സിമാന്റിക് റീ-റാങ്കർ ഉപയോഗിച്ച് ഇത് ഓട്ടോമാറ്റിക് ആയി നടക്കും. അടുത്തവാസികളുമായി റീ-റാങ്കിംഗ് ഉദാഹരണം:
# ഏറ്റവും സാദൃശ്യമുള്ള ഡോക്യുമെന്റുകൾ കണ്ടെത്തുക
distances, indices = nbrs.kneighbors([query_vector])
index = []
# ഏറ്റവും സാദൃശ്യമുള്ള ഡോക്യുമെന്റുകൾ പ്രിന്റ് ചെയ്യുക
for i in range(3):
index = indices[0][i]
for index in indices[0]:
print(flattened_df['chunks'].iloc[index])
print(flattened_df['path'].iloc[index])
print(flattened_df['distances'].iloc[index])
else:
print(f"Index {index} not found in DataFrame")മറ്റ് ഘട്ടം LLM കൂടി ചേർത്ത് മറുപടികൾക്ക് നമ്മുടെ ഡാറ്റയോട് ഭൂതടിപ്പിക്കുക. ഇത് ഇപ്രകാരമാണ് നടപ്പിലാക്കുന്നത്:
user_input = "what is a perceptron?"
def chatbot(user_input):
# ചോദ്യത്തെ ഒരു ക്വറി വെക്ടറായി മാറ്റുക
query_vector = create_embeddings(user_input)
# ഏറ്റവും സമാനമായ ഡോക്യുമെന്റുകൾ കണ്ടെത്തുക
distances, indices = nbrs.kneighbors([query_vector])
# സੰਦਰഭം നൽകാൻ ക്വരിക്കു ഡോക്യുമെന്റുകൾ ചേർക്കുക
history = []
for index in indices[0]:
history.append(flattened_df['chunks'].iloc[index])
# ചരിത്രവും ഉപയോക്തൃ ഇൻപുട്ടും ചേർക്കുക
history.append(user_input)
# ഒരു സന്ദേശ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുക
messages=[
{"role": "system", "content": "You are an AI assistant that helps with AI questions."},
{"role": "user", "content": "\n\n".join(history) }
]
# ഒരു പ്രതികരണം സൃഷ്ടിക്കാൻ ചാറ്റ് കംപ്ലീഷൻ ഉപയോഗിക്കുക
response = openai.chat.completions.create(
model="gpt-4",
temperature=0.7,
max_tokens=800,
messages=messages
)
return response.choices[0].message
chatbot(user_input)-
മറുപടികളുടെ ഗുണനിലവാരം: സ്വാഭാവികം, പ്രവാഹകരവും മനുഷ്യ സദൃശവുമായിരിക്കണം.
-
ഡാറ്റയുടെ ഭൂതടിപ്പ്: ലഭ്യമായ രേഖകളിൽ നിന്നാണോ മറുപടി എന്ന വിലയിരുത്തൽ.
-
പ്രസക്തി: ചോദ്യം ചെയ്തതു സംബന്ധിച്ച മറുപടി നൽകുന്നുണ്ടോ എന്നത്.
-
ശുദ്ധവാക്യശൈലി - വ്യാകരണപ്രകാരം മറുപടി തറ്റാതെ ഫലപ്രദമാണോ.
ഒരു ആപ്പ് മെച്ചപ്പെടുത്തുന്നതിന് ഫംഗ്ഷൻ കോൾസ് ഉപയോഗിച്ചും RAG-ലെ നിരവധി ഉപയോഗങ്ങൾ:
-
ചോദ്യോത്തര വ്യവസ്ഥകൾ: കമ്പനിയുടെയ ഡാറ്റ ചാറ്റിൽ ഭൂതടിച്ച് കാര്യമാകുന്നവരല്ല.
-
ശുപാർശ ഉപാധികൾ: ഏറ്റവും സമാനമായ മൂല്യങ്ങൾ (ചിത്രങ്ങൾ, റെസ്റ്റോറന്റുകൾ തുടങ്ങിയവ) ഒക്കെയും കണ്ടെത്തുന്ന സിസ്റ്റം നിർമ്മിക്കാം.
-
ചാറ്റ്ബോട്ട് സേവനങ്ങൾ: ചാറ്റ് ചരിത്രം സംഭരിച്ച് ഉപയോക്തൃ ഡാറ്റ അനുസരിച്ച് വ്യക്തിഗത സംഭാഷണം.
-
വക്ടർ എൻബെഡിംഗുകളെ അടിസ്ഥാനമാക്കി ചിത്രം തിരയൽ, ഇമേജ് തിരിച്ചറിവിലും അനൊമലി കണ്ടെത്തലിലും പ്രയോജനം.
RAG-ന്റെ അടിസ്ഥാന മേഖലകൾ, ഡാറ്റ ആപ്ലിക്കേഷനിൽ ചേർക്കൽ, ഉപയോക്തൃ ചോദ്യവും ഔട്ട്പുട്ടും ഉൾപ്പെടുത്തി ഞങ്ങൾ പഠിച്ചു. RAG സൃഷ്ടി ലളിതമാക്കാൻ Semanti Kernel, Langchain, Autogen പോലുള്ള ഫ്രെയിംവർക്ക്സ് ഉപയോഗിക്കാം.
Retrieval Augmented Generation (RAG) ന്റെ പഠനം തുടരാൻ നിങ്ങൾക്ക് ചെയ്യാവുന്നത്:
-
ഇഷ്ടമുള്ള ഫ്രെയിംവർക്കിൽ ആപ്ലിക്കേഷനായി ഒരു ഫ്രണ്ട്-എണ്ട് വികസിപ്പിക്കുക
-
LangChain അല്ലെങ്കിൽ Semantic Kernel എന്ന ഫ്രെയിംവർക്ക് ഉപയോഗിച്ച് ആപ്ലിക്കേഷൻ പുനഃസൃഷ്ടിക്കുക
പാഠം പൂർത്തിയാക്കിയതിന് അഭിനന്ദനങ്ങൾ 👏.
ഈ പാഠം പൂർത്തിയാക്കിയ ശേഷം, നമ്മുടെ Generative AI Learning collection പരിശോധിച്ച് Generative AI അറിവ് ഉയർത്തുമ്പോൾ തുടരുക!
അസംബന്ധിത കുറിപ്പ്:
ഈ രേഖ AI വിവർത്തന സേവനം Co-op Translator ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം പൂർണ്ണ ശുദ്ധിത്വത്തിനായി ശ്രമിക്കുമ്പോഴും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിഴവുകൾ ഉണ്ടായേക്കാമെന്ന കാര്യം ദയവായി ശ്രദ്ധിക്കുക. സ്വന്തം മാതൃഭാഷയിലുള്ള അദ്ധ്യക്ഷ രേഖതimetableകൾ പ്രാമാണികമായ ഉറവിടമായാണ് കണക്കാക്കേണ്ടത്. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യവിവർത്തനം നിർദ്ദേശിക്കുന്നതാണ്. ഈ വിവർത്തനം ഉപയോഗിച്ചതു കൊണ്ടോ അതിൽ നിന്നുള്ള തെറ്റുള്ള മനസ്സിലാക്കലുകളിലോ നാം ഉത്തരവാദിത്വം ഏറ്റെടുക്കുന്നില്ല.