Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Disaggregiertes Vorfüllen und Dekodieren für Inferenz HyperPod

Disaggregated Prefill and Decode (DPD) trennt die beiden Phasen der LLM-Inferenz, Vorfüllen und Dekodieren, auf dedizierte GPU-Pools und überträgt den Schlüsselwert-Cache (KV) zwischen ihnen über den Elastic Fabric Adapter (EFA) mithilfe von Remote Direct Memory Access (RDMA). GPU-Direct

Wenn Prefill und Decoding auf derselben GPU (Colocated) ausgeführt werden, kann eine einzelne Anfrage mit langem Kontext dazu führen, dass Token-Streams während des Fluges für andere Clients blockiert werden, was die Latenz pro Token unter Last erhöht. DPD beseitigt diese Interferenz, indem es auf einem Satz von GPUs rechengebundenes Prefill und auf einem anderen eine speicherbandbreitengebundene Dekodierung ausführt. Dadurch wird bei gemischtem Traffic eine vorhersehbarere Latenz erzielt und Sie können jede Phase unabhängig voneinander skalieren.

Der Inferenzoperator kümmert sich um die Orchestrierung. Dazu gehören die Bereitstellung des Routers, die Verkabelung von Prefill- und Decoder-Pods über LMCache und NIXL sowie die Integration mit Observability. HyperPod Sie können DPD aktivieren, indem Sie derselben Ressource, die Sie bereits für Inferenzendpunkte verwenden, einen pdSpec Abschnitt hinzufügen. InferenceEndpointConfig

Wenn DPD hilft

DPD bietet den größten Nutzen, wenn alle der folgenden Bedingungen erfüllt sind:

Wenn Ihr Workload kurze Eingaben hat, wenig Parallelität aufweist oder kleine Modelle verwendet, ist eine standardmäßige Colocation-Bereitstellung einfacher und bietet eine gute Leistung.

Voraussetzungen

Bevor Sie Inferenzendpunkte bereitstellen, die Disaggregated Prefill and Decode verwenden, müssen Sie die folgenden Komponenten in Ihrer lokalen Entwicklungsumgebung einrichten:

Stellen Sie einen DPD-Endpunkt bereit

Die meisten InferenceEndpointConfig Felder werden an Endgeräte weitergegeben, die nicht von DPD stammen, und sind in dokumentiert. Bereitstellen von Grundlagenmodellen und maßgeschneiderten, optimierten Modellen Um DPD zu aktivieren, fügen Sie Ihrem Manifest die folgenden Abschnitte hinzu.

Prefill-Decode Spezifikation: PDSpec

Deklariert die prefill/decode Topologie und spezifiziert Argumente. Durch das Vorhandensein dieses Felds wird der Endpunkt disaggregiert: Der Operator erstellt separate Deployments zum Vorfüllen und Dekodieren und verkabelt sie über den Router und das LMcache PD-Backend miteinander.

pdSpec:
  prefillSpec:
    replicas: 1
    resources:
      limits:
        nvidia.com/gpu: ${GPUS_PER_NODE}
      requests:
        nvidia.com/gpu: ${GPUS_PER_NODE}
    args:
      - "--gpu-memory-utilization"
      - "0.75"
  decodingSpec:
    replicas: 1
    resources:
      limits:
        nvidia.com/gpu: ${GPUS_PER_NODE}
      requests:
        nvidia.com/gpu: ${GPUS_PER_NODE}
  routingThreshold: 4096

DPD-Umgebungsvariablen: Umgebungsvariablen

Diese Umgebungsvariablen werden sowohl auf den Prefiller- als auch auf den Decoder-Container identisch angewendet. Es gibt kein env-var-Feld pro Rolle. Verwenden Sie für das Verhalten pro Rolle stattdessen. pdSpec.{prefillSpec,decodingSpec}.args

environmentVariables:
  - name: PD_BUFFER_SIZE
    value: "8589934592"
  - name: LMCACHE_SAVE_DECODE_CACHE
    value: "False"
  - name: PYTHONHASHSEED
    value: "0"

Konfigurieren Sie die Routing-Strategie

intelligentRoutingSpecIn diesem Abschnitt wird die Routing-Strategie festgelegt, mit der der DPD-Router für jede Anfrage einen Prefiller auswählt. Der Router wird automatisch erstellt, wenn er vorhanden pdSpec ist. Dieser Abschnitt ist optional und standardmäßig aktiviert. prefixaware

intelligentRoutingSpec:
  enabled: true
  routingStrategy: prefixaware

DPD kann auch in intelligentes Routing und KV-Caching integriert werden. Weitere Informationen finden Sie unter Konfigurieren Sie KV-Caching und intelligentes Routing.

Bei einem einzigen Prefill-Replikat werden alle Strategien zu diesem Replikat weitergeleitet. Die Auswahl wirkt sich nur auf das Verhalten aus, wenn: prefillSpec.replicas > 1

Vollständiges Beispiel

Das folgende Manifest stellt Llama 3.3 70B auf zwei ml.p5.48xlarge-Instances (ein Prefiller, ein Decoder) bereit:

