RAG-ի (առբերման-ավելացված սերունդ) ինտեգրում ժամանակակից վեբ շրջանակների հետ. գործնական ուղեցույց

Ներածություն

Վերջին տարիներին բնական լեզվի մշակման ոլորտը (NLP) ականատես է եղել Լեզուների խոշոր մոդելների (LLMs) զարգացման և դրանց կիրառման տարբեր ոլորտներում զգալի աճի: Այնուամենայնիվ, LLM-ների հիմնական սահմանափակումներից մեկը նրանց անկարողությունն է առբերելու և արտաքին գիտելիքներն իրենց պատասխաններում ներառելու անկարողությունը: Այստեղ է, որ գործի են դրվում Retrieval-Augmented Generation (RAG) տեխնիկան: Այս հոդվածում մենք կուսումնասիրենք FastAPI-ի և Django-ի միջոցով RAG-ի տեխնիկայի իրականացումը վեբ հավելվածներում LLM-ի հնարավորությունները բարելավելու համար, ներառյալ LangChain-ի հետ նվագախումբը՝ տվյալների անխափան որոնման և մշակման համար:

Ի՞նչ է RAG-ը:

RAG-ը տեխնիկա է, որը միավորում է Retrieval և Generation մոդելների ուժեղ կողմերը՝ ավելի ճշգրիտ և տեղեկատվական պատասխաններ ստանալու համար: RAG-ի հիմքում ընկած հիմնական գաղափարն այն է, որ սկզբում համապատասխան տեղեկատվություն ստանալ գիտելիքի բազայից կամ տվյալների բազայից, այնուհետև օգտագործել այս տեղեկատվությունը պատասխան առաջացնելու համար: Այս մոտեցումը թույլ է տալիս LLM-ներին օգտագործել արտաքին գիտելիքները և տրամադրել ավելի ճշգրիտ և տեղեկատվական պատասխաններ:

Ինչու՞ օգտագործել RAG-ը FastAPI-ի և Django-ի հետ:

FastAPI-ն և Django-ն ամենահայտնի վեբ շրջանակներից երկուսն են, որոնք օգտագործվում են վեբ հավելվածներ ստեղծելու համար: Նրանք ապահովում են ամուր և մասշտաբային ենթակառուցվածք՝ վեբ հավելվածներ ստեղծելու համար և կարող են հեշտությամբ ինտեգրվել RAG տեխնիկայի հետ՝ LLM-ի հնարավորությունները բարձրացնելու համար: FastAPI-ն ժամանակակից վեբ շրջանակ է, որն ապահովում է վեբ հավելվածներ ստեղծելու արագ և արդյունավետ միջոց, մինչդեռ Django-ն բարձր մակարդակի վեբ շրջանակ է, որն ապահովում է ճարտարապետություն, ձևանմուշներ և API-ներ՝ ամուր վեբ հավելվածներ ստեղծելու համար:

RAG-ի իրականացում FastAPI-ով

FastAPI-ն ապահովում է RAG տեխնիկայի իրականացման պարզ և արդյունավետ միջոց: Ահա կոդերի բլոկի օրինակ, որը ցույց է տալիս, թե ինչպես օգտագործել FastAPI RAG-ն իրականացնելու համար.

«Պիթոն». fastapi ներմուծման FastAPI-ից langchain import LLMCchain-ից langchain.chains.openai-ից ներմուծել OpenAIApi

հավելված = FastAPI ()

@app.get ("/rag") async def rag (հարցում՝ str):

llm_chain = LLMCchain (
    llm=OpenAIApi(),
    retrieval=LangChainRetrieval(
        ինդեքս=LangChainIndex(
            անուն = "my_index",
            փաստաթղթեր=["doc1", "doc2", "doc3"]
        )
    )
)

# Ստեղծեք պատասխան՝ օգտագործելով LLM շղթան
պատասխան = llm_chain.run (հարցում)

վերադարձ {"response": answer}

Այս օրինակում մենք սահմանում ենք LLM շղթա՝ օգտագործելով «LLMChain» դասը LangChain-ից: Այնուհետև մենք սահմանում ենք որոնման բաղադրիչ՝ օգտագործելով «LangChainRetrieval» դասը, որն օգտագործվում է գիտելիքների բազայից կամ տվյալների բազայից համապատասխան տեղեկատվություն առբերելու համար: Ի վերջո, մենք օգտագործում ենք «run» մեթոդը՝ LLM շղթայի միջոցով պատասխան ստեղծելու համար:

**RAG-ի իրականացում Django-ի հետ**


Django-ն ապահովում է բարձր մակարդակի վեբ շրջանակ, որը կարող է հեշտությամբ ինտեգրվել RAG տեխնիկայի հետ: Ահա կոդերի բլոկի օրինակ, որը ցույց է տալիս, թե ինչպես օգտագործել Django-ն RAG-ն իրականացնելու համար.

«Պիթոն».
django.http-ից ներմուծել JsonResponse
langchain import LLMCchain-ից
langchain.chains.openai-ից ներմուծել OpenAIApi

