@epfml/discojs 2.0.0 → 2.1.2-p20240506085037.0

package/dist/core/training/trainer/trainer.js

@@ -1,160 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Trainer = void 0;
-var tslib_1 = require("tslib");
-var round_tracker_1 = require("./round_tracker");
-var trainer_logger_1 = require("../../logging/trainer_logger");
-/** Abstract class whose role is to train a model with a given dataset. This can be either done
- * locally (alone) or in a distributed way with collaborators. The Trainer works as follows:
- *
- * 1. Call trainModel(dataset) to start training
- * 2. Once a batch ends, onBatchEnd is triggered, which will then call onRoundEnd once the round has ended.
- *
- * The onRoundEnd needs to be implemented to specify what actions to do when the round has ended, such as a communication step with collaborators. To know when
- * a round has ended we use the roundTracker object.
- */
-var Trainer = /** @class */ (function () {
-    /**
-     * Constructs the training manager.
-     * @param task the trained task
-     * @param trainingInformant the training informant
-     */
-    function Trainer(task, trainingInformant, memory, model) {
-        this.task = task;
-        this.trainingInformant = trainingInformant;
-        this.memory = memory;
-        this.model = model;
-        this.stopTrainingRequested = false;
-        this.trainerLogger = new trainer_logger_1.TrainerLogger();
-        var trainingInformation = task.trainingInformation;
-        if (trainingInformation === undefined) {
-            throw new Error('round duration is undefined');
-        }
-        this.trainingInformation = trainingInformation;
-        this.roundTracker = new round_tracker_1.RoundTracker(trainingInformation.roundDuration);
-    }
-    /** onBatchEnd callback, when a round ends, we call onRoundEnd (to be implemented for local and distributed instances)
-     */
-    Trainer.prototype.onBatchEnd = function (_, logs) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (logs === undefined) {
-                            return [2 /*return*/];
-                        }
-                        this.roundTracker.updateBatch();
-                        this.stopTrainModelIfRequested();
-                        if (!this.roundTracker.roundHasEnded()) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.onRoundEnd(logs.acc)];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * We update the training graph, this needs to be done on epoch end as there is no validation accuracy onBatchEnd.
-     */
-    Trainer.prototype.onEpochEnd = function (epoch, logs) {
-        this.trainerLogger.onEpochEnd(epoch, logs);
-        if (logs !== undefined && !isNaN(logs.acc) && !isNaN(logs.val_acc)) {
-            this.trainingInformant.updateTrainingGraph(this.roundDecimals(logs.acc));
-            this.trainingInformant.updateValidationGraph(this.roundDecimals(logs.val_acc));
-        }
-        else {
-            this.trainerLogger.error('onEpochEnd: NaN value');
-        }
-    };
-    /**
-     * When the training ends this function will be call
-     */
-    Trainer.prototype.onTrainEnd = function (logs) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            return (0, tslib_1.__generator)(this, function (_a) {
-                this.trainingInformant.addMessage('Training finished.');
-                return [2 /*return*/];
-            });
-        });
-    };
-    /**
-     * Request stop training to be used from the Disco instance or any class that is taking care of the trainer.
-     */
-    Trainer.prototype.stopTraining = function () {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            return (0, tslib_1.__generator)(this, function (_a) {
-                this.stopTrainingRequested = true;
-                return [2 /*return*/];
-            });
-        });
-    };
-    /**
-     * Start training the model with the given dataset
-     * @param dataset
-     */
-    Trainer.prototype.trainModel = function (dataset, valDataset) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.resetStopTrainerState();
-                        // Assign callbacks and start training
-                        return [4 /*yield*/, this.model.fitDataset(dataset, {
-                                epochs: this.trainingInformation.epochs,
-                                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) {
-                                        switch (_a.label) {
-                                            case 0: return [4 /*yield*/, this.onBatchEnd(epoch, logs)];
-                                            case 1: return [2 /*return*/, _a.sent()];
-                                        }
-                                    }); }); },
-                                    onTrainEnd: function (logs) { 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.onTrainEnd(logs)];
-                                            case 1: return [2 /*return*/, _a.sent()];
-                                        }
-                                    }); }); }
-                                }
-                            })];
-                    case 1:
-                        // Assign callbacks and start training
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Format accuracy
-     */
-    Trainer.prototype.roundDecimals = function (accuracy, decimalsToRound) {
-        if (decimalsToRound === void 0) { decimalsToRound = 2; }
-        return +(accuracy * 100).toFixed(decimalsToRound);
-    };
-    /**
-     * reset stop training state
-     */
-    Trainer.prototype.resetStopTrainerState = function () {
-        this.model.stopTraining = false;
-        this.stopTrainingRequested = false;
-    };
-    /**
-     * If stop training is requested, do so
-     */
-    Trainer.prototype.stopTrainModelIfRequested = function () {
-        if (this.stopTrainingRequested) {
-            this.model.stopTraining = true;
-            this.stopTrainingRequested = false;
-        }
-    };
-    Trainer.prototype.getTrainerLog = function () {
-        return this.trainerLogger.log;
-    };
-    return Trainer;
-}());
-exports.Trainer = Trainer;

