შესავალი

თანამედროვე პროგრამული სისტემების მუდმივად მზარდმა სირთულემ გამოიწვია ინციდენტების სიხშირისა და სიმძიმის ზრდა, ინციდენტების პროაქტიული გამოძიება და გადაწყვეტა DevOps-ის კრიტიკულ ასპექტად აქცია. ხელოვნური ინტელექტი (AI) და მანქანათმცოდნეობა (ML) გაჩნდა, როგორც მძლავრი ინსტრუმენტები DevOps მილსადენების გასაუმჯობესებლად, რაც საშუალებას აძლევს AI-ზე დაფუძნებულ ავტომატიზაციას და ორკესტრაციას აღმოაჩინოს და გადაჭრას ინციდენტები, სანამ ისინი გავლენას მოახდენენ ბიზნესზე. ამ სტატიაში ჩვენ განვიხილავთ, თუ როგორ უნდა განვახორციელოთ AI-ზე მომუშავე DevOps მილსადენები DSPy-ისა და LangChain-ის გამოყენებით, აქცენტით ინციდენტების პროაქტიულ გამოძიებასა და გადაწყვეტაზე AIOps და RAG მოდელების გამოყენებით და ინტეგრირება AWS DevOps Agent-თან ინციდენტების ავტომატური გამოძიებისთვის.

DSPy და LangChain-ის მიმოხილვა

DSPy არის პითონის ბიბლიოთეკა, რომელიც გთავაზობთ მარტივ და ეფექტურ გზას AI-ზე მომუშავე DevOps მილსადენების შესაქმნელად და განსათავსებლად. ის დეველოპერებს საშუალებას აძლევს თავიანთ DevOps მილსადენებში გააერთიანონ სხვადასხვა AI და ML მოდელები, მათ შორის ბუნებრივი ენის დამუშავება (NLP), კომპიუტერული ხედვა და პროგნოზირებადი ანალიტიკა. თავის მხრივ, LangChain არის პითონის ბიბლიოთეკა, რომელიც დეველოპერებს საშუალებას აძლევს შექმნან და განათავსონ ფართომასშტაბიანი AI მოდელები მოდულური და მასშტაბირებადი არქიტექტურის გამოყენებით.

AI-ით აღჭურვილი DevOps მილსადენების დანერგვა DSPy-ით და LangChain-ით

AI-ზე მომუშავე DevOps მილსადენების განსახორციელებლად DSPy-თან და LangChain-თან ერთად, ჩვენ უნდა მივყვეთ ამ ნაბიჯებს:

1. მონაცემთა შეგროვება: შეაგროვეთ შესაბამისი მონაცემები სხვადასხვა წყაროდან, როგორიცაა ჟურნალები, მეტრიკა და კონფიგურაციის ფაილები.
2. მონაცემთა წინასწარი დამუშავება: შეგროვებული მონაცემების წინასწარი დამუშავება ანალიზისა და მოდელირებისთვის მოსამზადებლად.
3. **მოდელური ტრენინგი **: ავარჯიშეთ AI და ML მოდელები წინასწარ დამუშავებული მონაცემების გამოყენებით ინციდენტების აღმოსაჩენად და პროგნოზირებისთვის.
4. მოდელის დანერგვა: განათავსეთ გაწვრთნილი მოდელები DevOps მილსადენში DSPy-ისა და LangChain-ის გამოყენებით.
5. ინციდენტის გამოძიება: გამოიყენეთ განლაგებული მოდელები ინციდენტების გამოსაძიებლად და ძირითადი მიზეზების დასადგენად.
6. ინციდენტის რეზოლუცია: გამოიყენეთ ინციდენტის გამოძიების შედეგად მიღებული შეხედულებები ინციდენტების პროაქტიულად მოსაგვარებლად.

კოდის მაგალითი: მარტივი RAG მოდელის დანერგვა DSPy-ით და LangChain-ით

აქ არის მარტივი კოდის მაგალითი, რომელიც აჩვენებს, თუ როგორ უნდა განხორციელდეს RAG (ძირეული მიზეზის ანალიზი) მოდელი DSPy-ისა და LangChain-ის გამოყენებით: ``პითონი იმპორტი dspy langchain იმპორტიდან LLMCchain

ჩატვირთეთ წინასწარ დამუშავებული მონაცემები

data = 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_message": ["რაღაც შეცდომა"] }) root_cause = rag_model.predict(incident_data) ბეჭდვა (root_cause)

კოდის ეს მაგალითი გვიჩვენებს, თუ როგორ უნდა განხორციელდეს მარტივი RAG მოდელი DSPy-ისა და LangChain-ის გამოყენებით. RAG მოდელი იღებს ჟურნალის დონეს და შეცდომის შეტყობინებას, როგორც შეყვანის ფუნქციებს და პროგნოზირებს ინციდენტის ძირეულ მიზეზს.

## ტოპ 5-10 ყველაზე ხშირად გამოყენებული ბრძანება/ნაწყვეტი

