MLOps के लिए Jenkins: एक संपूर्ण CI/CD ट्यूटोरियल

Windows 11 पर Jenkins सेटअप करना

हम आसानी से Jenkins को Linux और macOS पर इंस्टॉल कर सकते हैं। हालांकि, Windows पर इसे इंस्टॉल करने के लिए कई चरणों की आवश्यकता होती है। इन चरणों में Java Development Kit इंस्टॉल करना, लोकल सिक्योरिटी पॉलिसी सेट करना, डोमेन यूज़र के साथ Jenkins इंस्टॉल करना, और Jenkins सर्वर शुरू करना शामिल है।

OpenJDK इंस्टॉल करना

आइए Java इंस्टॉल करने से शुरू करते हैं। हमें Adoptium वेबसाइट पर जाना है और Windows 11 के लिए नवीनतम LTS रिलीज़ डाउनलोड करनी है।

हमें OpenJDK क्यों इंस्टॉल करना चाहिए? Jenkins एक Java-आधारित एप्लिकेशन है जिसे चलाने के लिए Java Runtime Environment (JRE) या Java Development Kit (JDK) की आवश्यकता होती है।

छवि स्रोत: Adoptium

OpenJDK को डिफ़ॉल्ट मानों के साथ इंस्टॉल करें, सिवाय इसके कि हमें “Set or override JAVA_HOME variable” विकल्प को चेक करना होगा।

इंस्टॉलेशन पूरा होने के बाद, हम टर्मिनल विंडो में java -version टाइप करके जाँच सकते हैं कि यह सही से इंस्टॉल हुआ है या नहीं:

“Log on as service” के लिए यूज़र अकाउंट सेट करना

Jenkins इंस्टॉल करने के लिए, आपको इंस्टॉलर के लिए यूज़र लॉगिन एक्सेस सक्षम करने हेतु “Local Security Policy” में बदलाव करने की आवश्यकता है। ऐसा करने के लिए, कीबोर्ड पर Win + R दबाएँ, “secpol.msc” टाइप करें और Enter दबाएँ। इसके बाद “Local Policies” > “User Rights Assignments” > “Log on as a service” पर जाएँ।

हम एक नई विंडो पर रीडायरेक्ट होंगे, जहाँ हम अपना Windows यूज़रनेम टाइप करेंगे और “Check Names” बटन पर क्लिक करेंगे। इसके बाद, “OK” बटन दबाएँ और “Local Security Policy” विंडो से बाहर निकलें।

Jenkins इंस्टॉल करना

jenkins.io वेबसाइट पर जाएँ और Jenkins के लिए Windows Installer पैकेज डाउनलोड करें।  

छवि स्रोत: jenkins.io

जब हम उस विंडो पर पहुँचें जहाँ लिखा हो "Run service as a local or domain user," तो अपना Windows यूज़रनेम और पासवर्ड टाइप करें, फिर “Test Credentials” बटन दबाएँ। यदि स्वीकृत हो, तो “Next” बटन पर क्लिक करें।

बाकी सब कुछ डिफ़ॉल्ट पर रखें और इंस्टॉलेशन पूरा करें। सेटअप होने में कुछ मिनट लग सकते हैं।

Jenkins सर्वर शुरू करना

Jenkins सर्वर शुरू करना सरल है। हमें बस Windows कुंजी दबाकर "Services" खोजनी है। Services विंडो में, Jenkins खोजें और ऊपर दिए गए प्ले बटन पर क्लिक करें।

डिफ़ॉल्ट रूप से, Jenkins https://localhost:8080/ पर चलता है। डैशबोर्ड तक पहुँचने के लिए बस उस URL को ब्राउज़र में पेस्ट करें। Jenkins डैशबोर्ड में प्रवेश करने के लिए आपको एडमिनिस्ट्रेटर पासवर्ड टाइप करना होगा।

