@epfml/discojs 2.1.1 → 2.1.2-p20240506085037.0

package/dist/default_tasks/skin_mnist.d.ts

@@ -0,0 +1,2 @@
+import type { TaskProvider } from '../index.js';
+export declare const skinMnist: TaskProvider;

package/dist/default_tasks/skin_mnist.js

@@ -0,0 +1,80 @@
+import * as tf from '@tensorflow/tfjs';
+import { data, models } from '../index.js';
+export const skinMnist = {
+    getTask() {
+        return {
+            id: 'skin_mnist',
+            displayInformation: {
+                taskTitle: 'Skin disease classification',
+                summary: {
+                    preview: 'Can you determine the skin disease from the dermatoscopic images?',
+                    overview: 'HAM10000 "Human Against Machine with 10000 training images" dataset is a large collection of multi-source dermatoscopic images of pigmented lesions from Kaggle'
+                },
+                limitations: 'The training data is limited to small images of size 28x28, similarly to the MNIST dataset.',
+                tradeoffs: 'Training success strongly depends on label distribution',
+                dataFormatInformation: '',
+                dataExampleText: 'Below you find an example',
+                dataExampleImage: 'http://walidbn.com/ISIC_0024306.jpg'
+            },
+            trainingInformation: {
+                modelID: 'skin_mnist-model',
+                epochs: 50,
+                roundDuration: 1,
+                validationSplit: 0.1,
+                batchSize: 32,
+                preprocessingFunctions: [data.ImagePreprocessing.Normalize],
+                dataType: 'image',
+                IMAGE_H: 28,
+                IMAGE_W: 28,
+                LABEL_LIST: [
+                    'Melanocytic nevi',
+                    'Melanoma',
+                    'Benign keratosis-like lesions',
+                    'Basal cell carcinoma',
+                    'Actinic keratoses',
+                    'Vascular lesions',
+                    'Dermatofibroma'
+                ],
+                scheme: 'federated',
+                noiseScale: undefined,
+                clippingRadius: undefined
+            }
+        };
+    },
+    getModel() {
+        const numClasses = 7;
+        const size = 28;
+        const model = tf.sequential();
+        model.add(tf.layers.conv2d({
+            inputShape: [size, size, 3],
+            filters: 256,
+            kernelSize: 3,
+            activation: 'relu'
+        }));
+        model.add(tf.layers.maxPooling2d({ poolSize: [2, 2] }));
+        model.add(tf.layers.dropout({ rate: 0.3 }));
+        model.add(tf.layers.conv2d({
+            filters: 128,
+            kernelSize: 3,
+            activation: 'relu'
+        }));
+        model.add(tf.layers.maxPooling2d({ poolSize: [2, 2] }));
+        model.add(tf.layers.dropout({ rate: 0.3 }));
+        model.add(tf.layers.conv2d({
+            filters: 64,
+            kernelSize: 3,
+            activation: 'relu'
+        }));
+        model.add(tf.layers.maxPooling2d({ poolSize: [2, 2] }));
+        model.add(tf.layers.dropout({ rate: 0.3 }));
+        model.add(tf.layers.flatten());
+        model.add(tf.layers.dense({ units: 32 }));
+        model.add(tf.layers.dense({ units: numClasses, activation: 'softmax' }));
+        model.compile({
+            optimizer: tf.train.adam(0.001),
+            loss: 'categoricalCrossentropy',
+            metrics: ['accuracy']
+        });
+        return Promise.resolve(new models.TFJS(model));
+    }
+};

package/dist/default_tasks/titanic.d.ts

@@ -0,0 +1,2 @@
+import type { TaskProvider } from '../index.js';
+export declare const titanic: TaskProvider;

