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á.
# Execute inferência LLM em lote com vLLM
Este tutorial orienta você na execução da inferência de modelo de linguagem grande (LLM) de alto rendimento em um arquivo JSONL de solicitações usando o mecanismo de inferência vLLM ativado. [ GitHub ](https://github.com/vllm-project/vllm) Você envia o pacote de tarefas de inferência em lote [ vLLM GitHub ](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/vllm_batch) com um arquivo em que cada linha é um prompt, escolhe um modelo e o trabalho se espalha por uma frota de GPU. Cada solicitação recebe uma resposta LLM e uma etapa agregada empacota tudo em um arquivo JSONL, além de um visualizador de HTML independente que você pode abrir em qualquer navegador.
O pacote lida com cargas de trabalho off-line e embaraçosamente paralelas: geração de conteúdo, conjuntos de dados de avaliação, tradução, extração e classificação. Ele se encaixa em qualquer lugar em que você precise de um modelo para responder a muitas solicitações independentes sem um servidor de API ativo. Nos bastidores, ele usa o recurso de fragmentação de tarefas do Deadline Cloud para agrupar solicitações em tarefas em lote, o que permite comparar o paralelismo com a sobrecarga de agendamento com um único parâmetro. `ChunkSize` Para obter mais informações, consulte [Divisão de tarefas para modelos de trabalho](build-job-bundle-chunking.md).
Carregar um 7 B-parameter LLM leva 30 segundos ou mais, portanto, pagar esse custo por tarefa dominaria o tempo de execução do lote. Os ambientes de etapas Open Job Description solucionam esse problema: o servidor vLLM é iniciado quando um trabalhador pega o trabalho e permanece carregado em todas as tarefas que o trabalhador executa, depois é encerrado com a sessão. Um lote de 24 solicitações em uma frota de 4 trabalhadores paga por 4 cargas de modelo em vez de 24.
**Tempo estimado: ** 30 a 60 minutos, incluindo a configuração da fazenda.
A execução deste tutorial gera cobranças para as instâncias de trabalho da GPU que processam a tarefa.
## Visão geral do
Para concluir este tutorial, siga estas etapas:
1. Configure sua fazenda.
1. Prepare o arquivo de entrada.
1. Envie o trabalho de inferência em lote.
1. Faça o download e veja os resultados.
1. Limpe recursos.
## Configure sua fazenda
A maneira mais rápida de obter uma fazenda compatível é implantar o CloudFormation modelo de fazenda [ CUDA em GitHub](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/cuda_farm). Depois que a pilha chegar`CREATE_COMPLETE`, configure o Deadline Cloud CLI para usar a nova fazenda:
```
deadline config set defaults.farm_id {{FarmId-from-stack-outputs}}
deadline config set defaults.queue_id {{CUDAQueueId-from-stack-outputs}}
```
Se você já tem uma fazenda, precisa de uma frota gerenciada por serviços com GPUs NVIDIA e pelo menos 32 GB de RAM, além de uma fila com um ambiente de fila conda anexado que forneça leituras e parâmetros de trabalho. `CondaPackages` `CondaChannels`
## Prepare o arquivo de entrada
A entrada é um arquivo JSONL com um objeto JSON por linha. Cada linha deve ter um `prompt` campo:
```
{"prompt": "What is photosynthesis?", "id": "001"}
{"prompt": "Write a haiku about clouds.", "id": "002"}
{"prompt": "Explain gravity to a 5 year old.", "id": "003", "max_tokens": 256, "temperature": 0.9}
```
Os campos opcionais por solicitação incluem `id` rastreamento, limitação `max_tokens` do comprimento da resposta e controle da `temperature` aleatoriedade da amostragem. Per-promptos campos substituem os padrões de nível de trabalho somente para essa linha, e quaisquer campos adicionais passam para a saída inalterados.
O pacote inclui uma ferramenta HTML de dependência zero para criar arquivos de entrada. Abra `tools/prompt_builder.html` em seu navegador para adicionar solicitações, definir opções por solicitação e exportar como JSONL.
## Envie o trabalho de inferência em lote
**Para enviar com o remetente da GUI**
1. No diretório do `vllm_batch` pacote, abra o remetente:
```
deadline bundle gui-submit .
```
1. Escolha seu arquivo JSONL de entrada.
1. Defina ** o intervalo de solicitações ** (por exemplo, `1-10` para as primeiras 10 solicitações no arquivo).
1. Defina o tamanho do ** bloco**, que é o número de solicitações que cada tarefa processa (padrão`5`).
1. Escolha um diretório de saída e escolha ** Enviar**.
Como alternativa, envie com a CLI:
```
deadline bundle submit . \
--parameter InputFile={{prompts.jsonl}} \
--parameter Prompts=1-10 \
--parameter ChunkSize=5 \
--parameter OutputDir=$PWD/results
```
O `ModelName` parâmetro assume como padrão `Qwen/Qwen2.5-7B-Instruct` e aceita qualquer ID de modelo do Hugging Face. O `Prompts` parâmetro aceita a sintaxe completa do intervalo inteiro Open Job Description, como `2,5,8-9` para linhas específicas ou `4,7` para executar novamente somente linhas com falha. Em vez de fixar o tamanho do bloco, você também pode permitir que o Deadline Cloud o ajuste automaticamente: `TargetRuntimeSeconds` defina quanto tempo você deseja que cada bloco demore (padrão 120 segundos), e o agendador aumenta ou diminui o tamanho do bloco em tarefas futuras para atingir a meta. Para ver a lista completa de parâmetros, consulte [ a tabela de parâmetros no exemplo README em GitHub](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/vllm_batch#parameters).
## Baixe e veja os resultados
**Para baixar e visualizar os resultados**
1. Depois que o trabalho for concluído, baixe a saída:
```
deadline job download-output --job-id {{job-id}}
```
1. Todas as saídas vão para uma `output/` subpasta dentro do diretório que você escolheu. Abra `results/output/results.html` em seu navegador para ver os resultados visuais ou leia `results/output/output.jsonl` para ver a saída combinada bruta.
Cada linha de saída carrega o prompt original e seus campos de passagem, além da `generated_text` resposta, do motivo do término e da contagem de tokens:
```
{"prompt": "What is photosynthesis?", "id": "001", "generated_text": "Photosynthesis is...", "finish_reason": "stop", "prompt_tokens": 7, "completion_tokens": 42}
```
## Encadeie a saída na geração de imagens em lote
O `output.jsonl` arquivo é uma entrada pronta para o pacote de lote de texto para imagem. Gere texto com esse pacote (slogans, legendas, descrições de cenas) e envie o arquivo de saída para o pacote de geração de imagens, que usa automaticamente cada linha `generated_text` como legenda composta sobre a imagem gerada. Para obter o passo a passo completo, consulte. [Gere imagens em lote com um modelo de difusão](tutorial-text-to-image-batch.md)
## Fazer a limpeza.
Para evitar cobranças contínuas, limpe os recursos que você criou para este tutorial:
**Para limpar os recursos do tutorial**
1. Se você implantou o CloudFormation modelo de farm CUDA, exclua a CloudFormation pilha do console. CloudFormation
1. Se você usou uma fazenda existente e criou uma frota de GPU especificamente para este tutorial, interrompa ou exclua essa frota. Se você usou uma frota compartilhada preexistente, deixe-a em vigor.
1. Remova os arquivos de saída locais se não precisar mais deles.
## Recursos relacionados
Os seguintes recursos fornecem informações adicionais:
+ [Exemplo de código-fonte em GitHub ](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/vllm_batch)
+ [Gere imagens em lote com um modelo de difusão](tutorial-text-to-image-batch.md)
+ [Divisão de tarefas para modelos de trabalho](build-job-bundle-chunking.md)
+ [Compare LLMs com vLLM e lm-evaluation-harness](tutorial-vllm-leaderboard.md)
+ [Especificação de ambientes Open Job Description em GitHub ](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment)