อธิบายโมเดลภาษาขนาดใหญ่: วิธีการทำงานของ LLM และวิธีเรียกใช้งานของคุณเองบน Kubernetes

คู่มือภาษาอังกฤษธรรมดาสำหรับโมเดลภาษาขนาดใหญ่ — มันคืออะไร จริงๆ แล้วมันทำงานอย่างไรภายใต้ประทุน และวิธีการรันของคุณเองบน Kubernetes เขียนขึ้นสำหรับผู้จัดการและวิศวกรที่ไม่ใช่ด้านเทคนิค: อ่านแบบคร่าวๆ แล้วใส่ลงใน YAML เมื่อคุณพร้อมที่จะปรับใช้

1. โมเดลภาษาขนาดใหญ่จริงๆ คืออะไร?

ลองนึกภาพการเติมข้อความอัตโนมัติบนโทรศัพท์ของคุณ คุณพิมพ์ว่า "ฉันจะโทรหาคุณเมื่อฉันได้รับ" และมันแนะนำ "บ้าน" นั่นเป็นโมเดลภาษาเล็กๆ: ได้เห็นข้อความจำนวนมากและเรียนรู้ว่าคำใดมักจะตามหลังข้อความใด ก ใหญ่ โมเดลภาษาเป็นแนวคิดเดียวกันที่ขยายขนาดขึ้นหลายล้านตัว — ไม่ได้ฝึกฝนจากข้อความของคุณ แต่ฝึกฝนบนอินเทอร์เน็ตสาธารณะ หนังสือ โค้ด และเอกสารประกอบจำนวนมาก

คำว่า "ใหญ่" กำลังทำงานจริง โมเดลเหล่านี้ประกอบด้วยตัวเลขภายในหลายพันล้านหมายเลข (เรียกว่า พารามิเตอร์) ที่ได้รับการปรับแต่งระหว่างการฝึก เมื่อมีคนพูดว่าโมเดลคือ "7B" หรือ "70B" พวกเขาหมายถึงพารามิเตอร์ 7 พันล้านหรือ 70 พันล้าน โดยทั่วไปพารามิเตอร์ที่มากขึ้นหมายถึงความสามารถที่มากขึ้น — และความกระหายในหน่วยความจำและการประมวลผลที่มากขึ้น

แบบจำลองทางจิตที่เป็นประโยชน์สำหรับผู้จัดการ: LLM เป็นผู้ช่วยบัณฑิตที่อ่านเก่งและไม่รู้จักเหน็ดเหนื่อย มันอ่านได้มากกว่ามนุษย์คนใดๆ ที่เคยอ่านได้ ร่างได้เร็ว และไม่เคยเบื่อ แต่บางครั้งมันก็บอกสิ่งต่าง ๆ ด้วยความมั่นใจอย่างยิ่งว่าเป็นสิ่งที่ผิด และไม่มีความทรงจำของเมื่อวาน เว้นแต่คุณจะเตือนมัน

2. วิธีการทำงานจริง

ภายใต้ประทุนมีห้าแนวคิด คุณไม่จำเป็นต้องมีคณิตศาสตร์มาติดตาม - แต่ละข้อมีการเปรียบเทียบในชีวิตประจำวัน

2.1 โทเค็น — สับข้อความเป็นชิ้นๆ

โมเดลอ่านคำไม่หมด พวกเขาแบ่งข้อความออกเป็น โทเค็น: กลุ่มตัวอักษรทั่วไป "Kubernetes" อาจจะกลายเป็น Kub + ernetes; "การวิ่ง" อาจจะเป็น run + ning. ประมาณว่า 1 โทเค็น data 0.75 คำภาษาอังกฤษดังนั้น 1,000 โทเค็นจึงเท่ากับ 750 คำ สิ่งนี้มีความสำคัญในเชิงพาณิชย์: การเรียกเก็บเงิน API ที่โฮสต์ต่อโทเค็นและโมเดล หน้าต่างบริบท (สามารถ "เห็น" ได้ในคราวเดียวมากแค่ไหน) วัดเป็นโทเค็น

2.2 การฝัง — เปลี่ยนคำให้เป็นพิกัดของความหมาย

แต่ละโทเค็นจะถูกแปลงเป็นรายการตัวเลขแบบยาว — การฝัง — นั่นแสดงถึงความหมายของจุดในอวกาศ คำที่ใช้ในลักษณะเดียวกันจะอยู่ใกล้กัน "ราชา" และ "ราชินี" นั่งใกล้กัน “ราชา” และ “กล้วย” นั่งห่างกัน นี่คือวิธีที่เครื่องจักรที่ใช้เฉพาะเลขคณิตเท่านั้นที่สามารถจัดการได้ ความหมาย: ความหมายกลายเป็นเรขาคณิตแล้ว

2.3 The Transformer และ "ความสนใจ" — ความก้าวหน้าในปี 2017

