learning_model 1.0.51 → 1.0.53

package/dist/lib/learning/mobilenet.js

@@ -0,0 +1,386 @@
+"use strict";
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// mobilenet 모델을 이용한 전이학습 방법 
+///////////////////////////////////////////////////////////////////////////
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tf = __importStar(require("@tensorflow/tfjs"));
+const tfjs_backend_wasm_1 = require("@tensorflow/tfjs-backend-wasm");
+const tfjs_1 = require("@tensorflow/tfjs");
+const tf_1 = require("../utils/tf");
+const canvas_1 = require("../utils/canvas");
+const dataset_1 = require("../utils/dataset");
+class LearningMobilenet {
+    constructor({ epochs = 50, batchSize = 16, limitSize = 2, learningRate = 0.001, validateRate = 0.15, } = {}) {
+        this.imageExamples = [];
+        this.classNumber = [];
+        this.MOBILE_NET_INPUT_WIDTH = 224;
+        this.MOBILE_NET_INPUT_HEIGHT = 224;
+        this.MOBILE_NET_INPUT_CHANNEL = 3;
+        this.IMAGE_NORMALIZATION_FACTOR = 255.0;
+        // 진행 상태를 나타내는 이벤트를 정의합니다.
+        this.onProgress = () => { };
+        this.onLoss = () => { };
+        this.onEvents = () => { };
+        this.onTrainBegin = () => { };
+        this.onTrainEnd = () => { };
+        this.onEpochEnd = () => { };
+        this.model = null;
+        this.epochs = epochs;
+        this.batchSize = batchSize;
+        this.learningRate = learningRate;
+        this.validateRate = validateRate;
+        this.isRunning = false;
+        this.isReady = false;
+        this.isTrainedDone = false;
+        this.limitSize = limitSize;
+        this.mobilenetModule = null;
+        this.classNumber = [];
+    }
+    //
+    // 기존의 모델 로드
+    load(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ jsonURL, labels }) {
+            if (labels.length <= 0) {
+                return Promise.reject(new Error('Labels length is 0'));
+            }
+            try {
+                this.model = yield tf.loadLayersModel(jsonURL);
+                for (var i = 0; i < labels.length; i++) {
+                    this.registerClassNumber(labels[i]);
+                }
+                this.isReady = true;
+                this.model.summary();
+            }
+            catch (error) {
+                console.error('Model load failed', error);
+                throw error;
+            }
+        });
+    }
+    registerClassNumber(value) {
+        // 중복 값의 인덱스를 찾습니다.
+        const existingIndex = this.classNumber.indexOf(value);
+        // 중복 값이 있다면 해당 인덱스를 반환합니다.
+        if (existingIndex !== -1) {
+            return existingIndex;
+        }
+        // 중복 값이 없다면 새로운 항목을 추가하고 그 인덱스를 반환합니다.
+        this.classNumber.push(value);
+        return this.classNumber.length - 1;
+    }
+    _convertToTfDataset() {
+        for (let i = 0; i < this.imageExamples.length; i++) {
+            this.imageExamples[i] = (0, dataset_1.fisherYates)(this.imageExamples[i]);
+        }
+        const trainDataset = [];
+        const validationDataset = [];
+        for (let i = 0; i < this.imageExamples.length; i++) {
+            const classLength = this.imageExamples[i].length;
+            // 클래스의 전체 데이터 수를 사용하여 학습 및 검증 데이터 수 계산
+            const numValidation = Math.ceil(this.validateRate * classLength);
+            const numTrain = classLength - numValidation;
+            // One-Hot 인코딩을 사용하여 라벨 생성
+            const y = (0, dataset_1.flatOneHot)(i, this.classNumber.length);
+            // numTrain과 numValidation에 따라 데이터를 학습 및 검증 데이터로 분할
+            const classTrain = this.imageExamples[i].slice(0, numTrain).map(dataArray => ({ data: dataArray, label: y }));
+            trainDataset.push(...classTrain);
+            const classValidation = this.imageExamples[i].slice(numTrain, numTrain + numValidation).map(dataArray => ({ data: dataArray, label: y }));
+            validationDataset.push(...classValidation);
+        }
+        // Shuffle entire datasets
+        const shuffledTrainDataset = (0, dataset_1.fisherYates)(trainDataset);
+        const shuffledValidationDataset = (0, dataset_1.fisherYates)(validationDataset);
+        // Convert to tf.data.Dataset
+        const trainX = tf.data.array(shuffledTrainDataset.map(sample => sample.data));
+        const validationX = tf.data.array(shuffledValidationDataset.map(sample => sample.data));
+        const trainY = tf.data.array(shuffledTrainDataset.map(sample => sample.label));
+        const validationY = tf.data.array(shuffledValidationDataset.map(sample => sample.label));
+        return {
+            trainDataset: tf.data.zip({ xs: trainX, ys: trainY }),
+            validationDataset: tf.data.zip({ xs: validationX, ys: validationY })
+        };
+    }
+    // 학습 데이타 등록 
+    addData(label, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.mobilenetModule !== null) {
+                    const cap = (0, tf_1.isTensor)(data) ? data : yield (0, tf_1.capture)(data, false);
+                    const predict = tf.tidy(() => {
+                        return this.mobilenetModule.predict(cap);
+                    });
+                    const activation = yield predict.data();
+                    const classIndex = this.registerClassNumber(label);
+                    if (!this.imageExamples[classIndex]) {
+                        this.imageExamples[classIndex] = [];
+                    }
+                    this.imageExamples[classIndex].push(activation);
+                    if (this.classNumber.length >= this.limitSize) {
+                        this.isReady = true;
+                    }
+                    // Dispose of the prediction tensor to free memory
+                    predict.dispose();
+                    // If cap is not a tensor, we don't need to dispose it. Otherwise, we should.
+                    if (!(0, tf_1.isTensor)(data)) {
+                        cap.dispose();
+                    }
+                }
+                else {
+                    throw new Error('mobilenetModule is null');
+                }
+                return Promise.resolve();
+            }
+            catch (error) {
+                console.error('Model training failed', error);
+                throw error;
+            }
+        });
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                console.log('init call');
+                yield this.setupBackend();
+                this.mobilenetModule = yield (0, tf_1.loadModel)();
+            }
+            catch (error) {
+                console.log('init Error', error);
+                throw error;
+            }
+        });
+    }
+    setupBackend() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isWasmSupported = yield this.checkWasmSupport();
+            if (isWasmSupported) {
+                console.log('Backend is set to WebAssembly');
+            }
+            else {
+                yield tf.setBackend('cpu');
+                yield tf.ready();
+                console.log('Backend is set to CPU');
+            }
+        });
+    }
+    checkWasmSupport() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const wasmVersion = tf.version['tfjs-backend-wasm'] || tf.version['tfjs-core'];
+                (0, tfjs_backend_wasm_1.setWasmPaths)(`https://cdn.jsdelivr.net/npm/@tensorflow/tfjs-backend-wasm@${wasmVersion}/dist/`);
+                yield tf.setBackend('wasm');
+                yield tf.ready();
+                return true;
+            }
+            catch (error) {
+                console.warn('WASM backend is not supported in this environment.', error);
+                return false;
+            }
+        });
+    }
+    // 모델 학습 처리
+    train() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isRunning) {
+                return Promise.reject(new Error('Training is already in progress.'));
+            }
+            // 콜백 정의
+            const customCallback = {
+                onTrainBegin: (log) => {
+                    this.isTrainedDone = false;
+                    this.onTrainBegin(log);
+                },
+                onTrainEnd: (log) => {
+                    this.isTrainedDone = true;
+                    this.onTrainEnd(log);
+                    this.isRunning = false;
+                },
+                onBatchBegin: (batch, logs) => {
+                    //console.log(`Batch ${batch} is starting.`);
+                },
+                onBatchEnd: (batch, logs) => {
+                    //console.log(`Batch ${batch} has ended.`);
+                },
+                onEpochBegin: (epoch, logs) => {
+                    //console.log(`Epoch ${epoch+1} is starting.`, logs);
+                },
+                onEpochEnd: (epoch, logs) => {
+                    this.onEpochEnd(epoch, logs);
+                    this.onLoss(logs.loss);
+                    this.onProgress(epoch + 1);
+                    this.onEvents({
+                        epoch: epoch,
+                        logs: logs,
+                    });
+                }
+            };
+            try {
+                this.isRunning = true;
+                if (this.classNumber.length < this.limitSize) {
+                    return Promise.reject(new Error('Please train Data need over 2 data length'));
+                }
+                const datasets = this._convertToTfDataset();
+                const trainData = datasets.trainDataset.batch(this.batchSize);
+                const validationData = datasets.validationDataset.batch(this.batchSize);
+                const optimizer = tf.train.adam(this.learningRate);
+                const trainModel = yield this._createModel(optimizer);
+                const jointModel = tf.sequential();
+                jointModel.add(this.mobilenetModule);
+                jointModel.add(trainModel);
+                this.model = jointModel;
+                const history = yield trainModel.fitDataset(trainData, {
+                    epochs: this.epochs,
+                    validationData: validationData,
+                    callbacks: customCallback
+                });
+                optimizer.dispose();
+                return history;
+            }
+            catch (error) {
+                this.isRunning = false;
+                console.error('Model training failed', error);
+                throw error;
+            }
+        });
+    }
+    // 추론하기
+    infer(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.model === null) {
+                return Promise.reject(new Error('Model is Null'));
+            }
+            try {
+                const classProbabilities = new Map();
+                const croppedImage = (0, canvas_1.cropTo)(data, 224, false);
+                const captured = yield (0, tf_1.capture)(croppedImage, false);
+                const logits = tf.tidy(() => {
+                    return this.model.predict(captured);
+                });
+                const values = yield logits.data();
+                const EPSILON = 1e-6; // 매우 작은 값을 표현하기 위한 엡실론
+                for (let i = 0; i < values.length; i++) {
+                    let probability = Math.max(0, Math.min(1, values[i])); // 확률 값을 0과 1 사이로 조정
+                    probability = probability < EPSILON ? 0 : probability; // 매우 작은 확률 값을 0으로 간주
+                    const className = this.classNumber[i]; // 클래스 이름
+                    const existingProbability = classProbabilities.get(className);
+                    if (existingProbability !== undefined) {
+                        classProbabilities.set(className, existingProbability + probability);
+                    }
+                    else {
+                        classProbabilities.set(className, probability);
+                    }
+                }
+                console.log('classProbabilities', classProbabilities);
+                (0, tfjs_1.dispose)(logits);
+                return classProbabilities;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    // 모델 저장
+    saveModel(handlerOrURL, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                console.log('saveModel try', this.isTrainedDone);
+                if (!this.isTrainedDone) {
+                    return Promise.reject(new Error('Train is not done status'));
+                }
+                yield ((_a = this.model) === null || _a === void 0 ? void 0 : _a.save(handlerOrURL, config));
+            }
+            catch (e) {
+                console.log('saveModel Error', e);
+            }
+        });
+    }
+    // 진행중 여부
+    running() {
+        return this.isRunning;
+    }
+    ready() {
+        return this.isReady;
+    }
+    // 모델 저장
+    _createModel(optimizer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 입력 이미지 크기에 맞게 모델 구조 수정
+                let varianceScaling;
+                varianceScaling = tf.initializers.varianceScaling({});
+                const trainModel = tf.sequential({
+                    layers: [
+                        tf.layers.dense({
+                            inputShape: this.mobilenetModule.outputs[0].shape.slice(1),
+                            units: 128,
+                            activation: 'relu',
+                            kernelInitializer: varianceScaling, // 'varianceScaling'
+                            useBias: true
+                        }),
+                        tf.layers.dense({
+                            kernelInitializer: varianceScaling, // 'varianceScaling'
+                            useBias: false,
+                            activation: 'softmax',
+                            units: this.classNumber.length,
+                        })
+                    ]
+                });
+                trainModel.compile({
+                    loss: 'categoricalCrossentropy',
+                    optimizer: optimizer,
+                    metrics: ['accuracy']
+                });
+                return trainModel;
+            }
+            catch (error) {
+                console.error('Failed to load model', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.default = LearningMobilenet;

package/dist/lib/learning/mobilenet.test.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const tf = __importStar(require("@tensorflow/tfjs"));
+const mobilenet_1 = __importDefault(require("./mobilenet"));
+const fs = __importStar(require("fs"));
+const { createCanvas, loadImage } = require('canvas');
+let imageTensor1;
+let imageTensor2;
+// 이미지경로를 기준으로
+function ImagePathToTensor(imagePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const imageBuffer = fs.readFileSync(imagePath);
+        const image = yield loadImage(imageBuffer);
+        const canvas = createCanvas(image.width, image.height);
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(image, 0, 0);
+        const imageData = ctx.getImageData(0, 0, image.width, image.height);
+        return tf.tensor3d(imageData.data, [imageData.height, imageData.width, 4], 'int32');
+    });
+}
+describe('LearningMobilenetImage', () => {
+    const learning = new mobilenet_1.default({});
+    const image1Path = path.join(__dirname, '../../public/images/image1.jpeg');
+    const image2Path = path.join(__dirname, '../../public/images/image2.jpeg');
+    console.log('Resolved path for image1:', image1Path);
+    beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+        learning.init();
+        imageTensor1 = yield ImagePathToTensor(image1Path);
+        imageTensor2 = yield ImagePathToTensor(image2Path);
+    }));
+    it('loads an image and converts it to a tensor', () => {
+        expect(imageTensor1).toBeDefined();
+        expect(imageTensor1 instanceof tf.Tensor).toBe(true);
+        expect(imageTensor2).toBeDefined();
+        expect(imageTensor2 instanceof tf.Tensor).toBe(true);
+    });
+    // test('mobilenet add data', () => {
+    //   learning.addData("라벨1", imageTensor1);
+    //   learning.addData("라벨1", imageTensor1);
+    //   learning.addData("라벨2", imageTensor2);
+    //   learning.addData("라벨2", imageTensor2);
+    // });
+});

