@epfml/discojs 0.1.0 → 2.0.0

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

@@ -0,0 +1,11 @@
+import { Task } from '../..';
+import { Dataset } from '../dataset';
+export declare abstract class Data {
+    readonly dataset: Dataset;
+    readonly task: Task;
+    readonly size?: number | undefined;
+    protected constructor(dataset: Dataset, task: Task, size?: number | undefined);
+    static init(dataset: Dataset, task: Task, size?: number): Promise<Data>;
+    abstract batch(): Data;
+    abstract preprocess(): Data;
+}

package/dist/core/dataset/data/data.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Data = void 0;
+var tslib_1 = require("tslib");
+var Data = /** @class */ (function () {
+    function Data(dataset, task, size) {
+        this.dataset = dataset;
+        this.task = task;
+        this.size = size;
+    }
+    Data.init = function (dataset, task, size) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                throw new Error('abstract');
+            });
+        });
+    };
+    return Data;
+}());
+exports.Data = Data;

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

@@ -0,0 +1,5 @@
+import { Data } from './data';
+export interface DataSplit {
+    train: Data;
+    validation?: Data;
+}

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

@@ -0,0 +1,8 @@
+import { Task } from '../..';
+import { Dataset } from '../dataset';
+import { Data } from './data';
+export declare class ImageData extends Data {
+    static init(dataset: Dataset, task: Task, size?: number): Promise<Data>;
+    batch(): Data;
+    preprocess(): Data;
+}

package/dist/core/dataset/data/image_data.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageData = void 0;
+var tslib_1 = require("tslib");
+var preprocessing_1 = require("./preprocessing");
+var data_1 = require("./data");
+var ImageData = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(ImageData, _super);
+    function ImageData() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ImageData.init = function (dataset, task, size) {
+        var _a;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var sample, shape, e_1;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!((_a = task.trainingInformation.preprocessingFunctions) === null || _a === void 0 ? void 0 : _a.includes(preprocessing_1.ImagePreprocessing.Resize))) return [3 /*break*/, 4];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, dataset.take(1).toArray()];
+                    case 2:
+                        sample = (_b.sent())[0];
+                        // TODO: We suppose the presence of labels
+                        // TODO: Typing (discojs-node/src/dataset/data_loader/image_loader.spec.ts)
+                        if (!(typeof sample === 'object' && sample !== null)) {
+                            throw new Error();
+                        }
+                        shape = void 0;
+                        if ('xs' in sample && 'ys' in sample) {
+                            shape = sample.xs.shape;
+                        }
+                        else {
+                            shape = sample.shape;
+                        }
+                        if (!(shape[0] === task.trainingInformation.IMAGE_W &&
+                            shape[1] === task.trainingInformation.IMAGE_H)) {
+                            throw new Error();
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _b.sent();
+                        throw new Error('Data input format is not compatible with the chosen task');
+                    case 4: return [2 /*return*/, new ImageData(dataset, task, size)];
+                }
+            });
+        });
+    };
+    ImageData.prototype.batch = function () {
+        var batchSize = this.task.trainingInformation.batchSize;
+        var newDataset = batchSize === undefined ? this.dataset : this.dataset.batch(batchSize);
+        return new ImageData(newDataset, this.task, this.size);
+    };
+    ImageData.prototype.preprocess = function () {
+        var newDataset = this.dataset;
+        var preprocessImage = (0, preprocessing_1.getPreprocessImage)(this.task);
+        newDataset = newDataset.map(function (x) { return preprocessImage(x); });
+        return new ImageData(newDataset, this.task, this.size);
+    };
+    return ImageData;
+}(data_1.Data));
+exports.ImageData = ImageData;

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

@@ -0,0 +1,5 @@
+export { DataSplit } from './data_split';
+export { Data } from './data';
+export { ImageData } from './image_data';
+export { TabularData } from './tabular_data';
+export { ImagePreprocessing } from './preprocessing';

package/dist/core/dataset/data/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImagePreprocessing = exports.TabularData = exports.ImageData = exports.Data = void 0;
+var data_1 = require("./data");
+Object.defineProperty(exports, "Data", { enumerable: true, get: function () { return data_1.Data; } });
+var image_data_1 = require("./image_data");
+Object.defineProperty(exports, "ImageData", { enumerable: true, get: function () { return image_data_1.ImageData; } });
+var tabular_data_1 = require("./tabular_data");
+Object.defineProperty(exports, "TabularData", { enumerable: true, get: function () { return tabular_data_1.TabularData; } });
+var preprocessing_1 = require("./preprocessing");
+Object.defineProperty(exports, "ImagePreprocessing", { enumerable: true, get: function () { return preprocessing_1.ImagePreprocessing; } });

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

