tfjs-evolution 0.0.3 → 0.0.5

package/esm2022/lib/models/teachable-evolution.mjs

@@ -0,0 +1,424 @@
+import { CustomMobileNet } from "./custom-mobilenet";
+import * as tf from '@tensorflow/tfjs';
+import { capture } from '../utils/tf';
+import { Util } from "../utils/util";
+import * as tfvis from '@tensorflow/tfjs-vis';
+const VALIDATION_FRACTION = 0.15;
+/**
+ * Receives a Metadata object and fills in the optional fields such as timeStamp
+ * @param data a Metadata object
+ */
+const fillMetadata = (data) => {
+    // util.assert(typeof data.tfjsVersion === 'string', () => `metadata.tfjsVersion is invalid`);
+    // data.packageVersion = data.packageVersion || version;
+    data.packageName = data.packageName || '@teachablemachine/image';
+    data.timeStamp = data.timeStamp || new Date().toISOString();
+    data.userMetadata = data.userMetadata || {};
+    data.modelName = data.modelName || 'untitled';
+    data.labels = data.labels || [];
+    // data.imageSize = data.imageSize || IMAGE_SIZE;
+    return data;
+};
+export class TeachableMobileNet extends CustomMobileNet {
+    // Array of all the examples collected.
+    /**
+      It is static since all the instance will share the same features, for saving memory and time.
+      The idea is avoiding restoring the features individually and having the recalculate them for every new
+      individuals.
+     */
+    static { this.examples = []; }
+    // Number of total samples
+    static { this.totalSamples = 0; }
+    static { this.classes_names = []; }
+    constructor() {
+        super();
+        this.classes = [];
+        this.createHead();
+    }
+    /**
+     * This method will return the head, the trainable part, the part under evolution.
+     */
+    getHead() {
+        return this.trainingModel;
+    }
+    /**
+     * Create the head for transfer learning.
+     * This is the trainable section of the transfer learning.
+     */
+    createHead() {
+        const inputSize = TeachableMobileNet.getinputShape();
+        this.trainingModel = tf.sequential({
+            layers: [
+                tf.layers.dense({
+                    inputShape: [inputSize],
+                    units: 100,
+                    activation: 'relu',
+                    useBias: true
+                }),
+                tf.layers.dense({
+                    useBias: false,
+                    activation: 'softmax',
+                    units: TeachableMobileNet.classes_names.length
+                })
+            ]
+        });
+        const optimizer = tf.train.adam();
+        // const optimizer = tf.train.rmsprop(params.learningRate);
+        this.trainingModel.compile({
+            optimizer,
+            // loss: 'binaryCrossentropy',
+            loss: 'categoricalCrossentropy',
+            metrics: ['accuracy']
+        });
+    }
+    async train() {
+        const trainingSurface = { name: 'Loss and MSE', tab: 'Training' };
+        const dataset = TeachableMobileNet.convertToTfDataset();
+        //Salving a copy of the validation dataset, for later
+        TeachableMobileNet.validationDataset = dataset.validationDataset;
+        // console.log("Dataset for training: ", dataset.trainDataset);
+        const trainData = dataset.trainDataset.batch(30);
+        const validationData = dataset.validationDataset.batch(10);
+        // this.createHead();
+        const callbacks = [
+            // Show on a tfjs-vis visor the loss and accuracy values at the end of each epoch.
+            tfvis.show.fitCallbacks(trainingSurface, ['loss', 'acc', "val_loss", "val_acc"], {
+                callbacks: ['onEpochEnd'],
+            }),
+            {},
+        ];
+        const history = await this.trainingModel.fitDataset(trainData, {
+            epochs: 100,
+            validationData,
+            callbacks
+        }).then((info) => {
+            console.log('Precisão final', info.history.val_acc[info.history.acc.length - 1]);
+        });
+        // await this.accuracy_per_class();
+        // console.log("History: ", history.history.acc);
+        // await this.trainingModel.fit(this.featureX, this.target, {})
+    }
+    async accuracy_per_class(confusion_matrix_recipient) {
+        /**Calculating Accuracy per class */
+        const accuracyperclass = await this.calculateAccuracyPerClass(TeachableMobileNet.validationDataset);
+        // console.log("Accuracy per class: ", accuracyperclass);
+        //Confusion matrix
+        // Calling tf.confusionMatrix() method 
+        const output = tf.math.confusionMatrix(accuracyperclass.reference, accuracyperclass.predictions, TeachableMobileNet.classes_names.length);
+        // Printing output 
+        output.print();
+        const confusion_matrix = output.dataSync();
+        // console.log(confusion_matrix);
+        // console.log(confusion_matrix[TeachableMobileNet.classes_names.length + TeachableMobileNet.classes_names.length]);
+        const accuracy = [];
+        for (let i = 0; i < TeachableMobileNet.classes_names.length; i++) {
+            accuracy.push(confusion_matrix[TeachableMobileNet.classes_names.length * i + i] / TeachableMobileNet.numValidation);
+        }
+        console.log("Accuracy per class: ", accuracy);
+        for (let i = 0; i < TeachableMobileNet.classes_names.length; i++) {
+            confusion_matrix_recipient.push([]);
+            for (let j = 0; j < TeachableMobileNet.classes_names.length; j++) {
+                confusion_matrix_recipient[i].push([]);
+                confusion_matrix_recipient[i][j] = confusion_matrix[TeachableMobileNet.classes_names.length * i + j] / TeachableMobileNet.numValidation;
+                confusion_matrix_recipient[i][j] = (confusion_matrix_recipient[i][j].toFixed(2)) * 100;
+            }
+            // accuracy.push(confusion_matrix[TeachableMobileNet.classes_names.length*i+ i]/TeachableMobileNet.numValidation)
+        }
+        console.log("Confusion matrix as a matrix");
+        console.log(confusion_matrix_recipient);
+        return accuracy.map((elem) => elem.toFixed(2) * 100);
+    }
+    async loadImages(number_of_species, classes_names, options) {
+        TeachableMobileNet.classes_names = classes_names;
+        await this.add_species(number_of_species, options);
+    }
+    async add_species(number_of_species, options) {
+        //Loading feature model, used to create features from images
+        //  await this.loadFeatureModel();
+        for (let i = 0; i < TeachableMobileNet.classes_names.length; i++) {
+            // this.add_images(this.classes_names[i], number_of_species, options);
+        }
+    }
+    /**
+     *
+     * @param name - name of the class receiving an example
+     * @param number_of_species - how many images to add
+     * @param options - details on the location of the images
+     */
+    async add_images(name, number_of_species, options) {
+        const class_add = [];
+        for (let i = 0; i < number_of_species; i++) {
+            //   class_add.push(`${options.base}/${name}/${options.file_name} ${i}.${options.file_extension}`);
+            //Uploading images
+            const cake = new Image();
+            // cake.src = `${options.base}/${name}/${options.file_name} ${i}.${options.file_extension}`;
+            cake.height = 224;
+            cake.width = 224;
+            cake.src = "./assets/dataset/Can%C3%A1rio-da-Terra/image%200.jpeg";
+            // console.log("Image location: ", cake.src )
+            await new Promise((resolve, reject) => {
+                cake.onload = () => {
+                    //Finding the correspondent index of the class with name given
+                    const index = TeachableMobileNet.classes_names.findIndex((elem) => elem === name);
+                    // this.addExample(index, cake);
+                    resolve();
+                };
+                cake.onerror = (error) => {
+                    // Handle error if the image fails to load
+                    reject(error);
+                };
+            });
+        }
+        // this.classes.push({name: name, images: class_add})  
+    }
+    /**
+     * This method will transform images into tensors
+     * @param number_of_classes - number of classes
+     * @param classes_names - name of each class
+     */
+    async createTensors(number_of_classes, classes_names) {
+        let output = [];
+        /** There is a function on TensorFlow.js that also does that */
+        const signatures = new Util().identityMatrix(number_of_classes);
+        for (let i = 0; i < number_of_classes; i++) {
+            this.classes[i].signature = signatures[i];
+            this.classes[i].name = classes_names[i];
+            for (let j = 0; j < this.classes[i].images.length; j++) {
+            }
+        }
+    }
+    /**
+     * Add a sample of data under the provided className
+     * @param className the classification this example belongs to
+     * @param sample the image / tensor that belongs in this classification
+     */
+    // public async addExample(className: number, sample: HTMLCanvasElement | tf.Tensor) {
+    static async addExample(className, name, sample) {
+        // console.log("Adding a new example...") 
+        const cap = isTensor(sample) ? sample : capture(sample);
+        //Getting the features
+        const example = this.truncatedModel.predict(cap);
+        // console.log("Shape after feature extraction: ", example.shape)          
+        const activation = example.dataSync();
+        //Very important to clean the memory aftermath, it makes the difference
+        cap.dispose();
+        example.dispose();
+        // //Accessing the instance variable, not the local ones
+        // // save samples of each class separately 
+        if (!TeachableMobileNet.examples[className])
+            //and an empty array, make sure there is not empty elements. 
+            //it will create issue when transforming to tensors
+            TeachableMobileNet.examples[className] = [];
+        if (!TeachableMobileNet.classes_names[className])
+            //Saving the lable when it first appears
+            TeachableMobileNet.classes_names[className] = name;
+        TeachableMobileNet.examples[className].push(activation);
+        // // increase our sample counter
+        TeachableMobileNet.totalSamples++;
+    }
+    /**
+      * process the current examples provided to calculate labels and format
+      * into proper tf.data.Dataset
+      */
+    static prepare() {
+        for (const classes in TeachableMobileNet.examples) {
+            if (classes.length === 0) {
+                throw new Error('Add some examples before training');
+            }
+        }
+        const datasets = this.convertToTfDataset();
+        this.trainDataset = datasets.trainDataset;
+        this.validationDataset = datasets.validationDataset;
+    }
+    prepareDataset() {
+        for (let i = 0; i < TeachableMobileNet.numClasses; i++) {
+            //Different from the original implementation of TM, mine is using example as static.
+            //The goal is saving memory by using a single instance of the variable
+            TeachableMobileNet.examples[i] = [];
+        }
+    }
+    /**
+         * Process the examples by first shuffling randomly per class, then adding
+         * one-hot labels, then splitting into training/validation datsets, and finally
+         * sorting one last time
+         */
+    static convertToTfDataset() {
+        // first shuffle each class individually
+        // TODO: we could basically replicate this by insterting randomly
+        for (let i = 0; i < TeachableMobileNet.examples.length; i++) {
+            TeachableMobileNet.examples[i] = fisherYates(TeachableMobileNet.examples[i], this.seed);
+        }
+        // then break into validation and test datasets
+        let trainDataset = [];
+        let validationDataset = [];
+        // for each class, add samples to train and validation dataset
+        for (let i = 0; i < TeachableMobileNet.examples.length; i++) {
+            // console.log("Number of classes: ", TeachableMobileNet.classes_names.length);
+            const y = flatOneHot(i, TeachableMobileNet.classes_names.length);
+            const classLength = TeachableMobileNet.examples[i].length;
+            // console.log("Number of elements per class: ", classLength);
+            const numValidation = Math.ceil(VALIDATION_FRACTION * classLength);
+            const numTrain = classLength - numValidation;
+            this.numValidation = numValidation;
+            /**It is visiting per class, thus, it is possible to fix y, the target label */
+            const classTrain = this.examples[i].slice(0, numTrain).map((dataArray) => {
+                return { data: dataArray, label: y };
+            });
+            const classValidation = this.examples[i].slice(numTrain).map((dataArray) => {
+                return { data: dataArray, label: y };
+            });
+            trainDataset = trainDataset.concat(classTrain);
+            validationDataset = validationDataset.concat(classValidation);
+        }
+        // console.log("Training element: ", trainDataset[trainDataset.length-1])      
+        // console.log("Training length: ", trainDataset.length)
+        // console.log("validation length: ", validationDataset.length);
+        // finally shuffle both train and validation datasets
+        trainDataset = fisherYates(trainDataset, this.seed);
+        validationDataset = fisherYates(validationDataset, this.seed);
+        const trainX = tf.data.array(trainDataset.map(sample => sample.data));
+        const validationX = tf.data.array(validationDataset.map(sample => sample.data));
+        const trainY = tf.data.array(trainDataset.map(sample => sample.label));
+        const validationY = tf.data.array(validationDataset.map(sample => sample.label));
+        // return tf.data dataset objects
+        return {
+            trainDataset: tf.data.zip({ xs: trainX, ys: trainY }),
+            validationDataset: tf.data.zip({ xs: validationX, ys: validationY })
+        };
+    }
+    datasetForEvaluation() {
+    }
+    async evaluate() {
+        if (!TeachableMobileNet.feature_aux) {
+            const features = [];
+            const targets = [];
+            for (let i = 0; i < TeachableMobileNet.examples.length; i++) {
+                const y = flatOneHot(i, TeachableMobileNet.classes_names.length);
+                //For class i, push all the examples.
+                TeachableMobileNet.examples[i].forEach((elemn) => {
+                    //Pushing the target signature
+                    targets.push(y);
+                    //Pushing features
+                    features.push(elemn);
+                });
+            }
+            TeachableMobileNet.feature_aux = tf.tensor(features);
+            TeachableMobileNet.target_aux = tf.tensor(targets);
+        }
+        const aux = this.trainingModel.evaluate(TeachableMobileNet.feature_aux, TeachableMobileNet.target_aux);
+        return aux[1].dataSync()[0];
+    }
+    // async evaluate(){
+    //   const features: any=[];
+    //   const targets: any=[];
+    //   for (let i = 0; i < TeachableMobileNet.examples.length; i++) {
+    //     const y = flatOneHot(i, TeachableMobileNet.classes_names.length);
+    //     //For class i, push all the examples.
+    //     TeachableMobileNet.examples[i].forEach((elemn)=>{
+    //        //Pushing the target signature
+    //        targets.push(y);
+    //        //Pushing features
+    //        features.push(elemn)
+    //     })
+    //   }  
+    //   const aux_features= tf.tensor(features);
+    //   const aux_target= tf.tensor(targets);
+    //   // console.log("Tensor stack for evaluation: ", aux_features.shape)
+    //   const aux: any = this.trainingModel.evaluate(aux_features, aux_target);
+    //   return aux[1].dataSync()[0];
+    // }
+    /*** Final statistics */
+    /*
+         * Calculate each class accuracy using the validation dataset
+    */
+    async calculateAccuracyPerClass(validationData) {
+        const validationXs = TeachableMobileNet.validationDataset.mapAsync(async (dataset) => {
+            return dataset.xs;
+        });
+        const validationYs = TeachableMobileNet.validationDataset.mapAsync(async (dataset) => {
+            return dataset.ys;
+        });
+        // console.log("validation dataset: ", validationXs);
+        // console.log("For calculating batch size: ", validationYs);
+        // we need to split our validation data into batches in case it is too large to fit in memory
+        const batchSize = Math.min(validationYs.size, 32);
+        // const batchSize =1;
+        const iterations = Math.ceil(validationYs.size / batchSize);
+        // console.log("Batch size: ", batchSize);
+        const batchesX = validationXs.batch(batchSize);
+        const batchesY = validationYs.batch(batchSize);
+        const itX = await batchesX.iterator();
+        const itY = await batchesY.iterator();
+        const allX = [];
+        const allY = [];
+        for (let i = 0; i < iterations; i++) {
+            // 1. get the prediction values in batches
+            const batchedXTensor = await itX.next();
+            //  console.log("Batch size on accuracy per class: ", batchedXTensor.value.shape);
+            const batchedXPredictionTensor = this.trainingModel.predict(batchedXTensor.value);
+            const argMaxX = batchedXPredictionTensor.argMax(1); // Returns the indices of the max values along an axis
+            allX.push(argMaxX);
+            // 2. get the ground truth label values in batches
+            const batchedYTensor = await itY.next();
+            const argMaxY = batchedYTensor.value.argMax(1); // Returns the indices of the max values along an axis
+            allY.push(argMaxY);
+            // 3. dispose of all our tensors
+            batchedXTensor.value.dispose();
+            batchedXPredictionTensor.dispose();
+            batchedYTensor.value.dispose();
+        }
+        // concatenate all the results of the batches
+        const reference = tf.concat(allY); // this is the ground truth
+        const predictions = tf.concat(allX); // this is the prediction our model is guessing
+        // console.log("this is the ground truth: ",  reference.dataSync())
+        // console.log("This is the prediction our model is guessing: ",  predictions.dataSync())
+        // only if we concatenated more than one tensor for preference and reference
+        if (iterations !== 1) {
+            for (let i = 0; i < allX.length; i++) {
+                allX[i].dispose();
+                allY[i].dispose();
+            }
+        }
+        //  console.log("Lengtth: ", await reference.dataSync().length)  
+        // const accuracyperclass=[];
+        // const reference_aux= await reference.dataSync();
+        // const prediction_aux= await predictions.dataSync();
+        // console.log( predictions.dataSync());
+        // reference_aux.forEach((element, index) => {
+        //   if()
+        // });  
+        return { reference, predictions };
+    }
+} //end of class
+/***Support methods (helpers) */
+const isTensor = (c) => typeof c.dataId === 'object' && typeof c.shape === 'object';
+/**
+ * Converts an integer into its one-hot representation and returns
+ * the data as a JS Array.
+ */
+function flatOneHot(label, numClasses) {
+    const labelOneHot = new Array(numClasses).fill(0);
+    labelOneHot[label] = 1;
+    return labelOneHot;
+}
+/**
+ * Shuffle an array of Float32Array or Samples using Fisher-Yates algorithm
+ * Takes an optional seed value to make shuffling predictable
+ */
+function fisherYates(array, seed) {
+    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;
+        if (seed) {
+            randomIndex = Math.floor(seed() * (i + 1));
+        }
+        else {
+            randomIndex = Math.floor(Math.random() * (i + 1));
+        }
+        [shuffled[i], shuffled[randomIndex]] = [shuffled[randomIndex], shuffled[i]];
+    }
+    return shuffled;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"teachable-evolution.js","sourceRoot":"","sources":["../../../../../projects/tfjs-evolution/src/lib/models/teachable-evolution.ts"],"names":[],"mappings":"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","sourcesContent":["import { CustomMobileNet, loadTruncatedMobileNet } from \"./custom-mobilenet\";\r\n\r\nimport * as tf from '@tensorflow/tfjs';\r\n\r\nimport { capture } from '../utils/tf';\r\nimport { Class } from '../utils/class';\r\nimport { Util } from \"../utils/util\";\r\n\r\nimport * as seedrandom from 'seedrandom';\r\n\r\nimport * as tfvis from '@tensorflow/tfjs-vis';\r\n\r\nimport { TensorContainer } from '@tensorflow/tfjs-core/dist/tensor_types';\r\n\r\nconst VALIDATION_FRACTION = 0.15;\r\n\r\n\r\n\r\n/**\r\n * the metadata to describe the model's creation,\r\n * includes the labels associated with the classes\r\n * and versioning information from training.\r\n */\r\nexport interface Metadata {\r\n  tfjsVersion: string;\r\n  tmVersion?: string;\r\n  packageVersion: string;\r\n  packageName: string;\r\n  modelName?: string;\r\n  timeStamp?: string;\r\n  labels: string[];\r\n  userMetadata?: {};\r\n  grayscale?: boolean;\r\n  imageSize?: number;\r\n}\r\n\r\n/**\r\n * Receives a Metadata object and fills in the optional fields such as timeStamp\r\n * @param data a Metadata object\r\n */\r\nconst fillMetadata = (data: Partial<Metadata>) => {\r\n  // util.assert(typeof data.tfjsVersion === 'string', () => `metadata.tfjsVersion is invalid`);\r\n  // data.packageVersion = data.packageVersion || version;\r\n  data.packageName = data.packageName || '@teachablemachine/image';\r\n  data.timeStamp = data.timeStamp || new Date().toISOString();\r\n  data.userMetadata = data.userMetadata || {};\r\n  data.modelName = data.modelName || 'untitled';\r\n  data.labels = data.labels || [];\r\n  // data.imageSize = data.imageSize || IMAGE_SIZE;\r\n  return data as Metadata;\r\n};\r\n\r\nexport class TeachableMobileNet extends CustomMobileNet {\r\n\r\n    // Array of all the examples collected.\r\n    /**\r\n      It is static since all the instance will share the same features, for saving memory and time.\r\n      The idea is avoiding restoring the features individually and having the recalculate them for every new\r\n      individuals.\r\n     */\r\n    public static examples: Float32Array[][] = [];\r\n\r\n    // Number of total samples\r\n    private static totalSamples = 0;\r\n\r\n    classes: Class[]=[];\r\n\r\n    static classes_names: string[]=[];\r\n\r\n    static numClasses: number;\r\n\r\n        /**\r\n     * the training model for transfer learning\r\n     */\r\n    protected trainingModel!: tf.LayersModel;\r\n  trainDataset: any;\r\n  validationDataset: any;\r\n  static trainDataset: any;\r\n  static validationDataset: any;\r\n  static numValidation: number;\r\n\r\n  constructor(){\r\n    super();\r\n    this.createHead();\r\n  }\r\n\r\n  /**\r\n   * This method will return the head, the trainable part, the part under evolution.\r\n   */\r\n  getHead(){\r\n    return this.trainingModel;\r\n  }\r\n\r\n /**\r\n  * Create the head for transfer learning.\r\n  * This is the trainable section of the transfer learning.\r\n  */\r\n createHead(){\r\n\r\n  const inputSize= TeachableMobileNet.getinputShape();\r\n\r\n  this.trainingModel = tf.sequential({\r\n    layers: [\r\n      tf.layers.dense({\r\n        inputShape: [inputSize],\r\n        units:100,\r\n        activation: 'relu',  \r\n        useBias: true\r\n    }),\r\n    tf.layers.dense({  \r\n      useBias: false,\r\n      activation: 'softmax',\r\n      units: TeachableMobileNet.classes_names.length\r\n  })\r\n    ]\r\n  });\r\n\r\n  const optimizer = tf.train.adam();\r\n  // const optimizer = tf.train.rmsprop(params.learningRate);\r\n\r\n  this.trainingModel.compile({\r\n      optimizer,\r\n      // loss: 'binaryCrossentropy',\r\n      loss: 'categoricalCrossentropy',\r\n      metrics: ['accuracy']\r\n  });\r\n }\r\n \r\n async  train(){\r\n\r\n  const trainingSurface = { name: 'Loss and MSE', tab: 'Training' };\r\n\r\n  const dataset= TeachableMobileNet.convertToTfDataset();\r\n\r\n  //Salving a copy of the validation dataset, for later\r\n  TeachableMobileNet.validationDataset= dataset.validationDataset;\r\n\r\n  // console.log(\"Dataset for training: \", dataset.trainDataset);\r\n\r\n  const trainData = dataset.trainDataset.batch(30);\r\n  const validationData = dataset.validationDataset.batch(10);\r\n\r\n  // this.createHead();\r\n\r\n  const callbacks= [\r\n    // Show on a tfjs-vis visor the loss and accuracy values at the end of each epoch.\r\n    tfvis.show.fitCallbacks(trainingSurface, ['loss', 'acc', \"val_loss\", \"val_acc\"],\r\n      {\r\n        callbacks: ['onEpochEnd'],\r\n      }\r\n    ),\r\n    {},]\r\n\r\n  const history: any = await this.trainingModel.fitDataset(trainData, {\r\n    epochs: 100,\r\n    validationData,\r\n    callbacks\r\n}).then((info:any)=>{\r\n   console.log('Precisão final', info.history.val_acc[info.history.acc.length-1]);\r\n});\r\n\r\n\r\n// await this.accuracy_per_class();\r\n\r\n\r\n// console.log(\"History: \", history.history.acc);\r\n  // await this.trainingModel.fit(this.featureX, this.target, {})\r\n }\r\n\r\nasync accuracy_per_class(confusion_matrix_recipient: any){\r\n  /**Calculating Accuracy per class */\r\nconst accuracyperclass: any =  await this.calculateAccuracyPerClass(TeachableMobileNet.validationDataset);\r\n// console.log(\"Accuracy per class: \", accuracyperclass);\r\n\r\n//Confusion matrix\r\n// Calling tf.confusionMatrix() method \r\nconst output = tf.math.confusionMatrix( accuracyperclass.reference, accuracyperclass.predictions, TeachableMobileNet.classes_names.length); \r\n  \r\n// Printing output \r\noutput.print()\r\nconst confusion_matrix=  output.dataSync();\r\n\r\n// console.log(confusion_matrix);\r\n// console.log(confusion_matrix[TeachableMobileNet.classes_names.length + TeachableMobileNet.classes_names.length]);\r\n\r\nconst accuracy = [];\r\n\r\nfor(let i=0; i<TeachableMobileNet.classes_names.length;i++){\r\n\r\n  accuracy.push(confusion_matrix[TeachableMobileNet.classes_names.length*i+ i]/TeachableMobileNet.numValidation)\r\n}\r\n\r\nconsole.log(\"Accuracy per class: \", accuracy);\r\n\r\nfor(let i=0; i<TeachableMobileNet.classes_names.length;i++){\r\n\r\n  confusion_matrix_recipient.push([]);\r\n\r\n  for(let j=0; j<TeachableMobileNet.classes_names.length;j++){\r\n    confusion_matrix_recipient[i].push([]);\r\n\r\n    confusion_matrix_recipient[i][j]= confusion_matrix[TeachableMobileNet.classes_names.length*i+ j]/TeachableMobileNet.numValidation\r\n    confusion_matrix_recipient[i][j]=(confusion_matrix_recipient[i][j].toFixed(2))*100;\r\n  }\r\n\r\n  // accuracy.push(confusion_matrix[TeachableMobileNet.classes_names.length*i+ i]/TeachableMobileNet.numValidation)\r\n}\r\n\r\nconsole.log(\"Confusion matrix as a matrix\")\r\nconsole.log(confusion_matrix_recipient);\r\n\r\nreturn accuracy.map((elem: any)=>elem.toFixed(2)*100);\r\n}\r\n\r\n \r\n async loadImages(number_of_species: number, classes_names: string[], options: object){\r\n        TeachableMobileNet.classes_names=classes_names;\r\n    \r\n        await this.add_species(number_of_species, options);        \r\n\r\n}\r\n\r\nasync add_species(number_of_species: number, options: object){\r\n  \r\n    //Loading feature model, used to create features from images\r\n    //  await this.loadFeatureModel();\r\n\r\n    for (let i = 0; i < TeachableMobileNet.classes_names.length; i++) {\r\n      // this.add_images(this.classes_names[i], number_of_species, options);\r\n    }\r\n}\r\n\r\n/**\r\n * \r\n * @param name - name of the class receiving an example\r\n * @param number_of_species - how many images to add\r\n * @param options - details on the location of the images\r\n */\r\nasync add_images(name: string, number_of_species: number, options: any){   \r\n\r\n    const class_add: any= [];\r\n\r\n    for (let i = 0; i < number_of_species; i++) {      \r\n    //   class_add.push(`${options.base}/${name}/${options.file_name} ${i}.${options.file_extension}`);\r\n        \r\n        //Uploading images\r\n        const cake = new Image();        \r\n        // cake.src = `${options.base}/${name}/${options.file_name} ${i}.${options.file_extension}`;\r\n        cake.height=224;\r\n        cake.width=224;\r\n        cake.src=\"./assets/dataset/Can%C3%A1rio-da-Terra/image%200.jpeg\"\r\n        // console.log(\"Image location: \", cake.src )\r\n\r\n        await new Promise<void>((resolve, reject) => {\r\n            cake.onload = () => {\r\n\r\n                //Finding the correspondent index of the class with name given\r\n                const index= TeachableMobileNet.classes_names.findIndex((elem)=>elem===name)\r\n\r\n                // this.addExample(index, cake);\r\n\r\n              resolve();\r\n            };\r\n  \r\n            cake.onerror = (error) => {\r\n              // Handle error if the image fails to load\r\n              reject(error);\r\n            };\r\n          });\r\n  }\r\n\r\n  // this.classes.push({name: name, images: class_add})  \r\n\r\n  }\r\n\r\n\r\n\r\n      \r\n/**\r\n * This method will transform images into tensors\r\n * @param number_of_classes - number of classes\r\n * @param classes_names - name of each class\r\n */\r\nasync createTensors(number_of_classes: number, classes_names: string[]) {\r\n\r\n    let output: any = [];\r\n\r\n    /** There is a function on TensorFlow.js that also does that */\r\n    const signatures= new Util().identityMatrix(number_of_classes);\r\n\r\n    for (let i = 0; i < number_of_classes; i++) {\r\n\r\n        this.classes[i].signature=signatures[i];\r\n        this.classes[i].name=classes_names[i];\r\n\r\n        for (let j = 0; j < this.classes[i].images.length; j++) {\r\n\r\n\r\n        }\r\n\r\n    }\r\n}\r\n\r\n    /**\r\n     * Add a sample of data under the provided className\r\n     * @param className the classification this example belongs to\r\n     * @param sample the image / tensor that belongs in this classification\r\n     */\r\n    // public async addExample(className: number, sample: HTMLCanvasElement | tf.Tensor) {\r\npublic static async addExample(className: number, name: string, sample: HTMLImageElement | HTMLCanvasElement | tf.Tensor) {\r\n\r\n            // console.log(\"Adding a new example...\") \r\n          \r\n            const cap = isTensor(sample) ? sample : capture(sample);\r\n            \r\n            \r\n            //Getting the features\r\n            const example = this.truncatedModel.predict(cap) as tf.Tensor;\r\n            // console.log(\"Shape after feature extraction: \", example.shape)          \r\n           \r\n\r\n            const activation = example.dataSync() as Float32Array;\r\n            \r\n            //Very important to clean the memory aftermath, it makes the difference\r\n            cap.dispose();\r\n            example.dispose();\r\n    \r\n            // //Accessing the instance variable, not the local ones\r\n            // // save samples of each class separately \r\n            \r\n            if(!TeachableMobileNet.examples[className])\r\n              //and an empty array, make sure there is not empty elements. \r\n              //it will create issue when transforming to tensors\r\n              TeachableMobileNet.examples[className]=[]\r\n\r\n\r\n              if(!TeachableMobileNet.classes_names[className])\r\n                //Saving the lable when it first appears\r\n                TeachableMobileNet.classes_names[className]=name;\r\n\r\n            TeachableMobileNet.examples[className].push(activation);\r\n    \r\n            // // increase our sample counter\r\n            TeachableMobileNet.totalSamples++;\r\n        }\r\n\r\n\r\n   /**\r\n     * process the current examples provided to calculate labels and format\r\n     * into proper tf.data.Dataset\r\n     */\r\n   static prepare() {\r\n    for (const classes in TeachableMobileNet.examples){\r\n        if (classes.length === 0) {\r\n            throw new Error('Add some examples before training');\r\n        }\r\n    }\r\n\r\n    const datasets: any = this.convertToTfDataset();\r\n\r\n    this.trainDataset = datasets.trainDataset;\r\n    this.validationDataset = datasets.validationDataset;\r\n}\r\n\r\npublic prepareDataset() {\r\n  for (let i = 0; i < TeachableMobileNet.numClasses; i++) {\r\n    //Different from the original implementation of TM, mine is using example as static.\r\n    //The goal is saving memory by using a single instance of the variable\r\n    TeachableMobileNet.examples[i] = [];\r\n  }\r\n}\r\n\r\n \r\n    // Optional seed to make shuffling of data predictable\r\n    static seed: seedrandom.prng;\r\n\r\n\r\n\r\n    \r\n/**\r\n     * Process the examples by first shuffling randomly per class, then adding\r\n     * one-hot labels, then splitting into training/validation datsets, and finally\r\n     * sorting one last time\r\n     */\r\n \r\nstatic convertToTfDataset() {\r\n\r\n         // first shuffle each class individually\r\n        // TODO: we could basically replicate this by insterting randomly\r\n        for (let i = 0; i < TeachableMobileNet.examples.length; i++) {\r\n          TeachableMobileNet.examples[i] = fisherYates(TeachableMobileNet.examples[i], this.seed) as Float32Array[];\r\n      }\r\n\r\n      // then break into validation and test datasets\r\n      let trainDataset: Sample[] = [];\r\n      let validationDataset: Sample[] = [];\r\n\r\n      // for each class, add samples to train and validation dataset\r\n      for (let i = 0; i < TeachableMobileNet.examples.length; i++) {\r\n         \r\n        // console.log(\"Number of classes: \", TeachableMobileNet.classes_names.length);\r\n\r\n        const y = flatOneHot(i, TeachableMobileNet.classes_names.length);\r\n\r\n        const classLength = TeachableMobileNet.examples[i].length;\r\n\r\n        // console.log(\"Number of elements per class: \", classLength);\r\n\r\n        const numValidation = Math.ceil(VALIDATION_FRACTION * classLength);\r\n        const numTrain = classLength - numValidation;\r\n\r\n        this.numValidation=numValidation;\r\n       \r\n        /**It is visiting per class, thus, it is possible to fix y, the target label */\r\n     \r\n      const classTrain = this.examples[i].slice(0, numTrain).map((dataArray) => {\r\n          return { data: dataArray, label: y };\r\n      });\r\n\r\n      const classValidation = this.examples[i].slice(numTrain).map((dataArray) => {\r\n          return { data: dataArray, label: y };\r\n      });\r\n\r\n      trainDataset = trainDataset.concat(classTrain);\r\n      validationDataset = validationDataset.concat(classValidation); \r\n\r\n\r\n      }\r\n\r\n      // console.log(\"Training element: \", trainDataset[trainDataset.length-1])      \r\n      // console.log(\"Training length: \", trainDataset.length)\r\n      // console.log(\"validation length: \", validationDataset.length);\r\n\r\n      \r\n        // finally shuffle both train and validation datasets\r\n        trainDataset = fisherYates(trainDataset, this.seed) as Sample[];\r\n        validationDataset = fisherYates(validationDataset, this.seed) as Sample[];\r\n\r\n        const trainX = tf.data.array(trainDataset.map(sample => sample.data));\r\n        const validationX = tf.data.array(validationDataset.map(sample => sample.data));\r\n        const trainY = tf.data.array(trainDataset.map(sample => sample.label));\r\n        const validationY = tf.data.array(validationDataset.map(sample => sample.label));\r\n\r\n                // return tf.data dataset objects\r\n                return {\r\n                  trainDataset: tf.data.zip({ xs: trainX,  ys: trainY}),\r\n                  validationDataset: tf.data.zip({ xs: validationX,  ys: validationY})\r\n              };\r\n\r\n\r\n}\r\n\r\ndatasetForEvaluation(){\r\n\r\n}\r\n\r\n/**Metrics */\r\n\r\nstatic feature_aux: any;\r\nstatic target_aux: any;\r\n\r\nasync evaluate(){\r\n   \r\n  if(!TeachableMobileNet.feature_aux){\r\n    const features: any=[];\r\n  const targets: any=[];\r\n\r\n  for (let i = 0; i < TeachableMobileNet.examples.length; i++) {\r\n\r\n    const y = flatOneHot(i, TeachableMobileNet.classes_names.length);\r\n    \r\n\r\n\r\n    //For class i, push all the examples.\r\n    TeachableMobileNet.examples[i].forEach((elemn)=>{\r\n\r\n       //Pushing the target signature\r\n       targets.push(y);\r\n       \r\n       //Pushing features\r\n       features.push(elemn)\r\n    })\r\n\r\n  }  \r\n\r\n  TeachableMobileNet.feature_aux= tf.tensor(features);\r\n  TeachableMobileNet.target_aux= tf.tensor(targets);\r\n\r\n  } \r\n\r\n  const aux: any = this.trainingModel.evaluate(TeachableMobileNet.feature_aux, TeachableMobileNet.target_aux);\r\n  \r\n  return aux[1].dataSync()[0];\r\n\r\n\r\n}\r\n\r\n\r\n// async evaluate(){\r\n\r\n//   const features: any=[];\r\n//   const targets: any=[];\r\n\r\n//   for (let i = 0; i < TeachableMobileNet.examples.length; i++) {\r\n\r\n//     const y = flatOneHot(i, TeachableMobileNet.classes_names.length);\r\n    \r\n\r\n\r\n//     //For class i, push all the examples.\r\n//     TeachableMobileNet.examples[i].forEach((elemn)=>{\r\n\r\n//        //Pushing the target signature\r\n//        targets.push(y);\r\n       \r\n//        //Pushing features\r\n//        features.push(elemn)\r\n//     })\r\n\r\n//   }  \r\n\r\n//   const aux_features= tf.tensor(features);\r\n//   const aux_target= tf.tensor(targets);\r\n\r\n  \r\n//   // console.log(\"Tensor stack for evaluation: \", aux_features.shape)\r\n\r\n//   const aux: any = this.trainingModel.evaluate(aux_features, aux_target);\r\n\r\n\r\n//   return aux[1].dataSync()[0];\r\n\r\n\r\n// }\r\n\r\n\r\n/*** Final statistics */\r\n/* \r\n     * Calculate each class accuracy using the validation dataset\r\n*/\r\npublic async calculateAccuracyPerClass(validationData: any) {\r\n\r\n  const validationXs = TeachableMobileNet.validationDataset.mapAsync(async (dataset: TensorContainer) => {\r\n    return (dataset as { xs: TensorContainer, ys: TensorContainer}).xs;\r\n});\r\n\r\nconst validationYs = TeachableMobileNet.validationDataset.mapAsync(async (dataset: TensorContainer) => {\r\n    return (dataset as { xs: TensorContainer, ys: TensorContainer}).ys;\r\n});\r\n\r\n// console.log(\"validation dataset: \", validationXs);\r\n \r\n// console.log(\"For calculating batch size: \", validationYs);\r\n\r\n// we need to split our validation data into batches in case it is too large to fit in memory\r\nconst batchSize = Math.min(validationYs.size, 32);\r\n// const batchSize =1;\r\n\r\nconst iterations = Math.ceil(validationYs.size / batchSize);\r\n\r\n// console.log(\"Batch size: \", batchSize);\r\n\r\nconst batchesX = validationXs.batch(batchSize);\r\n\r\nconst batchesY = validationYs.batch(batchSize);\r\nconst itX = await batchesX.iterator();\r\nconst itY = await batchesY.iterator();\r\nconst allX = [];\r\nconst allY = [];\r\n\r\nfor (let i = 0; i < iterations; i++) {\r\n\r\n    // 1. get the prediction values in batches\r\n     const batchedXTensor = await itX.next();  \r\n\r\n    //  console.log(\"Batch size on accuracy per class: \", batchedXTensor.value.shape);\r\n\r\n    const batchedXPredictionTensor = this.trainingModel.predict(batchedXTensor.value) as tf.Tensor;\r\n\r\n    const argMaxX = batchedXPredictionTensor.argMax(1); // Returns the indices of the max values along an axis\r\n\r\n    allX.push(argMaxX);\r\n\r\n    // 2. get the ground truth label values in batches\r\n    const batchedYTensor = await itY.next();\r\n    const argMaxY = batchedYTensor.value.argMax(1); // Returns the indices of the max values along an axis\r\n\r\n    allY.push(argMaxY);\r\n    \r\n    // 3. dispose of all our tensors\r\n     batchedXTensor.value.dispose();\r\n     batchedXPredictionTensor.dispose();\r\n     batchedYTensor.value.dispose();\r\n}\r\n\r\n      // concatenate all the results of the batches\r\n      const reference = tf.concat(allY); // this is the ground truth\r\n      const predictions = tf.concat(allX); // this is the prediction our model is guessing\r\n      \r\n      // console.log(\"this is the ground truth: \",  reference.dataSync())\r\n      // console.log(\"This is the prediction our model is guessing: \",  predictions.dataSync())\r\n\r\n        // only if we concatenated more than one tensor for preference and reference\r\n        if (iterations !== 1) {\r\n            for (let i = 0; i < allX.length; i++) {\r\n                allX[i].dispose();\r\n                allY[i].dispose();\r\n            }\r\n        }\r\n\r\n    //  console.log(\"Lengtth: \", await reference.dataSync().length)  \r\n    \r\n    // const accuracyperclass=[];\r\n\r\n    // const reference_aux= await reference.dataSync();\r\n    // const prediction_aux= await predictions.dataSync();\r\n    // console.log( predictions.dataSync());\r\n\r\n    // reference_aux.forEach((element, index) => {\r\n    //   if()\r\n      \r\n    // });  \r\n\r\n\r\n        return { reference, predictions };  \r\n\r\n}\r\n\r\n}//end of class\r\n\r\n\r\n\r\n\r\n\r\n/***Support methods (helpers) */\r\n\r\nconst isTensor = (c: any): c is tf.Tensor =>\r\n    typeof c.dataId === 'object' && typeof c.shape === 'object';\r\n/**\r\n * Converts an integer into its one-hot representation and returns\r\n * the data as a JS Array.\r\n */\r\nfunction flatOneHot(label: number, numClasses: number) {\r\n\r\n  const labelOneHot = new Array(numClasses).fill(0) as number[];\r\n  labelOneHot[label] = 1;\r\n\r\n  return labelOneHot;\r\n}\r\n\r\ninterface Sample {\r\n  data: Float32Array;\r\n  label: number[];\r\n}\r\n\r\n\r\n/**\r\n * Shuffle an array of Float32Array or Samples using Fisher-Yates algorithm\r\n * Takes an optional seed value to make shuffling predictable\r\n */\r\nfunction fisherYates(array: Float32Array[] | Sample[], seed?: seedrandom.prng) {\r\n  const length = array.length;\r\n\r\n  // need to clone array or we'd be editing original as we goo\r\n  const shuffled = array.slice();\r\n\r\n  for (let i = (length - 1); i > 0; i -= 1) {\r\n      let randomIndex ;\r\n      if (seed) {\r\n          randomIndex = Math.floor(seed() * (i + 1));\r\n      }\r\n      else {\r\n          randomIndex = Math.floor(Math.random() * (i + 1));\r\n      }\r\n\r\n      [shuffled[i], shuffled[randomIndex]] = [shuffled[randomIndex],shuffled[i]];\r\n  }\r\n\r\n  return shuffled;\r\n}\r\n"]}

