மேம்படுத்தப்பட்ட மென்பொருள் மேம்பாட்டு பணிப்பாய்வுகளுக்காக எல்எல்எம்களுடன் RAG ஐ ஒருங்கிணைத்தல்

மேம்படுத்தப்பட்ட மென்பொருள் மேம்பாட்டு பணிப்பாய்வுகளுக்காக எல்எல்எம்களுடன் RAG ஐ ஒருங்கிணைத்தல்

அறிமுகம்

செயற்கை நுண்ணறிவு (AI), இயந்திர கற்றல் (ML) மற்றும் இயற்கை மொழி செயலாக்கம் (NLP) ஆகியவற்றின் முன்னேற்றங்களால் மென்பொருள் மேம்பாட்டு நிலப்பரப்பு வேகமாக உருவாகி வருகிறது. மென்பொருளை உருவாக்கும் விதத்தில் புரட்சியை ஏற்படுத்தும் இரண்டு முக்கிய தொழில்நுட்பங்கள் மீட்டெடுப்பு-ஆக்மென்ட் ஜெனரேஷன் (RAG) மற்றும் பெரிய மொழி மாதிரிகள் (LLMs). இந்தக் கட்டுரையில், மென்பொருள் பொறியியல் செயல்முறைகளை ஒழுங்குபடுத்தவும், குறியீடு உருவாக்கத்தை மேம்படுத்தவும், டெவலப்பர் உற்பத்தித்திறனை மேம்படுத்தவும் LLMகளுடன் RAG இன் ஒருங்கிணைப்பை ஆராய்வோம்.

மீட்பு-ஆக்மென்டட் ஜெனரேஷன் (RAG) என்றால் என்ன?

RAG என்பது NLPக்கான மீட்டெடுப்பு அடிப்படையிலான மற்றும் தலைமுறை அடிப்படையிலான அணுகுமுறைகளின் வலிமையை ஒருங்கிணைக்கும் ஒரு நுட்பமாகும். இது ஒரு பெரிய உரையிலிருந்து தொடர்புடைய தகவலை மீட்டெடுக்கிறது மற்றும் புதிய உரையின் உருவாக்கத்தை அதிகரிக்க அதைப் பயன்படுத்துகிறது. கேள்வி பதில், உரை சுருக்கம் மற்றும் குறியீடு உருவாக்கம் உள்ளிட்ட பல்வேறு NLP பணிகளில் இந்த அணுகுமுறை மிகவும் பயனுள்ளதாக உள்ளது.

பெரிய மொழி மாதிரிகள் (LLMகள்) என்றால் என்ன?

எல்எல்எம்கள் என்பது ஒரு வகையான நரம்பியல் நெட்வொர்க் ஆகும், இது மனிதனைப் போன்ற மொழியை செயலாக்க மற்றும் உருவாக்க வடிவமைக்கப்பட்டுள்ளது. அவை பொதுவாக உரையின் பாரிய தரவுத்தொகுப்புகளில் பயிற்றுவிக்கப்படுகின்றன, மேலும் மொழி மொழிபெயர்ப்பு, உரை சுருக்கம் மற்றும் குறியீடு உருவாக்கம் போன்ற குறிப்பிட்ட பணிகளுக்கு நன்றாகச் சரிசெய்யப்படலாம். LLMகள் பல NLP பணிகளில் அதிநவீன முடிவுகளை அடைந்துள்ளன, மேலும் அவை chatbots, virtual Assistants மற்றும் மொழி மொழிபெயர்ப்பு அமைப்புகள் போன்ற பயன்பாடுகளில் பரவலாகப் பயன்படுத்தப்படுகின்றன.

மேம்படுத்தப்பட்ட மென்பொருள் மேம்பாட்டு பணிப்பாய்வுகளுக்காக எல்எல்எம்களுடன் RAG ஐ ஒருங்கிணைத்தல்

எல்எல்எம்களுடன் RAG இன் ஒருங்கிணைப்பு மென்பொருளை உருவாக்கும் விதத்தில் புரட்சியை ஏற்படுத்தும் ஆற்றலைக் கொண்டுள்ளது. மீட்டெடுப்பு அடிப்படையிலான மற்றும் தலைமுறை அடிப்படையிலான அணுகுமுறைகளின் பலத்தை இணைப்பதன் மூலம், RAG ஆனது LLM களுக்கு மிகவும் துல்லியமான மற்றும் பொருத்தமான குறியீட்டை உருவாக்க உதவும். இது டெவலப்பர் உற்பத்தித்திறன், குறியீடு தரம் மற்றும் ஒட்டுமொத்த மென்பொருள் மேம்பாட்டு பணிப்பாய்வுகளில் குறிப்பிடத்தக்க முன்னேற்றங்களுக்கு வழிவகுக்கும்.

