@epfml/discojs 0.0.1

package/dist/training/trainer/trainer_builder.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrainerBuilder = void 0;
+var tslib_1 = require("tslib");
+var __1 = require("../..");
+var distributed_trainer_1 = require("./distributed_trainer");
+var local_trainer_1 = require("./local_trainer");
+/**
+ * A class that helps build the Trainer and auxiliary classes.
+ */
+var TrainerBuilder = /** @class */ (function () {
+    function TrainerBuilder(memory, task, trainingInformant) {
+        this.memory = memory;
+        this.task = task;
+        this.trainingInformant = trainingInformant;
+    }
+    /**
+     * Builds a trainer object.
+     *
+     * @param client client to share weights with (either distributed or federated)
+     * @param distributed whether to build a distributed or local trainer
+     * @returns
+     */
+    TrainerBuilder.prototype.build = function (client, distributed) {
+        if (distributed === void 0) { distributed = false; }
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var model;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getModel(client)];
+                    case 1:
+                        model = _a.sent();
+                        if (distributed) {
+                            return [2 /*return*/, new distributed_trainer_1.DistributedTrainer(this.task, this.trainingInformant, this.memory, model, model, client)];
+                        }
+                        else {
+                            return [2 /*return*/, new local_trainer_1.LocalTrainer(this.task, this.trainingInformant, this.memory, model)];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * If a model exists in memory, laod it, otherwise load model from server
+     * @returns
+     */
+    TrainerBuilder.prototype.getModel = function (client) {
+        var _a;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var modelID, modelExistsInMemory, model;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        modelID = (_a = this.task.trainingInformation) === null || _a === void 0 ? void 0 : _a.modelID;
+                        if (modelID === undefined) {
+                            throw new Error('undefined model ID');
+                        }
+                        return [4 /*yield*/, this.memory.getModelMetadata(__1.ModelType.WORKING, this.task.taskID, modelID)];
+                    case 1:
+                        modelExistsInMemory = _b.sent();
+                        if (!(modelExistsInMemory !== undefined)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.memory.getModel(__1.ModelType.WORKING, this.task.taskID, modelID)];
+                    case 2:
+                        model = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, client.getLatestModel()];
+                    case 4:
+                        model = _b.sent();
+                        _b.label = 5;
+                    case 5: return [4 /*yield*/, this.updateModelInformation(model)];
+                    case 6: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    TrainerBuilder.prototype.updateModelInformation = function (model) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var info;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                // Continue local training from previous epoch checkpoint
+                if (model.getUserDefinedMetadata() === undefined) {
+                    model.setUserDefinedMetadata({ epoch: 0 });
+                }
+                info = this.task.trainingInformation;
+                if (info === undefined) {
+                    throw new Error('undefined training information');
+                }
+                model.compile(info.modelCompileData);
+                if (info.learningRate !== undefined) {
+                    // TODO: Not the right way to change learningRate and hence we cast to any
+                    // the right way is to construct the optimiser and pass learningRate via
+                    // argument.
+                    model.optimizer.learningRate = info.learningRate;
+                }
+                return [2 /*return*/, model];
+            });
+        });
+    };
+    return TrainerBuilder;
+}());
+exports.TrainerBuilder = TrainerBuilder;

package/dist/training/training_schemes.d.ts

@@ -0,0 +1,5 @@
+export declare enum TrainingSchemes {
+    LOCAL = "local",
+    DECENTRALIZED = "deai",
+    FEDERATED = "feai"
+}

package/dist/training/training_schemes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrainingSchemes = void 0;
+/* eslint-disable no-unused-vars */
+var TrainingSchemes;
+(function (TrainingSchemes) {
+    TrainingSchemes["LOCAL"] = "local";
+    TrainingSchemes["DECENTRALIZED"] = "deai";
+    TrainingSchemes["FEDERATED"] = "feai";
+})(TrainingSchemes = exports.TrainingSchemes || (exports.TrainingSchemes = {}));

package/dist/training_informant.d.ts

