@epfml/discojs 3.0.1-p20240902094132.0 → 3.0.1-p20240902162912.0

package/dist/client/federated/federated_client.js

@@ -0,0 +1,210 @@
+import createDebug from "debug";
+import { serialization } from "../../index.js";
+import { Client } from "../client.js";
+import { type } from "../messages.js";
+import { waitMessage, waitMessageWithTimeout, WebSocketServer, } from "../event_connection.js";
+import * as messages from "./messages.js";
+const debug = createDebug("discojs:client:federated");
+/**
+ * Arbitrary node id assigned to the federated server which we are communicating with.
+ * Indeed, the server acts as a node within the network. In the federated setting described
+ * by this client class, the server is the only node which we are communicating with.
+*/
+const SERVER_NODE_ID = "federated-server-node-id";
+/**
+ * Client class that communicates with a centralized, federated server, when training
+ * a specific task in the federated setting.
+ */
+export class FederatedClient extends Client {
+    // Total number of other federated contributors, including this client, excluding the server
+    // E.g., if 3 users are training a federated model, nbOfParticipants is 3
+    #nbOfParticipants = 1;
+    /**
+     * When the server notifies clients to pause and wait until more
+     * participants join, we rely on this promise to wait
+     * until the server signals that the training can resume
+     */
+    #promiseForMoreParticipants = undefined;
+    /**
+     * When the server notifies the client that they can resume training
+     * after waiting for more participants, we want to be able to display what
+     * we were doing before waiting (training locally or updating our model).
+     * We use this attribute to store the status to rollback to when we stop waiting
+     */
+    #previousStatus = undefined;
+    /**
+    * Whether the client should wait until more
+    * participants join the session, i.e. a promise has been created
+    */
+    get #waitingForMoreParticipants() {
+        return this.#promiseForMoreParticipants !== undefined;
+    }
+    // the number of participants excluding the server
+    get nbOfParticipants() {
+        return this.#nbOfParticipants;
+    }
+    /**
+     * Opens a new WebSocket connection with the server and listens to new messages over the channel
+     */
+    async connectServer(url) {
+        const server = await WebSocketServer.connect(url, messages.isMessageFederated, // can only receive federated message types from the server
+        messages.isMessageFederated);
+        return server;
+    }
+    /**
+     * Initializes the connection to the server, gets our node ID
+     * as well as the latest training information: latest global model, current round and
+     * whether we are waiting for more participants.
+     */
+    async connect() {
+        const model = await super.connect(); // Get the server base model
+        const serverURL = new URL("", this.url.href);
+        switch (this.url.protocol) {
+            case "http:":
+                serverURL.protocol = "ws:";
+                break;
+            case "https:":
+                serverURL.protocol = "wss:";
+                break;
+            default:
+                throw new Error(`unknown protocol: ${this.url.protocol}`);
+        }
+        serverURL.pathname += `federated/${this.task.id}`;
+        this._server = await this.connectServer(serverURL);
+        // Setup an event callback if the server signals that we should 
+        // wait for more participants
+        this.server.on(type.WaitingForMoreParticipants, () => {
+            debug(`[${id.slice(0, 4)}] received WaitingForMoreParticipants message from server`);
+            // Display the waiting status right away
+            this.emit("status", "Waiting for more participants");
+            // Upon receiving a WaitingForMoreParticipants message,
+            // the client will await for this promise to resolve before sending its
+            // local weight update
+            this.#promiseForMoreParticipants = this.waitForMoreParticipants();
+        });
+        // As an example assume we need at least 2 participants to train,
+        // When two participants join almost at the same time, the server
+        // sends a NewFederatedNodeInfo with waitForMoreParticipants=true to the first participant
+        // and directly follows with an EnoughParticipants message when the 2nd participant joins
+        // However, the EnoughParticipants can arrive before the NewFederatedNodeInfo (which is much bigger)
+        // so we check whether we received the EnoughParticipants before being assigned a node ID
+        let receivedEnoughParticipants = false;
+        this.server.once(type.EnoughParticipants, () => {
+            if (this._ownId === undefined) {
+                debug(`Received EnoughParticipants message from server before the NewFederatedNodeInfo message`);
+                receivedEnoughParticipants = true;
+            }
+        });
+        this.aggregator.registerNode(SERVER_NODE_ID);
+        const msg = {
+            type: type.ClientConnected,
+        };
+        this.server.send(msg);
+        const { id, waitForMoreParticipants, payload, round, nbOfParticipants } = await waitMessageWithTimeout(this.server, type.NewFederatedNodeInfo);
+        // This should come right after receiving the message to make sure
+        // we don't miss a subsequent message from the server
+        // We check if the server is telling us to wait for more participants
+        // and we also check if a EnoughParticipant message ended up arriving
+        // before the NewFederatedNodeInfo
+        if (waitForMoreParticipants && !receivedEnoughParticipants) {
+            // Create a promise that resolves when enough participants join
+            // The client will await this promise before sending its local weight update
+            this.#promiseForMoreParticipants = this.waitForMoreParticipants();
+        }
+        if (this._ownId !== undefined) {
+            throw new Error('received id from server but was already received');
+        }
+        this._ownId = id;
+        debug(`[${id.slice(0, 4)}] joined session at round ${round} `);
+        this.aggregator.setRound(round);
+        this.#nbOfParticipants = nbOfParticipants;
+        // Upon connecting, the server answers with a boolean
+        // which indicates whether there are enough participants or not
+        debug(`[${this.ownId.slice(0, 4)}] upon connecting, wait for participant flag %o`, this.#waitingForMoreParticipants);
+        model.weights = serialization.weights.decode(payload);
+        return model;
+    }
+    /**
+     * Method called when the server notifies the client that there aren't enough
+     * participants (anymore) to start/continue training
+     * The method creates a promise that will resolve once the server notifies
+     * the client that the training can resume via a subsequent EnoughParticipants message
+     * @returns a promise which resolves when enough participants joined the session
+     */
+    async waitForMoreParticipants() {
+        return new Promise((resolve) => {
+            // "once" is important because we can't resolve the same promise multiple times
+            this.server.once(type.EnoughParticipants, () => {
+                debug(`[${this.ownId.slice(0, 4)}] received EnoughParticipants message from server`);
+                // Emit the last status emitted before waiting if defined
+                if (this.#previousStatus !== undefined)
+                    this.emit("status", this.#previousStatus);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Disconnection process when user quits the task.
+     */
+    async disconnect() {
+        await this.server.disconnect();
+        this._server = undefined;
+        this._ownId = undefined;
+        this.aggregator.setNodes(this.aggregator.nodes.delete(SERVER_NODE_ID));
+    }
+    onRoundBeginCommunication() {
+        // Prepare the result promise for the incoming round
+        this.aggregationResult = new Promise((resolve) => this.aggregator.once('aggregation', resolve));
+        // Save the status in case participants leave and we switch to waiting for more participants
+        // Once enough new participants join we can display the previous status again
+        this.#previousStatus = "Training the model on the data you connected";
+        this.emit("status", this.#previousStatus);
+        return Promise.resolve();
+    }
+    /**
+     * Send the local weight update to the server and waits (indefinitely) for the server global update
+     *
+     * If the waitingForMoreParticipants flag is set, we first wait (also indefinitely) until the
+     * server notifies us that the training can resume.
+     *
+    // NB: For now, we suppose a fully-federated setting.
+     * @param weights Local weights sent to the server at the end of the local training round
+     * @returns the new global weights sent by the server
+     */
+    async onRoundEndCommunication(weights) {
+        if (this.aggregationResult === undefined) {
+            throw new Error("local aggregation result was not set");
+        }
+        // First we check if we are waiting for more participants before sending our weight update
+        if (this.#waitingForMoreParticipants) {
+            // wait for the promise to resolve, which takes as long as it takes for new participants to join
+            debug(`[${this.ownId.slice(0, 4)}] is awaiting the promise for more participants`);
+            this.emit("status", "Waiting for more participants");
+            await this.#promiseForMoreParticipants;
+            // Make sure to set the promise back to undefined once resolved
+            this.#promiseForMoreParticipants = undefined;
+        }
+        // Save the status in case participants leave and we switch to waiting for more participants
+        // Once enough new participants join we can display the previous status again
+        this.#previousStatus = "Updating the model with other participants' models";
+        this.emit("status", this.#previousStatus);
+        // Send our local contribution to the server
+        // and receive the server global update for this round as an answer to our contribution
+        const payloadToServer = this.aggregator.makePayloads(weights).first();
+        const msg = {
+            type: type.SendPayload,
+            payload: await serialization.weights.encode(payloadToServer),
+            round: this.aggregator.round,
+        };
+        // Need to await the resulting global model right after sending our local contribution
+        // to make sure we don't miss it
+        debug(`[${this.ownId.slice(0, 4)}] sent its local update to the server for round ${this.aggregator.round}`);
+        this.server.send(msg);
+        debug(`[${this.ownId.slice(0, 4)}] is waiting for server update for round ${this.aggregator.round + 1}`);
+        const { payload: payloadFromServer, round: serverRound, nbOfParticipants } = await waitMessage(this.server, type.ReceiveServerPayload); // Wait indefinitely for the server update
+        this.#nbOfParticipants = nbOfParticipants; // Save the current participants
+        const serverResult = serialization.weights.decode(payloadFromServer);
+        this.aggregator.setRound(serverRound);
+        return serverResult;
+    }
+}

package/dist/client/federated/index.d.ts

@@ -1,2 +1,2 @@
-export { Base as FederatedClient } from './base.js';
+export { FederatedClient } from './federated_client.js';
 export * as messages from './messages.js';

package/dist/client/federated/index.js

@@ -1,2 +1,2 @@
-export { Base as FederatedClient } from './base.js';
+export { FederatedClient } from './federated_client.js';
 export * as messages from './messages.js';

package/dist/client/federated/messages.d.ts

@@ -1,6 +1,15 @@
 import { type weights } from '../../serialization/index.js';
-import { type, type AssignNodeID, type ClientConnected } from '../messages.js';
-export type MessageFederated = ClientConnected | SendPayload | ReceiveServerPayload | AssignNodeID;
+import { type NodeID } from '..//types.js';
+import { type, type ClientConnected } from '../messages.js';
+export type MessageFederated = ClientConnected | NewFederatedNodeInfo | SendPayload | ReceiveServerPayload | WaitingForMoreParticipants | EnoughParticipants;
+export interface NewFederatedNodeInfo {
+    type: type.NewFederatedNodeInfo;
+    id: NodeID;
+    waitForMoreParticipants: boolean;
+    payload: weights.Encoded;
+    round: number;
+    nbOfParticipants: number;
+}
 export interface SendPayload {
     type: type.SendPayload;
     payload: weights.Encoded;
@@ -12,4 +21,10 @@ export interface ReceiveServerPayload {
     round: number;
     nbOfParticipants: number;
 }
+export interface EnoughParticipants {
+    type: type.EnoughParticipants;
+}
+export interface WaitingForMoreParticipants {
+    type: type.WaitingForMoreParticipants;
+}
 export declare function isMessageFederated(raw: unknown): raw is MessageFederated;

package/dist/client/federated/messages.js

@@ -5,9 +5,11 @@ export function isMessageFederated(raw) {
     }
     switch (raw.type) {
         case type.ClientConnected:
+        case type.NewFederatedNodeInfo:
         case type.SendPayload:
         case type.ReceiveServerPayload:
-        case type.AssignNodeID:
+        case type.WaitingForMoreParticipants:
+        case type.EnoughParticipants:
             return true;
     }
     return false;

package/dist/client/index.d.ts

@@ -1,8 +1,8 @@
-export { Base as Client } from './base.js';
+export { Client } from './client.js';
 export * from './types.js';
 export * as aggregator from '../aggregator/index.js';
 export * as decentralized from './decentralized/index.js';
 export * as federated from './federated/index.js';
 export * as messages from './messages.js';
 export { getClient, timeout } from './utils.js';
-export { Local } from './local.js';
+export { LocalClient } from './local_client.js';

package/dist/client/index.js

@@ -1,8 +1,8 @@
-export { Base as Client } from './base.js';
+export { Client } from './client.js';
 export * from './types.js';
 export * as aggregator from '../aggregator/index.js';
 export * as decentralized from './decentralized/index.js';
 export * as federated from './federated/index.js';
 export * as messages from './messages.js';
 export { getClient, timeout } from './utils.js';
-export { Local } from './local.js';
+export { LocalClient } from './local_client.js';

package/dist/client/local_client.d.ts

@@ -0,0 +1,10 @@
+import { WeightsContainer } from "../index.js";
+import { Client } from "./client.js";
+/**
+ * A LocalClient represents a Disco user training only on their local data without collaborating
+ * with anyone. Thus LocalClient doesn't do anything during communication
+ */
+export declare class LocalClient extends Client {
+    onRoundBeginCommunication(): Promise<void>;
+    onRoundEndCommunication(weights: WeightsContainer): Promise<WeightsContainer>;
+}

package/dist/client/local_client.js

@@ -0,0 +1,14 @@
+import { Client } from "./client.js";
+/**
+ * A LocalClient represents a Disco user training only on their local data without collaborating
+ * with anyone. Thus LocalClient doesn't do anything during communication
+ */
+export class LocalClient extends Client {
+    onRoundBeginCommunication() {
+        return Promise.resolve();
+    }
+    // Simply return the local weights 
+    onRoundEndCommunication(weights) {
+        return Promise.resolve(weights);
+    }
+}

package/dist/client/messages.d.ts

@@ -1,23 +1,21 @@
 import type * as decentralized from './decentralized/messages.js';
 import type * as federated from './federated/messages.js';
-import { type NodeID } from './types.js';
 export declare enum type {
     ClientConnected = 0,
-    AssignNodeID = 1,
+    NewDecentralizedNodeInfo = 1,
     SignalForPeer = 2,
     PeerIsReady = 3,
     PeersForRound = 4,
     Payload = 5,
-    SendPayload = 6,
-    ReceiveServerPayload = 7
+    NewFederatedNodeInfo = 6,
+    WaitingForMoreParticipants = 7,
+    EnoughParticipants = 8,
+    SendPayload = 9,
+    ReceiveServerPayload = 10
 }
 export interface ClientConnected {
     type: type.ClientConnected;
 }
-export interface AssignNodeID {
-    type: type.AssignNodeID;
-    id: NodeID;
-}
 export type Message = decentralized.MessageFromServer | decentralized.MessageToServer | decentralized.PeerMessage | federated.MessageFederated;
 export type NarrowMessage<D> = Extract<Message, {
     type: D;

package/dist/client/messages.js

@@ -1,21 +1,37 @@
 export var type;
 (function (type) {
     // Sent from client to server as first point of contact to join a task. 
-    // The server answers with an node id in a AssignNodeID message
+    // The server answers with an node id in a NewFederatedNodeInfo
+    // or NewDecentralizedNodeInfo message
     type[type["ClientConnected"] = 0] = "ClientConnected";
-    // When a user joins a task with a ClientConnected message, the server
-    // answers with an AssignNodeID message with its peer id.
-    type[type["AssignNodeID"] = 1] = "AssignNodeID";
     /* Decentralized */
+    // When a user joins a task with a ClientConnected message, the server
+    // answers with  its peer id and also tells the client whether we are waiting
+    // for more participants before starting training
+    type[type["NewDecentralizedNodeInfo"] = 1] = "NewDecentralizedNodeInfo";
     // Message forwarded by the server from a client to another client
     // to establish a peer-to-peer (WebRTC) connection
     type[type["SignalForPeer"] = 2] = "SignalForPeer";
+    // Message sent by nodes to server signaling they are ready to 
+    // start the next round
     type[type["PeerIsReady"] = 3] = "PeerIsReady";
+    // Sent by the server to participating peers containing the list
+    // of peers for the round
     type[type["PeersForRound"] = 4] = "PeersForRound";
+    // The weight update
     type[type["Payload"] = 5] = "Payload";
-    // Federated
-    type[type["SendPayload"] = 6] = "SendPayload";
-    type[type["ReceiveServerPayload"] = 7] = "ReceiveServerPayload";
+    /* Federated */
+    // The server answers the ClientConnected message with the necessary information
+    // to start training: node id, latest model global weights, current round etc
+    type[type["NewFederatedNodeInfo"] = 6] = "NewFederatedNodeInfo";
+    // Message sent by server to notify clients that there are not enough
+    // participants to continue training
+    type[type["WaitingForMoreParticipants"] = 7] = "WaitingForMoreParticipants";
+    // Message sent by server to notify clients that there are now enough
+    // participants to start training collaboratively
+    type[type["EnoughParticipants"] = 8] = "EnoughParticipants";
+    type[type["SendPayload"] = 9] = "SendPayload";
+    type[type["ReceiveServerPayload"] = 10] = "ReceiveServerPayload";
 })(type || (type = {}));
 export function hasMessageType(raw) {
     if (typeof raw !== 'object' || raw === null) {

package/dist/client/utils.js

@@ -13,7 +13,7 @@ export function getClient(trainingScheme, serverURL, task, aggregator) {
         case 'federated':
             return new clients.federated.FederatedClient(serverURL, task, aggregator);
         case 'local':
-            return new clients.Local(serverURL, task, aggregator);
+            return new clients.LocalClient(serverURL, task, aggregator);
         default: {
             const _ = trainingScheme;
             throw new Error('should never happen');

package/dist/default_tasks/cifar10.js

@@ -32,7 +32,7 @@ export const cifar10 = {
                 scheme: 'decentralized',
                 privacy: { clippingRadius: 20, noiseScale: 1 },
                 decentralizedSecure: true,
-                minimumReadyPeers: 3,
+                minNbOfParticipants: 3,
                 maxShareValue: 100,
                 tensorBackend: 'tfjs'
             }

package/dist/default_tasks/lus_covid.js

@@ -29,6 +29,7 @@ export const lusCovid = {
                 LABEL_LIST: ['COVID-Positive', 'COVID-Negative'],
                 dataType: 'image',
                 scheme: 'federated',
+                minNbOfParticipants: 2,
                 tensorBackend: 'tfjs'
             }
         };

package/dist/default_tasks/mnist.js

@@ -31,7 +31,7 @@ export const mnist = {
                 LABEL_LIST: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
                 scheme: 'decentralized',
                 decentralizedSecure: true,
-                minimumReadyPeers: 3,
+                minNbOfParticipants: 3,
                 maxShareValue: 100,
                 tensorBackend: 'tfjs'
             }

package/dist/default_tasks/simple_face.js

@@ -28,7 +28,8 @@ export const simpleFace = {
                 IMAGE_H: 200,
                 IMAGE_W: 200,
                 LABEL_LIST: ['child', 'adult'],
-                scheme: 'federated', // secure aggregation not yet implemented for federated
+                scheme: 'federated',
+                minNbOfParticipants: 2,
                 tensorBackend: 'tfjs'
             }
         };

package/dist/default_tasks/titanic.js

@@ -62,7 +62,8 @@ export const titanic = {
                 outputColumns: [
                     'Survived'
                 ],
-                scheme: 'federated', // secure aggregation not yet implemented for FeAI
+                scheme: 'federated',
+                minNbOfParticipants: 2,
                 tensorBackend: 'tfjs'
             }
         };

package/dist/default_tasks/wikitext.js

@@ -26,6 +26,7 @@ export const wikitext = {
                 modelID: 'llm-raw-model',
                 preprocessingFunctions: [data.TextPreprocessing.Tokenize, data.TextPreprocessing.LeftPadding],
                 scheme: 'federated',
+                minNbOfParticipants: 2,
                 epochs: 6,
                 // Unused by wikitext because data already comes split
                 // But if set to 0 then the webapp doesn't display the validation metrics

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * as data from './dataset/index.js';
 export * as serialization from './serialization/index.js';
+export { Encoded as EncodedModel } from './serialization/model.js';
+export { Encoded as EncodedWeights } from './serialization/weights.js';
 export * as training from './training/index.js';
 export * as privacy from './privacy.js';
 export * as client from './client/index.js';
@@ -7,13 +9,14 @@ export * as aggregator from './aggregator/index.js';
 export { WeightsContainer, aggregation } from './weights/index.js';
 export { Logger, ConsoleLogger } from './logging/index.js';
 export { Memory, type ModelInfo, type ModelSource, Empty as EmptyMemory } from './memory/index.js';
-export { Disco, RoundLogs } from './training/index.js';
+export { Disco, RoundLogs, RoundStatus } from './training/index.js';
 export { Validator } from './validation/index.js';
 export { Model, BatchLogs, EpochLogs, ValidationMetrics } 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 * as async_iterator from "./utils/async_iterator.js";
+export { EventEmitter } from "./utils/event_emitter.js";
 export { Dataset } from "./dataset/index.js";
 export * from "./dataset/types.js";
 export * from "./types.js";

package/dist/index.js

@@ -14,6 +14,7 @@ export * as models from './models/index.js';
 export * from './task/index.js';
 export * as defaultTasks from './default_tasks/index.js';
 export * as async_iterator from "./utils/async_iterator.js";
+export { EventEmitter } from "./utils/event_emitter.js";
 export { Dataset } from "./dataset/index.js";
 export * from "./dataset/types.js"; // TODO merge with above
 export * from "./types.js";

package/dist/logging/logger.d.ts

@@ -1,6 +1,6 @@
 export interface Logger {
     /**
-     * Logs sucess message (in green)
+     * Logs success message (in green)
      * @param message - message to be displayed
      */
     success(message: string): void;

package/dist/task/index.d.ts

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

package/dist/task/index.js

@@ -1,4 +1,3 @@
 export { isTask, isTaskID } from './task.js';
-export { isDigest } from './digest.js';
 export { isDisplayInformation } from './display_information.js';
 export { pushTask, fetchTasks } from './task_handler.js';

package/dist/task/task.d.ts

@@ -1,10 +1,8 @@
 import { type DisplayInformation } from './display_information.js';
 import { type TrainingInformation } from './training_information.js';
-import { type Digest } from './digest.js';
 export type TaskID = string;
 export interface Task {
     id: TaskID;
-    digest?: Digest;
     displayInformation: DisplayInformation;
     trainingInformation: TrainingInformation;
 }

package/dist/task/task.js

@@ -1,6 +1,5 @@
 import { isDisplayInformation } from './display_information.js';
 import { isTrainingInformation } from './training_information.js';
-import { isDigest } from './digest.js';
 export function isTaskID(obj) {
     return typeof obj === 'string';
 }
@@ -8,14 +7,13 @@ export function isTask(raw) {
     if (typeof raw !== 'object' || raw === null) {
         return false;
     }
-    const { id, digest, displayInformation, trainingInformation } = raw;
+    const { id, displayInformation, trainingInformation } = raw;
     if (!isTaskID(id) ||
-        (digest !== undefined && !isDigest(digest)) ||
         !isDisplayInformation(displayInformation) ||
         !isTrainingInformation(trainingInformation)) {
         return false;
     }
-    const repack = { id, digest, displayInformation, trainingInformation };
+    const repack = { id, displayInformation, trainingInformation };
     const _correct = repack;
     const _total = repack;
     return true;

package/dist/task/training_information.d.ts

@@ -21,7 +21,7 @@ export interface TrainingInformation {
     privacy?: Privacy;
     decentralizedSecure?: boolean;
     maxShareValue?: number;
-    minimumReadyPeers?: number;
+    minNbOfParticipants: number;
     aggregator?: 'mean' | 'secure';
     tokenizer?: string | PreTrainedTokenizer;
     maxSequenceLength?: number;

package/dist/task/training_information.js

@@ -24,20 +24,20 @@ export function isTrainingInformation(raw) {
     if (typeof raw !== 'object' || raw === null) {
         return false;
     }
-    const { IMAGE_H, IMAGE_W, LABEL_LIST, aggregator, batchSize, dataType, decentralizedSecure, privacy, epochs, inputColumns, maxShareValue, minimumReadyPeers, modelID, outputColumns, preprocessingFunctions, roundDuration, scheme, validationSplit, tokenizer, maxSequenceLength, tensorBackend } = raw;
+    const { IMAGE_H, IMAGE_W, LABEL_LIST, aggregator, batchSize, dataType, decentralizedSecure, privacy, epochs, inputColumns, maxShareValue, minNbOfParticipants, modelID, outputColumns, preprocessingFunctions, roundDuration, scheme, validationSplit, tokenizer, maxSequenceLength, tensorBackend } = raw;
     if (typeof dataType !== 'string' ||
         typeof modelID !== 'string' ||
         typeof epochs !== 'number' ||
         typeof batchSize !== 'number' ||
         typeof roundDuration !== 'number' ||
         typeof validationSplit !== 'number' ||
+        typeof minNbOfParticipants !== 'number' ||
         (tokenizer !== undefined && typeof tokenizer !== 'string' && !(tokenizer instanceof PreTrainedTokenizer)) ||
         (maxSequenceLength !== undefined && typeof maxSequenceLength !== 'number') ||
         (aggregator !== undefined && typeof aggregator !== 'string') ||
         (decentralizedSecure !== undefined && typeof decentralizedSecure !== 'boolean') ||
         (privacy !== undefined && !isPrivacy(privacy)) ||
         (maxShareValue !== undefined && typeof maxShareValue !== 'number') ||
-        (minimumReadyPeers !== undefined && typeof minimumReadyPeers !== 'number') ||
         (IMAGE_H !== undefined && typeof IMAGE_H !== 'number') ||
         (IMAGE_W !== undefined && typeof IMAGE_W !== 'number') ||
         (LABEL_LIST !== undefined && !isStringArray(LABEL_LIST)) ||
@@ -96,7 +96,7 @@ export function isTrainingInformation(raw) {
         epochs,
         inputColumns,
         maxShareValue,
-        minimumReadyPeers,
+        minNbOfParticipants,
         modelID,
         outputColumns,
         preprocessingFunctions,