@epfml/discojs 0.0.1

package/dist/dataset/dataset_builder.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasetBuilder = void 0;
+var tslib_1 = require("tslib");
+var DatasetBuilder = /** @class */ (function () {
+    function DatasetBuilder(dataLoader, task) {
+        this.dataLoader = dataLoader;
+        this.task = task;
+        this.sources = [];
+        this.labelledSources = new Map();
+        this.built = false;
+    }
+    DatasetBuilder.prototype.addFiles = function (sources, label) {
+        var _this = this;
+        if (this.built) {
+            throw new Error('builder already consumed');
+        }
+        if (label === undefined) {
+            this.sources = this.sources.concat(sources);
+        }
+        else {
+            sources.forEach(function (source) { return _this.labelledSources.set(label, source); });
+        }
+    };
+    DatasetBuilder.prototype.clearFiles = function (label) {
+        if (this.built) {
+            throw new Error('builder already consumed');
+        }
+        if (label === undefined) {
+            this.sources = [];
+        }
+        else {
+            this.labelledSources.delete(label);
+        }
+    };
+    DatasetBuilder.prototype.build = function () {
+        var _a, _b;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var data, config, config;
+            return (0, tslib_1.__generator)(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        // Require that at leat one source collection is non-empty, but not both
+                        if ((this.sources.length > 0) === (this.labelledSources.size > 0)) {
+                            throw new Error('invalid sources');
+                        }
+                        if (!(this.sources.length > 0)) return [3 /*break*/, 2];
+                        config = {
+                            features: (_a = this.task.trainingInformation) === null || _a === void 0 ? void 0 : _a.inputColumns,
+                            labels: (_b = this.task.trainingInformation) === null || _b === void 0 ? void 0 : _b.outputColumns
+                        };
+                        return [4 /*yield*/, this.dataLoader.loadAll(this.sources, config)];
+                    case 1:
+                        data = _c.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        config = {
+                            labels: Array.from(this.labelledSources.keys())
+                        };
+                        return [4 /*yield*/, this.dataLoader.loadAll(Array.from(this.labelledSources.values()), config)];
+                    case 3:
+                        data = _c.sent();
+                        _c.label = 4;
+                    case 4:
+                        // TODO @s314cy: Support .csv labels for image datasets
+                        this.built = true;
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    };
+    DatasetBuilder.prototype.isBuilt = function () {
+        return this.built;
+    };
+    DatasetBuilder.prototype.size = function () {
+        return Math.max(this.sources.length, this.labelledSources.size);
+    };
+    return DatasetBuilder;
+}());
+exports.DatasetBuilder = DatasetBuilder;

package/dist/dataset/index.d.ts

@@ -0,0 +1,2 @@
+export { Dataset, DatasetBuilder } from './dataset_builder';
+export * from './data_loader';

package/dist/dataset/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasetBuilder = void 0;
+var tslib_1 = require("tslib");
+var dataset_builder_1 = require("./dataset_builder");
+Object.defineProperty(exports, "DatasetBuilder", { enumerable: true, get: function () { return dataset_builder_1.DatasetBuilder; } });
+(0, tslib_1.__exportStar)(require("./data_loader"), exports);

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export * as aggregation from './aggregation';
+export * as dataset from './dataset';
+export * as serialization from './serialization';
+export * as tasks from './tasks';
+export * as training from './training';
+export * as privacy from './privacy';
+export { Base as Client } from './client';
+export * as client from './client';
+export { AsyncBuffer } from './async_buffer';
+export { AsyncInformant } from './async_informant';
+export { Logger, ConsoleLogger } from './logging';
+export { Memory, ModelType, Empty as EmptyMemory } from './memory';
+export { ModelActor } from './model_actor';
+export { TrainingInformation, DisplayInformation, isTask, Task, isTaskID, TaskID } from './task';
+export { TrainingInformant } from './training_informant';
+export { TrainingSchemes } from './training/training_schemes';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrainingSchemes = exports.TrainingInformant = exports.isTaskID = exports.isTask = exports.ModelActor = exports.EmptyMemory = exports.ModelType = exports.Memory = exports.ConsoleLogger = exports.Logger = exports.AsyncInformant = exports.AsyncBuffer = exports.client = exports.Client = exports.privacy = exports.training = exports.tasks = exports.serialization = exports.dataset = exports.aggregation = void 0;
+var tslib_1 = require("tslib");
+exports.aggregation = (0, tslib_1.__importStar)(require("./aggregation"));
+exports.dataset = (0, tslib_1.__importStar)(require("./dataset"));
+exports.serialization = (0, tslib_1.__importStar)(require("./serialization"));
+exports.tasks = (0, tslib_1.__importStar)(require("./tasks"));
+exports.training = (0, tslib_1.__importStar)(require("./training"));
+exports.privacy = (0, tslib_1.__importStar)(require("./privacy"));
+var client_1 = require("./client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Base; } });
+exports.client = (0, tslib_1.__importStar)(require("./client"));
+var async_buffer_1 = require("./async_buffer");
+Object.defineProperty(exports, "AsyncBuffer", { enumerable: true, get: function () { return async_buffer_1.AsyncBuffer; } });
+var async_informant_1 = require("./async_informant");
+Object.defineProperty(exports, "AsyncInformant", { enumerable: true, get: function () { return async_informant_1.AsyncInformant; } });
+var logging_1 = require("./logging");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logging_1.Logger; } });
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return logging_1.ConsoleLogger; } });
+var memory_1 = require("./memory");
+Object.defineProperty(exports, "Memory", { enumerable: true, get: function () { return memory_1.Memory; } });
+Object.defineProperty(exports, "ModelType", { enumerable: true, get: function () { return memory_1.ModelType; } });
+Object.defineProperty(exports, "EmptyMemory", { enumerable: true, get: function () { return memory_1.Empty; } });
+var model_actor_1 = require("./model_actor");
+Object.defineProperty(exports, "ModelActor", { enumerable: true, get: function () { return model_actor_1.ModelActor; } });
+var task_1 = require("./task");
+Object.defineProperty(exports, "isTask", { enumerable: true, get: function () { return task_1.isTask; } });
+Object.defineProperty(exports, "isTaskID", { enumerable: true, get: function () { return task_1.isTaskID; } });
+var training_informant_1 = require("./training_informant");
+Object.defineProperty(exports, "TrainingInformant", { enumerable: true, get: function () { return training_informant_1.TrainingInformant; } });
+var training_schemes_1 = require("./training/training_schemes");
+Object.defineProperty(exports, "TrainingSchemes", { enumerable: true, get: function () { return training_schemes_1.TrainingSchemes; } });
+(0, tslib_1.__exportStar)(require("./types"), exports);

