மேம்படுத்தப்பட்ட மென்பொருள் கட்டமைப்பிற்காக லாங்செயின் மற்றும் DSPy உடன் AI முகவர்களை ஒழுங்கமைத்தல்

மேம்படுத்தப்பட்ட மென்பொருள் கட்டமைப்பிற்காக லாங்செயின் மற்றும் DSPy உடன் AI முகவர்களை ஒழுங்கமைத்தல்

அறிமுகம்

இன்றைய வேகமான டிஜிட்டல் நிலப்பரப்பில், செயற்கை நுண்ணறிவு (AI) மற்றும் இயந்திர கற்றல் (ML) திறன்களின் ஒருங்கிணைப்புடன் மென்பொருள் அமைப்புகள் பெருகிய முறையில் சிக்கலானதாகி வருகின்றன. இதன் விளைவாக, AI முகவர்களை திறம்பட ஒழுங்கமைக்கக்கூடிய அளவிடக்கூடிய மற்றும் மீள்திறன் அமைப்புகளை வடிவமைப்பது மென்பொருள் பொறியாளர்களுக்கு ஒரு அழுத்தமான கவலையாக மாறியுள்ளது. லாங்செயின் மற்றும் DSPy ஐப் பயன்படுத்தி AI முகவர்களைச் செயல்படுத்துவதில் கவனம் செலுத்துவதன் மூலம், திறமையான மென்பொருள் கட்டமைப்புகளை வடிவமைக்க AI, மென்பொருள் பொறியியல் மற்றும் ஆர்கெஸ்ட்ரேஷன் கருவிகளின் குறுக்குவெட்டுகளை இந்தக் கட்டுரை ஆராய்கிறது.

AI ஆர்கெஸ்ட்ரேஷனின் தேவை

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

LangChain: AI முகவர்களை உருவாக்குவதற்கான ஒரு கட்டமைப்பு

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

DSPy: ஆர்கெஸ்ட்ரேஷனுக்கான ஒரு கட்டமைப்பு

DSPy என்பது பல AI முகவர்களைத் திட்டமிடக்கூடிய விநியோகிக்கப்பட்ட அமைப்புகளை உருவாக்குவதற்கான ஒரு பைதான் கட்டமைப்பாகும். பல முகவர்களுக்கிடையிலான சிக்கலான தொடர்புகளை நிர்வகிக்கக்கூடிய அளவிடக்கூடிய மற்றும் நெகிழ்வான அமைப்புகளை வடிவமைத்து வரிசைப்படுத்த டெவலப்பர்களுக்கு உதவும் கருவிகள் மற்றும் நூலகங்களின் தொகுப்பை இது வழங்குகிறது. DSPy ஆனது Apache Kafka செய்தியிடல் அமைப்பின் மேல் கட்டமைக்கப்பட்டுள்ளது மற்றும் விநியோகிக்கப்பட்ட அமைப்புகளை உருவாக்குவதற்கான உயர்நிலை API ஐ வழங்குகிறது.

LangChain மற்றும் DSPy உடன் AI முகவர்களைச் செயல்படுத்துதல்

LangChain மற்றும் DSPy ஐப் பயன்படுத்தி AI முகவர்களைச் செயல்படுத்த, நாம் இந்தப் படிகளைப் பின்பற்ற வேண்டும்:

1. ** முகவர் கட்டமைப்பை வரையறுக்கவும்**: உள்ளீடுகள், வெளியீடுகள் மற்றும் பிற முகவர்களுடனான தொடர்புகள் உட்பட AI முகவரின் கட்டமைப்பை வரையறுக்கவும்.
2. ஏஜென்ட் லாஜிக்கைச் செயல்படுத்தவும்: பகுத்தறிவு, கற்றல் மற்றும் தழுவல் வழிமுறைகள் உட்பட, LangChain ஐப் பயன்படுத்தி AI ஏஜென்ட்டின் தர்க்கத்தைச் செயல்படுத்தவும்.
3. ** முகவர் தொடர்புகளை ஒழுங்கமைக்கவும்**: தொடர்பு நெறிமுறைகள் மற்றும் தரவு பரிமாற்ற வழிமுறைகள் உட்பட பல AI முகவர்களுக்கிடையேயான தொடர்புகளை ஒழுங்கமைக்க DSPy ஐப் பயன்படுத்தவும்.
4. சிஸ்டத்தை வரிசைப்படுத்து: கிளவுட் பிளாட்ஃபார்ம் அல்லது டோக்கர் போன்ற கண்டெய்னரைசேஷன் கட்டமைப்பைப் பயன்படுத்தி கணினியை வரிசைப்படுத்தவும்.

குறியீடு எடுத்துக்காட்டு: லாங்செயினுடன் ஒரு எளிய AI முகவரைச் செயல்படுத்துதல்

LangChain ஐப் பயன்படுத்தி AI முகவரை எவ்வாறு செயல்படுத்துவது என்பதை விளக்கும் எளிய குறியீடு எடுத்துக்காட்டு இங்கே:

லாங்செயின் இறக்குமதி
langchain.chains இலிருந்து LLMCchain ஐ இறக்குமதி செய்கிறது


முகவர் = langchain.Agent(
    input_schema={"text": str},
    output_schema={"text": str},
    சங்கிலி=LLMchain(
        மாதிரி="டாவின்சி:இன்ஸ்ட்ரக்டிக்ஸ்",
        max_length=2048,
        வெப்பநிலை=0.7,
    ),
)

