Massive Language Fashions (LLMs) têm visto avanços notáveis nos últimos anos. Modelos como GPT-4, Gemini do Google e Claude 3 estão definindo novos padrões em capacidades e aplicações. Esses modelos não estão apenas aprimorando a geração e tradução de texto, mas também estão abrindo novos caminhos no processamento multimodal, combinando entradas de texto, imagem, áudio e vídeo para fornecer soluções de IA mais abrangentes.
Por exemplo, o GPT-4 da OpenAI mostrou melhorias significativas na compreensão e geração de texto semelhante ao humano, enquanto os modelos Gemini do Google se destacam no tratamento de diversos tipos de dados, incluindo texto, imagens e áudio, permitindo interações mais integradas e contextualmente relevantes. Da mesma forma, os modelos Claude 3 da Anthropic são notados por suas capacidades multilíngues e desempenho aprimorado em tarefas de IA.
À medida que o desenvolvimento de LLMs continua a acelerar, entender as complexidades desses modelos, particularmente seus parâmetros e requisitos de memória, torna-se essential. Este guia visa desmistificar esses aspectos, oferecendo uma explicação detalhada e fácil de entender.
Noções básicas de grandes modelos de linguagem
O que são grandes modelos de linguagem?
Massive Language Fashions são redes neurais treinadas em conjuntos de dados massivos para entender e gerar linguagem humana. Eles dependem de arquiteturas como Transformers, que usam mecanismos como autoatenção para processar e produzir texto.
Importância dos parâmetros em LLMs
Parâmetros são os principais componentes desses modelos. Eles incluem pesos e vieses, que o modelo ajusta durante o treinamento para minimizar erros em previsões. O número de parâmetros geralmente se correlaciona com a capacidade e o desempenho do modelo, mas também influencia seus requisitos computacionais e de memória.
Compreendendo a arquitetura do transformador
Arquitetura de transformadores
Visão geral
A arquitetura Transformer, introduzida no artigo “Consideration Is All You Want” por Vaswani et al. (2017), tornou-se a base para muitos LLMs. Ela consiste em um codificador e um decodificador, cada um composto de várias camadas idênticas.
Componentes de codificador e decodificador
- Codificador: Processa a sequência de entrada e cria uma representação sensível ao contexto.
- Decodificador: Gera a sequência de saída usando a representação do codificador e os tokens gerados anteriormente.
Blocos de construção principais
- Atenção Multi-Cabeça: Permite que o modelo se concentre em diferentes partes da sequência de entrada simultaneamente.
- Redes Neurais Feed-Ahead: Adiciona não linearidade e complexidade ao modelo.
- Normalização de Camadas: Estabiliza e acelera o treinamento normalizando saídas intermediárias.
Calculando o número de parâmetros
Modelos pré-treinados para treinamento eficiente de transformadores
Calculando parâmetros em LLMs baseados em transformadores
Vamos decompor o cálculo de parâmetros para cada componente de um LLM baseado em Transformer. Usaremos a notação do artigo authentic, onde d_model representa a dimensão dos estados ocultos do modelo.
- Camada de incorporação:
- Parâmetros =
vocab_size*d_model
- Parâmetros =
- Atenção Multi-Cabeça:
- Para
hcabeças, comd_k = d_v = d_model / h: - Parâmetros = 4 *
d_model^2 (para projeções Q, Okay, V e de saída)
- Para
- Rede de alimentação direta:
- Parâmetros = 2 *
d_model*d_ff+d_model+d_ff - Onde
d_ffé tipicamente 4 *d_model
- Parâmetros = 2 *
- Normalização de Camadas:
- Parâmetros = 2 *
d_model(para escala e viés)
- Parâmetros = 2 *
Parâmetros totais para uma camada Transformer:
Parameters_layer=Parameters_attention+Parameters_ffn+ 2 *Parameters_layernorm
Para um modelo com N camadas:
- Parâmetros totais =
N*Parameters_layer+Parameters_embedding+Parameters_output
Exemplo de cálculo
Vamos considerar um modelo com as seguintes especificações:
d_model= 768h(número de cabeças de atenção) = 12N(número de camadas) = 12vocab_size= 50.000
- Camada de incorporação:
- 50.000 * 768 = 38.400.000
- Atenção Multi-Cabeça:
- Rede de alimentação direta:
- 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4.719.616
- Normalização de Camadas:
Parâmetros totais por camada:
- 2.359.296 + 4.719.616 + (2 * 1.536) = 7.081.984
Parâmetros totais para 12 camadas:
- 12 * 7.081.984 = 84.983.808
Parâmetros totais do modelo:
- 84.983.808 + 38.400.000 = 123.383.808
Este modelo teria aproximadamente 123 milhões de parâmetros.
Tipos de uso de memória
Ao trabalhar com LLMs, precisamos considerar dois tipos principais de uso de memória:
- Memória do modelo: A memória necessária para armazenar os parâmetros do modelo.
- Memória de trabalho: A memória necessária durante a inferência ou treinamento para armazenar ativações intermediárias, gradientes e estados do otimizador.
Calculando a memória do modelo
A memória do modelo está diretamente relacionada ao número de parâmetros. Cada parâmetro é tipicamente armazenado como um número de ponto flutuante de 32 bits, embora alguns modelos usem treinamento de precisão mista com floats de 16 bits.
Memória do modelo (bytes) = Número de parâmetros * Bytes por parâmetro
Para nosso modelo de exemplo com 123 milhões de parâmetros:
- Memória do modelo (32 bits) = 123.383.808 * 4 bytes = 493.535.232 bytes ≈ 494 MB
- Memória do modelo (16 bits) = 123.383.808 * 2 bytes = 246.767.616 bytes ≈ 247 MB
Estimando a memória de trabalho
Os requisitos de memória de trabalho podem variar significativamente com base na tarefa específica, tamanho do lote e comprimento da sequência. Uma estimativa aproximada para a memória de trabalho durante a inferência é:
Memória de trabalho ≈ 2 * Memória do modelo
Isso é responsável pelo armazenamento dos parâmetros do modelo e das ativações intermediárias. Durante o treinamento, os requisitos de memória podem ser ainda maiores devido à necessidade de armazenar gradientes e estados do otimizador:
Memória de treinamento ≈ 4 * Memória do modelo
Para nosso modelo de exemplo:
- Inferência Memória de trabalho ≈ 2 * 494 MB = 988 MB ≈ 1 GB
- Memória de treinamento ≈ 4 * 494 MB = 1.976 MB ≈ 2 GB
Uso de memória em estado estável e uso de memória de pico
Ao treinar grandes modelos de linguagem com base na arquitetura Transformer, entender o uso da memória é essential para alocação eficiente de recursos. Vamos dividir os requisitos de memória em duas categorias principais: uso de memória em estado estável e uso de memória de pico.
Uso de memória em estado estacionário
O uso de memória em estado estável compreende os seguintes componentes:
- Pesos do modelo: Cópias FP32 dos parâmetros do modelo, exigindo 4N bytes, onde N é o número de parâmetros.
- Estados do Otimizador: Para o otimizador Adam, isso requer 8N bytes (2 estados por parâmetro).
- Gradientes: Cópias FP32 dos gradientes, exigindo 4N bytes.
- Dados de entrada: Assumindo entradas int64, isso requer 8 bytes BD, onde B é o tamanho do lote e D é a dimensão de entrada.
O uso complete da memória em estado estável pode ser aproximado por:
- M_estável = 16N + 8BD bytes
Uso de memória de pico
O pico de uso da memória ocorre durante o passo reverso quando as ativações são armazenadas para computação de gradiente. Os principais contribuidores para o pico de memória são:
- Normalização de Camadas: Requer 4E bytes por norma de camada, onde E = BSH (B: tamanho do lote, S: comprimento da sequência, H: tamanho oculto).
- Bloqueio de atenção:
- Cálculo QKV: 2E bytes
- Matriz de atenção: 4 bytes BSS (S: comprimento da sequência)
- Saída de atenção: 2E bytes
- Bloco de alimentação direta:
- Primeira camada linear: 2E bytes
- Ativação GELU: 8E bytes
- Segunda camada linear: 2E bytes
- Perda de entropia cruzada:
- Logits: 6 bytes BSV (V: tamanho do vocabulário)
A memória de ativação complete pode ser estimada como:
- M_act = L * (14E + 4BSS) + 6 bytes BSV
Onde L é o número de camadas do transformador.
Uso complete de pico de memória
O pico de uso da memória durante o treinamento pode ser aproximado pela combinação da memória de estado estável e da memória de ativação:
- M_pico = M_estável + M_ato + 4 bytes BSV
O termo 4BSV adicional representa uma alocação further no início do passe para trás.
Ao compreender esses componentes, podemos otimizar o uso da memória durante o treinamento e a inferência, garantindo alocação eficiente de recursos e melhor desempenho de grandes modelos de linguagem.
Leis de escala e considerações de eficiência
Leis de escala para LLMs
Pesquisas mostraram que o desempenho de LLMs tende a seguir certas leis de escala conforme o número de parâmetros aumenta. Kaplan et al. (2020) observaram que o desempenho do modelo melhora como uma lei de potência do número de parâmetros, orçamento de computação e tamanho do conjunto de dados.
A relação entre o desempenho do modelo e o número de parâmetros pode ser aproximada por:
Desempenho ∝ N^α
Onde N é o número de parâmetros e α é um expoente de escala normalmente em torno de 0,07 para tarefas de modelagem de linguagem.
Isso implica que, para alcançar uma melhoria de 10% no desempenho, precisamos aumentar o número de parâmetros por um fator de 10^(1/α) ≈ 3,7.
Técnicas de Eficiência
À medida que os LLMs continuam a crescer, pesquisadores e profissionais desenvolveram várias técnicas para melhorar a eficiência:
a) Treinamento de precisão mista: Usar números de ponto flutuante de 16 bits ou mesmo 8 bits para certas operações para reduzir o uso de memória e os requisitos computacionais.
b) Paralelismo de modelos: Distribuir o modelo entre várias GPUs ou TPUs para lidar com modelos maiores do que cabem em um único dispositivo.
c) Ponto de verificação de gradiente: Troca de computação por memória, recalculando certas ativações durante a passagem para trás em vez de armazená-las.
e) Poda e Quantização: Remover pesos menos importantes ou reduzir sua precisão após o treinamento para criar modelos menores e mais eficientes.
e) Destilação: Treinar modelos menores para imitar o comportamento de modelos maiores, potencialmente preservando grande parte do desempenho com menos parâmetros.
Exemplo prático e cálculos
GPT-3, um dos maiores modelos de linguagem, tem 175 bilhões de parâmetros. Ele usa a parte decodificadora da arquitetura Transformer. Para entender sua escala, vamos dividir a contagem de parâmetros com valores hipotéticos:
d_model = 12288d_ff = 4 * 12288 = 49152- Número de camadas = 96
Para uma camada decodificadora:
Parâmetros totais = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1,1 bilhão
Complete para 96 camadas:
1,1 bilhão * 96 = 105,6 bilhões
Os parâmetros restantes vêm da incorporação e de outros componentes.
Conclusão
Entender os parâmetros e os requisitos de memória de grandes modelos de linguagem é essential para projetar, treinar e implementar efetivamente essas ferramentas poderosas. Ao dividir os componentes da arquitetura do Transformer e examinar exemplos práticos como GPT, obtemos uma visão mais profunda da complexidade e escala desses modelos.
Para entender melhor os últimos avanços em grandes modelos de linguagem e suas aplicações, confira estes guias abrangentes:
