@epfml/discojs 0.0.1

package/dist/serialization/model.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = exports.isEncoded = void 0;
+var tslib_1 = require("tslib");
+var tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+var msgpack_lite_1 = (0, tslib_1.__importDefault)(require("msgpack-lite"));
+function isEncoded(raw) {
+    return Array.isArray(raw) && raw.every(function (r) { return typeof r === 'number'; });
+}
+exports.isEncoded = isEncoded;
+function encode(model) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var saved;
+        var _this = this;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, new Promise(function (resolve) {
+                        void model.save({
+                            save: function (artifacts) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+                                return (0, tslib_1.__generator)(this, function (_a) {
+                                    resolve(artifacts);
+                                    return [2 /*return*/, {
+                                            modelArtifactsInfo: {
+                                                dateSaved: new Date(),
+                                                modelTopologyType: 'JSON'
+                                            }
+                                        }];
+                                });
+                            }); }
+                        });
+                    })];
+                case 1:
+                    saved = _a.sent();
+                    return [2 /*return*/, (0, tslib_1.__spreadArray)([], (0, tslib_1.__read)(msgpack_lite_1.default.encode(saved).values()), false)];
+            }
+        });
+    });
+}
+exports.encode = encode;
+function decode(encoded) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var raw;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    raw = msgpack_lite_1.default.decode(encoded);
+                    return [4 /*yield*/, tf.loadLayersModel({
+                            load: function () { return raw; }
+                        })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+exports.decode = decode;

package/dist/serialization/weights.d.ts

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

package/dist/serialization/weights.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = exports.isEncoded = void 0;
+var tslib_1 = require("tslib");
+var tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+var msgpack = (0, tslib_1.__importStar)(require("msgpack-lite"));
+function isSerialized(raw) {
+    if (typeof raw !== 'object' || raw === null) {
+        return false;
+    }
+    if (!('shape' in raw && 'data' in raw)) {
+        return false;
+    }
+    var _a = raw, shape = _a.shape, data = _a.data;
+    if (!(Array.isArray(shape) && shape.every(function (e) { return typeof e === 'number'; })) ||
+        !(data instanceof Float32Array)) {
+        return false;
+    }
+    // eslint-disable-next-line
+    var _ = { shape: shape, data: data };
+    return true;
+}
+function isEncoded(raw) {
+    return Array.isArray(raw) && raw.every(function (e) { return typeof e === 'number'; });
+}
+exports.isEncoded = isEncoded;
+function encode(weights) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var serialized;
+        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 () {
+                        var _a;
+                        return (0, tslib_1.__generator)(this, function (_b) {
+                            switch (_b.label) {
+                                case 0:
+                                    _a = {
+                                        shape: t.shape
+                                    };
+                                    return [4 /*yield*/, t.data()];
+                                case 1: return [2 /*return*/, (_a.data = _b.sent(),
+                                        _a)];
+                            }
+                        });
+                    }); }))];
+                case 1:
+                    serialized = _a.sent();
+                    return [2 /*return*/, (0, tslib_1.__spreadArray)([], (0, tslib_1.__read)(msgpack.encode(serialized).values()), false)];
+            }
+        });
+    });
+}
+exports.encode = encode;
+function decode(encoded) {
+    var raw = msgpack.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 tf.tensor(w.data, w.shape); });
+}
+exports.decode = decode;

package/dist/task/data_example.d.ts

@@ -0,0 +1,5 @@
+export declare function isDataExample(raw: unknown): raw is DataExample;
+export interface DataExample {
+    columnName: string;
+    columnData: string | number;
+}

package/dist/task/data_example.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDataExample = void 0;
+var immutable_1 = require("immutable");
+function isDataExample(raw) {
+    if (typeof raw !== 'object') {
+        return false;
+    }
+    if (raw === null) {
+        return false;
+    }
+    if (!(0, immutable_1.Set)(Object.keys(raw)).equals(immutable_1.Set.of('columnName', 'columnData'))) {
+        return false;
+    }
+    var _a = raw, columnName = _a.columnName, columnData = _a.columnData;
+    if (typeof columnName !== 'string' ||
+        (typeof columnData !== 'string' && typeof columnData !== 'number')) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var _ = { columnName: columnName, columnData: columnData };
+    return true;
+}
+exports.isDataExample = isDataExample;

