ਜਾਣ-ਪਛਾਣ

ਆਧੁਨਿਕ ਸੌਫਟਵੇਅਰ ਪ੍ਰਣਾਲੀਆਂ ਦੀ ਲਗਾਤਾਰ ਵਧ ਰਹੀ ਗੁੰਝਲਤਾ ਨੇ ਘਟਨਾਵਾਂ ਦੀ ਬਾਰੰਬਾਰਤਾ ਅਤੇ ਗੰਭੀਰਤਾ ਵਿੱਚ ਵਾਧਾ ਕੀਤਾ ਹੈ, ਜਿਸ ਨਾਲ ਕਿਰਿਆਸ਼ੀਲ ਘਟਨਾ ਦੀ ਜਾਂਚ ਅਤੇ ਰੈਜ਼ੋਲੂਸ਼ਨ ਨੂੰ DevOps ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ (AI) ਅਤੇ ਮਸ਼ੀਨ ਲਰਨਿੰਗ (ML) DevOps ਪਾਈਪਲਾਈਨਾਂ ਨੂੰ ਵਧਾਉਣ ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਟੂਲ ਵਜੋਂ ਉਭਰੇ ਹਨ, ਜਿਸ ਨਾਲ AI-ਚਾਲਿਤ ਆਟੋਮੇਸ਼ਨ ਅਤੇ ਆਰਕੈਸਟੇਸ਼ਨ ਨੂੰ ਕਾਰੋਬਾਰ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਘਟਨਾਵਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਹੱਲ ਕਰਨ ਲਈ ਸਮਰੱਥ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਖੋਜ ਕਰਾਂਗੇ ਕਿ DSPy ਅਤੇ LangChain ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI-ਸੰਚਾਲਿਤ DevOps ਪਾਈਪਲਾਈਨਾਂ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ, AIOps ਅਤੇ RAG ਮਾਡਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਿਰਿਆਸ਼ੀਲ ਘਟਨਾ ਦੀ ਜਾਂਚ ਅਤੇ ਰੈਜ਼ੋਲੂਸ਼ਨ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦੇ ਹੋਏ, ਅਤੇ ਸਵੈਚਲਿਤ ਘਟਨਾ ਦੀ ਜਾਂਚ ਲਈ AWS DevOps ਏਜੰਟ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ।

DSPy ਅਤੇ LangChain ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

DSPy ਇੱਕ ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜੋ AI-ਪਾਵਰਡ DevOps ਪਾਈਪਲਾਈਨਾਂ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਤੈਨਾਤ ਕਰਨ ਦਾ ਇੱਕ ਸਧਾਰਨ ਅਤੇ ਕੁਸ਼ਲ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਇਹ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਉਹਨਾਂ ਦੀਆਂ DevOps ਪਾਈਪਲਾਈਨਾਂ ਵਿੱਚ ਕੁਦਰਤੀ ਭਾਸ਼ਾ ਪ੍ਰੋਸੈਸਿੰਗ (NLP), ਕੰਪਿਊਟਰ ਵਿਜ਼ਨ, ਅਤੇ ਭਵਿੱਖਬਾਣੀ ਵਿਸ਼ਲੇਸ਼ਣ ਸਮੇਤ ਵੱਖ-ਵੱਖ AI ਅਤੇ ML ਮਾਡਲਾਂ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਦੂਜੇ ਪਾਸੇ, LangChain, ਇੱਕ ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜੋ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਇੱਕ ਮਾਡਿਊਲਰ ਅਤੇ ਸਕੇਲੇਬਲ ਆਰਕੀਟੈਕਚਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵੱਡੇ ਪੈਮਾਨੇ ਦੇ AI ਮਾਡਲਾਂ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਤੈਨਾਤ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦੀ ਹੈ।

DSPy ਅਤੇ LangChain ਨਾਲ AI-ਪਾਵਰਡ DevOps ਪਾਈਪਲਾਈਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

DSPy ਅਤੇ LangChain ਨਾਲ AI-ਸੰਚਾਲਿਤ DevOps ਪਾਈਪਲਾਈਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇਹਨਾਂ ਪੜਾਵਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

