Native Byzantine-Robust Aggregation for Trustworthy Federated Learning: A C++20 Evaluation of Krum, Multi-Krum, Trimmed Mean, and Coordinate-wise Median

Imagine um grupo de estranhos tentando resolver um quebra-cabeça complexo juntos, mas todos estão em salas diferentes e não podem ver as peças uns dos outros. Eles só podem enviar descrições de seu progresso para um líder central. Esta é a essência de um método de computação moderno chamado aprendizado federado (federated learning), onde muitos dispositivos treinam uma inteligência artificial compartilhada sem nunca compartilhar seus dados privados. O sistema funciona maravilhosamente quando todos jogam limpo, mas enfrenta uma fraqueza crítica: e se um desses estranhos estiver mentindo? Um dispositivo comprometido poderia enviar uma descrição completamente errada, não porque esteja quebrado, mas porque é malicioso, visando corromper a resposta final. Neste cenário, simplesmente confiar na maioria não é suficiente, pois alguns atores maldosos podem desviar todo o grupo do caminho. O desafio para os cientistas é construir um sistema que possa detectar esses mentirosos e ignorar seus maus conselhos, garantindo que o resultado final permaneça confiável, mesmo quando alguns participantes estão tentando ativamente sabotar o processo.

Os pesquisadores há muito sabem como filtrar matematicamente esses atores maldosos usando regras específicas, mas transformar essas regras em software rápido e confiável tem sido difícil. Um novo estudo de Md Shahanur Islam Shagor, da Universidade Estadual de Silvicultura e Tecnologias de Voronezh, aborda este problema construindo um motor de alta velocidade para executar essas verificações de segurança. A equipe não inventou uma nova maneira de filtrar dados ruins; em vez disso, pegaram quatro métodos existentes e bem conhecidos para detectar mentirosos e os reconstruíram do zero usando uma linguagem de programação moderna projetada para velocidade e segurança. O objetivo deles era provar que esses mecanismos de segurança poderiam rodar rápido o suficiente para serem úteis em aplicações do mundo real, garantindo também que nunca aceitassem acidentalmente uma entrada quebrada ou perigosa.

Os pesquisadores focaram em quatro estratégias específicas para lidar com dados ruins. As duas primeiras, conhecidas como Krum e Multi-Krum, funcionam medindo o quão longe a atualização de cada pessoa está de todos os outros. Se a atualização de uma pessoa for drasticamente diferente da do grupo, o sistema a identifica como um ponto fora da curva (outlier) e escolhe a pessoa mais consistente ou faz a média das poucas pessoas mais consistentes. As outras duas estratégias, a média aparada (trimmed mean) e a mediana coordenada a coordenada (coordinate-wise median), funcionam olhando para cada parte da peça do quebra-cabeça individualmente. Elas descartam os números mais altos e mais baixos para cada parte antes de calcular a média, ou simplesmente escolhem o valor central, ignorando efetivamente os valores extremos que possam estar tentando distorcer o resultado. Embora essas ideias matemáticas sejam bem compreendidas, os pesquisadores queriam ver como elas se comportavam quando implementadas como um programa de computador nativo que pudesse rodar ao lado dos sistemas de software massivos usados para inteligência artificial hoje.

Para testar seu trabalho, a equipe criou uma simulação controlada onde dez clientes virtuais tentaram treinar um modelo ao longo de vinte e cinco rodadas. Nesta simulação, dois dos clientes foram programados para agir como atacantes maliciosos. Um atacante tentou inverter completamente a direção do progresso, enquanto o outro inundou o sistema com ruído aleatório de alta variância projetado para confundir a matemática. Apesar dessas tentativas agressivas de descarrilar o processo, o sistema guiou com sucesso o modelo em direção ao alvo correto. Após vinte e cinco rodas, a distância entre a posição atual do modelo e o alvo real encolheuu para menos de cinco por cento de onde começou. Este resultado manteve-se verdadeiro para o método Multi-Krum, a média aparada e a mediana, provando que essas regras estabelecidas podiam de fato resistir a uma taxa de ataque de vinte por cento em um ambiente controlado.

No entanto, a parte mais surpreendente do estudo não foi apenas que as regras de segurança funcionaram, mas o quão rápido elas rodaram em comparação com ferramentas de software padrão. Os pesquisadores mediram o tempo necessário para processar atualizações contendo mil parâmetros e, novamente, com cem mil parâmetros. Para os métodos baseados em distância, como Krum e Multi-Krum, o novo código nativo foi dramaticamente mais rápido. Ao processar mil parâmetros, o novo código foi mais de duas vezes mais rápido que as ferramentas padrão e, quando o tamanho cresceu para cem mil parâmetros, tornou-se mais de três vezes mais rápido. Esse aumento de velocidade aconteceu porque o novo código pôde usar o processador do computador para lidar com muitos cálculos de uma só vez e realizar verificações de distância complexas com extrema eficiência.

Contudo, a história foi diferente para os outros métodos. A média aparada, que envolve ordenar números para encontrar o meio, não ficou mais rápida com o novo código. Na verdade, em tamanhos menores, foi na verdade mais lenta que as ferramentas padrão e, em tamanhos maiores, mal conseguiu igualá-las. Essa descoberta é crucial porque mostra que simplesmente reescrever o código em uma linguagem mais rápida não torna tudo automaticamente mais rápido. As ferramentas padrão para ordenar números já são tão altamente otimizadas que um programa customizado tem dificuldade em superá-las. Os pesquisadores descobriram que a vantagem de velocidade depende inteiramente da matemática sendo realizada; para algumas tarefas, o novo motor é um salto enorme, enquanto para outras, não oferece benefício algum.

O estudo também enfatizou que a velocidade não pode vir à custa da segurança. O novo sistema foi projetado com uma abordagem de "falha fechada" (fail-closed), o que significa que, se as entradas forem bagunçadas, os números estiverem faltando ou a configuração for impossível, o sistema simplesmente se recusa a rodar em vez de produzir um resultado potencialmente perigoso. Ele verifica cenários impossíveis, como ter atacantes demais para o número de pessoas presentes, e os rejeita imediatamente. Também garante que nenhum número estranho ou indefinido escape pelas frestas para corromper o modelo final. Esse rigor garante que o sistema permaneça confiável, mesmo que signifique rejeitar uma solicitação que um sistema menos cuidadoso poderia ter tentado processar.

Em última análise, este trabalho demonstra que construir um sistema de inteligência artificial confiável requer um equilíbrio cuidadoso entre segurança e desempenho. Os pesquisadores mostraram que é possível criar uma defesa robusta contra atores maliciosos que seja tanto matematicamente sólida quanto computacionalmente eficiente, mas apenas se o design for adaptado à estratégia específica utilizada. O estudo conclui que não existe uma solução única "rápida" para todos os problemas de segurança. Em vez disso, os engenheiros devem escolher a ferramenta certa para o trabalho, entendendo que algumas regras de segurança rodarão muito mais rápido do que outras, dependendo do tamanho dos dados e da natureza do cálculo. Ao combinar verificações de segurança rigorosas com computação de alto desempenho, é possível construir sistemas de aprendizado federado que não são apenas inteligentes, mas também resilientes o suficiente para serem confiáveis no mundo real.