llm analysis
Bug fixes
Análise de latência e memória de modelos de transformadores para treinamento e inferência
LLMAnalysis Muitas fórmulas ou equações estão flutuando em papéis, blogs etc., sobre como calcular a latência e a memória de treinamento ou inferência para grandes modelos de idiomas (LLMS) ou transformadores. Em vez de fazer matemática em papéis ou digitar lençóis do Excel, let's automate the boring stuff with llm-analysis !
Dado o modelo especificado, a GPU, o tipo de dados e as configurações de paralelismo, LLM-análise estima a latência e o uso da memória do LLMS para treinamento ou inferência. Com a análise da LLM, pode-se facilmente experimentar diferentes configurações de treinamento/inferência teoricamente e entender melhor o desempenho do sistema para diferentes cenários.
A análise da LLM ajuda a responder a perguntas como:
feasible (não obtendo OOM) e optimal (maximizando a taxa de transferência com uma restrição de latência) para treinamento ou inferênciatime leva com a configuração fornecida para fazer treinamento ou inferência e o cost (GPU-Hours)modeling change , hardware improvement , quantization , parallelism etc.)Verifique o exemplo de casos de uso. Com a análise da LLM, você pode fazer essa análise em minutos!
Para instalar a análise LLM da Pypi:
pip install llm-analysisPara instalar a última construção de desenvolvimento:
pip install --upgrade git+https://github.com/cli99/llm-analysis.git@main Para instalar a partir da fonte, clone o repo e execute pip install . ou poetry install (instale poesia por pip install poetry ).
LLMAnalysis Para integrar a análise LLM em seu código, use a classe LLMAnalysis . Consulte a Doc LlManalysis para obter detalhes.
LLMAnalysis é construída com flops e números de eficiência de memória e as seguintes classes de configuração:
ModelConfig cobre as informações do modelo, ou seja, comprimento da sequência máxima, número de camadas de transformador, número de cabeças de atenção, dimensão oculta, tamanho do vocabulárioGPUConfig cobre a GPU e as especificações de memóriaDtypeConfig cobre o número de bits usados para o peso do modelo, ativação e incorporaçãoParallelismConfig cobre o paralelismo do tensor ( tp ), o paralelismo do pipeline ( pp ), o paralelismo da sequência ( sp ), o paralelismo de especialistas ( ep ) e o paralelismo de dados ( dp ). Em seguida, LLMAnalysis pode ser consultada com diferentes argumentos através dos métodos de treinamento e inferência.
A análise da LLM fornece duas funções de entrada, treinar e inferir, para facilitar o uso através da interface da linha de comando. Correr
python -m llm_analysis.analysis train --helpou
python -m llm_analysis.analysis infer --helpPara verificar as opções ou ler o documento vinculado. Consulte os exemplos para ver como eles são usados.
train e infer Use os mapeamentos de nome-configuração predefinidos ( model_configs , gpu_configs , dtype_configs ) e outros argumentos de entrada de usuário para construir a LLMAnalysis e fazer a consulta.
Os mapeamentos predefinidos são preenchidos no tempo de execução dos arquivos json Model, GPU e Type Data Type em Model_configs, GPU_CONFIGS e DTYPE_CONFIGS. Para adicionar um novo modelo, GPU ou tipo de dados ao mapeamento para consulta, basta adicionar um arquivo de descrição json à pasta correspondente.
A LLM-Analysis também suporta a recuperação ModelConfig de um caminho de arquivo JSON de configuração de modelo ou abraçando o rosto com o nome do modelo.
python -m llm_analysis.analysis train --model_name=local_example_model.json . Verifique as configurações do modelo na pasta Model_Configs.EleutherAI/gpt-neox-20b como model_name ao chamar o train ou infer funções de entrada. python -m llm_analysis.analysis train --model_name=EleutherAI/gpt-neox-20b --total_num_gpus 32 --ds_zero 3 . Com esse método, a LLM-Analysis depende de transformers para encontrar a configuração do modelo correspondente em huggingface.co/models, o que significa que as informações de modelos mais recentes só existem após certa versão da biblioteca Transformers. Para acessar os modelos mais recentes por meio de seus nomes, atualize o pacote de transformers instalado. Uma lista de comandos úteis é fornecida para consultar os mapeamentos predefinidos, além de abraçar o rosto ou para despejar configurações. Run python -m llm_analysis.config --help para obter detalhes.
Alguns exemplos:
python -m llm_analysis.config get_model_config_by_name EleutherAI/gpt-neox-20b Obtém o ModelConfig do mapeamento povoado pelo nome, se não for encontrado, a análise da LLM tenta obtê-lo do Huggingface.
Observe que os modelos de LLAMA precisam de pelo menos transformers-4.28.1 para recuperar, atualizar para uma biblioteca transformers posteriores ou usar o ModelConfig predefinido para modelos LLAMA ( / em nomes de modelos são substituídos por _ ).
python -m llm_analysis.config list_gpu_configslista os nomes de todas as configurações de GPU predefinidas, então você pode consultar com
python -m llm_analysis.config get_gpu_config_by_name a100-sxm-80gb para mostrar o GPUConfig correspondente.
A configuração de falhas e a eficiência da memória como 1 (padrão) fornecem o limite inferior do treinamento ou da latência de inferência, pois assume o desempenho do hardware de pico (o que nunca é o caso). Um flops fechado sobre a realidade ou a eficiência da memória pode ser encontrado por benchmarking e perfil usando as dimensões de entrada no modelo.
Se for necessário fazer suposições, para eficiência de flops, relatórios de literatura de até 0.5 para treinamento em modelo em larga escala e até 0.7 para inferência; 0.9 pode ser um alvo agressivo para a eficiência da memória.
A análise da LLM visa fornecer uma estimativa de lower-bound ao uso e latência da memória.
Atualmente, a análise de LLM abrange o paralelismo do tensor (TP), o paralelismo do pipeline (PP), o paralelismo da sequência (SP), o paralelismo de especialistas (EP) e o paralelismo de dados (DP).
TP, PP e SP adotam o estilo de paralelização usado em Megatron-LM para treinamento e FasterTransformer para inferência
Na análise de treinamento, o Sharding DP assume usar DeepSpeed ZeRO ou FSDP . ds_zero é usado para especificar a estratégia de sharding dp
| ds_zero | DeepSpeed Zero | FSDP | Sharding |
|---|---|---|---|
| 0 | desabilitado | NO_SHARD | Sem sharding |
| 1 | Estágio 1 | N / D | Estados do otimizador de shard |
| 2 | Estágio 2 | Shard_grad_op | Gradientes de fragmento e estados de otimizador |
| 3 | Estágio 3 | Full_shard | Gradientes de fragmento, estados de otimizador, parâmetros de modelo |
O EP paraleliza o número de especialistas em MLP nos dispositivos ep_size , ou seja, o número de especialistas por GPU é total number of experts / ep_size . Assim, para o módulo MLP, o número de dispositivos para outras dimensões de paralelização é dividido por ep_size em comparação com outras partes do modelo.
A comunicação de TP é calculada como usando ring allreduce . A comunicação de EP é calculada como usando alltoall . O tempo de comunicação do DP para o peso do modelo não utilizado ao usar FSDP ou zero de velocidade profunda é estimado e comparado com a latência de computação, o maior valor dos dois é usado para a latência geral. Outras comunicações DP e PP são ignoradas por enquanto, ou seja, assumindo a sobreposição perfeita de computação e comunicação, o que não é verdadeiro quando a comunicação não pode se sobrepor à computação devido à dependência ou quando a comunicação é muito longa para se esconder devido à interconexão lenta ou ao grande volume de dados.
A análise da LLM suporta recomputação de ativação completa e seletiva.
| Activation_recompomputação | O que é posicionado e recomputado |
|---|---|
| 0 | Sem recomputação de ativação; requer a maior quantidade de memória |
| 1 | Pontos de verificação O cálculo da atenção (Matriz qk^T multiplicar, softmax, abandono softmax e atenção sobre V.) no módulo de atenção de uma camada de transformador; conforme descrito na redução da recomputação de ativação em grandes modelos de transformadores. |
| 2 | Pontos de verificação da entrada no módulo de atenção em uma camada de transformador; requer um passe extra para a frente da atenção. |
| 3 | Pontos de verificação A entrada na sequência de módulos (layernom-attention-layernom) em uma camada de transformador; Requer um passe extra para frente (Layernom-Attion-Layernom). |
| 4 | A recomputação de ativação completa armazena a entrada na camada do transformador; requer a menor quantidade de memória; requer um passe extra para a frente de toda a camada. |
Os tipos de dados são expressos com o número de bits, apenas 32 (FP32, TF32), 16 (FP16, BF16), 8 (INT8) e 4 (INT4) tipos de dados são modelados por enquanto.
O ajuste fino é modelado da mesma forma (controlado por total_num_tokens passado para a função de entrada train ) como pré-treinamento, assumindo assim o ajuste fino completo (todos os modelos). O ajuste fino com eficiência de parâmetro (PEFT) está em suporte futuro.
A inferência assume a sobreposição perfeita das operações de computação e memória ao calcular a latência e a reutilização máxima da memória ao calcular o uso da memória.
Verifique os TODOS abaixo para obter o que vem a seguir e fique atento?! Quaisquer contribuições ou feedback são altamente bem -vindos!
Se você usar a análise LLM em seu trabalho, cite:
Cheng Li. (2023). LLM-Analysis: Latency and Memory Analysis of Transformer Models for Training and Inference. GitHub repository, https://github.com/cli99/llm-analysis.
ou
@misc{llm-analysis-chengli,
author = {Cheng Li},
title = {LLM-Analysis: Latency and Memory Analysis of Transformer Models for Training and Inference},
year = {2023},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {url{https://github.com/cli99/llm-analysis}},
}
Contribuições e sugestões são bem -vindas.
A análise LLM usa o pré-compromisso para garantir que a formatação do código seja consistente. Para solicitações de tração com a contribuição do código, instale o pré-compromisso ( pip install pre-commit ), bem como os ganchos usados ( pip install no repositório) e formate o código (é executado automaticamente antes de cada confirmação do Git) antes de enviar o PR.