package/dist/lib/utils/canvas.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cropTo = cropTo;
+const newCanvas = () => document.createElement('canvas');
+function cropTo(image, size, flipped = false, canvas = newCanvas()) {
+    let width;
+    let height;
+    // If ImageData
+    if (image instanceof ImageData) {
+        width = image.width;
+        height = image.height;
+    }
+    // If image, bitmap, or canvas
+    else if (image instanceof HTMLImageElement || image instanceof HTMLCanvasElement) {
+        width = image.width;
+        height = image.height;
+    }
+    // If video element
+    else if (image instanceof HTMLVideoElement) {
+        width = image.videoWidth;
+        height = image.videoHeight;
+    }
+    else {
+        throw new Error("Unsupported Drawable type");
+    }
+    const min = Math.min(width, height);
+    const scale = size / min;
+    const scaledW = Math.ceil(width * scale);
+    const scaledH = Math.ceil(height * scale);
+    const dx = scaledW - size;
+    const dy = scaledH - size;
+    canvas.width = canvas.height = size;
+    const ctx = canvas.getContext('2d');
+    // Handle ImageData separately
+    if (image instanceof ImageData) {
+        ctx.putImageData(image, ~~(dx / 2) * -1, ~~(dy / 2) * -1); // Adjust this if needed
+    }
+    else {
+        ctx.drawImage(image, ~~(dx / 2) * -1, ~~(dy / 2) * -1, scaledW, scaledH);
+    }
+    if (flipped) {
+        ctx.scale(-1, 1);
+        ctx.drawImage(canvas, size * -1, 0);
+    }
+    return canvas;
+}

