** නවීන වෙබ් රාමු සමඟ RAG (ප්‍රතිසාධන-වර්ධිත පරම්පරාව) ඒකාබද්ධ කිරීම: ප්‍රායෝගික මාර්ගෝපදේශයක්**

හැඳින්වීම

මෑත වසරවලදී, ස්වාභාවික භාෂා සැකසුම් ක්ෂේත්‍රය (NLP) විශාල භාෂා ආකෘති (LLMs) සහ විවිධ වසම්වල ඒවායේ යෙදීම් සංවර්ධනයේ සැලකිය යුතු ඉහළ යාමක් දැක තිබේ. කෙසේ වෙතත්, LLM වල ඇති ප්‍රධාන සීමාවන්ගෙන් එකක් වන්නේ ඔවුන්ගේ ප්‍රතිචාර වලට බාහිර දැනුම ලබා ගැනීමට සහ ඒවා ඇතුළත් කිරීමට ඇති නොහැකියාවයි. Retrieval-Augmented Generation (RAG) ශිල්පීය ක්‍රම ක්‍රියාත්මක වන්නේ මෙහිදීය. මෙම ලිපියෙන්, බාධාවකින් තොරව දත්ත ලබා ගැනීම සහ සැකසීම සඳහා LangChain සමඟ වාද්‍ය වෘන්දය ඇතුළුව, වෙබ් යෙදුම්වල LLM හැකියාවන් වැඩි දියුණු කිරීම සඳහා FastAPI සහ Django භාවිතා කරමින් RAG ශිල්පීය ක්‍රම ක්‍රියාත්මක කිරීම අපි ගවේෂණය කරන්නෙමු.

RAG යනු කුමක්ද?

RAG යනු වඩාත් නිවැරදි සහ තොරතුරු සහිත ප්‍රතිචාර නිපදවීමට Retrieval සහ Generation මාදිලිවල ශක්තීන් ඒකාබද්ධ කරන තාක්‍ෂණයකි. RAG පිටුපස ඇති මූලික අදහස නම් පළමුව දැනුම් පදනමකින් හෝ දත්ත ගබඩාවකින් අදාළ තොරතුරු ලබා ගැනීම සහ ප්‍රතිචාරයක් ජනනය කිරීමට මෙම තොරතුරු භාවිතා කිරීමයි. මෙම ප්‍රවේශය LLM වලට බාහිර දැනුම ලබා ගැනීමට සහ වඩාත් නිවැරදි සහ තොරතුරු ප්‍රතිචාර සැපයීමට ඉඩ සලසයි.

FastAPI සහ Django සමඟ RAG භාවිතා කරන්නේ ඇයි?

FastAPI සහ Django යනු වෙබ් යෙදුම් තැනීම සඳහා භාවිතා කරන වඩාත් ජනප්‍රිය වෙබ් රාමු දෙකකි. ඒවා වෙබ් යෙදුම් තැනීම සඳහා ශක්තිමත් සහ පරිමාණය කළ හැකි යටිතල පහසුකම් සපයන අතර, LLM හැකියාවන් වැඩිදියුණු කිරීම සඳහා RAG තාක්ෂණික ක්‍රම සමඟ පහසුවෙන් ඒකාබද්ධ කළ හැකිය. FastAPI යනු වෙබ් යෙදුම් තැනීමට වේගවත් හා කාර්යක්ෂම ක්‍රමයක් සපයන නවීන වෙබ් රාමුවක් වන අතර Django යනු ශක්තිමත් වෙබ් යෙදුම් තැනීම සඳහා ගෘහ නිර්මාණ ශිල්පය, සැකිලි සහ API සපයන ඉහළ මට්ටමේ වෙබ් රාමුවකි.

FastAPI සමඟ RAG ක්‍රියාත්මක කිරීම

FastAPI RAG තාක්ෂණික ක්‍රම ක්‍රියාත්මක කිරීමට සරල සහ කාර්යක්ෂම ක්‍රමයක් සපයයි. RAG ක්‍රියාත්මක කිරීම සඳහා FastAPI භාවිතා කරන්නේ කෙසේදැයි පෙන්වන උදාහරණ කේත බ්ලොක් එකක් මෙන්න:

fastapi ආයාත FastAPI වෙතින්
langchain ආනයනය LLMCchain වෙතින්
langchain.chains.openai වෙතින් OpenAIApi ආනයනය කරන්න

යෙදුම = FastAPI()