डिफ़ॉल्ट एडमिनिस्ट्रेटर पासवर्ड प्राप्त करने के लिए, Jenkins डायरेक्टरी पर जाएँ और Jenkins.err.log फ़ाइल को ढूँढकर खोलें।

Jenkins एरर फ़ाइल को नीचे स्क्रॉल करें और जनरेटेड पासवर्ड ढूँढें। उसे कॉपी करें और एडमिनिस्ट्रेटर पासवर्ड इनपुट बॉक्स में पेस्ट करें।

इसके बाद, सर्वर आवश्यक टूल्स और एक्सटेंशन्स को इंस्टॉल करने में कुछ मिनट लेगा।

सर्वर सेटअप पूरा होने पर, यह हमें नया यूज़र बनाने के लिए कहेगा। सभी आवश्यक जानकारी दर्ज करें और "Save and Continue" बटन पर क्लिक करें।

हमें डैशबोर्ड पर ले जाया जाएगा, जहाँ हम विभिन्न Jenkins पाइपलाइन्स बना, देख और चला सकते हैं। 

Jenkins में एक एजेंट बनाना

एजेंट्स, जिन्हें नोड्स भी कहा जाता है, वे मशीनें हैं जिन्हें Jenkins मास्टर सर्वर द्वारा भेजे गए जॉब्स को निष्पादित करने के लिए सेटअप किया जाता है। ये एजेंट्स पाइपलाइन्स चलाने के लिए आवश्यक वातावरण और कंप्यूट प्रदान करते हैं। डिफ़ॉल्ट रूप से Windows 11 एजेंट उपलब्ध है, लेकिन हम कस्टम विकल्पों के साथ अपना एजेंट हमेशा बना सकते हैं।

एजेंट्स सेट करना

मुख्य डैशबोर्ड पर, “Manage Jenkins” विकल्प पर क्लिक करें और फिर नीचे दिखाए अनुसार “Set up agent” बटन पर क्लिक करें। वैकल्पिक रूप से, आप एजेंट्स बनाने और प्रबंधित करने के लिए “Nodes” बटन पर भी क्लिक कर सकते हैं।

एजेंट का नाम टाइप करें और “Permanent Agent” प्रकार चुनें। 

कृपया एजेंट के लिए एक डायरेक्टरी प्रदान करना सुनिश्चित करें जहाँ सभी फ़ाइलें और लॉग सेव होंगे। एक लेबल जोड़ें और बाकी सेटिंग्स को डिफ़ॉल्ट पर रखें। पाइपलाइन बनाते समय, हम टास्क्स चलाने के लिए एजेंट लेबल का उपयोग करेंगे।

एजेंट को लोकली चलाना

“Save” बटन दबाने पर, एक प्रॉम्प्ट दिखाई देगा, जो हमें हमारे ऑपरेटिंग सिस्टम के आधार पर उपयुक्त कमांड को टर्मिनल में कॉपी-पेस्ट करने के लिए निर्देश देगा।

curl.exe -sO http://localhost:8080/jnlpJars/agent.jar & java -jar agent.jar -url http://localhost:8080/ -secret 1a30c62de92630dbcc1e2f19aaf482057e6170ced6835355447bc4ba4eefb76a -name "DC Agent 1" -webSocket -workDir "/home/Jenkins"संचालित द्वारा

टर्मिनल में कमांड पेस्ट और रन करने के बाद, हमें एक सफलता संदेश दिखाई देगा जो बताएगा कि हमारा एजेंट, मेरे मामले में DC Agent 1, बैकग्राउंड में चल रहा है।

यह जाँचने के लिए कि एजेंट चल रहा है और जॉब निष्पादित करने के लिए तैयार है, Jenkins डैशबोर्ड पर जाएँ, “Manage Jenkins” पर क्लिक करें, और फिर एजेंट की स्थिति देखने के लिए “Nodes” बटन पर क्लिक करें।

एक सरल Jenkins पाइपलाइन बनाना 

