បង្កើតប្រព័ន្ធកម្មវិធីព្យាបាលដោយខ្លួនឯងជាមួយនឹងស្ថាបត្យកម្ម AI ភ្នាក់ងារចម្រុះ និង LangChain

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

នៅក្នុងទិដ្ឋភាពនៃការអភិវឌ្ឍន៍កម្មវិធីដែលមានល្បឿនលឿននាពេលបច្ចុប្បន្ននេះ ការកសាងប្រព័ន្ធសូហ្វវែរព្យាបាលដោយខ្លួនឯងបានក្លាយទៅជាតម្រូវការដ៏សំខាន់សម្រាប់ធានានូវភាពជឿជាក់ មាត្រដ្ឋាន និងភាពធន់នៃប្រព័ន្ធកម្មវិធីស្មុគស្មាញ។ ស្ថាបត្យកម្ម monolithic ប្រពៃណីលែងគ្រប់គ្រាន់ដើម្បីបំពេញតម្រូវការនៃការអភិវឌ្ឍន៍កម្មវិធីទំនើប ដែលប្រព័ន្ធត្រូវតែអាចសម្របខ្លួនទៅនឹងតម្រូវការផ្លាស់ប្តូរ ដោះស្រាយការបរាជ័យដែលមិនបានរំពឹងទុក និងងើបឡើងវិញពីកំហុសយ៉ាងឆាប់រហ័ស។ នេះគឺជាកន្លែងដែលស្ថាបត្យកម្ម AI ច្រើនភ្នាក់ងារ និង LangChain ចូលមកលេង ដោយផ្តល់នូវដំណោះស្រាយដ៏មានអានុភាពសម្រាប់ការកសាងប្រព័ន្ធកម្មវិធីព្យាបាលដោយខ្លួនឯងដែលអាចរៀន សម្របខ្លួន និងឆ្លើយតបទៅនឹងការផ្លាស់ប្តូរលក្ខខណ្ឌ។

តើស្ថាបត្យកម្ម AI ពហុភ្នាក់ងារជាអ្វី?

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

នៅក្នុងបរិបទនៃប្រព័ន្ធសូហ្វវែរ ស្ថាបត្យកម្ម AI ពហុភ្នាក់ងារអាចត្រូវបានប្រើដើម្បីបង្កើតប្រព័ន្ធព្យាបាលដោយខ្លួនឯងដែលអាចរកឃើញ និងឆ្លើយតបចំពោះកំហុស ការបរាជ័យ និងភាពមិនប្រក្រតីផ្សេងទៀតក្នុងពេលវេលាជាក់ស្តែង។ តាមរយៈការចែកចាយដំណើរការធ្វើការសម្រេចចិត្តនៅទូទាំងភ្នាក់ងារជាច្រើន ប្រព័ន្ធទាំងនេះអាចរៀនពីបទពិសោធន៍ សម្របខ្លួនទៅនឹងលក្ខខណ្ឌនៃការផ្លាស់ប្តូរ និងងើបឡើងវិញពីកំហុសយ៉ាងឆាប់រហ័ស។

LangChain ជាអ្វី?

LangChain គឺជាបណ្ណាល័យ Python ប្រភពបើកចំហសម្រាប់បង្កើតប្រព័ន្ធ AI ពហុភ្នាក់ងារ។ វាផ្តល់នូវក្របខ័ណ្ឌសាមញ្ញ បត់បែន និងអាចធ្វើមាត្រដ្ឋានបានសម្រាប់ការកសាងប្រព័ន្ធ AI ដ៏ស្មុគស្មាញដែលអាចរៀន សម្របខ្លួន និងឆ្លើយតបទៅនឹងលក្ខខណ្ឌផ្លាស់ប្តូរ។ LangChain ត្រូវបានរចនាឡើងដើម្បីធ្វើការជាមួយក្របខ័ណ្ឌ AI ដ៏ធំទូលាយ រួមទាំង TensorFlow, PyTorch និង Keras ហើយអាចត្រូវបានប្រើដើម្បីបង្កើតប្រព័ន្ធដែលរួមបញ្ចូលជាមួយប្រភពទិន្នន័យជាច្រើន រួមទាំងមូលដ្ឋានទិន្នន័យ APIs និងឧបករណ៍ IoT ។