package/esm2022/lib/utils/class.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90ZmpzLWV2b2x1dGlvbi9zcmMvbGliL3V0aWxzL2NsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENsYXNzIHtcclxuICAgIGltYWdlczogc3RyaW5nW11cclxuICAgIHNpZ25hdHVyZT86IG51bWJlcltdXHJcbiAgICBuYW1lPzogc3RyaW5nICAgIFxyXG59XHJcbiJdfQ==

package/esm2022/lib/utils/tf.mjs

@@ -0,0 +1,29 @@
+import * as tf from '@tensorflow/tfjs';
+/**
+ * Receives an image and normalizes it between -1 and 1.
+ * Returns a batched image (1 - element batch) of shape [1, w, h, c]
+ * @param rasterElement the element with pixels to convert to a Tensor
+ * @param grayscale optinal flag that changes the crop to [1, w, h, 1]
+ */
+export function capture(rasterElement, grayscale) {
+    return tf.tidy(() => {
+        // console.log("Not a tensor....")
+        const pixels = tf.browser.fromPixels(rasterElement);
+        // crop the image so we're using the center square
+        const cropped = cropTensor(pixels);
+        // Expand the outer most dimension so we have a batch size of 1
+        const batchedImage = cropped.expandDims(0);
+        // Normalize the image between -1 and a1. The image comes in between 0-255
+        // so we divide by 127 and subtract 1.
+        return batchedImage.toFloat().div(tf.scalar(127)).sub(tf.scalar(1));
+    });
+}
+export function cropTensor(img) {
+    const size = Math.min(img.shape[0], img.shape[1]);
+    const centerHeight = img.shape[0] / 2;
+    const beginHeight = centerHeight - (size / 2);
+    const centerWidth = img.shape[1] / 2;
+    const beginWidth = centerWidth - (size / 2);
+    return img.slice([beginHeight, beginWidth, 0], [size, size, 3]);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90ZmpzLWV2b2x1dGlvbi9zcmMvbGliL3V0aWxzL3RmLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFdkM7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQWMsT0FBTyxDQUFDLGFBQXNFLEVBQUUsU0FBbUI7SUFDbkgsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRTtRQUNoQixrQ0FBa0M7UUFDbEMsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLENBQUM7UUFFcEQsa0RBQWtEO1FBQ2xELE1BQU0sT0FBTyxHQUFHLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUVuQywrREFBK0Q7UUFDL0QsTUFBTSxZQUFZLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUUzQywwRUFBMEU7UUFDMUUsc0NBQXNDO1FBQ3RDLE9BQU8sWUFBWSxDQUFDLE9BQU8sRUFBRSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN4RSxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUM7QUFJRCxNQUFNLFVBQVUsVUFBVSxDQUFFLEdBQWdCO0lBRXhDLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDbEQsTUFBTSxZQUFZLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDdEMsTUFBTSxXQUFXLEdBQUcsWUFBWSxHQUFHLENBQUMsSUFBSSxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQzlDLE1BQU0sV0FBVyxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3JDLE1BQU0sVUFBVSxHQUFHLFdBQVcsR0FBRyxDQUFDLElBQUksR0FBRyxDQUFDLENBQUMsQ0FBQztJQUc1QyxPQUFPLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxXQUFXLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ3BFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyB0ZiBmcm9tICdAdGVuc29yZmxvdy90ZmpzJztcclxuXHJcbi8qKlxyXG4gKiBSZWNlaXZlcyBhbiBpbWFnZSBhbmQgbm9ybWFsaXplcyBpdCBiZXR3ZWVuIC0xIGFuZCAxLlxyXG4gKiBSZXR1cm5zIGEgYmF0Y2hlZCBpbWFnZSAoMSAtIGVsZW1lbnQgYmF0Y2gpIG9mIHNoYXBlIFsxLCB3LCBoLCBjXVxyXG4gKiBAcGFyYW0gcmFzdGVyRWxlbWVudCB0aGUgZWxlbWVudCB3aXRoIHBpeGVscyB0byBjb252ZXJ0IHRvIGEgVGVuc29yXHJcbiAqIEBwYXJhbSBncmF5c2NhbGUgb3B0aW5hbCBmbGFnIHRoYXQgY2hhbmdlcyB0aGUgY3JvcCB0byBbMSwgdywgaCwgMV1cclxuICovXHJcbmV4cG9ydCBmdW5jdGlvbiAgICAgY2FwdHVyZShyYXN0ZXJFbGVtZW50OiBIVE1MSW1hZ2VFbGVtZW50IHwgSFRNTFZpZGVvRWxlbWVudCB8IEhUTUxDYW52YXNFbGVtZW50LCBncmF5c2NhbGU/OiBib29sZWFuKSB7XHJcbiAgICByZXR1cm4gdGYudGlkeSgoKSA9PiB7XHJcbiAgICAgICAgLy8gY29uc29sZS5sb2coXCJOb3QgYSB0ZW5zb3IuLi4uXCIpXHJcbiAgICAgICAgY29uc3QgcGl4ZWxzID0gdGYuYnJvd3Nlci5mcm9tUGl4ZWxzKHJhc3RlckVsZW1lbnQpO1xyXG5cclxuICAgICAgICAvLyBjcm9wIHRoZSBpbWFnZSBzbyB3ZSdyZSB1c2luZyB0aGUgY2VudGVyIHNxdWFyZVxyXG4gICAgICAgIGNvbnN0IGNyb3BwZWQgPSBjcm9wVGVuc29yKHBpeGVscyk7XHJcblxyXG4gICAgICAgIC8vIEV4cGFuZCB0aGUgb3V0ZXIgbW9zdCBkaW1lbnNpb24gc28gd2UgaGF2ZSBhIGJhdGNoIHNpemUgb2YgMVxyXG4gICAgICAgIGNvbnN0IGJhdGNoZWRJbWFnZSA9IGNyb3BwZWQuZXhwYW5kRGltcygwKTtcclxuXHJcbiAgICAgICAgLy8gTm9ybWFsaXplIHRoZSBpbWFnZSBiZXR3ZWVuIC0xIGFuZCBhMS4gVGhlIGltYWdlIGNvbWVzIGluIGJldHdlZW4gMC0yNTVcclxuICAgICAgICAvLyBzbyB3ZSBkaXZpZGUgYnkgMTI3IGFuZCBzdWJ0cmFjdCAxLlxyXG4gICAgICAgIHJldHVybiBiYXRjaGVkSW1hZ2UudG9GbG9hdCgpLmRpdih0Zi5zY2FsYXIoMTI3KSkuc3ViKHRmLnNjYWxhcigxKSk7XHJcbiAgICB9KTtcclxufVxyXG5cclxuXHJcblxyXG5leHBvcnQgZnVuY3Rpb24gY3JvcFRlbnNvciggaW1nOiB0Zi5UZW5zb3IzRCApIDogdGYuVGVuc29yM0Qge1xyXG4gICAgXHJcbiAgICBjb25zdCBzaXplID0gTWF0aC5taW4oaW1nLnNoYXBlWzBdLCBpbWcuc2hhcGVbMV0pO1xyXG4gICAgY29uc3QgY2VudGVySGVpZ2h0ID0gaW1nLnNoYXBlWzBdIC8gMjtcclxuICAgIGNvbnN0IGJlZ2luSGVpZ2h0ID0gY2VudGVySGVpZ2h0IC0gKHNpemUgLyAyKTtcclxuICAgIGNvbnN0IGNlbnRlcldpZHRoID0gaW1nLnNoYXBlWzFdIC8gMjtcclxuICAgIGNvbnN0IGJlZ2luV2lkdGggPSBjZW50ZXJXaWR0aCAtIChzaXplIC8gMik7XHJcbiAgICBcclxuXHJcbiAgICByZXR1cm4gaW1nLnNsaWNlKFtiZWdpbkhlaWdodCwgYmVnaW5XaWR0aCwgMF0sIFtzaXplLCBzaXplLCAzXSk7XHJcbn0iXX0=