@app.get("/rag")
async def rag (විමසුම: str):
    
    llm_chain = LLMCchain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                name="my_index",
                ලේඛන =["doc1", "doc2", "doc3"]
            )
        )
    )

    # LLM දාමය භාවිතයෙන් ප්‍රතිචාරයක් ජනනය කරන්න
    ප්‍රතිචාරය = llm_chain.run(query)

    ආපසු {"ප්‍රතිචාරය": ප්‍රතිචාරය}

මෙම උදාහරණයේදී, අපි LangChain වෙතින් LLMchain පන්තිය භාවිතා කරමින් LLM දාමයක් නිර්වචනය කරමු. අපි පසුව දැනුම් පදනමකින් හෝ දත්ත ගබඩාවකින් අදාළ තොරතුරු ලබා ගැනීමට භාවිතා කරන LangChainRetrieval පන්තිය භාවිතයෙන් ලබා ගැනීමේ සංරචකයක් නිර්වචනය කරමු. අවසාන වශයෙන්, අපි LLM දාමය භාවිතයෙන් ප්‍රතිචාරයක් ජනනය කිරීමට 'ධාවනය' ක්‍රමය භාවිතා කරමු.

ජංගෝ සමඟ RAG ක්‍රියාත්මක කිරීම

Django විසින් RAG තාක්ෂණික ක්‍රම සමඟ පහසුවෙන් ඒකාබද්ධ කළ හැකි ඉහළ මට්ටමේ වෙබ් රාමුවක් සපයයි. RAG ක්‍රියාත්මක කිරීම සඳහා Django භාවිතා කරන්නේ කෙසේද යන්න පෙන්නුම් කරන උදාහරණ කේත බ්ලොක් එකක් මෙන්න:

django.http වෙතින් JsonResponse ආනයනය කරන්න
langchain ආනයනය LLMCchain වෙතින්
langchain.chains.openai වෙතින් OpenAIApi ආනයනය කරන්න

def rag (ඉල්ලීම):
    # LLM දාමය නිර්වචනය කරන්න
    llm_chain = LLMCchain(
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            index=LangChainIndex(
                name="my_index",
                ලේඛන =["doc1", "doc2", "doc3"]
            )
        )
    )

    # LLM දාමය භාවිතයෙන් ප්‍රතිචාරයක් ජනනය කරන්න
    ප්‍රතිචාරය = llm_chain.run(request.GET.get("query"))

    ආපසු JsonResponse({"ප්‍රතිචාරය": ප්‍රතිචාරය})

මෙම උදාහරණයේදී, විමසුමක් ආදානය ලෙස ගෙන LLM දාමය භාවිතයෙන් ප්‍රතිචාරයක් ජනනය කරන 'rag' නැරඹුම් ශ්‍රිතයක් අපි අර්ථ දක්වමු.

LangChain සමඟ RAG සංවිධානය කිරීම

LangChain RAG ශිල්පීය ක්‍රම මෙහෙයවීමට සරල සහ කාර්යක්ෂම ක්‍රමයක් සපයයි. RAG සංවිධානය කිරීමට LangChain භාවිතා කරන්නේ කෙසේද යන්න පෙන්නුම් කරන උදාහරණ කේත බ්ලොක් එකක් මෙන්න:

langchain ආනයනය LLMCchain වෙතින්
langchain.chains.openai වෙතින් OpenAIApi ආනයනය කරන්න

# LLM දාමය නිර්වචනය කරන්න
llm_chain = LLMCchain(
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        index=LangChainIndex(
            name="my_index",
            ලේඛන =["doc1", "doc2", "doc3"]
        )
    )
)

# LLM දාමය භාවිතයෙන් ප්‍රතිචාරයක් ජනනය කරන්න
ප්‍රතිචාරය = llm_chain.run ("RAG යනු කුමක්ද?")

මුද්‍රණය (ප්‍රතිචාරය)

මෙම උදාහරණයේදී, අපි LangChain වෙතින් LLMchain පන්තිය භාවිතා කරමින් LLM දාමයක් නිර්වචනය කරමු. පසුව අපි LLM දාමය භාවිතයෙන් ප්‍රතිචාරයක් ජනනය කිරීමට 'ධාවනය' ක්‍රමය භාවිතා කරමු.

ඉහළම 5-10 වැඩිපුරම භාවිතා කරන ලද විධාන/Snippets

