← Índice de Demos
FHE em Ação · Federated Learning
Demo 05 · Treino Multicêntrico Sob Cifra
Demonstração Factual

Treino coletivo sem expor pacientes.

Quatro hospitais treinam um modelo de predição de sepse juntos — sem nenhum deles ver os dados dos outros, e sem o agregador ver gradientes individuais.

Cenário

4 hospitais querem treinar coletivamente um modelo de predição de sepse. Cada um tem 50 pacientes próprios. Quanto mais dado, melhor o modelo.

Por que FL puro não basta

Federated Learning resolve "dado fica local". Mas pesquisa mostra que gradientes vazam dado: é possível reconstruir o paciente a partir do gradiente.

FL + FHE

Gradientes são cifrados antes de sair. Agregador soma sob cifra. Apenas a soma é decifrada. Reconstrução individual fica matematicamente impossível.

Passo 01 · Setup

Definir os parâmetros.

Antes do treino federado, escolhemos os parâmetros CKKS. Para gradientes em ML, CKKS é o esquema natural.

Capacidade · CKKS

8 192Slots/ciphertext
2Profundidade
APROX.Tipo de esquema
~128 bitSegurança

O que cada termo significa

CKKS (esquema "aproximado") — Família FHE para números reais. Ruído de aproximação controlado (erro ~10⁻¹¹ aqui). Esquema padrão para ML federado — gradientes são vetores de reais.

8 192 slots — Cada ciphertext é um vetor de 8 192 valores. Um único ciphertext carrega o vetor de gradientes de um hospital inteiro. 4 hospitais = 4 ciphertexts somados.

Profundidade multiplicativa 2 — Quantas multiplicações encadeadas. Para agregação federada (somar + dividir por N), profundidade 2 é confortável.

~128 bits de segurança — Padrão da indústria. Quebrar a chave exige ~2128 operações. Inviável.

Base RLWE — Ring Learning With Errors. O mesmo problema do ML-KEM/ML-DSA padronizados pelo NIST como criptografia pós-quântica.

Passo 02 · Chaves

Chave colaborativa.

Em produção real, a chave de decifração é dividida entre os 4 hospitais via threshold cryptography. Nenhum hospital sozinho pode decifrar nem o gradiente médio — só com quórum.

Quem detém os shares

Albert Einstein — share 1/4

Sírio-Libanês — share 2/4

HCor — share 3/4

Oswaldo Cruz — share 4/4

Quórum exigido: 4 de 4. Sem cooperação dos quatro, nem o gradiente médio é revelado.

Por que threshold neste caso

Sem operador central confiável — Em ML federado tradicional, geralmente há um "agregador confiável" que centraliza tudo. Isso é frágil: o agregador pode ser invadido, comprometido, ou simplesmente desonesto. Threshold elimina o operador único de confiança.

Cada hospital é par — Os 4 hospitais são instituições pares, não há hierarquia entre eles. Threshold encaixa naturalmente em colaborações horizontais entre instituições do mesmo nível.

Auditoria distribuída — Cada decifração registra log auditável das 4 partes. Nenhum hospital pode "rodar análises secretas" sobre os dados dos outros.

Passo 03 · Treino local

Cada hospital treina localmente.

Cada hospital roda um passo de gradiente descendente sobre seus 50 pacientes próprios. Os dados nunca saem do hospital. O resultado do treino é apenas um vetor de 4 números: o gradiente.

O que cada hospital faz

// Para cada paciente local:
for paciente in pacientes_locais {
  // frequência cardíaca, pressão, lactato
  features := paciente.X
  y_real := paciente.sepse

  // predição linear com pesos atuais
  y_pred := dot(w, features) + bias
  erro := y_pred - y_real

  // acumula gradiente
  grad += erro * features / N
}

// Resultado: vetor de 4 números

O que está acontecendo

Predição de sepse — Modelo linear simples (regressão sobre 3 features clínicas: frequência cardíaca, pressão arterial, nível de lactato). Sepse é uma das doenças onde detecção precoce salva vidas mensuráveis.

Treino local = dado local — O hospital itera sobre seus pacientes dentro do seu próprio sistema. Cada cálculo de erro acontece em servidor próprio. Os pacientes nunca saem do hospital, em momento algum.

Gradiente = 4 números — O resultado de todo o treino é um vetor minúsculo de 4 valores reais: a "direção" em que os pesos do modelo devem se mover. É essa derivada que sai do hospital.

