મેં તેને સમજવા માટે Python માં શૂન્યથી RAG બનાવ્યું

મેં છ મહિના સુધી પ્રોડક્શનમાં LangChain નો ઉપયોગ કર્યો. હું સમજાવી શકતો નહોતો કે તે કેવી રીતે કામ કરે છે. મેં ચોક્કસ મેટ્રિક્સ કેમ પસંદ કર્યા અથવા ટેક્સ્ટ વેક્ટરમાં કેવી રીતે રૂપાંતરિત થયું તે મને ખબર નહોતી. લાઇબ્રેરીએ તેની પાછળનું લોજિક છુપાવી દીધું હતું.

આ સુધારવા માટે, મેં ફ્રેમવર્ક કાઢી નાખ્યું. મેં 500 લાઇનના સાદા Python નો ઉપયોગ કરીને શૂન્યથી RAG પાઇપલાઇન લખી.

મેન્યુઅલી આ સ્ટેક બનાવવાથી મેં જે શીખ્યું તે અહીં છે.

બ્લેક બોક્સ સાથેની સમસ્યા

જ્યારે તમે હાઇ-લેવલ લાઇબ્રેરીઓનો ઉપયોગ કરો છો, ત્યારે તમે નિયંત્રણ ગુમાવો છો. મેં જોયું કે મોડલ્સ તથ્યો વિશે ભ્રમિત (hallucinate) થાય છે અથવા ખોટા સંદર્ભો (citations) આપે છે. મને એ ખબર નહોતી પડતી કે ભૂલ chunker માં હતી, embedding model માં હતી કે prompt માં.

જ્યારે તમે તે જાતે બનાવો છો, ત્યારે દરેક લેયરનું નિરીક્ષણ કરી શકાય છે. તમે LLM ને મોકલવામાં આવેલા ચોક્કસ chunks ને પ્રિન્ટ કરી શકો છો. તમે વાક્ય ક્યાં તૂટે છે તે ચોક્કસ રીતે જોઈ શકો છો.

RAG ના પાંચ લેયર્સ

RAG એ કોઈ એક અલ્ગોરિધમ નથી. તે એકસાથે જોડાયેલી પાંચ અલગ-અલગ પ્રક્રિયાઓ છે:

  • Chunking: ટેક્સ્ટને કેવી રીતે વિભાજિત કરવું તે નક્કી કરવું.
  • Embedding: ટેક્સ્ટને ગણિતમાં રૂપાંતરિત કરવું.
  • Retrieval: યોગ્ય ભાગો શોધવા.
  • Prompt Construction: મોડલને કેવી રીતે વર્તવું તે કહેવું.
  • Generation: અંતિમ જવાબ મેળવવો.

નિર્માણમાંથી મળેલા પાઠ

  1. Chunking એ સૌથી મહત્વનું પગલું છે મોટાભાગના ટ્યુટોરિયલ્સ આને છોડી દે છે. જો તમે overlap નો ઉપયોગ ન કરો, તો તમે સીમાઓ (boundaries) પર સંદર્ભ ગુમાવી બેસો છો. મેં character-level overlap સાથે sliding window નો ઉપયોગ કર્યો. આ સુનિશ્ચિત કરે છે કે મોડલ બે chunks વચ્ચેનો સંબંધ જોઈ શકે.

  2. ડિસ્ટન્સ મેટ્રિક્સ મહત્વના છે મેં ખરાબ સર્ચ રિઝલ્ટ્સને ડિબગ કરવામાં કલાકો વિતાવ્યા. સમસ્યા ડેટામાં નહોતી, પણ મેટ્રિકમાં હતી. ChromaDB ડિફોલ્ટ તરીકે L2 distance નો ઉપયોગ કરે છે. Semantic search માટે, તમારે Cosine similarity ની જરૂર છે. કોડની એક લાઇનએ બધું બદલી નાખ્યું.

  3. Prompts ને નિયંત્રણોની જરૂર છે LLM એ માહિતી પૂર્ણ કરનાર છે, કોઈ જ્ઞાની (oracle) નથી. જો તમે અસ્પષ્ટ પ્રશ્ન પૂછશો, તો તે જવાબ બનાવી દેશે. મેં એક કડક refusal template નો ઉપયોગ કરવાનું શીખ્યું. મેં મોડલને કહ્યું: "જો સંદર્ભમાં જવાબ ન હોય, તો કહો કે તમને ખબર નથી." આનાથી hallucinations 40% થી ઘટીને 5% થઈ ગયા.

  4. તમારી વિનંતીઓને batch માં મોકલો દરેક chunk માટે એક HTTP request મોકલવી ધીમી પ્રક્રિયા છે. તેને batches માં મોકલવી ઘણું ઝડપી છે. તે લોકલ મોડલને કામને pipeline કરવાની મંજૂરી આપે છે.

  5. નીચેથી ઉપર તરફ ટેસ્ટ કરો અંતમાં ટેસ્ટ લખશો નહીં. પહેલા તમારા chunker ને ટેસ્ટ કરો. પછી તમારા embedder ને ટેસ્ટ કરો. પછી તમારા store ને ટેસ્ટ કરો. જો તમે છેલ્લે ટેસ્ટ કરશો, તો તમે લોજિકને બદલે બગ્સ (bugs) ને ટેસ્ટ કરશો.

જો તમને લાગે છે કે તમે તમારા AI સ્ટેકને ખરેખર સમજી શકતા નથી, તો તેને જાતે બનાવો. કોડ એ લક્ષ્ય નથી. વિચારવાની પ્રક્રિયા એ લક્ષ્ય છે.

Source: https://dev.to/avinash_zala_1c6f5e7c4af9/i-built-rag-from-scratch-in-python-to-understand-it-heres-what-i-learned-33kf

વૈકલ્પિક લર્નિંગ કોમ્યુનિટી: https://t.me/GyaanSetuAi