Jenkins पाइपलाइन स्वचालित चरणों की एक श्रृंखला है जो मॉडलों के प्रशिक्षण, इवैल्युएशन और परिनियोजन में मदद करती है। यह इन प्रक्रियाओं को एक सरल प्रोग्रामिंग स्क्रिप्ट का उपयोग करके परिभाषित करती है, जिससे प्रोजेक्ट वर्कफ़्लोज़ को मैनेज और ऑटोमेट करना आसान हो जाता है।

इस खंड में, हम एक सैंपल Jenkins पाइपलाइन बनाएंगे और अपने नए बनाए गए एजेंट को पाइपलाइन एक्ज़ीक्यूटर के रूप में उपयोग करेंगे।

Jenkins पाइपलाइन सेट करना 

डैशबोर्ड पर, “New Item” बटन पर क्लिक करें, आइटम का नाम टाइप करें, “Pipeline” विकल्प चुनें और “OK” पर क्लिक करें।

इसके बाद, एक प्रॉम्प्ट हमें पाइपलाइन कॉन्फ़िगर करने के लिए कहेगा। नीचे “Pipeline” सेक्शन तक स्क्रॉल करें, जहाँ हमें Jenkins पाइपलाइन स्क्रिप्ट लिखनी है।

Jenkins पाइपलाइन स्क्रिप्ट में, हम वातावरण और एजेंट सेट करने से शुरू करते हैं। हमारे मामले में, हम agent को पहले परिभाषित किए गए एजेंट के लेबल के साथ सेट कर रहे हैं।

इसके बाद, हम stages सेक्शन लिखेंगे जहाँ पाइपलाइन के सभी विभिन्न चरण (Build, Test, Deploy) जोड़े जाएंगे। हमारे मामले में, हम केवल echo कमांड से प्रिंट कर रहे हैं और bat कमांड का उपयोग करके टर्मिनल कमांड्स चला रहे हैं।

• bat Windows 11 के लिए उपयोग होता है
• sh Linux के लिए

बस इतना ही। यह इतना सरल है। यहाँ स्क्रिप्ट कोड है:

pipeline {
    agent {
        label 'MLAgent' // Ensure this label matches your Windows 11 agent
    }

    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                // Add your Windows build commands here
                bat 'echo Running build commands'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                // Add your Windows test commands here
                bat 'echo Running test commands'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                // Add your Windows deploy commands here
                bat 'echo Running deploy commands'
            }
        }
    }
}संचालित द्वारा

स्क्रिप्ट जोड़ने के बाद, “Apply” और “Save” बटन पर क्लिक करें।

Jenkins पाइपलाइन चलाना

पाइपलाइन को टेस्ट और रन करने के लिए “Build Now” बटन पर क्लिक करें। इसकी स्थिति देखने के लिए “Status” बटन पर क्लिक करें। 

रन पूरा होने के बाद, हम "Status" मेनू में किसी विशिष्ट रन पर क्लिक करके लॉग्स देख सकते हैं। 

"Last build (#2)" लिंक पर क्लिक करें और फिर "Console Output" बटन पर क्लिक करें। यह हमें कंसोल आउटपुट विंडो पर ले जाएगा, जहाँ हम पाइपलाइन के लॉग्स और परिणाम पा सकते हैं।

हम “Pipeline Console” बटन पर क्लिक करके पाइपलाइन के हर चरण को विस्तार से भी देख सकते हैं। इसमें आउटपुट, शुरू और समाप्त होने में लगा समय, पाइपलाइन कमांड्स और लॉग्स शामिल होते हैं। 

एक MLOps प्रोजेक्ट के लिए Jenkins पाइपलाइन बनाना

Jenkins का प्रारंभिक परिचय हो जाने के बाद, अब गंभीर होने और MLOps प्रोजेक्ट पर काम करने का समय है। 

