बड़े भाषा मॉडलों की व्याख्या: LLMs कैसे काम करते हैं और Kubernetes पर अपना खुद का कैसे चलाएं

बड़े भाषा मॉडलों के लिए एक सरल-अंग्रेजी मार्गदर्शिका - वे क्या हैं, वे वास्तव में हुड के नीचे कैसे काम करते हैं, और Kubernetes पर अपना खुद का कैसे चलाएं। गैर-तकनीकी प्रबंधकों और इंजीनियरों के लिए समान रूप से लिखा गया है: उपमाओं पर नज़र डालें, फिर जब आप तैनाती के लिए तैयार हों तो YAML में शामिल हो जाएं।

1. वास्तव में एक बड़ा भाषा मॉडल क्या है?

अपने फ़ोन पर स्वत: पूर्ण होने की कल्पना करें. आप टाइप करते हैं "जब मुझे मिलेगा तो मैं तुम्हें फोन करूंगा" और यह "घर" सुझाता है। यह एक छोटा भाषा मॉडल है: इसने बहुत सारे टेक्स्ट संदेश देखे हैं और सीखा है कि कौन से शब्द किसका अनुसरण करते हैं। ए बड़ा भाषा मॉडल वही विचार है जिसे लाखों लोगों द्वारा बढ़ाया गया है - आपके ग्रंथों पर नहीं बल्कि सार्वजनिक इंटरनेट, पुस्तकों, कोड और दस्तावेज़ीकरण के एक बड़े हिस्से पर प्रशिक्षित किया गया है।

शब्द "बड़ा" असली काम कर रहा है. इन मॉडलों में अरबों आंतरिक संख्याएँ होती हैं (जिन्हें कहा जाता है)। पैरामीटर) जो प्रशिक्षण के दौरान ट्यून हो जाते हैं। जब लोग कहते हैं कि एक मॉडल "7बी" या "70बी" है, तो उनका मतलब 7 अरब या 70 अरब पैरामीटर से है। अधिक मापदंडों का मतलब आम तौर पर अधिक क्षमता है - और मेमोरी और गणना के लिए एक बड़ी भूख।

प्रबंधकों के लिए एक उपयोगी मानसिक मॉडल: LLM एक अथक, बहुत पढ़ा-लिखा स्नातक सहायक है। यह किसी भी इंसान से अधिक पढ़ सकता है, तेजी से ड्राफ्ट करता है, और कभी ऊबता नहीं है - लेकिन यह कभी-कभी पूरे आत्मविश्वास के साथ ऐसी बातें बताता है जो बिल्कुल गलत हैं, और जब तक आप इसे याद नहीं दिलाते तब तक इसे कल की कोई याद नहीं होती है।

2. वे वास्तव में कैसे काम करते हैं

हुड के नीचे पाँच विचार हैं। आपको उनका अनुसरण करने के लिए गणित की आवश्यकता नहीं है - प्रत्येक की एक रोजमर्रा की सादृश्यता है।

2.1 टोकन - पाठ को टुकड़ों में काटना

मॉडल पूरे शब्द नहीं पढ़ते. वे पाठ को तोड़ देते हैं टोकन: पात्रों का सामान्य भाग। "Kubernetes" बन सकता है Kub + ernetes; "चलना" हो सकता है run + ning. मोटे तौर पर, 1 टोकन ≈ 0.75 अंग्रेजी शब्द, तो 1,000 टोकन लगभग 750 शब्द हैं। यह व्यावसायिक रूप से मायने रखता है: होस्ट किए गए APIs बिल प्रति टोकन, और एक मॉडल संदर्भ विंडो (यह एक बार में कितना "देख सकता है") टोकन में मापा जाता है।

2.2 एंबेडिंग्स - शब्दों को अर्थ के निर्देशांक में बदलना

प्रत्येक टोकन को संख्याओं की एक लंबी सूची में बदल दिया जाता है - a एम्बेडिंग - जो अंतरिक्ष में एक बिंदु के रूप में इसके अर्थ को दर्शाता है। समान रूप से प्रयुक्त शब्द एक-दूसरे के निकट पहुँचते हैं। "राजा" और "रानी" पास-पास बैठते हैं; "राजा" और "केला" दूर-दूर बैठे हैं। इस प्रकार एक मशीन जो केवल अंकगणित करती है, हेरफेर कर सकती है अर्थ: अर्थ को ज्यामिति में बदल दिया गया है।

2.3 ट्रांसफार्मर और "ध्यान" - 2017 की सफलता

