Struct DistributedGradientAccumulator 

pub struct DistributedGradientAccumulator {
    pub local_gradient: Vec<f32>,
    pub peer_gradients: HashMap<String, Vec<f32>>,
    /* private fields */
}

Accumulates gradients from distributed peers via content-addressed storage.

Workflow:

1. Call commit_local to serialize and store the local gradient, obtaining a Cid that can be broadcast to peers.
2. Call add_peer_gradient for each CID received from a peer. The accumulator fetches the raw bytes from the BlockStore, decodes them via Arrow IPC, and caches the result.
3. Once is_ready returns true, call aggregate to run FedAvg over all collected gradients (local + peers).

Fields

local_gradient: Vec<f32>

The local node’s gradient, set by commit_local.

peer_gradients: HashMap<String, Vec<f32>>

Gradients received from peers, keyed by peer ID.

Implementations

impl DistributedGradientAccumulator

pub fn new(session_id: &str, config: BackwardPassConfig) -> Self

Create a new accumulator for the given session.

pub async fn commit_local( &mut self, grad: Vec<f32>, store: &dyn BlockStore, ) -> Result<Cid>

Store the local gradient as Arrow IPC bytes in store, returning its CID.

The CID is computed as a raw-block CID (SHA-256) over the Arrow IPC bytes.

pub async fn add_peer_gradient( &mut self, peer_id: &str, cid: &Cid, store: &dyn BlockStore, ) -> Result<()>

Fetch and decode a peer’s gradient from store using its CID.

pub fn aggregate(&self) -> Result<Vec<f32>, GradientError>

Aggregate all collected gradients using the configured AggregationMethod.

Includes the local gradient plus all peer gradients collected so far. The aggregation strategy is taken from BackwardPassConfig::aggregation.

pub fn is_ready(&self, min_peers: usize) -> bool

Returns true when at least min_peers peer gradients have been collected.

pub fn session_id(&self) -> &str

The session identifier passed at construction time.

pub fn peer_count(&self) -> usize

Number of peer gradients collected so far (not counting local).