@@ -0,0 +1,13 @@
+import { tf, Task } from '../..';
+declare type PreprocessImage = (image: tf.TensorContainer) => tf.TensorContainer;
+export declare type Preprocessing = ImagePreprocessing;
+export interface ImageTensorContainer extends tf.TensorContainerObject {
+    xs: tf.Tensor3D | tf.Tensor4D;
+    ys: tf.Tensor1D | number | undefined;
+}
+export declare enum ImagePreprocessing {
+    Normalize = "normalize",
+    Resize = "resize"
+}
+export declare function getPreprocessImage(task: Task): PreprocessImage;
+export {};

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPreprocessImage = exports.ImagePreprocessing = void 0;
+var __1 = require("../..");
+var ImagePreprocessing;
+(function (ImagePreprocessing) {
+    ImagePreprocessing["Normalize"] = "normalize";
+    ImagePreprocessing["Resize"] = "resize";
+})(ImagePreprocessing = exports.ImagePreprocessing || (exports.ImagePreprocessing = {}));
+function getPreprocessImage(task) {
+    var preprocessImage = function (tensorContainer) {
+        var _a, _b;
+        // TODO unsafe cast, tfjs does not provide the right interface
+        var info = task.trainingInformation;
+        var _c = tensorContainer, xs = _c.xs, ys = _c.ys;
+        if ((_a = info.preprocessingFunctions) === null || _a === void 0 ? void 0 : _a.includes(ImagePreprocessing.Normalize)) {
+            xs = xs.div(__1.tf.scalar(255));
+        }
+        if (((_b = info.preprocessingFunctions) === null || _b === void 0 ? void 0 : _b.includes(ImagePreprocessing.Resize)) &&
+            info.IMAGE_H !== undefined &&
+            info.IMAGE_W !== undefined) {
+            xs = __1.tf.image.resizeBilinear(xs, [
+                info.IMAGE_H, info.IMAGE_W
+            ]);
+        }
+        return {
+            xs: xs,
+            ys: ys
+        };
+    };
+    return preprocessImage;
+}
+exports.getPreprocessImage = getPreprocessImage;

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

@@ -0,0 +1,8 @@
+import { Task } from '../..';
+import { Dataset } from '../dataset';
+import { Data } from './data';
+export declare class TabularData extends Data {
+    static init(dataset: Dataset, task: Task, size?: number): Promise<Data>;
+    batch(): Data;
+    preprocess(): Data;
+}

package/dist/core/dataset/data/tabular_data.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TabularData = void 0;
+var tslib_1 = require("tslib");
+var data_1 = require("./data");
+var TabularData = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(TabularData, _super);
+    function TabularData() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TabularData.init = function (dataset, task, size) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var e_1;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, dataset.iterator()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        e_1 = _a.sent();
+                        throw new Error('Data input format is not compatible with the chosen task');
+                    case 3: return [2 /*return*/, new TabularData(dataset, task, size)];
+                }
+            });
+        });
+    };
+    TabularData.prototype.batch = function () {
+        var batchSize = this.task.trainingInformation.batchSize;
+        var newDataset = batchSize === undefined ? this.dataset : this.dataset.batch(batchSize);
+        return new TabularData(newDataset, this.task, this.size);
+    };
+    TabularData.prototype.preprocess = function () {
+        return this;
+    };
+    return TabularData;
+}(data_1.Data));
+exports.TabularData = TabularData;

package/dist/{dataset → core/dataset}/data_loader/data_loader.d.ts

@@ -1,22 +1,15 @@
-import { Dataset } from '../dataset_builder';
-import { Task } from '../../task';
+import { Task } from '../..';
+import { Dataset } from '../dataset';
+import { DataSplit } from '../data';
 export interface DataConfig {
     features?: string[];
     labels?: string[];
     shuffle?: boolean;
     validationSplit?: number;
 }
-export interface Data {
-    dataset: Dataset;
-    size: number;
-}
-export interface DataTuple {
-    train: Data;
-    validation?: Data;
-}
 export declare abstract class DataLoader<Source> {
     protected task: Task;
     constructor(task: Task);
     abstract load(source: Source, config: DataConfig): Promise<Dataset>;
-    abstract loadAll(sources: Source[], config: DataConfig): Promise<DataTuple>;
+    abstract loadAll(sources: Source[], config: DataConfig): Promise<DataSplit>;
 }

