🤖 machine learning

FQTree: Fine-grained Quantization and Hardware Generation of Boosted Decision Trees

Este artigo apresenta o FQTree, um algoritmo de treinamento consciente de quantização de granularidade fina combinado com o framework de geração de hardware QXXGB, que otimiza árvores de decisão de boosting para implantação em FPGA ao reduzir o uso de LUT em 26–57% enquanto mantém ou melhora a precisão.

Autores originais: Zhiqiang Que, Chang Sun, Haiyang Wang, Dinesh Pamunuwa, Roshan Weerasekera, Qijia Tang, Bakhtiar Zadeh, Wayne Luk, Maria Spiropulu

Publicado 2026-08-13

📖 4 min de leitura☕ Leitura rápida

CC BY 4.0

Autores originais: Zhiqiang Que, Chang Sun, Haiyang Wang, Dinesh Pamunuwa, Roshan Weerasekera, Qijia Tang, Bakhtiar Zadeh, Wayne Luk, Maria Spiropulu

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você esteja tentando ensinar um robô a tomar decisões, como um árbitro em um videogame ou um segurança em uma boate. Você não quer que o robô seja um pensador lento e pesado; você quer que ele seja ultrarrápido, fazendo escolhas de milésimos de segundo sem hesitar. Este é o mundo das "Árvores de Decisão com Impulso" (Boosted Decision Trees - BDTs). Pense em uma BDT não como um único cérebro gigante, mas como uma equipe de muitos tomadores de decisão pequenos e simples. Cada um faz uma pergunta simples como: "A temperatura está acima de 20 graus?" ou "A velocidade é superior a 50 mph?". Com base na resposta, a equipe passa o bastão para a próxima pessoa na fila. Ao final da fila, toda a equipe somou suas opiniões para fazer uma decisão final. Essas equipes são famosas por serem ótimas em detectar padrões em dados bagunçados, mas têm um problema: elas costumam ser pesadas e lentas demais para os chips minúsculos e super-rápidos (chamados FPGAs) que alimentam sistemas de tempo real, como carros autônomos ou experimentos de física de partículas.

O grande desafio é que essas equipes de decisão são geralmente treinadas usando números "flutuantes" (como 3,14159...), que são precisos, mas ocupam muito espaço e energia para serem armazenados. Para fazer com que funcionem em chips minúsculos, os engenheiros geralmente tentam espremer esses números em caixas menores e mais simples (como números inteiros). Mas é como tentar colocar uma gelatina gigante e trêmula em uma caixa pequena e rígida: se você apenas a espremer depois que a gelatina já tiver endurecido, ela quebra, e o robô começa a cometer erros bobos. A forma antiga de fazer isso era adivinhar o tamanho certo da caixa para cada um, o que muitas vezes desperdiçava espaço ou arruinava a inteligência do robô.

Este artigo apresenta um novo método inteligente chamado FQTree (Fine-grained Quantization Tree) e uma ferramenta companheira chamada QXGB que muda a forma como construímos essas equipes de decisão. Em vez de treinar a equipe com números grandes e flutuantes e depois tentar espremê-los em uma caixa mais tarde, o FQTree ensina a equipe a pensar em caixas pequenas e simples enquanto elas estão aprendendo. É como treinar uma ginasta para realizar uma performance em uma trave de equilíbrio estreita desde o primeiro dia, em vez de deixá-la praticar em um chão largo e depois forçá-la a subir na trave logo antes da competição.

O ingrediente secreto é que o FQTree percebe que nem todos os membros da equipe de decisão são igualmente importantes. Os primeiros membros, que fazem as chamadas grandes e óbvias, precisam ser muito precisos. Os membros posteriores, que apenas fazem pequenos ajustes para corrigir erros minúsculos, não precisam ser tão precisos. O FQTree descobre automaticamente quanta "capacidade cerebral" cada membro precisa. Ele dá aos grandes pensadores mais bits (mais detalhes) e aos pequenos pensadores menos bits (menos detalhes), economizando uma quantidade massiva de espaço. Ele também usa um truque chamado "dobra de viés" (bias folding), que é como deslocar todos os números para que sejam todos positivos, permitindo que o hardware descarte o bit de sinal e se torne ainda mais simples.

