ការរួមបញ្ចូល RAG ជាមួយ LLMs សម្រាប់ដំណើរការការងារអភិវឌ្ឍន៍កម្មវិធីដែលប្រសើរឡើង

សេចក្តីផ្តើម

ទិដ្ឋភាពនៃការអភិវឌ្ឍន៍កម្មវិធីកំពុងវិវឌ្ឍយ៉ាងឆាប់រហ័ស ដែលជំរុញដោយភាពជឿនលឿននៃបញ្ញាសិប្បនិម្មិត (AI) ការរៀនម៉ាស៊ីន (ML) និងដំណើរការភាសាធម្មជាតិ (NLP)។ បច្ចេកវិទ្យាសំខាន់ពីរដែលកំពុងធ្វើបដិវត្តវិធីដែលយើងបង្កើតកម្មវិធីគឺ Retrieval-Augmented Generation (RAG) និង Large Language Models (LLMs)។ នៅក្នុងអត្ថបទនេះ យើងនឹងស្វែងយល់ពីការរួមបញ្ចូល RAG ជាមួយ LLMs ដើម្បីសម្រួលដំណើរការវិស្វកម្មផ្នែកទន់ កែលម្អការបង្កើតកូដ និងបង្កើនផលិតភាពរបស់អ្នកអភិវឌ្ឍន៍។

** អ្វីទៅជា Retrieval-augmented Generation (RAG)?**

RAG គឺជាបច្ចេកទេសមួយដែលរួមបញ្ចូលគ្នានូវភាពខ្លាំងនៃវិធីសាស្រ្តដែលមានមូលដ្ឋានលើការទាញយក និងផ្អែកលើជំនាន់ទៅ NLP ។ វាពាក់ព័ន្ធនឹងការទាញយកព័ត៌មានដែលពាក់ព័ន្ធពីសារពាង្គកាយដ៏ធំនៃអត្ថបទ ហើយប្រើវាដើម្បីបង្កើនការបង្កើតអត្ថបទថ្មី។ វិធីសាស្រ្តនេះត្រូវបានបង្ហាញថាមានប្រសិទ្ធភាពខ្ពស់ក្នុងកិច្ចការផ្សេងៗរបស់ NLP រួមទាំងការឆ្លើយសំណួរ ការសង្ខេបអត្ថបទ និងការបង្កើតកូដ។

** តើអ្វីជាគំរូភាសាធំ (LLMs)?**

LLMs គឺជាប្រភេទនៃបណ្តាញសរសៃប្រសាទដែលត្រូវបានរចនាឡើងដើម្បីដំណើរការ និងបង្កើតភាសាដូចមនុស្ស។ ពួកវាជាធម្មតាត្រូវបានបណ្តុះបណ្តាលលើសំណុំទិន្នន័យដ៏ធំនៃអត្ថបទ ហើយអាចត្រូវបានកែសម្រួលយ៉ាងល្អសម្រាប់កិច្ចការជាក់លាក់ដូចជាការបកប្រែភាសា ការសង្ខេបអត្ថបទ និងការបង្កើតកូដ។ LLMs សម្រេចបានលទ្ធផលទាន់សម័យក្នុងកិច្ចការ NLP ជាច្រើន ហើយត្រូវបានប្រើប្រាស់យ៉ាងទូលំទូលាយនៅក្នុងកម្មវិធីដូចជា chatbots ជំនួយការនិម្មិត និងប្រព័ន្ធបកប្រែភាសា។

ឧបករណ៍ Orchestration៖ LangChain និង DSPy

ដើម្បីរួមបញ្ចូល RAG ជាមួយ LLMs យើងត្រូវការឧបករណ៍ orchestration ដែលអាចគ្រប់គ្រងលំហូរទិន្នន័យ និងគ្រប់គ្រងការប្រតិបត្តិនៃសមាសធាតុ RAG និង LLM ។ ឧបករណ៍ orchestration ដ៏ពេញនិយមពីរដែលអាចប្រើបានសម្រាប់គោលបំណងនេះគឺ LangChain និង DSPy ។