ஆர்கெஸ்ட்ரேஷன் கருவிகள்: LangChain மற்றும் DSPy

எல்எல்எம்களுடன் RAGஐ ஒருங்கிணைக்க, தரவு ஓட்டத்தை நிர்வகிக்கக்கூடிய மற்றும் RAG மற்றும் LLM கூறுகளின் செயல்பாட்டைக் கட்டுப்படுத்தக்கூடிய ஆர்கெஸ்ட்ரேஷன் கருவிகள் எங்களுக்குத் தேவை. இந்த நோக்கத்திற்காக பயன்படுத்தக்கூடிய இரண்டு பிரபலமான ஆர்கெஸ்ட்ரேஷன் கருவிகள் LangChain மற்றும் DSPy ஆகும்.

LangChain

LangChain என்பது ஒரு திறந்த மூல பைதான் நூலகமாகும், இது RAG-அடிப்படையிலான பயன்பாடுகளை உருவாக்குவதற்கான எளிய மற்றும் உள்ளுணர்வு API ஐ வழங்குகிறது. சக்திவாய்ந்த மென்பொருள் மேம்பாட்டு பணிப்பாய்வுகளை உருவாக்க டெவலப்பர்கள் எல்எல்எம்கள் மற்றும் பிற NLP கூறுகளுடன் RAG ஐ எளிதாக ஒருங்கிணைக்க அனுமதிக்கிறது.

டிஎஸ்பி

DSPy என்பது மற்றொரு திறந்த மூல பைதான் நூலகமாகும், இது RAG-அடிப்படையிலான பயன்பாடுகளை உருவாக்குவதற்கான உயர்-நிலை API ஐ வழங்குகிறது. இது எல்எல்எம்கள் மற்றும் பிற என்எல்பி கூறுகளுடன் தடையின்றி வேலை செய்யும் வகையில் வடிவமைக்கப்பட்டுள்ளது, இது எல்எல்எம்களுடன் RAGஐ ஒருங்கிணைப்பதற்கான சிறந்த தேர்வாக அமைகிறது.

** குறியீடு எடுத்துக்காட்டு: LangChain ஐப் பயன்படுத்தி LLMகளுடன் RAG ஐ ஒருங்கிணைத்தல்**

LangChain ஐப் பயன்படுத்தி எல்எல்எம்களுடன் RAG ஐ எவ்வாறு ஒருங்கிணைப்பது என்பதை விளக்கும் எளிய குறியீடு எடுத்துக்காட்டு இங்கே:

லாங்செயின் இறக்குமதி
langchain.chains இருந்து RAGChain இறக்குமதி


rag_model = langchain.RAG(
    index=langchain.Index(
        name="my_index",
        ஆவணங்கள்=["ஆவணம்1", "ஆவணம்2", "ஆவணம்3"],
    ),
    retriever=langchain.Retriever(
        பெயர்="மை_ரெட்ரீவர்",
        மாதிரி="மை_ரெட்ரீவர்_மாடல்",
    ),
    ஜெனரேட்டர்=லாங்செயின்.ஜெனரேட்டர்(
        பெயர்="மை_ஜெனரேட்டர்",
        மாதிரி="மை_ஜெனரேட்டர்_மாடல்",
    ),
)

# LLM மாதிரியை வரையறுக்கவும்
llm_model = langchain.LLM(
    பெயர்="my_llm",
    மாதிரி="my_llm_model",
)

# ஒரு RAG சங்கிலியை உருவாக்கவும்
rag_chain = RAGChain(
    பெயர்="my_rag_chain",
    மாதிரி = ராக்_மாடல்,
    llm=llm_model,
)

# குறியீட்டை உருவாக்க RAG சங்கிலியைப் பயன்படுத்தவும்
குறியீடு = rag_chain.generate(
    input_text="இரண்டு முழு எண்களை உள்ளீடாக எடுத்து அவற்றின் கூட்டுத்தொகையை வழங்கும் செயல்பாட்டை எழுதவும்",
)

அச்சு (குறியீடு)

லாங்செயினைப் பயன்படுத்தி RAG மாதிரியை எப்படி வரையறுப்பது, LLM மாதிரியை வரையறுப்பது, RAG சங்கிலியை உருவாக்குவது மற்றும் குறியீட்டை உருவாக்க சங்கிலியைப் பயன்படுத்துவது எப்படி என்பதை இந்தக் குறியீடு எடுத்துக்காட்டு விளக்குகிறது.