package/dist/core/dataset/data_loader/image_loader.d.ts

@@ -0,0 +1,17 @@
+import { tf } from '../..';
+import { Dataset } from '../dataset';
+import { DataSplit } from '../data';
+import { DataLoader, DataConfig } from '../data_loader';
+/**
+ * TODO @s314cy:
+ * Load labels and correctly match them with their respective images, with the following constraints:
+ * 1. Images are given as 1 image/1 file
+ * 2. Labels are given as multiple labels/1 file, each label file can contain a different amount of labels
+ */
+export declare abstract class ImageLoader<Source> extends DataLoader<Source> {
+    abstract readImageFrom(source: Source): Promise<tf.Tensor3D>;
+    load(image: Source, config?: DataConfig): Promise<Dataset>;
+    private buildDataset;
+    loadAll(images: Source[], config?: DataConfig): Promise<DataSplit>;
+    shuffle(array: number[]): void;
+}

package/dist/core/dataset/data_loader/image_loader.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageLoader = void 0;
+var tslib_1 = require("tslib");
+var immutable_1 = require("immutable");
+var __1 = require("../..");
+var data_1 = require("../data");
+var data_loader_1 = require("../data_loader");
+/**
+ * TODO @s314cy:
+ * Load labels and correctly match them with their respective images, with the following constraints:
+ * 1. Images are given as 1 image/1 file
+ * 2. Labels are given as multiple labels/1 file, each label file can contain a different amount of labels
+ */
+var ImageLoader = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(ImageLoader, _super);
+    function ImageLoader() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ImageLoader.prototype.load = function (image, config) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var tensorContainer;
+            var _a;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(config === undefined || config.labels === undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.readImageFrom(image)];
+                    case 1:
+                        tensorContainer = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        _a = {};
+                        return [4 /*yield*/, this.readImageFrom(image)];
+                    case 3:
+                        tensorContainer = (_a.xs = _b.sent(),
+                            _a.ys = config.labels[0],
+                            _a);
+                        _b.label = 4;
+                    case 4: return [2 /*return*/, __1.tf.data.array([tensorContainer])];
+                }
+            });
+        });
+    };
+    ImageLoader.prototype.buildDataset = function (images, labels, indices, config) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var dataset;
+            var _this = this;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dataset = __1.tf.data.generator(function () {
+                            var withLabels = (config === null || config === void 0 ? void 0 : config.labels) !== undefined;
+                            var index = 0;
+                            var iterator = {
+                                next: function () { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+                                    var sample, label, value;
+                                    return (0, tslib_1.__generator)(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                if (index === indices.length) {
+                                                    return [2 /*return*/, { done: true }];
+                                                }
+                                                return [4 /*yield*/, this.readImageFrom(images[indices[index]])];
+                                            case 1:
+                                                sample = _a.sent();
+                                                label = withLabels ? labels[indices[index]] : undefined;
+                                                value = withLabels ? { xs: sample, ys: label } : sample;
+                                                index++;
+                                                return [2 /*return*/, {
+                                                        value: value,
+                                                        done: false
+                                                    }];
+                                        }
+                                    });
+                                }); }
+                            };
+                            return iterator; // Lazy
+                        });
+                        return [4 /*yield*/, data_1.ImageData.init(dataset, this.task, indices.length)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ImageLoader.prototype.loadAll = function (images, config) {
+        var _a, _b;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var labels, indices, numberOfClasses, dataset, trainSize, trainIndices, valIndices, trainDataset, valDataset;
+            return (0, tslib_1.__generator)(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        labels = [];
+                        indices = (0, immutable_1.Range)(0, images.length).toArray();
+                        if ((config === null || config === void 0 ? void 0 : config.labels) !== undefined) {
+                            numberOfClasses = (_b = (_a = this.task.trainingInformation) === null || _a === void 0 ? void 0 : _a.LABEL_LIST) === null || _b === void 0 ? void 0 : _b.length;
+                            if (numberOfClasses === undefined) {
+                                throw new Error('wanted labels but none found in task');
+                            }
+                            labels = __1.tf.oneHot(__1.tf.tensor1d(config.labels, 'int32'), numberOfClasses).arraySync();
+                        }
+                        if ((config === null || config === void 0 ? void 0 : config.shuffle) === undefined || (config === null || config === void 0 ? void 0 : config.shuffle)) {
+                            this.shuffle(indices);
+                        }
+                        if (!((config === null || config === void 0 ? void 0 : config.validationSplit) === undefined || (config === null || config === void 0 ? void 0 : config.validationSplit) === 0)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.buildDataset(images, labels, indices, config)];
+                    case 1:
+                        dataset = _c.sent();
+                        return [2 /*return*/, {
+                                train: dataset,
+                                validation: undefined
+                            }];
+                    case 2:
+                        trainSize = Math.floor(images.length * (1 - config.validationSplit));
+                        trainIndices = indices.slice(0, trainSize);
+                        valIndices = indices.slice(trainSize);
+                        return [4 /*yield*/, this.buildDataset(images, labels, trainIndices, config)];
+                    case 3:
+                        trainDataset = _c.sent();
+                        return [4 /*yield*/, this.buildDataset(images, labels, valIndices, config)];
+                    case 4:
+                        valDataset = _c.sent();
+                        return [2 /*return*/, {
+                                train: trainDataset,
+                                validation: valDataset
+                            }];
+                }
+            });
+        });
+    };
+    ImageLoader.prototype.shuffle = function (array) {
+        for (var i = 0; i < array.length; i++) {
+            var j = Math.floor(Math.random() * i);
+            var swap = array[i];
+            array[i] = array[j];
+            array[j] = swap;
+        }
+    };
+    return ImageLoader;
+}(data_loader_1.DataLoader));
+exports.ImageLoader = ImageLoader;

