AI-இயக்கப்படும் டெவொப்ஸ் பைப்லைன்களை DSPy மற்றும் LangChain உடன் செயல்திறனுள்ள சம்பவ விசாரணை மற்றும் தீர்மானத்திற்காக ஒழுங்கமைத்தல்

அறிமுகம்

நவீன மென்பொருள் அமைப்புகளின் எப்போதும் வளர்ந்து வரும் சிக்கலானது சம்பவங்களின் அதிர்வெண் மற்றும் தீவிரத்தன்மையை அதிகரிக்க வழிவகுத்தது, செயலில் உள்ள சம்பவ விசாரணை மற்றும் தீர்மானம் DevOps இன் முக்கியமான அம்சமாக உள்ளது. செயற்கை நுண்ணறிவு (AI) மற்றும் இயந்திர கற்றல் (ML) ஆகியவை DevOps பைப்லைன்களை மேம்படுத்துவதற்கான சக்திவாய்ந்த கருவிகளாக வெளிப்பட்டுள்ளன, AI-உந்துதல் ஆட்டோமேஷன் மற்றும் ஆர்கெஸ்ட்ரேஷன் ஆகியவை வணிகத்தை பாதிக்கும் முன் சம்பவங்களைக் கண்டறிந்து தீர்க்க உதவுகின்றன. இந்தக் கட்டுரையில், DSPy மற்றும் LangChain ஐப் பயன்படுத்தி AI-இயங்கும் DevOps பைப்லைன்களை எவ்வாறு செயல்படுத்துவது என்பதை ஆராய்வோம், AIOps மற்றும் RAG மாதிரிகளைப் பயன்படுத்தி செயலில் உள்ள சம்பவ விசாரணை மற்றும் தீர்மானம் மற்றும் தானியங்கு சம்பவ விசாரணைக்காக AWS DevOps முகவருடன் ஒருங்கிணைத்து.

DSPy மற்றும் LangChain இன் கண்ணோட்டம்

DSPy என்பது ஒரு பைதான் நூலகமாகும், இது AI-இயங்கும் DevOps பைப்லைன்களை உருவாக்க மற்றும் வரிசைப்படுத்த எளிய மற்றும் திறமையான வழியை வழங்குகிறது. இயற்கை மொழி செயலாக்கம் (NLP), கணினி பார்வை மற்றும் முன்கணிப்பு பகுப்பாய்வு உள்ளிட்ட பல்வேறு AI மற்றும் ML மாதிரிகளை டெவலப்பர்கள் தங்கள் DevOps பைப்லைன்களில் ஒருங்கிணைக்க இது அனுமதிக்கிறது. LangChain, மறுபுறம், ஒரு பைதான் நூலகமாகும், இது டெவலப்பர்களுக்கு ஒரு மட்டு மற்றும் அளவிடக்கூடிய கட்டமைப்பைப் பயன்படுத்தி பெரிய அளவிலான AI மாதிரிகளை உருவாக்கவும் பயன்படுத்தவும் உதவுகிறது.

DSPy மற்றும் LangChain உடன் AI-இயக்கப்படும் DevOps பைப்லைன்களை செயல்படுத்துதல்

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

1. தரவு சேகரிப்பு: பதிவுகள், அளவீடுகள் மற்றும் உள்ளமைவு கோப்புகள் போன்ற பல்வேறு ஆதாரங்களில் இருந்து தொடர்புடைய தரவை சேகரிக்கவும்.
2. தரவு முன் செயலாக்கம்: சேகரிக்கப்பட்ட தரவை பகுப்பாய்வு மற்றும் மாடலிங் செய்ய தயார்படுத்துவதற்கு முன் செயலாக்கம்.
3. மாடல் பயிற்சி: சம்பவங்களைக் கண்டறிந்து கணிக்க முன் செயலாக்கப்பட்ட தரவைப் பயன்படுத்தி AI மற்றும் ML மாடல்களைப் பயிற்றுவிக்கவும்.
4. மாடல் வரிசைப்படுத்தல்: DSPy மற்றும் LangChain ஐப் பயன்படுத்தி DevOps பைப்லைனில் பயிற்சி பெற்ற மாடல்களை வரிசைப்படுத்தவும்.
5. சம்பவ விசாரணை: சம்பவங்களை விசாரிக்கவும் மூல காரணங்களை கண்டறியவும் பயன்படுத்தப்பட்ட மாதிரிகளைப் பயன்படுத்தவும்.
6. சம்பவத் தீர்மானம்: சம்பவங்களை முன்கூட்டியே தீர்க்க, சம்பவ விசாரணையிலிருந்து பெறப்பட்ட நுண்ணறிவுகளைப் பயன்படுத்தவும்.

குறியீடு எடுத்துக்காட்டு: DSPy மற்றும் LangChain உடன் ஒரு எளிய RAG மாதிரியை செயல்படுத்துதல்

DSPy மற்றும் LangChain ஐப் பயன்படுத்தி RAG (Root Cause Analysis) மாதிரியை எவ்வாறு செயல்படுத்துவது என்பதை விளக்கும் எளிய குறியீடு எடுத்துக்காட்டு இங்கே:

இறக்குமதி dsp
langchain இறக்குமதி LLMChain இலிருந்து

# முன் செயலாக்கப்பட்ட தரவை ஏற்றவும்
தரவு = pd.read_csv("data.csv")

# RAG மாதிரியை வரையறுக்கவும்
rag_model = dspy.RAGModel(
    input_features=["log_level", "error_message"],
    output_features=["root_cause"]
)

# RAG மாதிரியைப் பயிற்றுவிக்கவும்
rag_model.train(தரவு)

# RAG மாதிரியை வரிசைப்படுத்தவும்
llm_chain = LLMCchain(
    மாதிரி="davinci:002",
    max_length=2048
)
rag_model.deploy(llm_chain)

# சம்பவங்களை விசாரிக்க பயன்படுத்தப்பட்ட RAG மாதிரியைப் பயன்படுத்தவும்
சம்பவம்_தரவு = pd.DataFrame({
    "log_level": ["ERROR"],
    "error_message": ["ஏதோ தவறாகிவிட்டது"]
})
root_cause = rag_model.predict(incident_data)
அச்சு (மூல_காரணம்)

இந்த குறியீடு உதாரணம் DSPy மற்றும் LangChain ஐப் பயன்படுத்தி ஒரு எளிய RAG மாதிரியை எவ்வாறு செயல்படுத்துவது என்பதை விளக்குகிறது. RAG மாதிரியானது பதிவு நிலை மற்றும் பிழை செய்தியை உள்ளீட்டு அம்சங்களாக எடுத்து, சம்பவத்தின் மூல காரணத்தை கணிக்கின்றது.

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

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

1. dspy.RAGModel(input_features, output_features): குறிப்பிட்ட உள்ளீடு மற்றும் வெளியீட்டு அம்சங்களுடன் RAG மாதிரியை வரையறுக்கவும்.
2. dspy.RAGModel.train(data): வழங்கப்பட்ட தரவைப் பயன்படுத்தி RAG மாதிரியைப் பயிற்றுவிக்கவும்.
3. dspy.RAGModel.deploy(llm_chain): LangChain LLMchain ஐப் பயன்படுத்தி பயிற்சியளிக்கப்பட்ட RAG மாதிரியைப் பயன்படுத்தவும்.
4. llm_chain = LLMCchain(model, max_length): குறிப்பிட்ட மாதிரி மற்றும் அதிகபட்ச நீளம் கொண்ட LangChain LLMCchain ஐ உருவாக்கவும்.
5. rag_model.predict(data): ஒரு சம்பவத்தின் மூல காரணத்தைக் கணிக்க, பயன்படுத்தப்பட்ட RAG மாதிரியைப் பயன்படுத்தவும்.
6. dspy.DataPreprocessor(input_data): DSPy ஐப் பயன்படுத்தி ஒரு தரவு முன் செயலாக்க பைப்லைனை வரையறுக்கவும்.
7. dspy.ModelTrainer(மாதிரி, தரவு): DSPy ஐப் பயன்படுத்தி AI அல்லது ML மாதிரியைப் பயிற்றுவிக்கவும்.
8. dspy.ModelDeployer(model, llm_chain): DSPy மற்றும் LangChain ஐப் பயன்படுத்தி பயிற்சி பெற்ற மாதிரியை வரிசைப்படுத்தவும்.
9. langchain.LLMCchain.predict(input_data): ஒரு மாதிரியின் வெளியீட்டைக் கணிக்க LangChain LLMCchain ஐப் பயன்படுத்தவும்.
10. dspy.RAGModel.evaluate(data): DSPy ஐப் பயன்படுத்தி RAG மாதிரியின் செயல்திறனை மதிப்பிடவும்.

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

Chart.js ஐப் பயன்படுத்தி காட்சிப்படுத்தலின் எடுத்துக்காட்டு இங்கே:

{
  "வகை": "பார்",
  "தரவு": {
    "லேபிள்கள்": ["சம்பவ வகை A", "சம்பவ வகை B", "சம்பவ வகை C"],
    "தரவுத்தொகுப்புகள்": [
      {
        "லேபிள்": "ரூட் காஸ் ஏ",
        "தரவு": [10, 15, 7],
        "பின்னணி நிறம்": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "எல்லை அகலம்": 1
      },
      {
        "லேபிள்": "ரூட் காஸ் பி",
        "தரவு": [8, 12, 9],
        "பின்னணி நிறம்": "rgba(54, 162, 235, 0.2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        "எல்லை அகலம்": 1
      },
      {
        "லேபிள்": "ரூட் காஸ் சி",
        "தரவு": [14, 18, 11],
        "பின்னணி நிறம்": "rgba(255, 206, 86, 0.2)",
        "borderColor": "rgba(255, 206, 86, 1)",
        "எல்லை அகலம்": 1
      }
    ]
  },
  "விருப்பங்கள்": {
    "தலைப்பு": {
      "காட்சி": உண்மை,
      "உரை": "மூல காரண பகுப்பாய்வு"
    },
    "செதில்கள்": {
      "yAxes": [
        {
          "உண்ணி": {
            "beginAtZero": உண்மை
          }
        }
      ]
    }
  }
}

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

முடிவு

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