package/dist/task/display_information.d.ts

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

package/dist/task/display_information.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDisplayInformation = void 0;
+var immutable_1 = require("immutable");
+var data_example_1 = require("./data_example");
+function isDisplayInformation(raw) {
+    if (typeof raw !== 'object') {
+        return false;
+    }
+    if (raw === null) {
+        return false;
+    }
+    var requiredFields = immutable_1.Set.of('dataExampleText', 'dataFormatInformation', 'overview', '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, overview = _a.overview, summary = _a.summary, taskTitle = _a.taskTitle, tradeoffs = _a.tradeoffs;
+    if (typeof dataExampleText !== 'string' ||
+        typeof dataFormatInformation !== 'string' ||
+        typeof overview !== 'string' ||
+        typeof summary !== 'string' ||
+        typeof taskTitle !== 'string' ||
+        typeof tradeoffs !== 'string' ||
+        (model !== undefined && typeof model !== 'string') ||
+        (dataExampleImage !== undefined && typeof dataExampleImage !== 'string') ||
+        (limitations !== undefined && typeof limitations !== 'string')) {
+        return false;
+    }
+    if (dataExample !== undefined && !(Array.isArray(dataExample) &&
+        dataExample.every(data_example_1.isDataExample))) {
+        return false;
+    }
+    if (headers !== undefined && !(Array.isArray(headers) &&
+        headers.every(function (e) { return typeof e === 'string'; }))) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var _ = {
+        taskTitle: taskTitle,
+        summary: summary,
+        overview: overview,
+        tradeoffs: tradeoffs,
+        dataFormatInformation: dataFormatInformation,
+        dataExampleText: dataExampleText,
+        model: model,
+        dataExample: dataExample,
+        headers: headers,
+        dataExampleImage: dataExampleImage,
+        limitations: limitations
+    };
+    return true;
+}
+exports.isDisplayInformation = isDisplayInformation;

package/dist/task/index.d.ts

@@ -0,0 +1,3 @@
+export { isTask, Task, isTaskID, TaskID } from './task';
+export { isDisplayInformation, DisplayInformation } from './display_information';
+export { TrainingInformation } from './training_information';

package/dist/task/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDisplayInformation = 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 display_information_1 = require("./display_information");
+Object.defineProperty(exports, "isDisplayInformation", { enumerable: true, get: function () { return display_information_1.isDisplayInformation; } });

package/dist/task/model_compile_data.d.ts

@@ -0,0 +1,6 @@
+export declare class ModelCompileData {
+    readonly optimizer: string;
+    readonly loss: string;
+    readonly metrics: string[];
+    constructor(optimizer: string, loss: string, metrics: string[]);
+}

package/dist/task/model_compile_data.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelCompileData = void 0;
+var ModelCompileData = /** @class */ (function () {
+    function ModelCompileData(optimizer, loss, metrics) {
+        this.optimizer = optimizer;
+        this.loss = loss;
+        this.metrics = metrics;
+    }
+    return ModelCompileData;
+}());
+exports.ModelCompileData = ModelCompileData;

package/dist/task/task.d.ts

@@ -0,0 +1,10 @@
+import { DisplayInformation } from './display_information';
+import { TrainingInformation } from './training_information';
+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;
+}

package/dist/task/task.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTask = exports.isTaskID = void 0;
+var display_information_1 = require("./display_information");
+function isTaskID(obj) {
+    return typeof obj === 'string';
+}
+exports.isTaskID = isTaskID;
+function isTask(raw) {
+    if (typeof raw !== 'object') {
+        return false;
+    }
+    if (raw === null) {
+        return false;
+    }
+    if (!('taskID' in raw)) {
+        return false;
+    }
+    var _a = raw, taskID = _a.taskID, displayInformation = _a.displayInformation;
+    if (typeof taskID !== 'string') {
+        return false;
+    }
+    if (displayInformation !== undefined &&
+        !(0, display_information_1.isDisplayInformation)(displayInformation)) {
+        return false;
+    }
+    // TODO check for TrainingInformation
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var _ = { taskID: taskID, displayInformation: displayInformation };
+    return true;
+}
+exports.isTask = isTask;