முதல் 5-10 அதிகம் பயன்படுத்தப்பட்ட கட்டளைகள்/துணுக்குகள்

LangChain மற்றும் DSPy ஐப் பயன்படுத்தி எல்எல்எம்களுடன் RAG ஐ ஒருங்கிணைப்பதற்காக அதிகம் பயன்படுத்தப்படும் 5-10 கட்டளைகள்/துணுக்குகள் இங்கே:

1. langchain.RAG(): RAG மாதிரி நிகழ்வை உருவாக்குகிறது.
2. langchain.Index(): ஆவணங்களைச் சேமிப்பதற்கும் மீட்டெடுப்பதற்கும் ஒரு குறியீட்டு நிகழ்வை உருவாக்குகிறது.
3. langchain.Retriever(): தொடர்புடைய ஆவணங்களை மீட்டெடுப்பதற்கான ரீட்ரீவர் நிகழ்வை உருவாக்குகிறது.
4. langchain.Generator(): புதிய உரையை உருவாக்குவதற்கான ஜெனரேட்டர் நிகழ்வை உருவாக்குகிறது.
5. langchain.LLM(): LLM மாதிரி நிகழ்வை உருவாக்குகிறது.
6. RAGChain(): RAG சங்கிலி நிகழ்வை உருவாக்குகிறது.
7. rag_chain.generate(): குறியீட்டை உருவாக்க RAG சங்கிலியைப் பயன்படுத்துகிறது.
8. llm_model.generate(): குறியீட்டை உருவாக்க LLM மாதிரியைப் பயன்படுத்துகிறது.
9. index.add_document(): குறியீட்டில் ஒரு ஆவணத்தைச் சேர்க்கிறது.
10. retriever.retrieve(): ரிட்ரீவரைப் பயன்படுத்தி தொடர்புடைய ஆவணங்களைப் பெறுகிறது.

காட்சிப்படுத்தல்

Chart.js ஐப் பயன்படுத்தி RAG மற்றும் LLM கூறுகளின் காட்சிப்படுத்தல் இங்கே:

{
  "வகை": "பார்",
  "தரவு": {
    "லேபிள்கள்": ["RAG", "LLM"],
    "தரவுத்தொகுப்புகள்": [
      {
        "லேபிள்": "கூறுகள்",
        "தரவு": [10, 20],
        "பின்னணி நிறம்": ["#4CAF50", "#FF9800"]
      }
    ]
  },
  "விருப்பங்கள்": {
    "தலைப்பு": {
      "காட்சி": உண்மை,
      "உரை": "RAG மற்றும் LLM கூறுகள்"
    },
    "செதில்கள்": {
      "yAxes": [
        {
          "காட்சி": உண்மை,
          "beginAtZero": உண்மை
        }
      ]
    }
  }
}

இந்த காட்சிப்படுத்தல் RAG மற்றும் LLM மாதிரிகளில் உள்ள கூறுகளின் எண்ணிக்கையைக் காட்டுகிறது.

முடிவு

எல்எல்எம்களுடன் RAG இன் ஒருங்கிணைப்பு மென்பொருளை உருவாக்கும் விதத்தில் புரட்சியை ஏற்படுத்தும் ஆற்றலைக் கொண்டுள்ளது. மீட்டெடுப்பு அடிப்படையிலான மற்றும் தலைமுறை அடிப்படையிலான அணுகுமுறைகளின் பலத்தை இணைப்பதன் மூலம், RAG ஆனது LLM களுக்கு மிகவும் துல்லியமான மற்றும் பொருத்தமான குறியீட்டை உருவாக்க உதவும். இது டெவலப்பர் உற்பத்தித்திறன், குறியீடு தரம் மற்றும் ஒட்டுமொத்த மென்பொருள் மேம்பாட்டு பணிப்பாய்வுகளில் குறிப்பிடத்தக்க முன்னேற்றங்களுக்கு வழிவகுக்கும். LangChain மற்றும் DSPy போன்ற ஆர்கெஸ்ட்ரேஷன் கருவிகள் மூலம், டெவலப்பர்கள் எல்எல்எம்கள் மற்றும் பிற NLP கூறுகளுடன் RAG ஐ எளிதாக ஒருங்கிணைத்து சக்திவாய்ந்த மென்பொருள் மேம்பாட்டு பணிப்பாய்வுகளை உருவாக்க முடியும்.