@@ -0,0 +1,88 @@
+import { List, Set } from 'immutable';
+import { TaskID } from '.';
+import { TrainingSchemes } from './training/training_schemes';
+/**
+ * Class that collects information about the status of the training-loop of the model.
+ */
+export declare class TrainingInformant {
+    private readonly nbrMessagesToShow;
+    readonly taskID: TaskID;
+    readonly taskTrainingScheme: TrainingSchemes;
+    whoReceivedMyModel: Set<unknown>;
+    nbrUpdatesWithOthers: number;
+    waitingTime: number;
+    nbrWeightRequests: number;
+    messages: List<unknown>;
+    currentRound: number;
+    currentNumberOfParticipants: number;
+    totalNumberOfParticipants: number;
+    averageNumberOfParticipants: number;
+    validationAccuracyChart: unknown;
+    validationAccuracy: number;
+    trainingAccuracyChart: unknown;
+    trainingAccuracy: number;
+    displayHeatmap: boolean;
+    currentValidationAccuracy: number;
+    validationAccuracyDataSerie: List<number>;
+    currentTrainingAccuracy: number;
+    trainingAccuracyDataSerie: List<number>;
+    weightsIn: number;
+    weightsOut: number;
+    /**
+     *
+     * @param nbrMessagesToShow the number of messages to be kept to inform the users about status of communication with other peers.
+     * @param taskID the task's name.
+     */
+    constructor(nbrMessagesToShow: number, taskID: TaskID, taskTrainingScheme: TrainingSchemes);
+    /**
+     * Updates the set of peers who received my model.
+     * @param {String} peerName the peer's name to whom I recently shared my model to.
+     */
+    updateWhoReceivedMyModel(peerName: string): void;
+    /**
+     * Updates the number of updates I did with other peers.
+     * @param {Number} nbrUpdates the number of updates I did thanks to other peers contribution since the last update of the parameter.
+     */
+    updateNbrUpdatesWithOthers(nbrUpdates: number): void;
+    /**
+     * Updates the time I waited to receive weights.
+     * @param {Number} time
+     */
+    updateWaitingTime(time: number): void;
+    /**
+     * Updates the number of weights request I received.
+     * @param {Number} nbrRequests the number of weight requests I received since the last update of the parameter.
+     */
+    updateNbrWeightsRequests(nbrRequests: number): void;
+    /**
+     * Add a new message to the message list.
+     * @param {String} msg a message.
+     */
+    addMessage(msg: string): void;
+    /**
+     * Update the server statistics with the JSON received from the server
+     * For now it's just the JSON, but we might want to keep it as a dictionnary
+     * @param {any} receivedStatistics statistics received from the server.
+     */
+    updateWithServerStatistics(receivedStatistics: Record<string, number>): void;
+    /**
+     *  Updates the data to be displayed on the validation accuracy graph.
+     * @param {Number} validationAccuracy the current validation accuracy of the model
+     */
+    updateValidationAccuracyGraph(validationAccuracy: number): void;
+    /**
+     * Returns wether or not the Task's training scheme is Decentralized
+     * @returns Boolean value
+     */
+    isTaskTrainingSchemeDecentralized(): boolean;
+    /**
+     * Returns wether or not the Task's training scheme is Federated
+     * @returns Boolean value
+     */
+    isTaskTrainingSchemeFederated(): boolean;
+    /**
+     *  Updates the data to be displayed on the training accuracy graph.
+     * @param {Number} trainingAccuracy the current training accuracy of the model
+     */
+    updateTrainingAccuracyGraph(trainingAccuracy: number): void;
+}

package/dist/training_informant.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrainingInformant = void 0;
+var immutable_1 = require("immutable");
+var training_schemes_1 = require("./training/training_schemes");
+var nbEpochsOnGraphs = 10;
+/**
+ * Class that collects information about the status of the training-loop of the model.
+ */
+var TrainingInformant = /** @class */ (function () {
+    /**
+     *
+     * @param nbrMessagesToShow the number of messages to be kept to inform the users about status of communication with other peers.
+     * @param taskID the task's name.
+     */
+    function TrainingInformant(nbrMessagesToShow, taskID, taskTrainingScheme) {
+        this.nbrMessagesToShow = nbrMessagesToShow;
+        this.taskID = taskID;
+        this.taskTrainingScheme = taskTrainingScheme;
+        // Decentralized Informations
+        // number of people with whom I've shared my model
+        this.whoReceivedMyModel = (0, immutable_1.Set)();
+        // message feedback from peer-to-peer training
+        this.messages = (0, immutable_1.List)();
+        this.validationAccuracyDataSerie = (0, immutable_1.Repeat)(0, nbEpochsOnGraphs).toList();
+        this.trainingAccuracyDataSerie = (0, immutable_1.Repeat)(0, nbEpochsOnGraphs).toList();
+        this.weightsIn = 0;
+        this.weightsOut = 0;
+        // how many times the model has been averaged with someone's else model
+        this.nbrUpdatesWithOthers = 0;
+        // how much time I've been waiting for a model
+        this.waitingTime = 0;
+        // number of weight requests I've responded to
+        this.nbrWeightRequests = 0;
+        // statistics received from the server
+        this.currentRound = 0;
+        this.currentNumberOfParticipants = 0;
+        this.totalNumberOfParticipants = 0;
+        this.averageNumberOfParticipants = 0;
+        // validation accuracy chart
+        this.validationAccuracyChart = null; // new TrainingChart("validationAccuracy_".concat(taskID), "Validation Accuracy")
+        this.validationAccuracy = 0;
+        // training accuracy chart
+        this.trainingAccuracyChart = null; // new TrainingChart("trainingAccuracy_".concat(taskID), "Training Accuracy")
+        this.trainingAccuracy = 0;
+        // is the model using Interoperability (default to false)
+        this.displayHeatmap = false;
+        // default values for the validation and training charts
+        this.currentValidationAccuracy = 0;
+        this.currentTrainingAccuracy = 0;
+    }
+    /**
+     * Updates the set of peers who received my model.
+     * @param {String} peerName the peer's name to whom I recently shared my model to.
+     */
+    TrainingInformant.prototype.updateWhoReceivedMyModel = function (peerName) {
+        this.whoReceivedMyModel = this.whoReceivedMyModel.add(peerName);
+    };
+    /**
+     * Updates the number of updates I did with other peers.
+     * @param {Number} nbrUpdates the number of updates I did thanks to other peers contribution since the last update of the parameter.
+     */
+    TrainingInformant.prototype.updateNbrUpdatesWithOthers = function (nbrUpdates) {
+        this.nbrUpdatesWithOthers += nbrUpdates;
+    };
+    /**
+     * Updates the time I waited to receive weights.
+     * @param {Number} time
+     */
+    TrainingInformant.prototype.updateWaitingTime = function (time) {
+        this.waitingTime += time;
+    };
+    /**
+     * Updates the number of weights request I received.
+     * @param {Number} nbrRequests the number of weight requests I received since the last update of the parameter.
+     */
+    TrainingInformant.prototype.updateNbrWeightsRequests = function (nbrRequests) {
+        this.nbrWeightRequests += nbrRequests;
+    };
+    /**
+     * Add a new message to the message list.
+     * @param {String} msg a message.
+     */
+    TrainingInformant.prototype.addMessage = function (msg) {
+        if (this.messages.size >= this.nbrMessagesToShow) {
+            this.messages = this.messages.shift();
+        }
+        this.messages = this.messages.push(msg);
+    };
+    /**
+     * Update the server statistics with the JSON received from the server
+     * For now it's just the JSON, but we might want to keep it as a dictionnary
+     * @param {any} receivedStatistics statistics received from the server.
+     */
+    TrainingInformant.prototype.updateWithServerStatistics = function (receivedStatistics) {
+        this.currentRound = receivedStatistics.round;
+        this.currentNumberOfParticipants = receivedStatistics.currentNumberOfParticipants;
+        this.totalNumberOfParticipants = receivedStatistics.totalNumberOfParticipants;
+        this.averageNumberOfParticipants = receivedStatistics.averageNumberOfParticipants;
+    };
+    /**
+     *  Updates the data to be displayed on the validation accuracy graph.
+     * @param {Number} validationAccuracy the current validation accuracy of the model
+     */
+    TrainingInformant.prototype.updateValidationAccuracyGraph = function (validationAccuracy) {
+        this.validationAccuracyDataSerie =
+            this.validationAccuracyDataSerie.shift().push(validationAccuracy);
+        this.currentValidationAccuracy = validationAccuracy;
+    };
+    /**
+     * Returns wether or not the Task's training scheme is Decentralized
+     * @returns Boolean value
+     */
+    TrainingInformant.prototype.isTaskTrainingSchemeDecentralized = function () {
+        return this.taskTrainingScheme === training_schemes_1.TrainingSchemes.DECENTRALIZED;
+    };
+    /**
+     * Returns wether or not the Task's training scheme is Federated
+     * @returns Boolean value
+     */
+    TrainingInformant.prototype.isTaskTrainingSchemeFederated = function () {
+        return this.taskTrainingScheme === training_schemes_1.TrainingSchemes.FEDERATED;
+    };
+    /**
+     *  Updates the data to be displayed on the training accuracy graph.
+     * @param {Number} trainingAccuracy the current training accuracy of the model
+     */
+    TrainingInformant.prototype.updateTrainingAccuracyGraph = function (trainingAccuracy) {
+        this.trainingAccuracyDataSerie =
+            this.trainingAccuracyDataSerie.shift().push(trainingAccuracy);
+        this.currentTrainingAccuracy = trainingAccuracy;
+    };
+    return TrainingInformant;
+}());
+exports.TrainingInformant = TrainingInformant;

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+import * as tf from '@tensorflow/tfjs';
+export declare type Path = string;
+export declare type Weights = tf.Tensor[];
+export declare type MetadataID = string;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@epfml/discojs",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/epfml/disco.git"
+  },
+  "bugs": {
+    "url": "https://github.com/epfml/disco/issues"
+  },
+  "homepage": "https://github.com/epfml/disco#readme",
+  "dependencies": {
+    "@tensorflow/tfjs": "3",
+    "axios": "0.27",
+    "immutable": "4",
+    "isomorphic-ws": "4",
+    "lodash": "4",
+    "msgpack-lite": "0.1",
+    "simple-peer": "9",
+    "tslib": "2",
+    "url": "0.11",
+    "uuid": "8",
+    "ws": "8"
+  },
+  "devDependencies": {
+    "@tensorflow/tfjs-node": "3",
+    "@types/chai": "4",
+    "@types/lodash": "4",
+    "@types/mocha": "9",
+    "@types/msgpack-lite": "0.1",
+    "@types/simple-peer": "9",
+    "@types/uuid": "8",
+    "@typescript-eslint/eslint-plugin": "4",
+    "@typescript-eslint/parser": "4",
+    "chai": "4",
+    "eslint": "7",
+    "eslint-config-standard-with-typescript": "21",
+    "mocha": "9",
+    "ts-node": "10",
+    "typescript": "<4.5.0"
+  }
+}