package/dist/lib/utils/data_manager.d.ts

@@ -1,12 +1,11 @@
-import * as tf from '@tensorflow/tfjs';
 declare class DataManager {
     private labelMap;
     private labelIndex;
     private data;
     addData(label: string, values: number[]): Promise<void>;
     convertToTensors(): {
-        xs: tf.Tensor2D;
-        ys: tf.Tensor1D;
+        xs: any;
+        ys: any;
     };
     getLabelMap(): {
         [key: string]: number;

package/dist/lib/utils/data_manager.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tf = __importStar(require("@tensorflow/tfjs"));
+class DataManager {
+    constructor() {
+        this.labelMap = {};
+        this.labelIndex = 0;
+        this.data = [];
+    }
+    addData(label, values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(label in this.labelMap)) {
+                this.labelMap[label] = this.labelIndex++;
+            }
+            const numericLabel = this.labelMap[label];
+            this.data.push({ label: numericLabel, values });
+        });
+    }
+    convertToTensors() {
+        const xs = this.data.map(d => d.values);
+        const ys = this.data.map(d => d.label);
+        const xsTensor = tf.tensor2d(xs, [xs.length, xs[0].length], 'float32');
+        const ysTensor = tf.tensor1d(ys, 'float32');
+        return { xs: xsTensor, ys: ysTensor };
+    }
+    getLabelMap() {
+        return this.labelMap;
+    }
+}
+exports.default = DataManager;