package/dist/logging/console_logger.d.ts

@@ -0,0 +1,18 @@
+import { Logger } from './logger';
+/**
+ * Same properties as Toaster but on the console
+ *
+ * @class Logger
+ */
+export declare class ConsoleLogger extends Logger {
+    /**
+     * Logs success message on the console (in green)
+     * @param {String} message - message to be displayed
+     */
+    success(message: string): void;
+    /**
+     * Logs error message on the console (in red)
+     * @param message - message to be displayed
+     */
+    error(message: string): void;
+}

package/dist/logging/console_logger.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+var tslib_1 = require("tslib");
+var chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+var logger_1 = require("./logger");
+/**
+ * Same properties as Toaster but on the console
+ *
+ * @class Logger
+ */
+var ConsoleLogger = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(ConsoleLogger, _super);
+    function ConsoleLogger() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Logs success message on the console (in green)
+     * @param {String} message - message to be displayed
+     */
+    ConsoleLogger.prototype.success = function (message) {
+        console.log(chalk_1.default.green(message));
+    };
+    /**
+     * Logs error message on the console (in red)
+     * @param message - message to be displayed
+     */
+    ConsoleLogger.prototype.error = function (message) {
+        console.log(chalk_1.default.red(message));
+    };
+    return ConsoleLogger;
+}(logger_1.Logger));
+exports.ConsoleLogger = ConsoleLogger;

package/dist/logging/index.d.ts

@@ -0,0 +1,2 @@
+export { Logger } from './logger';
+export { ConsoleLogger } from './console_logger';

package/dist/logging/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = exports.Logger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+var console_logger_1 = require("./console_logger");
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return console_logger_1.ConsoleLogger; } });

package/dist/logging/logger.d.ts

@@ -0,0 +1,12 @@
+export declare abstract class Logger {
+    /**
+     * Logs sucess message (in green)
+     * @param message - message to be displayed
+     */
+    abstract success(message: string): void;
+    /**
+     * Logs error message (in red)
+     * @param message - message to be displayed
+     */
+    abstract error(message: string): void;
+}

package/dist/logging/logger.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+var Logger = /** @class */ (function () {
+    function Logger() {
+    }
+    return Logger;
+}());
+exports.Logger = Logger;

package/dist/logging/trainer_logger.d.ts