აქ არის ტოპ 5-10 ყველაზე ხშირად გამოყენებული ბრძანება/სნიპეტი DSPy-სა და LangChain-ისთვის:

1. `dspy.RAGModel(input_features, output_features)`: განსაზღვრეთ RAG მოდელი მითითებული შეყვანისა და გამომავალი ფუნქციებით.
2. `dspy.RAGModel.train(data)`: მოამზადეთ RAG მოდელი მოწოდებული მონაცემების გამოყენებით.
3. `dspy.RAGModel.deploy(llm_chain)`: განათავსეთ გაწვრთნილი RAG მოდელი LangChain LLMChain-ის გამოყენებით.
4. `llm_chain = LLMCchain(მოდელი, max_length)`: შექმენით LangChain LLMCchain მითითებული მოდელით და მაქსიმალური სიგრძით.
5. `rag_model.predict(data)`: გამოიყენეთ განლაგებული RAG მოდელი ინციდენტის ძირითადი მიზეზის პროგნოზირებისთვის.
6. `dspy.DataPreprocessor(input_data)`: განსაზღვრეთ მონაცემთა წინასწარი დამუშავების მილსადენი DSPy-ის გამოყენებით.
7. `dspy.ModelTrainer(model, data)`: მოამზადეთ AI ან ML მოდელი DSPy-ის გამოყენებით.
8. `dspy.ModelDeployer(model, llm_chain)`: განათავსეთ გაწვრთნილი მოდელი DSPy და LangChain-ის გამოყენებით.
9. `langchain.LLMChain.predict(input_data)`: გამოიყენეთ LangChain LLMChain მოდელის გამოსავლის პროგნოზირებისთვის.
10. `dspy.RAGModel.evaluate(data)`: შეაფასეთ RAG მოდელის შესრულება DSPy-ის გამოყენებით.

## ვიზუალიზაცია

აქ მოცემულია ვიზუალიზაციის მაგალითი Chart.js-ის გამოყენებით:
``ჯსონ
{
  "ტიპი": "ბარი",
  "მონაცემები": {
    "ეტიკეტები": ["ინციდენტის ტიპი A", "ინციდენტის ტიპი B", "ინციდენტის ტიპი C"],
    "მონაცემთა ნაკრები": [
      {
        "label": "ძირეული მიზეზი A",
        "მონაცემები": [10, 15, 7],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "საზღვრის სიგანე": 1
      },
      {
        "label": "ძირეული მიზეზი B",
        "მონაცემები": [8, 12, 9],
        "backgroundColor": "rgba(54, 162, 235, 0.2)",
        "borderColor": "rgba(54, 162, 235, 1)",
        "საზღვრის სიგანე": 1
      },
      {
        "label": "ძირეული მიზეზი C",
        "მონაცემები": [14, 18, 11],
        "backgroundColor": "rgba(255, 206, 86, 0.2)",
        "borderColor": "rgba(255, 206, 86, 1)",
        "საზღვრის სიგანე": 1
      }
    ]
  },
  "ოფციები": {
    "სათაური": {
      "ჩვენება": მართალია,
      "text": "ძირეული მიზეზის ანალიზი"
    },
    "სასწორები": {
      "yAxes": [
        {
          "ტკიპები": {
            "beginAtZero": მართალია
          }
        }
      ]
    }
  }
}

ეს ვიზუალიზაცია აჩვენებს ძირეული მიზეზების განაწილებას სხვადასხვა ტიპის ინციდენტისთვის.

დასკვნა

ამ სტატიაში ჩვენ გამოვიკვლიეთ, თუ როგორ უნდა განვახორციელოთ AI-ზე მომუშავე DevOps მილსადენები DSPy-ისა და LangChain-ის გამოყენებით, აქცენტით ინციდენტების პროაქტიულ გამოძიებასა და გადაწყვეტაზე AIOps და RAG მოდელების გამოყენებით და ინტეგრირება AWS DevOps Agent-თან ინციდენტების ავტომატური გამოძიებისთვის. ჩვენ ვაჩვენეთ მარტივი კოდის მაგალითი, რომელიც ახორციელებს RAG მოდელს DSPy-ისა და LangChain-ის გამოყენებით და მოგვაწოდეთ 5-10 ყველაზე ხშირად გამოყენებული ბრძანებების/სნიპეტების სია DSPy-სა და LangChain-ისთვის. ჩვენ ასევე ჩავრთეთ ვიზუალიზაციის მაგალითი Chart.js-ის გამოყენებით. ამ სტატიაში ასახული ნაბიჯების დაცვით, დეველოპერებს შეუძლიათ შექმნან და განათავსონ AI-ზე მომუშავე DevOps მილსადენები, რომლებიც აღმოაჩენენ და აგვარებენ ინციდენტებს პროაქტიულად, აუმჯობესებენ მათი პროგრამული სისტემების საერთო ეფექტურობასა და საიმედოობას.