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.
Definir os parâmetros.
Antes do treino federado, escolhemos os parâmetros CKKS. Para gradientes em ML, CKKS é o esquema natural.
Capacidade · CKKS
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.
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.
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
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.
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
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
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.
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
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
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.
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
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.
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
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.
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.
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.
É 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.
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
- Definimos parâmetros CKKS para vetores de gradientes
- Chave dividida entre 4 hospitais via threshold
- Cada hospital treinou localmente sobre seus 50 pacientes
- Cifrou gradiente local antes de enviar (3.7 ms)
- Agregador somou os 4 ciphertexts sob cifra (1 ms)
- Hospitais decifraram coletivamente o gradiente médio
- Modelo atualizado reflete conhecimento coletivo dos 200 pacientes