@@ -0,0 +1,24 @@
+import * as tf from '@tensorflow/tfjs';
+import { List } from 'immutable';
+import { ConsoleLogger } from '.';
+export declare class TrainerLog {
+    epochs: List<number>;
+    trainAccuracy: List<number>;
+    validationAccuracy: List<number>;
+    loss: List<number>;
+    add(epoch: number, logs?: tf.Logs): void;
+}
+/**
+ *
+ * @class TrainerLogger
+ */
+export declare class TrainerLogger extends ConsoleLogger {
+    readonly log: TrainerLog;
+    readonly saveTrainerLog: boolean;
+    constructor(saveTrainerLog?: boolean);
+    onEpochEnd(epoch: number, logs?: tf.Logs): void;
+    /**
+     *  Display ram usage
+     */
+    ramUsage(): void;
+}

package/dist/logging/trainer_logger.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrainerLogger = exports.TrainerLog = void 0;
+var tslib_1 = require("tslib");
+var tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+var immutable_1 = require("immutable");
+var _1 = require(".");
+var TrainerLog = /** @class */ (function () {
+    function TrainerLog() {
+        this.epochs = (0, immutable_1.List)();
+        this.trainAccuracy = (0, immutable_1.List)();
+        this.validationAccuracy = (0, immutable_1.List)();
+        this.loss = (0, immutable_1.List)();
+    }
+    TrainerLog.prototype.add = function (epoch, logs) {
+        this.epochs = this.epochs.push(epoch);
+        if (logs !== undefined) {
+            this.trainAccuracy = this.trainAccuracy.push(logs.acc);
+            this.validationAccuracy = this.validationAccuracy.push(logs.val_acc);
+            this.loss = this.loss.push(logs.loss);
+        }
+    };
+    return TrainerLog;
+}());
+exports.TrainerLog = TrainerLog;
+/**
+ *
+ * @class TrainerLogger
+ */
+var TrainerLogger = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(TrainerLogger, _super);
+    // TODO: pass savaTrainerLog as false in browser, used for benchmarking
+    function TrainerLogger(saveTrainerLog) {
+        if (saveTrainerLog === void 0) { saveTrainerLog = true; }
+        var _this = _super.call(this) || this;
+        _this.saveTrainerLog = saveTrainerLog;
+        _this.log = new TrainerLog();
+        return _this;
+    }
+    TrainerLogger.prototype.onEpochEnd = function (epoch, logs) {
+        var _a, _b, _c;
+        // save logs
+        if (this.saveTrainerLog) {
+            this.log.add(epoch, logs);
+        }
+        // console output
+        var msg = "Train: " + ((_a = logs === null || logs === void 0 ? void 0 : logs.acc) !== null && _a !== void 0 ? _a : 'undefined') + "\nValidation:" + ((_b = logs === null || logs === void 0 ? void 0 : logs.val_acc) !== null && _b !== void 0 ? _b : 'undefined') + "\nLoss:" + ((_c = logs === null || logs === void 0 ? void 0 : logs.loss) !== null && _c !== void 0 ? _c : 'undefined');
+        this.success("On epoch end:\n" + msg);
+    };
+    /**
+     *  Display ram usage
+     */
+    TrainerLogger.prototype.ramUsage = function () {
+        this.success("Training RAM usage is  = " + tf.memory().numBytes * 0.000001 + " MB");
+        this.success("Number of allocated tensors  = " + tf.memory().numTensors);
+    };
+    return TrainerLogger;
+}(_1.ConsoleLogger));
+exports.TrainerLogger = TrainerLogger;

package/dist/memory/base.d.ts

@@ -0,0 +1,53 @@
+import * as tf from '@tensorflow/tfjs';
+import { TaskID } from '..';
+import { ModelType } from './model_type';
+export declare abstract class Memory {
+    /**
+     * Fetches metadata of the model.
+     * @param taskID the working model's corresponding task
+     * @param modelName the working model's file name
+     */
+    abstract getModelMetadata(type: ModelType, taskID: TaskID, modelName: string): Promise<tf.io.ModelArtifactsInfo | undefined>;
+    /**
+     * Loads the current working model and returns it as a fresh TFJS object.
+     * @param taskID the working model's corresponding task
+     * @param modelName the working model's file name
+     */
+    abstract getModel(type: ModelType, taskID: TaskID, modelName: string): Promise<tf.LayersModel>;
+    /**
+     * Loads a model from the model library into the current working model.
+     * @param taskID the saved model's corresponding task
+     * @param modelName the saved model's file name
+     */
+    abstract loadSavedModel(taskID: TaskID, modelName: string): Promise<void>;
+    /**
+     * Loads a fresh TFJS model object into the current working model.
+     * @param taskID the working model's corresponding task
+     * @param modelName the working model's file name
+     * @param model the fresh model
+     */
+    abstract updateWorkingModel(taskID: TaskID, modelName: string, model: tf.LayersModel): Promise<void>;
+    /**
+     * Adds the current working model to the model library.
+     * @param taskID the working model's corresponding task
+     * @param modelName the working model's file name
+     */
+    abstract saveWorkingModel(taskID: TaskID, modelName: string): Promise<void>;
+    /**
+     * Removes the model from the library.
+     * @param taskID the model's corresponding task
+     * @param modelName the model's file name
+     */
+    abstract deleteModel(type: ModelType, taskID: TaskID, modelName: string): Promise<void>;
+    /**
+     * Downloads a previously saved model.
+     * @param {taskID} taskID the saved model's corresponding task
+     * @param {string} modelName the saved model's file name
+     */
+    abstract downloadSavedModel(taskID: TaskID, modelName: string): Promise<void>;
+    /**
+     * @param {taskID} taskID
+     * @param {string} modelName
+     */
+    abstract contains(modelType: ModelType, taskID: TaskID, modelName: string): Promise<boolean>;
+}