FastAPI සහ Django සමඟ RAG ක්‍රියාත්මක කිරීම සඳහා වැඩිපුරම භාවිතා කරන ලද විධාන/snippets 5-10 මෙන්න:

1. langchain ආනයනය LLMCchain වෙතින්: LangChain වෙතින් LLMchain පන්තිය ආයාත කරන්න.
2. `llm_chain = LLMCchain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"])))': LLMha යන්න භාවිතා කරමින් LLMha යන්න පන්තිය නිර්වචනය කරන්න.
3. ප්‍රතිචාරය = llm_chain.run(query): LLM දාමය භාවිතයෙන් ප්‍රතිචාරයක් ජනනය කරන්න.
4. fastAPI ආයාත කිරීමෙන් FastAPI: FastAPI වෙතින් FastAPI පන්තිය ආයාත කරන්න.
5. app = FastAPI(): FastAPI යෙදුමක් නිර්වචනය කරන්න.
6. @app.get("/rag"): RAG අන්ත ලක්ෂ්‍යය සඳහා මාර්ගයක් නිර්වචනය කරන්න.
7. `llm_chain = LLMCchain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"])))': LLMha යන්න භාවිතා කරමින් LLMha යන්න පන්තිය නිර්වචනය කරන්න.
8. ප්‍රතිචාරය = llm_chain.run(query): LLM දාමය භාවිතයෙන් ප්‍රතිචාරයක් ජනනය කරන්න.
9. django.http import JsonResponse: 'JsonResponse' පන්තිය Django වෙතින් ආයාත කරන්න.
10. ආපසු JsonResponse({"ප්‍රතිචාරය": ප්‍රතිචාරය}): ජනනය කරන ලද ප්‍රතිචාරය සමඟ JSON ප්‍රතිචාරයක් ලබා දෙන්න.

දෘෂ්‍යකරණය

Chart.js භාවිතයෙන් RAG නල මාර්ගයේ දෘශ්‍යකරණයක් මෙන්න:

'''' ජේසන් { "වර්ගය": "තිරස් තීරුව", "දත්ත": { "ලේබල්": ["නැවත ලබා ගැනීම", "පරම්පරාව", "පශ්චාත් සැකසුම්"], "දත්ත කට්ටල": [ { "ලේබලය": "RAG නල මාර්ගය", "දත්ත": [10, 20, 30], "පසුබිම් වර්ණය": [ "rgba(255, 99, 132, 0.2)", "rgba(54, 162, 235, 0.2)", "rgba(255, 206, 86, 0.2)" ], "දේශසීමා වර්ණය": [ "rgba(255, 99, 132, 1)", "rgba(54, 162, 235, 1)", "rgba(255, 206, 86, 1)" ], "දේශසීමා පළල": 1 } ] }, "විකල්ප": { "මාතෘකාව": { "දර්ශණය": ඇත්ත, "පෙළ": "RAG නල මාර්ගය" }, "පරිමාණ": { "yAxes": [ { "කිනිතුල්ලන්": { "beginAtZero": ඇත්ත } } ] } } }

මෙම දෘශ්‍යකරණය RAG නල මාර්ගය අදියර තුනකින් පෙන්වයි: ලබා ගැනීම, උත්පාදනය සහ පසු-සැකසීම.

** නිගමනය **


මෙම ලිපියෙන්, බාධාවකින් තොරව දත්ත ලබා ගැනීම සහ සැකසීම සඳහා LangChain සමඟ වාද්‍ය වෘන්දය ඇතුළුව, වෙබ් යෙදුම්වල LLM හැකියාවන් වැඩි දියුණු කිරීම සඳහා FastAPI සහ Django භාවිතා කරමින් RAG ශිල්පීය ක්‍රම ක්‍රියාත්මක කිරීම අපි ගවේෂණය කළෙමු. අපි කේත උදාහරණ සහ RAG නල මාර්ගයේ දෘශ්‍යකරණය ඇතුළුව FastAPI සහ Django සමඟ RAG ක්‍රියාත්මක කිරීම සඳහා ප්‍රායෝගික මාර්ගෝපදේශයක් ද ලබා දුන්නෙමු. ඔවුන්ගේ වෙබ් යෙදුම්වල RAG ශිල්පීය ක්‍රම ක්‍රියාත්මක කිරීමට බලාපොරොත්තු වන සංවර්ධකයින් සඳහා මෙම ලිපිය ප්‍රයෝජනවත් සම්පතක් සපයා ඇතැයි අපි බලාපොරොත්තු වෙමු.