மல்டி-ஏஜென்ட் AI கட்டமைப்புகள் மற்றும் லாங்செயின் மூலம் சுய-குணப்படுத்தும் மென்பொருள் அமைப்புகளை உருவாக்குதல்

மல்டி-ஏஜென்ட் AI கட்டமைப்புகள் மற்றும் LangChain உடன் சுய-குணப்படுத்தும் மென்பொருள் அமைப்புகளை உருவாக்குதல்

அறிமுகம்

இன்றைய வேகமான மென்பொருள் மேம்பாட்டு நிலப்பரப்பில், சிக்கலான மென்பொருள் அமைப்புகளின் நம்பகத்தன்மை, அளவிடுதல் மற்றும் மீள்தன்மை ஆகியவற்றை உறுதிப்படுத்த சுய-குணப்படுத்தும் மென்பொருள் அமைப்புகளை உருவாக்குவது ஒரு முக்கியமான தேவையாக மாறியுள்ளது. பாரம்பரிய மோனோலிதிக் கட்டமைப்புகள் நவீன மென்பொருள் மேம்பாட்டின் தேவைகளைப் பூர்த்தி செய்ய போதுமானதாக இல்லை, அங்கு அமைப்புகள் மாறிவரும் தேவைகளுக்கு ஏற்றவாறு மாற்றியமைக்க வேண்டும், எதிர்பாராத தோல்விகளைக் கையாள வேண்டும் மற்றும் பிழைகளில் இருந்து விரைவாக மீட்க வேண்டும். இங்குதான் மல்டி-ஏஜென்ட் AI கட்டமைப்புகள் மற்றும் LangChain ஆகியவை செயல்படுகின்றன, இது சுய-குணப்படுத்தும் மென்பொருள் அமைப்புகளை உருவாக்குவதற்கான ஒரு சக்திவாய்ந்த தீர்வை வழங்குகிறது, அவை மாறிவரும் நிலைமைகளைக் கற்றுக்கொள்ளவும், மாற்றியமைக்கவும் மற்றும் பதிலளிக்கவும் முடியும்.

மல்டி ஏஜென்ட் AI கட்டிடக்கலை என்றால் என்ன?

மல்டி-ஏஜென்ட் AI கட்டமைப்புகள் என்பது ஒரு வகையான விநியோகிக்கப்பட்ட AI அமைப்பாகும், இது ஒரு பொதுவான இலக்கை அடைய ஒருவருக்கொருவர் மற்றும் அவற்றின் சூழலுடன் தொடர்பு கொள்ளும் பல தன்னாட்சி முகவர்களைக் கொண்டுள்ளது. ஒவ்வொரு முகவருக்கும் அதன் சொந்த முடிவெடுக்கும் திறன்கள், அறிவு மற்றும் வளங்கள் உள்ளன, மேலும் அவர்கள் தகவல்களைப் பகிர்ந்து கொள்ளவும், செயல்களை ஒருங்கிணைக்கவும் மற்றும் மாறும் நிலைமைகளுக்கு ஏற்பவும் ஒருவருக்கொருவர் தொடர்பு கொள்ளலாம்.

மென்பொருள் அமைப்புகளின் சூழலில், நிகழ்நேரத்தில் பிழைகள், தோல்விகள் மற்றும் பிற முரண்பாடுகளைக் கண்டறிந்து பதிலளிக்கக்கூடிய சுய-குணப்படுத்தும் அமைப்புகளை உருவாக்க மல்டி-ஏஜென்ட் AI கட்டமைப்புகள் பயன்படுத்தப்படலாம். பல முகவர்களிடையே முடிவெடுக்கும் செயல்முறையை விநியோகிப்பதன் மூலம், இந்த அமைப்புகள் அனுபவத்திலிருந்து கற்றுக் கொள்ளலாம், மாறிவரும் நிலைமைகளுக்கு ஏற்ப மாற்றலாம் மற்றும் பிழைகளில் இருந்து விரைவாக மீட்கலாம்.

LangChain என்றால் என்ன?

LangChain என்பது பல முகவர் AI அமைப்புகளை உருவாக்குவதற்கான திறந்த மூல பைதான் நூலகம் ஆகும். இது சிக்கலான AI அமைப்புகளை உருவாக்குவதற்கான எளிய, நெகிழ்வான மற்றும் அளவிடக்கூடிய கட்டமைப்பை வழங்குகிறது. LangChain ஆனது TensorFlow, PyTorch மற்றும் Keras உள்ளிட்ட பலவிதமான AI கட்டமைப்புகளுடன் வேலை செய்ய வடிவமைக்கப்பட்டுள்ளது, மேலும் தரவுத்தளங்கள், APIகள் மற்றும் IoT சாதனங்கள் உட்பட பல்வேறு தரவு மூலங்களுடன் ஒருங்கிணைக்கும் அமைப்புகளை உருவாக்கப் பயன்படுத்தலாம்.

