อธิบายโมเดลภาษาขนาดใหญ่: วิธีการทำงานของ 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) กฎง่ายๆ:

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

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