package/dist/core/dataset/data_loader/index.d.ts

@@ -0,0 +1,3 @@
+export { DataConfig, DataLoader } from './data_loader';
+export { ImageLoader } from './image_loader';
+export { TabularLoader } from './tabular_loader';

package/dist/core/dataset/data_loader/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TabularLoader = exports.ImageLoader = exports.DataLoader = void 0;
+var data_loader_1 = require("./data_loader");
+Object.defineProperty(exports, "DataLoader", { enumerable: true, get: function () { return data_loader_1.DataLoader; } });
+var image_loader_1 = require("./image_loader");
+Object.defineProperty(exports, "ImageLoader", { enumerable: true, get: function () { return image_loader_1.ImageLoader; } });
+var tabular_loader_1 = require("./tabular_loader");
+Object.defineProperty(exports, "TabularLoader", { enumerable: true, get: function () { return tabular_loader_1.TabularLoader; } });

package/dist/core/dataset/data_loader/tabular_loader.d.ts

@@ -0,0 +1,29 @@
+import { tf, Task } from '../..';
+import { Dataset } from '../dataset';
+import { DataSplit } from '../data';
+import { DataLoader, DataConfig } from '../data_loader';
+export declare abstract class TabularLoader<Source> extends DataLoader<Source> {
+    private readonly delimiter;
+    constructor(task: Task, delimiter: string);
+    /**
+     * Creates a CSV dataset object based off the given source.
+     * @param source File object, URL string or local file system path.
+     * @param csvConfig Object expected by TF.js to create a CSVDataset.
+     * @returns The CSVDataset object built upon the given source.
+     */
+    abstract loadTabularDatasetFrom(source: Source, csvConfig: Record<string, unknown>): tf.data.CSVDataset;
+    /**
+     * Expects delimiter-separated tabular data made of N columns. The data may be
+     * potentially split among several sources. Every source should contain N-1
+     * feature columns and 1 single label column.
+     * @param source List of File objects, URLs or file system paths.
+     * @param config
+     * @returns A TF.js dataset built upon read tabular data stored in the given sources.
+     */
+    load(source: Source, config?: DataConfig): Promise<Dataset>;
+    /**
+      * Creates the CSV datasets based off the given sources, then fuses them into a single CSV
+      * dataset.
+      */
+    loadAll(sources: Source[], config: DataConfig): Promise<DataSplit>;
+}