apiVersion: inference.sagemaker.aws.amazon.com/v1
kind: InferenceEndpointConfig
metadata:
  name: dpd-test
  namespace: default
spec:
  endpointName: dpd-test
  instanceType: ml.p5.48xlarge
  invocationEndpoint: v1/chat/completions
  modelName: Llama-3.3-70B-Instruct
  modelSourceConfig:
    modelSourceType: s3
    modelLocation: Llama-3.3-70B-Instruct
    s3Storage:
      bucketName: <YOUR_BUCKET>
      region: <YOUR_REGION>
  loadBalancer:
    healthCheckPath: /health
  metrics:
    enabled: true
  kvCacheSpec:
    enableL1Cache: true
  intelligentRoutingSpec:
    enabled: true
    routingStrategy: prefixaware
  pdSpec:
    prefillSpec:
      replicas: 1
      resources:
        requests:
          nvidia.com/gpu: "8"
        limits:
          nvidia.com/gpu: "8"
    decodingSpec:
      replicas: 1
      resources:
        requests:
          nvidia.com/gpu: "8"
        limits:
          nvidia.com/gpu: "8"
    routingThreshold: 4096
  worker:
    image: public.ecr.aws/deep-learning-containers/vllm:server-hyperpod-cuda-v1.1
    args:
      - "--model"
      - "/opt/ml/model"
      - "--host"
      - "0.0.0.0"
      - "--port"
      - "8000"
      - "--tensor-parallel-size"
      - "8"
      - "--max-model-len"
      - "16384"
      - "--gpu-memory-utilization"
      - "0.75"
    modelInvocationPort:
      name: http
      containerPort: 8000
    modelVolumeMount:
      name: model-weights
      mountPath: /opt/ml/model
    resources:
      requests:
        cpu: "96"
        memory: 1024Gi
        nvidia.com/gpu: "8"
      limits:
        cpu: "96"
        memory: 1024Gi
        nvidia.com/gpu: "8"
    environmentVariables:
      - name: HF_HOME
        value: /tmp/hf_home
      - name: PD_BUFFER_SIZE
        value: "8589934592"
      - name: LMCACHE_SAVE_DECODE_CACHE
        value: "False"
      - name: PYTHONHASHSEED
        value: "0"

Wenden Sie das Manifest an:

kubectl apply -f inference_endpoint_dpd_config.yaml

Überprüfen der Bereitstellung

Das Abrufen von Bildern und das Laden des Modells dauern mehrere Minuten. Pod-Status überwachen:

kubectl get pods -A \
  | grep -E "prefill-|decode-|router"

Eine fehlerfreie Bereitstellung zeigt:

NAMESPACE                   NAME                                   READY   STATUS    RESTARTS   AGE
default                     prefill-dpd-test-XXXX                  3/3     Running   0          7m
default                     decode-dpd-test-XXXX                   3/3     Running   0          7m
hyperpod-inference-system   dpd-test-router-XXXX                   2/2     Running   0          7m

Jeder Modell-Pod hat 3 Container (vLLM-Worker, Nginx-Reverse-Proxy, Collector). OpenTelemetry Der Router-Pod hat 2 Container (Router, Collector). OpenTelemetry Überprüfen Sie den InferenceEndpointConfig Status:

kubectl get inferenceendpointconfig dpd-test -n default \
  -o jsonpath='{.status.conditions[0].message}{"\n"}'

Erwartete Ausgabe: DPD prefill and decode deployments are ready

Überprüfen Sie die DPD-Rollen

Bestätigen Sie die Prefiller-Berichte sender und die Decoder-Berichte. receiver Dies ist das wichtigste Startsignal. Wenn beide Pods dieselbe Rolle melden oder keiner die Leitung druckt, hat der Bediener DPD nicht richtig verkabelt.

PREFILL_POD=$(kubectl get pod -n ${NAMESPACE} \
  -l 'inference.sagemaker.aws.amazon.com/dpd-role=prefill' \
  -o jsonpath='{.items[0].metadata.name}')

DECODE_POD=$(kubectl get pod -n ${NAMESPACE} \
  -l 'inference.sagemaker.aws.amazon.com/dpd-role=decode' \
  -o jsonpath='{.items[0].metadata.name}')

kubectl logs $PREFILL_POD -n ${NAMESPACE} -c prefill-${DEPLOYMENT_NAME} \
  | grep -oE "'pd_role': '[a-z]+'" | sort -u

kubectl logs $DECODE_POD -n ${NAMESPACE} -c decode-${DEPLOYMENT_NAME} \
  | grep -oE "'pd_role': '[a-z]+'" | sort -u

Erwartete Ausgabe:

'pd_role': 'sender'
'pd_role': 'receiver'

Rufen Sie den Endpunkt auf

Sobald der Endpunkt bereit ist, senden Sie eine kurze und eine lange Aufforderung, beide Routing-Pfade zu nutzen, und überprüfen Sie dann die Protokolle, um die KV-Übertragung über EFA zu bestätigen.