package/dist/memory/base.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+var Memory = /** @class */ (function () {
+    function Memory() {
+    }
+    return Memory;
+}());
+exports.Memory = Memory;

package/dist/memory/empty.d.ts

@@ -0,0 +1,12 @@
+import * as tf from '@tensorflow/tfjs';
+import { Memory } from './base';
+export declare class Empty extends Memory {
+    getModelMetadata(): Promise<undefined>;
+    contains(): Promise<boolean>;
+    getModel(): Promise<tf.LayersModel>;
+    loadSavedModel(): Promise<void>;
+    updateWorkingModel(): Promise<void>;
+    saveWorkingModel(): Promise<void>;
+    deleteModel(): Promise<void>;
+    downloadSavedModel(): Promise<void>;
+}

package/dist/memory/empty.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Empty = void 0;
+var tslib_1 = require("tslib");
+var base_1 = require("./base");
+var Empty = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(Empty, _super);
+    function Empty() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Empty.prototype.getModelMetadata = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                return [2 /*return*/, undefined];
+            });
+        });
+    };
+    Empty.prototype.contains = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                return [2 /*return*/, false];
+            });
+        });
+    };
+    Empty.prototype.getModel = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                throw new Error('empty');
+            });
+        });
+    };
+    Empty.prototype.loadSavedModel = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                throw new Error('empty');
+            });
+        });
+    };
+    Empty.prototype.updateWorkingModel = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    Empty.prototype.saveWorkingModel = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    Empty.prototype.deleteModel = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    Empty.prototype.downloadSavedModel = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                throw new Error('empty');
+            });
+        });
+    };
+    return Empty;
+}(base_1.Memory));
+exports.Empty = Empty;

package/dist/memory/index.d.ts

@@ -0,0 +1,3 @@
+export { Empty } from './empty';
+export { Memory } from './base';
+export { ModelType } from './model_type';

package/dist/memory/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelType = exports.Memory = exports.Empty = void 0;
+var empty_1 = require("./empty");
+Object.defineProperty(exports, "Empty", { enumerable: true, get: function () { return empty_1.Empty; } });
+var base_1 = require("./base");
+Object.defineProperty(exports, "Memory", { enumerable: true, get: function () { return base_1.Memory; } });
+var model_type_1 = require("./model_type");
+Object.defineProperty(exports, "ModelType", { enumerable: true, get: function () { return model_type_1.ModelType; } });

package/dist/memory/model_type.d.ts

@@ -0,0 +1,4 @@
+export declare enum ModelType {
+    WORKING = "working",
+    SAVED = "saved"
+}

package/dist/memory/model_type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelType = void 0;
+// Type of model to store & retrieve
+var ModelType;
+(function (ModelType) {
+    ModelType["WORKING"] = "working";
+    ModelType["SAVED"] = "saved";
+})(ModelType = exports.ModelType || (exports.ModelType = {}));

package/dist/model_actor.d.ts

@@ -0,0 +1,16 @@
+import { Logger } from '@/logging/logger';
+import { Task } from '@/task';
+/**
+ * Base class for all actors of the system (e.g. trainer, tester, etc.)
+ * containing commonly used parameters
+ */
+export declare class ModelActor {
+    task: Task;
+    logger: Logger;
+    /**
+     * Constructor for Actor
+     * @param {Task} task - task on which the tasking shall be performed
+     * @param {Logger} logger - logging system (e.g. toaster)
+     */
+    constructor(task: Task, logger: Logger);
+}