package/dist/core/dataset/data_loader/tabular_loader.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TabularLoader = void 0;
+var tslib_1 = require("tslib");
+var immutable_1 = require("immutable");
+var data_1 = require("../data");
+var data_loader_1 = require("../data_loader");
+// window size from which the dataset shuffling will sample
+var BUFFER_SIZE = 1000;
+var TabularLoader = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(TabularLoader, _super);
+    function TabularLoader(task, delimiter) {
+        var _this = _super.call(this, task) || this;
+        _this.delimiter = delimiter;
+        return _this;
+    }
+    /**
+     * Expects delimiter-separated tabular data made of N columns. The data may be
+     * potentially split among several sources. Every source should contain N-1
+     * feature columns and 1 single label column.
+     * @param source List of File objects, URLs or file system paths.
+     * @param config
+     * @returns A TF.js dataset built upon read tabular data stored in the given sources.
+     */
+    TabularLoader.prototype.load = function (source, config) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var columnConfigs, csvConfig, dataset;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                /**
+                 * Prepare the CSV config object based off the given features and labels.
+                 * If labels is empty, then the returned dataset is comprised of samples only.
+                 * Otherwise, each entry is of the form `{ xs, ys }` with `xs` as features and `ys`
+                 * as labels.
+                 */
+                if ((config === null || config === void 0 ? void 0 : config.features) === undefined) {
+                    // TODO @s314cy
+                    throw new Error('Not implemented');
+                }
+                columnConfigs = (0, immutable_1.Map)((0, immutable_1.Set)(config.features).map(function (feature) { return [feature, { required: false, isLabel: false }]; })).merge((0, immutable_1.Set)(config.labels).map(function (label) { return [label, { required: true, isLabel: true }]; }));
+                csvConfig = {
+                    hasHeader: true,
+                    columnConfigs: columnConfigs.toObject(),
+                    configuredColumnsOnly: true,
+                    delimiter: this.delimiter
+                };
+                dataset = this.loadTabularDatasetFrom(source, csvConfig).map(function (t) {
+                    if (typeof t === 'object' && ('xs' in t) && ('ys' in t)) {
+                        return t;
+                    }
+                    throw new TypeError('Expected TensorContainerObject');
+                }).map(function (t) {
+                    // TODO order may not be stable between tensor
+                    var _a = t, xs = _a.xs, ys = _a.ys;
+                    return {
+                        xs: Object.values(xs),
+                        ys: Object.values(ys)
+                    };
+                });
+                return [2 /*return*/, ((config === null || config === void 0 ? void 0 : config.shuffle) === undefined || (config === null || config === void 0 ? void 0 : config.shuffle)) ? dataset.shuffle(BUFFER_SIZE) : dataset];
+            });
+        });
+    };
+    /**
+      * Creates the CSV datasets based off the given sources, then fuses them into a single CSV
+      * dataset.
+      */
+    TabularLoader.prototype.loadAll = function (sources, config) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var datasets, dataset, data;
+            var _this = this;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(sources.map(function (source) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.load(source, (0, tslib_1.__assign)((0, tslib_1.__assign)({}, config), { shuffle: false }))];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        }); }); }))];
+                    case 1:
+                        datasets = _a.sent();
+                        dataset = (0, immutable_1.List)(datasets).reduce(function (acc, dataset) { return acc.concatenate(dataset); });
+                        dataset = (config === null || config === void 0 ? void 0 : config.shuffle) ? dataset.shuffle(BUFFER_SIZE) : dataset;
+                        return [4 /*yield*/, data_1.TabularData.init(dataset, this.task, 
+                            // dataset.size does not work for csv datasets
+                            // https://github.com/tensorflow/tfjs/issues/5845
+                            undefined)
+                            // TODO: Implement validation split for tabular data (tricky due to streaming)
+                        ];
+                    case 2:
+                        data = _a.sent();
+                        // TODO: Implement validation split for tabular data (tricky due to streaming)
+                        return [2 /*return*/, {
+                                train: data
+                            }];
+                }
+            });
+        });
+    };
+    return TabularLoader;
+}(data_loader_1.DataLoader));
+exports.TabularLoader = TabularLoader;

package/dist/core/dataset/dataset.d.ts

@@ -0,0 +1,2 @@
+import { tf } from '..';
+export declare type Dataset = tf.data.Dataset<tf.TensorContainer>;

package/dist/{dataset → core/dataset}/dataset_builder.d.ts

@@ -1,7 +1,6 @@
-import * as tf from '@tensorflow/tfjs';
-import { DataConfig, DataLoader, DataTuple } from './data_loader/data_loader';
-import { Task } from '@/task';
-export declare type Dataset = tf.data.Dataset<tf.TensorContainer>;
+import { Task } from '..';
+import { DataSplit } from './data';
+import { DataConfig, DataLoader } from './data_loader/data_loader';
 export declare class DatasetBuilder<Source> {
     private readonly task;
     private readonly dataLoader;
@@ -11,8 +10,9 @@ export declare class DatasetBuilder<Source> {
     constructor(dataLoader: DataLoader<Source>, task: Task);
     addFiles(sources: Source[], label?: string): void;
     clearFiles(label?: string): void;
+    private resetBuiltState;
     private getLabels;
-    build(config?: DataConfig): Promise<DataTuple>;
+    build(config?: DataConfig): Promise<DataSplit>;
     isBuilt(): boolean;
     size(): number;
 }