@epfml/discojs 1.0.0 → 2.1.1

package/dist/{task → core/task}/training_information.d.ts

@@ -1,32 +1,28 @@
-import { DataExample } from './data_example';
+import { Preprocessing } from '../dataset/data/preprocessing';
 import { ModelCompileData } from './model_compile_data';
+export declare function isTrainingInformation(raw: unknown): raw is TrainingInformation;
 export interface TrainingInformation {
     modelID: string;
     epochs: number;
     roundDuration: number;
     validationSplit: number;
     batchSize: number;
-    preprocessFunctions: string[];
+    preprocessingFunctions?: Preprocessing[];
     modelCompileData: ModelCompileData;
     dataType: string;
-    maxShareValue?: number;
-    minimumReadyPeers?: number;
-    decentralizedSecure?: boolean;
-    receivedMessagesThreshold?: number;
     inputColumns?: string[];
     outputColumns?: string[];
-    threshold?: number;
     IMAGE_H?: number;
     IMAGE_W?: number;
+    modelURL?: string;
     LABEL_LIST?: string[];
-    aggregateImagesById?: boolean;
     learningRate?: number;
-    NUM_CLASSES?: number;
-    csvLabels?: boolean;
-    RESIZED_IMAGE_H?: number;
-    RESIZED_IMAGE_W?: number;
-    LABEL_ASSIGNMENT?: DataExample[];
-    scheme?: string;
+    scheme: string;
     noiseScale?: number;
     clippingRadius?: number;
+    decentralizedSecure?: boolean;
+    byzantineRobustAggregator?: boolean;
+    tauPercentile?: number;
+    maxShareValue?: number;
+    minimumReadyPeers?: number;
 }

package/dist/core/task/training_information.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTrainingInformation = void 0;
+var model_compile_data_1 = require("./model_compile_data");
+function isTrainingInformation(raw) {
+    if (typeof raw !== 'object') {
+        return false;
+    }
+    if (raw === null) {
+        return false;
+    }
+    var _a = raw, dataType = _a.dataType, scheme = _a.scheme, epochs = _a.epochs, 
+    // roundDuration,
+    validationSplit = _a.validationSplit, batchSize = _a.batchSize, modelCompileData = _a.modelCompileData, modelID = _a.modelID, preprocessingFunctions = _a.preprocessingFunctions, inputColumns = _a.inputColumns, outputColumns = _a.outputColumns, IMAGE_H = _a.IMAGE_H, IMAGE_W = _a.IMAGE_W, roundDuration = _a.roundDuration, modelURL = _a.modelURL, learningRate = _a.learningRate, decentralizedSecure = _a.decentralizedSecure, maxShareValue = _a.maxShareValue, minimumReadyPeers = _a.minimumReadyPeers, LABEL_LIST = _a.LABEL_LIST, noiseScale = _a.noiseScale, clippingRadius = _a.clippingRadius;
+    if (typeof dataType !== 'string' ||
+        typeof modelID !== 'string' ||
+        typeof epochs !== 'number' ||
+        typeof batchSize !== 'number' ||
+        typeof roundDuration !== 'number' ||
+        typeof validationSplit !== 'number' ||
+        (modelURL !== undefined && typeof modelURL !== 'string') ||
+        (noiseScale !== undefined && typeof noiseScale !== 'number') ||
+        (clippingRadius !== undefined && typeof clippingRadius !== 'number') ||
+        (learningRate !== undefined && typeof learningRate !== 'number') ||
+        (decentralizedSecure !== undefined && typeof decentralizedSecure !== 'boolean') ||
+        (maxShareValue !== undefined && typeof maxShareValue !== 'number') ||
+        (minimumReadyPeers !== undefined && typeof minimumReadyPeers !== 'number')) {
+        return false;
+    }
+    // interdepences on data type
+    switch (dataType) {
+        case 'image':
+            if (typeof IMAGE_H !== 'number' || typeof IMAGE_W !== 'number') {
+                return false;
+            }
+            break;
+        case 'tabular':
+            if (!(Array.isArray(inputColumns) && inputColumns.every(function (e) { return typeof e === 'string'; }))) {
+                return false;
+            }
+            if (!(Array.isArray(outputColumns) && outputColumns.every(function (e) { return typeof e === 'string'; }))) {
+                return false;
+            }
+            break;
+    }
+    // interdepences on scheme
+    switch (scheme) {
+        case 'decentralized':
+            break;
+        case 'federated':
+            break;
+        case 'local':
+            break;
+    }
+    if (!(0, model_compile_data_1.isModelCompileData)(modelCompileData)) {
+        return false;
+    }
+    if (LABEL_LIST !== undefined && !(Array.isArray(LABEL_LIST) && LABEL_LIST.every(function (e) { return typeof e === 'string'; }))) {
+        return false;
+    }
+    if (preprocessingFunctions !== undefined && !(Array.isArray(preprocessingFunctions) && preprocessingFunctions.every(function (e) { return typeof e === 'string'; }))) {
+        return false;
+    }
+    return true;
+}
+exports.isTrainingInformation = isTrainingInformation;