def rag (խնդրանք):
    # Սահմանեք LLM շղթան
    llm_chain = LLMCchain (
        llm=OpenAIApi(),
        retrieval=LangChainRetrieval(
            ինդեքս=LangChainIndex(
                անուն = "my_index",
                փաստաթղթեր=["doc1", "doc2", "doc3"]
            )
        )
    )

    # Ստեղծեք պատասխան՝ օգտագործելով LLM շղթան
    answer = llm_chain.run(request.GET.get(«հարցում»))

    վերադարձնել JsonResponse ({"response": answer})

Այս օրինակում մենք սահմանում ենք «rag» դիտման ֆունկցիա, որը ընդունում է հարցումը որպես մուտքագրում և առաջացնում է պատասխան՝ օգտագործելով LLM շղթան:

RAG-ի կազմակերպում LangChain-ի հետ

LangChain-ն ապահովում է RAG տեխնիկան կազմակերպելու պարզ և արդյունավետ միջոց: Ահա կոդերի բլոկի օրինակ, որը ցույց է տալիս, թե ինչպես օգտագործել LangChain-ը RAG-ը կազմակերպելու համար.

«Պիթոն». langchain import LLMCchain-ից langchain.chains.openai-ից ներմուծել OpenAIApi

Սահմանեք LLM շղթան

llm_chain = LLMCchain ( llm=OpenAIApi(), retrieval=LangChainRetrieval( ինդեքս=LangChainIndex( անուն = "my_index", փաստաթղթեր=["doc1", "doc2", "doc3"] ) ) )

Ստեղծեք պատասխան՝ օգտագործելով LLM շղթան

answer = llm_chain.run («Ի՞նչ է RAG-ը»:)

տպել (պատասխան)

Այս օրինակում մենք սահմանում ենք LLM շղթա՝ օգտագործելով «LLMChain» դասը LangChain-ից: Այնուհետև մենք օգտագործում ենք «run» մեթոդը՝ LLM շղթայի միջոցով պատասխան ստեղծելու համար:

**Թոփ 5-10 ամենաշատ օգտագործվող հրամաններ/հատվածներ**


Ահա FastAPI-ի և Django-ի հետ RAG-ի իրականացման համար ամենաշատ օգտագործվող 5-10 հրամանները/հատվածները.

1. «langchain import LLMChain»-ից. ներմուծեք «LLMChain» դասը LangChain-ից:
2. `llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", document=["doc1", "doc2", "doc3"])))": Սահմանեք LLM շղթա՝ օգտագործելով `LLMCha
3. «response = llm_chain.run(query)»: Ստեղծեք պատասխան՝ օգտագործելով LLM շղթան:
4. «from fastapi import FastAPI». ներմուծեք «FastAPI» դասը FastAPI-ից:
5. «app = FastAPI()»: Սահմանեք FastAPI հավելված:
6. «@app.get(«/rag»)»: Սահմանեք երթուղի RAG վերջնակետի համար:
7. `llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", document=["doc1", "doc2", "doc3"])))`. Սահմանեք LLM շղթա՝ օգտագործելով «LLMCha» դասը
8. «response = llm_chain.run(query)»: Ստեղծեք պատասխան՝ օգտագործելով LLM շղթան:
9. «from django.http import JsonResponse»: Ներմուծեք «JsonResponse» դասը Django-ից:
10. `return JsonResponse({"response": answer})`. վերադարձրեք JSON պատասխանը ստեղծված պատասխանով:

**Վիզուալիզացիա**


Ահա RAG խողովակաշարի պատկերացում՝ օգտագործելով Chart.js.

```ջսոն
{
  "տեսակ": "horizontalBar",
  "տվյալներ": {
    «պիտակներ»՝ [«Առբերում», «Սերունդ», «Հետմշակում»],
    «տվյալների հավաքածուներ»:
      {
        «պիտակ»՝ «RAG Pipeline»,
        «տվյալներ»: [10, 20, 30],
        "backgroundColor":
          «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 Pipeline"
    },
    «կշեռքներ»: {
      «yAxes»:
        {
          "ticks": {
            «beginAtZero»: ճիշտ է
          }
        }
      ]
    }
  }
}

Այս վիզուալիզացիան ցույց է տալիս RAG խողովակաշարը երեք փուլով` որոնում, արտադրություն և հետմշակում:

Եզրակացություն

Այս հոդվածում մենք ուսումնասիրեցինք RAG տեխնիկայի իրականացումը, օգտագործելով FastAPI-ն և Django-ն՝ վեբ հավելվածներում LLM-ի հնարավորությունները բարելավելու համար, ներառյալ LangChain-ի հետ կազմակերպումը տվյալների անխափան որոնման և մշակման համար: Մենք նաև տրամադրեցինք գործնական ուղեցույց RAG-ի իրականացման համար FastAPI-ի և Django-ի հետ, ներառյալ կոդերի օրինակները և RAG խողովակաշարի արտացոլումը: Հուսով ենք, որ այս հոդվածը օգտակար ռեսուրս է տրամադրել ծրագրավորողների համար, ովքեր ցանկանում են կիրառել RAG տեխնիկան իրենց վեբ հավելվածներում: