learning_model 1.0.38 → 1.0.39

package/dist/learning/base.d.ts

@@ -2,7 +2,6 @@ import * as tf from '@tensorflow/tfjs';
 import { io } from '@tensorflow/tfjs-core';
 interface LearningInterface {
     model: tf.LayersModel | null;
-    labels: string[];
     isRunning: boolean;
     isReady: boolean;
     onProgress(progress: number): void;

package/dist/learning/mobilenet.d.ts

@@ -7,21 +7,18 @@ declare class LearningMobilenet implements LearningInterface {
     batchSize: number;
     learningRate: number;
     validateRate: number;
-    labels: string[];
-    modelURL: string;
     isRunning: boolean;
     isReady: boolean;
     isTrainedDone: boolean;
     limitSize: number;
     mobilenetModule: tf.LayersModel | null;
-    imageTensors: tf.Tensor<tf.Rank>[];
+    imageExamples: Float32Array[][];
+    classNumber: string[];
     readonly MOBILE_NET_INPUT_WIDTH = 224;
     readonly MOBILE_NET_INPUT_HEIGHT = 224;
     readonly MOBILE_NET_INPUT_CHANNEL = 3;
     readonly IMAGE_NORMALIZATION_FACTOR = 255;
-    constructor({ modelURL, // 디폴트 mobilenet 이미지 
-    epochs, batchSize, limitSize, learningRate, validateRate, }?: {
-        modelURL?: string;
+    constructor({ epochs, batchSize, limitSize, learningRate, validateRate, }?: {
         epochs?: number;
         batchSize?: number;
         limitSize?: number;
@@ -38,6 +35,8 @@ declare class LearningMobilenet implements LearningInterface {
         jsonURL: string;
         labels: Array<string>;
     }): Promise<void>;
+    private registerClassNumber;
+    private _convertToTfDataset;
     addData(label: string, data: any): Promise<void>;
     init(): Promise<void>;
     train(): Promise<tf.History>;
@@ -45,9 +44,6 @@ declare class LearningMobilenet implements LearningInterface {
     saveModel(handlerOrURL: io.IOHandler | string, config?: io.SaveConfig): Promise<void>;
     running(): boolean;
     ready(): boolean;
-    private _preprocessedTargetData;
-    private _preprocessedInputData;
-    private loadModel;
     private _createModel;
 }
 export default LearningMobilenet;

package/dist/learning/mobilenet.js

@@ -38,10 +38,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const tf = __importStar(require("@tensorflow/tfjs"));
+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({ modelURL = 'https://storage.googleapis.com/tfjs-models/tfjs/mobilenet_v1_0.25_224/model.json', // 디폴트 mobilenet 이미지 
-    epochs = 10, batchSize = 16, limitSize = 2, learningRate = 0.001, validateRate = 0.2, } = {}) {
-        this.imageTensors = [];
+    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;
@@ -58,14 +62,12 @@ class LearningMobilenet {
         this.batchSize = batchSize;
         this.learningRate = learningRate;
         this.validateRate = validateRate;
-        this.labels = [];
-        this.modelURL = modelURL;
         this.isRunning = false;
         this.isReady = false;
         this.isTrainedDone = false;
         this.limitSize = limitSize;
         this.mobilenetModule = null;
-        this.imageTensors = [];
+        this.classNumber = [];
     }
     //
     // 기존의 모델 로드
@@ -76,7 +78,9 @@ class LearningMobilenet {
             }
             try {
                 this.model = yield tf.loadLayersModel(jsonURL);
-                this.labels = labels;
+                for (var i = 0; i < labels.length; i++) {
+                    this.registerClassNumber(labels[i]);
+                }
                 this.isReady = true;
                 this.model.summary();
             }
@@ -86,33 +90,68 @@ class LearningMobilenet {
             }
         });
     }
+    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 {
-                const imgTensor = tf.tidy(() => {
-                    if (this.mobilenetModule !== null) {
-                        console.log('predict before', data);
-                        const t = tf.browser.fromPixels(data);
-                        // Resize the image to match the model's input shape
-                        const resizedTensor = tf.image.resizeBilinear(t, [224, 224]);
-                        const normalizedTensor = resizedTensor.div(255.0);
-                        // Add an extra dimension to the tensor
-                        const expandedTensor = normalizedTensor.expandDims(0);
-                        console.log('predict extend', expandedTensor);
-                        const predict = this.mobilenetModule.predict(expandedTensor);
-                        console.log('predict', predict);
-                        return predict;
+                if (this.mobilenetModule !== null) {
+                    const cap = (0, tf_1.isTensor)(data) ? data : (0, tf_1.capture)(data, false);
+                    const predict = this.mobilenetModule.predict(cap);
+                    const activation = predict.dataSync();
+                    const classIndex = this.registerClassNumber(label);
+                    if (!this.imageExamples[classIndex]) {
+                        this.imageExamples[classIndex] = [];
                     }
-                    else {
-                        throw new Error('mobilenetModule is null');
+                    this.imageExamples[classIndex].push(activation);
+                    if (this.classNumber.length >= this.limitSize) {
+                        this.isReady = true;
                     }
-                });
-                console.log('imgTensor', imgTensor);
-                this.imageTensors.push(imgTensor);
-                this.labels.push(label);
-                if (this.labels.length >= this.limitSize) {
-                    this.isReady = true;
+                }
+                else {
+                    throw new Error('mobilenetModule is null');
                 }
                 return Promise.resolve();
             }
@@ -125,7 +164,7 @@ class LearningMobilenet {
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                this.mobilenetModule = yield this.loadModel();
+                this.mobilenetModule = yield (0, tf_1.loadModel)();
             }
             catch (error) {
                 console.log('init Error', error);
@@ -144,12 +183,10 @@ class LearningMobilenet {
                 onTrainBegin: (log) => {
                     this.isTrainedDone = false;
                     this.onTrainBegin(log);
-                    console.log('Training has started.');
                 },
                 onTrainEnd: (log) => {
                     this.isTrainedDone = true;
                     this.onTrainEnd(log);
-                    console.log('Training has ended.');
                     this.isRunning = false;
                 },
                 onBatchBegin: (batch, logs) => {
@@ -163,8 +200,6 @@ class LearningMobilenet {
                 },
                 onEpochEnd: (epoch, logs) => {
                     this.onEpochEnd(epoch, logs);
-                    console.log(`Epoch ${epoch + 1} has ended.`);
-                    console.log('Loss:', logs);
                     this.onLoss(logs.loss);
                     this.onProgress(epoch + 1);
                     this.onEvents({
@@ -175,21 +210,24 @@ class LearningMobilenet {
             };
             try {
                 this.isRunning = true;
-                if (this.labels.length < this.limitSize) {
+                if (this.classNumber.length < this.limitSize) {
                     return Promise.reject(new Error('Please train Data need over 2 data length'));
                 }
-                this.model = yield this._createModel(this.labels.length);
-                const inputData = this._preprocessedInputData(this.model);
-                console.log('this.imageTensors', this.imageTensors, inputData);
-                const targetData = this._preprocessedTargetData();
-                console.log('targetData', targetData);
-                const history = yield this.model.fit(inputData, targetData, {
+                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 history = yield trainModel.fitDataset(trainData, {
                     epochs: this.epochs,
-                    batchSize: this.batchSize,
-                    validationSplit: this.validateRate,
+                    validationData: validationData,
                     callbacks: customCallback
                 });
-                console.log('Model training completed', history);
+                const jointModel = tf.sequential();
+                jointModel.add(this.mobilenetModule);
+                jointModel.add(trainModel);
+                this.model = jointModel;
+                optimizer.dispose();
                 return history;
             }
             catch (error) {
@@ -206,36 +244,18 @@ class LearningMobilenet {
                 return Promise.reject(new Error('Model is Null'));
             }
             try {
-                const imgTensor = tf.tidy(() => {
-                    if (this.mobilenetModule !== null) {
-                        console.log('predict before', data);
-                        const t = tf.browser.fromPixels(data);
-                        // Resize the image to match the model's input shape
-                        const resizedTensor = tf.image.resizeBilinear(t, [224, 224]);
-                        const normalizedTensor = resizedTensor.div(255.0);
-                        // Add an extra dimension to the tensor
-                        const expandedTensor = normalizedTensor.expandDims(0);
-                        console.log('predict extend', expandedTensor);
-                        const predict = this.mobilenetModule.predict(expandedTensor);
-                        console.log('predict', predict);
-                        return predict;
-                    }
-                    else {
-                        throw new Error('mobilenetModule is null');
-                    }
+                const classProbabilities = new Map();
+                const croppedImage = (0, canvas_1.cropTo)(data, 224, false);
+                const logits = tf.tidy(() => {
+                    const captured = (0, tf_1.capture)(croppedImage, false);
+                    return this.model.predict(captured);
                 });
-                const predictions = this.model.predict(imgTensor);
-                const predictedClass = predictions.as1D().argMax();
-                const classId = (yield predictedClass.data())[0];
-                console.log('classId', classId, this.labels[classId]);
-                const predictionsData = yield predictions.data(); // 예측 텐서의 데이터를 비동기로 가져옴
-                const classProbabilities = new Map(); // 클래스별 확률 누적값을 저장할 맵
-                console.log('predictionsData', predictionsData);
+                const values = yield logits.data();
                 const EPSILON = 1e-6; // 매우 작은 값을 표현하기 위한 엡실론
-                for (let i = 0; i < predictionsData.length; i++) {
-                    let probability = Math.max(0, Math.min(1, predictionsData[i])); // 확률 값을 0과 1 사이로 조정
+                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.labels[i]; // 클래스 이름
+                    const className = this.classNumber[i]; // 클래스 이름
                     const existingProbability = classProbabilities.get(className);
                     if (existingProbability !== undefined) {
                         classProbabilities.set(className, existingProbability + probability);
@@ -244,9 +264,7 @@ class LearningMobilenet {
                         classProbabilities.set(className, probability);
                     }
                 }
-                console.log('Class Probabilities:', classProbabilities);
-                predictedClass.dispose();
-                predictions.dispose();
+                (0, tfjs_1.dispose)(logits);
                 return classProbabilities;
             }
             catch (error) {
@@ -258,7 +276,6 @@ class LearningMobilenet {
     saveModel(handlerOrURL, config) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            console.log('saved model');
             if (!this.isTrainedDone) {
                 return Promise.reject(new Error('Train is not done status'));
             }
@@ -272,71 +289,36 @@ class LearningMobilenet {
     ready() {
         return this.isReady;
     }
-    // target 라벨 데이타
-    _preprocessedTargetData() {
-        // 라벨 unique 처리 & 배열 리턴
-        console.log('uniqueLabels.length', this.labels, this.labels.length);
-        const labelIndices = this.labels.map((label) => this.labels.indexOf(label));
-        console.log('labelIndices', labelIndices);
-        const oneHotEncode = tf.oneHot(tf.tensor1d(labelIndices, 'int32'), this.labels.length);
-        console.log('oneHotEncode', oneHotEncode);
-        return oneHotEncode;
-    }
-    // 입력 이미지 데이타 
-    _preprocessedInputData(model) {
-        // 이미지 배열을 배치로 변환 - [null, 224, 224, 3]
-        const inputShape = model.inputs[0].shape;
-        console.log('inputShape', inputShape);
-        // inputShape를 이와 같이 포멧 맞춘다. for reshape to [224, 224, 3]
-        const inputShapeArray = inputShape.slice(1);
-        console.log('inputShapeArray', inputShapeArray);
-        const inputBatch = tf.stack(this.imageTensors.map((image) => {
-            return tf.reshape(image, inputShapeArray);
-        }));
-        return inputBatch;
-    }
-    loadModel() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const load_model = yield tf.loadLayersModel(this.modelURL);
-            load_model.summary();
-            const layer = load_model.getLayer('conv_pw_13_relu');
-            const truncatedModel = tf.model({
-                inputs: load_model.inputs,
-                outputs: layer.output
-            });
-            return truncatedModel;
-        });
-    }
     // 모델 저장
-    _createModel(numClasses) {
+    _createModel(optimizer) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const truncatedModel = yield this.loadModel();
                 // 입력 이미지 크기에 맞게 모델 구조 수정
-                const model = tf.sequential();
-                // 추가적인 합성곱 층
-                model.add(tf.layers.conv2d({
-                    filters: 64,
-                    kernelSize: 3,
-                    activation: 'relu',
-                    padding: 'same',
-                    inputShape: truncatedModel.outputs[0].shape.slice(1)
-                }));
-                model.add(tf.layers.flatten());
-                // 더 깊은 밀집층
-                model.add(tf.layers.dense({ units: 100, activation: 'relu' }));
-                model.add(tf.layers.dense({ units: 100, activation: 'relu' }));
-                // 드롭아웃 층
-                model.add(tf.layers.dropout({ rate: 0.5 }));
-                model.add(tf.layers.dense({ units: this.labels.length, activation: 'softmax' }));
-                const optimizer = tf.train.adam(this.learningRate); // Optimizer를 생성하고 학습률을 설정합니다.
-                model.compile({
-                    loss: (numClasses === 2) ? 'binaryCrossentropy' : 'categoricalCrossentropy',
+                let varianceScaling;
+                varianceScaling = tf.initializers.varianceScaling({});
+                const trainModel = tf.sequential({
+                    layers: [
+                        tf.layers.dense({
+                            inputShape: this.mobilenetModule.outputs[0].shape.slice(1),
+                            units: 64,
+                            activation: 'relu',
+                            kernelInitializer: varianceScaling,
+                            useBias: true
+                        }),
+                        tf.layers.dense({
+                            kernelInitializer: varianceScaling,
+                            useBias: false,
+                            activation: 'softmax',
+                            units: this.classNumber.length,
+                        })
+                    ]
+                });
+                trainModel.compile({
+                    loss: 'categoricalCrossentropy',
                     optimizer: optimizer,
-                    metrics: ['accuracy', 'acc']
+                    metrics: ['accuracy']
                 });
-                model.summary();
-                return model;
+                return trainModel;
             }
             catch (error) {
                 console.error('Failed to load model', error);

package/dist/lib/learning/base.d.ts

@@ -2,7 +2,6 @@ import * as tf from '@tensorflow/tfjs';
 import { io } from '@tensorflow/tfjs-core';
 interface LearningInterface {
     model: tf.LayersModel | null;
-    labels: string[];
     isRunning: boolean;
     isReady: boolean;
     onProgress(progress: number): void;

package/dist/lib/learning/mobilenet.d.ts

@@ -7,21 +7,18 @@ declare class LearningMobilenet implements LearningInterface {
     batchSize: number;
     learningRate: number;
     validateRate: number;
-    labels: string[];
-    modelURL: string;
     isRunning: boolean;
     isReady: boolean;
     isTrainedDone: boolean;
     limitSize: number;
     mobilenetModule: tf.LayersModel | null;
-    imageTensors: tf.Tensor<tf.Rank>[];
+    imageExamples: Float32Array[][];
+    classNumber: string[];
     readonly MOBILE_NET_INPUT_WIDTH = 224;
     readonly MOBILE_NET_INPUT_HEIGHT = 224;
     readonly MOBILE_NET_INPUT_CHANNEL = 3;
     readonly IMAGE_NORMALIZATION_FACTOR = 255;
-    constructor({ modelURL, // 디폴트 mobilenet 이미지 
-    epochs, batchSize, limitSize, learningRate, validateRate, }?: {
-        modelURL?: string;
+    constructor({ epochs, batchSize, limitSize, learningRate, validateRate, }?: {
         epochs?: number;
         batchSize?: number;
         limitSize?: number;
@@ -38,6 +35,8 @@ declare class LearningMobilenet implements LearningInterface {
         jsonURL: string;
         labels: Array<string>;
     }): Promise<void>;
+    private registerClassNumber;
+    private _convertToTfDataset;
     addData(label: string, data: any): Promise<void>;
     init(): Promise<void>;
     train(): Promise<tf.History>;
@@ -45,9 +44,6 @@ declare class LearningMobilenet implements LearningInterface {
     saveModel(handlerOrURL: io.IOHandler | string, config?: io.SaveConfig): Promise<void>;
     running(): boolean;
     ready(): boolean;
-    private _preprocessedTargetData;
-    private _preprocessedInputData;
-    private loadModel;
     private _createModel;
 }
 export default LearningMobilenet;

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

@@ -0,0 +1,3 @@
+type Drawable = ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
+export declare function cropTo(image: Drawable, size: number, flipped?: boolean, canvas?: HTMLCanvasElement): HTMLCanvasElement;
+export {};

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

@@ -0,0 +1,6 @@
+export interface Sample {
+    data: Float32Array;
+    label: number[];
+}
+export declare function flatOneHot(label: number, numClasses: number): number[];
+export declare function fisherYates(array: Float32Array[] | Sample[]): Float32Array[] | Sample[];

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

@@ -0,0 +1,7 @@
+import * as tf from '@tensorflow/tfjs';
+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): tf.Tensor<tf.Rank>;
+export declare function cropTensor(img: tf.Tensor3D, grayscaleModel?: boolean, grayscaleInput?: boolean): tf.Tensor3D;

package/dist/utils/canvas.d.ts

@@ -0,0 +1,3 @@
+type Drawable = ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
+export declare function cropTo(image: Drawable, size: number, flipped?: boolean, canvas?: HTMLCanvasElement): HTMLCanvasElement;
+export {};

package/dist/utils/canvas.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cropTo = void 0;
+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;
+}
+exports.cropTo = cropTo;

package/dist/utils/dataset.d.ts

@@ -0,0 +1,6 @@
+export interface Sample {
+    data: Float32Array;
+    label: number[];
+}
+export declare function flatOneHot(label: number, numClasses: number): number[];
+export declare function fisherYates(array: Float32Array[] | Sample[]): Float32Array[] | Sample[];

package/dist/utils/dataset.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fisherYates = exports.flatOneHot = void 0;
+function flatOneHot(label, numClasses) {
+    const labelOneHot = new Array(numClasses).fill(0);
+    labelOneHot[label] = 1;
+    return labelOneHot;
+}
+exports.flatOneHot = flatOneHot;
+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;
+}
+exports.fisherYates = fisherYates;

package/dist/utils/tf.d.ts

@@ -0,0 +1,7 @@
+import * as tf from '@tensorflow/tfjs';
+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): tf.Tensor<tf.Rank>;
+export declare function cropTensor(img: tf.Tensor3D, grayscaleModel?: boolean, grayscaleInput?: boolean): tf.Tensor3D;