मशीन लर्निंग के लिए Docker से पुनरुत्पाद्य वातावरण
विद्यार्थी एक Dockerfile लिखेंगे, जो Python और निश्चित संस्करण वाली मशीन लर्निंग लाइब्रेरी इंस्टॉल करे तथा प्रशिक्षण स्क्रिप्ट की प्रतिलिपि बनाए; फिर वे कंटेनर बनाकर चलाएँगे और एकदम समान पुनरुत्पादन की पुष्टि करेंगे।
मशीन लर्निंग के लिए Docker से पुनरुत्पाद्य वातावरण, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
ML में दोहराने योग्य परिणामों की समस्या
आपके लैपटॉप पर प्रशिक्षित मॉडल किसी सहकर्मी की मशीन पर अलग परिणाम दे सकता है, क्योंकि Python संस्करण, लाइब्रेरी संस्करण या सिस्टम लाइब्रेरी अलग हो सकती हैं। Docker आपके पूरे वातावरण — Python, ML लाइब्रेरी और प्रशिक्षण स्क्रिप्ट — को एक कंटेनर में पैकेज करके इस समस्या का समाधान करता है, जो किसी भी मशीन पर एक जैसा चलता है। कंटेनर-आधारित ML प्रशिक्षण दोहराने योग्य शोध और विश्वसनीय CI/CD पाइपलाइन की नींव है।
Docker की अवधारणाएँ: इमेज, कंटेनर और लेयर
Docker इमेज Dockerfile द्वारा परिभाषित केवल-पठन टेम्पलेट होती है। इसमें एक के ऊपर एक रखी गई लेयर होती हैं: Dockerfile का प्रत्येक निर्देश एक लेयर जोड़ता है। कंटेनर किसी इमेज का चल रहा उदाहरण होता है। इमेज पोर्टेबल होती हैं और my-ml-image:v1.2 जैसे टैग के माध्यम से उनके संस्करण तय किए जाते हैं। मुख्य बात यह है कि एक ही इमेज टैग हर जगह बिट-स्तर पर एक जैसे रनटाइम वातावरण का निर्माण करता है, आपके लैपटॉप से लेकर क्लाउड GPU इंस्टेंस तक।
# Basic Docker commands for ML workflows
# Build an image from Dockerfile in current directory
# docker build -t my-ml-trainer:v1 .
# Run a training script inside the container
# docker run --rm --gpus all my-ml-trainer:v1 python train.py
# List running containers
# docker ps
# Inspect image layers (shows what changed at each step)
# docker history my-ml-trainer:v1ML प्रशिक्षण के लिए Dockerfile लिखना
Dockerfile एक टेक्स्ट फ़ाइल होती है जिसमें क्रमिक निर्देश होते हैं, जिन्हें Docker इमेज बनाने के लिए चलाता है। किसी आधिकारिक Python बेस इमेज से शुरू करें, कार्यशील डायरेक्टरी सेट करें, requirements.txt कॉपी करें, निर्भरताएँ इंस्टॉल करें और फिर अपना प्रशिक्षण कोड कॉपी करें। FROM निर्देश बेस इमेज निर्दिष्ट करता है; GPU प्रशिक्षण के लिए NVIDIA की CUDA-सक्षम बेस इमेज का उपयोग करें।
# Dockerfile
# FROM python:3.11-slim
#
# WORKDIR /app
#
# # Copy and install dependencies first (layer caching)
# COPY requirements.txt .
# RUN pip install --no-cache-dir -r requirements.txt
#
# # Copy training code
# COPY train.py .
# COPY data/ data/
#
# # Default command
# CMD ['python', 'train.py']
print('Dockerfile structure shown above (Python comment).')requirements.txt में निर्भरताओं के संस्करण तय करना
दोहराने योग्य परिणामों के लिए requirements.txt में निश्चित संस्करण आवश्यक हैं। न्यूनतम संस्करण (>=) के बजाय सटीक संस्करण निर्दिष्टकर्ता (==) का उपयोग करें। अपने वातावरण का परीक्षण करने के बाद pip freeze > requirements.txt से पूरी तरह निश्चित संस्करणों वाली requirements फ़ाइल बनाएँ। ML प्रोजेक्ट में हमेशा scikit-learn, numpy, pandas और उपयोग किए जा रहे फ़्रेमवर्क के संस्करण निश्चित करें, क्योंकि छोटे संस्करण बदलाव भी मॉडल के व्यवहार को बदल सकते हैं।
# requirements.txt (pinned versions for reproducibility)
# scikit-learn==1.4.2
# numpy==1.26.4
# pandas==2.2.1
# matplotlib==3.8.4
# mlflow==2.13.0
# torch==2.3.0
# transformers==4.40.2
# xgboost==2.0.3
# lightgbm==4.3.0
# imbalanced-learn==0.12.2
# joblib==1.4.2
# Generate from your current environment:
# pip freeze > requirements.txtतेज़ पुनर्निर्माण के लिए Docker लेयर कैशिंग
Docker प्रत्येक निर्देश को अलग कैश की गई लेयर के रूप में बनाता है। यदि किसी लेयर के इनपुट में बदलाव नहीं हुआ है, तो Docker निर्देश को दोबारा चलाने के बजाय कैश की गई लेयर का पुनः उपयोग करता है। इसका अर्थ है कि COPY requirements.txt और RUN pip install को पहले, तथा COPY . . (सारा कोड कॉपी करने वाला निर्देश) को बाद में रखने से कोड फ़ाइलों में बदलाव होने पर पैकेजों को धीमी गति से दोबारा इंस्टॉल करने की आवश्यकता नहीं पड़ती। Dockerfile का अच्छा क्रम दोहराए जाने वाले विकास को बहुत तेज़ कर देता है।
# Optimised Dockerfile layer order
# FROM python:3.11-slim
#
# WORKDIR /app
#
# # Step 1: Install system packages (rarely changes)
# RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
#
# # Step 2: Install Python deps (changes only when requirements.txt changes)
# COPY requirements.txt .
# RUN pip install --no-cache-dir -r requirements.txt
#
# # Step 3: Copy code (changes most often -- put last)
# COPY . .
#
# CMD ['python', 'train.py']
print('Layer order shown above.')GPU समर्थन: CUDA Docker इमेज
GPU पर डीप लर्निंग मॉडल प्रशिक्षित करने के लिए Docker Hub से NVIDIA की आधिकारिक CUDA बेस इमेज का उपयोग करें। इन इमेज में PyTorch और TensorFlow के लिए आवश्यक CUDA रनटाइम और cuDNN लाइब्रेरी शामिल होती हैं। कंटेनर चलाते समय --gpus all फ़्लैग होस्ट GPU को कंटेनर के लिए उपलब्ध कराता है। इमेज में मौजूद CUDA संस्करण होस्ट मशीन पर इंस्टॉल किए गए ड्राइवरों से मेल खाना चाहिए।
# Dockerfile for GPU training with PyTorch
# FROM nvidia/cuda:12.1-cudnn8-runtime-ubuntu22.04
#
# # Install Python
# RUN apt-get update && apt-get install -y python3.11 python3-pip
# RUN ln -s /usr/bin/python3.11 /usr/bin/python
#
# WORKDIR /app
# COPY requirements.txt .
# RUN pip install --no-cache-dir -r requirements.txt
# COPY train.py .
#
# CMD ['python', 'train.py']
# Run with GPU:
# docker run --rm --gpus all my-gpu-trainer:v1
print('GPU Dockerfile structure shown above.')पर्यावरण चर के माध्यम से कॉन्फ़िगरेशन देना
अपने प्रशिक्षण स्क्रिप्ट में हाइपरपैरामीटर को सीधे लिखने से बचें। इसके बजाय os.getenv से उन्हें पर्यावरण चर के रूप में पढ़ें और कंटेनर चलाते समय -e फ़्लैग के माध्यम से दें। इससे दोबारा निर्माण किए बिना अलग-अलग हाइपरपैरामीटर के साथ एक ही इमेज चलाना संभव होता है और केवल रन कमांड बदलकर हाइपरपैरामीटर की कई जाँचें आसानी से की जा सकती हैं।
import os
# In train.py -- read config from environment variables
LEARNING_RATE = float(os.getenv('LEARNING_RATE', '0.001'))
N_ESTIMATORS = int(os.getenv('N_ESTIMATORS', '100'))
MAX_DEPTH = int(os.getenv('MAX_DEPTH', '5'))
OUTPUT_DIR = os.getenv('OUTPUT_DIR', '/app/outputs')
print(f'Training with lr={LEARNING_RATE}, n={N_ESTIMATORS}, depth={MAX_DEPTH}')
# Run with custom config:
# docker run -e LEARNING_RATE=0.01 -e N_ESTIMATORS=200 my-ml-trainer:v1डेटा और आउटपुट के लिए वॉल्यूम माउंट करना
कंटेनर अस्थायी होते हैं — कंटेनर के भीतर लिखा गया डेटा उसके रुकने पर मिट जाता है। होस्ट डायरेक्टरी को कंटेनर से जोड़ने के लिए वॉल्यूम माउंट (-v फ़्लैग) का उपयोग करें। अपनी डेटा डायरेक्टरी को केवल-पठन और आउटपुट डायरेक्टरी को पढ़ने-लिखने के लिए माउंट करें। इससे बड़े डेटासेट इमेज के बाहर रहते हैं (जिससे इमेज का आकार घटता है) और कंटेनर बंद होने के बाद भी मॉडल चेकपॉइंट तथा परिणाम सुरक्षित रहते हैं।
# Mount host data/ and outputs/ into container
# docker run --rm \
# -v /host/path/data:/app/data:ro \
# -v /host/path/outputs:/app/outputs \
# -e N_ESTIMATORS=200 \
# my-ml-trainer:v1
# In train.py, read from /app/data and write to /app/outputs
import os
data_dir = '/app/data'
output_dir = '/app/outputs'
os.makedirs(output_dir, exist_ok=True)
print('Data dir:', os.listdir(data_dir) if os.path.exists(data_dir) else 'not mounted')बहु-चरणीय बिल्ड: हल्की प्रोडक्शन इमेज
प्रशिक्षण इमेज में कंपाइलर, हेडर फ़ाइलें और विकास उपकरण शामिल होते हैं, जिनकी अनुमान के लिए आवश्यकता नहीं होती। बहु-चरणीय बिल्ड में एक चरण का उपयोग सब कुछ कंपाइल या इंस्टॉल करने के लिए और दूसरे हल्के चरण का उपयोग केवल अंतिम आर्टिफैक्ट कॉपी करने के लिए किया जाता है। इससे इमेज का आकार 4 GB से घटकर 200 MB से कम हो सकता है, जिससे इमेज डाउनलोड तेज़ होते हैं और प्रोडक्शन में हमले का क्षेत्र कम होता है।
# Multi-stage Dockerfile
# --- Stage 1: Build ---
# FROM python:3.11 AS builder
# WORKDIR /app
# COPY requirements.txt .
# RUN pip install --no-cache-dir --user -r requirements.txt
#
# --- Stage 2: Runtime ---
# FROM python:3.11-slim
# WORKDIR /app
# COPY --from=builder /root/.local /root/.local
# COPY serve.py .
# COPY model/ model/
# ENV PATH=/root/.local/bin:$PATH
#
# CMD ['python', 'serve.py']
print('Multi-stage Dockerfile shown above.')Docker के भीतर MLflow चलाना
MLflow ट्रैकिंग URI को पर्यावरण चर के रूप में देकर Docker और MLflow को साथ में उपयोग करें। कंटेनर मॉडल को प्रशिक्षित करता है, पैरामीटर और मेट्रिक्स दूरस्थ MLflow सर्वर पर लॉग करता है और मॉडल आर्टिफैक्ट साझा संग्रहण में सहेजता है। यह स्वचालित पुनःप्रशिक्षण पाइपलाइन का आधारभूत ढाँचा है: एक शेड्यूलर Docker कंटेनर को चलाता है, जो बिना किसी मैन्युअल हस्तक्षेप के प्रशिक्षण, मूल्यांकन और नए मॉडल संस्करण का पंजीकरण करता है।
import os
import mlflow
from sklearn.ensemble import RandomForestClassifier
# Read from environment (set by docker run -e)
MLFLOW_URI = os.getenv('MLFLOW_TRACKING_URI', 'http://localhost:5000')
mlflow.set_tracking_uri(MLFLOW_URI)
mlflow.set_experiment('docker_training')
with mlflow.start_run():
n_est = int(os.getenv('N_ESTIMATORS', '100'))
mlflow.log_param('n_estimators', n_est)
clf = RandomForestClassifier(n_estimators=n_est, random_state=42)
# clf.fit(X_train, y_train) -- assume data is mounted
# acc = accuracy_score(y_test, clf.predict(X_test))
# mlflow.log_metric('accuracy', acc)
# mlflow.sklearn.log_model(clf, 'model')
print('Logged to:', MLFLOW_URI)इमेज को रजिस्ट्री में भेजना
Docker इमेज को अपनी टीम के साथ साझा करने या क्लाउड अवसंरचना पर तैनात करने के लिए उन्हें कंटेनर रजिस्ट्री में भेजें। Docker Hub सार्वजनिक रजिस्ट्री है; AWS ECR, Google GCR और Azure ACR लोकप्रिय निजी विकल्प हैं। अपनी इमेज को रजिस्ट्री URL और इमेज नाम से टैग करें, फिर उसे भेजें। CI/CD पाइपलाइन आम तौर पर प्रत्येक कमिट पर नई इमेज बनाती हैं और पूरी traceability के लिए उसे कमिट SHA को टैग के रूप में उपयोग करके भेजती हैं।
# Tag and push to Docker Hub
# docker tag my-ml-trainer:v1 yourusername/my-ml-trainer:v1
# docker push yourusername/my-ml-trainer:v1
# Tag and push to AWS ECR
# aws ecr get-login-password --region eu-west-1 | \
# docker login --username AWS --password-stdin 123456789.dkr.ecr.eu-west-1.amazonaws.com
# docker tag my-ml-trainer:v1 123456789.dkr.ecr.eu-west-1.amazonaws.com/my-ml-trainer:v1
# docker push 123456789.dkr.ecr.eu-west-1.amazonaws.com/my-ml-trainer:v1
print('Registry push commands shown above.')त्वरित जाँच
इस पाठ में दिए गए Python के साथ मशीन लर्निंग संबंधी अवधारणाओं की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: Docker कंटेनर पूरे Python वातावरण को पैकेज करते हैं, जिससे किसी भी मशीन पर प्रशिक्षण के परिणाम एक जैसे रहते हैं, कोड कॉपी करने से पहले निर्भरताएँ इंस्टॉल करने पर लेयर कैशिंग बिल्ड को तेज़ बनाती है, और वॉल्यूम माउंट बड़े डेटासेट को इमेज के बाहर रखते हैं तथा कंटेनर बंद होने के बाद आउटपुट सुरक्षित रखते हैं। आगे हम MLflow Model Registry का अध्ययन करेंगे, जिसमें मॉडल को स्टेजिंग और प्रोडक्शन जीवनचक्र चरणों के माध्यम से आगे बढ़ाया जाता है।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “मशीन लर्निंग के लिए Docker से पुनरुत्पाद्य वातावरण” पाठ निःशुल्क है?
हाँ—“मशीन लर्निंग के लिए Docker से पुनरुत्पाद्य वातावरण” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“मशीन लर्निंग के लिए Docker से पुनरुत्पाद्य वातावरण” में मैं क्या सीखूँगा?
विद्यार्थी एक Dockerfile लिखेंगे, जो Python और निश्चित संस्करण वाली मशीन लर्निंग लाइब्रेरी इंस्टॉल करे तथा प्रशिक्षण स्क्रिप्ट की प्रतिलिपि बनाए; फिर वे कंटेनर बनाकर चलाएँगे और एकदम समान पुनरुत्पादन… आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।
“मशीन लर्निंग के लिए Docker से पुनरुत्पाद्य वातावरण” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- MLflow के साथ प्रयोग ट्रैकिंग: पैरामीटर, मेट्रिक और आर्टिफैक्ट लॉग करना
- मशीन लर्निंग के लिए Docker से पुनरुत्पाद्य वातावरण
- मॉडल रजिस्ट्री: स्टेजिंग, प्रोडक्शन और संग्रहण
- GitHub Actions के साथ स्वचालित पुनर्प्रशिक्षण पाइपलाइन