O treinamento e raciocínio de grandes modelos frequentemente envolvem o conceito de precisão, e existem muitos tipos, e eles também são divididos em diferentes formatos com o mesmo nível de precisão. Além disso, também existem os conceitos de multiprecisão e precisão mista em cenários práticos.
Precisão comum
Precisão em ponto flutuante: precisão dupla (FP64), precisão simples (FP32, TF32), meia precisão (FP16, BF16), precisão de 8 bits (FP8), precisão de 4 bits (FP4, NF4)
Precisão da quantificação: INT8, INT4 (também INT3/INT5/INT6)
Um número de ponto flutuante consiste em três partes: bits de signo, exponencial e mantisa. Quanto maior o bit exponencial, maior a faixa de números que podem ser representados. Quanto maior o dígito da mantise, maior a precisão do número.
A tabela resume a situação da seguinte forma
| formato | bit de símbolo | Bit exponencial | casa decimal | Total de dígitos | | FP64 | 1 | 11 | 52 | 64 | | FP32 | 1 | 8 | 23 | 32 | | TF32 | 1 | 8 | 10 | 19 | | BF16 | 1 | 8 | 7 | 16 | | FP16 | 1 | 5 | 10 | 16 | | FP8 E4M3 | 1 | 4 | 3 | 8 | | FP8 E5M2 | 1 | 5 | 2 | 8 | | FP4 | 1 | 2 | 1 | 4 |
FP32: Número de ponto flutuante de 32 bits, 4 bytes por dado
TF32: Número de ponto flutuante de 19 bits, cada dado tem 2 bytes
FP16: Número de ponto flutuante de 16 bits, 2 bytes por dado
BF16: Número de ponto flutuante de 16 bits, cada dado tem 2 bytes
Int8: inteiro de 8 bits, cada dado representa 1 byte
Int4: inteiros de 4 bits, cada dado tem 0,5 bytes
Por que tanta precisão
Por causa do custo e da precisão. Todos sabemos que alta precisão é definitivamente mais precisa, mas também trará custos mais altos de computação e armazenamento. Menor precisão reduz a precisão dos cálculos, mas pode melhorar a eficiência computacional e o desempenho. Assim, uma variedade de precisões diferentes permite que você escolha a mais adequada em diferentes situações.
A dupla precisão é mais precisa do que a expressão de precisão simples, mas consome o dobro de armazenamento e leva mais tempo para ser calculada.
Por que grandes modelos precisam ser quantificados?
1. Reduzir o uso de memória
Modelos grandes geralmente usam números de ponto flutuante de 32 bits (FP32) ou números de ponto flutuante de 16 bits (FP16) para representar pesos e valores de ativação. Por meio da quantização, esses valores de alta precisão podem ser convertidos em representações de menor precisão (por exemplo, inteiros de 8 bits, INT8), reduzindo significativamente o espaço de armazenamento do modelo. Isso é importante para implantação em dispositivos com recursos limitados, como dispositivos móveis, sistemas embarcados, etc.
2. Acelerar a velocidade do raciocínio
Modelos quantizados podem rodar de forma mais eficiente em hardware. Muitos hardwares modernos (como GPUs, TPUs, NPUs, etc.) possuem suporte especializado de otimização para computação de baixa precisão, permitindo operações de quantização mais rápidas. Além disso, cálculos de baixa precisão frequentemente envolvem menos operações de bits, reduzindo a complexidade computacional e, assim, acelerando a inferência.
3. Reduzir o consumo de energia
O modelo quantizado não só reduz a necessidade de recursos computacionais, mas também diminui o consumo de energia. Isso é especialmente importante para dispositivos movidos a bateria, como smartphones, dispositivos IoT, etc., onde baixo consumo de energia significa maior duração da bateria.
4. Dispositivos de borda fáceis de implantar
Muitos modelos grandes foram inicialmente treinados e implantados na nuvem, mas com o desenvolvimento da computação de borda, cada vez mais cenários de aplicação exigem que os modelos sejam implantados em dispositivos de borda. Com poder computacional e recursos de armazenamento limitados em dispositivos de borda, a quantização pode ajudar esses modelos a rodar de forma mais eficiente em dispositivos de borda.
5. Reduzir os requisitos de largura de banda
No processo de inferência distribuída ou atualizações de modelos, a quantização pode reduzir a largura de banda necessária para a transferência do modelo. Isso é útil para ambientes com largura de banda limitada na rede, como dispositivos IoT em áreas remotas.
6. Manter o desempenho do modelo
Embora a quantização introduza certa perda de precisão, o desempenho original do modelo pode ser amplamente preservado por meio de métodos apropriados de quantização (como quantização de precisão mista, quantização pós-treinamento, treinamento de percepção quantitativa, etc.). Portanto, em aplicações práticas, a quantificação pode encontrar um bom equilíbrio entre desempenho e eficiência.
Referência de memória
| tipo | Cada bilhão de parâmetros precisa ocupar memória | | float32 | 4G | | FP16/BF16 | 2G | | int8 | 1G | | int4 | 0,5G |
FP64 (Precisão Dupla)
Ponto flutuante de 64 bits, tipicamente um formato binário de ponto flutuante de dupla precisão definido pelo IEEE 754, possui:
Símbolo de 1 dígito
Índice de 11 dígitos
52 casas decimais
Alcance: ~2,23e-308... ~1,80e308 com precisão decimal total 15-17.
Uso:
Esse formato é usado para cálculos científicos que exigem alta precisão.
Ele normalmente não é usado para cálculos de aprendizado profundo.
Suporte de software:
Representa o tipo duplo na maioria dos sistemas C/C++.
Suportado em TensorFlow (ex.: tf.float64) / PyTorch (ex.: torch.float64 ou torch.double).
Suporte de hardware:
Normalmente suportado em CPUs x86.
A maioria das GPUs, especialmente as de jogos, incluindo a série RTX, tem desempenho severamente limitado em FP64 (geralmente 1/32 do desempenho FP32 em vez de 1/2).
GPUs recentes sem restrições suportadas por FP64 incluem GP100/100/102/104 em Tesla P40/P4 e Quadro GP100, GV100 em Tesla V100/Quadro GV100/Titan V, e a recentemente anunciada GA100 em A100 (curiosamente, a nova arquitetura Ampere tem uma terceira geração) em comparação com os Tensor Cores habilitados para FP64 O novo processamento FP64 compatível com IEEE agora está incluído, entregando 2,5 vezes o desempenho FP64 do V100.
FP32 (Precisão Total)
Esse formato há muito tempo é um cavalo de batalha para o deep learning. Outro formato IEEE 754, ponto flutuante de precisão simples, possui:
Símbolo de 1 dígito
Índice de 8 dígitos
23 casas decimais
Idealmente, tanto o treinamento quanto a inferência deveriam ser feitos no FP32, mas o FP32 é duas vezes mais lento que o FP16/BF16, então métodos de precisão mista são frequentemente usados na prática, onde os mesmos pesos do FP32 são usados como o "peso mestre" exato, os pesos do FP16/BF16 são usados para cálculos de propagação para frente e para trás a fim de melhorar a velocidade de treinamento, e finalmente os pesos soberanos do FP32 são atualizados com gradientes FP16/BF16 na fase de atualização do gradiente.
Durante o treinamento, o peso soberano é sempre FP32. Na prática, pesos de meia precisão frequentemente fornecem precisão semelhante à FP32 na inferência – porque pesos exatos FP32 só são necessários quando o gradiente do modelo é atualizado. Isso significa que podemos usar pesos de meia precisão na inferência, então podemos obter o mesmo resultado com apenas metade da memória da GPU.
Alcance: ~1,18e-38... ~3,40e38 com precisão de 6-9 decimais significativos.
Uso:
O tipo padrão de computação em redes neurais por muito tempo. Pesos, ativações e outros valores em redes neurais há muito tempo são padrão para FP32.
Para muitos cálculos científicos, especialmente os iterativos, a precisão não é suficiente, levando ao acúmulo de erros.
Suporte de software:
Representa o tipo float na maioria dos sistemas C/C++.
Suportado em TensorFlow (ex.: tf.float32) / PyTorch (ex.: torch.float32 ou torch.float).
Suporte de hardware:
Normalmente suportado em CPUs x86.
Normalmente suportado por GPU NVIDIA/AMD.
FP16 (Metade de Precisão)
De forma semelhante, o formato padrão IEEE 754, o formato de ponto flutuante de meia precisão, possui:
Símbolo de 1 dígito
Índice de 5 dígitos
10 casas decimais
O número FP16 tem um alcance numérico muito menor que o FP32. Portanto, FP16 corre risco de transbordamento (quando usado para representar números muito grandes) e desbordamento (quando usado para representar números muito pequenos). Por exemplo, quando você faz 10k * 10k, o resultado final deve ser 100M, que FP16 não pode representar porque o número máximo que FP16 pode representar é 64k. Então você acaba com NaN (Não Número) nos cálculos de redes neurais, porque os cálculos são feitos em camadas e em ordem loteada, então, uma vez que NaN aparece, todos os cálculos anteriores são destruídos. Em geral, isso pode ser mitigado pela escala de perdas, mas essa abordagem nem sempre funciona.
Alcance: ~5,96e−8 (6,10e−5) ... 65504, com precisão de 4 dígitos decimais significativos.
Uso:
O deep learning tende a usar FP16 em vez de FP32, já que cálculos de menor precisão parecem não importar para redes neurais. A precisão extra não adianta nada, e ao mesmo tempo é mais lenta, exigindo mais memória e desacelerando a comunicação.
Pode ser usado para treinamento, geralmente com treinamento de precisão mista (TensorFlow/PyTorch).
Pode ser usado para quantização pós-treinamento para acelerar a inferência (TensorFlow Lite). Outros formatos usados para quantização pós-treinamento incluem inteiros INT8 (inteiros de 8 bits), INT4 (4 bits) e até INT1 (valores binários).
Suporte de software:
Atualmente não está no padrão C/C++ (mas há uma proposta de float curta). Alguns sistemas C/C++ suportam __fp16 tipos. Caso contrário, pode ser usado com bibliotecas especiais.
Suportado em TensorFlow (ex.: tf.float16) / PyTorch (ex.: torch.float16 ou torch.half).
Suporte de hardware:
CPUs x86 não são suportadas (como um tipo único).
O suporte em GPUs gamers antigas é ruim (desempenho 32/1 para FP64, veja o post sobre GPUs para mais detalhes). Atualmente, ele é bem suportado em GPUs modernas, como a série NVIDIA RTX.
BFLOAT16 (Meia Precisão)
Outro formato de 16 bits originalmente desenvolvido pelo Google é chamado de "Brain Floating Point Format", ou "bfloat16" para abreviar. O nome vem do Google Brain.
O IEEE FP16 original foi projetado sem considerar aplicações de deep learning, e sua faixa dinâmica era muito limitada. BFLOAT16 resolve esse problema, oferecendo a mesma faixa dinâmica do FP32.
Portanto, BFLOAT16 possuem:
Símbolo de 1 dígito
Índice de 8 dígitos
7 casas decimais
O formato bfloat16 é truncado para IEEE 754 FP32, permitindo uma conversão rápida para e de IEEE 754 FP32. Ao converter para o formato bfloat16, os bits exponenciais são preservados, enquanto os campos mantissa podem ser reduzidos por truncamento.
Alcance: ~1,18e-38 ... ~3,40e38 com 3 casas decimais significativas.
Uso:
Agora parece que está substituindo o FP16. Diferente do FP16, que frequentemente requer processamento especial por meio de técnicas como escalonamento de perda, o BF16 é quase um substituto direto do FP32 ao treinar e executar redes neurais profundas.
Suporte de software:
Não no padrão C/C++. Pode ser usado com bibliotecas especiais.
Suportado em TensorFlow (ex.: tf.bfloat16) / PyTorch (ex.: torch.bfloat16).
TF32
TensorFloat-32 ou TF32 é o novo modo matemático nas GPUs NVIDIA A100.
Usando as mesmas louva-a-deus de 10 bits da matemática de meia-precisão (FP16), o TF32 prova ter margem suficiente para atender aos requisitos de precisão das cargas de trabalho de IA. E o TF32 usa o mesmo índice de 8 bits do FP32, então pode suportar a mesma faixa numérica.
Tecnicamente, é um formato de 19 bits. Pense nisso como uma BFLOAT16 de precisão estendida, como "BFLOAT19", ou uma precisão diminuída como FP32.
Então, TF32 tem:
Símbolo de 1 dígito
Índice de 8 dígitos
10 casas decimais
A vantagem do TF32 é que ele tem o mesmo formato do FP32. Ao calcular o produto interno com TF32, a mantissa do operando de entrada é arredondada de 23 para 10 bits. Os operandos de arredondamento são multiplicados exatamente e acumulados no FP32 normal.
O TF32 Tensor Core roda com entradas FP32 e gera resultados em FP32 sem alterações de código. Operações não-matriciais continuam a usar FP32. Isso oferece uma maneira fácil de acelerar dados de entrada/saída FP32 em frameworks de deep learning e HPC.
Alcance: ~1,18e-38 ... ~3,40e38 com precisão de 4 casas decimais significativas.
Uso:
Uma das grandes vantagens do TF32 é que ele só precisa de suporte de compiladores no nível mais profundo, ou seja, dentro do compilador CUDA. O resto do código apenas mostra FP32 com menos precisão, mas com a mesma faixa dinâmica. Usar o TF32 serve principalmente para fazer chamadas para a biblioteca e mostrar se ela está funcionando corretamente. A presença do TF32 permite plug-ins rápidos, aproveitando a velocidade dos Núcleos Tensor sem muito trabalho.
Formatos como FP16 e BFLOAT16 exigem mais ajustes, pois envolvem layouts de bits diferentes. Mas usar esses formatos reduz a largura de banda da memória, permitindo uma execução mais rápida.
Para comparação, o desempenho máximo do A100 é:
FP32 sem núcleos tensoriais: 19,5 TFLOPS
Núcleos Tensoriais TF32: 156 TFLOPS (então usar TF32 em vez de FP32 facilita aumentar a velocidade).
FP16/BF16 Núcleos de Tensor: 312 TFLOPS (portanto, uma mudança razoável para FP16/BF16 pode trazer mais ganhos de velocidade, mas a um custo maior).
Suporte de software:
Não no padrão C/C++.
CUDA 11 suportado.
Suporte de hardware:
GPU: NVIDIA A100 é o primeiro modelo a ser suportado
FP8
Introduzido pela GPU H100, ele permite maior multiplicação de matrizes e convolução, mas com menor precisão.
Os tipos de dados FP100 suportados pelo H8 são, na verdade, 2 tipos de dados diferentes que podem ser usados para diferentes partes do treinamento de redes neurais:
E4M3 - consiste em 1 bit simbólico, 4 bits exponenciais e 3 casas decimais. Pode armazenar até +/-448 e nan.
E5M2 - consiste em 1 bit de sinal, 5 bits exponenciais e 2 casas decimais. Ele pode armazenar valores de até +/-57344, +/-inf e nan. A desvantagem de aumentar a faixa dinâmica é que os valores armazenados são menos precisos.
Estrutura dos tipos de dados em ponto flutuante. Todos os valores exibidos (em FP16, BF16, FP8 E4M3 e FP8 E5M2) são a representação mais próxima do valor 0,3952.
Ambos os tipos podem ser usados durante o treinamento de uma rede neural. Em geral, ativação e peso para frente exigem maior precisão, então é melhor usar o tipo de dado E4M3 durante a passagem para frente. No entanto, na retropropagação, o gradiente que flui pela rede geralmente é menos suscetível à perda de precisão, mas requer uma faixa dinâmica maior. Portanto, é melhor armazená-los usando o formato de dados E5M2. O H100 TensorCore suporta qualquer combinação desses tipos como entrada, permitindo que armazenemos cada tensor com a precisão desejada.
Referência:
O login do hiperlink está visível.
O login do hiperlink está visível. |
Postado em 2025-3-10 14:22:34
|
|
|
|