हम दो पाइपलाइन्स बनाएंगे: पहली पाइपलाइन CI होगी, जो डेटा को लोड और प्रोसेस करेगी, मॉडल को ट्रेन करेगी, मॉडल का इवैल्युएशन करेगी, और फिर मॉडल सर्वर का परीक्षण करेगी। इसके बाद, यह CD पाइपलाइन शुरू करेगी, जो मॉडल इन्फरेंस सर्वर को स्टार्ट करेगी।

प्रक्रिया को विस्तार से समझने के लिए, CI/CD for Machine Learning कोर्स लें, जो आपको मशीन लर्निंग विकास प्रक्रियाओं को सुव्यवस्थित करना सिखाता है।

प्रोजेक्ट फ़ाइलें

किसी भी प्रोजेक्ट की तरह, हमें प्रोजेक्ट फ़ाइलें बनानी हैं, जिनमें डेटा लोडिंग, मॉडल ट्रेनिंग, मॉडल इवैल्युएशन, और मॉडल सर्विंग की Python फ़ाइलें शामिल हैं। आवश्यक Python पैकेज इंस्टॉल करने के लिए हमें requirements .txt फ़ाइल भी चाहिए।

data_loading.py:

इस स्क्रिप्ट में, हम scikit-learn का Wine डेटासेट लोड करेंगे और उसे pandas DataFrame में कन्वर्ट करेंगे। फिर हम डेटासेट को ट्रेनिंग और टेस्टिंग सेट्स में बाँटेंगे। अंत में, हम प्रोसेस्ड डेटा को एक पिकल फ़ाइल के रूप में सेव करेंगे।

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
import pandas as pd
import joblib

def load_data():
    # Load the wine dataset
    wine = load_wine(as_frame=True)
    data = pd.DataFrame(data=wine.data, columns=wine.feature_names)
    data["target"] = wine.target
    print(data.head())
    return data

def split_data(data, target_column="target"):
    X = data.drop(columns=[target_column])
    y = data[target_column]
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    return X_train, X_test, y_train, y_test

def save_preprocessed_data(X_train, X_test, y_train, y_test, file_path):
    joblib.dump((X_train, X_test, y_train, y_test), file_path)


if __name__ == "__main__":
    data = load_data()
    X_train, X_test, y_train, y_test = split_data(data)
    save_preprocessed_data(X_train, X_test, y_train, y_test, "preprocessed_data.pkl")संचालित द्वारा

model_training.py:

इस फ़ाइल में, हम प्रोसेस्ड डेटा लोड करेंगे, एक रैंडम फॉरेस्ट क्लासिफायर ट्रेन करेंगे, और मॉडल को पिकल फ़ाइल के रूप में सेव करेंगे।

from sklearn.ensemble import RandomForestClassifier
import joblib

def load_preprocessed_data(file_path):
    return joblib.load(file_path)

def train_model(X_train, y_train):
    model = RandomForestClassifier(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)
    return model

def save_model(model, file_path):
    joblib.dump(model, file_path)


if __name__ == "__main__":
    X_train, X_test, y_train, y_test = load_preprocessed_data("preprocessed_data.pkl")

    model = train_model(X_train, y_train)
    save_model(model, "model.pkl")संचालित द्वारा

model_evaluation.py:

मॉडल का इवैल्युएशन करने के लिए, हम मॉडल और प्रोसेस्ड डेटासेट दोनों को लोड करेंगे, एक क्लासिफिकेशन रिपोर्ट जनरेट करेंगे, और एक्यूरेसी स्कोर प्रिंट करेंगे।

import joblib
from sklearn.metrics import accuracy_score, classification_report

def load_model(file_path):
    return joblib.load(file_path)

def load_preprocessed_data(file_path):
    return joblib.load(file_path)

def evaluate_model(model, X_test, y_test):
    predictions = model.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)
    report = classification_report(y_test, predictions)
    return accuracy, report

