Contexto Delimitado: Aprendizado Federado (paebiru-learn)

Este contexto implementa o Refinamento Coletivo: treinamento distribuído hardware-aware onde dados permanecem soberanos nos nós. Os deltas de peso são comprimidos em função do stress físico real do nó, agregados via FedAvg com assinatura threshold FROST, e protegidos por mecanismos de privacidade diferencial e imunologia cognitiva.

classDiagram
    direction TB

    class FedAvgAggregator {
        <<FedAvg>>
        - round_id: u64
        - min_participants: u32
        - global_model: ModelWeights
        + announce_round() RoundAnnouncement
        + collect_delta(WeightDelta)
        + aggregate() GlobalModelUpdate
        + sign_update(FrostGroup) FrostThresholdSig
    }

    class WeightDelta {
        <<Compressed_Gradient>>
        - node_id: NodeId
        - delta: Vec~f32~
        - pruning_mask: BitVec
        - quantized: bool
        - data_size: u64
        - sig: FrostPartialSig
    }

    class HardwareAwareCompressor {
        <<Sec4>>
        - pruning_scale: f32
        - max_pruning_ratio: f32
        + prune(delta, pain) WeightDelta
        + quantize_int8(delta, pain) WeightDelta
        + pruning_ratio(pain) f32
    }

    class LangevinSGD {
        <<Stochastic_Optimizer>>
        - eta: f32
        - entropy: EntropySource
        + step(weights, grad, thermal_state)
        + box_muller_noise(dim) Vec~f32~
    }

    class LearnerAgent {
        <<Biology_Bus>>
        - model_cache: ModelWeights
        - local_dataset: DatasetRef
        - compressor: HardwareAwareCompressor
        - optimizer: LangevinSGD
        + on_learning_trigger(RoundAnnouncement)
        + train_local(epochs) WeightDelta
        + submit_delta(delta) RoundResult
        + on_stress_high()
    }

    class RoundAnnouncement {
        - round_id: u64
        - model_hash: [u8 32]
        - min_participants: u32
        - deadline: u64
        - task_description: String
    }

    class GlobalModelUpdate {
        - round_id: u64
        - model_hash: [u8 32]
        - signature: FrostThresholdSig
        - participant_ids: Vec~NodeId~
    }

    class ModelWeights {
        <<candle_core_Tensor>>
        + load(path) ModelWeights
        + apply_delta(WeightDelta)
        + cosine_similarity(other) f32
    }

    FedAvgAggregator *-- GlobalModelUpdate
    FedAvgAggregator ..> WeightDelta : collects
    FedAvgAggregator ..> ModelWeights : updates
    LearnerAgent *-- HardwareAwareCompressor
    LearnerAgent *-- LangevinSGD
    LearnerAgent ..> FedAvgAggregator : submits delta
    LearnerAgent ..> ModelWeights : trains locally
    HardwareAwareCompressor ..> WeightDelta : produces
    LangevinSGD ..> EntropySource : noise samples
    LangevinSGD ..> ThermalState : temperature

Mapeamento de Diretórios:

• crates/learn/ — crate independente; backend tensorial candle-core
• crates/learn/src/fedavg.rs — FedAvgAggregator, RoundAnnouncement, GlobalModelUpdate, WeightDelta
• crates/learn/src/hw_aware.rs — HardwareAwareCompressor: pruning + quantização int8
• crates/learn/src/sgd_thermal.rs — LangevinSGD: thermal_step via Box–Muller sobre EntropySource
• crates/biology/src/domain/agent/learner.rs — LearnerAgent: ponte entre bus de feromônios e paebiru-learn

Ciclo de uma Rodada FL

O aprendizado no PAEBIRU não é centralizado; ele emerge como uma Episteme Distribuída.

sequenceDiagram
    participant Agg as Ancião (Aggregator)
    participant Bus as Biology Bus
    participant Agent as Agente ABAPORU (Learner)
    participant Comp as HardwareAwareCompressor
    participant Opt as LangevinSGD
    participant FL as FedAvgAggregator

    Agg->>Bus: LEARNING_TRIGGER (RoundAnnouncement)
    Bus->>Agent: on_learning_trigger()
    Note over Agent: Digestão local de dados
    Agent->>Agent: train_local(E epochs, LangevinSGD)
    Agent->>Comp: prune(delta, pain_level)
    Comp-->>Agent: WeightDelta (pruned + quant)
    Agent->>FL: submit_delta(delta, frost_sig)
    FL->>FL: aggregate (FedAvg weighted by n_i/N)
    FL->>Agg: GlobalModelUpdate (frost_threshold_sig)
    Agg->>Bus: MODEL_UPDATED
    Bus->>Agent: refresh model_cache

