@epfml/discojs 3.0.1-p20241007204240.0 → 3.0.1-p20241024094708.0

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

@@ -6,25 +6,13 @@ import { Client } from "../client.js";
  */
 export declare class FederatedClient extends Client {
     #private;
-    get nbOfParticipants(): number;
-    /**
-     * Opens a new WebSocket connection with the server and listens to new messages over the channel
-     */
-    private connectServer;
+    getNbOfParticipants(): number;
     /**
      * 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.
      */
     connect(): Promise<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
-     */
-    private waitForMoreParticipants;
     /**
      * Disconnection process when user quits the task.
      */

package/dist/client/federated/federated_client.js

@@ -1,6 +1,6 @@
 import createDebug from "debug";
 import { serialization } from "../../index.js";
-import { Client } from "../client.js";
+import { Client, shortenId } from "../client.js";
 import { type } from "../messages.js";
 import { waitMessage, waitMessageWithTimeout, WebSocketServer, } from "../event_connection.js";
 import * as messages from "./messages.js";
@@ -19,38 +19,10 @@ 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() {
+    getNbOfParticipants() {
         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
@@ -70,31 +42,12 @@ export class FederatedClient extends Client {
                 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
+        // Opens a new WebSocket connection with the server and listens to new messages over the channel
+        this._server = await WebSocketServer.connect(serverURL, messages.isMessageFederated, // can only receive federated message types from the server
+        messages.isMessageFederated);
+        // c.f. setupServerCallbacks doc for explanation
         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.setupServerCallbacks(() => receivedEnoughParticipants = true);
         this.aggregator.registerNode(SERVER_NODE_ID);
         const msg = {
             type: type.ClientConnected,
@@ -109,40 +62,21 @@ export class FederatedClient extends Client {
         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();
+            this.promiseForMoreParticipants = this.createPromiseForMoreParticipants();
         }
         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} `);
+        debug(`[${shortenId(id)}] 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);
+        debug(`[${shortenId(this.ownId)}] 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.
      */
@@ -155,10 +89,7 @@ export class FederatedClient extends Client {
     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);
+        this.saveAndEmit("local training");
         return Promise.resolve();
     }
     /**
@@ -176,18 +107,8 @@ export class FederatedClient extends Client {
             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);
+        await this.waitForParticipantsIfNeeded();
+        this.saveAndEmit("updating model");
         // 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();
@@ -198,9 +119,9 @@ export class FederatedClient extends Client {
         };
         // 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}`);
+        debug(`[${shortenId(this.ownId)}] 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}`);
+        debug(`[${shortenId(this.ownId)}] 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);

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

@@ -1,30 +1,25 @@
-import { type weights } from '../../serialization/index.js';
+import type { serialization } from "../../index.js";
 import { type NodeID } from '..//types.js';
-import { type, type ClientConnected } from '../messages.js';
+import { type } from '../messages.js';
+import type { ClientConnected, WaitingForMoreParticipants, EnoughParticipants } 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;
+    payload: serialization.Encoded;
     round: number;
     nbOfParticipants: number;
 }
 export interface SendPayload {
     type: type.SendPayload;
-    payload: weights.Encoded;
+    payload: serialization.Encoded;
     round: number;
 }
 export interface ReceiveServerPayload {
     type: type.ReceiveServerPayload;
-    payload: weights.Encoded;
+    payload: serialization.Encoded;
     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/local_client.d.ts

@@ -5,6 +5,7 @@ import { Client } from "./client.js";
  * with anyone. Thus LocalClient doesn't do anything during communication
  */
 export declare class LocalClient extends Client {
+    getNbOfParticipants(): number;
     onRoundBeginCommunication(): Promise<void>;
     onRoundEndCommunication(weights: WeightsContainer): Promise<WeightsContainer>;
 }

package/dist/client/local_client.js

@@ -4,6 +4,9 @@ import { Client } from "./client.js";
  * with anyone. Thus LocalClient doesn't do anything during communication
  */
 export class LocalClient extends Client {
+    getNbOfParticipants() {
+        return 1;
+    }
     onRoundBeginCommunication() {
         return Promise.resolve();
     }

package/dist/client/messages.d.ts

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

package/dist/client/messages.js

@@ -9,34 +9,36 @@ export var type;
     // 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 peers to the server to signal they want to 
+    // join the next round
+    type[type["JoinRound"] = 2] = "JoinRound";
     // 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";
+    // Message forwarded by the server from a client to another client
+    // to establish a peer-to-peer (WebRTC) connection
+    type[type["SignalForPeer"] = 5] = "SignalForPeer";
     // The weight update
-    type[type["Payload"] = 5] = "Payload";
+    type[type["Payload"] = 6] = "Payload";
     /* 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";
+    type[type["NewFederatedNodeInfo"] = 7] = "NewFederatedNodeInfo";
     // Message sent by server to notify clients that there are not enough
     // participants to continue training
-    type[type["WaitingForMoreParticipants"] = 7] = "WaitingForMoreParticipants";
+    type[type["WaitingForMoreParticipants"] = 8] = "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["EnoughParticipants"] = 9] = "EnoughParticipants";
+    type[type["SendPayload"] = 10] = "SendPayload";
+    type[type["ReceiveServerPayload"] = 11] = "ReceiveServerPayload";
 })(type || (type = {}));
 export function hasMessageType(raw) {
-    if (typeof raw !== 'object' || raw === null) {
+    if (typeof raw !== 'object' || raw === null)
         return false;
-    }
     const o = raw;
     if (!('type' in o && typeof o.type === 'number' && o.type in type)) {
         return false;

package/dist/default_tasks/cifar10.js

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

package/dist/default_tasks/lus_covid.js

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

package/dist/default_tasks/mnist.js

@@ -29,7 +29,7 @@ export const mnist = {
                 preprocessingFunctions: [data.ImagePreprocessing.Resize, data.ImagePreprocessing.Normalize],
                 LABEL_LIST: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
                 scheme: 'decentralized',
-                decentralizedSecure: true,
+                aggregationStrategy: 'secure',
                 minNbOfParticipants: 3,
                 maxShareValue: 100,
                 tensorBackend: 'tfjs'

package/dist/default_tasks/simple_face.js

@@ -28,6 +28,7 @@ export const simpleFace = {
                 IMAGE_W: 200,
                 LABEL_LIST: ['child', 'adult'],
                 scheme: 'federated',
+                aggregationStrategy: 'mean',
                 minNbOfParticipants: 2,
                 tensorBackend: 'tfjs'
             }

package/dist/default_tasks/titanic.js

@@ -62,6 +62,7 @@ export const titanic = {
                     'Survived'
                 ],
                 scheme: 'federated',
+                aggregationStrategy: 'mean',
                 minNbOfParticipants: 2,
                 tensorBackend: 'tfjs'
             }

package/dist/default_tasks/wikitext.js

@@ -25,6 +25,7 @@ export const wikitext = {
                 dataType: 'text',
                 preprocessingFunctions: [data.TextPreprocessing.Tokenize, data.TextPreprocessing.LeftPadding],
                 scheme: 'federated',
+                aggregationStrategy: 'mean',
                 minNbOfParticipants: 2,
                 epochs: 6,
                 // Unused by wikitext because data already comes split

package/dist/index.d.ts

@@ -1,7 +1,5 @@
 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';

package/dist/serialization/coder.d.ts

@@ -0,0 +1,4 @@
+export type Encoded = Uint8Array;
+export declare function isEncoded(raw: unknown): raw is Encoded;
+export declare function encode(serialized: unknown): Encoded;
+export declare function decode(encoded: Encoded): unknown;

package/dist/serialization/coder.js

@@ -0,0 +1,51 @@
+import * as msgpack from "@msgpack/msgpack";
+export function isEncoded(raw) {
+    if (!(raw instanceof Uint8Array))
+        return false;
+    const _ = raw;
+    return true;
+}
+// create a new buffer instead of referencing the backing one
+function copy(arr) {
+    // `Buffer.slice` (subclass of Uint8Array on Node) doesn't copy
+    // thus doesn't respect Liskov substitution principle
+    // https://nodejs.org/api/buffer.html#bufslicestart-end
+    // here we call the correct implementation
+    return Uint8Array.prototype.slice.call(arr);
+}
+// to avoid mapping every ArrayBuffer to Uint8Array,
+// we register our own convertors for the type we know are needed
+// type id are arbitrally taken from msgpack-lite
+// https://www.npmjs.com/package/msgpack-lite#extension-types
+const CODEC = new msgpack.ExtensionCodec();
+// used by TFJS's weights
+CODEC.register({
+    type: 0x17,
+    encode(obj) {
+        if (!(obj instanceof Float32Array))
+            return null;
+        return new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength);
+    },
+    decode: (raw) => 
+    // to reinterpred uint8 into float32, it needs to be 4-bytes aligned
+    // but the given buffer might not be so we need to copy it.
+    new Float32Array(copy(raw).buffer),
+});
+// used by TFJS's saved model
+CODEC.register({
+    type: 0x1a,
+    encode(obj) {
+        if (!(obj instanceof ArrayBuffer))
+            return null;
+        return new Uint8Array(obj);
+    },
+    decode: (raw) => 
+    // need to copy as backing ArrayBuffer might be larger
+    copy(raw),
+});
+export function encode(serialized) {
+    return msgpack.encode(serialized, { extensionCodec: CODEC });
+}
+export function decode(encoded) {
+    return msgpack.decode(encoded, { extensionCodec: CODEC });
+}

package/dist/serialization/index.d.ts

@@ -1,2 +1,4 @@
 export * as model from './model.js';
 export * as weights from './weights.js';
+export type { Encoded } from "./coder.js";
+export { isEncoded } from "./coder.js";

package/dist/serialization/index.js

@@ -1,2 +1,3 @@
 export * as model from './model.js';
 export * as weights from './weights.js';
+export { isEncoded } from "./coder.js";

package/dist/serialization/model.d.ts

@@ -1,5 +1,4 @@
 import type { Model } from '../index.js';
-export type Encoded = Uint8Array;
-export declare function isEncoded(raw: unknown): raw is Encoded;
+import { Encoded } from "./coder.js";
 export declare function encode(model: Model): Promise<Encoded>;
 export declare function decode(encoded: unknown): Promise<Model>;

package/dist/serialization/model.js

@@ -1,38 +1,29 @@
-import msgpack from 'msgpack-lite';
 import { models, serialization } from '../index.js';
+import * as coder from "./coder.js";
+import { isEncoded } from "./coder.js";
 const Type = {
     TFJS: 0,
     GPT: 1
 };
-export function isEncoded(raw) {
-    return raw instanceof Uint8Array;
-}
 export async function encode(model) {
-    let encoded;
     switch (true) {
         case model instanceof models.TFJS: {
             const serialized = await model.serialize();
-            encoded = msgpack.encode([Type.TFJS, serialized]);
-            break;
+            return coder.encode([Type.TFJS, serialized]);
         }
         case model instanceof models.GPT: {
             const { weights, config } = model.serialize();
             const serializedWeights = await serialization.weights.encode(weights);
-            encoded = msgpack.encode([Type.GPT, serializedWeights, config]);
-            break;
+            return coder.encode([Type.GPT, serializedWeights, config]);
         }
         default:
             throw new Error("unknown model type");
     }
-    // Node's Buffer extends Node's Uint8Array, which might not be the same
-    // as the browser's Uint8Array. we ensure here that it is.
-    return new Uint8Array(encoded);
 }
 export async function decode(encoded) {
-    if (!isEncoded(encoded)) {
+    if (!isEncoded(encoded))
         throw new Error("Invalid encoding, raw encoding isn't an instance of Uint8Array");
-    }
-    const raw = msgpack.decode(encoded);
+    const raw = coder.decode(encoded);
     if (!Array.isArray(raw) || raw.length < 2) {
         throw new Error("invalid encoding, encoding isn't an array or doesn't contain enough values");
     }
@@ -59,15 +50,9 @@ export async function decode(encoded) {
             else {
                 throw new Error('invalid encoding, gpt-tfjs model encoding should be an array of length 2 or 3');
             }
-            if (!Array.isArray(rawModel)) {
-                throw new Error('invalid encoding, gpt-tfjs model weights should be an array');
-            }
-            const arr = rawModel;
-            if (arr.some((r) => typeof r !== 'number')) {
-                throw new Error("invalid encoding, gpt-tfjs weights should be numbers");
-            }
-            const nums = arr;
-            const weights = serialization.weights.decode(nums);
+            if (!isEncoded(rawModel))
+                throw new Error("invalid encoding, gpt-tfjs model weights should be an encoding of its weights");
+            const weights = serialization.weights.decode(rawModel);
             return models.GPT.deserialize({ weights, config });
         }
         default:

package/dist/serialization/weights.d.ts

@@ -1,5 +1,4 @@
-import { WeightsContainer } from '../index.js';
-export type Encoded = number[];
-export declare function isEncoded(raw: unknown): raw is Encoded;
+import { WeightsContainer } from "../index.js";
+import { Encoded } from "./coder.js";
 export declare function encode(weights: WeightsContainer): Promise<Encoded>;
 export declare function decode(encoded: Encoded): WeightsContainer;

package/dist/serialization/weights.js

@@ -1,37 +1,26 @@
-import * as msgpack from 'msgpack-lite';
-import * as tf from '@tensorflow/tfjs';
-import { WeightsContainer } from '../index.js';
+import * as tf from "@tensorflow/tfjs";
+import { WeightsContainer } from "../index.js";
+import * as coder from "./coder.js";
 function isSerialized(raw) {
-    if (typeof raw !== 'object' || raw === null) {
+    if (typeof raw !== "object" || raw === null)
         return false;
-    }
     const { shape, data } = raw;
-    if (!(Array.isArray(shape) && shape.every((e) => typeof e === 'number')) ||
-        !(Array.isArray(data) && data.every((e) => typeof e === 'number'))) {
+    if (!(Array.isArray(shape) && shape.every((e) => typeof e === "number")) ||
+        !(data instanceof Float32Array))
         return false;
-    }
-    const _ = {
-        shape: shape,
-        data: data,
-    };
+    const _ = { shape, data };
     return true;
 }
-export function isEncoded(raw) {
-    return Array.isArray(raw) && raw.every((e) => typeof e === 'number');
-}
 export async function encode(weights) {
-    const serialized = await Promise.all(weights.weights.map(async (t) => {
-        return {
-            shape: t.shape,
-            data: [...await t.data()]
-        };
-    }));
-    return [...msgpack.encode(serialized).values()];
+    const serialized = await Promise.all(weights.weights.map(async (t) => ({
+        shape: t.shape,
+        data: await t.data(),
+    })));
+    return coder.encode(serialized);
 }
 export function decode(encoded) {
-    const raw = msgpack.decode(encoded);
-    if (!(Array.isArray(raw) && raw.every(isSerialized))) {
-        throw new Error('expected to decode an array of serialized weights');
-    }
+    const raw = coder.decode(encoded);
+    if (!(Array.isArray(raw) && raw.every(isSerialized)))
+        throw new Error("expected to decode an array of serialized weights");
     return new WeightsContainer(raw.map((w) => tf.tensor(w.data, w.shape)));
 }

package/dist/task/task_handler.d.ts

@@ -1,5 +1,5 @@
-import { Map } from 'immutable';
-import type { Model } from '../index.js';
-import type { Task, TaskID } from './task.js';
-export declare function pushTask(url: URL, task: Task, model: Model): Promise<void>;
-export declare function fetchTasks(url: URL): Promise<Map<TaskID, Task>>;
+import { Map } from "immutable";
+import type { Model } from "../index.js";
+import type { Task, TaskID } from "./task.js";
+export declare function pushTask(base: URL, task: Task, model: Model): Promise<void>;
+export declare function fetchTasks(base: URL): Promise<Map<TaskID, Task>>;