package/dist/task/training_information.d.ts

@@ -0,0 +1,29 @@
+import { DataExample } from './data_example';
+import { ModelCompileData } from './model_compile_data';
+export interface TrainingInformation {
+    modelID: string;
+    epochs: number;
+    roundDuration: number;
+    validationSplit: number;
+    batchSize: number;
+    preprocessFunctions: string[];
+    modelCompileData: ModelCompileData;
+    dataType: string;
+    receivedMessagesThreshold?: number;
+    inputColumns?: string[];
+    outputColumns?: string[];
+    threshold?: number;
+    IMAGE_H?: number;
+    IMAGE_W?: number;
+    LABEL_LIST?: string[];
+    aggregateImagesById?: boolean;
+    learningRate?: number;
+    NUM_CLASSES?: number;
+    csvLabels?: boolean;
+    RESIZED_IMAGE_H?: number;
+    RESIZED_IMAGE_W?: number;
+    LABEL_ASSIGNMENT?: DataExample[];
+    scheme?: string;
+    noiseScale?: number;
+    clippingRadius?: number;
+}

package/dist/task/training_information.js

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

package/dist/tasks/cifar10.d.ts

@@ -0,0 +1,4 @@
+import * as tf from '@tensorflow/tfjs';
+import { Task } from '../task';
+export declare const task: Task;
+export declare function model(): Promise<tf.LayersModel>;

package/dist/tasks/cifar10.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.model = exports.task = void 0;
+var tslib_1 = require("tslib");
+var tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+exports.task = {
+    taskID: 'cifar10',
+    displayInformation: {
+        taskTitle: 'CIFAR10',
+        summary: 'In this challenge, we ask you to classify images into categories based on the objects shown on the image.',
+        overview: 'The CIFAR-10 dataset is a collection of images that are commonly used to train machine learning and computer vision algorithms. It is one of the most widely used datasets for machine learning research.',
+        limitations: 'The training data is limited to small images of size 32x32.',
+        tradeoffs: 'Training success strongly depends on label distribution',
+        dataFormatInformation: 'Images should be of .png format and of size 32x32. <br> The label file should be .csv, where each row contains a file_name, class.  <br> <br> e.g. if you have images: 0.png (of a frog) and 1.png (of a car) <br> labels.csv contains: (Note that no header is needed)<br> 0.png, frog <br> 1.png, car',
+        dataExampleText: 'Below you can find 10 random examples from each of the 10 classes in the dataset.',
+        dataExampleImage: './cifar10-example.png'
+    },
+    trainingInformation: {
+        modelID: 'cifar10-model',
+        epochs: 10,
+        roundDuration: 10,
+        validationSplit: 0.2,
+        batchSize: 10,
+        modelCompileData: {
+            optimizer: 'adam',
+            loss: 'categoricalCrossentropy',
+            metrics: ['accuracy']
+        },
+        threshold: 1,
+        dataType: 'image',
+        csvLabels: true,
+        IMAGE_H: 32,
+        IMAGE_W: 32,
+        preprocessFunctions: ['resize'],
+        RESIZED_IMAGE_H: 224,
+        RESIZED_IMAGE_W: 224,
+        LABEL_LIST: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+        LABEL_ASSIGNMENT: [
+            { columnName: 'airplane', columnData: 0 },
+            { columnName: 'automobile', columnData: 1 },
+            { columnName: 'bird', columnData: 2 },
+            { columnName: 'cat', columnData: 3 },
+            { columnName: 'deer', columnData: 4 },
+            { columnName: 'dog', columnData: 5 },
+            { columnName: 'frog', columnData: 6 },
+            { columnName: 'horse', columnData: 7 },
+            { columnName: 'ship', columnData: 8 },
+            { columnName: 'truck', columnData: 9 }
+        ],
+        scheme: 'Decentralized'
+    }
+};
+function model() {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var mobilenet, x, predictions;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, tf.loadLayersModel('https://storage.googleapis.com/tfjs-models/tfjs/mobilenet_v1_0.25_224/model.json')];
+                case 1:
+                    mobilenet = _a.sent();
+                    x = mobilenet.getLayer('global_average_pooling2d_1');
+                    predictions = tf.layers
+                        .dense({ units: 10, activation: 'softmax', name: 'denseModified' })
+                        .apply(x.output);
+                    return [2 /*return*/, tf.model({
+                            inputs: mobilenet.input,
+                            outputs: predictions,
+                            name: 'modelModified'
+                        })];
+            }
+        });
+    });
+}
+exports.model = model;