LangChain

LangChain គឺជាបណ្ណាល័យ Python ប្រភពបើកចំហដែលផ្តល់នូវ API ដ៏សាមញ្ញ និងវិចារណញាណសម្រាប់បង្កើតកម្មវិធីដែលមានមូលដ្ឋានលើ RAG ។ វាអនុញ្ញាតឱ្យអ្នកអភិវឌ្ឍន៍បញ្ចូល RAG យ៉ាងងាយស្រួលជាមួយ LLMs និងសមាសធាតុ NLP ផ្សេងទៀតដើម្បីបង្កើតលំហូរការងារអភិវឌ្ឍន៍កម្មវិធីដ៏មានឥទ្ធិពល។

DSPy

DSPy គឺជាបណ្ណាល័យ Python ប្រភពបើកចំហមួយផ្សេងទៀតដែលផ្តល់ API កម្រិតខ្ពស់សម្រាប់បង្កើតកម្មវិធីដែលមានមូលដ្ឋានលើ RAG ។ វាត្រូវបានរចនាឡើងដើម្បីធ្វើការយ៉ាងរលូនជាមួយ LLMs និងសមាសធាតុ NLP ផ្សេងទៀត ដែលធ្វើឱ្យវាក្លាយជាជម្រើសដ៏ល្អសម្រាប់ការរួមបញ្ចូល RAG ជាមួយ LLMs ។

**ឧទាហរណ៍កូដ៖ ការរួមបញ្ចូល RAG ជាមួយ LLMs ដោយប្រើ LangChain **

នេះគឺជាឧទាហរណ៍កូដសាមញ្ញដែលបង្ហាញពីរបៀបរួមបញ្ចូល RAG ជាមួយ LLMs ដោយប្រើ LangChain៖ ``ពស់ថ្លាន់ នាំចូល langchain ពី langchain.chains នាំចូល RAGChain

rag_model = langchain.RAG( index=langchain.Index( name="my_index", ឯកសារ =["document1", "document2", "document3"], ) retriever=langchain.Retriever( name="my_retriever", model="my_retriever_model", ) generator=langchain.Generator( name="my_generator", model="my_generator_model", ) )

កំណត់គំរូ LLM

llm_model = langchain.LLM( name="my_llm", model="my_llm_model", )

បង្កើតខ្សែសង្វាក់ RAG

rag_chain = RAGChain( name="my_rag_chain", model=rag_model, llm=llm_គំរូ, )

ប្រើខ្សែសង្វាក់ RAG ដើម្បីបង្កើតកូដ

កូដ = rag_chain.generate( input_text="សរសេរអនុគមន៍ដែលយកចំនួនគត់ពីរជាការបញ្ចូល ហើយត្រឡប់ផលបូករបស់វា", )

បោះពុម្ព (កូដ)

ឧទាហរណ៍កូដនេះបង្ហាញពីរបៀបកំណត់គំរូ RAG ដោយប្រើ LangChain កំណត់គំរូ LLM បង្កើតខ្សែសង្វាក់ RAG និងប្រើខ្សែសង្វាក់ដើម្បីបង្កើតកូដ។

** កំពូល 5-10 ពាក្យបញ្ជា / អត្ថបទដែលប្រើច្រើនបំផុត **

នេះគឺជា 5-10 ពាក្យបញ្ជាដែលប្រើច្រើនជាងគេបំផុតសម្រាប់ការរួមបញ្ចូល RAG ជាមួយ LLMs ដោយប្រើ LangChain និង DSPy៖

