@epfml/discojs 2.0.0 → 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/default_tasks/titanic.js

@@ -0,0 +1,88 @@
+import * as tf from '@tensorflow/tfjs';
+import { data, models } from '../index.js';
+export const titanic = {
+    getTask() {
+        return {
+            id: 'titanic',
+            displayInformation: {
+                taskTitle: 'Titanic',
+                summary: {
+                    preview: "Test our platform by using a publicly available <b>tabular</b> dataset. <br><br> Download the passenger list from the Titanic shipwreck here: <a class='underline text-primary-dark dark:text-primary-light' href='https://github.com/epfml/disco/raw/develop/example_training_data/titanic_train.csv'>titanic_train.csv</a> (more info <a class='underline text-primary-dark dark:text-primary-light' href='https://www.kaggle.com/c/titanic'>here</a>). <br> This model predicts the type of person most likely to survive/die in the historic ship accident, based on their characteristics (sex, age, class etc.).",
+                    overview: 'We all know the unfortunate story of the Titanic: this flamboyant new transatlantic boat that sunk in 1912 in the North Atlantic Ocean. Today, we revist this tragedy by trying to predict the survival odds of the passenger given some basic features.'
+                },
+                model: 'The current model does not normalize the given data and applies only a very simple pre-processing of the data.',
+                tradeoffs: 'We are using a small model for this task: 4 fully connected layers with few neurons. This allows fast training but can yield to reduced accuracy.',
+                dataFormatInformation: 'This model takes as input a CSV file with 12 columns. The features are general information about the passenger (sex, age, name, etc.) and specific related Titanic data such as the ticket class bought by the passenger, its cabin number, etc.<br><br>pclass: A proxy for socio-economic status (SES)<br>1st = Upper<br>2nd = Middle<br>3rd = Lower<br><br>age: Age is fractional if less than 1. If the age is estimated, it is in the form of xx.5<br><br>sibsp: The dataset defines family relations in this way:<br>Sibling = brother, sister, stepbrother, stepsister<br>Spouse = husband, wife (mistresses and fiancés were ignored)<br><br>parch: The dataset defines family relations in this way:<br>Parent = mother, father<br>Child = daughter, son, stepdaughter, stepson<br>Some children travelled only with a nanny, therefore parch=0 for them.<br><br>The first line of the CSV contains the header:<br> PassengerId, Survived, Pclass, Name, Sex, Age, SibSp, Parch, Ticket, Fare, Cabin, Embarked<br><br>Each susequent row contains the corresponding data.',
+                dataExampleText: 'Below one can find an example of a datapoint taken as input by our model. In this datapoint, the person is young man named Owen Harris that unfortunnalty perished with the Titanic. He boarded the boat in South Hamptons and was a 3rd class passenger. On the testing & validation page, the data should not contain the label column (Survived).',
+                dataExample: [
+                    { columnName: 'PassengerId', columnData: '1' },
+                    { columnName: 'Survived', columnData: '0' },
+                    { columnName: 'Name', columnData: 'Braund, Mr. Owen Harris' },
+                    { columnName: 'Sex', columnData: 'male' },
+                    { columnName: 'Age', columnData: '22' },
+                    { columnName: 'SibSp', columnData: '1' },
+                    { columnName: 'Parch', columnData: '0' },
+                    { columnName: 'Ticket', columnData: '1/5 21171' },
+                    { columnName: 'Fare', columnData: '7.25' },
+                    { columnName: 'Cabin', columnData: 'E46' },
+                    { columnName: 'Embarked', columnData: 'S' },
+                    { columnName: 'Pclass', columnData: '3' }
+                ],
+                headers: [
+                    'PassengerId',
+                    'Survived',
+                    'Name',
+                    'Sex',
+                    'Age',
+                    'SibSp',
+                    'Parch',
+                    'Ticket',
+                    'Fare',
+                    'Cabin',
+                    'Embarked',
+                    'Pclass'
+                ]
+            },
+            trainingInformation: {
+                modelID: 'titanic-model',
+                epochs: 20,
+                roundDuration: 10,
+                validationSplit: 0.2,
+                batchSize: 30,
+                preprocessingFunctions: [data.TabularPreprocessing.Sanitize],
+                dataType: 'tabular',
+                inputColumns: [
+                    'Age',
+                    'SibSp',
+                    'Parch',
+                    'Fare',
+                    'Pclass'
+                ],
+                outputColumns: [
+                    'Survived'
+                ],
+                scheme: 'federated', // secure aggregation not yet implemented for FeAI
+                noiseScale: undefined,
+                clippingRadius: undefined
+            }
+        };
+    },
+    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.