@epfml/discojs 2.1.1 → 2.1.2-p20240506085037.0

package/dist/weights/aggregation.js

@@ -0,0 +1,44 @@
+import { List } from 'immutable';
+import * as tf from '@tensorflow/tfjs';
+import { WeightsContainer } from './weights_container.js';
+function parseWeights(weights) {
+    const r = List(weights).map((w) => w instanceof WeightsContainer ? w : new WeightsContainer(w));
+    const size = r.first()?.weights.length;
+    if (size === undefined) {
+        throw new Error('no weights to work with');
+    }
+    r.rest().forEach((w) => {
+        const actual = w.weights.length;
+        if (actual !== size) {
+            throw new Error(`weights dimensions are different for some of the operands: expected ${size} but found ${actual}`);
+        }
+    });
+    return r;
+}
+function reduce(weights, fn) {
+    return parseWeights(weights).reduce((acc, ws) => acc.mapWith(ws, fn));
+}
+/**
+ * Sums the given iterable of weights entry-wise.
+ * @param weights The list of weights to sum
+ * @returns The summed weights
+ */
+export function sum(weights) {
+    return reduce(weights, tf.add);
+}
+/**
+ * Computes the successive entry-wise difference between the weights of the given iterable.
+ * The operation is not commutative w.r.t. the iterable's ordering.
+ */
+export function diff(weights) {
+    return reduce(weights, tf.sub);
+}
+/**
+ * Averages the given iterable of weights entry-wise.
+ * @param weights The list of weights to average
+ * @returns The averaged weights
+ */
+export function avg(weights) {
+    const ws = List(weights);
+    return sum(ws).map((w) => w.div(ws.size));
+}

package/dist/weights/index.d.ts

@@ -0,0 +1,2 @@
+export { WeightsContainer } from './weights_container.js';
+export * as aggregation from './aggregation.js';

package/dist/weights/index.js

@@ -0,0 +1,2 @@
+export { WeightsContainer } from './weights_container.js';
+export * as aggregation from './aggregation.js';

package/dist/weights/weights_container.d.ts

@@ -0,0 +1,68 @@
+import * as tf from '@tensorflow/tfjs';
+type Weights = tf.Tensor[];
+export type TensorLike = tf.Tensor | ArrayLike<number>;
+/**
+ * Convenient wrapper object representing an immutable list of TF.js tensors.
+ */
+export declare class WeightsContainer {
+    private readonly _weights;
+    /**
+     * Constructs a weights container based on the given weights iterable.
+     * The iterable's elements can either be regular TF.js tensors or number arrays.
+     * @param weights The weights iterable to build the weights container from
+     */
+    constructor(weights: Iterable<TensorLike>);
+    get weights(): Weights;
+    /**
+     * Adds this weights container with another one. The addition is performed entry-wise.
+     * The weights containers must be of the same shape.
+     * @param other The other weights container
+     * @returns A new subtracted weights container
+     */
+    add(other: WeightsContainer): WeightsContainer;
+    /**
+     * Subtracts another weights container from this one. The subtraction is performed entry-wise.
+     * The weights containers must be of the same shape.
+     * @param other The other weights container
+     * @returns A new subtracted weights container
+     */
+    sub(other: WeightsContainer): WeightsContainer;
+    /**
+     * Multiplies this weights container with this one. The multiplication is performed entry-wise.
+     * The weights containers must be of the same shape.
+     * @param other The other weights container
+     * @returns A new multiplied weights container
+     */
+    mul(other: TensorLike | number): WeightsContainer;
+    /**
+     * Zips this weights container with another one and applies the given binary operator to the
+     * coupled entries.
+     * @param other The other weights container
+     * @param fn The binary operator
+     * @returns The mapping's result
+     */
+    mapWith(other: WeightsContainer, fn: (a: tf.Tensor, b: tf.Tensor) => tf.Tensor): WeightsContainer;
+    map(fn: (t: tf.Tensor, i: number) => tf.Tensor): WeightsContainer;
+    map(fn: (t: tf.Tensor) => tf.Tensor): WeightsContainer;
+    reduce(fn: (acc: tf.Tensor, t: tf.Tensor) => tf.Tensor): tf.Tensor;
+    /**
+     * Access the TF.js tensor located at the given index.
+     * @param index The tensor's index
+     * @returns The tensor located at the index
+     */
+    get(index: number): tf.Tensor | undefined;
+    /**
+     * Computes the weights container's Frobenius norm
+     * @returns The Frobenius norm
+     */
+    frobeniusNorm(): number;
+    concat(other: WeightsContainer): WeightsContainer;
+    equals(other: WeightsContainer, margin?: number): boolean;
+    /**
+     * Instantiates a new weights container from the given tensors or arrays of numbers.
+     * @param weights The tensors or number arrays
+     * @returns The instantiated weights container
+     */
+    static of(...weights: TensorLike[]): WeightsContainer;
+}
+export {};

package/dist/weights/weights_container.js