प्रत्येक आधुनिक LLM के पीछे की वास्तुकला है ट्रांसफार्मर. इसकी कुंजी ट्रिक कहलाती है ध्यान: किसी शब्द को संसाधित करते समय, मॉडल वाक्य में हर दूसरे शब्द को देखता है और निर्णय लेता है कि कौन सा प्रासंगिक है। "ट्रॉफी सूटकेस में फिट नहीं हुई क्योंकि यह बहुत बड़ा था," ध्यान वह है जो मॉडल को यह समझने देता है कि "यह" ट्रॉफी को संदर्भित करता है, सूटकेस को नहीं। ध्यान दें कि ये मॉडल संदर्भ, बारीकियों और लंबी दूरी के संदर्भों को इतनी अच्छी तरह से क्यों संभालते हैं - और उन्हें इतनी अधिक गणना की आवश्यकता क्यों है, क्योंकि हर शब्द हर दूसरे शब्द पर ध्यान देता है।

2.4 प्रशिक्षण - तीन चरण

1. पूर्व प्रशिक्षण: मॉडल को अंतिम शब्द छिपाकर अरबों वाक्य दिखाए जाते हैं और इसका अनुमान लगाने के लिए कहा जाता है। इसे गलत समझें, मापदंडों को कुरेदें, दोहराएं - खरबों बार। यहीं पर यह व्याकरण, तथ्य, तर्क पैटर्न और कोड को अवशोषित करता है। यह महंगा हिस्सा भी है, जिसकी कीमत GPU समय में लाखों पाउंड है।
2. फ़ाइन ट्यूनिंग: फिर कच्चे मॉडल को उपयोगी प्रश्न-उत्तर व्यवहार के क्यूरेटेड उदाहरणों पर प्रशिक्षित किया जाता है, इसलिए यह स्वत: पूर्ण के बजाय एक सहायक की तरह कार्य करता है।
3. संरेखण (आरएलएचएफ): अंततः, मनुष्य मॉडल के उत्तरों को रैंक करते हैं और उस फीडबैक का उपयोग इसे अधिक उपयोगी, ईमानदार और सुरक्षित बनाने के लिए किया जाता है। यही कारण है कि एक चैट मॉडल हानिकारक अनुरोधों को अस्वीकार कर देता है और एक सुसंगत लहजा अपनाता है।

2.5 अनुमान - यह आपको कैसे उत्तर देता है

जब आप संकेत भेजते हैं, तो मॉडल उत्तर उत्पन्न करता है एक समय में एक टोकन: यह सबसे संभावित अगले टोकन की भविष्यवाणी करता है, इसे जोड़ता है, फिर अगले की भविष्यवाणी करता है, और इसी तरह - एक तेज़, अच्छी तरह से पढ़े हुए व्यक्ति की तरह, पहले पूरे वाक्य की योजना बनाए बिना शब्द दर शब्द लिखता है। एक सेटिंग बुलाई गई तापमान यह नियंत्रित करता है कि यह कितना साहसिक है: कम तापमान सुरक्षित, दोहराए जाने योग्य उत्तर देता है (कोड और निष्कर्षण के लिए अच्छा); उच्च तापमान रचनात्मक, विविध उत्तर देता है (मंथन के लिए अच्छा)। इस टोकन-बाय-टोकन प्रक्रिया को कहा जाता है अनुमान, और यह वह हिस्सा है जिसके लिए आप उत्पादन में भुगतान करते हैं - प्रत्येक अनुरोध GPU चक्र को जला देता है।

3. LLM किसमें अच्छे और बुरे हैं

उपकरण के किनारों को जानने से महंगी गलतियों से बचाव होता है।

इनमें से अधिकांश का समाधान है RAG (पुनर्प्राप्ति-संवर्धित पीढ़ी): मॉडल की मेमोरी पर भरोसा करने के बजाय, आप अपने सिस्टम से प्रासंगिक दस्तावेज़ लाते हैं और उन्हें प्रॉम्प्ट में पेस्ट करते हैं, इसलिए मॉडल उत्तर देता है आपके डेटा से. इस प्रकार आप बिना किसी मॉडल के बातें बनाए अपने आंतरिक विकी पर एक चैटबॉट बनाते हैं।

4. शब्दावली, डिकोड किया गया

5. अपना खुद का LLM क्यों चलाएं?

होस्ट किए गए APIs (ओपनएआई, एंथ्रोपिक और अन्य) शुरू करने का सबसे तेज़ तरीका हैं और उत्कृष्ट हैं। लेकिन चार कारण हैं कि संगठन Llama, मिस्ट्रल, क्वेन, या जेम्मा जैसे ओपन-वेट मॉडल को स्वयं-होस्ट करना चुनते हैं:

