@epfml/discojs-node 2.0.0

package/README.md

@@ -0,0 +1,53 @@
+# Disco.js Node Module
+
+`discojs-node` contains the Node.js code of Disco.js, based off and extending `discojs-core`.
+
+## Installation
+
+The `discojs-node` project is available as the `@epfml/discojs-node` NPM package, which can be installed with
+`npm i @epfml/discojs-node`.
+
+### Development Environment
+
+The dev tools run on Node.js and require `npm`, a package manager for the Node.js runtime environment.
+We recommend using [nvm](https://github.com/nvm-sh/nvm) for installing both Node.js and NPM.
+
+To install the project's dependencies, run:
+
+```
+cd ..
+npm ci
+```
+
+Since the dependencies of `discojs-core`, `discojs-web` and `discojs-node` are the same, they are specified in a top-level `package.json` file, to ease installation and building.
+
+> **⚠ WARNING: Apple Silicon.**
+> `TensorFlow.js` version `3` do support M1 processors for macs. To do so, make sure you have an `arm` Node.js executable installed (not `x86_64`). It can be checked using:
+
+```
+node -p "process.arch"
+```
+
+which should return something similar to `arm64`.
+
+## Build
+
+The server and CLI modules, as well as all unit tests (except Cypress) use the `discojs-node` interface, i.e. they all run on Node.js. This Disco.js Node module is build on top of and extends `discojs-core`, whose code is [symlinked](https://en.wikipedia.org/wiki/Symbolic_link) into `discojs-node/src/core`. To build this project:
+
+```
+npm run build
+```
+
+This invokes the TypeScript compiler (`tsc`). It will output the compilation files of `discojs-node` in a `dist/` directory. To recompile from stratch, simply `rm -rf dist/` before running `npm run build` again.
+
+## Development
+
+### Contributing
+
+Contributions to `discojs-node` must only include Node-specific code. Code common to both Node and the browser must be added to `discojs-core` instead.
+
+As a rule of thumb, the `src/core/` directory must never be modified when modifying `discojs-node`, since it is [symlinked](https://en.wikipedia.org/wiki/Symbolic_link) to `discojs-core`.
+
+If you wish to add a new file or submodule to the project, please do so in a similar way as `src/core/` is structured. That is, [adding a new task](../../docs/TASK.md) to `discojs-node` would mean adding a new file to `src/tasks/` and modifying `src/tasks/index.ts` (NOT `src/core/tasks/...`).
+
+Note that, if you end up making calls to the Tensorflow.js API, you must import it from the root index. This is to ensure the Node version of TF.js is loaded, and only once.

package/dist/core/async_buffer.d.ts

@@ -0,0 +1,41 @@
+import { Map } from 'immutable';
+import { TaskID, AsyncInformant } from '.';
+/**
+ * The AsyncWeightsBuffer class holds and manipulates information about the
+ * async weights buffer. It works as follows:
+ *
+ * Setup: Init round to zero and create empty buffer (a map from user id to weights)
+ *
+ * - When a user adds weights only do so when they are recent weights: i.e. this.round - round <= roundCutoff.
+ * - If a user already added weights, update them. (-> there can be at most one entry of weights per id in a buffer).
+ * - When the buffer is full, call aggregateAndStoreWeights with the weights in the buffer and then increment round by one  and reset the buffer.
+ *
+ * @remarks
+ * taskID: corresponds to the task that weights correspond to.
+ * bufferCapacity: size of the buffer.
+ * buffer: holds a map of users to their added weights.
+ * round: the latest round of the weight buffer.
+ * roundCutoff: cutoff for accepted rounds.
+ */
+export declare class AsyncBuffer<T> {
+    readonly taskID: TaskID;
+    private readonly bufferCapacity;
+    private readonly aggregateAndStoreWeights;
+    private readonly roundCutoff;
+    buffer: Map<string, T>;
+    round: number;
+    private observer;
+    constructor(taskID: TaskID, bufferCapacity: number, aggregateAndStoreWeights: (weights: Iterable<T>) => Promise<void>, roundCutoff?: number);
+    registerObserver(observer: AsyncInformant<T>): void;
+    bufferIsFull(): boolean;
+    private updateWeightsIfBufferIsFull;
+    isNotWithinRoundCutoff(round: number): boolean;
+    /**
+       * Add weights originating from weights of a given round.
+       * Only add to buffer if the given round is not old.
+       * @param weights
+       * @param round
+       * @returns true if weights were added, and false otherwise
+       */
+    add(id: string, weights: T, round: number): Promise<boolean>;
+}

package/dist/core/async_buffer.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncBuffer = void 0;
+var tslib_1 = require("tslib");
+var immutable_1 = require("immutable");
+/**
+ * The AsyncWeightsBuffer class holds and manipulates information about the
+ * async weights buffer. It works as follows:
+ *
+ * Setup: Init round to zero and create empty buffer (a map from user id to weights)
+ *
+ * - When a user adds weights only do so when they are recent weights: i.e. this.round - round <= roundCutoff.
+ * - If a user already added weights, update them. (-> there can be at most one entry of weights per id in a buffer).
+ * - When the buffer is full, call aggregateAndStoreWeights with the weights in the buffer and then increment round by one  and reset the buffer.
+ *
+ * @remarks
+ * taskID: corresponds to the task that weights correspond to.
+ * bufferCapacity: size of the buffer.
+ * buffer: holds a map of users to their added weights.
+ * round: the latest round of the weight buffer.
+ * roundCutoff: cutoff for accepted rounds.
+ */
+var AsyncBuffer = /** @class */ (function () {
+    function AsyncBuffer(taskID, bufferCapacity, aggregateAndStoreWeights, roundCutoff) {
+        if (roundCutoff === void 0) { roundCutoff = 0; }
+        this.taskID = taskID;
+        this.bufferCapacity = bufferCapacity;
+        this.aggregateAndStoreWeights = aggregateAndStoreWeights;
+        this.roundCutoff = roundCutoff;
+        this.buffer = (0, immutable_1.Map)();
+        this.round = 0;
+    }
+    AsyncBuffer.prototype.registerObserver = function (observer) {
+        this.observer = observer;
+    };
+    // TODO do not test private
+    AsyncBuffer.prototype.bufferIsFull = function () {
+        return this.buffer.size >= this.bufferCapacity;
+    };
+    AsyncBuffer.prototype.updateWeightsIfBufferIsFull = function () {
+        var _a;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.bufferIsFull()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.aggregateAndStoreWeights(this.buffer.values())];
+                    case 1:
+                        _b.sent();
+                        this.round += 1;
+                        (_a = this.observer) === null || _a === void 0 ? void 0 : _a.update();
+                        this.buffer = (0, immutable_1.Map)();
+                        console.log('\n************************************************************');
+                        console.log("Buffer is full; Aggregating weights and starting round: " + this.round + "\n");
+                        _b.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // TODO do not test private
+    AsyncBuffer.prototype.isNotWithinRoundCutoff = function (round) {
+        // Note that always this.round >= round
+        return this.round - round > this.roundCutoff;
+    };
+    /**
+       * Add weights originating from weights of a given round.
+       * Only add to buffer if the given round is not old.
+       * @param weights
+       * @param round
+       * @returns true if weights were added, and false otherwise
+       */
+    AsyncBuffer.prototype.add = function (id, weights, round) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var weightsUpdatedByUser, msg;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.isNotWithinRoundCutoff(round)) {
+                            console.log("Did not add weights of " + id + " to buffer. Due to old round update: " + round + ", current round is " + this.round);
+                            return [2 /*return*/, false];
+                        }
+                        weightsUpdatedByUser = this.buffer.has(id);
+                        msg = weightsUpdatedByUser ? '\tUpdating' : '-> Adding new';
+                        console.log(msg + " weights of " + id + " to buffer.");
+                        this.buffer = this.buffer.set(id, weights);
+                        return [4 /*yield*/, this.updateWeightsIfBufferIsFull()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    return AsyncBuffer;
+}());
+exports.AsyncBuffer = AsyncBuffer;

package/dist/core/async_informant.d.ts

@@ -0,0 +1,20 @@
+import { AsyncBuffer } from './async_buffer';
+export declare class AsyncInformant<T> {
+    private readonly asyncBuffer;
+    private round;
+    private currentNumberOfParticipants;
+    private totalNumberOfParticipants;
+    private averageNumberOfParticipants;
+    constructor(asyncBuffer: AsyncBuffer<T>);
+    update(): void;
+    private updateRound;
+    private updateNumberOfParticipants;
+    private updateAverageNumberOfParticipants;
+    private updateTotalNumberOfParticipants;
+    getCurrentRound(): number;
+    getNumberOfParticipants(): number;
+    getTotalNumberOfParticipants(): number;
+    getAverageNumberOfParticipants(): number;
+    getAllStatistics(): Record<'round' | 'currentNumberOfParticipants' | 'totalNumberOfParticipants' | 'averageNumberOfParticipants', number>;
+    printAllInfos(): void;
+}

package/dist/core/async_informant.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncInformant = void 0;
+var AsyncInformant = /** @class */ (function () {
+    function AsyncInformant(asyncBuffer) {
+        this.asyncBuffer = asyncBuffer;
+        this.round = 0;
+        this.currentNumberOfParticipants = 0;
+        this.totalNumberOfParticipants = 0;
+        this.averageNumberOfParticipants = 0;
+        this.asyncBuffer.registerObserver(this);
+    }
+    // Update functions
+    AsyncInformant.prototype.update = function () {
+        // DEBUG
+        console.log('Before update');
+        this.printAllInfos();
+        this.updateRound();
+        this.updateNumberOfParticipants();
+        // DEBUG
+        console.log('After update');
+        this.printAllInfos();
+    };
+    AsyncInformant.prototype.updateRound = function () {
+        this.round = this.asyncBuffer.round;
+    };
+    AsyncInformant.prototype.updateNumberOfParticipants = function () {
+        this.currentNumberOfParticipants = this.asyncBuffer.buffer.size;
+        this.updateTotalNumberOfParticipants(this.currentNumberOfParticipants);
+        this.updateAverageNumberOfParticipants();
+    };
+    AsyncInformant.prototype.updateAverageNumberOfParticipants = function () {
+        this.averageNumberOfParticipants = this.totalNumberOfParticipants / this.round;
+    };
+    AsyncInformant.prototype.updateTotalNumberOfParticipants = function (currentNumberOfParticipants) {
+        this.totalNumberOfParticipants += currentNumberOfParticipants;
+    };
+    // Getter functions
+    AsyncInformant.prototype.getCurrentRound = function () {
+        return this.round;
+    };
+    AsyncInformant.prototype.getNumberOfParticipants = function () {
+        return this.currentNumberOfParticipants;
+    };
+    AsyncInformant.prototype.getTotalNumberOfParticipants = function () {
+        return this.totalNumberOfParticipants;
+    };
+    AsyncInformant.prototype.getAverageNumberOfParticipants = function () {
+        return this.averageNumberOfParticipants;
+    };
+    AsyncInformant.prototype.getAllStatistics = function () {
+        return {
+            round: this.getCurrentRound(),
+            currentNumberOfParticipants: this.getNumberOfParticipants(),
+            totalNumberOfParticipants: this.getTotalNumberOfParticipants(),
+            averageNumberOfParticipants: this.getAverageNumberOfParticipants()
+        };
+    };
+    // Debug
+    AsyncInformant.prototype.printAllInfos = function () {
+        console.log('task : ', this.asyncBuffer.taskID);
+        console.log('round : ', this.getCurrentRound());
+        console.log('participants : ', this.getNumberOfParticipants());
+        console.log('total : ', this.getTotalNumberOfParticipants());
+        console.log('average : ', this.getAverageNumberOfParticipants());
+    };
+    return AsyncInformant;
+}());
+exports.AsyncInformant = AsyncInformant;

package/dist/core/client/base.d.ts

@@ -0,0 +1,33 @@
+import { tf, WeightsContainer, Task, TrainingInformant } from '..';
+export declare abstract class Base {
+    readonly url: URL;
+    readonly task: Task;
+    protected connected: boolean;
+    constructor(url: URL, task: Task);
+    /**
+     * Handles the connection process from the client to any sort of
+     * centralized server.
+     */
+    abstract connect(): Promise<void>;
+    /**
+     * Handles the disconnection process of the client from any sort
+     * of centralized server.
+     */
+    abstract disconnect(): Promise<void>;
+    getLatestModel(): Promise<tf.LayersModel>;
+    /**
+     * The training manager matches this function with the training loop's
+     * onTrainEnd callback when training a TFJS model object. See the
+     * training manager for more details.
+     */
+    abstract onTrainEndCommunication(weights: WeightsContainer, trainingInformant: TrainingInformant): Promise<void>;
+    /**
+     * This function will be called whenever a local round has ended.
+     *
+     * @param updatedWeights
+     * @param staleWeights
+     * @param round
+     * @param trainingInformant
+     */
+    abstract onRoundEndCommunication(updatedWeights: WeightsContainer, staleWeights: WeightsContainer, round: number, trainingInformant: TrainingInformant): Promise<WeightsContainer>;
+}

package/dist/core/client/base.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+var tslib_1 = require("tslib");
+var axios_1 = (0, tslib_1.__importDefault)(require("axios"));
+var __1 = require("..");
+var Base = /** @class */ (function () {
+    function Base(url, task) {
+        this.url = url;
+        this.task = task;
+        this.connected = false;
+    }
+    Base.prototype.getLatestModel = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var url, response;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = new URL('', this.url.href);
+                        if (!url.pathname.endsWith('/')) {
+                            url.pathname += '/';
+                        }
+                        url.pathname += "tasks/" + this.task.taskID + "/model.json";
+                        return [4 /*yield*/, axios_1.default.get(url.href)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, __1.serialization.model.decode(response.data)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return Base;
+}());
+exports.Base = Base;

package/dist/core/client/decentralized/base.d.ts

@@ -0,0 +1,32 @@
+import { List, Map } from 'immutable';
+import { TrainingInformant, WeightsContainer, Task } from '../..';
+import { Base as ClientBase } from '../base';
+import { PeerID } from './types';
+import * as messages from './messages';
+import { PeerConnection } from '../event_connection';
+/**
+ * Abstract class for decentralized clients, executes onRoundEndCommunication as well as connecting
+ * to the signaling server
+ */
+export declare abstract class Base extends ClientBase {
+    readonly url: URL;
+    readonly task: Task;
+    protected readonly minimumReadyPeers: number;
+    private server?;
+    private peers?;
+    private ID?;
+    private pool?;
+    constructor(url: URL, task: Task);
+    private waitForPeers;
+    protected sendMessagetoPeer(peer: PeerConnection, msg: messages.PeerMessage): void;
+    private connectServer;
+    /**
+     * Initialize the connection to the peers and to the other nodes.
+     */
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    onTrainEndCommunication(_: WeightsContainer, trainingInformant: TrainingInformant): Promise<void>;
+    onRoundEndCommunication(updatedWeights: WeightsContainer, staleWeights: WeightsContainer, round: number, trainingInformant: TrainingInformant): Promise<WeightsContainer>;
+    abstract sendAndReceiveWeights(peers: Map<PeerID, PeerConnection>, noisyWeights: WeightsContainer, round: number, trainingInformant: TrainingInformant): Promise<List<WeightsContainer>>;
+    abstract clientHandle(peers: Map<PeerID, PeerConnection>): void;
+}

package/dist/core/client/decentralized/base.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+var tslib_1 = require("tslib");
+var immutable_1 = require("immutable");
+var nodeUrl = (0, tslib_1.__importStar)(require("url"));
+var __1 = require("../..");
+var base_1 = require("../base");
+var peer_pool_1 = require("./peer_pool");
+var messages = (0, tslib_1.__importStar)(require("./messages"));
+var messages_1 = require("../messages");
+var event_connection_1 = require("../event_connection");
+var utils_1 = require("../utils");
+/**
+ * Abstract class for decentralized clients, executes onRoundEndCommunication as well as connecting
+ * to the signaling server
+ */
+var Base = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(Base, _super);
+    function Base(url, task) {
+        var _a, _b;
+        var _this = _super.call(this, url, task) || this;
+        _this.url = url;
+        _this.task = task;
+        _this.minimumReadyPeers = (_b = (_a = _this.task.trainingInformation) === null || _a === void 0 ? void 0 : _a.minimumReadyPeers) !== null && _b !== void 0 ? _b : 3;
+        return _this;
+    }
+    // send message to server that client is ready
+    Base.prototype.waitForPeers = function (round) {
+        var _a;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var msg, receivedMessage, peers, ret;
+            var _this = this;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.debug(this.ID, 'is ready for round', round);
+                        // clean old round
+                        this.peers = undefined;
+                        msg = { type: messages_1.type.PeerIsReady };
+                        if (this.server === undefined) {
+                            throw new Error('server undefined, could not connect peers');
+                        }
+                        this.server.send(msg);
+                        return [4 /*yield*/, (0, event_connection_1.waitMessageWithTimeout)(this.server, messages_1.type.PeersForRound, utils_1.MAX_WAIT_PER_ROUND)];
+                    case 1:
+                        receivedMessage = _b.sent();
+                        peers = (0, immutable_1.Set)(receivedMessage.peers);
+                        if (this.ID !== undefined && peers.has(this.ID)) {
+                            throw new Error('received peer list contains our own id');
+                        }
+                        if (this.peers !== undefined) {
+                            throw new Error('got new peer list from server but was already received for this round');
+                        }
+                        if (peers.size + 1 < this.minimumReadyPeers) {
+                            throw new Error('new peer list do not contain enough ready peers');
+                        }
+                        this.peers = peers;
+                        console.debug(this.ID, 'got peers for round:', peers.toJS());
+                        if (this.pool === undefined) {
+                            throw new Error('waiting for peers but peer pool is undefined');
+                        }
+                        return [4 /*yield*/, this.pool];
+                    case 2: return [4 /*yield*/, (_b.sent()).getPeers((0, immutable_1.Set)((_a = this.peers) !== null && _a !== void 0 ? _a : []), this.server, function (p) { return _this.clientHandle(p); })];
+                    case 3:
+                        ret = _b.sent();
+                        console.debug(this.ID, "got peers for round " + round + ":", ret.keySeq().toJS());
+                        return [2 /*return*/, ret];
+                }
+            });
+        });
+    };
+    // TODO inline? have a serialization mod
+    Base.prototype.sendMessagetoPeer = function (peer, msg) {
+        console.debug(this.ID, 'sends message to peer', msg.peer, msg);
+        peer.send(msg);
+    };
+    /*
+    creation of the websocket for the server, connection of client to that webSocket,
+    deals with message reception from decentralized client perspective (messages received by client)
+     */
+    Base.prototype.connectServer = function (url) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var server;
+            var _this = this;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, event_connection_1.WebSocketServer.connect(url, messages.isMessageFromServer, messages.isMessageToServer)];
+                    case 1:
+                        server = _a.sent();
+                        server.on(messages_1.type.SignalForPeer, function (event) {
+                            console.debug(_this.ID, 'got signal from', event.peer);
+                            if (_this.pool === undefined) {
+                                throw new Error('got signal but peer pool is undefined');
+                            }
+                            void _this.pool.then(function (pool) { return pool.signal(event.peer, event.signal); });
+                        });
+                        return [2 /*return*/, server];
+                }
+            });
+        });
+    };
+    /**
+     * Initialize the connection to the peers and to the other nodes.
+     */
+    Base.prototype.connect = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var URL, serverURL, _a, msg, peerIdMsg;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        URL = typeof window !== 'undefined' ? window.URL : nodeUrl.URL;
+                        serverURL = new URL('', this.url.href);
+                        switch (this.url.protocol) {
+                            case 'http:':
+                                serverURL.protocol = 'ws:';
+                                break;
+                            case 'https:':
+                                serverURL.protocol = 'wss:';
+                                break;
+                            default:
+                                throw new Error("unknown protocol: " + this.url.protocol);
+                        }
+                        serverURL.pathname += "deai/" + this.task.taskID;
+                        _a = this;
+                        return [4 /*yield*/, this.connectServer(serverURL)];
+                    case 1:
+                        _a.server = _b.sent();
+                        msg = {
+                            type: messages_1.type.clientConnected
+                        };
+                        this.server.send(msg);
+                        return [4 /*yield*/, (0, event_connection_1.waitMessage)(this.server, messages_1.type.PeerID)];
+                    case 2:
+                        peerIdMsg = _b.sent();
+                        console.debug(peerIdMsg.id, 'got own id from server');
+                        if (this.ID !== undefined) {
+                            throw new Error('got ID from server but was already received');
+                        }
+                        this.ID = peerIdMsg.id;
+                        this.pool = peer_pool_1.PeerPool.init(peerIdMsg.id);
+                        this.connected = true; // Is this still needed?
+                        console.debug(this.ID, 'client connected to server');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // disconnect from server & peers
+    Base.prototype.disconnect = function () {
+        var _a, _b;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        console.debug(this.ID, 'disconnect');
+                        return [4 /*yield*/, this.pool];
+                    case 1:
+                        (_a = (_c.sent())) === null || _a === void 0 ? void 0 : _a.shutdown();
+                        this.pool = undefined;
+                        (_b = this.server) === null || _b === void 0 ? void 0 : _b.disconnect();
+                        this.server = undefined;
+                        this.connected = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Base.prototype.onTrainEndCommunication = function (_, trainingInformant) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                // TODO: enter seeding mode?
+                trainingInformant.addMessage('Training finished.');
+                return [2 /*return*/];
+            });
+        });
+    };
+    Base.prototype.onRoundEndCommunication = function (updatedWeights, staleWeights, round, trainingInformant) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var peers, noisyWeights, finalWeights, e_1, msg;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, this.waitForPeers(round)
+                            // centralized phase of communication --> client tells server that they have finished a local round and are ready to aggregate
+                            // Apply clipping and DP to updates that will be sent
+                        ];
+                    case 1:
+                        peers = _a.sent();
+                        noisyWeights = __1.privacy.addDifferentialPrivacy(updatedWeights, staleWeights, this.task);
+                        return [4 /*yield*/, this.sendAndReceiveWeights(peers, noisyWeights, round, trainingInformant)];
+                    case 2:
+                        finalWeights = _a.sent();
+                        console.debug(this.ID, 'sent and received', finalWeights.size, 'weights at round', round);
+                        return [2 /*return*/, __1.aggregation.avg(finalWeights)];
+                    case 3:
+                        e_1 = _a.sent();
+                        msg = "errored on round " + round;
+                        if (e_1 instanceof Error) {
+                            msg += ": " + e_1.message;
+                        }
+                        console.warn(this.ID, msg);
+                        return [2 /*return*/, updatedWeights];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Base;
+}(base_1.Base));
+exports.Base = Base;

package/dist/core/client/decentralized/clear_text.d.ts

@@ -0,0 +1,14 @@
+import { List, Map } from 'immutable';
+import { TrainingInformant, WeightsContainer } from '../..';
+import { Base } from './base';
+import { PeerID } from './types';
+import { PeerConnection } from '../event_connection';
+/**
+ * Decentralized client that does not utilize secure aggregation, but sends model updates in clear text
+ */
+export declare class ClearText extends Base {
+    private receivedWeights?;
+    sendAndReceiveWeights(peers: Map<PeerID, PeerConnection>, noisyWeights: WeightsContainer, round: number, trainingInformant: TrainingInformant): Promise<List<WeightsContainer>>;
+    private receiveWeights;
+    clientHandle(peers: Map<PeerID, PeerConnection>): void;
+}