1. `langchain.RAG()`: បង្កើតគំរូគំរូ RAG ។
2. `langchain.Index()`៖ បង្កើតសន្ទស្សន៍សម្រាប់រក្សាទុក និងទាញយកឯកសារ។
3. `langchain.Retriever()`៖ បង្កើតឧទាហរណ៍សម្រាប់ទាញយកឯកសារពាក់ព័ន្ធ។
4. `langchain.Generator()`: បង្កើត generator instance សម្រាប់បង្កើតអត្ថបទថ្មី។
5. `langchain.LLM()`: បង្កើតឧទាហរណ៍គំរូ LLM ។
6. `RAGChain()`: បង្កើតឧទាហរណ៍ខ្សែសង្វាក់ RAG ។
7. `rag_chain.generate()`៖ ប្រើខ្សែសង្វាក់ RAG ដើម្បីបង្កើតកូដ។
8. `llm_model.generate()`៖ ប្រើគំរូ LLM ដើម្បីបង្កើតកូដ។
9. `index.add_document()`៖ បន្ថែមឯកសារទៅលិបិក្រម។
10. `retriever.retrieve()`: ទាញយកឯកសារពាក់ព័ន្ធដោយប្រើឧបករណ៍ទាញយក។

** ការមើលឃើញ **

នេះគឺជាការមើលឃើញនៃសមាសធាតុ RAG និង LLM ដោយប្រើ Chart.js៖
```json
{
  "type": "របារ",
  "ទិន្នន័យ"៖ {
    "ស្លាក": ["RAG", "LLM"],
    "សំណុំទិន្នន័យ": [
      {
        "label": "សមាសធាតុ",
        "ទិន្នន័យ": [10, 20],
        "backgroundColor": ["#4CAF50", "#FF9800"]
      }
    ]
  },
  "ជម្រើស"៖ {
    "ចំណងជើង"៖ {
      "បង្ហាញ": ពិត,
      "text": "សមាសធាតុ RAG និង LLM"
    },
    "មាត្រដ្ឋាន"៖ {
      "yAxes": [
        {
          "បង្ហាញ": ពិត,
          "beginAtZero"៖ ពិត
        }
      ]
    }
  }
}

ការមើលឃើញនេះបង្ហាញពីចំនួនសមាសធាតុនៅក្នុងគំរូ RAG និង LLM ។

សេចក្តីសន្និដ្ឋាន

ការរួមបញ្ចូលគ្នានៃ RAG ជាមួយ LLMs មានសក្តានុពលក្នុងការធ្វើបដិវត្តន៍វិធីដែលយើងបង្កើតកម្មវិធី។ ដោយរួមបញ្ចូលគ្នានូវភាពខ្លាំងនៃវិធីសាស្រ្តផ្អែកលើការទាញយក និងផ្អែកលើជំនាន់ RAG អាចជួយ LLMs ដើម្បីបង្កើតកូដដែលត្រឹមត្រូវ និងពាក់ព័ន្ធបន្ថែមទៀត។ នេះអាចនាំឱ្យមានការកែលម្អយ៉ាងសំខាន់នៅក្នុងផលិតភាពរបស់អ្នកអភិវឌ្ឍន៍ គុណភាពកូដ និងដំណើរការការងារអភិវឌ្ឍន៍កម្មវិធីទាំងមូល។ ជាមួយនឹងឧបករណ៍ orchestration ដូចជា LangChain និង DSPy អ្នកអភិវឌ្ឍន៍អាចរួមបញ្ចូល RAG យ៉ាងងាយស្រួលជាមួយ LLMs និងសមាសធាតុ NLP ផ្សេងទៀតដើម្បីបង្កើតលំហូរការងារអភិវឌ្ឍន៍កម្មវិធីដ៏មានឥទ្ធិពល។

ការរួមបញ្ចូល RAG ជាមួយ LLMs សម្រាប់ដំណើរការការងារអភិវឌ្ឍន៍កម្មវិធីដែលប្រសើរឡើង

កំណត់គំរូ LLM

បង្កើតខ្សែសង្វាក់ RAG

ប្រើខ្សែសង្វាក់ RAG ដើម្បីបង្កើតកូដ

Have Questions?