• डेटा गोपनीयता और अनुपालन. संवेदनशील डेटा आपके नेटवर्क को कभी नहीं छोड़ता - स्वास्थ्य देखभाल, वित्त, कानूनी और सार्वजनिक क्षेत्र के लिए महत्वपूर्ण।
• पैमाने पर लागत. एक निश्चित स्थिर अनुरोध मात्रा से ऊपर, आपके पास मौजूद GPU, API का भुगतान करने की तुलना में प्रति टोकन सस्ता हो सकता है।
• नियंत्रण एवं स्थिरता. आपके नीचे मॉडल कभी नहीं बदलता है, और आप विक्रेता की दर सीमा या अवमूल्यन के अधीन नहीं हैं।
• विलंबता और ऑफ़लाइन उपयोग. आपके एप्लिकेशन के बगल में, या बिना किसी इंटरनेट निर्भरता वाले ऑन-प्रिमाइसेस पर अनुमान।

व्यापार-बंद वह है अब आप हार्डवेयर, स्केलिंग और विश्वसनीयता के स्वामी हैं — जो बिल्कुल वही है जिसमें Kubernetes अच्छा है।

6. हार्डवेयर वास्तविकता (तैनाती से पहले इसे पढ़ें)

LLM का वज़न GPU मेमोरी (VRAM) में फिट होना चाहिए। अंगूठे का एक मोटा नियम:

दो सेवारत इंजन वास्तविक तैनाती पर हावी हैं:

• Ollama - सबसे आसान ऑन-रैंप। विकास, आंतरिक उपकरण और CPU या एकल-GPU नोड्स के लिए बढ़िया। एक आदेश से परिमाणित मॉडल खींचता है।
• vLLM - उत्पादन कार्यकर्ता। उच्च-थ्रूपुट, कई अनुरोधों को बैच करता है, और एक को उजागर करता है OpenAI-संगत API इसलिए आपका मौजूदा कोड एक-पंक्ति URL परिवर्तन के साथ काम करता है। (हगिंग फेस टीजीआई एक करीबी विकल्प है।)

7. Kubernetes पर अपना खुद का LLM तैनात करना

नीचे दी गई हर चीज़ कम से कम एक GPU नोड और के साथ एक क्लस्टर मानती है NVIDIA डिवाइस प्लगइन स्थापित, जो GPUs को शेड्यूल करने योग्य संसाधन के रूप में उजागर करता है nvidia.com/gpu. हम इसे टुकड़े-टुकड़े करके बनाएंगे।

7.1 एक नामस्थान और मॉडल वज़न संग्रहीत करने का स्थान

मॉडल फ़ाइलें बड़ी (गीगाबाइट) होती हैं और डाउनलोड करने में धीमी होती हैं, इसलिए हम उन्हें कैश करते हैं PersistentVolumeClaim प्रत्येक पॉड पुनः आरंभ करने के बजाय।

apiVersion: v1
kind: Namespace
metadata:
  name: llm
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: model-cache
  namespace: llm
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 100Gi          # weights are big; size generously
  # storageClassName: fast-ssd   # use an SSD class if your cluster offers one

7.2 विकल्प ए - एक्सपीआर0एक्स (आसान शुरुआत)

Ollama पहली तैनाती या आंतरिक उपकरण के लिए आदर्श है। यह इसे एक GPU के साथ चलाता है; हटाएं nvidia.com/gpu केवल बीफ़ी नोड पर CPU चलाने की सीमा।

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama
  namespace: llm
  labels:
    app: ollama
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama
  template:
    metadata:
      labels:
        app: ollama
    spec:
      containers:
        - name: ollama
          image: ollama/ollama:latest
          ports:
            - containerPort: 11434
          resources:
            requests:
              cpu: "2"
              memory: 8Gi
            limits:
              nvidia.com/gpu: 1        # remove this line for CPU-only
              memory: 16Gi
          volumeMounts:
            - name: models
              mountPath: /root/.ollama
          readinessProbe:
            httpGet:
              path: /
              port: 11434
            initialDelaySeconds: 10
            periodSeconds: 10
      volumes:
        - name: models
          persistentVolumeClaim:
            claimName: model-cache
---
apiVersion: v1
kind: Service
metadata:
  name: ollama
  namespace: llm
spec:
  selector:
    app: ollama
  ports:
    - port: 80
      targetPort: 11434

एक बार जब पॉड चल रहा हो, तो एक मॉडल को कैश में खींचें और उसके साथ चैट करें:

# pull a quantized model into the PVC (one-off)
kubectl -n llm exec deploy/ollama -- ollama pull llama3