package/dist/core/training/disco.d.ts

@@ -0,0 +1,23 @@
+import { Client, data, Logger, Task, TrainingInformant, TrainingSchemes, Memory } from '..';
+import { TrainerLog } from '../logging/trainer_logger';
+interface DiscoOptions {
+    client?: Client;
+    url?: string | URL;
+    scheme?: TrainingSchemes;
+    informant?: TrainingInformant;
+    logger?: Logger;
+    memory?: Memory;
+}
+export declare class Disco {
+    readonly task: Task;
+    readonly logger: Logger;
+    readonly memory: Memory;
+    private readonly client;
+    private readonly trainer;
+    constructor(task: Task, options: DiscoOptions);
+    fit(dataTuple: data.DataSplit): Promise<void>;
+    pause(): Promise<void>;
+    close(): Promise<void>;
+    logs(): Promise<TrainerLog>;
+}
+export {};

package/dist/core/training/disco.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Disco = void 0;
+var tslib_1 = require("tslib");
+var __1 = require("..");
+var trainer_builder_1 = require("./trainer/trainer_builder");
+// Handles the training loop, server communication & provides the user with feedback.
+var Disco = /** @class */ (function () {
+    // client need to be connected
+    function Disco(task, options) {
+        if (options.scheme === undefined) {
+            options.scheme = __1.TrainingSchemes[task.trainingInformation.scheme];
+        }
+        if (options.client === undefined) {
+            if (options.url === undefined) {
+                throw new Error('could not determine client from given parameters');
+            }
+            if (typeof options.url === 'string') {
+                options.url = new URL(options.url);
+            }
+            switch (options.scheme) {
+                case __1.TrainingSchemes.FEDERATED:
+                    options.client = new __1.client.federated.Client(options.url, task);
+                    break;
+                case __1.TrainingSchemes.DECENTRALIZED:
+                    options.client = new __1.client.federated.Client(options.url, task);
+                    break;
+                default:
+                    options.client = new __1.client.Local(options.url, task);
+                    break;
+            }
+        }
+        if (options.informant === undefined) {
+            switch (options.scheme) {
+                case __1.TrainingSchemes.FEDERATED:
+                    options.informant = new __1.informant.FederatedInformant(task);
+                    break;
+                case __1.TrainingSchemes.DECENTRALIZED:
+                    options.informant = new __1.informant.DecentralizedInformant(task);
+                    break;
+                default:
+                    options.informant = new __1.informant.LocalInformant(task);
+                    break;
+            }
+        }
+        if (options.logger === undefined) {
+            options.logger = new __1.ConsoleLogger();
+        }
+        if (options.memory === undefined) {
+            options.memory = new __1.EmptyMemory();
+        }
+        if (options.client.task !== task) {
+            throw new Error('client not setup for given task');
+        }
+        if (options.informant.task.taskID !== task.taskID) {
+            throw new Error('informant not setup for given task');
+        }
+        this.task = task;
+        this.client = options.client;
+        this.memory = options.memory;
+        this.logger = options.logger;
+        var trainerBuilder = new trainer_builder_1.TrainerBuilder(this.memory, this.task, options.informant);
+        this.trainer = trainerBuilder.build(this.client, options.scheme !== __1.TrainingSchemes.LOCAL);
+    }
+    Disco.prototype.fit = function (dataTuple) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var trainDataset, valDataset;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.logger.success('Thank you for your contribution. Data preprocessing has started');
+                        trainDataset = dataTuple.train.batch().preprocess();
+                        valDataset = dataTuple.validation !== undefined
+                            ? dataTuple.validation.batch().preprocess()
+                            : trainDataset;
+                        return [4 /*yield*/, this.client.connect()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.trainer];
+                    case 2: return [4 /*yield*/, (_a.sent()).trainModel(trainDataset.dataset, valDataset.dataset)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Stops the training function. Does not disconnect the client.
+    Disco.prototype.pause = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.trainer];
+                    case 1: return [4 /*yield*/, (_a.sent()).stopTraining()];
+                    case 2:
+                        _a.sent();
+                        this.logger.success('Training was successfully interrupted.');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Disco.prototype.close = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pause()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.client.disconnect()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Disco.prototype.logs = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.trainer];
+                    case 1: return [2 /*return*/, (_a.sent()).getTrainerLog()];
+                }
+            });
+        });
+    };
+    return Disco;
+}());
+exports.Disco = Disco;