package/dist/core/training/trainer/trainer_builder.js

@@ -1,95 +0,0 @@
-"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, info, 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 TypeError('model ID is undefined');
-                        }
-                        info = { type: __1.ModelType.WORKING, taskID: this.task.taskID, name: modelID };
-                        return [4 /*yield*/, this.memory.contains(info)];
-                    case 1: return [4 /*yield*/, ((_b.sent()) ? this.memory.getModel(info) : client.getLatestModel())];
-                    case 2:
-                        model = _b.sent();
-                        return [4 /*yield*/, this.updateModelInformation(model)];
-                    case 3: 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 TypeError('training information is undefined');
-                }
-                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/core/training/training_schemes.d.ts

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

package/dist/core/training/training_schemes.js

@@ -1,10 +0,0 @@
-"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"] = "decentralized";
-    TrainingSchemes["FEDERATED"] = "federated";
-})(TrainingSchemes = exports.TrainingSchemes || (exports.TrainingSchemes = {}));

package/dist/core/types.d.ts

@@ -1,4 +0,0 @@
-import { tf } from '.';
-export declare type Path = string;
-export declare type Weights = tf.Tensor[];
-export declare type MetadataID = string;

package/dist/core/types.js

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

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

@@ -1 +0,0 @@
-export { Validator } from './validator';

package/dist/core/validation/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = void 0;
-var validator_1 = require("./validator");
-Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return validator_1.Validator; } });

package/dist/core/validation/validator.d.ts

@@ -1,17 +0,0 @@
-import { List } from 'immutable';
-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.Data): Promise<void>;
-    getModel(): Promise<tf.LayersModel>;
-    accuracyData(): List<number>;
-    accuracy(): number;
-    visitedSamples(): number;
-}

package/dist/core/validation/validator.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = void 0;
-var tslib_1 = require("tslib");
-var immutable_1 = require("immutable");
-var __1 = require("..");
-var Validator = /** @class */ (function () {
-    function Validator(task, logger, memory, source, client) {
-        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');
-        }
-    }
-    Validator.prototype.assess = function (data) {
-        var _a, _b, _c;
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var batchSize, labels, classes, model, hits;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        batchSize = (_a = this.task.trainingInformation) === null || _a === void 0 ? void 0 : _a.batchSize;
-                        if (batchSize === undefined) {
-                            throw new TypeError('batch size is undefined');
-                        }
-                        labels = (_b = this.task.trainingInformation) === null || _b === void 0 ? void 0 : _b.LABEL_LIST;
-                        classes = (_c = labels === null || labels === void 0 ? void 0 : labels.length) !== null && _c !== void 0 ? _c : 1;
-                        return [4 /*yield*/, this.getModel()];
-                    case 1:
-                        model = _d.sent();
-                        hits = 0;
-                        return [4 /*yield*/, data.dataset.batch(batchSize).forEachAsync(function (e) {
-                                if (typeof e === 'object' && 'xs' in e && 'ys' in e) {
-                                    var xs = e.xs;
-                                    var ys = e.ys.dataSync();
-                                    var pred = model.predict(xs, { batchSize: batchSize })
-                                        .dataSync()
-                                        .map(Math.round);
-                                    _this.size += xs.shape[0];
-                                    hits += (0, immutable_1.List)(pred).zip((0, immutable_1.List)(ys))
-                                        .map(function (_a) {
-                                        var _b = (0, tslib_1.__read)(_a, 2), p = _b[0], y = _b[1];
-                                        return 1 - Math.abs(p - y);
-                                    })
-                                        .reduce(function (acc, e) { return acc + e; }) / classes;
-                                    var currentAccuracy = hits / _this.size;
-                                    _this.graphInformant.updateAccuracy(currentAccuracy);
-                                }
-                                else {
-                                    throw new TypeError('missing feature/label in dataset');
-                                }
-                            })];
-                    case 2:
-                        _d.sent();
-                        this.logger.success("Obtained validation accuracy of " + this.accuracy());
-                        this.logger.success("Visited " + this.visitedSamples() + " samples");
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Validator.prototype.getModel = function () {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var _a;
-            return (0, tslib_1.__generator)(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this.source !== undefined;
-                        if (!_a) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.memory.contains(this.source)];
-                    case 1:
-                        _a = (_b.sent());
-                        _b.label = 2;
-                    case 2:
-                        if (!_a) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.memory.getModel(this.source)];
-                    case 3: return [2 /*return*/, _b.sent()];
-                    case 4:
-                        if (!(this.client !== undefined)) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.client.getLatestModel()];
-                    case 5: return [2 /*return*/, _b.sent()];
-                    case 6: throw new Error('cannot identify model');
-                }
-            });
-        });
-    };
-    Validator.prototype.accuracyData = function () {
-        return this.graphInformant.data();
-    };
-    Validator.prototype.accuracy = function () {
-        return this.graphInformant.accuracy();
-    };
-    Validator.prototype.visitedSamples = function () {
-        return this.size;
-    };
-    return Validator;
-}());
-exports.Validator = Validator;

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