package/dist/lib/utils/dataset.d.ts

@@ -3,4 +3,4 @@ export interface Sample {
     label: number[];
 }
 export declare function flatOneHot(label: number, numClasses: number): number[];
-export declare function fisherYates(array: Float32Array[] | Sample[]): Float32Array[] | Sample[];
+export declare function fisherYates(array: Float32Array[] | Sample[]): Float32Array<ArrayBuffer>[] | Sample[];

package/dist/lib/utils/dataset.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatOneHot = flatOneHot;
+exports.fisherYates = fisherYates;
+function flatOneHot(label, numClasses) {
+    const labelOneHot = new Array(numClasses).fill(0);
+    labelOneHot[label] = 1;
+    return labelOneHot;
+}
+function fisherYates(array) {
+    const length = array.length;
+    // need to clone array or we'd be editing original as we goo
+    const shuffled = array.slice();
+    for (let i = (length - 1); i > 0; i -= 1) {
+        let randomIndex;
+        randomIndex = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[randomIndex]] = [shuffled[randomIndex], shuffled[i]];
+    }
+    return shuffled;
+}

package/dist/lib/utils/tf.d.ts

@@ -3,5 +3,5 @@ export declare function isTensor(c: any): c is tf.Tensor;
 export declare function loadModel(): Promise<tf.LayersModel>;
 export declare function mobileNetURL(version: number): string;
 export declare function imageToTensor(data: any): tf.Tensor3D;
-export declare function capture(rasterElement: HTMLImageElement | HTMLVideoElement | HTMLCanvasElement, grayscale?: boolean): Promise<tf.Tensor<tf.Rank>>;
+export declare function capture(rasterElement: HTMLImageElement | HTMLVideoElement | HTMLCanvasElement, grayscale?: boolean): Promise<any>;
 export declare function cropTensor(img: tf.Tensor3D, grayscaleModel?: boolean, grayscaleInput?: boolean): tf.Tensor3D;