Modelos e plataformas de IA

Compreendendo Parâmetros e Requisitos de Memória de Modelos de Linguagem Grande: Uma Análise Aprofundada

mm
Publicado em
Atualizado em
Adicione Unite.AI às suas fontes preferidas no Google

Modelos de Linguagem Grande (LLMs) têm visto avanços notáveis nos últimos anos. Modelos como GPT-4, Google’s Gemini e Claude 3 estão definindo novos padrões em capacidades e aplicações. Esses modelos não apenas melhoram a geração de texto e tradução, mas também estão quebrando novos paradigmas no processamento multimodal, combinando 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 diferentes tipos de dados, incluindo texto, imagens e áudio, permitindo interações mais fluidas 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, se torna crucial. Este guia visa desmistificar esses aspectos, oferecendo uma explicação detalhada e fácil de entender.

Os Fundamentos dos Modelos de Linguagem Grande

O que São Modelos de Linguagem Grande?

Modelos de Linguagem Grande são redes neurais treinadas em conjuntos de dados massivos para compreender 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 nos LLMs

Parâmetros são os componentes principais desses modelos. Eles incluem pesos e vieses, que o modelo ajusta durante o treinamento para minimizar erros nas previsões. O número de parâmetros frequentemente correlaciona com a capacidade e desempenho do modelo, mas também influencia seus requisitos computacionais e de memória.

Compreendendo a Arquitetura Transformer

Transformers-architecture

Arquitetura Transformers

Visão Geral

A arquitetura Transformer, introduzida no artigo “Attention Is All You Need” por Vaswani et al. (2017), se tornou a base para muitos LLMs. Ela consiste em um codificador e um decodificador, cada um composto por várias camadas idênticas.

Componentes do Codificador e Decodificador

  • Codificador: Processa a sequência de entrada e cria uma representação consciente do contexto.
  • Decodificador: Gera a sequência de saída usando a representação do codificador e os tokens previamente gerados.

Blocos de Construção Chave

  1. Atenção Multi-Cabeça: Permite que o modelo se concentre em diferentes partes da sequência de entrada simultaneamente.
  2. Redes Neurais Feed-Forward: Adiciona não linearidade e complexidade ao modelo.
  3. Normalização de Camada: Estabiliza e acelera o treinamento, normalizando as saídas intermediárias.

Calculando o Número de Parâmetros

Transformer Training

Modelos Pré-Treinados para Treinamento Eficiente de Transformers

Calculando Parâmetros em LLMs Baseados em Transformers

Vamos quebrar o cálculo de parâmetros para cada componente de um LLM baseado em Transformer. Usaremos a notação do artigo original, onde d_model representa a dimensão dos estados ocultos do modelo.

  1. Camada de Embedding:
    • Parâmetros = vocab_size * d_model
  2. Atenção Multi-Cabeça:
    • Para h cabeças, com d_k = d_v = d_model / h:
    • Parâmetros = 4 * d_model^2 (para Q, K, V e projeções de saída)
  3. Rede Neural Feed-Forward:
    • Parâmetros = 2 * d_model * d_ff + d_model + d_ff
    • Onde d_ff é tipicamente 4 * d_model
  4. Normalização de Camada:
    • Parâmetros = 2 * d_model (para escala e viés)

Parâmetros totais para uma camada de Transformer:

  • Parâmetros_layer = Parâmetros_atenção + Parâmetros_ffn + 2 * Parâmetros_layernorm

Para um modelo com N camadas:

  • Parâmetros Totais = N * Parâmetros_layer + Parâmetros_embedding + Parâmetros_output

Exemplo de Cálculo

Vamos considerar um modelo com as seguintes especificações:

  • d_model = 768
  • h (número de cabeças de atenção) = 12
  • N (número de camadas) = 12
  • vocab_size = 50.000
  1. Camada de Embedding:
    • 50.000 * 768 = 38.400.000
  2. Atenção Multi-Cabeça:
    • 4 * 768^2 = 2.359.296
  3. Rede Neural Feed-Forward:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4.719.616
  4. Normalização de Camada:
    • 2 * 768 = 1.536

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

Esse modelo teria aproximadamente 123 milhões de parâmetros.

Tipos de Uso de Memória

Ao trabalhar com LLMs, precisamos considerar dois principais tipos de uso de memória:

  1. Memória do Modelo: A memória necessária para armazenar os parâmetros do modelo.
  2. 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 números de ponto flutuante de 16 bits.

Memória do Modelo (bytes) = Número de parâmetros * Bytes por parâmetro