បង្កើតប្រព័ន្ធកម្មវិធីព្យាបាលដោយខ្លួនឯងជាមួយ LangChain

ដើម្បីបង្កើតប្រព័ន្ធកម្មវិធីព្យាបាលដោយខ្លួនឯងជាមួយ LangChain យើងត្រូវរចនាស្ថាបត្យកម្ម AI ភ្នាក់ងារចម្រុះ ដែលអាចរកឃើញ និងឆ្លើយតបចំពោះកំហុស ការបរាជ័យ និងភាពមិនប្រក្រតីផ្សេងៗក្នុងពេលវេលាជាក់ស្តែង។ នេះជាទិដ្ឋភាពទូទៅកម្រិតខ្ពស់នៃស្ថាបត្យកម្ម៖

ការរចនាភ្នាក់ងារ៖ យើងត្រូវរចនាសំណុំនៃភ្នាក់ងារស្វយ័ត ដែលអាចធ្វើអន្តរកម្មគ្នាទៅវិញទៅមក និងបរិស្ថានរបស់ពួកគេ ដើម្បីសម្រេចបាននូវគោលដៅរួមមួយ។ ភ្នាក់ងារនីមួយៗគួរតែមានសមត្ថភាពធ្វើការសម្រេចចិត្ត ចំណេះដឹង និងធនធានផ្ទាល់ខ្លួន។
Knowledge Graph: យើងត្រូវបង្កើតក្រាហ្វចំណេះដឹងដែលតំណាងឱ្យទំនាក់ទំនងរវាងភ្នាក់ងារ បរិស្ថាន និងគោលដៅនៃប្រព័ន្ធ។ ក្រាហ្វនេះអាចត្រូវបានប្រើដើម្បីវែកញែកអំពីស្ថានភាពនៃប្រព័ន្ធ និងធ្វើការសម្រេចចិត្ត។
Decision-Making: យើងត្រូវអនុវត្តដំណើរការធ្វើការសម្រេចចិត្តដែលអនុញ្ញាតឱ្យភ្នាក់ងារវែកញែកអំពីស្ថានភាពនៃប្រព័ន្ធ និងធ្វើការសម្រេចចិត្តដោយផ្អែកលើក្រាហ្វចំណេះដឹង។
ការប្រតិបត្តិសកម្មភាព៖ យើងត្រូវអនុវត្តដំណើរការប្រតិបត្តិសកម្មភាពដែលអនុញ្ញាតឱ្យភ្នាក់ងារអនុវត្តការសម្រេចចិត្តរបស់ពួកគេ និងធ្វើអន្តរកម្មជាមួយបរិស្ថាន។

នេះគឺជាឧទាហរណ៍ដ៏សាមញ្ញមួយនៃប្រព័ន្ធសូហ្វវែរព្យាបាលដោយខ្លួនឯងដែលបង្កើតឡើងដោយ LangChain៖ ``ពស់ថ្លាន់ នាំចូល langchain ពី langchain.agents ភ្នាក់ងារនាំចូល ពី langchain.llms នាំចូល LLM

ក្រាហ្វ = { 'ភ្នាក់ងារ'៖ ['ភ្នាក់ងារ ១', 'ភ្នាក់ងារ២', 'ភ្នាក់ងារ៣'], 'បរិស្ថាន'៖ ['មូលដ្ឋានទិន្នន័យ', 'API', 'ឧបករណ៍ IoT'], 'គោលដៅ': ['រកឃើញកំហុស', 'ឆ្លើយតបទៅនឹងការបរាជ័យ', 'ងើបឡើងវិញពីកំហុស'] }