package/dist/tasks/index.d.ts

@@ -0,0 +1,5 @@
+export * as cifar10 from './cifar10';
+export * as lus_covid from './lus_covid';
+export * as mnist from './mnist';
+export * as simple_face from './simple_face';
+export * as titanic from './titanic';

package/dist/tasks/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.titanic = exports.simple_face = exports.mnist = exports.lus_covid = exports.cifar10 = void 0;
+var tslib_1 = require("tslib");
+exports.cifar10 = (0, tslib_1.__importStar)(require("./cifar10"));
+exports.lus_covid = (0, tslib_1.__importStar)(require("./lus_covid"));
+exports.mnist = (0, tslib_1.__importStar)(require("./mnist"));
+exports.simple_face = (0, tslib_1.__importStar)(require("./simple_face"));
+exports.titanic = (0, tslib_1.__importStar)(require("./titanic"));

package/dist/tasks/lus_covid.d.ts

@@ -0,0 +1,4 @@
+import * as tf from '@tensorflow/tfjs';
+import { Task } from '../task';
+export declare const task: Task;
+export declare function model(): tf.LayersModel;

package/dist/tasks/lus_covid.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.model = exports.task = void 0;
+var tslib_1 = require("tslib");
+var tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+exports.task = {
+    taskID: 'lus_covid',
+    displayInformation: {
+        taskTitle: 'COVID Lung Ultrasound',
+        summary: "Do you have a dataset of lung ultrasound images on patients <b>suspected of Lower Respiratory Tract infection (LRTI) during the COVID pandemic</b>? <br> Learn how to discriminate between COVID positive and negative patients by joining this task. <br><br> Don’t have a dataset of your own? Download a sample of a few cases <a class='underline text-primary-dark dark:text-primary-light' href='https://drive.switch.ch/index.php/s/zM5ZrUWK3taaIly'>here</a>.",
+        overview: "Do you have a dataset of lung ultrasound images on patients <b>suspected of Lower Respiratory Tract infection (LRTI) during the COVID pandemic</b>? <br> Learn how to discriminate between COVID positive and negative patients by joining this task. <br><br> Don’t have a dataset of your own? Download a sample of a few cases <a class='underline text-primary-dark dark:text-primary-light' href='https://drive.switch.ch/index.php/s/zM5ZrUWK3taaIly'>here</a>.",
+        model: 'We use a simplified* version of the <b>DeepChest model</b>: A deep learning model developed in our lab (intelligent Global Health). On a cohort of 400 Swiss patients suspected of LRTI, the model obtained over 90% area under the ROC curve for this task. <br><br>*Simplified to ensure smooth running on your browser, the performance is minimally affected. Details of the adaptations are below <br>- <b>Removed</b>: positional embedding (i.e. we don’t take the anatomic position into consideration). Rather, the model now does mean pooling over the feature vector of the images for each patient <br>- <b>Replaced</b>: ResNet18 by Mobilenet',
+        tradeoffs: 'We are using a simpler version of DeepChest in order to be able to run it on the browser.',
+        dataFormatInformation: 'This model takes as input an image dataset. It consists on a set of lung ultrasound images per patient with its corresponding label of covid positive or negative. Moreover, to identify the images per patient you have to follow the follwing naming pattern: "patientId_*.png"',
+        dataExampleText: 'Below you can find an example of an expected lung image for patient 2 named: 2_QAID_1.masked.reshaped.squared.224.png',
+        dataExampleImage: './2_QAID_1.masked.reshaped.squared.224.png'
+    },
+    trainingInformation: {
+        modelID: 'lus-covid-model',
+        epochs: 15,
+        roundDuration: 10,
+        validationSplit: 0.2,
+        batchSize: 2,
+        modelCompileData: {
+            optimizer: 'adam',
+            loss: 'binaryCrossentropy',
+            metrics: ['accuracy']
+        },
+        learningRate: 0.05,
+        threshold: 2,
+        IMAGE_H: 224,
+        IMAGE_W: 224,
+        preprocessFunctions: [],
+        LABEL_LIST: ['COVID-Positive', 'COVID-Negative'],
+        NUM_CLASSES: 2,
+        dataType: 'image',
+        aggregateImagesById: true,
+        scheme: 'Decentralized'
+    }
+};
+function model() {
+    var model = tf.sequential();
+    model.add(tf.layers.dense({ inputShape: [1000], units: 512, activation: 'relu' }));
+    model.add(tf.layers.dense({ units: 64, activation: 'relu' }));
+    model.add(tf.layers.dense({ units: 2, activation: 'softmax' }));
+    return model;
+}
+exports.model = model;