1. ਡਾਟਾ ਸੰਗ੍ਰਹਿ: ਵੱਖ-ਵੱਖ ਸਰੋਤਾਂ, ਜਿਵੇਂ ਕਿ ਲੌਗ, ਮੈਟ੍ਰਿਕਸ, ਅਤੇ ਕੌਂਫਿਗਰੇਸ਼ਨ ਫਾਈਲਾਂ ਤੋਂ ਸੰਬੰਧਿਤ ਡੇਟਾ ਇਕੱਠਾ ਕਰੋ।
2. ਡਾਟਾ ਪ੍ਰੀਪ੍ਰੋਸੈਸਿੰਗ: ਇਕੱਤਰ ਕੀਤੇ ਡੇਟਾ ਨੂੰ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਮਾਡਲਿੰਗ ਲਈ ਤਿਆਰ ਕਰਨ ਲਈ ਪ੍ਰੀਪ੍ਰੋਸੈਸ ਕਰੋ।
3. ਮਾਡਲ ਸਿਖਲਾਈ: ਘਟਨਾਵਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਲਈ ਪ੍ਰੀ-ਪ੍ਰੋਸੈੱਸਡ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI ਅਤੇ ML ਮਾਡਲਾਂ ਨੂੰ ਸਿਖਲਾਈ ਦਿਓ।
4. ਮਾਡਲ ਤੈਨਾਤੀ: ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਮਾਡਲਾਂ ਨੂੰ DSPy ਅਤੇ LangChain ਦੀ ਵਰਤੋਂ ਕਰਕੇ DevOps ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਤੈਨਾਤ ਕਰੋ।
5. ਘਟਨਾ ਦੀ ਜਾਂਚ: ਘਟਨਾਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਮੂਲ ਕਾਰਨਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਤੈਨਾਤ ਮਾਡਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।
6. ਘਟਨਾ ਹੱਲ: ਘਟਨਾਵਾਂ ਨੂੰ ਸਰਗਰਮੀ ਨਾਲ ਹੱਲ ਕਰਨ ਲਈ ਘਟਨਾ ਦੀ ਜਾਂਚ ਤੋਂ ਪ੍ਰਾਪਤ ਜਾਣਕਾਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਕੋਡ ਉਦਾਹਰਨ: DSPy ਅਤੇ LangChain ਦੇ ਨਾਲ ਇੱਕ ਸਧਾਰਨ RAG ਮਾਡਲ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ ਕੋਡ ਉਦਾਹਰਨ ਹੈ ਜੋ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ DSPy ਅਤੇ LangChain ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ RAG (ਰੂਟ ਕਾਰਨ ਵਿਸ਼ਲੇਸ਼ਣ) ਮਾਡਲ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ: ``ਅਜਗਰ ਡੀਐਸਪੀ ਨੂੰ ਆਯਾਤ ਕਰੋ ਲੈਂਗਚੈਨ ਆਯਾਤ ਐਲਐਲਐਮਚੇਨ ਤੋਂ

ਪ੍ਰੀਪ੍ਰੋਸੈਸਡ ਡੇਟਾ ਲੋਡ ਕਰੋ

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 = LLMCਚੇਨ ( model="davinci:002", ਅਧਿਕਤਮ_ਲੰਬਾਈ = 2048 ) rag_model.deploy(llm_chain)

ਘਟਨਾਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਤੈਨਾਤ RAG ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰੋ

ਘਟਨਾ_ਡਾਟਾ = pd.ਡਾਟਾਫ੍ਰੇਮ ({ "log_level": ["ERROR"], "error_message": ["ਕੁਝ ਗਲਤ ਹੋ ਗਿਆ"] }) root_cause = rag_model.predict(ਘਟਨਾ_ਡਾਟਾ) ਪ੍ਰਿੰਟ(ਰੂਟ_ਕਾਰਨ) `` ਇਹ ਕੋਡ ਉਦਾਹਰਨ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ 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 LLMCchain ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ RAG ਮਾਡਲ ਨੂੰ ਤੈਨਾਤ ਕਰੋ।
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): DSPy ਦੀ ਵਰਤੋਂ ਕਰਕੇ AI ਜਾਂ ML ਮਾਡਲ ਨੂੰ ਸਿਖਲਾਈ ਦਿਓ।
8. dspy.ModelDeployer(model, llm_chain): DSPy ਅਤੇ LangChain ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਮਾਡਲ ਤੈਨਾਤ ਕਰੋ।
9. langchain.LLMChain.predict(input_data): ਇੱਕ ਮਾਡਲ ਦੇ ਆਉਟਪੁੱਟ ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਣ ਲਈ ਇੱਕ Langchain LLMChain ਦੀ ਵਰਤੋਂ ਕਰੋ।
10. dspy.RAGModel.evaluate(data): DSPy ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ RAG ਮਾਡਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰੋ।

ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ

ਇੱਥੇ Chart.js ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਦਾ ਇੱਕ ਉਦਾਹਰਨ ਹੈ: ਜੇਸਨ { "type": "ਪੱਟੀ", "ਡਾਟਾ": { "labels": ["ਘਟਨਾ ਦੀ ਕਿਸਮ A", "ਘਟਨਾ ਦੀ ਕਿਸਮ B", "ਘਟਨਾ ਕਿਸਮ C"], "datasets": [ { "label": "ਰੂਟ ਕਾਰਨ ਏ", "ਡਾਟਾ": [10, 15, 7], "ਬੈਕਗ੍ਰਾਉਂਡ ਰੰਗ": "rgba(255, 99, 132, 0.2)", "borderColor": "rgba(255, 99, 132, 1)", "ਬਾਰਡਰ ਚੌੜਾਈ": 1 }, { "label": "ਰੂਟ ਕਾਰਨ ਬੀ", "ਡਾਟਾ": [8, 12, 9], "ਬੈਕਗ੍ਰਾਉਂਡ ਰੰਗ": "rgba(54, 162, 235, 0.2)", "borderColor": "rgba(54, 162, 235, 1)", "ਬਾਰਡਰ ਚੌੜਾਈ": 1 }, { "label": "ਰੂਟ ਕਾਰਨ C", "ਡਾਟਾ": [14, 18, 11], "ਬੈਕਗ੍ਰਾਉਂਡ ਰੰਗ": "rgba(255, 206, 86, 0.2)", "borderColor": "rgba(255, 206, 86, 1)", "ਬਾਰਡਰ ਚੌੜਾਈ": 1 } ] }, "ਵਿਕਲਪ": { "ਸਿਰਲੇਖ": { "ਡਿਸਪਲੇ": ਸਹੀ, "text": "ਜੜ੍ਹ ਕਾਰਨ ਵਿਸ਼ਲੇਸ਼ਣ" }, "ਪੈਮਾਨਾ": { "yAxes": [ { "ਟਿਕਸ": { "beginAtZero": ਸਹੀ } } ] } } } ਇਹ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਵੱਖ-ਵੱਖ ਘਟਨਾਵਾਂ ਦੀਆਂ ਕਿਸਮਾਂ ਦੇ ਮੂਲ ਕਾਰਨਾਂ ਦੀ ਵੰਡ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।

ਸਿੱਟਾ

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਖੋਜ ਕੀਤੀ ਹੈ ਕਿ DSPy ਅਤੇ LangChain ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI-ਸੰਚਾਲਿਤ DevOps ਪਾਈਪਲਾਈਨਾਂ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ, AIOps ਅਤੇ RAG ਮਾਡਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਿਰਿਆਸ਼ੀਲ ਘਟਨਾ ਦੀ ਜਾਂਚ ਅਤੇ ਰੈਜ਼ੋਲੂਸ਼ਨ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦੇ ਹੋਏ, ਅਤੇ ਸਵੈਚਲਿਤ ਘਟਨਾ ਦੀ ਜਾਂਚ ਲਈ AWS DevOps ਏਜੰਟ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ। ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਕੋਡ ਉਦਾਹਰਨ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕੀਤਾ ਜੋ DSPy ਅਤੇ LangChain ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ RAG ਮਾਡਲ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਅਤੇ DSPy ਅਤੇ LangChain ਲਈ ਚੋਟੀ ਦੇ 5-10 ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਕਮਾਂਡਾਂ/ਸਨਿਪਟਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਅਸੀਂ Chart.js ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਉਦਾਹਰਨ ਵੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ। ਇਸ ਲੇਖ ਵਿੱਚ ਦੱਸੇ ਗਏ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਡਿਵੈਲਪਰ AI-ਸੰਚਾਲਿਤ DevOps ਪਾਈਪਲਾਈਨਾਂ ਦਾ ਨਿਰਮਾਣ ਅਤੇ ਤੈਨਾਤ ਕਰ ਸਕਦੇ ਹਨ ਜੋ ਉਹਨਾਂ ਦੇ ਸੌਫਟਵੇਅਰ ਸਿਸਟਮਾਂ ਦੀ ਸਮੁੱਚੀ ਕੁਸ਼ਲਤਾ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦੇ ਹੋਏ, ਘਟਨਾਵਾਂ ਨੂੰ ਸਰਗਰਮੀ ਨਾਲ ਖੋਜ ਅਤੇ ਹੱਲ ਕਰਦੇ ਹਨ।