@epfml/discojs 0.0.1

package/README.md

@@ -0,0 +1,32 @@
+# discojs
+
+discojs contains the core code of disco.
+
+## Node Installation and NPM installation
+
+The app is running under Node 15.12.0. It can be downloaded from [here](https://nodejs.org/en/download/releases/).
+
+NPM is a package manager for the JavaScript runtime environment Node.js.  
+To start the application (running locally) run the following command.  
+Note: the application is currently developed using [NPM 7.6.3](https://www.npmjs.com/package/npm/v/7.6.3).
+
+```
+npm install
+```
+
+This command will install the necessary libraries required to run the application (defined in the `package.json` and `package-lock.json`). The latter command is only required when one is using the app for the first time.
+
+> **⚠ WARNING: Apple Silicon.**  
+> `TensorFlow.js` in version `3.13.0` currently supports for M1 mac laptops. However, make sure you have an `arm` node executable installed (not `x86`). It can be checked using:
+
+```
+node -p "process.arch"
+```
+
+## Build
+
+In order to enable the Browser to use the `discojs` package, we must build discojs:
+
+```
+npm run build
+```

package/dist/aggregation.d.ts

@@ -0,0 +1,3 @@
+import { Set } from 'immutable';
+import { Weights } from './types';
+export declare function averageWeights(peersWeights: Set<Weights>): Weights;

package/dist/aggregation.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.averageWeights = void 0;
+function averageWeights(peersWeights) {
+    var _a;
+    var firstWeightSize = (_a = peersWeights.first()) === null || _a === void 0 ? void 0 : _a.length;
+    if (firstWeightSize === undefined) {
+        throw new Error('no weights to average');
+    }
+    if (!peersWeights.rest().every(function (ws) { return ws.length === firstWeightSize; })) {
+        throw new Error('variable weights size');
+    }
+    var numberOfPeers = peersWeights.size;
+    var peersAverageWeights = peersWeights.reduce(function (accum, weights) {
+        return accum.map(function (w, i) { return w.add(weights[i]); });
+    }).map(function (w) { return w.div(numberOfPeers); });
+    return peersAverageWeights;
+}
+exports.averageWeights = averageWeights;

package/dist/async_buffer.d.ts

@@ -0,0 +1,41 @@
+import { AsyncInformant } from './async_informant';
+import { TaskID } from './task';
+/**
+ * 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: 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/async_buffer.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncBuffer = void 0;
+var tslib_1 = require("tslib");
+/**
+ * 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 = new 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 () {
+            var allWeights;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.bufferIsFull()) return [3 /*break*/, 2];
+                        allWeights = Array.from(this.buffer.values());
+                        return [4 /*yield*/, this.aggregateAndStoreWeights(allWeights)];
+                    case 1:
+                        _b.sent();
+                        this.round += 1;
+                        (_a = this.observer) === null || _a === void 0 ? void 0 : _a.update();
+                        this.buffer.clear();
+                        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.set(id, weights);
+                        return [4 /*yield*/, this.updateWeightsIfBufferIsFull()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    return AsyncBuffer;
+}());
+exports.AsyncBuffer = AsyncBuffer;

package/dist/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/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/client/base.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import * as tf from '@tensorflow/tfjs';
+import { Task } from '@/task';
+import { TrainingInformant } from '@/training_informant';
+import { Weights } from '@/types';
+export declare abstract class Base {
+    readonly url: URL;
+    readonly task: Task;
+    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: Weights, 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: Weights, staleWeights: Weights, round: number, trainingInformant: TrainingInformant): Promise<Weights>;
+}

package/dist/client/base.js

@@ -0,0 +1,34 @@
+"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 serialization = (0, tslib_1.__importStar)(require("../serialization"));
+var Base = /** @class */ (function () {
+    function Base(url, task) {
+        this.url = url;
+        this.task = task;
+    }
+    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*/, serialization.model.decode(response.data)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return Base;
+}());
+exports.Base = Base;

package/dist/client/decentralized.d.ts

@@ -0,0 +1,23 @@
+import { TrainingInformant, Weights } from '..';
+import { Base } from './base';
+/**
+ * Class that deals with communication with the PeerJS server.
+ * Collects the list of receivers currently connected to the PeerJS server.
+ */
+export declare class Decentralized extends Base {
+    private server?;
+    private peers;
+    private readonly weights;
+    private connectServer;
+    private connectNewPeer;
+    /**
+     * Initialize the connection to the peers and to the other nodes.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnection process when user quits the task.
+     */
+    disconnect(): Promise<void>;
+    onRoundEndCommunication(updatedWeights: Weights, staleWeights: Weights, epoch: number, trainingInformant: TrainingInformant): Promise<Weights>;
+    onTrainEndCommunication(_: Weights, trainingInformant: TrainingInformant): Promise<void>;
+}

