@epfml/discojs 1.0.0 → 2.1.1

package/dist/core/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTasks = exports.Validator = exports.TrainingSchemes = exports.Disco = exports.EmptyMemory = exports.ModelType = exports.Memory = exports.TrainerLog = exports.ConsoleLogger = exports.Logger = exports.AsyncInformant = exports.AsyncBuffer = exports.aggregation = exports.WeightsContainer = exports.client = exports.Client = exports.informant = exports.TrainingInformant = exports.GraphInformant = exports.privacy = exports.training = exports.serialization = exports.data = exports.tf = void 0;
+var tslib_1 = require("tslib");
+exports.tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+exports.data = (0, tslib_1.__importStar)(require("./dataset"));
+exports.serialization = (0, tslib_1.__importStar)(require("./serialization"));
+exports.training = (0, tslib_1.__importStar)(require("./training"));
+exports.privacy = (0, tslib_1.__importStar)(require("./privacy"));
+var informant_1 = require("./informant");
+Object.defineProperty(exports, "GraphInformant", { enumerable: true, get: function () { return informant_1.GraphInformant; } });
+Object.defineProperty(exports, "TrainingInformant", { enumerable: true, get: function () { return informant_1.TrainingInformant; } });
+Object.defineProperty(exports, "informant", { enumerable: true, get: function () { return informant_1.informant; } });
+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 weights_1 = require("./weights");
+Object.defineProperty(exports, "WeightsContainer", { enumerable: true, get: function () { return weights_1.WeightsContainer; } });
+Object.defineProperty(exports, "aggregation", { enumerable: true, get: function () { return weights_1.aggregation; } });
+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; } });
+Object.defineProperty(exports, "TrainerLog", { enumerable: true, get: function () { return logging_1.TrainerLog; } });
+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 training_1 = require("./training");
+Object.defineProperty(exports, "Disco", { enumerable: true, get: function () { return training_1.Disco; } });
+Object.defineProperty(exports, "TrainingSchemes", { enumerable: true, get: function () { return training_1.TrainingSchemes; } });
+var validation_1 = require("./validation");
+Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return validation_1.Validator; } });
+(0, tslib_1.__exportStar)(require("./task"), exports);
+exports.defaultTasks = (0, tslib_1.__importStar)(require("./default_tasks"));
+(0, tslib_1.__exportStar)(require("./types"), exports);

package/dist/{informant → core/informant}/training_informant/base.d.ts

@@ -1,8 +1,8 @@
 import { List } from 'immutable';
