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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

एलएलएम का वजन जीपीयू मेमोरी (वीआरएएम) में फिट होना चाहिए। अंगूठे का एक मोटा नियम:

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

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

7. कुबेरनेट्स पर अपना खुद का एलएलएम तैनात करना

नीचे दी गई हर चीज़ कम से कम एक GPU नोड और के साथ एक क्लस्टर मानती है NVIDIA डिवाइस प्लगइन स्थापित, जो शेड्यूल करने योग्य संसाधन के रूप में GPU को उजागर करता है 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 विकल्प ए - ओलामा (आसान शुरुआत)

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

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 विकल्प बी - वीएलएलएम (उत्पादन थ्रूपुट, ओपनएआई-संगत)

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

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

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

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 स्केलिंग - और यह जीपीयू के साथ अलग क्यों है

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

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