if __name__ == "__main__":
    X_train, X_test, y_train, y_test = load_preprocessed_data("preprocessed_data.pkl")

    model = load_model("model.pkl")
    accuracy, report = evaluate_model(model, X_test, y_test)
    print(f"Model Accuracy: {accuracy}")
    print(f"Classification Report:\n{report}")संचालित द्वारा

model_serving.py:

मॉडल सर्विंग के लिए, हम FastAPI का उपयोग करके एक REST API बनाएँगे, जहाँ उपयोगकर्ता फीचर्स दर्ज कर सकें और प्रेडिक्शन प्राप्त कर सकें। सामान्यतः, लेबल जनरिक होते हैं। चीज़ों को अधिक रोचक बनाने के लिए, हम वाइन श्रेणियों को Verdante, Rubresco, और Floralis में बदलेंगे।

जब हम इस फ़ाइल को चलाते हैं, तो हम FastAPI सर्वर लॉन्च करते हैं, जिसे हम curl कमांड या Python में requests लाइब्रेरी का उपयोग करके एक्सेस कर सकते हैं।

from typing import List

import joblib
import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# Define the labels corresponding to the target classes
LABELS = [
    "Verdante",  # A vibrant and fresh wine, inspired by its balanced acidity and crisp flavors.
    "Rubresco",  # A rich and robust wine, named for its deep, ruby color and bold taste profile.
    "Floralis",  # A fragrant and elegant wine, known for its floral notes and smooth finish.
]

class Features(BaseModel):
    features: List[float]

def load_model(file_path):
    return joblib.load(file_path)

model = load_model("model.pkl")

@app.post("/predict")
def predict(features: Features):
    # Get the numerical prediction
    prediction_index = model.predict([features.features])[0]
    # Map the numerical prediction to the label
    prediction_label = LABELS[prediction_index]
    return {"prediction": prediction_label}

if __name__ == "__main__":
    uvicorn.run(app, host="127.0.0.1", port=9000)संचालित द्वारा

requirements.txt:

यह फ़ाइल हमें उपरोक्त Python फ़ाइलों को चलाने के लिए आवश्यक सभी पैकेज डाउनलोड और इंस्टॉल करने में मदद करेगी।

scikit-learn
pandas
fastapi
uvicornसंचालित द्वारा

मुख्य MLOps (CI) पाइपलाइन 

अब हम निरंतर इंटीग्रेशन Jenkins पाइपलाइन्स बनाएँगे। जैसे हमने एक सरल पाइपलाइन बनाई थी, वैसे ही हम "MLOps-pipe" बनाएँगे और डेटा प्रोसेसिंग से लेकर मॉडल इवैल्युएशन तक सब कुछ कवर करने वाली स्क्रिप्ट लिखेंगे।

MLOps पाइपलाइन स्क्रिप्ट में शामिल हैं:

1. agent को “MLAgent” label के साथ इनिशियलाइज़ करना।
2. वर्कस्पेस डायरेक्टरी सेट करना जहाँ हमारी सभी Python फ़ाइलें स्थित हैं।
3. मशीन लर्निंग पाइपलाइन के प्रत्येक चरण के लिए स्टेज बनाना:
1. सभी आवश्यक Python पैकेज इंस्टॉल करना (Initialize).
2. लोड किए गए डेटासेट को प्रोसेस करना (Load and Preprocess Data).
3. प्रोसेस्ड डेटासेट पर मॉडल ट्रेन करना (Train Model).
4. मॉडल का इवैल्युएशन करना और रिपोर्ट जनरेट करना (Evaluate Model).
5. curl कमांड का उपयोग करके मॉडल सर्वर का परीक्षण करना (Test Serve Model).
4. सर्वर टेस्टिंग पास होने के बाद, सर्वर डिप्लॉय करने के लिए एक अन्य पाइपलाइन ट्रिगर होगी। इसे अगले खंड में कवर किया जाएगा।
5. पोस्ट नोड में, हम डेटा प्रोसेस करेंगे और उसे पिकल फ़ाइल एक्सटेंशन देकर एक आर्टिफ़ैक्ट के रूप में सेव करेंगे।