PREFILL_POD=$(kubectl get pod -n ${NAMESPACE} \
  -l 'inference.sagemaker.aws.amazon.com/dpd-role=prefill' \
  -o jsonpath='{.items[0].metadata.name}')

DECODE_POD=$(kubectl get pod -n ${NAMESPACE} \
  -l 'inference.sagemaker.aws.amazon.com/dpd-role=decode' \
  -o jsonpath='{.items[0].metadata.name}')

ROUTER_POD=$(kubectl get pods -n hyperpod-inference-system -o name \
  | grep -- "${DEPLOYMENT_NAME}-${NAMESPACE}-router" | head -1)

ROUTER_URL=http://${DEPLOYMENT_NAME}-${NAMESPACE}-routing-service.hyperpod-inference-system.svc.cluster.local:443/v1/chat/completions

Kurze Aufforderung (unter dem Schwellenwert, direkt zum Decoder)

Anfragen mit weniger Tokens als dem Prefiller routingThreshold umgehen den Prefiller und gehen direkt zum Decoder:

kubectl run curl-short --rm -it --image=curlimages/curl --restart=Never -- \
  curl -s -k -X POST "$ROUTER_URL" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "/opt/ml/model",
      "messages": [{"role": "user", "content": "What is disaggregated prefill-decode in one sentence?"}],
      "max_tokens": 80,
      "temperature": 0.0
    }'

Lange Eingabeaufforderung (überschreitet den Schwellenwert, DPD-Pfad)

Anfragen, die den Schwellenwert überschreiten, werden über den Prefiller für die KV-Cache-Berechnung weitergeleitet und dann zur Token-Generierung an den Decoder weitergeleitet:

kubectl run curl-long --rm -it --image=curlimages/curl --restart=Never -- sh -c '
LONG=""
i=0; while [ $i -lt 600 ]; do LONG="${LONG}The quick brown fox jumps over the lazy dog. "; i=$((i+1)); done
curl -s -k -X POST "'"$ROUTER_URL"'" \
  -H "Content-Type: application/json" \
  -d "{\"model\":\"/opt/ml/model\",\"messages\":[{\"role\":\"user\",\"content\":\"${LONG}\"}],\"max_tokens\":30,\"temperature\":0.0}"
'

Überprüfen Sie die KV-Übertragung

Vergewissern Sie sich nach dem Senden einer langen Aufforderung, dass der KV-Cache übertragen wurde, indem Sie die Decoder-Protokolle überprüfen:

kubectl logs $DECODE_POD -n ${NAMESPACE} -c decode-${DEPLOYMENT_NAME} \
  | grep -E "Retrieved.*tokens.*throughput" | tail -2

Erwartete Ausgabe (eine Zeile pro TP-Rang):

[Worker_TP5] [LMCache INFO] [req_id=cmpl-...] Retrieved 6035 out of 6035 required tokens (from 6035 total tokens).
   size: 0.2344 gb, cost 1.3304 ms, throughput: 176.1686 GB/s

Retrieved N out of N required tokensmit N > 0 bestätigt, dass der KV-Cache den NIXL-Kanal erfolgreich überquert hat. Wie Sie sehenRetrieved 0 out of N, hat der Decoder auf die lokale Neuberechnung zurückgegriffen — siehe. Probleme bei der Bereitstellung von Disaggregated Prefill and Decode (DPD)

Sie können die Routing-Entscheidung auch in den Router-Protokollen überprüfen:

kubectl logs $ROUTER_POD -n hyperpod-inference-system -c router-container --tail=20 \
  | grep -E "Conditional routing"

Für die lange Eingabeaufforderung sollten Sie Folgendes sehen:

[INFO] Conditional routing: estimated_tokens=6750, threshold=4096, disaggregate=True

Für die kurze Eingabeaufforderung:

[INFO] Conditional routing: estimated_tokens=12, threshold=4096, disaggregate=False

Beobachtbarkeit

Aktivieren Sie Metriken, indem Sie Ihre einstellenmetrics.enabled: true. InferenceEndpointConfig DPD-Metriken sind im HyperPod Inferenz-Dashboard verfügbar. Weitere Informationen finden Sie unter Implementierung von Inferenzbeobachtbarkeit auf Clustern HyperPod.

Die folgenden DPD-specific Metriken sind verfügbar:

Optimieren Sie Ihren DPD-Einsatz

Die folgende Tabelle enthält eine Kurzübersicht zur Optimierung von DPD auf der Grundlage der Symptome, die Sie in Ihrem Metrik-Dashboard beobachten.

Testen Sie mit Ihrer tatsächlichen Arbeitslast und der Längenverteilung der Eingaben.

Um die Konfigurationsänderungen zu übernehmen, bearbeiten Sie Ihre Implementierungs-YAML und wenden Sie sie erneut an:

kubectl apply -f inference_endpoint_dpd_config.yaml

Bekannte Beschränkungen

Informationen zur Fehlerbehebung bei DPD-Bereitstellungen finden Sie unter. Probleme bei der Bereitstellung von Disaggregated Prefill and Decode (DPD)