package/dist/{training → core/training}/trainer/distributed_trainer.d.ts

@@ -1,5 +1,4 @@
-import * as tf from '@tensorflow/tfjs';
-import { Client, Memory, Task, TrainingInformant } from '../..';
+import { tf, Client, Memory, Task, TrainingInformant } from '../..';
 import { Trainer } from './trainer';
 /**
  * Class whose role is to train a model in a distributed way with a given dataset.

package/dist/{training → core/training}/trainer/distributed_trainer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DistributedTrainer = void 0;
 var tslib_1 = require("tslib");
+var __1 = require("../..");
 var trainer_1 = require("./trainer");
 /**
  * Class whose role is to train a model in a distributed way with a given dataset.
@@ -25,13 +26,13 @@ var DistributedTrainer = /** @class */ (function (_super) {
             return (0, tslib_1.__generator)(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        currentRoundWeights = this.model.weights.map(function (w) { return w.read(); });
-                        previousRoundWeights = this.previousRoundModel.weights.map(function (w) { return w.read(); });
+                        currentRoundWeights = __1.WeightsContainer.from(this.model);
+                        previousRoundWeights = __1.WeightsContainer.from(this.previousRoundModel);
                         return [4 /*yield*/, this.client.onRoundEndCommunication(currentRoundWeights, previousRoundWeights, this.roundTracker.round, this.trainingInformant)];
                     case 1:
                         aggregatedWeights = _a.sent();
-                        this.previousRoundModel.setWeights(currentRoundWeights);
-                        this.model.setWeights(aggregatedWeights);
+                        this.previousRoundModel.setWeights(currentRoundWeights.weights);
+                        this.model.setWeights(aggregatedWeights.weights);
                         return [4 /*yield*/, this.memory.updateWorkingModel({ taskID: this.task.taskID, name: this.trainingInformation.modelID }, this.model)];
                     case 2:
                         _a.sent();
@@ -48,7 +49,7 @@ var DistributedTrainer = /** @class */ (function (_super) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
             return (0, tslib_1.__generator)(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.client.onTrainEndCommunication(this.model.weights.map(function (w) { return w.read(); }), this.trainingInformant)];
+                    case 0: return [4 /*yield*/, this.client.onTrainEndCommunication(__1.WeightsContainer.from(this.model), this.trainingInformant)];
                     case 1:
                         _a.sent();
                         return [4 /*yield*/, _super.prototype.onTrainEnd.call(this)];

package/dist/{training → core/training}/trainer/local_trainer.d.ts

@@ -1,5 +1,5 @@
+import { tf } from '../..';
 import { Trainer } from './trainer';
-import { Logs } from '@tensorflow/tfjs';
 /** Class whose role is to locally (alone) train a model on a given dataset, without any collaborators.
  */
 export declare class LocalTrainer extends Trainer {
@@ -7,5 +7,5 @@ export declare class LocalTrainer extends Trainer {
      * Callback called every time a round is over. For local training, a round is typically an epoch
      */
     onRoundEnd(accuracy: number): Promise<void>;
-    protected onEpochEnd(epoch: number, logs?: Logs): void;
+    protected onEpochEnd(epoch: number, logs?: tf.Logs): void;
 }

package/dist/{training → core/training}/trainer/trainer.d.ts

@@ -1,5 +1,4 @@
-import * as tf from '@tensorflow/tfjs';
-import { Memory, Task, TrainingInformant, TrainingInformation } from '@/.';
+import { tf, Memory, Task, TrainingInformant, TrainingInformation } from '../..';
 import { RoundTracker } from './round_tracker';
 import { TrainerLog } from '../../logging/trainer_logger';
 /** Abstract class whose role is to train a model with a given dataset. This can be either done

package/dist/{training → core/training}/trainer/trainer.js

@@ -102,9 +102,9 @@ var Trainer = /** @class */ (function () {
                     case 0:
                         this.resetStopTrainerState();
                         // Assign callbacks and start training
-                        return [4 /*yield*/, this.model.fitDataset(dataset.batch(this.trainingInformation.batchSize), {
+                        return [4 /*yield*/, this.model.fitDataset(dataset, {
                                 epochs: this.trainingInformation.epochs,
-                                validationData: valDataset.batch(this.trainingInformation.batchSize),
+                                validationData: valDataset,
                                 callbacks: {
                                     onEpochEnd: function (epoch, logs) { return _this.onEpochEnd(epoch, logs); },
                                     onBatchEnd: function (epoch, logs) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {

package/dist/core/training/training_schemes.d.ts

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

package/dist/{training → core/training}/training_schemes.js

@@ -5,6 +5,6 @@ exports.TrainingSchemes = void 0;
 var TrainingSchemes;
 (function (TrainingSchemes) {
     TrainingSchemes["LOCAL"] = "local";
-    TrainingSchemes["DECENTRALIZED"] = "deai";
-    TrainingSchemes["FEDERATED"] = "feai";
+    TrainingSchemes["DECENTRALIZED"] = "decentralized";
+    TrainingSchemes["FEDERATED"] = "federated";
 })(TrainingSchemes = exports.TrainingSchemes || (exports.TrainingSchemes = {}));

package/dist/{validation → core/validation}/validator.d.ts

@@ -1,18 +1,15 @@
-import * as tf from '@tensorflow/tfjs';
-import { ModelActor } from '../model_actor';
-import { Task } from '@/task';
-import { Data } from '@/dataset';
-import { Logger } from '@/logging';
 import { List } from 'immutable';
-import { Client, Memory, ModelSource } from '..';
-export declare class Validator extends ModelActor {
+import { tf, data, Task, Logger, Client, Memory, ModelSource } from '..';
+export declare class Validator {
+    readonly task: Task;
+    readonly logger: Logger;
     private readonly memory;
     private readonly source?;
     private readonly client?;
     private readonly graphInformant;
     private size;
     constructor(task: Task, logger: Logger, memory: Memory, source?: ModelSource | undefined, client?: Client | undefined);
-    assess(data: Data): Promise<void>;
+    assess(data: data.Data): Promise<void>;
     getModel(): Promise<tf.LayersModel>;
     accuracyData(): List<number>;
     accuracy(): number;

package/dist/{validation → core/validation}/validator.js

@@ -2,22 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Validator = void 0;
 var tslib_1 = require("tslib");
-var model_actor_1 = require("../model_actor");
 var immutable_1 = require("immutable");
 var __1 = require("..");
-var Validator = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(Validator, _super);
+var Validator = /** @class */ (function () {
     function Validator(task, logger, memory, source, client) {
-        var _this = _super.call(this, task, logger) || this;
-        _this.memory = memory;
-        _this.source = source;
-        _this.client = client;
-        _this.graphInformant = new __1.GraphInformant();
-        _this.size = 0;
+        this.task = task;
+        this.logger = logger;
+        this.memory = memory;
+        this.source = source;
+        this.client = client;
+        this.graphInformant = new __1.GraphInformant();
+        this.size = 0;
         if (source === undefined && client === undefined) {
             throw new Error('cannot identify model');
         }
-        return _this;
     }
     Validator.prototype.assess = function (data) {
         var _a, _b, _c;
@@ -102,5 +100,5 @@ var Validator = /** @class */ (function (_super) {
         return this.size;
     };
     return Validator;
-}(model_actor_1.ModelActor));
+}());
 exports.Validator = Validator;

package/dist/core/weights/aggregation.d.ts

@@ -0,0 +1,7 @@
+import { TensorLike, WeightsContainer } from './weights_container';
+declare type WeightsLike = Iterable<TensorLike>;
+export declare function sum(weights: Iterable<WeightsLike | WeightsContainer>): WeightsContainer;
+export declare function diff(weights: Iterable<WeightsLike | WeightsContainer>): WeightsContainer;
+export declare function avg(weights: Iterable<WeightsLike | WeightsContainer>): WeightsContainer;
+export declare function avgClippingWeights(peersWeights: Iterable<WeightsLike | WeightsContainer>, currentModel: WeightsContainer, tauPercentile: number): WeightsContainer;
+export {};

package/dist/core/weights/aggregation.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.avgClippingWeights = exports.avg = exports.diff = exports.sum = void 0;
+var immutable_1 = require("immutable");
+var __1 = require("..");
+var weights_container_1 = require("./weights_container");
+function parseWeights(weights) {
+    var _a;
+    var r = (0, immutable_1.List)(weights).map(function (w) {
+        return w instanceof weights_container_1.WeightsContainer ? w : new weights_container_1.WeightsContainer(w);
+    });
+    var weightsSize = (_a = r.first()) === null || _a === void 0 ? void 0 : _a.weights.length;
+    if (weightsSize === undefined) {
+        throw new Error('no weights to work with');
+    }
+    if (r.rest().every(function (w) { return w.weights.length !== weightsSize; })) {
+        throw new Error('weights dimensions are different for some of the operands');
+    }
+    return r;
+}
+function centerWeights(weights, currentModel) {
+    return parseWeights(weights).map(function (model) { return model.mapWith(currentModel, __1.tf.sub); });
+}
+function clipWeights(modelList, normArray, tau) {
+    return modelList.map(function (weights) { return weights.map(function (w, i) { return __1.tf.prod(w, Math.min(1, tau / (normArray[i]))); }); });
+}
+function computeQuantile(array, q) {
+    var sorted = array.sort(function (a, b) { return a - b; });
+    var pos = (sorted.length - 1) * q;
+    var base = Math.floor(pos);
+    var rest = pos - base;
+    if (sorted[base + 1] !== undefined) {
+        return sorted[base] + rest * (sorted[base + 1] - sorted[base]);
+    }
+    else {
+        return sorted[base];
+    }
+}
+function reduce(weights, fn) {
+    return parseWeights(weights).reduce(function (acc, ws) {
+        return new weights_container_1.WeightsContainer(acc.weights.map(function (w, i) {
+            return fn(w, ws.get(i));
+        }));
+    });
+}
+function sum(weights) {
+    return reduce(weights, __1.tf.add);
+}
+exports.sum = sum;
+function diff(weights) {
+    return reduce(weights, __1.tf.sub);
+}
+exports.diff = diff;
+function avg(weights) {
+    var size = (0, immutable_1.List)(weights).size;
+    return sum(weights).map(function (ws) { return ws.div(size); });
+}
+exports.avg = avg;
+// See: https://arxiv.org/abs/2012.10333
+function avgClippingWeights(peersWeights, currentModel, tauPercentile) {
+    // Computing the centered peers weights with respect to the previous model aggragation
+    var centeredPeersWeights = centerWeights(peersWeights, currentModel);
+    // Computing the Matrix Norm (Frobenius Norm) of the centered peers weights
+    var normArray = Array.from(centeredPeersWeights.map(function (model) { return model.frobeniusNorm(); }));
+    // Computing the parameter tau as third percentile with respect to the norm array
+    var tau = computeQuantile(normArray, tauPercentile);
+    // Computing the centered clipped peers weights given the norm array and the parameter tau
+    var centeredMean = clipWeights(centeredPeersWeights, normArray, tau);
+    // Aggregating all centered clipped peers weights
+    return avg(centeredMean);
+}
+exports.avgClippingWeights = avgClippingWeights;

package/dist/core/weights/index.d.ts

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

package/dist/core/weights/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregation = exports.WeightsContainer = void 0;
+var tslib_1 = require("tslib");
+var weights_container_1 = require("./weights_container");
+Object.defineProperty(exports, "WeightsContainer", { enumerable: true, get: function () { return weights_container_1.WeightsContainer; } });
+exports.aggregation = (0, tslib_1.__importStar)(require("./aggregation"));

package/dist/core/weights/weights_container.d.ts

@@ -0,0 +1,19 @@
+import { tf, Weights } from '..';
+export declare type TensorLike = tf.Tensor | ArrayLike<number>;
+export declare class WeightsContainer {
+    private readonly _weights;
+    constructor(weights: Iterable<TensorLike>);
+    get weights(): Weights;
+    add(other: WeightsContainer): WeightsContainer;
+    sub(other: WeightsContainer): WeightsContainer;
+    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;
+    get(index: number): tf.Tensor | undefined;
+    frobeniusNorm(): number;
+    static of(...weights: TensorLike[]): WeightsContainer;
+    static from(model: tf.LayersModel): WeightsContainer;
+    static add(a: Iterable<TensorLike>, b: Iterable<TensorLike>): WeightsContainer;
+    static sub(a: Iterable<TensorLike>, b: Iterable<TensorLike>): WeightsContainer;
+}

package/dist/core/weights/weights_container.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeightsContainer = void 0;
+var tslib_1 = require("tslib");
+var immutable_1 = require("immutable");
+var __1 = require("..");
+var WeightsContainer = /** @class */ (function () {
+    function WeightsContainer(weights) {
+        this._weights = (0, immutable_1.List)(weights).map(function (w) {
+            return w instanceof __1.tf.Tensor ? w : __1.tf.tensor(w);
+        });
+    }
+    Object.defineProperty(WeightsContainer.prototype, "weights", {
+        get: function () {
+            return this._weights.toArray();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WeightsContainer.prototype.add = function (other) {
+        return this.mapWith(other, __1.tf.add);
+    };
+    WeightsContainer.prototype.sub = function (other) {
+        return this.mapWith(other, __1.tf.sub);
+    };
+    WeightsContainer.prototype.mapWith = function (other, fn) {
+        return new WeightsContainer(this._weights
+            .zip(other._weights)
+            .map(function (_a) {
+            var _b = (0, tslib_1.__read)(_a, 2), w1 = _b[0], w2 = _b[1];
+            return fn(w1, w2);
+        }));
+    };
+    WeightsContainer.prototype.map = function (fn) {
+        return new WeightsContainer(this._weights.map(fn));
+    };
+    WeightsContainer.prototype.reduce = function (fn) {
+        return this._weights.reduce(fn);
+    };
+    WeightsContainer.prototype.get = function (index) {
+        return this._weights.get(index);
+    };
+    WeightsContainer.prototype.frobeniusNorm = function () {
+        return Math.sqrt(this.map(function (w) { return w.square().sum(); }).reduce(function (a, b) { return a.add(b); }).dataSync()[0]);
+    };
+    WeightsContainer.of = function () {
+        var weights = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            weights[_i] = arguments[_i];
+        }
+        return new this(weights);
+    };
+    WeightsContainer.from = function (model) {
+        return new this(model.weights.map(function (w) { return w.read(); }));
+    };
+    WeightsContainer.add = function (a, b) {
+        return new this(a).add(new this(b));
+    };
+    WeightsContainer.sub = function (a, b) {
+        return new this(a).sub(new this(b));
+    };
+    return WeightsContainer;
+}());
+exports.WeightsContainer = WeightsContainer;

package/dist/dataset/data_loader/image_loader.d.ts

@@ -1,16 +1,4 @@
-import { tf } from '../..';
-import { Dataset } from '../dataset_builder';
-import { DataLoader, DataConfig, DataTuple } from './data_loader';
-/**
- * TODO @s314cy:
- * Load labels and correctly match them with their respective images, with the following constraints:
- * 1. Images are given as 1 image/1 file
- * 2. Labels are given as multiple labels/1 file, each label file can contain a different amount of labels
- */
-export declare abstract class ImageLoader<Source> extends DataLoader<Source> {
-    abstract readImageFrom(source: Source): Promise<tf.Tensor3D>;
-    load(image: Source, config?: DataConfig): Promise<Dataset>;
-    private buildDataset;
-    loadAll(images: Source[], config?: DataConfig): Promise<DataTuple>;
-    shuffle(array: number[]): void;
+import { tf, data } from '../..';
+export declare class WebImageLoader extends data.ImageLoader<File> {
+    readImageFrom(source: File): Promise<tf.Tensor3D>;
 }