# முகவர் தர்க்கத்தை செயல்படுத்தவும்
def agent_logic(input_text):
    output_text = agent.run(input_text)
    வெளியீடு_உரையைத் திருப்பி அனுப்பு

# முகவரை சோதிக்கவும்
input_text = "வாழ்க்கையின் அர்த்தம் என்ன?"
output_text = agent_logic(input_text)
அச்சு (output_text)

உள்ளீடு மற்றும் வெளியீட்டுத் திட்டங்கள் மற்றும் முகவரின் தர்க்கம் உட்பட, லாங்செயினைப் பயன்படுத்தி AI முகவரை எவ்வாறு வரையறுப்பது என்பதை இந்தக் குறியீடு எடுத்துக்காட்டு விளக்குகிறது. ஏஜென்ட் ஒரு பெரிய மொழி மாதிரி (LLM) சங்கிலியைப் பயன்படுத்தி செயல்படுத்தப்படுகிறது, இது ஒரு வகை AI முகவர், இது பகுத்தறிந்து உரையை உருவாக்க முடியும்.

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

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

1. langchain.Agent(): புதிய AI முகவர் நிகழ்வை உருவாக்குகிறது.

முகவர் = langchain.Agent(
    input_schema={"text": str},
    output_schema={"text": str},
    சங்கிலி=LLMchain(
        மாதிரி="டாவின்சி:இன்ஸ்ட்ரக்டிக்ஸ்",
        max_length=2048,
        வெப்பநிலை=0.7,
    ),
)

2. agent.run(): கொடுக்கப்பட்ட உள்ளீட்டுடன் AI முகவரை இயக்குகிறது.

output_text = agent.run(input_text)

3. DSPy.create_cluster(): பகிர்ந்தளிக்கப்பட்ட கணினிக்கு ஒரு புதிய க்ளஸ்டர் முனைகளை உருவாக்குகிறது.

கிளஸ்டர் = DSPy.create_cluster(
    எண்_முனைகள்=5,
    node_type="தொழிலாளர்",
)

4. DSPy.create_agent(): விநியோகிக்கப்பட்ட கணினிக்கு ஒரு புதிய AI முகவர் நிகழ்வை உருவாக்குகிறது.

முகவர் = DSPy.create_agent(
    கொத்து=கொத்து,
    agent_type="LLM",
)

5. DSPy.deploy_agent(): விநியோகிக்கப்பட்ட கணினியில் AI முகவரைப் பயன்படுத்துகிறது.

DSPy.deploy_agent(
    முகவர் = முகவர்,
    கொத்து=கொத்து,
)

6. DSPy.get_agent_status(): AI ஏஜென்ட்டின் நிலையை மீட்டெடுக்கிறது.

நிலை = DSPy.get_agent_status(
    முகவர் = முகவர்,
    கொத்து=கொத்து,
)

7. DSPy.update_agent(): புதிய தரவு அல்லது அளவுருக்கள் மூலம் AI முகவரைப் புதுப்பிக்கிறது.

DSPy.update_agent(
    முகவர் = முகவர்,
    கொத்து=கொத்து,
    new_data={"text": "புதிய உள்ளீட்டு உரை"},
)

8. DSPy.delete_agent(): விநியோகிக்கப்பட்ட அமைப்பிலிருந்து AI முகவரை நீக்குகிறது.

DSPy.delete_agent(
    முகவர் = முகவர்,
    கொத்து=கொத்து,
)

9. DSPy.create_chain(): விநியோகிக்கப்பட்ட கணினிக்கு AI முகவர்களின் புதிய சங்கிலியை உருவாக்குகிறது.

சங்கிலி = DSPy.create_chain(
    முகவர்கள்=[முகவர்1, முகவர்2, முகவர்3],
)

10. DSPy.deploy_chain(): விநியோகிக்கப்பட்ட கணினியில் AI முகவர்களின் சங்கிலியை வரிசைப்படுத்துகிறது.

DSPy.deploy_chain(
    சங்கிலி = சங்கிலி,
    கொத்து=கொத்து,
)

காட்சிப்படுத்தல்

Chart.js ஐப் பயன்படுத்தி LangChain மற்றும் DSPy கட்டமைப்பின் காட்சிப்படுத்தல் இங்கே:

{
  "வகை": "பைசார்ட்",
  "தரவு": {
    "லேபிள்கள்": ["LangChain", "DSPy"],
    "தரவுத்தொகுப்புகள்": [
      {
        "லேபிள்": "AI முகவர்கள்",
        "தரவு": [50, 50],
        "பின்னணி நிறம்": ["#4CAF50", "#FF9800"]
      }
    ]
  },
  "விருப்பங்கள்": {
    "தலைப்பு": {
      "காட்சி": உண்மை,
      "உரை": "LangChain மற்றும் DSPy கட்டிடக்கலை"
    },
    "புராணக்கதை": {
      "காட்சி": உண்மை
    }
  }
}

இந்த காட்சிப்படுத்தல் LangChain மற்றும் DSPy இடையே AI முகவர்களின் விநியோகத்தை நிரூபிக்கிறது, 50% முகவர்கள் LangChain இல் இயங்குகிறது மற்றும் 50% DSPy இல் இயங்குகிறது.

முடிவு

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