package/dist/tasks/mnist.d.ts

@@ -0,0 +1,4 @@
+import * as tf from '@tensorflow/tfjs';
+import { Task } from '../task';
+export declare const task: Task;
+export declare function model(): tf.LayersModel;

package/dist/tasks/mnist.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.model = exports.task = void 0;
+var tslib_1 = require("tslib");
+var tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+exports.task = {
+    taskID: 'mnist',
+    displayInformation: {
+        taskTitle: 'MNIST',
+        summary: "Test our platform by using a publicly available <b>image</b> dataset. <br><br> Download the classic MNIST imagebank of hand-written numbers <a class='underline text-primary-dark dark:text-primary-light' href='https://www.kaggle.com/scolianni/mnistasjpg'>here</a>. <br> This model learns to identify hand written numbers.",
+        overview: 'The MNIST handwritten digit classification problem is a standard dataset used in computer vision and deep learning. Although the dataset is effectively solved, we use it to test our Decentralised Learning algorithms and platform.',
+        model: 'The current model is a very simple CNN and its main goal is to test the app and the Decentralizsed Learning functionality.',
+        tradeoffs: 'We are using a simple model, first a 2d convolutional layer > max pooling > 2d convolutional layer > max pooling > convolutional layer > 2 dense layers.',
+        dataFormatInformation: 'This model is trained on images corresponding to digits 0 to 9. You can upload each digit image of your dataset in the box corresponding to its label. The model taskes images of size 28x28 as input.',
+        dataExampleText: 'Below you can find an example of an expected image representing the digit 9.',
+        dataExampleImage: './9-mnist-example.png'
+    },
+    trainingInformation: {
+        modelID: 'mnist-model',
+        epochs: 10,
+        roundDuration: 10,
+        validationSplit: 0.2,
+        batchSize: 30,
+        modelCompileData: {
+            optimizer: 'rmsprop',
+            loss: 'categoricalCrossentropy',
+            metrics: ['accuracy']
+        },
+        threshold: 1,
+        dataType: 'image',
+        IMAGE_H: 28,
+        IMAGE_W: 28,
+        preprocessFunctions: [],
+        LABEL_LIST: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+        aggregateImagesById: false,
+        scheme: 'Decentralized'
+    }
+};
+function model() {
+    var model = tf.sequential();
+    model.add(tf.layers.conv2d({
+        inputShape: [28, 28, 3],
+        kernelSize: 3,
+        filters: 16,
+        activation: 'relu'
+    }));
+    model.add(tf.layers.maxPooling2d({ poolSize: 2, strides: 2 }));
+    model.add(tf.layers.conv2d({ kernelSize: 3, filters: 32, activation: 'relu' }));
+    model.add(tf.layers.maxPooling2d({ poolSize: 2, strides: 2 }));
+    model.add(tf.layers.conv2d({ kernelSize: 3, filters: 32, activation: 'relu' }));
+    model.add(tf.layers.flatten({}));
+    model.add(tf.layers.dense({ units: 64, activation: 'relu' }));
+    model.add(tf.layers.dense({ units: 10, activation: 'softmax' }));
+    return model;
+}
+exports.model = model;

