@epfml/discojs 2.2.1 → 3.0.0

package/dist/client/index.js

@@ -4,5 +4,5 @@ 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 * as utils from './utils.js';
+export { getClient, timeout } from './utils.js';
 export { Local } from './local.js';

package/dist/client/local.d.ts

@@ -1,3 +1,5 @@
-import { Base } from './base.js';
+import { WeightsContainer } from "../weights/weights_container.js";
+import { Base } from "./base.js";
 export declare class Local extends Base {
+    onRoundEndCommunication(weights: WeightsContainer): Promise<WeightsContainer>;
 }

package/dist/client/local.js

@@ -1,3 +1,6 @@
-import { Base } from './base.js';
+import { Base } from "./base.js";
 export class Local extends Base {
+    onRoundEndCommunication(weights) {
+        return Promise.resolve(weights);
+    }
 }

package/dist/client/messages.d.ts

@@ -9,8 +9,7 @@ export declare enum type {
     PeersForRound = 4,
     Payload = 5,
     SendPayload = 6,
-    ReceiveServerMetadata = 7,
-    ReceiveServerPayload = 8
+    ReceiveServerPayload = 7
 }
 export interface ClientConnected {
     type: type.ClientConnected;

package/dist/client/messages.js

@@ -1,16 +1,21 @@
 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
     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
+    /* Decentralized */
+    // Message forwarded by the server from a client to another client
+    // to establish a peer-to-peer (WebRTC) connection
     type[type["SignalForPeer"] = 2] = "SignalForPeer";
     type[type["PeerIsReady"] = 3] = "PeerIsReady";
     type[type["PeersForRound"] = 4] = "PeersForRound";
     type[type["Payload"] = 5] = "Payload";
     // Federated
     type[type["SendPayload"] = 6] = "SendPayload";
-    type[type["ReceiveServerMetadata"] = 7] = "ReceiveServerMetadata";
-    type[type["ReceiveServerPayload"] = 8] = "ReceiveServerPayload";
+    type[type["ReceiveServerPayload"] = 7] = "ReceiveServerPayload";
 })(type || (type = {}));
 export function hasMessageType(raw) {
     if (typeof raw !== 'object' || raw === null) {

package/dist/client/utils.d.ts

@@ -1,2 +1,4 @@
-export declare const MAX_WAIT_PER_ROUND = 15000;
-export declare function timeout(ms?: number): Promise<never>;
+import type { Task } from '../index.js';
+import { client as clients, type aggregator } from '../index.js';
+export declare function timeout(ms?: number, errorMsg?: string): Promise<never>;
+export declare function getClient(trainingScheme: Required<Task['trainingInformation']['scheme']>, serverURL: URL, task: Task, aggregator: aggregator.Aggregator): clients.Client;

package/dist/client/utils.js

@@ -1,7 +1,22 @@
+import { client as clients } from '../index.js';
 // Time to wait for the others in milliseconds.
-export const MAX_WAIT_PER_ROUND = 15_000;
-export async function timeout(ms = MAX_WAIT_PER_ROUND) {
+const MAX_WAIT_PER_ROUND = 15_000;
+export async function timeout(ms = MAX_WAIT_PER_ROUND, errorMsg = 'timeout') {
     return await new Promise((_, reject) => {
-        setTimeout(() => { reject(new Error('timeout')); }, ms);
+        setTimeout(() => { reject(new Error(errorMsg)); }, ms);
     });
 }
+export function getClient(trainingScheme, serverURL, task, aggregator) {
+    switch (trainingScheme) {
+        case 'decentralized':
+            return new clients.decentralized.DecentralizedClient(serverURL, task, aggregator);
+        case 'federated':
+            return new clients.federated.FederatedClient(serverURL, task, aggregator);
+        case 'local':
+            return new clients.Local(serverURL, task, aggregator);
+        default: {
+            const _ = trainingScheme;
+            throw new Error('should never happen');
+        }
+    }
+}

package/dist/dataset/data/data.d.ts

@@ -1,4 +1,4 @@
-import type tf from '@tensorflow/tfjs';
+import * as tf from '@tensorflow/tfjs';
 import type { List } from 'immutable';
 import type { Task } from '../../index.js';
 import type { Dataset } from '../index.js';

package/dist/dataset/data/data.js

@@ -1,3 +1,4 @@
+import * as tf from '@tensorflow/tfjs';
 /**
  * Abstract class representing an immutable Disco dataset, including a TF.js dataset,
  * Disco task and set of preprocessing functions.
@@ -59,8 +60,18 @@ export class Data {
         if (applyPreprocessing.size === 0) {
             return x => Promise.resolve(x);
         }
-        const preprocessingChain = applyPreprocessing.reduce((acc, fn) => x => fn(acc(x), this.task), (x) => x);
-        return x => preprocessingChain(Promise.resolve(x));
+        const preprocessingChain = async (input) => {
+            let currentContainer = await input; // Start with the initial tensor container
+            for (const fn of applyPreprocessing) {
+                const newContainer = await fn(Promise.resolve(currentContainer), this.task);
+                if (currentContainer !== newContainer) {
+                    tf.dispose(currentContainer); // Dispose of the old container
+                }
+                currentContainer = newContainer;
+            }
+            return currentContainer; // Return the final tensor container
+        };
+        return async (entry) => await preprocessingChain(Promise.resolve(entry));
     }
     /**
      * The TF.js dataset preprocessing according to the set of preprocessing functions and the task's

package/dist/dataset/data/preprocessing/image_preprocessing.js

@@ -25,10 +25,12 @@ const normalize = {
     type: ImagePreprocessing.Normalize,
     apply: async (entry) => {
         const { xs, ys } = await entry;
-        return {
-            xs: xs.div(tf.scalar(255)),
-            ys
-        };
+        return tf.tidy(() => {
+            return {
+                xs: xs.div(tf.scalar(255)),
+                ys
+            };
+        });
     }
 };
 /**

package/dist/default_tasks/cifar10.js

@@ -30,8 +30,7 @@ export const cifar10 = {
                 IMAGE_W: 224,
                 LABEL_LIST: ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'],
                 scheme: 'decentralized',
-                noiseScale: undefined,
-                clippingRadius: 20,
+                privacy: { clippingRadius: 20, noiseScale: 1 },
                 decentralizedSecure: true,
                 minimumReadyPeers: 3,
                 maxShareValue: 100,

package/dist/default_tasks/lus_covid.js

@@ -29,11 +29,6 @@ export const lusCovid = {
                 LABEL_LIST: ['COVID-Positive', 'COVID-Negative'],
                 dataType: 'image',
                 scheme: 'federated',
-                noiseScale: undefined,
-                clippingRadius: 20,
-                decentralizedSecure: true,
-                minimumReadyPeers: 2,
-                maxShareValue: 100,
                 tensorBackend: 'tfjs'
             }
         };

package/dist/default_tasks/mnist.js

@@ -20,17 +20,16 @@ export const mnist = {
             trainingInformation: {
                 modelID: 'mnist-model',
                 epochs: 20,
-                roundDuration: 10,
+                roundDuration: 2,
                 validationSplit: 0.2,
-                batchSize: 30,
+                batchSize: 64,
                 dataType: 'image',
                 IMAGE_H: 28,
                 IMAGE_W: 28,
-                preprocessingFunctions: [data.ImagePreprocessing.Normalize],
+                // Images should already be at the right size but resizing just in case
+                preprocessingFunctions: [data.ImagePreprocessing.Resize, data.ImagePreprocessing.Normalize],
                 LABEL_LIST: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
                 scheme: 'decentralized',
-                noiseScale: undefined,
-                clippingRadius: 20,
                 decentralizedSecure: true,
                 minimumReadyPeers: 3,
                 maxShareValue: 100,
@@ -39,22 +38,24 @@ export const mnist = {
         };
     },
     getModel() {
+        // Architecture from the PyTorch MNIST example (I made it slightly smaller, 650kB instead of 5MB)
+        // https://github.com/pytorch/examples/blob/main/mnist/main.py
         const model = tf.sequential();
         model.add(tf.layers.conv2d({
             inputShape: [28, 28, 3],
-            kernelSize: 3,
-            filters: 16,
-            activation: 'relu'
+            kernelSize: 5,
+            filters: 8,
+            activation: 'relu',
         }));
+        model.add(tf.layers.conv2d({ kernelSize: 5, 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.dropout({ rate: 0.25 }));
+        model.add(tf.layers.flatten());
+        model.add(tf.layers.dense({ units: 32, activation: 'relu' }));
+        model.add(tf.layers.dropout({ rate: 0.25 }));
         model.add(tf.layers.dense({ units: 10, activation: 'softmax' }));
         model.compile({
-            optimizer: 'rmsprop',
+            optimizer: 'adam',
             loss: 'categoricalCrossentropy',
             metrics: ['accuracy']
         });

package/dist/default_tasks/simple_face.js

@@ -29,8 +29,6 @@ export const simpleFace = {
                 IMAGE_W: 200,
                 LABEL_LIST: ['child', 'adult'],
                 scheme: 'federated', // secure aggregation not yet implemented for federated
-                noiseScale: undefined,
-                clippingRadius: undefined,
                 tensorBackend: 'tfjs'
             }
         };

package/dist/default_tasks/titanic.js

@@ -46,8 +46,8 @@ export const titanic = {
             },
             trainingInformation: {
                 modelID: 'titanic-model',
-                epochs: 40,
-                roundDuration: 10,
+                epochs: 10,
+                roundDuration: 2,
                 validationSplit: 0.2,
                 batchSize: 30,
                 preprocessingFunctions: [data.TabularPreprocessing.Sanitize],
@@ -63,8 +63,6 @@ export const titanic = {
                     'Survived'
                 ],
                 scheme: 'federated', // secure aggregation not yet implemented for FeAI
-                noiseScale: undefined,
-                clippingRadius: undefined,
                 tensorBackend: 'tfjs'
             }
         };

package/dist/default_tasks/wikitext.js

@@ -9,7 +9,13 @@ export const wikitext = {
                     preview: 'Train a language model (L)LM in your browser, collaboratively and from scratch.',
                     overview: "You can train a GPT-2 model in your browser and in a collaborative manner on any textual dataset. As an example, you can try the Wikitext-103 dataset, composed of Wikipedia articles, widely used in natural language modeling, which you can download <a class='underline text-blue-400' target='_blank' href='https://dax-cdn.cdn.appdomain.cloud/dax-wikitext-103/1.0.1/wikitext-103.tar.gz'>here</a>. More information on how to connect the dataset at the next step."
                 },
-                model: 'The model follows the exact GPT-2 architecture and is implemented in TensorFlow.js. The tokenizer used for preprocessing is the GPT-2 Byte-Pair encoding tokenizer. The model is trained via an Adam optimizer with unit gradient clipping and softmax cross-entropy loss. To accommodate all devices, the context length is currently kept at 128 and the batch size at 1.',
+                model: [
+                    "The model follows the exact GPT-2 architecture and is implemented in TensorFlow.js.",
+                    "The tokenizer used for preprocessing is the GPT-2 Byte-Pair encoding tokenizer.",
+                    "The model is trained via an Adam optimizer with unit gradient clipping and softmax cross-entropy loss.",
+                    "It has around 5M parameters.",
+                    "To accommodate all devices, the context length is currently kept at 128 and the batch size at 1.",
+                ].join(" "),
                 dataFormatInformation: 'You can use any natural language (text) dataset you like. For example the Wikitext-103 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 is: <i>"For the first twenty years of its existence , the only staged performances of Parsifal took place in the Bayreuth Festspielhaus , the venue for which Wagner conceived the work ( except eight private performances for Ludwig II at Munich in 1884 and 1885 ) ."</i>',
                 sampleDatasetLink: 'https://dax-cdn.cdn.appdomain.cloud/dax-wikitext-103/1.0.1/wikitext-103.tar.gz',

package/dist/index.d.ts

@@ -5,7 +5,6 @@ export * as privacy from './privacy.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, type ModelInfo, type Path, type ModelSource, Empty as EmptyMemory } from './memory/index.js';
 export { Disco, RoundLogs } from './training/index.js';

package/dist/index.js

@@ -5,7 +5,6 @@ export * as privacy from './privacy.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, Empty as EmptyMemory } from './memory/index.js';
 export { Disco } from './training/index.js';

package/dist/models/gpt/config.js

@@ -3,7 +3,7 @@ export const DEFAULT_CONFIG = {
     name: 'transformer',
     lr: 0.001,
     weightDecay: 0,
-    maxIter: 5,
+    maxIter: 10,
     verbose: 0,
     modelType: 'gpt-nano',
     evaluate: true,

package/dist/privacy.d.ts

@@ -1,11 +1,9 @@
-import type { Task, WeightsContainer } from './index.js';
+import type { WeightsContainer } from "./index.js";
+/** Scramble weights */
+export declare function addNoise(weights: WeightsContainer, deviation: number): WeightsContainer;
 /**
- * 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.
- * The current round's weights are obtained after a single round of training, from the previous round's weights.
- * @param updatedWeights weights from the current round
- * @param staleWeights weights from the previous round
- * @param task the task
- * @returns the noised weights for the current round
- */
-export declare function addDifferentialPrivacy(updatedWeights: WeightsContainer, staleWeights: WeightsContainer, task: Task): WeightsContainer;
+ * Keep weights' norm within radius
+ *
+ * @param radius maximum norm
+ **/
+export declare function clipNorm(weights: WeightsContainer, radius: number): Promise<WeightsContainer>;

package/dist/privacy.js

@@ -1,42 +1,27 @@
-import * as tf from '@tensorflow/tfjs';
+import * as tf from "@tensorflow/tfjs";
+async function frobeniusNorm(weights) {
+    const squared = await weights
+        .map((w) => w.square().sum())
+        .reduce((a, b) => a.add(b))
+        .data();
+    if (squared.length !== 1)
+        throw new Error("unexcepted weights shape");
+    return Math.sqrt(squared[0]);
+}
+/** Scramble weights */
+export function addNoise(weights, deviation) {
+    const variance = Math.pow(deviation, 2);
+    return weights.map((w) => w.add(tf.randomNormal(w.shape, 0, variance)));
+}
 /**
- * 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.
- * The current round's weights are obtained after a single round of training, from the previous round's weights.
- * @param updatedWeights weights from the current round
- * @param staleWeights weights from the previous round
- * @param task the task
- * @returns the noised weights for the current round
- */
-export function addDifferentialPrivacy(updatedWeights, staleWeights, task) {
-    const noiseScale = task.trainingInformation?.noiseScale;
-    const clippingRadius = task.trainingInformation?.clippingRadius;
-    const weightsDiff = updatedWeights.sub(staleWeights);
-    let newWeightsDiff;
-    if (clippingRadius !== undefined) {
-        // Frobenius norm
-        const norm = weightsDiff.frobeniusNorm();
-        newWeightsDiff = weightsDiff.map((w) => {
-            const clipped = w.div(Math.max(1, norm / clippingRadius));
-            if (noiseScale !== undefined) {
-                // Add clipping and noise
-                const noise = tf.randomNormal(w.shape, 0, (noiseScale * noiseScale) * (clippingRadius * clippingRadius));
-                return clipped.add(noise);
-            }
-            else {
-                // Add clipping without any noise
-                return clipped;
-            }
-        });
-    }
-    else {
-        if (noiseScale !== undefined) {
-            // Add noise without any clipping
-            newWeightsDiff = weightsDiff.map((w) => tf.randomNormal(w.shape, 0, (noiseScale * noiseScale)));
-        }
-        else {
-            return updatedWeights;
-        }
-    }
-    return staleWeights.add(newWeightsDiff);
+ * Keep weights' norm within radius
+ *
+ * @param radius maximum norm
+ **/
+export async function clipNorm(weights, radius) {
+    if (radius <= 0)
+        throw new Error("invalid radius");
+    const norm = await frobeniusNorm(weights);
+    const scaling = Math.max(1, norm / radius);
+    return weights.map((w) => w.div(scaling));
 }

package/dist/task/task_handler.js

@@ -13,8 +13,16 @@ export async function pushTask(url, task, model) {
 export async function fetchTasks(url) {
     const response = await axios.get(new URL(TASK_ENDPOINT, url).href);
     const tasks = response.data;
-    if (!(Array.isArray(tasks) && tasks.every(isTask))) {
-        throw new Error('invalid tasks response');
+    if (!Array.isArray(tasks)) {
+        throw new Error('Expected to receive an array of Tasks when fetching tasks');
+    }
+    else if (!tasks.every(isTask)) {
+        for (const task of tasks) {
+            if (!isTask(task)) {
+                console.error("task has invalid format:", task);
+            }
+        }
+        throw new Error('invalid tasks response, the task object received is not well formatted');
     }
     return Map(tasks.map((t) => [t.id, t]));
 }

package/dist/task/training_information.d.ts

@@ -1,6 +1,9 @@
-import type { AggregatorChoice } from '../aggregator/get.js';
 import type { Preprocessing } from '../dataset/data/preprocessing/index.js';
 import { PreTrainedTokenizer } from '@xenova/transformers';
+interface Privacy {
+    clippingRadius?: number;
+    noiseScale?: number;
+}
 export interface TrainingInformation {
     modelID: string;
     epochs: number;
@@ -15,14 +18,14 @@ export interface TrainingInformation {
     IMAGE_W?: number;
     LABEL_LIST?: string[];
     scheme: 'decentralized' | 'federated' | 'local';
-    noiseScale?: number;
-    clippingRadius?: number;
+    privacy?: Privacy;
     decentralizedSecure?: boolean;
     maxShareValue?: number;
     minimumReadyPeers?: number;
-    aggregator?: AggregatorChoice;
+    aggregator?: 'mean' | 'secure';
     tokenizer?: string | PreTrainedTokenizer;
     maxSequenceLength?: number;
     tensorBackend: 'tfjs' | 'gpt';
 }
 export declare function isTrainingInformation(raw: unknown): raw is TrainingInformation;
+export {};

package/dist/task/training_information.js

@@ -6,11 +6,25 @@ function isStringArray(raw) {
     const arr = raw; // isArray is unsafely guarding with any[]
     return arr.every((e) => typeof e === 'string');
 }
+function isPrivacy(raw) {
+    if (typeof raw !== "object" || raw === null) {
+        return false;
+    }
+    const { clippingRadius, noiseScale, } = raw;
+    if ((clippingRadius !== undefined && typeof clippingRadius !== "number") ||
+        (noiseScale !== undefined && typeof noiseScale !== "number"))
+        return false;
+    const _ = {
+        clippingRadius,
+        noiseScale,
+    };
+    return true;
+}
 export function isTrainingInformation(raw) {
     if (typeof raw !== 'object' || raw === null) {
         return false;
     }
-    const { IMAGE_H, IMAGE_W, LABEL_LIST, aggregator, batchSize, clippingRadius, dataType, decentralizedSecure, epochs, inputColumns, maxShareValue, minimumReadyPeers, modelID, noiseScale, outputColumns, preprocessingFunctions, roundDuration, scheme, validationSplit, tokenizer, maxSequenceLength, tensorBackend } = raw;
+    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;
     if (typeof dataType !== 'string' ||
         typeof modelID !== 'string' ||
         typeof epochs !== 'number' ||
@@ -19,12 +33,11 @@ export function isTrainingInformation(raw) {
         typeof validationSplit !== 'number' ||
         (tokenizer !== undefined && typeof tokenizer !== 'string' && !(tokenizer instanceof PreTrainedTokenizer)) ||
         (maxSequenceLength !== undefined && typeof maxSequenceLength !== 'number') ||
-        (aggregator !== undefined && typeof aggregator !== 'number') ||
-        (clippingRadius !== undefined && typeof clippingRadius !== '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') ||
-        (noiseScale !== undefined && typeof noiseScale !== 'number') ||
         (IMAGE_H !== undefined && typeof IMAGE_H !== 'number') ||
         (IMAGE_W !== undefined && typeof IMAGE_W !== 'number') ||
         (LABEL_LIST !== undefined && !isStringArray(LABEL_LIST)) ||
@@ -33,6 +46,13 @@ export function isTrainingInformation(raw) {
         (preprocessingFunctions !== undefined && !Array.isArray(preprocessingFunctions))) {
         return false;
     }
+    if (aggregator !== undefined) {
+        switch (aggregator) {
+            case 'mean': break;
+            case 'secure': break;
+            default: return false;
+        }
+    }
     switch (dataType) {
         case 'image': break;
         case 'tabular': break;
@@ -70,15 +90,14 @@ export function isTrainingInformation(raw) {
         LABEL_LIST,
         aggregator,
         batchSize,
-        clippingRadius,
         dataType,
         decentralizedSecure,
+        privacy,
         epochs,
         inputColumns,
         maxShareValue,
         minimumReadyPeers,
         modelID,
-        noiseScale,
         outputColumns,
         preprocessingFunctions,
         roundDuration,

package/dist/training/disco.d.ts

@@ -1,14 +1,11 @@
-import { BatchLogs, data, EpochLogs, Logger, Memory, Task, TrainingInformation } from '../index.js';
-import { client as clients } from '../index.js';
-import type { Aggregator } from '../aggregator/index.js';
-import type { RoundLogs } from './trainer/trainer.js';
-export interface DiscoOptions {
-    client?: clients.Client;
-    aggregator?: Aggregator;
-    url?: string | URL;
-    scheme?: TrainingInformation['scheme'];
-    logger?: Logger;
-    memory?: Memory;
+import { data, BatchLogs, EpochLogs, Logger, Memory, Task, TrainingInformation } from "../index.js";
+import { client as clients } from "../index.js";
+import type { Aggregator } from "../aggregator/index.js";
+import { RoundLogs, Trainer } from "./trainer.js";
+interface Config {
+    scheme: TrainingInformation["scheme"];
+    logger: Logger;
+    memory: Memory;
 }
 /**
  * Top-level class handling distributed training from a client's perspective. It is meant to be
@@ -16,16 +13,22 @@ export interface DiscoOptions {
  * communication with nodes, logs and model memory.
  */
 export declare class Disco {
-    readonly task: Task;
-    readonly logger: Logger;
-    readonly memory: Memory;
-    private readonly client;
-    private readonly trainer;
-    constructor(task: Task, options: DiscoOptions);
+    #private;
+    readonly trainer: Trainer;
+    private constructor();
+    /**
+     * Connect to the given task and get ready to train.
+     *
+     * Will load the model from memory if available or fetch it from the server.
+     *
+     * @param clientConfig client to connect with or parameters on how to create one.
+     **/
+    static fromTask(task: Task, clientConfig: clients.Client | URL | {
+        aggregator: Aggregator;
+        url: URL;
+    }, config: Partial<Config>): Promise<Disco>;
     /** Train on dataset, yielding logs of every round. */
-    trainByRound(dataTuple: data.DataSplit): AsyncGenerator<RoundLogs & {
-        participants: number;
-    }>;
+    trainByRound(dataTuple: data.DataSplit): AsyncGenerator<RoundLogs>;
     /** Train on dataset, yielding logs of every epoch. */
     trainByEpoch(dataTuple: data.DataSplit): AsyncGenerator<EpochLogs>;
     /** Train on dataset, yielding logs of every batch. */
@@ -33,14 +36,12 @@ export declare class Disco {
     /** Run whole train on dataset. */
     trainFully(dataTuple: data.DataSplit): Promise<void>;
     /**
-    * Train on dataset, yield the nested steps.
-    *
-    * Don't forget to await the yielded generator otherwise nothing will progress.
-    * If you don't care about the whole process, use one of the other train methods.
-    **/
-    train(dataTuple: data.DataSplit): AsyncGenerator<AsyncGenerator<AsyncGenerator<BatchLogs, EpochLogs>, RoundLogs & {
-        participants: number;
-    }>>;
+     * Train on dataset, yield the nested steps.
+     *
+     * Don't forget to await the yielded generator otherwise nothing will progress.
+     * If you don't care about the whole process, use one of the other train methods.
+     **/
+    train(dataTuple: data.DataSplit): AsyncGenerator<AsyncGenerator<AsyncGenerator<BatchLogs, EpochLogs>, RoundLogs>>;
     /**
      * Stops the ongoing training instance without disconnecting the client.
      */
@@ -50,3 +51,4 @@ export declare class Disco {
      */
     close(): Promise<void>;
 }
+export {};