@epfml/discojs 2.1.2-p20240515133413.0 → 2.1.2-p20240528164510.0

package/dist/aggregator/base.js

@@ -24,6 +24,7 @@ export class Base {
      * It defines the effective aggregation group, which is possibly a subset
      * of all active nodes, depending on the aggregation scheme.
      */
+    // communication round -> NodeID -> T
     contributions;
     /**
      * Emits the aggregation event whenever an aggregation step is performed.

package/dist/aggregator/mean.d.ts

@@ -1,23 +1,18 @@
-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 { 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. */
 export declare class MeanAggregator extends Aggregator<WeightsContainer> {
+    #private;
     /**
-     * The threshold t to fulfill to trigger an aggregation step. It can either be:
-     * - relative: 0 < t <= 1, thus requiring t * |nodes| contributions
-     * - absolute: t > 1, thus requiring t contributions
+     * @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
      */
-    readonly threshold: number;
     constructor(model?: Model, roundCutoff?: number, threshold?: number);
-    /**
-     * Checks whether the contributions buffer is full, according to the set threshold.
-     * @returns Whether the contributions buffer is full
-     */
+    /** Checks whether the contributions buffer is full. */
     isFull(): boolean;
-    add(nodeId: client.NodeID, contribution: WeightsContainer, round: number): boolean;
+    add(nodeId: client.NodeID, contribution: WeightsContainer, round: number, currentContributions?: number): boolean;
     aggregate(): void;
     makePayloads(weights: WeightsContainer): Map<client.NodeID, WeightsContainer>;
 }

package/dist/aggregator/mean.js

@@ -1,65 +1,51 @@
-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.
- */
+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. */
 export class MeanAggregator extends Aggregator {
+    #threshold;
     /**
-     * The threshold t to fulfill to trigger an aggregation step. It can either be:
-     * - relative: 0 < t <= 1, thus requiring t * |nodes| contributions
-     * - absolute: t > 1, thus requiring t contributions
+     * @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
      */
-    threshold;
+    // TODO no way to require a single contribution
     constructor(model, roundCutoff = 0, threshold = 1) {
+        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);
-        // Default threshold is 100% of node participation
-        if (threshold === undefined) {
-            this.threshold = 1;
-            // Threshold must be positive
-        }
-        else if (threshold <= 0) {
-            throw new Error('threshold must be positive');
-            // Thresholds greater than 1 are considered absolute instead of relative to the number of nodes
-        }
-        else if (threshold > 1 && Math.round(threshold) !== threshold) {
-            throw new Error('absolute thresholds must integers');
-        }
-        else {
-            this.threshold = threshold;
-        }
+        this.#threshold = threshold;
     }
-    /**
-     * Checks whether the contributions buffer is full, according to the set threshold.
-     * @returns Whether the contributions buffer is full
-     */
+    /** Checks whether the contributions buffer is full. */
     isFull() {
-        if (this.threshold <= 1) {
-            const contribs = this.contributions.get(this.communicationRound);
-            if (contribs === undefined) {
-                return false;
-            }
-            return contribs.size >= this.threshold * this.nodes.size;
-        }
-        return this.contributions.size >= this.threshold;
+        const actualThreshold = this.#threshold <= 1
+            ? this.#threshold * this.nodes.size
+            : this.#threshold;
+        return (this.contributions.get(0)?.size ?? 0) >= actualThreshold;
     }
-    add(nodeId, contribution, round) {
-        if (this.nodes.has(nodeId) && this.isWithinRoundCutoff(round)) {
-            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;
-        }
-        return false;
+    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))
+            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;
     }
     aggregate() {
+        const currentContributions = this.contributions.get(0);
+        if (currentContributions === undefined)
+            throw new Error("aggregating without any contribution");
         this.log(AggregationStep.AGGREGATE);
-        const result = aggregation.avg(this.contributions.get(0)?.values());
-        if (this.model !== undefined) {
+        const result = aggregation.avg(currentContributions.values());
+        if (this.model !== undefined)
             this.model.weights = result;
-        }
         this.emit(result);
     }
     makePayloads(weights) {

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 { Map, List } from "immutable";
+import { Base as Aggregator } from "./base.js";
+import type { Model, WeightsContainer, client } from "../index.js";
 /**
  * Aggregator implementing secure multi-party computation for decentralized learning.
  * An aggregation consists of two communication rounds:
@@ -12,12 +12,10 @@ export declare class SecureAggregator extends Aggregator<WeightsContainer> {
     private readonly maxShareValue;
     constructor(model?: Model, maxShareValue?: number);
     aggregate(): void;
-    add(nodeId: client.NodeID, contribution: WeightsContainer, round: number, communicationRound: number): boolean;
+    add(nodeId: client.NodeID, contribution: WeightsContainer, round: number, communicationRound?: number): boolean;
     isFull(): boolean;
     makePayloads(weights: WeightsContainer): Map<client.NodeID, WeightsContainer>;
-    /**
-     * Generate N additive shares that aggregate to the secret weights array, where N is the number of peers.
-     */
+    /** Generate N additive shares that aggregate to the secret weights array, where N is the number of peers. */
     generateAllShares(secret: WeightsContainer): List<WeightsContainer>;
     /**
      * Generates one share in the same shape as the secret that is populated with values randomly chosen from

package/dist/aggregator/secure.js

@@ -1,7 +1,7 @@
-import { Map, List, Range } from 'immutable';
-import * as tf from '@tensorflow/tfjs';
-import { AggregationStep, Base as Aggregator } from './base.js';
-import { aggregation } from '../index.js';
+import { Map, List, Range } from "immutable";
+import * as tf from "@tensorflow/tfjs";
+import { AggregationStep, Base as Aggregator } from "./base.js";
+import { aggregation } from "../index.js";
 /**
  * Aggregator implementing secure multi-party computation for decentralized learning.
  * An aggregation consists of two communication rounds:
@@ -17,60 +17,72 @@ export class SecureAggregator extends Aggregator {
     }
     aggregate() {
         this.log(AggregationStep.AGGREGATE);
-        if (this.communicationRound === 0) {
+        switch (this.communicationRound) {
             // Sum the received shares
-            const result = aggregation.sum(this.contributions.get(0)?.values());
-            this.emit(result);
-        }
-        else if (this.communicationRound === 1) {
+            case 0: {
+                const currentContributions = this.contributions.get(0);
+                if (currentContributions === undefined)
+                    throw new Error("aggregating without any contribution");
+                const result = aggregation.sum(currentContributions.values());
+                this.emit(result);
+                break;
+            }
             // Average the received partial sums
-            const result = aggregation.avg(this.contributions.get(1)?.values());
-            if (this.model !== undefined) {
-                this.model.weights = result;
+            case 1: {
+                const currentContributions = this.contributions.get(1);
+                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);
+                break;
             }
-            this.emit(result);
-        }
-        else {
-            throw new Error('communication round is out of bounds');
+            default:
+                throw new Error("communication round is out of bounds");
         }
     }
     add(nodeId, contribution, round, communicationRound) {
-        if (this.nodes.has(nodeId) && this.isWithinRoundCutoff(round)) {
-            this.log(this.contributions.hasIn([communicationRound, nodeId]) ? AggregationStep.UPDATE : AggregationStep.ADD, nodeId);
-            this.contributions = this.contributions.setIn([communicationRound, nodeId], contribution);
-            this.informant?.update();
-            if (this.isFull()) {
-                this.aggregate();
-            }
-            return true;
+        switch (communicationRound) {
+            case 0:
+            case 1:
+                break;
+            default:
+                throw new Error("requires communication round to be 0 or 1");
         }
-        return false;
+        if (!this.nodes.has(nodeId) || !this.isWithinRoundCutoff(round))
+            return false;
+        this.log(this.contributions.hasIn([communicationRound, nodeId])
+            ? AggregationStep.UPDATE
+            : AggregationStep.ADD, nodeId);
+        this.contributions = this.contributions.setIn([communicationRound, nodeId], contribution);
+        this.informant?.update();
+        if (this.isFull())
+            this.aggregate();
+        return true;
     }
     isFull() {
-        const contribs = this.contributions.get(this.communicationRound);
-        if (contribs === undefined) {
-            return false;
-        }
-        return contribs.size === this.nodes.size;
+        return ((this.contributions.get(this.communicationRound)?.size ?? 0) ===
+            this.nodes.size);
     }
     makePayloads(weights) {
-        if (this.communicationRound === 0) {
-            const shares = this.generateAllShares(weights);
-            // Abitrarily assign our shares to the available nodes
-            return Map(List(this.nodes).zip(shares));
-        }
-        else {
+        switch (this.communicationRound) {
+            case 0: {
+                const shares = this.generateAllShares(weights);
+                // Abitrarily assign our shares to the available nodes
+                return Map(List(this.nodes).zip(shares));
+            }
             // Send our partial sum to every other nodes
-            return this.nodes.toMap().map(() => weights);
+            case 1:
+                return this.nodes.toMap().map(() => weights);
+            default:
+                throw new Error("communication round is out of bounds");
         }
     }
-    /**
-     * Generate N additive shares that aggregate to the secret weights array, where N is the number of peers.
-     */
+    /** Generate N additive shares that aggregate to the secret weights array, where N is the number of peers. */
     generateAllShares(secret) {
-        if (this.nodes.size === 0) {
-            throw new Error('too few participants to generate shares');
-        }
+        if (this.nodes.size === 0)
+            throw new Error("too few participants to generate shares");
         // Generate N-1 shares
         const shares = Range(0, this.nodes.size - 1)
             .map(() => this.generateRandomShare(secret))
@@ -86,6 +98,6 @@ export class SecureAggregator extends Aggregator {
         const MAX_SEED_BITS = 47;
         const random = crypto.getRandomValues(new BigInt64Array(1))[0];
         const seed = Number(BigInt.asUintN(MAX_SEED_BITS, random));
-        return secret.map((t) => tf.randomUniform(t.shape, -this.maxShareValue, this.maxShareValue, 'float32', seed));
+        return secret.map((t) => tf.randomUniform(t.shape, -this.maxShareValue, this.maxShareValue, "float32", seed));
     }
 }

package/dist/client/federated/messages.d.ts

@@ -1,7 +1,7 @@
 import { type client, type MetadataKey, type MetadataValue } from '../../index.js';
 import { type weights } from '../../serialization/index.js';
 import { type, type AssignNodeID, type ClientConnected } from '../messages.js';
-export type MessageFederated = ClientConnected | SendPayload | ReceiveServerPayload | RequestServerStatistics | ReceiveServerStatistics | ReceiveServerMetadata | AssignNodeID;
+export type MessageFederated = ClientConnected | SendPayload | ReceiveServerPayload | ReceiveServerMetadata | AssignNodeID;
 export interface SendPayload {
     type: type.SendPayload;
     payload: weights.Encoded;
@@ -12,13 +12,6 @@ export interface ReceiveServerPayload {
     payload: weights.Encoded;
     round: number;
 }
-export interface RequestServerStatistics {
-    type: type.RequestServerStatistics;
-}
-export interface ReceiveServerStatistics {
-    type: type.ReceiveServerStatistics;
-    statistics: Record<string, number>;
-}
 export interface ReceiveServerMetadata {
     type: type.ReceiveServerMetadata;
     nodeId: client.NodeID;

package/dist/client/federated/messages.js

@@ -5,20 +5,11 @@ export function isMessageFederated(raw) {
     }
     switch (raw.type) {
         case type.ClientConnected:
-            return true;
         case type.SendPayload:
-            return true;
         case type.ReceiveServerPayload:
-            return true;
-        case type.RequestServerStatistics:
-            return true;
-        case type.ReceiveServerStatistics:
-            return true;
         case type.ReceiveServerMetadata:
-            return true;
         case type.AssignNodeID:
             return true;
-        default:
-            return false;
     }
+    return false;
 }

package/dist/client/messages.d.ts

@@ -10,9 +10,7 @@ export declare enum type {
     Payload = 5,
     SendPayload = 6,
     ReceiveServerMetadata = 7,
-    ReceiveServerPayload = 8,
-    RequestServerStatistics = 9,
-    ReceiveServerStatistics = 10
+    ReceiveServerPayload = 8
 }
 export interface ClientConnected {
     type: type.ClientConnected;

package/dist/client/messages.js

@@ -11,8 +11,6 @@ export var type;
     type[type["SendPayload"] = 6] = "SendPayload";
     type[type["ReceiveServerMetadata"] = 7] = "ReceiveServerMetadata";
     type[type["ReceiveServerPayload"] = 8] = "ReceiveServerPayload";
-    type[type["RequestServerStatistics"] = 9] = "RequestServerStatistics";
-    type[type["ReceiveServerStatistics"] = 10] = "ReceiveServerStatistics";
 })(type || (type = {}));
 export function hasMessageType(raw) {
     if (typeof raw !== 'object' || raw === null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epfml/discojs",
-  "version": "2.1.2-p20240515133413.0",
+  "version": "2.1.2-p20240528164510.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",