@epfml/discojs 2.2.2-p20240703101552.0 → 3.0.0

package/dist/aggregator/base.d.ts

@@ -1,5 +1,6 @@
 import { Map, Set } from 'immutable';
-import type { client, Model, AsyncInformant } from '../index.js';
+import type { client } from '../index.js';
+import { EventEmitter } from '../utils/event_emitter.js';
 export declare enum AggregationStep {
     ADD = 0,
     UPDATE = 1,
@@ -8,12 +9,13 @@ export declare enum AggregationStep {
 /**
  * Main, abstract, aggregator class whose role is to buffer contributions and to produce
  * a result based off their aggregation, whenever some defined condition is met.
+ *
+ * Emits an event whenever an aggregation step is performed.
+ * Users wait for this event to fetch the aggregation result.
  */
-export declare abstract class Base<T> {
-    /**
-     * The Model whose weights are updated on aggregation.
-     */
-    protected _model?: Model | undefined;
+export declare abstract class Base<T> extends EventEmitter<{
+    'aggregation': T;
+}> {
     /**
      * The round cut-off for contributions.
      */
@@ -33,19 +35,6 @@ export declare abstract class Base<T> {
      * of all active nodes, depending on the aggregation scheme.
      */
     protected contributions: Map<number, Map<client.NodeID, T>>;
-    /**
-     * Emits the aggregation event whenever an aggregation step is performed.
-     * Triggers the resolve of the result promise and the preparation for the
-     * next aggregation round.
-     */
-    private readonly eventEmitter;
-    protected informant?: AsyncInformant<T>;
-    /**
-     * The result promise which, on resolve, will contain the current aggregation result.
-     * This promise should be fetched by any object making use of an aggregator, in order
-     * to await upon aggregation.
-     */
-    protected result: Promise<T>;
     /**
      * The current aggregation round, used for assessing whether a node contribution is recent enough
      * or not.
@@ -59,10 +48,6 @@ export declare abstract class Base<T> {
      */
     protected _communicationRound: number;
     constructor(
-    /**
-     * The Model whose weights are updated on aggregation.
-     */
-    _model?: Model | undefined, 
     /**
      * The round cut-off for contributions.
      */
@@ -85,7 +70,6 @@ export declare abstract class Base<T> {
      * Must store the aggregation's result in the aggregator's result promise.
      */
     abstract aggregate(): void;
-    registerObserver(informant: AsyncInformant<T>): void;
     /**
      * Returns whether the given round is recent enough, dependent on the
      * aggregator's round cutoff.
@@ -99,16 +83,12 @@ export declare abstract class Base<T> {
      * @param from The node which triggered the logging message
      */
     log(step: AggregationStep, from?: client.NodeID): void;
-    /**
-     * Sets the aggregator's TF.js model.
-     * @param model The new TF.js model
-     */
-    setModel(model: Model): void;
     /**
      * Adds a node's id to the set of active nodes. A node represents an active neighbor
      * peer/client within the network, whom we are communicating with during this aggregation
      * round.
      * @param nodeId The node to be added
+     * @returns True is the node wasn't already in the list of nodes, False if already included
      */
     registerNode(nodeId: client.NodeID): boolean;
     /**
@@ -129,27 +109,12 @@ export declare abstract class Base<T> {
      * @param round The new round
      */
     setRound(round: number): void;
-    /**
-     * Emits the event containing the aggregation result, which allows the result
-     * promise to resolve and for the next aggregation round to take place.
-     * @param aggregated The aggregation result
-     */
-    protected emit(aggregated: T): void;
     /**
      * Updates the aggregator's state to proceed to the next communication round.
      * If all communication rounds were performed, proceeds to the next aggregation round
      * and empties the collection of stored contributions.
      */
     nextRound(): void;
-    private makeResult;
-    /**
-     * Aggregation steps are performed asynchronously, yet can be awaited upon when required.
-     * This function gives access to the current aggregation result's promise, which will
-     * eventually resolve and contain the result of the very next aggregation step, at the
-     * time of the function call.
-     * @returns The promise containing the aggregation result
-     */
-    receiveResult(): Promise<T>;
     /**
      * Constructs the payloads sent to other nodes as contribution.
      * @param base Object from which the payload is computed
@@ -169,10 +134,6 @@ export declare abstract class Base<T> {
      * the amount of all active nodes times the number of communication rounds.
      */
     get size(): number;
-    /**
-     * The aggregator's current model.
-     */
-    get model(): Model | undefined;
     /**
      * The current communication round.
      */

package/dist/aggregator/base.js

@@ -9,9 +9,11 @@ export var AggregationStep;
 /**
  * Main, abstract, aggregator class whose role is to buffer contributions and to produce
  * a result based off their aggregation, whenever some defined condition is met.
+ *
+ * Emits an event whenever an aggregation step is performed.
+ * Users wait for this event to fetch the aggregation result.
  */
-export class Base {
-    _model;
+export class Base extends EventEmitter {
     roundCutoff;
     communicationRounds;
     /**
@@ -26,19 +28,6 @@ export class Base {
      */
     // communication round -> NodeID -> T
     contributions;
-    /**
-     * Emits the aggregation event whenever an aggregation step is performed.
-     * Triggers the resolve of the result promise and the preparation for the
-     * next aggregation round.
-     */
-    eventEmitter = new EventEmitter();
-    informant;
-    /**
-     * The result promise which, on resolve, will contain the current aggregation result.
-     * This promise should be fetched by any object making use of an aggregator, in order
-     * to await upon aggregation.
-     */
-    result;
     /**
      * The current aggregation round, used for assessing whether a node contribution is recent enough
      * or not.
@@ -52,10 +41,6 @@ export class Base {
      */
     _communicationRound = 0;
     constructor(
-    /**
-     * The Model whose weights are updated on aggregation.
-     */
-    _model, 
     /**
      * The round cut-off for contributions.
      */
@@ -64,21 +49,14 @@ export class Base {
      * The number of communication rounds occurring during any given aggregation round.
      */
     communicationRounds = 1) {
-        this._model = _model;
+        super();
         this.roundCutoff = roundCutoff;
         this.communicationRounds = communicationRounds;
         this.contributions = Map();
         this._nodes = Set();
-        // Make the initial result promise
-        this.result = this.makeResult();
         // On every aggregation, update the object's state to match the current aggregation
         // and communication rounds.
-        this.eventEmitter.on('aggregation', () => {
-            this.nextRound();
-        });
-    }
-    registerObserver(informant) {
-        this.informant = informant;
+        this.on('aggregation', () => this.nextRound());
     }
     /**
      * Returns whether the given round is recent enough, dependent on the
@@ -97,7 +75,7 @@ export class Base {
     log(step, from) {
         switch (step) {
             case AggregationStep.ADD:
-                console.log(`> Adding contribution from node ${from ?? '"unknown"'} for round (${this.communicationRound}, ${this.round})`);
+                console.log(`Adding contribution from node ${from ?? '"unknown"'} for round (${this.communicationRound}, ${this.round})`);
                 break;
             case AggregationStep.UPDATE:
                 if (from === undefined) {
@@ -115,18 +93,12 @@ export class Base {
             }
         }
     }
-    /**
-     * Sets the aggregator's TF.js model.
-     * @param model The new TF.js model
-     */
-    setModel(model) {
-        this._model = model;
-    }
     /**
      * Adds a node's id to the set of active nodes. A node represents an active neighbor
      * peer/client within the network, whom we are communicating with during this aggregation
      * round.
      * @param nodeId The node to be added
+     * @returns True is the node wasn't already in the list of nodes, False if already included
      */
     registerNode(nodeId) {
         if (!this.nodes.has(nodeId)) {
@@ -161,14 +133,6 @@ export class Base {
             this._round = round;
         }
     }
-    /**
-     * Emits the event containing the aggregation result, which allows the result
-     * promise to resolve and for the next aggregation round to take place.
-     * @param aggregated The aggregation result
-     */
-    emit(aggregated) {
-        this.eventEmitter.emit('aggregation', aggregated);
-    }
     /**
      * Updates the aggregator's state to proceed to the next communication round.
      * If all communication rounds were performed, proceeds to the next aggregation round
@@ -180,25 +144,6 @@ export class Base {
             this._round++;
             this.contributions = Map();
         }
-        this.result = this.makeResult();
-        this.informant?.update();
-    }
-    async makeResult() {
-        return await new Promise((resolve) => {
-            this.eventEmitter.once('aggregation', (w) => {
-                resolve(w);
-            });
-        });
-    }
-    /**
-     * Aggregation steps are performed asynchronously, yet can be awaited upon when required.
-     * This function gives access to the current aggregation result's promise, which will
-     * eventually resolve and contain the result of the very next aggregation step, at the
-     * time of the function call.
-     * @returns The promise containing the aggregation result
-     */
-    async receiveResult() {
-        return await this.result;
     }
     /**
      * The set of node ids, representing our neighbors within the network.
@@ -222,12 +167,6 @@ export class Base {
             .map((m) => m.size)
             .reduce((totalSize, size) => totalSize + size) ?? 0;
     }
-    /**
-     * The aggregator's current model.
-     */
-    get model() {
-        return this._model;
-    }
     /**
      * The current communication round.
      */

package/dist/aggregator/get.d.ts

@@ -1,16 +1,28 @@
 import type { Task } from '../index.js';
 import { aggregator } from '../index.js';
+type AggregatorOptions = Partial<{
+    scheme: Task['trainingInformation']['scheme'];
+    roundCutOff: number;
+    threshold: number;
+    thresholdType: 'relative' | 'absolute';
+}>;
 /**
- * Enumeration of the available types of aggregator.
- */
-export declare enum AggregatorChoice {
-    MEAN = 0,
-    SECURE = 1,
-    BANDIT = 2
-}
-/**
- * Provides the aggregator object adequate to the given task.
- * @param task The task
+ * Initializes an aggregator according to the task definition, the training scheme and the aggregator parameters.
+ * Here is the ordered list of parameters used to define the aggregator and its default behavior:
+ * task.trainingInformation.aggregator > options.scheme > task.trainingInformation.scheme
+ *
+ * If `task.trainingInformation.aggregator` is defined, we initialize the chosen aggregator with `options` parameter values.
+ * Otherwise, we default to a MeanAggregator for both training schemes.
+ *
+ * For the MeanAggregator we rely on `options.scheme` and fallback on `task.trainingInformation.scheme` to infer default values.
+ * Unless specified otherwise, for federated learning or local training the aggregator default to waiting
+ * for a single contribution to trigger a model update.
+ * (the server's model update for federated learning or our own contribution if training locally)
+ * For decentralized learning the aggregator defaults to waiting for every nodes' contribution to trigger a model update.
+ *
+ * @param task The task object associated with the current training session
+ * @param options Options passed down to the aggregator's constructor
  * @returns The aggregator
  */
-export declare function getAggregator(task: Task): aggregator.Aggregator;
+export declare function getAggregator(task: Task, options?: AggregatorOptions): aggregator.Aggregator;
+export {};

package/dist/aggregator/get.js

@@ -1,31 +1,48 @@
 import { aggregator } from '../index.js';
 /**
- * Enumeration of the available types of aggregator.
- */
-export var AggregatorChoice;
-(function (AggregatorChoice) {
-    AggregatorChoice[AggregatorChoice["MEAN"] = 0] = "MEAN";
-    AggregatorChoice[AggregatorChoice["SECURE"] = 1] = "SECURE";
-    AggregatorChoice[AggregatorChoice["BANDIT"] = 2] = "BANDIT";
-})(AggregatorChoice || (AggregatorChoice = {}));
-/**
- * Provides the aggregator object adequate to the given task.
- * @param task The task
+ * Initializes an aggregator according to the task definition, the training scheme and the aggregator parameters.
+ * Here is the ordered list of parameters used to define the aggregator and its default behavior:
+ * task.trainingInformation.aggregator > options.scheme > task.trainingInformation.scheme
+ *
+ * If `task.trainingInformation.aggregator` is defined, we initialize the chosen aggregator with `options` parameter values.
+ * Otherwise, we default to a MeanAggregator for both training schemes.
+ *
+ * For the MeanAggregator we rely on `options.scheme` and fallback on `task.trainingInformation.scheme` to infer default values.
+ * Unless specified otherwise, for federated learning or local training the aggregator default to waiting
+ * for a single contribution to trigger a model update.
+ * (the server's model update for federated learning or our own contribution if training locally)
+ * For decentralized learning the aggregator defaults to waiting for every nodes' contribution to trigger a model update.
+ *
+ * @param task The task object associated with the current training session
+ * @param options Options passed down to the aggregator's constructor
  * @returns The aggregator
  */
-export function getAggregator(task) {
-    const error = new Error('not implemented');
-    switch (task.trainingInformation.aggregator) {
-        case AggregatorChoice.MEAN:
-            return new aggregator.MeanAggregator();
-        case AggregatorChoice.BANDIT:
-            throw error;
-        case AggregatorChoice.SECURE:
-            if (task.trainingInformation.scheme !== 'decentralized') {
+export function getAggregator(task, options = {}) {
+    const aggregatorType = task.trainingInformation.aggregator ?? 'mean';
+    const scheme = options.scheme ?? task.trainingInformation.scheme;
+    switch (aggregatorType) {
+        case 'mean':
+            if (scheme === 'decentralized') {
+                // If options are not specified, we default to expecting a contribution from all peers, so we set the threshold to 100%
+                options = {
+                    roundCutOff: undefined, threshold: 1, thresholdType: 'relative',
+                    ...options
+                };
+            }
+            else {
+                // If scheme == 'federated' then we only expect the server's contribution at each round 
+                // so we set the aggregation threshold to 1 contribution
+                // If scheme == 'local' then we only expect our own contribution
+                options = {
+                    roundCutOff: undefined, threshold: 1, thresholdType: 'absolute',
+                    ...options
+                };
+            }
+            return new aggregator.MeanAggregator(options.roundCutOff, options.threshold, options.thresholdType);
+        case 'secure':
+            if (scheme !== 'decentralized') {
                 throw new Error('secure aggregation is currently supported for decentralized only');
             }
-            return new aggregator.SecureAggregator();
-        default:
-            return new aggregator.MeanAggregator();
+            return new aggregator.SecureAggregator(task.trainingInformation.maxShareValue);
     }
 }

package/dist/aggregator/index.d.ts

@@ -3,5 +3,5 @@ import type { Base } from './base.js';
 export { Base as AggregatorBase, AggregationStep } from './base.js';
 export { MeanAggregator } from './mean.js';
 export { SecureAggregator } from './secure.js';
-export { getAggregator, AggregatorChoice } from './get.js';
+export { getAggregator } from './get.js';
 export type Aggregator = Base<WeightsContainer>;

package/dist/aggregator/index.js

@@ -1,4 +1,4 @@
 export { Base as AggregatorBase, AggregationStep } from './base.js';
 export { MeanAggregator } from './mean.js';
 export { SecureAggregator } from './secure.js';
-export { getAggregator, AggregatorChoice } from './get.js';
+export { getAggregator } from './get.js';

package/dist/aggregator/mean.d.ts

@@ -1,18 +1,37 @@
 import type { Map } from "immutable";
 import { Base as Aggregator } from "./base.js";
-import type { Model, WeightsContainer, client } from "../index.js";
-/** Mean aggregator whose aggregation step consists in computing the mean of the received weights. */
+import type { WeightsContainer, client } from "../index.js";
+type ThresholdType = 'relative' | 'absolute';
+/**
+ * Mean aggregator whose aggregation step consists in computing the mean of the received weights.
+ *
+ */
 export declare class MeanAggregator extends Aggregator<WeightsContainer> {
     #private;
     /**
-     * @param threshold - how many contributions for trigger an aggregation step.
-     *   - relative: 0 < t <= 1, thus requiring t * |nodes| contributions
-     *   - absolute: t > 1, thus requiring t contributions
+     * Create a mean aggregator that averages all weight updates received when a specified threshold is met.
+     * By default, initializes an aggregator that waits for 100% of the nodes' contributions and that
+     * only accepts contributions from the current round (drops contributions from previous rounds).
+     *
+     * @param threshold - how many contributions trigger an aggregation step.
+     * It can be relative (a proportion): 0 < t <= 1, requiring t * |nodes| contributions.
+     * Important: to specify 100% of the nodes, set `threshold = 1` and `thresholdType = 'relative'`.
+     * It can be an absolute number, if t >=1 (then t has to be an integer), the aggregator waits fot t contributions
+     * Note, to specify waiting for a single contribution (such as a federated client only waiting for the server weight update),
+     * set `threshold = 1` and `thresholdType = 'absolute'`
+     * @param thresholdType 'relative' or 'absolute', defaults to 'relative'. Is only used to clarify the case when threshold = 1,
+     * If `threshold != 1` then the specified thresholdType is ignored and overwritten
+     * If `thresholdType = 'absolute'` then `threshold = 1` means waiting for 1 contribution
+     * if `thresholdType = 'relative'` then `threshold = 1`` means 100% of this.nodes' contributions,
+     * @param roundCutoff - from how many past rounds do we still accept contributions.
+     * If 0 then only accept contributions from the current round,
+     * if 1 then the current round and the previous one, etc.
      */
-    constructor(model?: Model, roundCutoff?: number, threshold?: number);
+    constructor(roundCutoff?: number, threshold?: number, thresholdType?: ThresholdType);
     /** Checks whether the contributions buffer is full. */
     isFull(): boolean;
     add(nodeId: client.NodeID, contribution: WeightsContainer, round: number, currentContributions?: number): boolean;
     aggregate(): void;
     makePayloads(weights: WeightsContainer): Map<client.NodeID, WeightsContainer>;
 }
+export {};

package/dist/aggregator/mean.js

@@ -1,39 +1,86 @@
 import { AggregationStep, Base as Aggregator } from "./base.js";
 import { aggregation } from "../index.js";
-/** Mean aggregator whose aggregation step consists in computing the mean of the received weights. */
+/**
+ * Mean aggregator whose aggregation step consists in computing the mean of the received weights.
+ *
+ */
 export class MeanAggregator extends Aggregator {
     #threshold;
+    #thresholdType;
     /**
-     * @param threshold - how many contributions for trigger an aggregation step.
-     *   - relative: 0 < t <= 1, thus requiring t * |nodes| contributions
-     *   - absolute: t > 1, thus requiring t contributions
+     * Create a mean aggregator that averages all weight updates received when a specified threshold is met.
+     * By default, initializes an aggregator that waits for 100% of the nodes' contributions and that
+     * only accepts contributions from the current round (drops contributions from previous rounds).
+     *
+     * @param threshold - how many contributions trigger an aggregation step.
+     * It can be relative (a proportion): 0 < t <= 1, requiring t * |nodes| contributions.
+     * Important: to specify 100% of the nodes, set `threshold = 1` and `thresholdType = 'relative'`.
+     * It can be an absolute number, if t >=1 (then t has to be an integer), the aggregator waits fot t contributions
+     * Note, to specify waiting for a single contribution (such as a federated client only waiting for the server weight update),
+     * set `threshold = 1` and `thresholdType = 'absolute'`
+     * @param thresholdType 'relative' or 'absolute', defaults to 'relative'. Is only used to clarify the case when threshold = 1,
+     * If `threshold != 1` then the specified thresholdType is ignored and overwritten
+     * If `thresholdType = 'absolute'` then `threshold = 1` means waiting for 1 contribution
+     * if `thresholdType = 'relative'` then `threshold = 1`` means 100% of this.nodes' contributions,
+     * @param roundCutoff - from how many past rounds do we still accept contributions.
+     * If 0 then only accept contributions from the current round,
+     * if 1 then the current round and the previous one, etc.
      */
-    // TODO no way to require a single contribution
-    constructor(model, roundCutoff = 0, threshold = 1) {
+    constructor(roundCutoff = 0, threshold = 1, thresholdType) {
         if (threshold <= 0)
-            throw new Error("threshold must be striclty positive");
-        if (threshold > 1 && !Number.isInteger(threshold))
-            throw new Error("absolute thresholds must be integeral");
-        super(model, roundCutoff, 1);
+            throw new Error("threshold must be strictly positive");
+        if (threshold > 1 && (!Number.isInteger(threshold)))
+            throw new Error("absolute thresholds must be integral");
+        super(roundCutoff, 1);
         this.#threshold = threshold;
+        if (threshold < 1) {
+            // Throw exception if threshold and thresholdType are conflicting
+            if (thresholdType === 'absolute') {
+                throw new Error(`thresholdType has been set to 'absolute' but choosing threshold=${threshold} implies that thresholdType should be 'relative'.`);
+            }
+            this.#thresholdType = 'relative';
+        }
+        else if (threshold > 1) {
+            // Throw exception if threshold and thresholdType are conflicting
+            if (thresholdType === 'relative') {
+                throw new Error(`thresholdType has been set to 'relative' but choosing threshold=${threshold} implies that thresholdType should be 'absolute'.`);
+            }
+            this.#thresholdType = 'absolute';
+        }
+        // remaining case: threshold == 1
+        else {
+            // Print a warning regarding the default behavior when thresholdType is not specified
+            if (thresholdType === undefined) {
+                console.warn("[WARN] Setting the aggregator's threshold to 100% of the nodes' contributions by default. " +
+                    "To instead wait for a single contribution, set thresholdType = 'absolute'");
+                this.#thresholdType = 'relative';
+            }
+            else {
+                this.#thresholdType = thresholdType;
+            }
+        }
     }
     /** Checks whether the contributions buffer is full. */
     isFull() {
-        const actualThreshold = this.#threshold <= 1
+        const thresholdValue = this.#thresholdType == 'relative'
             ? this.#threshold * this.nodes.size
             : this.#threshold;
-        return (this.contributions.get(0)?.size ?? 0) >= actualThreshold;
+        return (this.contributions.get(0)?.size ?? 0) >= thresholdValue;
     }
     add(nodeId, contribution, round, currentContributions = 0) {
         if (currentContributions !== 0)
             throw new Error("only a single communication round");
-        if (!this.nodes.has(nodeId) || !this.isWithinRoundCutoff(round))
+        if (!this.nodes.has(nodeId) || !this.isWithinRoundCutoff(round)) {
+            if (!this.nodes.has(nodeId))
+                console.warn("Contribution rejected because node id is not registered");
+            if (!this.isWithinRoundCutoff(round))
+                console.warn(`Contribution rejected because round ${round} is not within round cutoff`);
             return false;
+        }
         this.log(this.contributions.hasIn([0, nodeId])
             ? AggregationStep.UPDATE
             : AggregationStep.ADD, nodeId);
         this.contributions = this.contributions.setIn([0, nodeId], contribution);
-        this.informant?.update();
         if (this.isFull())
             this.aggregate();
         return true;
@@ -44,9 +91,7 @@ export class MeanAggregator extends Aggregator {
             throw new Error("aggregating without any contribution");
         this.log(AggregationStep.AGGREGATE);
         const result = aggregation.avg(currentContributions.values());
-        if (this.model !== undefined)
-            this.model.weights = result;
-        this.emit(result);
+        this.emit('aggregation', result);
     }
     makePayloads(weights) {
         // Communicate our local weights to every other node, be it a peer or a server

package/dist/aggregator/secure.d.ts

@@ -1,6 +1,6 @@
 import { Map, List } from "immutable";
 import { Base as Aggregator } from "./base.js";
-import type { Model, WeightsContainer, client } from "../index.js";
+import type { WeightsContainer, client } from "../index.js";
 /**
  * Aggregator implementing secure multi-party computation for decentralized learning.
  * An aggregation consists of two communication rounds:
@@ -10,7 +10,7 @@ import type { Model, WeightsContainer, client } from "../index.js";
  */
 export declare class SecureAggregator extends Aggregator<WeightsContainer> {
     private readonly maxShareValue;
-    constructor(model?: Model, maxShareValue?: number);
+    constructor(maxShareValue?: number);
     aggregate(): void;
     add(nodeId: client.NodeID, contribution: WeightsContainer, round: number, communicationRound?: number): boolean;
     isFull(): boolean;

package/dist/aggregator/secure.js

@@ -11,8 +11,8 @@ import { aggregation } from "../index.js";
  */
 export class SecureAggregator extends Aggregator {
     maxShareValue;
-    constructor(model, maxShareValue = 100) {
-        super(model, 0, 2);
+    constructor(maxShareValue = 100) {
+        super(0, 2);
         this.maxShareValue = maxShareValue;
     }
     aggregate() {
@@ -24,7 +24,7 @@ export class SecureAggregator extends Aggregator {
                 if (currentContributions === undefined)
                     throw new Error("aggregating without any contribution");
                 const result = aggregation.sum(currentContributions.values());
-                this.emit(result);
+                this.emit('aggregation', result);
                 break;
             }
             // Average the received partial sums
@@ -33,9 +33,7 @@ export class SecureAggregator extends Aggregator {
                 if (currentContributions === undefined)
                     throw new Error("aggregating without any contribution");
                 const result = aggregation.avg(currentContributions.values());
-                if (this.model !== undefined)
-                    this.model.weights = result;
-                this.emit(result);
+                this.emit('aggregation', result);
                 break;
             }
             default:
@@ -56,7 +54,6 @@ export class SecureAggregator extends Aggregator {
             ? AggregationStep.UPDATE
             : AggregationStep.ADD, nodeId);
         this.contributions = this.contributions.setIn([communicationRound, nodeId], contribution);
-        this.informant?.update();
         if (this.isFull())
             this.aggregate();
         return true;

package/dist/client/base.d.ts

@@ -1,4 +1,3 @@
-import type { Set } from 'immutable';
 import type { Model, Task, WeightsContainer } from '../index.js';
 import type { NodeID } from './types.js';
 import type { EventConnection } from './event_connection.js';
@@ -68,9 +67,10 @@ export declare abstract class Base {
      * Communication callback called the end of every training round.
      * @param _weights The most recent local weight updates
      * @param _round The current training round
+     * @returns aggregated weights or the local weights upon error
      */
-    onRoundEndCommunication(_weights: WeightsContainer, _round: number): Promise<void>;
-    get nodes(): Set<NodeID>;
+    abstract onRoundEndCommunication(_weights: WeightsContainer, _round: number): Promise<WeightsContainer>;
+    get nbOfParticipants(): number;
     get ownId(): NodeID;
     get server(): EventConnection;
 }

package/dist/client/base.js

@@ -64,14 +64,12 @@ export class Base {
      * @param _round The current training round
      */
     async onRoundBeginCommunication(_weights, _round) { }
-    /**
-     * Communication callback called the end of every training round.
-     * @param _weights The most recent local weight updates
-     * @param _round The current training round
-     */
-    async onRoundEndCommunication(_weights, _round) { }
-    get nodes() {
-        return this.aggregator.nodes;
+    // Number of contributors to a collaborative session
+    // If decentralized, it should be the number of peers
+    // If federated, it should the number of participants excluding the server
+    // If local it should be 1
+    get nbOfParticipants() {
+        return this.aggregator.nodes.size; // overriden by the federated client
     }
     get ownId() {
         if (this._ownId === undefined) {