@epfml/discojs 2.1.2-p20240723143623.0 → 2.1.2-p20240723160120.0

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/training_information.d.ts

@@ -1,5 +1,9 @@
 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;
@@ -14,8 +18,7 @@ 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;
@@ -25,3 +28,4 @@ export interface TrainingInformation {
     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' ||
@@ -20,11 +34,10 @@ export function isTrainingInformation(raw) {
         (tokenizer !== undefined && typeof tokenizer !== 'string' && !(tokenizer instanceof PreTrainedTokenizer)) ||
         (maxSequenceLength !== undefined && typeof maxSequenceLength !== 'number') ||
         (aggregator !== undefined && typeof aggregator !== 'string') ||
-        (clippingRadius !== undefined && typeof clippingRadius !== 'number') ||
         (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)) ||
@@ -77,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 trainerPromise;
-    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 {};

package/dist/training/disco.js

@@ -1,52 +1,73 @@
-import { List } from 'immutable';
-import { async_iterator } from '../index.js';
-import { client as clients, EmptyMemory, ConsoleLogger } from '../index.js';
-import { getAggregator } from '../aggregator/index.js';
-import { enumerate, split } from '../utils/async_iterator.js';
-import { TrainerBuilder } from './trainer/trainer_builder.js';
+import { async_iterator, } from "../index.js";
+import { client as clients, ConsoleLogger, EmptyMemory } from "../index.js";
+import { getAggregator } from "../aggregator/index.js";
+import { enumerate, split } from "../utils/async_iterator.js";
+import { Trainer } from "./trainer.js";
 /**
  * Top-level class handling distributed training from a client's perspective. It is meant to be
  * a convenient object providing a reduced yet complete API that wraps model training,
  * communication with nodes, logs and model memory.
  */
 export class Disco {
-    task;
-    logger;
-    memory;
-    client;
-    trainerPromise;
-    constructor(task, options) {
-        // Fill undefined options with default values
-        if (options.scheme === undefined) {
-            options.scheme = task.trainingInformation.scheme;
+    trainer;
+    #client;
+    #logger;
+    // small helper to avoid keeping Task & Memory around
+    #updateWorkingModel;
+    constructor(trainer, task, client, memory, logger) {
+        this.trainer = trainer;
+        this.#client = client;
+        this.#logger = logger;
+        this.#updateWorkingModel = () => memory.updateWorkingModel({
+            type: "working",
+            taskID: task.id,
+            name: task.trainingInformation.modelID,
+            tensorBackend: task.trainingInformation.tensorBackend,
+        }, this.trainer.model);
+    }
+    /**
+     * 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 async fromTask(task, clientConfig, config) {
+        const { scheme, logger, memory } = {
+            scheme: task.trainingInformation.scheme,
+            logger: new ConsoleLogger(),
+            memory: new EmptyMemory(),
+            ...config,
+        };
+        let client;
+        if (clientConfig instanceof clients.Client) {
+            client = clientConfig;
         }
-        if (options.client === undefined) {
-            if (options.url === undefined) {
-                throw new Error('could not determine client from given parameters');
-            }
-            if (options.aggregator === undefined) {
-                options.aggregator = getAggregator(task, { scheme: options.scheme });
+        else {
+            let url, aggregator;
+            if (clientConfig instanceof URL) {
+                url = clientConfig;
+                aggregator = getAggregator(task, { scheme });
             }
-            if (typeof options.url === 'string') {
-                options.url = new URL(options.url);
+            else {
+                ({ url, aggregator } = clientConfig);
             }
-            options.client = clients.getClient(options.scheme, options.url, task, options.aggregator);
-        }
-        if (options.logger === undefined) {
-            options.logger = new ConsoleLogger();
-        }
-        if (options.memory === undefined) {
-            options.memory = new EmptyMemory();
-        }
-        if (options.client.task !== task) {
-            throw new Error('client not setup for given task');
+            client = clients.getClient(scheme, url, task, aggregator);
         }
-        this.task = task;
-        this.client = options.client;
-        this.memory = options.memory;
-        this.logger = options.logger;
-        const trainerBuilder = new TrainerBuilder(this.memory, this.task);
-        this.trainerPromise = trainerBuilder.build(this.client, options.scheme !== 'local');
+        if (client.task !== task)
+            throw new Error("client not setup for given task");
+        let model;
+        const memoryInfo = {
+            type: "working",
+            taskID: task.id,
+            name: task.trainingInformation.modelID,
+            tensorBackend: task.trainingInformation.tensorBackend,
+        };
+        if (await memory.contains(memoryInfo))
+            model = await memory.getModel(memoryInfo);
+        else
+            model = await client.getLatestModel();
+        return new Disco(new Trainer(task, model, client), task, client, memory, logger);
     }
     /** Train on dataset, yielding logs of every round. */
     async *trainByRound(dataTuple) {
@@ -83,27 +104,24 @@ export class Disco {
                     ;
     }
     /**
-    * 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.
-    **/
-    // TODO RoundLogs should contain number of participants but Trainer doesn't need client
+     * 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.
+     **/
     async *train(dataTuple) {
-        this.logger.success("Training started.");
+        this.#logger.success("Training started.");
         const trainData = dataTuple.train.preprocess().batch();
         const validationData = dataTuple.validation?.preprocess().batch() ?? trainData;
-        await this.client.connect();
-        const trainer = await this.trainerPromise;
-        for await (const [round, epochs] of enumerate(trainer.fitModel(trainData.dataset, validationData.dataset))) {
+        await this.#client.connect();
+        for await (const [round, epochs] of enumerate(this.trainer.train(trainData.dataset, validationData.dataset))) {
             yield async function* () {
-                let epochsLogs = List();
-                for await (const [epoch, batches] of enumerate(epochs)) {
+                const [gen, returnedRoundLogs] = split(epochs);
+                for await (const [epoch, batches] of enumerate(gen)) {
                     const [gen, returnedEpochLogs] = split(batches);
                     yield gen;
                     const epochLogs = await returnedEpochLogs;
-                    epochsLogs = epochsLogs.push(epochLogs);
-                    this.logger.success([
+                    this.#logger.success([
                         `Round: ${round}`,
                         `  Epoch: ${epoch}`,
                         `    Training loss: ${epochLogs.training.loss}`,
@@ -116,26 +134,23 @@ export class Disco {
                             : "",
                     ].join("\n"));
                 }
-                return {
-                    epochs: epochsLogs,
-                    participants: this.client.nbOfParticipants, // already includes ourselves
-                };
+                return await returnedRoundLogs;
             }.bind(this)();
+            await this.#updateWorkingModel(this.trainer.model);
         }
-        this.logger.success("Training finished.");
+        this.#logger.success("Training finished.");
     }
     /**
      * Stops the ongoing training instance without disconnecting the client.
      */
     async pause() {
-        const trainer = await this.trainerPromise;
-        await trainer.stopTraining();
+        await this.trainer.stopTraining();
     }
     /**
      * Completely stops the ongoing training instance.
      */
     async close() {
         await this.pause();
-        await this.client.disconnect();
+        await this.#client.disconnect();
     }
 }

package/dist/training/index.d.ts

@@ -1,2 +1,2 @@
 export { Disco } from './disco.js';
-export { RoundLogs } from './trainer/trainer.js';
+export { RoundLogs, Trainer } from './trainer.js';

package/dist/training/index.js

@@ -1 +1,2 @@
 export { Disco } from './disco.js';
+export { Trainer } from './trainer.js';

package/dist/training/trainer.d.ts

@@ -0,0 +1,16 @@
+import * as tf from "@tensorflow/tfjs";
+import { List } from "immutable";
+import type { BatchLogs, EpochLogs, Model, Task } from "../index.js";
+import { Client } from "../client/index.js";
+export interface RoundLogs {
+    epochs: List<EpochLogs>;
+    participants: number;
+}
+/** Train a model and exchange with others **/
+export declare class Trainer {
+    #private;
+    readonly model: Model;
+    constructor(task: Task, model: Model, client: Client);
+    stopTraining(): Promise<void>;
+    train(dataset: tf.data.Dataset<tf.TensorContainer>, valDataset: tf.data.Dataset<tf.TensorContainer>): AsyncGenerator<AsyncGenerator<AsyncGenerator<BatchLogs, EpochLogs>, RoundLogs>, void>;
+}

package/dist/training/trainer.js

@@ -0,0 +1,72 @@
+import * as tf from "@tensorflow/tfjs";
+import { List } from "immutable";
+import { privacy } from "../index.js";
+import * as async_iterator from "../utils/async_iterator.js";
+/** Train a model and exchange with others **/
+export class Trainer {
+    model;
+    #client;
+    #roundDuration;
+    #epochs;
+    #privacy;
+    #training;
+    constructor(task, model, client) {
+        this.model = model;
+        this.#client = client;
+        this.#roundDuration = task.trainingInformation.roundDuration;
+        this.#epochs = task.trainingInformation.epochs;
+        this.#privacy = task.trainingInformation.privacy;
+        if (!Number.isInteger(this.#epochs / this.#roundDuration))
+            throw new Error(`round duration ${this.#roundDuration} doesn't divide number of epochs ${this.#epochs}`);
+    }
+    async stopTraining() {
+        await this.#training?.return();
+    }
+    async *train(dataset, valDataset) {
+        if (this.#training !== undefined)
+            throw new Error("training already running, stop it before launching a new one");
+        try {
+            this.#training = this.#runRounds(dataset, valDataset);
+            yield* this.#training;
+        }
+        finally {
+            this.#training = undefined;
+        }
+    }
+    async *#runRounds(dataset, valDataset) {
+        const totalRound = Math.trunc(this.#epochs / this.#roundDuration);
+        let previousRoundWeights;
+        for (let round = 0; round < totalRound; round++) {
+            await this.#client.onRoundBeginCommunication(this.model.weights, round);
+            yield this.#runRound(dataset, valDataset);
+            let localWeights = this.model.weights;
+            if (this.#privacy !== undefined)
+                localWeights = await applyPrivacy(previousRoundWeights, localWeights, this.#privacy);
+            const networkWeights = await this.#client.onRoundEndCommunication(localWeights, round);
+            this.model.weights = previousRoundWeights = networkWeights;
+        }
+    }
+    async *#runRound(dataset, valDataset) {
+        let epochsLogs = List();
+        for (let epoch = 0; epoch < this.#roundDuration; epoch++) {
+            const [gen, epochLogs] = async_iterator.split(this.model.train(dataset, valDataset));
+            yield gen;
+            epochsLogs = epochsLogs.push(await epochLogs);
+        }
+        return {
+            epochs: epochsLogs,
+            participants: this.#client.nbOfParticipants,
+        };
+    }
+}
+async function applyPrivacy(previous, current, options) {
+    let ret = current;
+    if (options.clippingRadius !== undefined) {
+        const previousRoundWeights = previous ?? current.map((w) => tf.zerosLike(w));
+        const weightsProgress = current.sub(previousRoundWeights);
+        ret = previousRoundWeights.add(await privacy.clipNorm(weightsProgress, options.clippingRadius));
+    }
+    if (options.noiseScale !== undefined)
+        ret = privacy.addNoise(ret, options.noiseScale);
+    return ret;
+}

package/dist/weights/weights_container.d.ts

@@ -51,11 +51,6 @@ export declare class WeightsContainer {
      * @returns The tensor located at the index
      */
     get(index: number): tf.Tensor | undefined;
-    /**
-     * Computes the weights container's Frobenius norm
-     * @returns The Frobenius norm
-     */
-    frobeniusNorm(): number;
     concat(other: WeightsContainer): WeightsContainer;
     equals(other: WeightsContainer, margin?: number): boolean;
     /**

package/dist/weights/weights_container.js

@@ -70,13 +70,6 @@ export class WeightsContainer {
     get(index) {
         return this._weights.get(index);
     }
-    /**
-     * Computes the weights container's Frobenius norm
-     * @returns The Frobenius norm
-     */
-    frobeniusNorm() {
-        return Math.sqrt(this.map((w) => w.square().sum()).reduce((a, b) => a.add(b)).dataSync()[0]);
-    }
     concat(other) {
         return WeightsContainer.of(...this.weights, ...other.weights);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epfml/discojs",
-  "version": "2.1.2-p20240723143623.0",
+  "version": "2.1.2-p20240723160120.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/async_informant.d.ts

@@ -1,15 +0,0 @@
-import type { AggregatorBase } from './aggregator/index.js';
-export declare class AsyncInformant<T> {
-    private readonly aggregator;
-    private _round;
-    private _currentNumberOfParticipants;
-    private _totalNumberOfParticipants;
-    private _averageNumberOfParticipants;
-    constructor(aggregator: AggregatorBase<T>);
-    update(): void;
-    get round(): number;
-    get currentNumberOfParticipants(): number;
-    get totalNumberOfParticipants(): number;
-    get averageNumberOfParticipants(): number;
-    getAllStatistics(): Record<'round' | 'currentNumberOfParticipants' | 'totalNumberOfParticipants' | 'averageNumberOfParticipants', number>;
-}

package/dist/async_informant.js

@@ -1,42 +0,0 @@
-export class AsyncInformant {
-    aggregator;
-    _round = 0;
-    _currentNumberOfParticipants = 0;
-    _totalNumberOfParticipants = 0;
-    _averageNumberOfParticipants = 0;
-    constructor(aggregator) {
-        this.aggregator = aggregator;
-    }
-    update() {
-        if (this.round === 0 || this.round < this.aggregator.round) {
-            this._round = this.aggregator.round;
-            this._currentNumberOfParticipants = this.aggregator.size;
-            this._averageNumberOfParticipants = this.totalNumberOfParticipants / this.round;
-            this._totalNumberOfParticipants += this.currentNumberOfParticipants;
-        }
-        else {
-            this._round = this.aggregator.round;
-        }
-    }
-    // Getter functions
-    get round() {
-        return this._round;
-    }
-    get currentNumberOfParticipants() {
-        return this._currentNumberOfParticipants;
-    }
-    get totalNumberOfParticipants() {
-        return this._totalNumberOfParticipants;
-    }
-    get averageNumberOfParticipants() {
-        return this._averageNumberOfParticipants;
-    }
-    getAllStatistics() {
-        return {
-            round: this.round,
-            currentNumberOfParticipants: this.currentNumberOfParticipants,
-            totalNumberOfParticipants: this.totalNumberOfParticipants,
-            averageNumberOfParticipants: this.averageNumberOfParticipants
-        };
-    }
-}

package/dist/training/trainer/distributed_trainer.d.ts

@@ -1,20 +0,0 @@
-import type { Model, Memory, Task, client as clients } from "../../index.js";
-import { Trainer } from "./trainer.js";
-/**
- * Class whose role is to train a model in a distributed way with a given dataset.
- */
-export declare class DistributedTrainer extends Trainer {
-    private readonly task;
-    private readonly memory;
-    private readonly client;
-    private readonly aggregator;
-    /**
-     * DistributedTrainer constructor, accepts same arguments as Trainer and in additional also a client who takes care of communicating weights.
-     */
-    constructor(task: Task, memory: Memory, model: Model, client: clients.Client);
-    onRoundBegin(round: number): Promise<void>;
-    /**
-     * Callback called every time a round is over
-     */
-    onRoundEnd(round: number): Promise<void>;
-}