สถาปัตยกรรมที่อยู่เบื้องหลัง LLM สมัยใหม่ทุกตัวคือ หม้อแปลงไฟฟ้า. เคล็ดลับสำคัญของเขาเรียกว่า ความสนใจ: เมื่อประมวลผลคำ โมเดลจะมองย้อนกลับไปที่คำอื่นๆ ในประโยค และตัดสินใจว่าคำใดที่เกี่ยวข้อง “ถ้วยรางวัลไม่พอดีกับกระเป๋าเดินทางเพราะว่า มัน ใหญ่เกินไป" ความสนใจคือสิ่งที่ทำให้โมเดลเข้าใจได้ว่า "มัน" หมายถึงถ้วยรางวัล ไม่ใช่กระเป๋าเดินทาง ความสนใจคือเหตุใดโมเดลเหล่านี้จึงจัดการกับบริบท ความแตกต่างเล็กน้อย และการอ้างอิงระยะไกลได้เป็นอย่างดี และเหตุใดจึงต้องใช้การประมวลผลมาก เพราะทุกคำให้ความสำคัญกับคำอื่นๆ

2.4 การฝึกอบรม — สามขั้นตอน

1. การฝึกอบรมก่อน: แบบจำลองนี้แสดงประโยคนับพันล้านประโยคโดยซ่อนคำสุดท้ายไว้และขอให้เดา ทำผิด ดันพารามิเตอร์ ทำซ้ำ — ล้านล้านครั้ง ที่นี่เป็นที่ที่ดูดซับไวยากรณ์ ข้อเท็จจริง รูปแบบการใช้เหตุผล และรหัส นอกจากนี้ยังเป็นชิ้นส่วนที่มีราคาแพง โดยมีราคาหลายล้านปอนด์เมื่อเทียบกับ GPU
2. การปรับแต่งแบบละเอียด: จากนั้น โมเดลดิบจะได้รับการฝึกอบรมเกี่ยวกับตัวอย่างพฤติกรรมคำถามและคำตอบที่เป็นประโยชน์ ดังนั้นจึงทำหน้าที่เหมือนผู้ช่วยมากกว่าการเติมข้อความอัตโนมัติ
3. การจัดตำแหน่ง (RLHF): สุดท้าย มนุษย์จัดอันดับคำตอบของแบบจำลอง และความคิดเห็นนั้นจะถูกนำไปใช้เพื่อทำให้แบบจำลองมีประโยชน์ ซื่อสัตย์ และปลอดภัยมากขึ้น นี่คือสาเหตุที่โมเดลการแชทปฏิเสธคำขอที่เป็นอันตรายและใช้น้ำเสียงที่สอดคล้องกัน

2.5 การอนุมาน — มันจะตอบคุณอย่างไร

เมื่อคุณส่งข้อความพร้อมต์ โมเดลจะสร้างการตอบกลับ โทเค็นหนึ่งครั้ง: มันทำนายโทเค็นถัดไปที่น่าจะเป็นไปได้มากที่สุด ต่อท้าย จากนั้นทำนายโทเค็นถัดไป และอื่นๆ — เหมือนคนที่อ่านเร็วและอ่านเก่งเขียนคำต่อคำโดยไม่ต้องวางแผนทั้งประโยคก่อน การตั้งค่าที่เรียกว่า อุณหภูมิ ควบคุมวิธีการผจญภัย: อุณหภูมิต่ำให้คำตอบที่ปลอดภัยและทำซ้ำได้ (เหมาะสำหรับการเขียนโค้ดและการสกัด); อุณหภูมิสูงให้คำตอบที่สร้างสรรค์และหลากหลาย (เหมาะสำหรับการระดมความคิด) กระบวนการโทเค็นต่อโทเค็นนี้เรียกว่า การอนุมานและเป็นส่วนที่คุณจ่ายสำหรับการผลิต — ทุกคำขอจะเบิร์นรอบ GPU

3. LLM อะไรดีและไม่ดี

การทราบขอบของเครื่องมือจะช่วยป้องกันข้อผิดพลาดที่มีราคาแพง

การแก้ไขสำหรับสิ่งเหล่านี้ส่วนใหญ่คือ RAG (การดึงข้อมูล-การสร้างเสริม): แทนที่จะเชื่อถือหน่วยความจำของโมเดล คุณจะดึงเอกสารที่เกี่ยวข้องจากระบบของคุณเองและวางลงในพรอมต์ เพื่อให้โมเดลตอบ จากข้อมูลของคุณ. นี่คือวิธีที่คุณสร้างแชทบอทบนวิกิภายในของคุณ โดยไม่ต้องสร้างโมเดลขึ้นมา

4. คำศัพท์ถอดรหัส

5. ทำไมต้องรัน LLM ของคุณเอง?

API ที่โฮสต์ (OpenAI, Anthropic และอื่นๆ) เป็นวิธีการเริ่มต้นที่เร็วที่สุดและยอดเยี่ยม แต่มีสี่เหตุผลที่องค์กรเลือกที่จะโฮสต์โมเดล open-weights ด้วยตนเอง เช่น Llama, Mistral, Qwen หรือ Gemma:

• ความเป็นส่วนตัวของข้อมูลและการปฏิบัติตามข้อกำหนด ข้อมูลที่ละเอียดอ่อนจะไม่ออกจากเครือข่ายของคุณ — สำคัญสำหรับการดูแลสุขภาพ การเงิน กฎหมาย และภาครัฐ
• ต้นทุนในระดับ นอกเหนือจากปริมาณคำขอที่แน่นอน GPU ที่คุณเป็นเจ้าของอาจมีราคาถูกกว่าต่อโทเค็นมากกว่าการจ่าย API
• การควบคุมและความเสถียร โมเดลจะไม่เปลี่ยนแปลงภายใต้คุณ และคุณไม่จำเป็นต้องอยู่ภายใต้ขีดจำกัดอัตราหรือการเลิกใช้งานของผู้ขาย
• เวลาแฝงและการใช้งานออฟไลน์ การอนุมานถัดจากแอปพลิเคชันของคุณ หรือภายในองค์กรโดยไม่ต้องพึ่งพาอินเทอร์เน็ต

การแลกเปลี่ยนก็คือ ตอนนี้คุณเป็นเจ้าของฮาร์ดแวร์ การปรับขนาด และความน่าเชื่อถือแล้ว — ซึ่งเป็นสิ่งที่ Kubernetes ทำได้ดีจริงๆ

6. ความเป็นจริงของฮาร์ดแวร์ (อ่านสิ่งนี้ก่อนที่คุณจะปรับใช้)

ตุ้มน้ำหนักของ LLM จะต้องพอดีกับหน่วยความจำ GPU (VRAM) กฎง่ายๆ:

เอ็นจิ้นที่ให้บริการสองตัวครองการใช้งานจริง:

• Ollama - ทางลาดที่ง่ายที่สุด เหมาะสำหรับการพัฒนา เครื่องมือภายใน และโหนด CPU หรือโหนด GPU เดี่ยว ดึงโมเดลเชิงปริมาณด้วยคำสั่งเดียว
• vLLM — กลไกการผลิต ปริมาณงานสูง แบทช์คำขอจำนวนมาก และเปิดเผย API ที่เข้ากันได้กับ OpenAI ดังนั้นโค้ดที่มีอยู่ของคุณจึงใช้ได้กับการเปลี่ยนแปลง URL หนึ่งบรรทัด (การกอดใบหน้า TGI เป็นทางเลือกที่ใกล้เคียง)

7. การปรับใช้ LLM ของคุณเองบน Kubernetes

ทุกอย่างด้านล่างถือว่าคลัสเตอร์ที่มีโหนด GPU อย่างน้อยหนึ่งโหนดและ ปลั๊กอินอุปกรณ์ NVIDIA ติดตั้งแล้ว ซึ่งเปิดเผย GPU เป็นทรัพยากรที่กำหนดเวลาได้ nvidia.com/gpu. เราจะสร้างมันขึ้นมาทีละชิ้น

7.1 เนมสเปซและสถานที่สำหรับจัดเก็บตุ้มน้ำหนักแบบจำลอง

ไฟล์โมเดลมีขนาดใหญ่ (กิกะไบต์) และดาวน์โหลดช้า ดังนั้นเราจึงแคชไว้ในไฟล์ การอ้างสิทธิ์ปริมาณคงที่ แทนที่จะดึงการรีสตาร์ทพ็อดทุกครั้ง

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 ตัวเลือก A — Ollama (การเริ่มต้นอย่างง่าย)

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 ตัวเลือก B — vLLM (ปริมาณงานการผลิต เข้ากันได้กับ OpenAI)

สำหรับการรับส่งข้อมูลจริง vLLM จะให้บริการคำขอหลายรายการพร้อมกันอย่างมีประสิทธิภาพและพูดภาษาถิ่น OpenAI API โมเดลที่มีรั้วรอบขอบชิด (เช่น Llama) จำเป็นต้องมีโทเค็น Hugging Face ซึ่งจัดเก็บเป็นความลับ

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 การเปิดเผยด้วย Ingress

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 Scaling — และเหตุใดจึงแตกต่างกับ GPU

คุณสามารถปรับขนาดอัตโนมัติได้ แต่จำไว้ว่า แต่ละแบบจำลองต้องมี GPU ทั้งหมดของตัวเอง — คุณไม่สามารถแบ่งปันแบบเศษส่วนได้ในกรณีธรรมดา และไม่มีการปรับขยายจุดเกินกว่า GPU ที่คุณมีอยู่จริง ปรับขนาดตามคิวหรือสัญญาณอัตราการร้องขอ (KEDA ดีเยี่ยมในที่นี้) แทนที่จะเป็น CPU

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–8B, เชิงปริมาณ)
3. เริ่มต้นด้วย Ollama สำหรับนักบินภายใน สำเร็จการศึกษาไป vLLM เมื่อคุณต้องการปริมาณงาน
4. เพิ่ม RAG เหนือเอกสารของคุณเองเพื่อตัดภาพหลอนและทำให้คำตอบเป็นปัจจุบัน
5. ให้มนุษย์อยู่ในวง ทุกที่ที่คำตอบผิดต้องเสียค่าใช้จ่ายจริง
6. วัดต้นทุนการอนุมานและเวลาแฝง ตามคำขอ — นั่นคือเศรษฐศาสตร์หน่วยที่แท้จริงของคุณ