កំណត់ដំណើរការធ្វើការសម្រេចចិត្ត

def decision_making(ភ្នាក់ងារ, knowledge_graph)៖ # ហេតុផលអំពីស្ថានភាពនៃប្រព័ន្ធ state = knowledge_graph['agents'][agent] # ធ្វើការសម្រេចចិត្តដោយផ្អែកលើរដ្ឋ ការសម្រេចចិត្ត = 'ឆ្លើយតបទៅនឹងការបរាជ័យ' ការសម្រេចចិត្តត្រឡប់មកវិញ

កំណត់ដំណើរការអនុវត្តសកម្មភាព

def action_execution (ភ្នាក់ងារ ការសម្រេចចិត្ត)៖ # អនុវត្តការសម្រេចចិត្ត ប្រសិនបើការសម្រេចចិត្ត == 'ឆ្លើយតបទៅនឹងការបរាជ័យ': #ឆ្លើយតបទៅនឹងការបរាជ័យ បោះពុម្ព ('ឆ្លើយតបទៅនឹងការបរាជ័យ...') ត្រឡប់មកវិញ

បង្កើតភ្នាក់ងារ LangChain

ភ្នាក់ងារ = ភ្នាក់ងារ ( name='ភ្នាក់ងារព្យាបាលដោយខ្លួនឯង', decision_making=ការសម្រេចចិត្ត, action_execution=ប្រតិបត្តិការ_ប្រតិបត្តិ, knowledge_graph=ក្រាហ្វ )

បង្កើត LangChain LLM

llm = LLM( name='ការព្យាបាលដោយខ្លួនឯង-llm', model='ដាវីនស៊ី' )

បង្កើតប្រព័ន្ធ LangChain

ប្រព័ន្ធ = langchain.System( agent=ភ្នាក់ងារ, llm=llm )

ដំណើរការប្រព័ន្ធ

system.run()

ឧទាហរណ៍នេះបង្ហាញពីប្រព័ន្ធសូហ្វវែរព្យាបាលដោយខ្លួនឯងសាមញ្ញ ដែលអាចរកឃើញកំហុស ឆ្លើយតបទៅនឹងការបរាជ័យ និងងើបឡើងវិញពីកំហុសបានយ៉ាងឆាប់រហ័ស។ ប្រព័ន្ធនេះមានសំណុំនៃភ្នាក់ងារស្វយ័តដែលមានអន្តរកម្មគ្នាទៅវិញទៅមក និងបរិយាកាសរបស់ពួកគេដើម្បីសម្រេចបាននូវគោលដៅរួមមួយ។ ភ្នាក់ងារប្រើប្រាស់ក្រាហ្វចំណេះដឹងដើម្បីវែកញែកអំពីស្ថានភាពនៃប្រព័ន្ធ និងធ្វើការសម្រេចចិត្តដោយផ្អែកលើក្រាហ្វ។

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

នេះគឺជាពាក្យបញ្ជាដែលប្រើច្រើនបំផុត 5-10 សម្រាប់ LangChain៖

1. `langchain.Agent()`: បង្កើតភ្នាក់ងារ LangChain ថ្មី។
2. `langchain.LLM()`៖ បង្កើត LangChain LLM ថ្មី។
3. `langchain.System()`៖ បង្កើតប្រព័ន្ធ LangChain ថ្មី។
4. `agent.decision_making()`៖ ដំណើរការដំណើរការធ្វើការសម្រេចចិត្តសម្រាប់ភ្នាក់ងារ។
5. `agent.action_execution()`៖ ដំណើរការដំណើរការប្រតិបត្តិសកម្មភាពសម្រាប់ភ្នាក់ងារ។
6. `llm.predict()`: ធ្វើការទស្សន៍ទាយដោយប្រើ LLM ។
7. `system.run()`: ដំណើរការប្រព័ន្ធ LangChain ។
8. `graph.add_node()`៖ បន្ថែមថ្នាំងថ្មីទៅក្រាហ្វចំណេះដឹង។
9. `graph.add_edge()`៖ បន្ថែមគែមថ្មីទៅក្រាហ្វចំណេះដឹង។
10. `graph.remove_node()`៖ លុបថ្នាំងចេញពីក្រាហ្វចំណេះដឹង។

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