package/dist/{core/default_tasks → default_tasks}/titanic.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.titanic = void 0;
-var tslib_1 = require("tslib");
-var __1 = require("..");
-exports.titanic = {
-    getTask: function () {
+import * as tf from '@tensorflow/tfjs';
+import { data, models } from '../index.js';
+export const titanic = {
+    getTask() {
         return {
-            taskID: 'titanic',
+            id: 'titanic',
             displayInformation: {
                 taskTitle: 'Titanic',
                 summary: {
@@ -50,17 +47,11 @@ exports.titanic = {
                 modelID: 'titanic-model',
                 epochs: 20,
                 roundDuration: 10,
-                validationSplit: 0,
+                validationSplit: 0.2,
                 batchSize: 30,
-                preprocessingFunctions: [],
-                modelCompileData: {
-                    optimizer: 'rmsprop',
-                    loss: 'binaryCrossentropy',
-                    metrics: ['accuracy']
-                },
+                preprocessingFunctions: [data.TabularPreprocessing.Sanitize],
                 dataType: 'tabular',
                 inputColumns: [
-                    'PassengerId',
                     'Age',
                     'SibSp',
                     'Parch',
@@ -70,28 +61,28 @@ exports.titanic = {
                 outputColumns: [
                     'Survived'
                 ],
-                scheme: 'Federated',
+                scheme: 'federated', // secure aggregation not yet implemented for FeAI
                 noiseScale: undefined,
                 clippingRadius: undefined
             }
         };
     },
-    getModel: function () {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var model;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                model = __1.tf.sequential();
-                model.add(__1.tf.layers.dense({
-                    inputShape: [6],
-                    units: 124,
-                    activation: 'relu',
-                    kernelInitializer: 'leCunNormal'
-                }));
-                model.add(__1.tf.layers.dense({ units: 64, activation: 'relu' }));
-                model.add(__1.tf.layers.dense({ units: 32, activation: 'relu' }));
-                model.add(__1.tf.layers.dense({ units: 1, activation: 'sigmoid' }));
-                return [2 /*return*/, model];
-            });
+    getModel() {
+        const model = tf.sequential();
+        model.add(tf.layers.dense({
+            inputShape: [5],
+            units: 124,
+            activation: 'relu',
+            kernelInitializer: 'leCunNormal'
+        }));
+        model.add(tf.layers.dense({ units: 64, activation: 'relu' }));
+        model.add(tf.layers.dense({ units: 32, activation: 'relu' }));
+        model.add(tf.layers.dense({ units: 1, activation: 'sigmoid' }));
+        model.compile({
+            optimizer: tf.train.sgd(0.001),
+            loss: 'binaryCrossentropy',
+            metrics: ['accuracy']
         });
+        return Promise.resolve(new models.TFJS(model));
     }
 };

package/dist/default_tasks/wikitext.d.ts

@@ -0,0 +1,2 @@
+import type { TaskProvider } from '../index.js';
+export declare const wikitext: TaskProvider;

package/dist/default_tasks/wikitext.js

@@ -0,0 +1,38 @@
+import { data, models } from '../index.js';
+export const wikitext = {
+    getTask() {
+        return {
+            id: 'wikitext-103',
+            displayInformation: {
+                taskTitle: 'Language modelling on wikitext',
+                summary: {
+                    preview: 'In this challenge, we ask you to do next word prediction on a dataset of Wikipedia articles.',
+                    overview: 'Wikitext-103-raw is a dataset comprising unprocessed text excerpts from Wikipedia articles, designed for tasks related to natural language processing and language modeling.'
+                },
+                limitations: 'The dataset may contain noise, inconsistencies, and unstructured content due to its raw nature, potentially posing challenges for certain NLP tasks.',
+                tradeoffs: 'The raw format may lack structured annotations and may require additional preprocessing for specific applications.',
+                dataFormatInformation: 'The dataset is organized as a large text file, with each line representing a segment of raw text from Wikipedia articles.',
+                dataExampleText: 'An example excerpt from the dataset could be: "The history of artificial intelligence dates back to ancient times, with philosophical discussions on the nature of thought and reasoning."'
+            },
+            trainingInformation: {
+                dataType: 'text',
+                modelID: 'wikitext-103-raw-model',
+                preprocessingFunctions: [data.TextPreprocessing.Tokenize, data.TextPreprocessing.LeftPadding],
+                validationSplit: 0.2, // TODO: is this used somewhere? because train, eval and test are already split in dataset
+                epochs: 5,
+                scheme: 'federated',
+                noiseScale: undefined,
+                decentralizedSecure: true,
+                minimumReadyPeers: 3,
+                maxShareValue: 100,
+                roundDuration: 10,
+                batchSize: 16,
+                tokenizer: 'Xenova/gpt2',
+                maxSequenceLength: 128
+            }
+        };
+    },
+    getModel() {
+        return Promise.resolve(new models.GPT());
+    }
+};

package/dist/index.d.ts

@@ -1,2 +1,18 @@
-export * from './core';
-export * as browser from './imports';
+export * as data from './dataset/index.js';
+export * as serialization from './serialization/index.js';
+export * as training from './training/index.js';
+export * as privacy from './privacy.js';
+export { GraphInformant } from './informant/index.js';
+export * as client from './client/index.js';
+export * as aggregator from './aggregator/index.js';
+export { WeightsContainer, aggregation } from './weights/index.js';
+export { AsyncInformant } from './async_informant.js';
+export { Logger, ConsoleLogger } from './logging/index.js';
+export { Memory, ModelType, type ModelInfo, type Path, type ModelSource, Empty as EmptyMemory } from './memory/index.js';
+export { Disco, RoundLogs } from './training/index.js';
+export { Validator } from './validation/index.js';
+export { Model, EpochLogs } from './models/index.js';
+export * as models from './models/index.js';
+export * from './task/index.js';
+export * as defaultTasks from './default_tasks/index.js';
+export * from './types.js';

package/dist/index.js

@@ -1,6 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.browser = void 0;
-var tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./core"), exports);
-exports.browser = (0, tslib_1.__importStar)(require("./imports"));
+export * as data from './dataset/index.js';
+export * as serialization from './serialization/index.js';
+export * as training from './training/index.js';
+export * as privacy from './privacy.js';
+export { GraphInformant } from './informant/index.js';
+export * as client from './client/index.js';
+export * as aggregator from './aggregator/index.js';
+export { WeightsContainer, aggregation } from './weights/index.js';
+export { AsyncInformant } from './async_informant.js';
+export { ConsoleLogger } from './logging/index.js';
+export { Memory, ModelType, Empty as EmptyMemory } from './memory/index.js';
+export { Disco } from './training/index.js';
+export { Validator } from './validation/index.js';
+export { Model } from './models/index.js';
+export * as models from './models/index.js';
+export * from './task/index.js';
+export * as defaultTasks from './default_tasks/index.js';
+export * from './types.js';

package/dist/{core/informant → informant}/graph_informant.d.ts

@@ -1,4 +1,4 @@
-import { List } from 'immutable';
+import { type List } from 'immutable';
 export declare class GraphInformant {
     static readonly NB_EPOCHS_ON_GRAPH = 10;
     private currentAccuracy;

package/dist/informant/graph_informant.js

@@ -0,0 +1,20 @@
+import { Repeat } from 'immutable';
+export class GraphInformant {
+    static NB_EPOCHS_ON_GRAPH = 10;
+    currentAccuracy;
+    accuracyDataSeries;
+    constructor() {
+        this.currentAccuracy = 0;
+        this.accuracyDataSeries = Repeat(0, GraphInformant.NB_EPOCHS_ON_GRAPH).toList();
+    }
+    updateAccuracy(accuracy) {
+        this.accuracyDataSeries = this.accuracyDataSeries.shift().push(accuracy);
+        this.currentAccuracy = accuracy;
+    }
+    data() {
+        return this.accuracyDataSeries;
+    }
+    accuracy() {
+        return this.currentAccuracy;
+    }
+}

package/dist/informant/index.d.ts

@@ -0,0 +1 @@
+export { GraphInformant } from './graph_informant.js';

package/dist/informant/index.js

@@ -0,0 +1 @@
+export { GraphInformant } from './graph_informant.js';

package/dist/{core/logging → logging}/console_logger.d.ts

@@ -1,10 +1,10 @@
-import { Logger } from './logger';
+import { Logger } from "./logger.js";
 /**
  * Same properties as Toaster but on the console
  *
  * @class Logger
  */
-export declare class ConsoleLogger extends Logger {
+export declare class ConsoleLogger implements Logger {
     /**
      * Logs success message on the console (in green)
      * @param {String} message - message to be displayed

package/dist/logging/console_logger.js

@@ -0,0 +1,22 @@
+import chalk from "chalk";
+/**
+ * Same properties as Toaster but on the console
+ *
+ * @class Logger
+ */
+export class ConsoleLogger {
+    /**
+     * Logs success message on the console (in green)
+     * @param {String} message - message to be displayed
+     */
+    success(message) {
+        console.log(chalk.green(message));
+    }
+    /**
+     * Logs error message on the console (in red)
+     * @param message - message to be displayed
+     */
+    error(message) {
+        console.error(chalk.red(message));
+    }
+}

package/dist/logging/index.d.ts

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

package/dist/logging/index.js

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

package/dist/{core/logging → logging}/logger.d.ts

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

package/dist/logging/logger.js

@@ -0,0 +1 @@
+export {};

package/dist/memory/base.d.ts

@@ -0,0 +1,119 @@
+import type { Model, TaskID } from '../index.js';
+import type { ModelType } from './model_type.js';
+/**
+ * Model path which uniquely identifies a model in memory.
+ */
+export type Path = string;
+/**
+ * Model information which uniquely identifies a model in memory.
+ */
+export interface ModelInfo {
+    /**
+     * The model's type: "working" or "saved" model.
+     */
+    type?: ModelType;
+    /**
+     * The model's version, to allow for multiple saved models of a same task without
+     * causing id conflicts
+     */
+    version?: number;
+    /**
+     * The model's corresponding task
+     */
+    taskID: TaskID;
+    /**
+     * The model's name
+     */
+    name: string;
+}
+/**
+ * A model source uniquely identifies a model stored in memory.
+ */
+export type ModelSource = ModelInfo | Path;
+/**
+ * Represents a model memory system, providing functions to fetch, save, delete and update models.
+ * Stored models can either be a model currently being trained ("working model") or a regular model
+ * saved in memory ("saved model"). There can only be a single working model for a given task.
+ */
+export declare abstract class Memory {
+    /**
+     * Fetches the model identified by the given model source.
+     * @param source The model source
+     * @returns The model
+     */
+    abstract getModel(source: ModelSource): Promise<Model>;
+    /**
+     * Removes the model identified by the given model source from memory.
+     * @param source The model source
+     * @returns The model
+     */
+    abstract deleteModel(source: ModelSource): Promise<void>;
+    /**
+     * Replaces the corresponding working model with the saved model identified by the given model source.
+     * @param source The model source
+     */
+    abstract loadModel(source: ModelSource): Promise<void>;
+    /**
+     * Fetches metadata for the model identified by the given model source.
+     * If the model does not exist in memory, returns undefined.
+     * @param source The model source
+     * @returns The model metadata or undefined
+     */
+    abstract getModelMetadata(source: ModelSource): Promise<object | undefined>;
+    /**
+     * Replaces the working model identified by the given source with the newly provided model.
+     * @param source The model source
+     * @param model The new model
+     */
+    abstract updateWorkingModel(source: ModelSource, model: Model): Promise<void>;
+    /**
+     * Creates a saved model copy from the working model identified by the given model source.
+     * Returns the saved model's path.
+     * @param source The model source
+     * @returns The saved model's path
+     */
+    abstract saveWorkingModel(source: ModelSource): Promise<Path | undefined>;
+    /**
+     * Saves the newly provided model to the given model source.
+     * Returns the saved model's path
+     * @param source The model source
+     * @param model The new model
+     * @returns The saved model's path
+     */
+    abstract saveModel(source: ModelSource, model: Model): Promise<Path | undefined>;
+    /**
+     * Moves the model identified by the model source to a file system. This is platform-dependent.
+     * @param source The model source
+     */
+    abstract downloadModel(source: ModelSource): Promise<void>;
+    /**
+     * Checks whether the model memory contains the model identified by the given source.
+     * @param source The model source
+     * @returns True if the memory contains the model, false otherwise
+     */
+    abstract contains(source: ModelSource): Promise<boolean>;
+    /**
+     * Computes the path in memory corresponding to the given model source, be it a path or model information.
+     * This is used to easily switch between model path and information, which are both unique model identifiers
+     * with a one-to-one correspondance. Returns undefined instead if no path could be inferred from the given
+     * model source.
+     * @param source The model source
+     * @returns The model path
+     */
+    abstract pathFor(source: ModelSource): Path | undefined;
+    /**
+     * Computes the model information corresponding to the given model source, be it a path or model information.
+     * This is used to easily switch between model path and information, which are both unique model identifiers
+     * with a one-to-one correspondance. Returns undefined instead if no unique model information could be inferred
+     * from the given model source.
+     * @param source The model source
+     * @returns The model information
+     */
+    abstract infoFor(source: ModelSource): ModelInfo | undefined;
+    /**
+     * Computes the lowest version a model source can have without conflicting with model versions currently in memory.
+     * @param source The model source
+     * @returns The duplicated model source
+     */
+    abstract duplicateSource(source: ModelSource): Promise<ModelSource | undefined>;
+}

package/dist/memory/base.js

@@ -0,0 +1,9 @@
+// only used browser-side
+// TODO: replace IO type
+/**
+ * Represents a model memory system, providing functions to fetch, save, delete and update models.
+ * Stored models can either be a model currently being trained ("working model") or a regular model
+ * saved in memory ("saved model"). There can only be a single working model for a given task.
+ */
+export class Memory {
+}

package/dist/memory/empty.d.ts

@@ -0,0 +1,20 @@
+import type { Model } from '../index.js';
+import type { ModelInfo, Path } from './base.js';
+import { Memory } from './base.js';
+/**
+ * Represents an empty model memory.
+ */
+export declare class Empty extends Memory {
+    getModelMetadata(): Promise<undefined>;
+    contains(): Promise<boolean>;
+    getModel(): Promise<Model>;
+    loadModel(): Promise<void>;
+    updateWorkingModel(): Promise<void>;
+    saveWorkingModel(): Promise<undefined>;
+    saveModel(): Promise<undefined>;
+    deleteModel(): Promise<void>;
+    downloadModel(): Promise<void>;
+    pathFor(): Path;
+    infoFor(): ModelInfo;
+    duplicateSource(): Promise<undefined>;
+}

package/dist/memory/empty.js

@@ -0,0 +1,43 @@
+import { Memory } from './base.js';
+/**
+ * Represents an empty model memory.
+ */
+export class Empty extends Memory {
+    getModelMetadata() {
+        return Promise.resolve(undefined);
+    }
+    contains() {
+        return Promise.resolve(false);
+    }
+    getModel() {
+        return Promise.reject(new Error('empty'));
+    }
+    loadModel() {
+        return Promise.reject(new Error('empty'));
+    }
+    updateWorkingModel() {
+        // nothing to do
+        return Promise.resolve();
+    }
+    saveWorkingModel() {
+        return Promise.resolve(undefined);
+    }
+    saveModel() {
+        return Promise.resolve(undefined);
+    }
+    async deleteModel() {
+        // nothing to do
+    }
+    downloadModel() {
+        return Promise.reject(new Error('empty'));
+    }
+    pathFor() {
+        throw new Error('empty');
+    }
+    infoFor() {
+        throw new Error('empty');
+    }
+    duplicateSource() {
+        return Promise.resolve(undefined);
+    }
+}

package/dist/memory/index.d.ts

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

package/dist/memory/index.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedDB = void 0;
-var memory_1 = require("./memory");
-Object.defineProperty(exports, "IndexedDB", { enumerable: true, get: function () { return memory_1.IndexedDB; } });
+export { Empty } from './empty.js';
+export { Memory } from './base.js';
+export { ModelType } from './model_type.js';

package/dist/memory/model_type.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Type of models stored in memory. Stored models can either be a model currently
+ * being trained ("working model") or a regular model saved in memory ("saved model").
+ * There can only be a single working model for a given task.
+ */
+export declare enum ModelType {
+    WORKING = "working",
+    SAVED = "saved"
+}

package/dist/memory/model_type.js

@@ -0,0 +1,10 @@
+/**
+ * Type of models stored in memory. Stored models can either be a model currently
+ * being trained ("working model") or a regular model saved in memory ("saved model").
+ * There can only be a single working model for a given task.
+ */
+export var ModelType;
+(function (ModelType) {
+    ModelType["WORKING"] = "working";
+    ModelType["SAVED"] = "saved";
+})(ModelType || (ModelType = {}));

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

@@ -1,4 +1,4 @@
-import { Task, WeightsContainer } from '.';
+import type { Task, WeightsContainer } from './index.js';
 /**
  * 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.