-import { TaskID } from '@/task';
+import { Task } from '../../task';
 import { GraphInformant } from '../graph_informant';
 export declare abstract class Base {
-    readonly taskID: TaskID;
+    readonly task: Task;
     private readonly nbrMessagesToShow;
     private messages;
     protected readonly trainingGraphInformant: GraphInformant;
@@ -11,7 +11,7 @@ export declare abstract class Base {
     protected currentNumberOfParticipants: number;
     protected totalNumberOfParticipants: number;
     protected averageNumberOfParticipants: number;
-    constructor(taskID: TaskID, nbrMessagesToShow: number);
+    constructor(task: Task, nbrMessagesToShow?: number);
     abstract update(statistics: Record<string, number>): void;
     addMessage(msg: string): void;
     getMessages(): string[];

package/dist/{informant → core/informant}/training_informant/base.js

@@ -4,8 +4,9 @@ exports.Base = void 0;
 var immutable_1 = require("immutable");
 var graph_informant_1 = require("../graph_informant");
 var Base = /** @class */ (function () {
-    function Base(taskID, nbrMessagesToShow) {
-        this.taskID = taskID;
+    function Base(task, nbrMessagesToShow) {
+        if (nbrMessagesToShow === void 0) { nbrMessagesToShow = 10; }
+        this.task = task;
         this.nbrMessagesToShow = nbrMessagesToShow;
         // written feedback
         this.messages = (0, immutable_1.List)();

package/dist/{informant → core/informant}/training_informant/local.d.ts

@@ -1,6 +1,6 @@
-import { TaskID } from '@/task';
+import { Task } from '../../task';
 import { Base } from '.';
 export declare class LocalInformant extends Base {
-    constructor(taskID: TaskID, nbrMessagesToShow: number);
+    constructor(task: Task, nbrMessagesToShow?: number);
     update(statistics: Record<string, number>): void;
 }

package/dist/{informant → core/informant}/training_informant/local.js

@@ -5,8 +5,8 @@ var tslib_1 = require("tslib");
 var _1 = require(".");
 var LocalInformant = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(LocalInformant, _super);
-    function LocalInformant(taskID, nbrMessagesToShow) {
-        var _this = _super.call(this, taskID, nbrMessagesToShow) || this;
+    function LocalInformant(task, nbrMessagesToShow) {
+        var _this = _super.call(this, task, nbrMessagesToShow) || this;
         _this.currentNumberOfParticipants = 1;
         _this.averageNumberOfParticipants = 1;
         _this.totalNumberOfParticipants = 1;

package/dist/{memory → core/memory}/base.d.ts

@@ -5,14 +5,14 @@ export declare type Path = string;
 export interface ModelInfo {
     type?: ModelType;
     taskID: TaskID;
-    name?: string;
+    name: string;
 }
 export declare type ModelSource = ModelInfo | Path;
 export declare abstract class Memory {
     abstract getModel(source: ModelSource): Promise<tf.LayersModel>;
     abstract deleteModel(source: ModelSource): Promise<void>;
     abstract loadModel(source: ModelSource): Promise<void>;
-    abstract getModelMetadata(source: ModelSource): Promise<tf.io.ModelArtifactsInfo | undefined>;
+    abstract getModelMetadata(source: ModelSource): Promise<object | undefined>;
     abstract updateWorkingModel(source: ModelSource, model: tf.LayersModel): Promise<void>;
     abstract saveWorkingModel(source: ModelSource): Promise<void>;
     abstract downloadModel(source: ModelSource): Promise<void>;

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

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

package/dist/core/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/{privacy.d.ts → core/privacy.d.ts}

@@ -1,5 +1,4 @@
-import { Weights } from '@/types';
-import { Task } from '@/task';
+import { Task, WeightsContainer } from '.';
 /**
  * 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.
@@ -9,4 +8,4 @@ import { Task } from '@/task';
  * @param task the task
  * @returns the noised weights for the current round
  */
-export declare function addDifferentialPrivacy(updatedWeights: Weights, staleWeights: Weights, task: Task): Weights;
+export declare function addDifferentialPrivacy(updatedWeights: WeightsContainer, staleWeights: WeightsContainer, task: Task): WeightsContainer;

package/dist/{privacy.js → core/privacy.js}

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addDifferentialPrivacy = void 0;
-var tslib_1 = require("tslib");
-var immutable_1 = require("immutable");
 var _1 = require(".");
 /**
  * Add task-parametrized Gaussian noise to and clip the weights update between the previous and current rounds.
@@ -17,16 +15,11 @@ 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 weightsDiff = updatedWeights.sub(staleWeights);
     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; }));
+        var norm_1 = weightsDiff.frobeniusNorm();
         newWeightsDiff = weightsDiff.map(function (w) {
             var clipped = w.div(Math.max(1, norm_1 / clippingRadius));
             if (noiseScale !== undefined) {
@@ -49,12 +42,6 @@ function addDifferentialPrivacy(updatedWeights, staleWeights, task) {
             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();
+    return staleWeights.add(newWeightsDiff);
 }
 exports.addDifferentialPrivacy = addDifferentialPrivacy;

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

@@ -0,0 +1,5 @@
+import { WeightsContainer } from '..';
+export declare type Encoded = number[];
+export declare function isEncoded(raw: unknown): raw is Encoded;
+export declare function encode(weights: WeightsContainer): Promise<Encoded>;
+export declare function decode(encoded: Encoded): WeightsContainer;

package/dist/{serialization → core/serialization}/weights.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decode = exports.encode = exports.isEncoded = void 0;
 var tslib_1 = require("tslib");
-var __1 = require("..");
 var msgpack = (0, tslib_1.__importStar)(require("msgpack-lite"));
+var __1 = require("..");
 function isSerialized(raw) {
     if (typeof raw !== 'object' || raw === null) {
         return false;
@@ -13,7 +13,7 @@ function isSerialized(raw) {
     }
     var _a = raw, shape = _a.shape, data = _a.data;
     if (!(Array.isArray(shape) && shape.every(function (e) { return typeof e === 'number'; })) ||
-        !(data instanceof Float32Array)) {
+        !(Array.isArray(data) && data.every(function (e) { return typeof e === 'number'; }))) {
         return false;
     }
     // eslint-disable-next-line
@@ -30,17 +30,19 @@ function encode(weights) {
         var _this = this;
         return (0, tslib_1.__generator)(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, Promise.all(weights.map(function (t) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+                case 0: return [4 /*yield*/, Promise.all(weights.weights.map(function (t) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
                         var _a;
-                        return (0, tslib_1.__generator)(this, function (_b) {
-                            switch (_b.label) {
+                        var _b;
+                        return (0, tslib_1.__generator)(this, function (_c) {
+                            switch (_c.label) {
                                 case 0:
-                                    _a = {
+                                    _b = {
                                         shape: t.shape
                                     };
+                                    _a = [[]];
                                     return [4 /*yield*/, t.data()];
-                                case 1: return [2 /*return*/, (_a.data = _b.sent(),
-                                        _a)];
+                                case 1: return [2 /*return*/, (_b.data = tslib_1.__spreadArray.apply(void 0, _a.concat([tslib_1.__read.apply(void 0, [_c.sent()]), false])),
+                                        _b)];
                             }
                         });
                     }); }))];
@@ -57,6 +59,6 @@ function decode(encoded) {
     if (!(Array.isArray(raw) && raw.every(isSerialized))) {
         throw new Error('expected to decode an array of serialized weights');
     }
-    return raw.map(function (w) { return __1.tf.tensor(w.data, w.shape); });
+    return new __1.WeightsContainer(raw.map(function (w) { return __1.tf.tensor(w.data, w.shape); }));
 }
 exports.decode = decode;

package/dist/core/task/digest.d.ts

@@ -0,0 +1,5 @@
+export interface Digest {
+    algorithm: string;
+    value: string;
+}
+export declare function isDigest(raw: unknown): raw is Digest;

package/dist/core/task/digest.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDigest = void 0;
+function isDigest(raw) {
+    if (typeof raw !== 'object') {
+        return false;
+    }
+    if (raw === null) {
+        return false;
+    }
+    var _a = raw, algorithm = _a.algorithm, value = _a.value;
+    if (!(typeof algorithm === 'string' &&
+        typeof value === 'string')) {
+        return false;
+    }
+    return true;
+}
+exports.isDigest = isDigest;

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

@@ -2,11 +2,11 @@ import { Summary } from './summary';
 import { DataExample } from './data_example';
 export declare function isDisplayInformation(raw: unknown): raw is DisplayInformation;
 export interface DisplayInformation {
-    taskTitle: string;
-    summary: Summary;
-    tradeoffs: string;
-    dataFormatInformation: string;
-    dataExampleText: string;
+    taskTitle?: string;
+    summary?: Summary;
+    tradeoffs?: string;
+    dataFormatInformation?: string;
+    dataExampleText?: string;
     model?: string;
     dataExample?: DataExample[];
     headers?: string[];

package/dist/{task → core/task}/display_information.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDisplayInformation = void 0;
-var immutable_1 = require("immutable");
 var summary_1 = require("./summary");
 var data_example_1 = require("./data_example");
 function isDisplayInformation(raw) {
@@ -11,21 +10,17 @@ function isDisplayInformation(raw) {
     if (raw === null) {
         return false;
     }
-    var requiredFields = immutable_1.Set.of('dataExampleText', 'dataFormatInformation', 'summary', 'taskTitle', 'tradeoffs');
-    if (!requiredFields.isSubset(Object.keys(raw))) {
-        return false;
-    }
     var _a = raw, dataExample = _a.dataExample, dataExampleImage = _a.dataExampleImage, dataExampleText = _a.dataExampleText, dataFormatInformation = _a.dataFormatInformation, headers = _a.headers, limitations = _a.limitations, model = _a.model, summary = _a.summary, taskTitle = _a.taskTitle, tradeoffs = _a.tradeoffs;
-    if (typeof dataExampleText !== 'string' ||
-        typeof dataFormatInformation !== 'string' ||
-        typeof taskTitle !== 'string' ||
-        typeof tradeoffs !== 'string' ||
+    if (typeof taskTitle !== 'string' ||
+        (dataExampleText !== undefined && typeof dataExampleText !== 'string') ||
+        (dataFormatInformation !== undefined && typeof dataFormatInformation !== 'string') ||
+        (tradeoffs !== undefined && typeof tradeoffs !== 'string') ||
         (model !== undefined && typeof model !== 'string') ||
         (dataExampleImage !== undefined && typeof dataExampleImage !== 'string') ||
         (limitations !== undefined && typeof limitations !== 'string')) {
         return false;
     }
-    if (!(0, summary_1.isSummary)(summary)) {
+    if (summary !== undefined && !(0, summary_1.isSummary)(summary)) {
         return false;
     }
     if (dataExample !== undefined && !(Array.isArray(dataExample) &&

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

@@ -1,3 +1,6 @@
 export { isTask, Task, isTaskID, TaskID } from './task';
+export { TaskProvider, isTaskProvider } from './task_provider';
+export { isDigest, Digest } from './digest';
 export { isDisplayInformation, DisplayInformation } from './display_information';
 export { TrainingInformation } from './training_information';
+export { pushTask, fetchTasks } from './task_handler';

package/dist/core/task/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTasks = exports.pushTask = exports.isDisplayInformation = exports.isDigest = exports.isTaskProvider = exports.isTaskID = exports.isTask = void 0;
+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 task_provider_1 = require("./task_provider");
+Object.defineProperty(exports, "isTaskProvider", { enumerable: true, get: function () { return task_provider_1.isTaskProvider; } });
+var digest_1 = require("./digest");
+Object.defineProperty(exports, "isDigest", { enumerable: true, get: function () { return digest_1.isDigest; } });
+var display_information_1 = require("./display_information");
+Object.defineProperty(exports, "isDisplayInformation", { enumerable: true, get: function () { return display_information_1.isDisplayInformation; } });
+var task_handler_1 = require("./task_handler");
+Object.defineProperty(exports, "pushTask", { enumerable: true, get: function () { return task_handler_1.pushTask; } });
+Object.defineProperty(exports, "fetchTasks", { enumerable: true, get: function () { return task_handler_1.fetchTasks; } });

package/dist/core/task/model_compile_data.d.ts

@@ -0,0 +1,6 @@
+export declare function isModelCompileData(raw: unknown): raw is ModelCompileData;
+export interface ModelCompileData {
+    optimizer: string;
+    loss: string;
+    metrics: string[];
+}

package/dist/core/task/model_compile_data.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModelCompileData = void 0;
+function isModelCompileData(raw) {
+    if (typeof raw !== 'object') {
+        return false;
+    }
+    if (raw === null) {
+        return false;
+    }
+    var _a = raw, optimizer = _a.optimizer, loss = _a.loss, metrics = _a.metrics;
+    if (typeof optimizer !== 'string' ||
+        typeof loss !== 'string') {
+        return false;
+    }
+    if (!(Array.isArray(metrics) &&
+        metrics.every(function (e) { return typeof e === 'string'; }))) {
+        return false;
+    }
+    return true;
+}
+exports.isModelCompileData = isModelCompileData;

package/dist/{task → core/task}/summary.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSummary = void 0;
-var immutable_1 = require("immutable");
 function isSummary(raw) {
     if (typeof raw !== 'object') {
         return false;
@@ -9,9 +8,6 @@ function isSummary(raw) {
     if (raw === null) {
         return false;
     }
-    if (!(0, immutable_1.Set)(Object.keys(raw)).equals(immutable_1.Set.of('preview', 'overview'))) {
-        return false;
-    }
     var _a = raw, preview = _a.preview, overview = _a.overview;
     if (!(typeof preview === 'string' && typeof overview === 'string')) {
         return false;

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

@@ -1,10 +1,12 @@
 import { DisplayInformation } from './display_information';
 import { TrainingInformation } from './training_information';
+import { Digest } from './digest';
 export declare type TaskID = string;
 export declare function isTaskID(obj: unknown): obj is TaskID;
 export declare function isTask(raw: unknown): raw is Task;
 export interface Task {
     taskID: TaskID;
-    displayInformation?: DisplayInformation;
-    trainingInformation?: TrainingInformation;
+    digest?: Digest;
+    displayInformation: DisplayInformation;
+    trainingInformation: TrainingInformation;
 }

package/dist/{task → core/task}/task.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTask = exports.isTaskID = void 0;
 var display_information_1 = require("./display_information");
+var training_information_1 = require("./training_information");
+var digest_1 = require("./digest");
 function isTaskID(obj) {
     return typeof obj === 'string';
 }
@@ -13,20 +15,21 @@ function isTask(raw) {
     if (raw === null) {
         return false;
     }
-    if (!('taskID' in raw)) {
+    var _a = raw, taskID = _a.taskID, digest = _a.digest, displayInformation = _a.displayInformation, trainingInformation = _a.trainingInformation;
+    if (typeof taskID !== 'string') {
         return false;
     }
-    var _a = raw, taskID = _a.taskID, displayInformation = _a.displayInformation;
-    if (typeof taskID !== 'string') {
+    if (digest !== undefined && !(0, digest_1.isDigest)(digest)) {
+        return false;
+    }
+    if (!(0, display_information_1.isDisplayInformation)(displayInformation)) {
         return false;
     }
-    if (displayInformation !== undefined &&
-        !(0, display_information_1.isDisplayInformation)(displayInformation)) {
+    if (!(0, training_information_1.isTrainingInformation)(trainingInformation)) {
         return false;
     }
-    // TODO check for TrainingInformation
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    var _ = { taskID: taskID, displayInformation: displayInformation };
+    var _ = { taskID: taskID, displayInformation: displayInformation, trainingInformation: trainingInformation };
     return true;
 }
 exports.isTask = isTask;

package/dist/core/task/task_handler.d.ts

@@ -0,0 +1,5 @@
+import { Map } from 'immutable';
+import { tf } from '..';
+import { Task, TaskID } from './task';
+export declare function pushTask(url: URL, task: Task, model: tf.LayersModel): Promise<void>;
+export declare function fetchTasks(url: URL): Promise<Map<TaskID, Task>>;

package/dist/core/task/task_handler.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTasks = exports.pushTask = void 0;
+var tslib_1 = require("tslib");
+var immutable_1 = require("immutable");
+var axios_1 = (0, tslib_1.__importDefault)(require("axios"));
+var __1 = require("..");
+var task_1 = require("./task");
+var TASK_ENDPOINT = 'tasks';
+function pushTask(url, task, model) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var _a, _b, _c;
+        var _d;
+        return (0, tslib_1.__generator)(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    _b = (_a = axios_1.default).post;
+                    _c = [url.href + TASK_ENDPOINT];
+                    _d = {
+                        task: task
+                    };
+                    return [4 /*yield*/, __1.serialization.model.encode(model)];
+                case 1:
+                    _d.model = _e.sent();
+                    return [4 /*yield*/, __1.serialization.weights.encode(__1.WeightsContainer.from(model))];
+                case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.weights = _e.sent(),
+                            _d)]))];
+                case 3:
+                    _e.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.pushTask = pushTask;
+function fetchTasks(url) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var response, tasks;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, axios_1.default.get(url.href + TASK_ENDPOINT)];
+                case 1:
+                    response = _a.sent();
+                    tasks = response.data;
+                    if (!Array.isArray(tasks) || !tasks.every(task_1.isTask)) {
+                        throw new Error('invalid tasks response');
+                    }
+                    return [2 /*return*/, (0, immutable_1.Map)(tasks.map(function (t) { return [t.taskID, t]; }))];
+            }
+        });
+    });
+}
+exports.fetchTasks = fetchTasks;

package/dist/core/task/task_provider.d.ts

@@ -0,0 +1,6 @@
+import { tf, Task } from '..';
+export interface TaskProvider {
+    getTask: () => Task;
+    getModel: () => Promise<tf.LayersModel>;
+}
+export declare function isTaskProvider(obj: any): obj is TaskProvider;

package/dist/core/task/task_provider.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTaskProvider = void 0;
+function isTaskProvider(obj) {
+    if ('getModel' in obj && typeof obj.getModel === 'function' &&
+        'getTask' in obj && typeof obj.getTask === 'function') {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+exports.isTaskProvider = isTaskProvider;