Para o nosso exemplo de modelo com 123 milhões de parâmetros:

  • Memória do Modelo (32-bit) = 123.383.808 * 4 bytes = 493.535.232 bytes ≈ 494 MB
  • Memória do Modelo (16-bit) = 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 leva em conta o armazenamento de parâmetros do modelo e 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 o nosso exemplo de modelo:

  • Memória de Trabalho de Inferência ≈ 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 baseados na arquitetura Transformer, entender o uso de memória é crucial para a alocação eficiente de recursos. Vamos quebrar 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 Estável

O uso de memória em estado estável inclui os seguintes componentes:

  1. Pesos do Modelo: Cópias FP32 dos parâmetros do modelo, exigindo 4N bytes, onde N é o número de parâmetros.
  2. Estados do Otimizador: Para o otimizador Adam, isso exige 8N bytes (2 estados por parâmetro).
  3. Gradientes: Cópias FP32 dos gradientes, exigindo 4N bytes.
  4. Dados de Entrada: Supondo entradas int64, isso exige 8BD bytes, onde B é o tamanho do lote e D é a dimensão de entrada.

O uso total de memória em estado estável pode ser aproximado por:

  • M_steady = 16N + 8BD bytes

Uso de Memória de Pico

O uso de memória de pico ocorre durante a passagem de retorno quando as ativações são armazenadas para o cálculo do gradiente. Os principais contribuintes para o uso de memória de pico são:

  1. Normalização de Camada: Exige 4E bytes por normalização de camada, onde E = BSH (B: tamanho do lote, S: comprimento da sequência, H: tamanho oculto).
  2. Bloco de Atenção:
    • Cálculo QKV: 2E bytes
    • Matriz de Atenção: 4BSS bytes (S: comprimento da sequência)
    • Saída de Atenção: 2E bytes
  3. Bloco Feed-Forward:
    • Primeira camada linear: 2E bytes
    • Ativação GELU: 8E bytes
    • Segunda camada linear: 2E bytes
  4. Perda de Entropia Cruzada:
    • Logits: 6BSV bytes (V: tamanho do vocabulário)

A memória total de ativação pode ser estimada como:

  • M_act = L * (14E + 4BSS) + 6BSV bytes

Onde L é o número de camadas de Transformer.

Uso Total de Memória de Pico

O uso de memória de pico durante o treinamento pode ser aproximado combinando a memória em estado estável e a memória de ativação:

  • M_peak = M_steady + M_act + 4BSV bytes

O termo adicional 4BSV leva em conta uma alocação extra no início da passagem de retorno.

Ao entender esses componentes, podemos otimizar o uso de memória durante o treinamento e a inferência, garantindo a alocação eficiente de recursos e o desempenho melhorado dos grandes modelos de linguagem.

Leis de Escala e Considerações de Eficiência

Leis de Escala para LLMs

Pesquisas mostraram que o desempenho dos LLMs tende a seguir certas leis de escala à medida que 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 tipicamente 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: Usando números de ponto flutuante de 16 bits ou até 8 bits para certas operações para reduzir o uso de memória e requisitos computacionais.

b) Paralelismo de Modelo: Distribuir o modelo em várias GPUs ou TPUs para lidar com modelos maiores do que podem caber em um dispositivo.

c) Checkpointing de Gradientes: Trocar computação por memória, recalculando certas ativações durante a passagem de retorno em vez de armazená-las.

d) Poda e Quantização: Remover pesos menos importantes ou reduzir sua precisão pós-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

O 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 quebrar a contagem de parâmetros com valores hipotéticos:

  • d_model = 12288
  • d_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

Parâmetros totais para 96 camadas:

1,1 bilhão * 96 = 105,6 bilhões

Os parâmetros restantes vêm da camada de embedding e outros componentes.

Conclusão

Entender os parâmetros e os requisitos de memória dos grandes modelos de linguagem é crucial para projetar, treinar e implantar essas ferramentas poderosas de forma eficaz. Ao quebrar os componentes da arquitetura Transformer e examinar exemplos práticos como o GPT, ganhamos uma visão mais profunda da complexidade e da escala desses modelos.

Para entender melhor os últimos avanços nos grandes modelos de linguagem e suas aplicações, confira esses guias abrangentes:

mm

Eu passei os últimos cinco anos me imergindo no fascinante mundo de Aprendizado de Máquina e Aprendizado Profundo. Minha paixão e expertise me levaram a contribuir para mais de 50 projetos de engenharia de software diversificados, com um foco particular em IA/ML. Minha curiosidade contínua também me levou em direção ao Processamento de Linguagem Natural, um campo que estou ansioso para explorar mais.