Integreiddio RAG (Cenhedlaeth Adalw-Ychwanegol) â Fframweithiau Gwe Modern: Canllaw Ymarferol

Cyflwyniad

Yn ystod y blynyddoedd diwethaf, mae maes Prosesu Iaith Naturiol (NLP) wedi gweld ymchwydd sylweddol yn natblygiad Modelau Iaith Mawr (LLMs) a'u cymwysiadau mewn gwahanol beuoedd. Fodd bynnag, un o brif gyfyngiadau LLMs yw eu hanallu i adalw ac ymgorffori gwybodaeth allanol yn eu hymatebion. Dyma lle mae technegau Adalw-Cynhyrchu Cynydd (RAG) yn dod i rym. Yn yr erthygl hon, byddwn yn archwilio gweithrediad technegau RAG gan ddefnyddio FastAPI a Django i wella galluoedd LLM mewn cymwysiadau gwe, gan gynnwys offeryniaeth gyda LangChain ar gyfer adfer a phrosesu data di-dor.

Beth yw RAG?

Mae RAG yn dechneg sy'n cyfuno cryfderau modelau Adalw a Chynhyrchu i gynhyrchu ymatebion mwy cywir ac addysgiadol. Y syniad sylfaenol y tu ôl i RAG yw adalw gwybodaeth berthnasol yn gyntaf o sylfaen wybodaeth neu gronfa ddata, ac yna defnyddio'r wybodaeth hon i gynhyrchu ymateb. Mae'r dull hwn yn galluogi LLMs i drosoli gwybodaeth allanol a darparu ymatebion mwy cywir ac addysgiadol.

Pam Defnyddio RAG gyda FastAPI a Django?

Mae FastAPI a Django yn ddau o'r fframweithiau gwe mwyaf poblogaidd a ddefnyddir ar gyfer adeiladu cymwysiadau gwe. Maent yn darparu seilwaith cadarn a graddadwy ar gyfer adeiladu cymwysiadau gwe, a gellir eu hintegreiddio'n hawdd â thechnegau RAG i wella galluoedd LLM. Mae FastAPI yn fframwaith gwe modern sy'n darparu ffordd gyflym ac effeithlon o adeiladu cymwysiadau gwe, tra bod Django yn fframwaith gwe lefel uchel sy'n darparu pensaernïaeth, templedi, ac APIs ar gyfer adeiladu cymwysiadau gwe cadarn.

Gweithredu RAG gyda FastAPI

Mae FastAPI yn darparu ffordd syml ac effeithlon o weithredu technegau RAG. Dyma enghraifft o floc cod sy'n dangos sut i ddefnyddio FastAPI i weithredu RAG:

o fastapi mewnforio FastAPI
o fewnforio langchain LLMChain
o langchain.chains.openai mewnforio OpenAIApi

ap = FastAPI()

@app.get ("/rag")
async def rag (ymholiad: str):
    
    llm_chain = LLMChain(
        llm=AgoredAIApi(),
        retrieval=Adalw LangChain(
            index=LangChainIndex(
                name="fy_mynegai",
                dogfennau=["doc1", "doc2", "doc3"]
            )
        )
    )

    # Cynhyrchu ymateb gan ddefnyddio'r gadwyn LLM
    ymateb = llm_chain.run(ymholiad)

    dychwelyd { "response" : ymateb}

Yn yr enghraifft hon, rydym yn diffinio cadwyn LLM gan ddefnyddio'r dosbarth LLMChain o LangChain. Yna rydym yn diffinio cydran adalw gan ddefnyddio'r dosbarth LangChainRetrieval, a ddefnyddir i adalw gwybodaeth berthnasol o sylfaen wybodaeth neu gronfa ddata. Yn olaf, rydym yn defnyddio'r dull rhedeg i gynhyrchu ymateb gan ddefnyddio'r gadwyn LLM.

Gweithredu RAG gyda Django

Mae Django yn darparu fframwaith gwe lefel uchel y gellir ei integreiddio'n hawdd â thechnegau RAG. Dyma enghraifft o floc cod sy'n dangos sut i ddefnyddio Django i weithredu RAG:

o django.http mewnforio JsonResponse
o fewnforio langchain LLMChain
o langchain.chains.openai mewnforio OpenAIApi

def rag (cais):
    # Diffiniwch y gadwyn LLM
    llm_chain = LLMChain(
        llm=AgoredAIApi(),
        retrieval=Adalw LangChain(
            index=LangChainIndex(
                name="fy_mynegai",
                dogfennau=["doc1", "doc2", "doc3"]
            )
        )
    )

    # Cynhyrchu ymateb gan ddefnyddio'r gadwyn LLM
    ymateb = llm_chain.run(request.GET.get("ymholiad"))

    dychwelyd JsonResponse({ "ymateb": ymateb})

Yn yr enghraifft hon, rydym yn diffinio swyddogaeth gweld rag sy'n cymryd ymholiad fel mewnbwn ac yn cynhyrchu ymateb gan ddefnyddio'r gadwyn LLM.

Cerddorfa RAG gyda LangChain

Mae LangChain yn darparu ffordd syml ac effeithlon o drefnu technegau RAG. Dyma enghraifft o floc cod sy'n dangos sut i ddefnyddio LangChain i drefnu RAG:

o fewnforio langchain LLMChain
o langchain.chains.openai mewnforio OpenAIApi

# Diffiniwch y gadwyn LLM
llm_chain = LLMChain(
    llm=AgoredAIApi(),
    retrieval=Adalw LangChain(
        index=LangChainIndex(
            name="fy_mynegai",
            dogfennau=["doc1", "doc2", "doc3"]
        )
    )
)

# Cynhyrchu ymateb gan ddefnyddio'r gadwyn LLM
ymateb = llm_chain.run("Beth yw RAG?")

argraffu (ymateb)

Yn yr enghraifft hon, rydym yn diffinio cadwyn LLM gan ddefnyddio'r dosbarth LLMChain o LangChain. Yna byddwn yn defnyddio'r dull rhedeg i gynhyrchu ymateb gan ddefnyddio'r gadwyn LLM.

Y 5-10 Gorchymyn/Pytiau a Ddefnyddir Fwyaf

Dyma'r 5-10 gorchymyn / pytiau a ddefnyddir fwyaf ar gyfer gweithredu RAG gyda FastAPI a Django:

1. o langchain import LLMChain: Mewnforio'r dosbarth LLMChain o LangChain.
2. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): Diffiniwch gadwyn LLM gan ddefnyddio'r dosbarth LLMChain.
3. response = llm_chain.run(query): Cynhyrchu ymateb gan ddefnyddio'r gadwyn LLM.
4. o fastapi mewnforio FastAPI: Mewnforio'r dosbarth FastAPI o FastAPI.
5. app = FastAPI(): Diffiniwch gymhwysiad FastAPI.
6. @app.get("/rag"): Diffiniwch lwybr ar gyfer y diweddbwynt RAG.
7. llm_chain = LLMChain(llm=OpenAIApi(), retrieval=LangChainRetrieval(index=LangChainIndex(name="my_index", documents=["doc1", "doc2", "doc3"]))): Diffiniwch gadwyn LLM gan ddefnyddio'r dosbarth LLMChain.
8. response = llm_chain.run(query): Cynhyrchu ymateb gan ddefnyddio'r gadwyn LLM.
9. o django.http mewnforio JsonResponse: Mewnforio'r dosbarth JsonResponse o Django.
10. dychwelyd JsonResponse({"response": response}): Dychwelyd ymateb JSON gyda'r ymateb a gynhyrchwyd.

ddelweddu

Dyma ddelwedd o'r biblinell RAG gan ddefnyddio Chart.js:

{
  "math": "Bar llorweddol",
  "data": {
    " : " labels " : [ " Adalw " , " Generation " " , " Ôl-brosesu "],
    "setiau data": [
      {
        " label " : " Piblinell RAG " ,
        "data": [10, 20, 30],
        "Lliw cefndir": [
          "rgb(255, 99, 132, 0.2)",
          "rgb(54, 162, 235, 0.2)",
          "rgb(255, 206, 86, 0.2)"
        ],
        "Lliw ffin": [
          "rgb(255, 99, 132, 1)",
          "rgb(54, 162, 235, 1)",
          "rgb(255, 206, 86, 1)"
        ],
        "Lled y ffin": 1
      }
    ]
  },
  "opsiynau": {
    "title": {
      "arddangos": gwir,
      "text": "Piblinell RAG"
    },
    "graddfeydd": {
      "yEchelin": [
        {
          "ticiau": {
            "dechrau AtZero": gwir
          }
        }
      ]
    }
  }
}

Mae'r delweddu hwn yn dangos y biblinell RAG gyda thri cham: adalw, cynhyrchu ac ôl-brosesu.

Casgliad

Yn yr erthygl hon, fe wnaethom archwilio gweithrediad technegau RAG gan ddefnyddio FastAPI a Django i wella galluoedd LLM mewn cymwysiadau gwe, gan gynnwys offeryniaeth gyda LangChain ar gyfer adfer a phrosesu data di-dor. Fe wnaethom hefyd ddarparu canllaw ymarferol ar gyfer gweithredu RAG gyda FastAPI a Django, gan gynnwys enghreifftiau cod a delweddiad o'r biblinell RAG. Gobeithiwn fod yr erthygl hon wedi darparu adnodd defnyddiol i ddatblygwyr sydd am roi technegau RAG ar waith yn eu rhaglenni gwe.