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

package/dist/training/trainer/distributed_trainer.js

@@ -1,41 +0,0 @@
-import { Trainer } from "./trainer.js";
-/**
- * Class whose role is to train a model in a distributed way with a given dataset.
- */
-export class DistributedTrainer extends Trainer {
-    task;
-    memory;
-    client;
-    aggregator;
-    /**
-     * DistributedTrainer constructor, accepts same arguments as Trainer and in additional also a client who takes care of communicating weights.
-     */
-    constructor(task, memory, model, client) {
-        super(task, model);
-        this.task = task;
-        this.memory = memory;
-        this.client = client;
-        this.aggregator = this.client.aggregator;
-        this.aggregator.setModel(model);
-    }
-    async onRoundBegin(round) {
-        await this.client.onRoundBeginCommunication(this.model.weights, round);
-    }
-    /**
-     * Callback called every time a round is over
-     */
-    async onRoundEnd(round) {
-        await this.client.onRoundEndCommunication(this.model.weights, round);
-        if (this.aggregator.model !== undefined) {
-            // The aggregator's own aggregation is async. The trainer updates its model to match the aggregator's
-            // after it has completed a round of training.
-            this.model.weights = this.aggregator.model.weights;
-        }
-        await this.memory.updateWorkingModel({
-            type: 'working',
-            taskID: this.task.id,
-            name: this.task.trainingInformation.modelID,
-            tensorBackend: this.task.trainingInformation.tensorBackend
-        }, this.model);
-    }
-}

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

@@ -1,12 +0,0 @@
-import type { Memory, Model, Task } from "../../index.js";
-import { Trainer } from "./trainer.js";
-/** Class whose role is to locally (alone) train a model on a given dataset,
- * without any collaborators.
- */
-export declare class LocalTrainer extends Trainer {
-    private readonly task;
-    private readonly memory;
-    constructor(task: Task, memory: Memory, model: Model);
-    onRoundBegin(): Promise<void>;
-    onRoundEnd(): Promise<void>;
-}

package/dist/training/trainer/local_trainer.js

@@ -1,24 +0,0 @@
-import { Trainer } from "./trainer.js";
-/** Class whose role is to locally (alone) train a model on a given dataset,
- * without any collaborators.
- */
-export class LocalTrainer extends Trainer {
-    task;
-    memory;
-    constructor(task, memory, model) {
-        super(task, model);
-        this.task = task;
-        this.memory = memory;
-    }
-    async onRoundBegin() {
-        return await Promise.resolve();
-    }
-    async onRoundEnd() {
-        await this.memory.updateWorkingModel({
-            type: 'working',
-            taskID: this.task.id,
-            name: this.task.trainingInformation.modelID,
-            tensorBackend: this.task.trainingInformation.tensorBackend
-        }, this.model);
-    }
-}

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

@@ -1,32 +0,0 @@
-import type tf from "@tensorflow/tfjs";
-import { List } from "immutable";
-import type { Model, Task } from "../../index.js";
-import { BatchLogs, EpochLogs } from "../../models/index.js";
-export interface RoundLogs {
-    epochs: List<EpochLogs>;
-}
-/** Abstract class whose role is to train a model with a given dataset. This can be either done
- * locally (alone) or in a distributed way with collaborators.
- *
- * 1. Call `fitModel(dataset)` to start training.
- * 2. which will then call onRoundEnd once the round has ended.
- *
- * The onRoundEnd needs to be implemented to specify what actions to do when the round has ended, such as a communication step with collaborators.
- */
-export declare abstract class Trainer {
-    #private;
-    readonly model: Model;
-    private training?;
-    constructor(task: Task, model: Model);
-    protected abstract onRoundBegin(round: number): Promise<void>;
-    protected abstract onRoundEnd(round: number): Promise<void>;
-    /**
-     * Request stop training to be used from the Disco instance or any class that is taking care of the trainer.
-     */
-    stopTraining(): Promise<void>;
-    /**
-     * Start training the model with the given dataset
-     * @param dataset
-     */
-    fitModel(dataset: tf.data.Dataset<tf.TensorContainer>, valDataset: tf.data.Dataset<tf.TensorContainer>): AsyncGenerator<AsyncGenerator<AsyncGenerator<BatchLogs, EpochLogs>, RoundLogs>, void>;
-}