នេះគឺជាការមើលឃើញដ៏សាមញ្ញនៃក្រាហ្វចំណេះដឹងដោយប្រើ Chart.js៖
```json
{
  "type": "ក្រាហ្វ",
  "ទិន្នន័យ"៖ {
    "ថ្នាំង": [
      {"id": "agent1", "label": "ភ្នាក់ងារ 1"},
      {"id": "agent2", "label": "ភ្នាក់ងារ 2"},
      {"id": "agent3", "label": "ភ្នាក់ងារ 3"},
      {"id": "database", "label": "Database"},
      {"id": "API", "label": "API"},
      {"id": "IoT device", "label": "IoT Device"}
    ],
    "គែម": [
      {"source": "agent1", "target": "database"},
      {"source": "agent2", "target": "API"},
      {"source": "agent3", "target": "IoT device"},
      {"source": "agent1", "target": "agent2"},
      {"source": "agent2", "target": "agent3"}
    ]
  },
  "ជម្រើស"៖ {
    "ប្លង់"៖ {
      "type": "រាងជារង្វង់"
    },
    "ថ្នាំង": {
      "ទំហំ": 50
    },
    "គែម": {
      "ទទឹង"៖ ២
    }
  }
}

ការមើលឃើញនេះបង្ហាញពីទំនាក់ទំនងរវាងភ្នាក់ងារ បរិស្ថាន និងគោលដៅនៃប្រព័ន្ធ។

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

ការកសាងប្រព័ន្ធសូហ្វវែរព្យាបាលដោយខ្លួនឯងជាមួយនឹងស្ថាបត្យកម្ម AI ពហុភ្នាក់ងារ ហើយ LangChain ផ្តល់នូវដំណោះស្រាយដ៏មានអានុភាពសម្រាប់ការធានានូវភាពជឿជាក់ មាត្រដ្ឋាន និងភាពធន់នៃប្រព័ន្ធកម្មវិធីស្មុគស្មាញ។ តាមរយៈការចែកចាយដំណើរការធ្វើការសម្រេចចិត្តនៅទូទាំងភ្នាក់ងារជាច្រើន ប្រព័ន្ធទាំងនេះអាចរៀនពីបទពិសោធន៍ សម្របខ្លួនទៅនឹងលក្ខខណ្ឌនៃការផ្លាស់ប្តូរ និងងើបឡើងវិញពីកំហុសយ៉ាងឆាប់រហ័ស។ ជាមួយនឹង LangChain អ្នកអភិវឌ្ឍន៍អាចបង្កើតប្រព័ន្ធ AI ដ៏ស្មុគស្មាញដែលរួមបញ្ចូលជាមួយប្រភពទិន្នន័យជាច្រើន រួមទាំងមូលដ្ឋានទិន្នន័យ APIs និងឧបករណ៍ IoT ។ ដោយធ្វើតាមគំរូកូដ និងប្រើប្រាស់ពាក្យបញ្ជា/អត្ថបទខ្លីៗដែលប្រើច្រើនបំផុត 5-10 អ្នកអភិវឌ្ឍន៍អាចបង្កើតប្រព័ន្ធកម្មវិធីព្យាបាលដោយខ្លួនឯងជាមួយ LangChain ។

ការកសាងប្រព័ន្ធកម្មវិធីព្យាបាលដោយខ្លួនឯងជាមួយនឹងស្ថាបត្យកម្ម AI ពហុភ្នាក់ងារ និង LangChain