@@ -0,0 +1,96 @@
+import { List } from 'immutable';
+import * as tf from '@tensorflow/tfjs';
+/**
+ * Convenient wrapper object representing an immutable list of TF.js tensors.
+ */
+export class WeightsContainer {
+    _weights;
+    /**
+     * Constructs a weights container based on the given weights iterable.
+     * The iterable's elements can either be regular TF.js tensors or number arrays.
+     * @param weights The weights iterable to build the weights container from
+     */
+    constructor(weights) {
+        this._weights = List(weights).map((w) => w instanceof tf.Tensor ? w : tf.tensor(w));
+    }
+    get weights() {
+        return this._weights.toArray();
+    }
+    /**
+     * Adds this weights container with another one. The addition is performed entry-wise.
+     * The weights containers must be of the same shape.
+     * @param other The other weights container
+     * @returns A new subtracted weights container
+     */
+    add(other) {
+        return this.mapWith(other, tf.add);
+    }
+    /**
+     * Subtracts another weights container from this one. The subtraction is performed entry-wise.
+     * The weights containers must be of the same shape.
+     * @param other The other weights container
+     * @returns A new subtracted weights container
+     */
+    sub(other) {
+        return this.mapWith(other, tf.sub);
+    }
+    /**
+     * Multiplies this weights container with this one. The multiplication is performed entry-wise.
+     * The weights containers must be of the same shape.
+     * @param other The other weights container
+     * @returns A new multiplied weights container
+     */
+    mul(other) {
+        return new WeightsContainer(this._weights
+            .map(w => w.mul(other)));
+    }
+    /**
+     * Zips this weights container with another one and applies the given binary operator to the
+     * coupled entries.
+     * @param other The other weights container
+     * @param fn The binary operator
+     * @returns The mapping's result
+     */
+    mapWith(other, fn) {
+        return new WeightsContainer(this._weights
+            .zip(other._weights)
+            .map(([w1, w2]) => fn(w1, w2)));
+    }
+    map(fn) {
+        return new WeightsContainer(this._weights.map(fn));
+    }
+    reduce(fn) {
+        return this._weights.reduce(fn);
+    }
+    /**
+     * Access the TF.js tensor located at the given index.
+     * @param index The tensor's index
+     * @returns The tensor located at the index
+     */
+    get(index) {
+        return this._weights.get(index);
+    }
+    /**
+     * Computes the weights container's Frobenius norm
+     * @returns The Frobenius norm
+     */
+    frobeniusNorm() {
+        return Math.sqrt(this.map((w) => w.square().sum()).reduce((a, b) => a.add(b)).dataSync()[0]);
+    }
+    concat(other) {
+        return WeightsContainer.of(...this.weights, ...other.weights);
+    }
+    equals(other, margin = 0) {
+        return this._weights
+            .zip(other._weights)
+            .every(([w1, w2]) => w1.sub(w2).abs().lessEqual(margin).all().dataSync()[0] === 1);
+    }
+    /**
+     * Instantiates a new weights container from the given tensors or arrays of numbers.
+     * @param weights The tensors or number arrays
+     * @returns The instantiated weights container
+     */
+    static of(...weights) {
+        return new this(weights);
+    }
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@epfml/discojs",
-  "version": "2.1.1",
+  "version": "2.1.2-p20240506085037.0",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "cp ./src/core/index.browser.ts ./src/core/index.ts && tsc",
-    "build-win": "copy ..\\discojs-core\\src\\index.node.ts ..\\discojs-core\\src\\index.ts && tsc",
-    "test": "cp ./src/core/index.node.ts ./src/core/index.ts && mocha",
-    "lint": "cp ./src/core/index.browser.ts ./src/core/index.ts && npx eslint --max-warnings 0 --ignore-pattern '*.spec.ts' --ignore-pattern 'src/core' ."
+    "watch": "nodemon --ext ts --ignore dist --exec npm run",
+    "build": "tsc",
+    "lint": "npx eslint .",
+    "test": "mocha"
   },
   "repository": {
     "type": "git",
@@ -18,17 +19,25 @@
   },
   "homepage": "https://github.com/epfml/disco#readme",
   "dependencies": {
-    "msgpack-lite": "0.1",
-    "immutable": "4",
     "@tensorflow/tfjs": "4",
+    "@xenova/transformers": "2",
+    "axios": "1",
+    "immutable": "4",
+    "isomorphic-wrtc": "1",
+    "isomorphic-ws": "5",
+    "msgpack-lite": "0.1",
+    "simple-peer": "9",
     "tslib": "2",
-    "isomorphic-ws": "4",
-    "url": "0.11",
-    "@koush/wrtc": "0.5",
-    "axios": "0.27",
-    "@types/msgpack-lite": "0.1",
-    "uuid": "8",
-    "ws": "8",
-    "simple-peer": "9"
+    "ws": "8"
+  },
+  "devDependencies": {
+    "@tensorflow/tfjs-node": "4",
+    "@types/chai": "4",
+    "@types/mocha": "10",
+    "@types/simple-peer": "9",
+    "chai": "5",
+    "mocha": "10",
+    "nodemon": "3",
+    "ts-node": "10"
   }
 }

package/README.md

@@ -1,53 +0,0 @@
-# Disco.js Web Module
-
-`discojs-web` contains the browser-only code of Disco.js, based off and extending `discojs-core`.
-
-## Installation
-
-The `discojs-web` project is available as the `@epfml/discojs` NPM package, which can be installed with
-`npm i @epfml/discojs`.
-
-### 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-web` 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-web/src/core`. To build this project:
-
-```
-npm run build
-```
-
-This invokes the TypeScript compiler (`tsc`). It will output the compilation files of `discojs-web` in a `dist/` directory. To recompile from stratch, simply `rm -rf dist/` before running `npm run build` again.
-
-## Development
-
-### Contributing
-
-Contributions to `discojs-web` must only include browser-specific code. Code common to both the browser and Node.js must be added to `discojs-core` instead.
-
-As a rule of thumb, the `src/core/` directory must never be modified when modifying `discojs-web`, 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-web` 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

@@ -1,41 +0,0 @@
-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

@@ -1,97 +0,0 @@
-"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

@@ -1,20 +0,0 @@
-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

@@ -1,69 +0,0 @@
-"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

@@ -1,33 +0,0 @@
-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

@@ -1,35 +0,0 @@
-"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

@@ -1,32 +0,0 @@
-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;
-}