As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Pré-preenchimento e decodificação desagregados para inferência HyperPod

O Disaggregated Prefill and Decode (DPD) separa as duas fases da inferência do LLM, pré-preenchimento e decodificação, em pools de GPU dedicados e transfere o cache de chave-valor (KV) entre elas pelo Elastic Fabric Adapter (EFA) usando o Remote Direct Memory Access (RDMA). GPU-Direct

Quando o pré-preenchimento e a decodificação são executados na mesma GPU (localizada), uma única solicitação de contexto longo pode paralisar fluxos de tokens em andamento para outros clientes, aumentando a latência por token sob carga. O DPD remove essa interferência executando o pré-preenchimento vinculado à computação em um conjunto de GPUs e a decodificação limitada à largura de banda de memória em outro, produzindo uma latência mais previsível sob tráfego misto e permitindo que você escale cada fase de forma independente.

O operador de inferência gerencia a orquestração, que inclui o provisionamento do roteador, a conexão dos pods de pré-preenchimento e decodificação via LMCache e NIXL e a integração com a observabilidade. HyperPod Você pode habilitar o DPD adicionando uma pdSpec seção ao mesmo InferenceEndpointConfig recurso que você já usa para endpoints de inferência.

Quando o DPD ajuda

O DPD oferece o maior benefício quando todas as seguintes condições estão presentes:

Se sua carga de trabalho tem entradas curtas, baixa simultaneidade ou usa modelos pequenos, uma implantação colocalizada padrão é mais simples e tem um bom desempenho.

Pré-requisitos

Antes de implantar endpoints de inferência que usam pré-preenchimento e decodificação desagregados, você precisa configurar os seguintes componentes em seu ambiente de desenvolvimento local:

Implemente um endpoint de DPD

A maioria dos InferenceEndpointConfig campos é compartilhada com endpoints não DPD e documentada em. Implantar modelos de base e modelos personalizados e ajustados Para habilitar o DPD, adicione as seções a seguir ao seu manifesto.

Prefill-Decode Especificação: PDSpec

Declara a prefill/decode topologia e especifica os argumentos. A presença desse campo é o que torna o endpoint desagregado: o operador cria implantações separadas para pré-preenchimento e decodificação e as conecta por meio do roteador e do back-end LMCache PD.

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

Variáveis de ambiente do DPD: Variáveis de ambiente

Essas variáveis de ambiente são aplicadas de forma idêntica aos contêineres do pré-preenchedor e do decodificador; não há campo env-var por função. Para comportamento por função, use pdSpec.{prefillSpec,decodingSpec}.args em vez disso.

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

Configurar a estratégia de roteamento

A intelligentRoutingSpec seção define a estratégia de roteamento que o roteador DPD usa para selecionar um pré-preenchedor para cada solicitação. O roteador é criado automaticamente quando pdSpec está presente; esta seção é opcional e o padrão é. prefixaware

intelligentRoutingSpec:
  enabled: true
  routingStrategy: prefixaware

O DPD também pode ser integrado com roteamento inteligente e cache KV. Para obter mais informações, consulte Configure o cache KV e o roteamento inteligente.

Com uma única réplica pré-preenchida, todas as estratégias são direcionadas para essa réplica. A escolha só afeta o comportamento quandoprefillSpec.replicas > 1:

Exemplo completo

O manifesto a seguir implanta o Llama 3.3 70B em duas instâncias ml.p5.48xlarge (um pré-preenchedor, um decodificador):

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"

Aplique o manifesto:

kubectl apply -f inference_endpoint_dpd_config.yaml

Verificar a implantação

A extração da imagem e o carregamento do modelo demoram vários minutos. Monitore o status do pod:

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

Uma implantação saudável mostra:

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

Cada pod de modelo tem 3 contêineres (trabalhador vLLM, proxy reverso Nginx, coletor). OpenTelemetry O pod do roteador tem 2 contêineres (roteador, OpenTelemetry coletor). Verifique o InferenceEndpointConfig status:

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

Saída esperada: DPD prefill and decode deployments are ready

Verifique as funções do DPD

Confirme os relatórios do pré-preenchedor sender e os relatórios do decodificador. receiver Esse é o sinal de inicialização mais exigente: se os dois pods relatarem a mesma função ou nenhum imprimir a linha, o operador não conectou o DPD corretamente.

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

Saída esperada:

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

Invocar o endpoint

Quando o endpoint estiver pronto, envie um prompt curto e um longo para exercitar os dois caminhos de roteamento e, em seguida, verifique os registros para confirmar a transferência de KV pelo EFA.

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

Aviso curto (abaixo do limite, direto para o decodificador)

Solicitações com menos tokens do que routingThreshold ignoram o pré-preenchedor e vão diretamente para o decodificador:

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
    }'

Solicitação longa (excede o limite, caminho DPD)

Solicitações que excedem o limite são roteadas pelo pré-preenchedor para computação de cache KV e, em seguida, para o decodificador para geração de token:

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}"
'

Verifique a transferência de KV

Depois de enviar um aviso longo, confirme se o cache KV foi transferido verificando os registros do decodificador:

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

Saída esperada (uma linha por classificação TP):

[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 tokenscom N > 0 confirma que o cache KV cruzou o canal NIXL com sucesso. Se você verRetrieved 0 out of N, o decodificador voltou para o recálculo local — veja. Problemas de implantação de pré-preenchimento e decodificação desagregados (DPD)

Você também pode verificar a decisão de roteamento nos registros do roteador:

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

Para o aviso longo, você deve ver:

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

Para o breve aviso:

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

Observabilidade

Ative as métricas metrics.enabled: true configurando seuInferenceEndpointConfig. As métricas do DPD estão disponíveis no painel de HyperPod inferência. Para obter mais informações, consulte Implementando a observabilidade de inferência em clusters HyperPod.

As seguintes DPD-specific métricas estão disponíveis:

Ajuste sua implantação de DPD

A tabela a seguir fornece uma referência rápida para ajustar o DPD com base nos sintomas que você observa em seu painel de métricas.

Teste com sua carga de trabalho real e a distribuição do comprimento de entrada.

Para aplicar as alterações de configuração, edite seu YAML de implantação e reaplique:

kubectl apply -f inference_endpoint_dpd_config.yaml

Limitações conhecidas

Para solucionar problemas de implantações de DPD, consulte. Problemas de implantação de pré-preenchimento e decodificação desagregados (DPD)