@@ -1,8 +0,0 @@
-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 declare function assertWeightsEqual(w1: WeightsContainer, w2: WeightsContainer, epsilon?: number): void;
-export {};

package/dist/core/weights/aggregation.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertWeightsEqual = exports.avgClippingWeights = exports.avg = exports.diff = exports.sum = void 0;
-var tslib_1 = require("tslib");
-var immutable_1 = require("immutable");
-var chai_1 = require("chai");
-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;
-// TODO: implement equal in WeightsContainer
-function assertWeightsEqual(w1, w2, epsilon) {
-    var e_1, _a;
-    if (epsilon === void 0) { epsilon = 0; }
-    try {
-        // Inefficient because we wait for each layer to completely load before we start loading the next layer
-        // when using tf.Tensor.dataSync() in a for loop. Could be made more efficient by using Promise.all().
-        // Not worth making more efficient, because this function is only used for testing, where tf.Tensors are small.
-        for (var _b = (0, tslib_1.__values)(w1.sub(w2).weights), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var t = _c.value;
-            chai_1.assert.strictEqual(__1.tf.lessEqual(t.abs(), epsilon).all().dataSync()[0], 1);
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-}
-exports.assertWeightsEqual = assertWeightsEqual;

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

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

package/dist/core/weights/index.js

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

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

@@ -1,64 +0,0 @@
-"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/imports.d.ts

@@ -1,2 +0,0 @@
-export * as data from './dataset/data_loader';
-export { IndexedDB } from './memory';

package/dist/imports.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedDB = exports.data = void 0;
-var tslib_1 = require("tslib");
-exports.data = (0, tslib_1.__importStar)(require("./dataset/data_loader"));
-var memory_1 = require("./memory");
-Object.defineProperty(exports, "IndexedDB", { enumerable: true, get: function () { return memory_1.IndexedDB; } });

package/dist/memory/memory.d.ts

@@ -1,26 +0,0 @@
-import { tf, Memory, Path, ModelInfo, ModelSource } from '..';
-export declare class IndexedDB extends Memory {
-    pathFor(source: ModelSource): Path;
-    infoFor(source: ModelSource): ModelInfo;
-    getModelMetadata(source: ModelSource): Promise<tf.io.ModelArtifactsInfo | undefined>;
-    contains(source: ModelSource): Promise<boolean>;
-    getModel(source: ModelSource): Promise<tf.LayersModel>;
-    deleteModel(source: ModelSource): Promise<void>;
-    loadModel(source: ModelSource): Promise<void>;
-    /**
-     * Saves the working model to the source.
-     * @param source the destination
-     * @param model the model
-     */
-    updateWorkingModel(source: ModelSource, model: tf.LayersModel): Promise<void>;
-    /**
-   * Creates a saved copy of the working model corresponding to the source.
-   * @param source the source
-   */
-    saveWorkingModel(source: ModelSource): Promise<void>;
-    /**
-   * Downloads the model corresponding to the source.
-   * @param source the source
-   */
-    downloadModel(source: ModelSource): Promise<void>;
-}