Uma vez que a equipe é treinada dessa maneira eficiente, o framework QXGB atua como um tradutor mágico. Ele pega a equipe treinada e constró de instantaneamente um projeto de hardware personalizado para um chip, sem precisar que um engenheiro humano redesenhe os circuitos para cada novo design. Os resultados são impressionantes: em três testes diferentes (um para reconhecer dígitos manuscritos, um para detectar partículas de jato na física e um para encontrar intrusos em redes), este método usou de 26% a 57% menos espaço de hardware (especificamente Tabelas de Consulta, ou LUTs) do que os melhores métodos atuais, mantendo a precisão tão alta ou até tornando-a melhor. Em alguns casos, ele até tornou as decisões duas vezes mais rápidas. É um ganho para ambos os lados: o robô fica menor, mais rápido e tão inteligente quanto antes.

Resumo Técnico: FQTree – Quantização de Grão Fino e Geração de Hardware para Árvores de Decisão Impulsionadas

Declaração do Problema

Árvores de Decisão Impulsionadas (BDTs) são amplamente utilizadas em aplicações de latência crítica devido ao seu desempenho preditivo e tamanho compacto, tornando-as adequadas para implantação em FPGAs (Field-Programmable Gate Arrays). No entanto, a implementação eficiente em hardware continua sendo um desafio. Os designs atuais de BDT orientados para FPGA geralmente dependem de representações de ponto fixo uniformes ou ajustadas manualmente em todo o modelo. Essa abordagem falha em considerar os papéis numéricos heterogêneos dos diferentes componentes de uma BDT (características de entrada, limiares de divisão, valores de folha e lógica de acumulação), o que frequentemente leva a custos de hardware desnecessários ou degradação evitável da precisão.

Além disso, a quantização pós-treinamento (PTQ) direta é frequentemente ineficaz para BDTs. Ao contrário das redes neurais, onde a quantização perturba a aritmética de forma contínua, a quantização de BDTs pode causar mudanças de roteamento discretas; pequenas perturbações nas características ou nos limiares podem inverter decisões de ramificação, alterando inteiramente a folha selecionada. Essa sensibilidade exige uma abordagem de Treinamento com Consciência de Quantização (QAT) que exponha o modelo aos efeitos da quantização durante a otimização, permitindo que os parâmetros numéricos se adaptem à precisão reduzida enquanto preservam a qualidade preditiva.

Metodologia

O Algoritmo FQTree

Os autores propõem o FQTree, um algoritmo de QAT de grão fino e consciente do hardware para BDTs. Diferente da PTQ, o FQTree incorpora a quantização diretamente no loop de treinamento.