LangChain உடன் சுய-குணப்படுத்தும் மென்பொருள் அமைப்புகளை உருவாக்குதல்

LangChain உடன் சுய-குணப்படுத்தும் மென்பொருள் அமைப்பை உருவாக்க, நிகழ்நேரத்தில் பிழைகள், தோல்விகள் மற்றும் பிற முரண்பாடுகளைக் கண்டறிந்து பதிலளிக்கக்கூடிய பல-ஏஜென்ட் AI கட்டமைப்பை நாம் வடிவமைக்க வேண்டும். கட்டிடக்கலையின் உயர்நிலை கண்ணோட்டம் இங்கே:

1. முகவர் வடிவமைப்பு: ஒரு பொதுவான இலக்கை அடைய, ஒருவருக்கொருவர் மற்றும் அவர்களின் சூழலுடன் தொடர்பு கொள்ளக்கூடிய தன்னாட்சி முகவர்களின் தொகுப்பை நாம் வடிவமைக்க வேண்டும். ஒவ்வொரு முகவருக்கும் அதன் சொந்த முடிவெடுக்கும் திறன்கள், அறிவு மற்றும் வளங்கள் இருக்க வேண்டும்.
2. அறிவு வரைபடம்: முகவர்கள், சுற்றுச்சூழல் மற்றும் அமைப்பின் குறிக்கோள்களுக்கு இடையிலான உறவுகளை பிரதிபலிக்கும் அறிவு வரைபடத்தை நாம் உருவாக்க வேண்டும். கணினியின் நிலையைப் பற்றி நியாயப்படுத்தவும் முடிவுகளை எடுக்கவும் இந்த வரைபடம் பயன்படுத்தப்படலாம்.
3. முடிவெடுத்தல்: முகவர்கள் அமைப்பின் நிலையைப் பற்றி நியாயப்படுத்தவும் அறிவு வரைபடத்தின் அடிப்படையில் முடிவுகளை எடுக்கவும் அனுமதிக்கும் முடிவெடுக்கும் செயல்முறையை நாம் செயல்படுத்த வேண்டும்.
4. Action Execution: முகவர்கள் தங்கள் முடிவுகளைச் செயல்படுத்தவும் சுற்றுச்சூழலுடன் தொடர்பு கொள்ளவும் அனுமதிக்கும் செயல் செயல்படுத்தல் செயல்முறையை நாம் செயல்படுத்த வேண்டும்.

LangChain உடன் கட்டமைக்கப்பட்ட சுய-குணப்படுத்தும் மென்பொருள் அமைப்பின் எளிய உதாரணம் இங்கே:

லாங்செயின் இறக்குமதி
langchain. முகவர் இறக்குமதி முகவரிடமிருந்து
langchain.llms இலிருந்து LLM ஐ இறக்குமதி செய்கிறது


வரைபடம் = {
    'முகவர்கள்': ['முகவர்1', 'முகவர்2', 'முகவர்3'],
    'சுற்றுச்சூழல்': ['டேட்டாபேஸ்', 'ஏபிஐ', 'ஐஓடி சாதனம்'],
    'இலக்குகள்': ['பிழைகளைக் கண்டறிதல்', 'தோல்விகளுக்குப் பதிலளி', 'பிழைகளிலிருந்து மீள்']
}

# முடிவெடுக்கும் செயல்முறையை வரையறுக்கவும்
முடிவு_செய்தல்(முகவர், அறிவு_வரைபடம்):
    # அமைப்பின் நிலை பற்றிய காரணம்
    நிலை = அறிவு_வரைபடம்['முகவர்கள்'][முகவர்]
    # மாநிலத்தின் அடிப்படையில் முடிவெடுக்கவும்
    முடிவு = 'தோல்விக்கு பதில்'
    திரும்ப முடிவு

# செயல் செயல்படுத்தும் செயல்முறையை வரையறுக்கவும்
def action_execution(முகவர், முடிவு):
    #முடிவை நிறைவேற்றுங்கள்
    முடிவு என்றால் == 'தோல்விக்கு பதில்':
        # தோல்விக்கு பதில் சொல்லுங்கள்
        அச்சு ('தோல்விக்கு பதிலளிக்கிறது...')
    திரும்ப

# LangChain முகவரை உருவாக்கவும்
முகவர் = முகவர்(
    பெயர்='சுய-குணப்படுத்தும் முகவர்',
    முடிவு_செய்தல்=முடிவு_எடுத்தல்,
    action_execution=action_execution,
    அறிவு_வரைபடம் = வரைபடம்
)