Mas aqui está o catch — Em FL puro, esse vetor de 4 números é enviado em claro. Pesquisa mostrou (gradient leakage attacks) que é possível reverter o gradiente para reconstruir parte do dataset. Por isso precisamos cifrar antes de enviar.

Passo 04 · Cifragem

Gradiente cifrado antes de sair.

Cada hospital cifra seu vetor de 4 gradientes com a chave pública do consórcio antes que qualquer byte saia. Apenas ciphertext atravessa a internet.

O que cada hospital envia

// gradiente local em claro:
grad := [0.0234, -0.0117,
          0.0089, -0.0042]

// cifragem (no servidor do hospital)
pt := encoder.Encode(grad)
ct := encryptor.Encrypt(pt)

// envia APENAS ct
send(ct) // 768 KB
3.7 msPor hospital
768 KBCiphertext

Por que cifrar 4 números?

Gradient leakage attacks — Pesquisa de IBM, Google e academia já demonstrou: a partir de gradientes em claro é possível recuperar parcialmente os dados de treino que os geraram. Para 50 pacientes com 3 features cada, em alguns casos é possível recuperar pacientes individuais com qualidade alarmante.

Por isso FHE — Cifrar os 4 números antes de enviar é o que torna FL realmente federado. Sem FHE, FL é uma promessa marketing — o dado vaza pelos gradientes. Com FHE, a promessa vira teorema.

Overhead aceitável — 4 floats em claro = 32 bytes. Cifrados = 768 KB. Overhead massivo, mas: (1) executado uma única vez por rodada de treino, (2) cifragem leva poucos milissegundos, (3) a alternativa (FL puro) não é defensável.

Mesma chave pública — Os 4 hospitais cifram com a MESMA chave pública (gerada via threshold no passo 2). Isso é o que permite ao agregador somar os ciphertexts no próximo passo.

Passo 05 · Agregação

Soma dos gradientes sob cifra.

O agregador recebe os 4 ciphertexts e os soma usando a propriedade homomórfica do CKKS. Multiplica por 1/4 para a média. Tudo cifrado, em 1 ms. O agregador nunca vê nenhum gradiente individual.

O algoritmo

// 1. soma os 4 ciphertexts
ctSum := evaluator.Add(cts[0], cts[1])
for i := 2; i < N; i++ {
  evaluator.Add(ctSum, cts[i])
}

// 2. multiplica por 1/N (média)
evaluator.Mul(ctSum, 0.25)
evaluator.Rescale(ctSum)

// → ctSum agora codifica:
// (grad₁+grad₂+grad₃+grad₄) / 4
1 msTempo total

O que o agregador sabe

Sabe que somou 4 coisas — Tem registro de que recebeu e processou 4 ciphertexts. Sabe a hora, o tamanho, o ID dos hospitais participantes.

NÃO sabe o que somou — Não tem ideia dos valores dos gradientes individuais. Não sabe nem se o gradiente do Einstein foi positivo ou negativo. Não sabe nem o sinal.

Não sabe nem o resultado — Mesmo o gradiente médio cifrado é opaco para o agregador. Ele só pode devolver o ciphertext aos hospitais. Apenas eles, com os shares de chave, podem decifrar.

1 ms para 4 hospitais — Velocidade real medida. Em produção com dezenas de hospitais e milhares de parâmetros (modelos maiores), o tempo escala linearmente: ~10 ms para 100 partes.

Passo 06 · Decifração

Modelo coletivo atualizado.

Os 4 hospitais cooperam (quórum 4-de-4) para decifrar APENAS o gradiente médio. Os 4 gradientes individuais permanecem matematicamente inacessíveis. Aplicam o gradiente médio aos pesos para atualizar o modelo.

Aplicação do gradiente

// gradiente médio decifrado:
grad_médio := [0.0156, -0.0089,
                0.0067, -0.0028]

// SGD: w ← w − lr · grad
lr := 0.5
for i := range w {
  w[i] -= lr * grad_médio[i]
}

// → modelo atualizado coletivo
// próxima rodada começa

O que esta rodada produziu

Modelo agora é coletivo — Os pesos atualizados refletem o aprendizado dos 4 hospitais juntos. Cada um se beneficia do conhecimento dos outros, sem ter visto dado de nenhum.