Boosting com Quantização: Durante o processo de boosting por estágios, cada árvore recém-ajustada é imediatamente quantizada antes de ser usada em estágios subsequentes de treinamento. Isso garante que as árvores posteriores se adaptem aos erros residuais da coleção (ensemble) já quantizada, compensando tanto os resíduos da tarefa quanto a distorção induzida pela quantização.
Esquema de Quantização de Valor de Folha: A inovação central é uma estratégia de quantização de valor de folha orientada ao hardware. Em vez de precisão uniforme, o FQTree atribui precisão com base na magnitude dos valores das folhas:
- Passo Global e Deslocamento por Árvore: Um passo de quantização global ( $s$ ) é usado em toda a coleção, combinado com um fator de deslocamento por árvore ( $f(\vec{v})$ ).
- Representação de Inteiro Não Negativo: O esquema transforma os valores das folhas em inteiros compactos não negativos. Valores negativos são clipados para zero, e um deslocamento é aplicado para remover o bit de sinal, simplificando o datapath.
- Dobramento de Viés (Bias Folding): O deslocamento removido durante o rebase é dobrado em um termo de viés de nível de árvore ou de classe, que é adicionado apenas uma vez após a acumulação, em vez de ser carregado através de cada caminho da árvore.
- Largura de Bits Dinâmica: A largura de bits para cada árvore ( $b_t$ ) é determinada pelo alcance dinâmico de seus valores inteiros quantizados ( $\lceil \log_2(\max(\vec{v}'_{int}) + 1) \rceil$ ). Árvores iniciais, que contribuem mais para a predição final, recebem naturalmente mais bits, enquanto árvores corretivas posteriores usam menos bits.
Quantização de Característica/Limiar: Uma quantização uniforme padrão é aplicada às características e aos limiares, com sua precisão naturalmente alinhada em hardware via subtratores com sinal.

O Framework QXGB

Para preencher a lacuna entre o treinamento e a implantação, os autores introduzem o QXGB (XGBoost Quantizado), um framework baseado em compilador para geração automática de hardware.

Representação de Fluxo de Dados: A BDT quantizada treinada é reduzida para uma representação intermediária (IR) de Conjunto de Instruções de Aritmética Distribuída (DAIS) estendida. Esta IR é estendida com uma instrução MUX explícita para capturar o roteamento condicional dos nós de decisão, tratando a inferência da BDT como um kernel de fluxo de dados sem estado.
Geração Automática: O compilador rastreia simbolicamente o grafo de computação e gera código RTL sintetizável ou código HLS (High-Level Synthesis). Este fluxo suporta emulação bit-exata e permite a exploração sistemática do compromisso entre precisão-latência-recursos sem redesenho manual.

Principais Contribuições

Algoritmo FQTree: Uma abordagem de QAT de grão fino que apresenta uma formulação de quantização de valor de folha orientada ao hardware que utiliza um passo global, deslocamento por árvore e dobramento de viés para permitir representações de inteiros não negativos compactas.
Framework QXGB: Um fluxo escalável, baseado em compilador, para gerar implementações de BDT em FPGA eficientes e de baixa latência tanto para HLS quanto para RTL, minimizando a latência e o uso de recursos.
Avaliação Abrangente: Demonstração de que o método reduz o uso de Look-Up Tables (LUT) em 26–57% em comparação com designs de BDT para FPGA de última geração, enquanto iguala ou melhora a precisão.

Resultados Experimentais

O método foi avaliado em três conjuntos de dados: JSC (Classificação de Subestrutura de Jato em física de altas energias), MNIST (classificação de dígitos manuscritos) e NID (Detecção de Intrusão de Rede).

Conjunto de Dados JSC: O FQTree alcançou 75,7% de precisão com 1.652 LUTs e 2 ciclos (4,0 ns). Comparado ao TreeLUT (75,6% de precisão, 2.234 LUTs, 3 ciclos), o FQTree melhorou a precisão enquanto reduziu o uso de LUTs em ~26% e a profundidade do pipeline. Em um ponto de menor custo, o FQTree alcançou 74,8% de precisão com apenas 548 LUTs (31% menos que o TreeLUT) e 1 ciclo de latência.
Conjunto de Dados MNIST: A configuração de maior precisão atingiu 97,7% de precisão com 8.147 LUTs e 2 ciclos, superando o melhor anterior (POLYBiNN, 97,2%) com latência e uso de recursos significativamente menores. Em pontos moderados, o FQTree alcançou 96,7% de precisão com 2.744 LUTs, representando uma redução de ~39% em LUTs em relação ao TreeLUT para precisão similar.
Conjunto de Dados NID: O FQTree alcançou 93,1% de precisão com apenas 157 LUTs e 1 ciclo, uma redução de ~55% em LUTs comparado ao TreeLUT (92,7% de precisão, 345 LUTs).
Baseline de PTQ: Quando comparado a um baseline de Quantização Pós-Treinamento usando o mesmo quantizador, o FQTree consistentemente forneceu melhores compromissos entre precisão-recurso, confirmando que os ganhos derivam tanto do design do quantizador quanto do processo de otimização QAT.

Significância e Alegações

O artigo afirma fornecer o primeiro fluxo unificado para implantação de BDTs em FPGA que combina quantização de valor de folha orientada ao hardware, treinamento com consciência de quantização e geração automática de hardware.

Os autores enfatizam que sua abordagem aborda os desafios específicos das BDTs, onde a quantização afeta as decisões de roteamento, não apenas a precisão aritmética. Ao integrar o controle de precisão de grão fino no treinamento e automatizar a geração de hardware via framework QXGB, o método permite a exploração sistemática do compromisso entre precisão-latência-recursos. Os resultados demonstram que o FQTree pode identificar implementações compactas e de alta qualidade que superam significativamente os designs de última geração existentes em termos de eficiência de hardware (uso de LUT) enquanto mantêm ou melhoram a precisão preditiva.