# ஒரு LangChain LLM ஐ உருவாக்கவும்
llm = LLM(
    பெயர்='சுய-குணப்படுத்துதல்-எல்எல்எம்',
    மாதிரி='டாவின்சி'
)

# ஒரு LangChain அமைப்பை உருவாக்கவும்
அமைப்பு = langchain.System(
    முகவர் = முகவர்,
    llm=llm
)

# கணினியை இயக்கவும்
system.run()

பிழைகளைக் கண்டறியவும், தோல்விகளுக்குப் பதிலளிக்கவும், பிழைகளில் இருந்து விரைவாக மீட்கவும் கூடிய எளிய சுய-குணப்படுத்தும் மென்பொருள் அமைப்பை இந்த எடுத்துக்காட்டு நிரூபிக்கிறது. இந்த அமைப்பு ஒரு பொதுவான இலக்கை அடைய ஒருவருக்கொருவர் மற்றும் அவற்றின் சூழலுடன் தொடர்பு கொள்ளும் தன்னாட்சி முகவர்களின் தொகுப்பைக் கொண்டுள்ளது. அமைப்பின் நிலையைப் பற்றி நியாயப்படுத்தவும் வரைபடத்தின் அடிப்படையில் முடிவுகளை எடுக்கவும் முகவர்கள் அறிவு வரைபடத்தைப் பயன்படுத்துகின்றனர்.

முதல் 5-10 அதிகம் பயன்படுத்தப்பட்ட கட்டளைகள்/துணுக்குகள்

LangChain க்காக அதிகம் பயன்படுத்தப்படும் முதல் 5-10 கட்டளைகள்/துணுக்குகள் இங்கே:

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 ஐப் பயன்படுத்தி அறிவு வரைபடத்தின் எளிய காட்சிப்படுத்தல் இங்கே:

{
  "வகை": "வரைபடம்",
  "தரவு": {
    "முனைகள்": [
      {"id": "agent1", "label": "Agent 1"},
      {"id": "agent2", "label": "Agent 2"},
      {"id": "agent3", "label": "Agent 3"},
      {"id": "database", "label": "Database"},
      {"id": "API", "label": "API"},
      {"id": "IoT சாதனம்", "லேபிள்": "IoT சாதனம்"}
    ],
    "விளிம்புகள்": [
      {"source": "agent1", "target": "database"},
      {"source": "agent2", "target": "API"},
      {"source": "agent3", "இலக்கு": "IoT சாதனம்"},
      {"source": "agent1", "target": "agent2"},
      {"source": "agent2", "target": "agent3"}
    ]
  },
  "விருப்பங்கள்": {
    "தளவமைப்பு": {
      "வகை": "வட்ட"
    },
    "முனைகள்": {
      "அளவு": 50
    },
    "விளிம்புகள்": {
      "அகலம்": 2
    }
  }
}

இந்த காட்சிப்படுத்தல் முகவர்கள், சுற்றுச்சூழல் மற்றும் அமைப்பின் குறிக்கோள்களுக்கு இடையிலான உறவுகளைக் காட்டுகிறது.

முடிவு

மல்டி-ஏஜென்ட் AI கட்டமைப்புகள் மற்றும் LangChain உடன் சுய-குணப்படுத்தும் மென்பொருள் அமைப்புகளை உருவாக்குவது சிக்கலான மென்பொருள் அமைப்புகளின் நம்பகத்தன்மை, அளவிடுதல் மற்றும் நெகிழ்ச்சித்தன்மையை உறுதி செய்வதற்கான சக்திவாய்ந்த தீர்வை வழங்குகிறது. பல முகவர்களிடையே முடிவெடுக்கும் செயல்முறையை விநியோகிப்பதன் மூலம், இந்த அமைப்புகள் அனுபவத்திலிருந்து கற்றுக் கொள்ளலாம், மாறிவரும் நிலைமைகளுக்கு ஏற்ப மாற்றலாம் மற்றும் பிழைகளில் இருந்து விரைவாக மீட்கலாம். LangChain மூலம், டெவலப்பர்கள் சிக்கலான AI அமைப்புகளை உருவாக்க முடியும், அவை தரவுத்தளங்கள், APIகள் மற்றும் IoT சாதனங்கள் உட்பட பரந்த அளவிலான தரவு மூலங்களுடன் ஒருங்கிணைக்கப்படுகின்றன. எடுத்துக்காட்டுக் குறியீட்டைப் பின்பற்றி, அதிகம் பயன்படுத்தப்படும் 5-10 கட்டளைகள்/துணுக்குகளைப் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் தங்கள் சொந்த சுய-குணப்படுத்தும் மென்பொருள் அமைப்புகளை LangChain மூலம் உருவாக்கலாம்.