Próxima rodada — Em produção real, este ciclo se repete dezenas a centenas de vezes até o modelo convergir. Cada rodada continua sob cifra. Cada rodada melhora o modelo.

Modelo é público — Os pesos atualizados são compartilhados entre os 4 hospitais. Quem tiver acesso ao modelo pode usar para predizer sepse. Mas o modelo não revela nenhum paciente individual — apenas o aprendizado agregado.

O ganho científico — Modelo coletivo treinado em 200 pacientes (4×50) é matematicamente melhor que qualquer modelo treinado isoladamente em 50.

Passo 07 · Validação

Comparação matemática.

Para provar que a agregação cifrada produziu o mesmo gradiente médio que uma agregação plaintext tradicional, comparamos lado a lado.

FHE vs Plaintext

8 × 10⁻¹¹Erro máximo

Comparação entre o gradiente médio decifrado pelo FHE e o gradiente médio calculado em claro sobre os mesmos 4 vetores. Diferença na 11ª casa decimal.

Por que essa precisão basta

11 casas decimais — Para comparação: gradientes em ML têm magnitude tipicamente entre 10⁻³ e 10⁻¹. Erro de 10⁻¹¹ é 8 ordens de magnitude menor que o sinal. Negligível.

Convergência preservada — O modelo treinado com agregação FHE converge para os mesmos pesos finais que o modelo treinado com agregação plaintext. A precisão CKKS é mais que suficiente para SGD.

CKKS é o esquema certo — Para BGV (esquema exato) seria necessário codificar gradientes como inteiros — possível mas inconveniente. CKKS opera nativamente em reais com precisão controlada.

Passo 08 · Adversarial

FL puro vs FL + FHE.

A diferença entre FL tradicional e FL+FHE não é cosmética. É a diferença entre uma promessa marketing frágil e uma garantia matemática verificável.

FL puro (sem FHE)O agregador vê gradientes individuais em claro. Pesquisa de IBM, Google e academia demonstrou (Deep Leakage from Gradients, NeurIPS 2019; Inverting Gradients, ICLR 2020): a partir do gradiente é POSSÍVEL reconstruir parte do dataset que o gerou. Para datasets pequenos como 50 pacientes, a reconstrução pode chegar a níveis alarmantes — o agregador efetivamente "vê" pacientes que nunca deveria ver.

Por isso FL puro é inadequado para dado clínico. A "promessa de privacidade" é frágil porque o vazamento acontece pelo próprio produto que FL deveria proteger.

FL + FHE (esta demo)O agregador nunca vê gradiente individual. Apenas a soma agregada — e ainda assim cifrada. A reconstrução do dataset original a partir de gradientes individuais fica matematicamente impossível porque os gradientes individuais NUNCA EXISTEM em claro fora do hospital de origem.

É a única arquitetura defensável. Para qualquer aplicação de ML federado em dado clínico (sepse, oncologia, imagem médica), FL+FHE é o padrão técnico que regulação séria vai exigir.

Passo 09 · Síntese

ML federado defensável.

Em poucos milissegundos, 4 hospitais treinaram coletivamente um modelo de predição de sepse — sem nenhum deles ver dado de outro, e sem o agregador ver gradientes individuais.

O fluxo completo

  1. Definimos parâmetros CKKS para vetores de gradientes
  2. Chave dividida entre 4 hospitais via threshold
  3. Cada hospital treinou localmente sobre seus 50 pacientes
  4. Cifrou gradiente local antes de enviar (3.7 ms)
  5. Agregador somou os 4 ciphertexts sob cifra (1 ms)
  6. Hospitais decifraram coletivamente o gradiente médio
  7. Modelo atualizado reflete conhecimento coletivo dos 200 pacientes

Números reais

3.7 msCifragem por hospital
1 msAgregação cifrada
768 KBPor ciphertext
10⁻¹¹Erro precisão
3 eBooks usam esta primitivaFHE_FARMACEUTICA_EBOOK (RWE multicêntrico) · FHE_HOSPITAIS_EBOOK (modelos preditivos sobre coorte multi-hospital) · FHE_BANCOS_EBOOK (scoring colaborativo entre instituições).
A tese centralFL é uma promessa de privacidade frágil — gradientes vazam dado. FL+FHE transforma promessa em teorema. Para qualquer ML federado sobre dado clínico, financeiro ou de cidadão, FL+FHE é o padrão técnico que regulação séria vai exigir nos próximos 5 anos.