1. Anúncio (Trigger): Um “Ancião” do cluster (nó com autoridade de coordenação) emite um feromônio LEARNING_TRIGGER.
2. Trabalho Local: Os Agentes ABAPORU treinam o modelo global sobre seus dados locais soberanos. A “digestão” ocorre na Macrophage VM ou via candle-core.
3. Proteção de Privacidade (DP-SGD): Antes de enviar, o Agente aplica Privacidade Diferencial: o delta é clipado (L2-Clipping) e perturbado com ruído gaussiano (Langevin).
4. Agregação Soberana: Os deltas são coletados e agregados via FedAvg, validados por assinaturas de threshold (FROST). O resultado é o novo estado do cérebro coletivo.

Compressão Hardware-Aware

O HardwareAwareCompressor consulta o AlgedonicSensor antes de cada submissão:

Nós com pain > 0.95 são excluídos da rodada para não degradar o agregado global abaixo do threshold de utilidade.

Langevin SGD

A T=0 (nó saudável), LangevinSGD é SGD puro. A T>0 (pain > 0), o ruído Langevin permite escapar de mínimos locais em dados não-i.i.d., melhorando a qualidade dos deltas em clusters heterogêneos. Cada step registra 32 * d bit-erasures no LandauerLedger, mantendo contabilidade termodinâmica do custo de treinamento.

Imunologia Cognitiva: Resiliência Bizantina

O sistema imunológico do PAEBIRU protege a inteligência coletiva contra envenenamento de modelo (Model Poisoning):

• Krum: Seleciona o delta mais representativo para evitar outliers.
• Trimmed Mean / Median: Descarta os valores extremos de cada dimensão do gradiente.
• FoolsGold: Detecta e mitiga ataques de Sybil baseados em similaridade anômala.

In-Network Learning

Enquanto a v1 foca em FedAvg, a visão para a v2+ do PAEBIRU evolui para uma topologia puramente in-transit (In-Network Learning Puro). A inteligência refina seus pesos dinamicamente durante os saltos de roteamento estigmergico, eliminando a necessidade de nós agregadores centrais.

• Stochastic Gradient Langevin Dynamics (SGLD): A atualização de pesos incorpora a temperatura da rede ($T$) e ruído estocástico ($\xi_t$) para evitar mínimos locais e viés local: $$ \Delta w_t = -\frac{\eta}{2} \nabla L(w_t) + \sqrt{\eta T} \xi_t $$
• Feromônios de Gradiente: Os traços de gradiente são depositados como “gotas” matemáticas no C.A.P.I.B.A. Storage durante o roteamento.
• Imunologia Cognitiva: O sistema utiliza esses feromônios para validar atualizações subsequentes. Se um gradiente divergir drasticamente do histórico (sinalizando envenenamento de dados), ele é rejeitado pelo nó, atuando como um filtro de correlação de enxame.
• Split-DNN: Habilita o particionamento de redes neurais (Edge Head / Fusion Trunk) para otimizar a banda em silício frágil.

Detalhes complementares (crates/learn/)

• Quantização adaptativa em três níveis: F32 → F16 → I8. A escolha é função monotônica de pain: F32 em saudável, F16 em estresse moderado (>0.3), I8 em crise (>0.6).
• Backend tensorial: candle-core (CPU default). PAEBIRU_CANDLE_BACKEND=cuda ativa GPU.
• Privacidade diferencial DAO-governada — epsilon, delta_dp, sigma_max são parâmetros de DAO; não código.

Relacionamento com RFC 010 (Compute-over-Data)

O paebiru-learn utiliza a infraestrutura de Compute-over-Data como seu motor de execução primário. As rodadas de treinamento são despachadas como ComputeJobs, onde o trabalho de gradiente é realizado no local onde os dados residem, minimizando o transporte de informação sensível e otimizando o uso de Joules na malha.

Cross-references

• BIOLOGY.md — LearnerAgent (ponte algedônico↔FL).
• KERNEL.md — Compute-over-Data e Macrophage VM.
• ENTROPY.md — LangevinSGD ⇄ ThermalState; LandauerLedger registra bit-erasures de cada step.
• ECONOMY.md — Dao governa parâmetros de privacidade e habilitação de agregadores byzantinos.