@epfml/discojs 3.0.1-p20241206154707.0 → 3.0.1-p20250204101254.0

package/dist/client/decentralized/peer.js

@@ -1,5 +1,5 @@
 import { List, Map, Range, Seq } from 'immutable';
-import wrtc from 'isomorphic-wrtc';
+import wrtc from "@epfml/isomorphic-wrtc";
 import SimplePeer from 'simple-peer';
 // message id + (chunk counter == 0) + chunk count
 const FIRST_HEADER_SIZE = 2 + 1 + 1;

package/dist/processing/index.d.ts

@@ -5,4 +5,4 @@ export * from "./tabular.js";
 export * from "./text.js";
 export declare function preprocess<D extends DataType>(task: Task<D>, dataset: Dataset<DataFormat.Raw[D]>): Promise<Dataset<DataFormat.ModelEncoded[D]>>;
 export declare function preprocessWithoutLabel<D extends DataType>(task: Task<D>, dataset: Dataset<DataFormat.RawWithoutLabel[D]>): Promise<Dataset<DataFormat.ModelEncoded[D][0]>>;
-export declare function postprocess<D extends DataType>(task: Task<D>, dataset: Dataset<DataFormat.ModelEncoded[D][1]>): Promise<Dataset<DataFormat.Inferred[D]>>;
+export declare function postprocess<D extends DataType>(task: Task<D>, encoded: DataFormat.ModelEncoded[D][1]): Promise<DataFormat.Inferred[D]>;

package/dist/processing/index.js

@@ -68,31 +68,29 @@ export async function preprocessWithoutLabel(task, dataset) {
         }
     }
 }
-export async function postprocess(task, dataset) {
+export async function postprocess(task, encoded) {
     switch (task.trainingInformation.dataType) {
         case "image": {
             // cast as typescript doesn't reduce generic type
-            const d = dataset;
+            const index = encoded;
             const { LABEL_LIST } = task.trainingInformation;
             const labels = List(LABEL_LIST);
-            return d.map((index) => {
-                const v = labels.get(index);
-                if (v === undefined)
-                    throw new Error("index not found in labels");
-                return v;
-            });
+            const v = labels.get(index);
+            if (v === undefined)
+                throw new Error("index not found in labels");
+            return v;
         }
         case "tabular": {
             // cast as typescript doesn't reduce generic type
-            const d = dataset;
-            return d;
+            const v = encoded;
+            return v;
         }
         case "text": {
             // cast as typescript doesn't reduce generic type
-            const d = dataset;
+            const token = encoded;
             const t = task;
             const tokenizer = await models.getTaskTokenizer(t);
-            return d.map((token) => tokenizer.decode([token]));
+            return tokenizer.decode([token]);
         }
     }
 }

package/dist/validator.d.ts

@@ -1,10 +1,10 @@
-import type { Dataset, DataFormat, DataType, Model, Task } from "./index.js";
+import { Dataset, DataFormat, DataType, Model, Task } from "./index.js";
 export declare class Validator<D extends DataType> {
     #private;
     readonly task: Task<D>;
     constructor(task: Task<D>, model: Model<D>);
     /** infer every line of the dataset and check that it is as labelled */
-    test(dataset: Dataset<DataFormat.Raw[D]>): AsyncGenerator<boolean, void>;
+    test(dataset: Dataset<DataFormat.Raw[D]>): Promise<Dataset<Record<"predicted" | "truth", DataFormat.Inferred[D]>>>;
     /** use the model to predict every line of the dataset */
     infer(dataset: Dataset<DataFormat.RawWithoutLabel[D]>): AsyncGenerator<DataFormat.Inferred[D], void>;
 }

package/dist/validator.js

@@ -7,15 +7,16 @@ export class Validator {
         this.#model = model;
     }
     /** infer every line of the dataset and check that it is as labelled */
-    async *test(dataset) {
-        const results = (await processing.preprocess(this.task, dataset))
-            .batch(this.task.trainingInformation.batchSize)
-            .map(async (batch) => (await this.#model.predict(batch.map(([inputs, _]) => inputs)))
-            .zip(batch.map(([_, outputs]) => outputs))
-            .map(([inferred, truth]) => inferred === truth))
+    async test(dataset) {
+        const preprocessed = await processing.preprocess(this.task, dataset);
+        const batched = preprocessed.batch(this.task.trainingInformation.batchSize);
+        const predictionWithTruth = batched
+            .map(async (batch) => (await this.#model.predict(batch.map(([inputs, _]) => inputs))).zip(batch.map(([_, outputs]) => outputs)))
             .flatten();
-        for await (const e of results)
-            yield e;
+        return predictionWithTruth.map(async ([predicted, truth]) => ({
+            predicted: await processing.postprocess(this.task, predicted),
+            truth: await processing.postprocess(this.task, truth),
+        }));
     }
     /** use the model to predict every line of the dataset */
     async *infer(dataset) {
@@ -23,7 +24,7 @@ export class Validator {
             .batch(this.task.trainingInformation.batchSize)
             .map((batch) => this.#model.predict(batch))
             .flatten();
-        const predictions = await processing.postprocess(this.task, modelPredictions);
+        const predictions = modelPredictions.map((prediction) => processing.postprocess(this.task, prediction));
         for await (const e of predictions)
             yield e;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epfml/discojs",
-  "version": "3.0.1-p20241206154707.0",
+  "version": "3.0.1-p20250204101254.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,13 +19,13 @@
   },
   "homepage": "https://github.com/epfml/disco#readme",
   "dependencies": {
+    "@epfml/isomorphic-wrtc": "1",
     "@jimp/core": "1",
     "@jimp/plugin-resize": "1",
     "@msgpack/msgpack": "^3.0.0-beta2",
     "@tensorflow/tfjs": "4",
     "@xenova/transformers": "2",
     "immutable": "4",
-    "isomorphic-wrtc": "1",
     "isomorphic-ws": "5",
     "simple-peer": "9",
     "tslib": "2",