नोट: start /B कमांड बैकग्राउंड में एक नया टर्मिनल विंडो लॉन्च करता है और मॉडल-सर्विंग स्क्रिप्ट चलाता है। साथ ही, यह Jenkins पाइपलाइन स्क्रिप्ट केवल Windows पर काम करेगी; Linux या अन्य ऑपरेटिंग सिस्टम्स के लिए हमें कमांड्स बदलने होंगे।

pipeline {
    agent { 
        node { 
            label 'MLAgent' 
            customWorkspace 'C:\\Repository\\GitHub\\MLOps-Jenkins' 
        } 
    }

    stages {
        stage('Initialize') {
            steps {
                script {
                    // Install necessary Python packages
                    bat "pip install -r requirements.txt"
                }
            }
        }

        stage('Load and Preprocess Data') {
            steps {
                script {
                    // Run data loading script
                    bat "python data_loading.py"
                }
            }
        }

        stage('Train Model') {
            steps {
                script {
                    // Run model training script
                    bat "python model_training.py"
                }
            }
        }

        stage('Evaluate Model') {
            steps {
                script {
                    // Run model evaluation script
                    bat "python model_evaluation.py"
                }
            }
        }

        stage('Serve Model') {
            steps {
                script {
                    // Start FastAPI server in the background
                    bat 'start /B python model_serving.py'
                    // Wait for the server to start
                    sleep time: 10, unit: 'SECONDS'
                }
            }
        }

        stage('Test Serve Model') {
            steps {
                script {
                    // Test the server with sample values
                    bat '''
                        curl -X POST "http://127.0.0.1:9000/predict" ^
                        -H "Content-Type: application/json" ^
                        -d "{\\"features\\": [13.2, 2.77, 2.51, 18.5, 103.0, 1.15, 2.61, 0.26, 1.46, 3.0, 1.05, 3.33, 820.0]}"
                    '''
                }
            }
        }

        stage('Deploy Model') {
            steps {
                script {
                    // Trigger another Jenkins job for model serving
                    build job: 'ModelServingPipeline', wait: false
                }
            }
        }
    }

    post {
        always {
            archiveArtifacts artifacts: '**.pkl', fingerprint: true
            echo 'Pipeline execution complete.'
        }
    }
}संचालित द्वारा

मॉडल सर्विंग (CD) पाइपलाइन 

अब हम सर्वर को लोकली डिप्लॉय और रन करने के लिए एक निरंतर परिनियोजन पाइपलाइन बनाएँगे।

पाइपलाइन स्क्रिप्ट सरल है। हम एजेंट को परिभाषित करने और वर्किंग डायरेक्टरी को अपने प्रोजेक्ट पर बदलने से शुरू करते हैं। इसके बाद, हम सर्वर को अनिश्चितकाल तक चलाते हैं। 

नोट: Jenkins में सर्वर को अनिश्चितकाल तक चलाना अनुशंसित नहीं है, क्योंकि पाइपलाइन्स का एक निश्चित आरंभ और अंत होना चाहिए। इस उदाहरण में, हम मान लेते हैं कि हमने ऐप को डिप्लॉय कर दिया है, लेकिन व्यवहार में, Docker को इंटीग्रेट करना और ऐप को Docker सर्वर पर चलाना बेहतर होता है।

यदि आप यह सीखने में रुचि रखते हैं कि एक मशीन लर्निंग इंजीनियर की तरह कैसे सोचा जाए, तो Developing Machine Learning Models for Production with an MLOps Mindset कोर्स करने पर विचार करें, जो आपको अपने मशीन लर्निंग मॉडलों को उनकी पूरी क्षमता तक ट्रेन, डॉक्यूमेंट, मेंटेन और स्केल करने में सक्षम बनाएगा।