package/dist/tasks/simple_face.d.ts

@@ -0,0 +1,4 @@
+import * as tf from '@tensorflow/tfjs';
+import { Task } from '../task';
+export declare const task: Task;
+export declare function model(imageWidth?: number, imageHeight?: number, imageChannels?: number, numOutputClasses?: number): tf.LayersModel;

package/dist/tasks/simple_face.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.model = exports.task = void 0;
+var tslib_1 = require("tslib");
+var tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+exports.task = {
+    taskID: 'simple_face',
+    displayInformation: {
+        taskTitle: 'Simple Face',
+        summary: 'Can you detect if the person in a picture is a child or an adult?',
+        overview: 'Simple face is a small subset of face_task from Kaggle',
+        limitations: 'The training data is limited to small images of size 200x200.',
+        tradeoffs: 'Training success strongly depends on label distribution',
+        dataFormatInformation: '',
+        dataExampleText: 'Bellow you can find an example',
+        dataExampleImage: './simple_face-example.png'
+    },
+    trainingInformation: {
+        modelID: 'simple_face-model',
+        epochs: 50,
+        roundDuration: 10,
+        validationSplit: 0.2,
+        batchSize: 10,
+        preprocessFunctions: [],
+        modelCompileData: {
+            optimizer: 'adam',
+            loss: 'categoricalCrossentropy',
+            metrics: ['accuracy']
+        },
+        dataType: 'image',
+        csvLabels: false,
+        IMAGE_H: 200,
+        IMAGE_W: 200,
+        LABEL_LIST: ['child', 'adult']
+    }
+};
+function model(imageWidth, imageHeight, imageChannels, numOutputClasses) {
+    if (imageWidth === void 0) { imageWidth = 200; }
+    if (imageHeight === void 0) { imageHeight = 200; }
+    if (imageChannels === void 0) { imageChannels = 3; }
+    if (numOutputClasses === void 0) { numOutputClasses = 2; }
+    var model = tf.sequential();
+    // In the first layer of our convolutional neural network we have
+    // to specify the input shape. Then we specify some parameters for
+    // the convolution operation that takes place in this layer.
+    model.add(tf.layers.conv2d({
+        inputShape: [imageWidth, imageHeight, imageChannels],
+        kernelSize: 5,
+        filters: 8,
+        strides: 1,
+        activation: 'relu',
+        kernelInitializer: 'varianceScaling'
+    }));
+    // The MaxPooling layer acts as a sort of downsampling using max values
+    // in a region instead of averaging.
+    model.add(tf.layers.maxPooling2d({ poolSize: [2, 2], strides: [2, 2] }));
+    // Repeat another conv2d + maxPooling stack.
+    // Note that we have more filters in the convolution.
+    model.add(tf.layers.conv2d({
+        kernelSize: 5,
+        filters: 16,
+        strides: 1,
+        activation: 'relu',
+        kernelInitializer: 'varianceScaling'
+    }));
+    model.add(tf.layers.maxPooling2d({ poolSize: [2, 2], strides: [2, 2] }));
+    // Now we flatten the output from the 2D filters into a 1D vector to prepare
+    // it for input into our last layer. This is common practice when feeding
+    // higher dimensional data to a final classification output layer.
+    model.add(tf.layers.flatten());
+    // Our last layer is a dense layer which has 10 output units, one for each
+    // output class (i.e. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9).
+    model.add(tf.layers.dense({
+        units: numOutputClasses,
+        kernelInitializer: 'varianceScaling',
+        activation: 'softmax'
+    }));
+    // Choose an optimizer, loss function and accuracy metric,
+    // then compile and return the model
+    var optimizer = tf.train.adam();
+    model.compile({
+        optimizer: optimizer,
+        loss: 'categoricalCrossentropy',
+        metrics: ['accuracy']
+    });
+    return model;
+}
+exports.model = model;