package/dist/training/trainer/trainer.js

@@ -1,61 +0,0 @@
-import { List } from "immutable";
-import * as async_iterator from "../../utils/async_iterator.js";
-/** Abstract class whose role is to train a model with a given dataset. This can be either done
- * locally (alone) or in a distributed way with collaborators.
- *
- * 1. Call `fitModel(dataset)` to start training.
- * 2. which will then call onRoundEnd once the round has ended.
- *
- * The onRoundEnd needs to be implemented to specify what actions to do when the round has ended, such as a communication step with collaborators.
- */
-export class Trainer {
-    model;
-    #roundDuration;
-    #epochs;
-    training;
-    constructor(task, model) {
-        this.model = model;
-        this.#roundDuration = task.trainingInformation.roundDuration;
-        this.#epochs = task.trainingInformation.epochs;
-        if (!Number.isInteger(this.#epochs / this.#roundDuration))
-            throw new Error(`round duration ${this.#roundDuration} doesn't divide number of epochs ${this.#epochs}`);
-    }
-    /**
-     * Request stop training to be used from the Disco instance or any class that is taking care of the trainer.
-     */
-    async stopTraining() {
-        await this.training?.return();
-    }
-    /**
-     * Start training the model with the given dataset
-     * @param dataset
-     */
-    async *fitModel(dataset, valDataset) {
-        if (this.training !== undefined)
-            throw new Error("training already running, cancel 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);
-        for (let round = 0; round < totalRound; round++) {
-            await this.onRoundBegin(round);
-            yield this.#runRound(dataset, valDataset);
-            await this.onRoundEnd(round);
-        }
-    }
-    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 };
-    }
-}

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

@@ -1,23 +0,0 @@
-import type { client as clients, Task, Memory } from '../../index.js';
-import type { Trainer } from './trainer.js';
-/**
- * A class that helps build the Trainer and auxiliary classes.
- */
-export declare class TrainerBuilder {
-    private readonly memory;
-    private readonly task;
-    constructor(memory: Memory, task: Task);
-    /**
-     * Builds a trainer object.
-     *
-     * @param client client to share weights with (either distributed or federated)
-     * @param distributed whether to build a distributed or local trainer
-     * @returns
-     */
-    build(client: clients.Client, distributed?: boolean): Promise<Trainer>;
-    /**
-     * If a model exists in memory, load it, otherwise load model from server
-     * @returns
-     */
-    private getModel;
-}

package/dist/training/trainer/trainer_builder.js

@@ -1,47 +0,0 @@
-import { DistributedTrainer } from './distributed_trainer.js';
-import { LocalTrainer } from './local_trainer.js';
-/**
- * A class that helps build the Trainer and auxiliary classes.
- */
-export class TrainerBuilder {
-    memory;
-    task;
-    constructor(memory, task) {
-        this.memory = memory;
-        this.task = task;
-    }
-    /**
-     * Builds a trainer object.
-     *
-     * @param client client to share weights with (either distributed or federated)
-     * @param distributed whether to build a distributed or local trainer
-     * @returns
-     */
-    async build(client, distributed = false) {
-        const model = await this.getModel(client);
-        if (distributed) {
-            return new DistributedTrainer(this.task, this.memory, model, client);
-        }
-        else {
-            return new LocalTrainer(this.task, this.memory, model);
-        }
-    }
-    /**
-     * If a model exists in memory, load it, otherwise load model from server
-     * @returns
-     */
-    async getModel(client) {
-        const modelID = this.task.trainingInformation?.modelID;
-        if (modelID === undefined) {
-            throw new TypeError('model ID is undefined');
-        }
-        const info = {
-            type: 'working',
-            taskID: this.task.id,
-            name: modelID,
-            tensorBackend: 'gpt'
-        };
-        const model = await (await this.memory.contains(info) ? this.memory.getModel(info) : client.getLatestModel());
-        return model;
-    }
-}