# ask it something from inside the cluster
kubectl -n llm exec deploy/ollama -- \
  ollama run llama3 "Explain Kubernetes in one sentence."

7.3 विकल्प बी - vLLM (उत्पादन थ्रूपुट, ओपनएआई-संगत)

वास्तविक ट्रैफ़िक के लिए, vLLM कई समवर्ती अनुरोधों को कुशलतापूर्वक पूरा करता है और OpenAI API बोली बोलता है। गेटेड मॉडल (जैसे Llama) को एक हगिंग फेस टोकन की आवश्यकता होती है, जिसे एक रहस्य के रूप में संग्रहीत किया जाता है।

apiVersion: v1
kind: Secret
metadata:
  name: hf-token
  namespace: llm
type: Opaque
stringData:
  token: "hf_xxxxxxxxxxxxxxxxxxxxxxxx"   # your Hugging Face access token
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-mistral
  namespace: llm
  labels:
    app: vllm-mistral
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vllm-mistral
  template:
    metadata:
      labels:
        app: vllm-mistral
    spec:
      containers:
        - name: vllm
          image: vllm/vllm-openai:latest
          args:
            - "--model"
            - "mistralai/Mistral-7B-Instruct-v0.3"
            - "--max-model-len"
            - "8192"
            - "--gpu-memory-utilization"
            - "0.90"
          ports:
            - containerPort: 8000
          env:
            - name: HUGGING_FACE_HUB_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-token
                  key: token
          resources:
            limits:
              nvidia.com/gpu: 1
          volumeMounts:
            - name: cache
              mountPath: /root/.cache/huggingface
          readinessProbe:
            httpGet:
              path: /health
              port: 8000
            initialDelaySeconds: 60      # first start downloads weights
            periodSeconds: 15
            failureThreshold: 40
      volumes:
        - name: cache
          persistentVolumeClaim:
            claimName: model-cache
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-mistral
  namespace: llm
spec:
  selector:
    app: vllm-mistral
  ports:
    - port: 80
      targetPort: 8000

क्योंकि vLLM OpenAI-संगत है, एप्लिकेशन कोड को केवल इन-क्लस्टर URL की आवश्यकता है - कोई SDK परिवर्तन नहीं:

curl http://vllm-mistral.llm.svc.cluster.local/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "messages": [{"role": "user", "content": "Summarise our refund policy."}],
    "temperature": 0.2
  }'

7.4 इसे एक प्रवेश के साथ उजागर करना

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: llm-api
  namespace: llm
  annotations:
    nginx.ingress.kubernetes.io/proxy-read-timeout: "300"   # long generations
spec:
  ingressClassName: nginx
  rules:
    - host: llm.internal.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: vllm-mistral
                port:
                  number: 80

7.5 स्केलिंग - और यह GPUs के साथ भिन्न क्यों है

आप ऑटोस्केल कर सकते हैं, लेकिन याद रखें प्रत्येक प्रतिकृति को अपनी संपूर्ण GPU की आवश्यकता होती है - आप साधारण मामले में किसी को आंशिक रूप से साझा नहीं कर सकते हैं, और आपके पास भौतिक रूप से मौजूद GPUs से आगे बढ़ने का कोई मतलब नहीं है। CPU के बजाय कतार या अनुरोध-दर सिग्नल पर स्केल (KEDA यहां उत्कृष्ट है)।

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: vllm-mistral
  namespace: llm
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: vllm-mistral
  minReplicas: 1
  maxReplicas: 4          # never exceed the number of GPUs in the cluster
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
  # For real LLM scaling, prefer KEDA on a queue depth or
  # requests-per-second metric exported by vLLM, not CPU.

8. एक व्यावहारिक रोलआउट चेकलिस्ट

1. होस्ट किए गए API पर प्रोटोटाइप GPU खरीदने से पहले उपयोग के मामले को सत्यापित करने के लिए।
2. एक ओपन-वेट मॉडल चुनें जो आपके हार्डवेयर में फिट बैठता है (मात्राबद्ध 7-8बी मॉडल से शुरू करें)।
3. Ollama से प्रारंभ करें एक आंतरिक पायलट के लिए; स्नातक करने के लिए vLLM जब आपको थ्रूपुट की आवश्यकता हो.
4. RAG जोड़ें मतिभ्रम को कम करने और उत्तरों को अद्यतन रखने के लिए अपने स्वयं के दस्तावेज़ों पर।
5. एक इंसान को पाश में रखो जहां भी गलत उत्तर की वास्तविक कीमत चुकानी पड़ती है।
6. अनुमान लागत और विलंबता को मापें प्रति अनुरोध - यही आपकी सच्ची इकाई अर्थशास्त्र है।