package/dist/model_actor.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelActor = void 0;
+/**
+ * Base class for all actors of the system (e.g. trainer, tester, etc.)
+ * containing commonly used parameters
+ */
+var ModelActor = /** @class */ (function () {
+    /**
+     * Constructor for Actor
+     * @param {Task} task - task on which the tasking shall be performed
+     * @param {Logger} logger - logging system (e.g. toaster)
+     */
+    function ModelActor(task, logger) {
+        this.task = task;
+        this.logger = logger;
+    }
+    return ModelActor;
+}());
+exports.ModelActor = ModelActor;

package/dist/privacy.d.ts

@@ -0,0 +1,12 @@
+import { Weights } from '@/types';
+import { Task } from '@/task';
+/**
+ * Add task-parametrized Gaussian noise to and clip the weights update between the previous and current rounds.
+ * The previous round's weights are the last weights pulled from server/peers.
+ * The current round's weights are obtained after a single round of training, from the previous round's weights.
+ * @param updatedWeights weights from the current round
+ * @param staleWeights weights from the previous round
+ * @param task the task
+ * @returns the noised weights for the current round
+ */
+export declare function addDifferentialPrivacy(updatedWeights: Weights, staleWeights: Weights, task: Task): Weights;

package/dist/privacy.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDifferentialPrivacy = void 0;
+var tslib_1 = require("tslib");
+var immutable_1 = require("immutable");
+var tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+/**
+ * Add task-parametrized Gaussian noise to and clip the weights update between the previous and current rounds.
+ * The previous round's weights are the last weights pulled from server/peers.
+ * The current round's weights are obtained after a single round of training, from the previous round's weights.
+ * @param updatedWeights weights from the current round
+ * @param staleWeights weights from the previous round
+ * @param task the task
+ * @returns the noised weights for the current round
+ */
+function addDifferentialPrivacy(updatedWeights, staleWeights, task) {
+    var _a, _b;
+    var noiseScale = (_a = task.trainingInformation) === null || _a === void 0 ? void 0 : _a.noiseScale;
+    var clippingRadius = (_b = task.trainingInformation) === null || _b === void 0 ? void 0 : _b.clippingRadius;
+    var weightsDiff = (0, immutable_1.List)(updatedWeights)
+        .zip((0, immutable_1.List)(staleWeights))
+        .map(function (_a) {
+        var _b = (0, tslib_1.__read)(_a, 2), w1 = _b[0], w2 = _b[1];
+        return w1.add(-w2);
+    });
+    var newWeightsDiff;
+    if (clippingRadius !== undefined) {
+        // Frobenius norm
+        var norm_1 = Math.sqrt(weightsDiff.map(function (w) { return w.square().sum().dataSync()[0]; }).reduce(function (a, b) { return a + b; }));
+        newWeightsDiff = weightsDiff.map(function (w) {
+            var clipped = w.div(Math.max(1, norm_1 / clippingRadius));
+            if (noiseScale !== undefined) {
+                // Add clipping and noise
+                var noise = tf.randomNormal(w.shape, 0, (noiseScale * noiseScale) * (clippingRadius * clippingRadius));
+                return clipped.add(noise);
+            }
+            else {
+                // Add clipping without any noise
+                return clipped;
+            }
+        });
+    }
+    else {
+        if (noiseScale !== undefined) {
+            // Add noise without any clipping
+            newWeightsDiff = weightsDiff.map(function (w) { return tf.randomNormal(w.shape, 0, (noiseScale * noiseScale)); });
+        }
+        else {
+            return updatedWeights;
+        }
+    }
+    return (0, immutable_1.List)(staleWeights)
+        .zip(newWeightsDiff)
+        .map(function (_a) {
+        var _b = (0, tslib_1.__read)(_a, 2), w = _b[0], d = _b[1];
+        return w.add(d);
+    })
+        .toArray();
+}
+exports.addDifferentialPrivacy = addDifferentialPrivacy;

package/dist/serialization/index.d.ts

@@ -0,0 +1,2 @@
+export * as model from './model';
+export * as weights from './weights';

package/dist/serialization/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weights = exports.model = void 0;
+var tslib_1 = require("tslib");
+exports.model = (0, tslib_1.__importStar)(require("./model"));
+exports.weights = (0, tslib_1.__importStar)(require("./weights"));

package/dist/serialization/model.d.ts

@@ -0,0 +1,5 @@
+import * as tf from '@tensorflow/tfjs';
+export declare type Encoded = number[];
+export declare function isEncoded(raw: unknown): raw is Encoded;
+export declare function encode(model: tf.LayersModel): Promise<Encoded>;
+export declare function decode(encoded: Encoded): Promise<tf.LayersModel>;