pipeline {
    agent { 
        node { 
            label 'MLAgent' 
            customWorkspace 'C:/Repository/GitHub/MLOps-Jenkins/' 
        } 
    }

    stages {
        stage('Start FastAPI Server') {
            steps {
                script {
                    // Start the FastAPI server
                    bat 'python model_serving.py'
                }
            }
        }
    }

}संचालित द्वारा

CI/CD पाइपलाइन्स चलाना

“MLOps-pipe” पाइपलाइन पर जाएँ और CI/CD पाइपलाइन प्रारंभ करने के लिए “Build Now” बटन पर क्लिक करें।

पाइपलाइन सफलतापूर्वक निष्पादित हो जाने पर, यह दो आर्टिफ़ैक्ट्स जनरेट करती है: एक मॉडल के लिए और एक प्रोसेस्ड डेटासेट के लिए।

Jenkins डैशबोर्ड पर “Stages” बटन पर क्लिक करके पाइपलाइन का विज़ुअलाइज़ेशन करें और सभी चरणों को देखें।

प्रत्येक चरण के विस्तृत लॉग देखने के लिए, "Pipeline Console" मेनू देखें।

हम "ModelServingPipeline" भी देख सकते हैं ताकि यह सत्यापित हो सके कि हमारा सर्वर लोकल URL http://127.0.0.1:9000 पर चल रहा है। 

ब्राउज़र में FastAPI एप्लिकेशन आज़माना

FastAPI के साथ Swagger UI आता है, जिसे लोकल URL में /docs जोड़कर एक्सेस किया जा सकता है: http://127.0.0.1:9000/docs।

Swagger UI हमें ब्राउज़र में FastAPI एप्लिकेशन टेस्ट करने देता है। यह सरल है, और हम देख सकते हैं कि हमारा मॉडल सर्वर ठीक से काम कर रहा है। प्रेडिक्टेड सैंपल वैल्यूज़ बताती हैं कि वाइन का प्रकार Rubresco है।

हमेशा यह सुनिश्चित करें कि प्रयोग समाप्त करने के बाद आप मॉडल सर्वर को शट डाउन कर दें। आप ऐसा Jenkins डैशबोर्ड में “Status” मेनू पर जाकर और फिर नीचे दिखाए अनुसार क्रॉस बटन पर क्लिक करके कर सकते हैं:

इस ट्यूटोरियल में दिए गए सभी कोड, डेटासेट्स, मॉडल और मेटाफ़ाइल्स GitHub रिपॉज़िटरी पर उपलब्ध हैं, जिन्हें आप आज़मा सकते हैं: kingabzpro/MLOps-with-Jenkins.

निष्कर्ष

Jenkins सभी प्रकार के MLOps कार्यों के लिए एक बेहतरीन ऑटोमेशन सर्वर है। यह अधिक फीचर्स, बेहतर नियंत्रण और उन्नत प्राइवेसी प्रदान करके GitHub Actions का एक उत्कृष्ट विकल्प साबित होता है। 

Jenkins का सबसे आकर्षक पहलू इसकी पाइपलाइन बनाने और चलाने की सरलता है, जो इसे शुरुआती और अनुभवी, दोनों प्रकार के उपयोगकर्ताओं के लिए सुलभ बनाती है।

यदि आप GitHub Actions का उपयोग करके समान क्षमताओं का पता लगाना चाहते हैं, तो A Beginner's Guide to CI/CD for Machine Learning ट्यूटोरियल न चूकें। जो लोग MLOps की समझ को गहरा करना चाहते हैं, उनके लिए Fully Automated MLOps कोर्स एक शानदार संसाधन है। यह MLOps आर्किटेक्चर, CI/CD/CM/CT तकनीकों और ऑटोमेशन पैटर्न्स पर व्यापक जानकारी प्रदान करता है, ताकि ऐसे ML सिस्टम डिप्लॉय किए जा सकें जो समय के साथ लगातार मूल्य दें।