package/dist/client/decentralized.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decentralized = void 0;
+var tslib_1 = require("tslib");
+var immutable_1 = require("immutable");
+var isomorphic_ws_1 = (0, tslib_1.__importDefault)(require("isomorphic-ws"));
+var msgpack_lite_1 = (0, tslib_1.__importDefault)(require("msgpack-lite"));
+var simple_peer_1 = (0, tslib_1.__importDefault)(require("simple-peer"));
+var url_1 = require("url");
+var __1 = require("..");
+var base_1 = require("./base");
+function isPeerMessage(data) {
+    if (typeof data !== 'object') {
+        return false;
+    }
+    if (data === null) {
+        return false;
+    }
+    if (!(0, immutable_1.Set)(Object.keys(data)).equals(immutable_1.Set.of('epoch', 'weights'))) {
+        return false;
+    }
+    var _a = data, epoch = _a.epoch, weights = _a.weights;
+    if (typeof epoch !== 'number' ||
+        !__1.serialization.weights.isEncoded(weights)) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var _ = { epoch: epoch, weights: weights };
+    return true;
+}
+function isServerOpeningMessage(msg) {
+    if (!(msg instanceof Array)) {
+        return false;
+    }
+    if (!msg.every(function (elem) { return typeof elem === 'number'; })) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var _ = msg;
+    return true;
+}
+function isServerPeerMessage(msg) {
+    if (!(msg instanceof Array)) {
+        return false;
+    }
+    if (msg.length !== 2) {
+        return false;
+    }
+    var _a = (0, tslib_1.__read)(msg, 2), id = _a[0], signal = _a[1];
+    if (typeof id !== 'number') {
+        return false;
+    }
+    if (!(signal instanceof Uint8Array)) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var _ = [id, signal];
+    return true;
+}
+// Time to wait between network checks in milliseconds.
+var TICK = 100;
+// Time to wait for the others in milliseconds.
+var MAX_WAIT_PER_ROUND = 10000;
+/**
+ * Class that deals with communication with the PeerJS server.
+ * Collects the list of receivers currently connected to the PeerJS server.
+ */
+var Decentralized = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(Decentralized, _super);
+    function Decentralized() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.peers = (0, immutable_1.Map)();
+        _this.weights = (0, immutable_1.Map)();
+        return _this;
+    }
+    Decentralized.prototype.connectServer = function (url) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var ws;
+            var _this = this;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ws = new isomorphic_ws_1.default.WebSocket(url);
+                        ws.binaryType = 'arraybuffer';
+                        ws.onmessage = function (event) {
+                            if (!(event.data instanceof ArrayBuffer)) {
+                                throw new Error('server did not send an ArrayBuffer');
+                            }
+                            var msg = msgpack_lite_1.default.decode(new Uint8Array(event.data));
+                            if (isServerOpeningMessage(msg)) {
+                                console.debug('server sent us the list of peer to connect to:', msg);
+                                if (_this.peers.size !== 0) {
+                                    throw new Error('server already gave us a list of peers');
+                                }
+                                _this.peers = (0, immutable_1.Map)((0, immutable_1.List)(msg)
+                                    .map(function (id) { return [id, _this.connectNewPeer(id, true)]; }));
+                            }
+                            else if (isServerPeerMessage(msg)) {
+                                var _a = (0, tslib_1.__read)(msg, 2), peerID = _a[0], encodedSignal = _a[1];
+                                var signal = msgpack_lite_1.default.decode(encodedSignal);
+                                console.debug('server on behalf of', peerID, 'sent', signal);
+                                var peer = _this.peers.get(peerID);
+                                if (peer === undefined) {
+                                    peer = _this.connectNewPeer(peerID, false);
+                                    _this.peers = _this.peers.set(peerID, peer);
+                                }
+                                peer.signal(signal);
+                            }
+                            else {
+                                throw new Error('send sent an invalid msg');
+                            }
+                        };
+                        return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                ws.onerror = function (err) { return reject(new Error("connecting server: " + err)); };
+                                ws.onopen = function () { return resolve(ws); };
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // connect a new peer
+    //
+    // if initiator is true, we start the connection on our side
+    // see SimplePeer.Options.initiator for more info
+    Decentralized.prototype.connectNewPeer = function (peerID, initiator) {
+        var _this = this;
+        console.debug('connect new peer with initiator: ', initiator);
+        var peer = new simple_peer_1.default({
+            initiator: initiator,
+            config: {
+                iceServers: (0, immutable_1.List)(simple_peer_1.default.config.iceServers)
+                    /* .push({
+                      urls: 'turn:34.77.172.69:3478',
+                      credential: 'deai',
+                      username: 'deai'
+                    }) */
+                    .toArray()
+            }
+        });
+        peer.on('signal', function (signal) {
+            console.debug('local', peerID, 'is signaling', signal);
+            if (_this.server === undefined) {
+                throw new Error('server closed but received a signal');
+            }
+            var msg = [peerID, msgpack_lite_1.default.encode(signal)];
+            _this.server.send(msgpack_lite_1.default.encode(msg));
+        });
+        peer.on('data', function (data) {
+            var _a;
+            var message = msgpack_lite_1.default.decode(data);
+            if (!isPeerMessage(message)) {
+                throw new Error("invalid message received from " + peerID);
+            }
+            var weights = __1.serialization.weights.decode(message.weights);
+            console.debug('peer', peerID, 'sent weights', weights);
+            if (((_a = _this.weights.get(peer)) === null || _a === void 0 ? void 0 : _a.get(message.epoch)) !== undefined) {
+                throw new Error("weights from " + peerID + " already received");
+            }
+            _this.weights.set(peer, _this.weights.get(peer, (0, immutable_1.List)())
+                .set(message.epoch, weights));
+        });
+        peer.on('connect', function () { return console.info('connected to peer', peerID); });
+        // TODO better error handling
+        peer.on('error', function (err) { throw err; });
+        return peer;
+    };
+    /**
+     * Initialize the connection to the peers and to the other nodes.
+     */
+    Decentralized.prototype.connect = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var serverURL, _a;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        serverURL = new url_1.URL('', this.url.href);
+                        serverURL.pathname += "/deai/tasks/" + this.task.taskID;
+                        _a = this;
+                        return [4 /*yield*/, this.connectServer(serverURL)];
+                    case 1:
+                        _a.server = _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnection process when user quits the task.
+     */
+    Decentralized.prototype.disconnect = function () {
+        var _a;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_b) {
+                this.peers.forEach(function (peer) { return peer.destroy(); });
+                this.peers = (0, immutable_1.Map)();
+                (_a = this.server) === null || _a === void 0 ? void 0 : _a.close();
+                this.server = undefined;
+                return [2 /*return*/];
+            });
+        });
+    };
+    Decentralized.prototype.onRoundEndCommunication = function (updatedWeights, staleWeights, epoch, trainingInformant) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var noisyWeights, msg, encodedMsg, getWeights, timeoutError, receivedWeights;
+            var _a;
+            var _this = this;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        noisyWeights = __1.privacy.addDifferentialPrivacy(updatedWeights, staleWeights, this.task);
+                        _a = {
+                            epoch: epoch
+                        };
+                        return [4 /*yield*/, __1.serialization.weights.encode(noisyWeights)];
+                    case 1:
+                        msg = (_a.weights = _b.sent(),
+                            _a);
+                        encodedMsg = msgpack_lite_1.default.encode(msg);
+                        this.peers
+                            .filter(function (peer) { return peer.connected; })
+                            .forEach(function (peer, peerID) {
+                            trainingInformant.addMessage("Sending weights to peer " + peerID);
+                            trainingInformant.updateWhoReceivedMyModel("peer " + peerID);
+                            peer.send(encodedMsg);
+                        });
+                        getWeights = function () {
+                            return _this.weights
+                                .valueSeq()
+                                .map(function (epochesWeights) { return epochesWeights.get(epoch); });
+                        };
+                        timeoutError = new Error('timeout');
+                        return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                var interval = setInterval(function () {
+                                    var gotAllWeights = getWeights().every(function (weights) { return weights !== undefined; });
+                                    if (gotAllWeights) {
+                                        clearInterval(interval);
+                                        resolve();
+                                    }
+                                }, TICK);
+                                setTimeout(function () {
+                                    clearInterval(interval);
+                                    reject(timeoutError);
+                                }, MAX_WAIT_PER_ROUND);
+                            }).catch(function (err) {
+                                if (err !== timeoutError) {
+                                    throw err;
+                                }
+                            })];
+                    case 2:
+                        _b.sent();
+                        receivedWeights = getWeights()
+                            .filter(function (weights) { return weights !== undefined; })
+                            .toSet();
+                        // Average weights
+                        trainingInformant.addMessage('Averaging weights');
+                        trainingInformant.updateNbrUpdatesWithOthers(1);
+                        // Return the new "received" weights
+                        return [2 /*return*/, __1.aggregation.averageWeights(receivedWeights)];
+                }
+            });
+        });
+    };
+    Decentralized.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*/];
+            });
+        });
+    };
+    return Decentralized;
+}(base_1.Base));
+exports.Decentralized = Decentralized;