tfjs-evolution 0.0.3 → 0.0.5

package/README.md

@@ -4,6 +4,78 @@ This is a placeholder for a package I am planning to publish.
 I have experimented with Evolutionary Computing in TensorFlow.js, and I am planning a paper and a NPN package.
 I was unable to find a NPM package, and decided to create one!
 
+I am releasing the parts by parts. 
+You can start to test the released parts, and let me know your thoughts.
+
+# Seeing your images
+
+You can see your images, it can useful to have an idea about how it looks like, what you are trying to feed the model.
+Remember: "garbage in garbage out".
+
+Import the directive for the panel.
+
+`import { DisplayPanelComponent } from 'tfjs-evolution';`
+
+
+Make sure to import the component. Angular is now standalone by default.
+
+`  imports: [DisplayPanelComponent]`
+
+Create a local instance, for calling the component method.
+
+` @ViewChild(DisplayPanelComponent) child!:DisplayPanelComponent;`
+
+Add a list of class names. It must be the same on the folder names.
+
+```` typescript
+  classes_names=[
+    "Canário-da-Terra",
+    "Pardal",
+    "Bem-Te-Vi",
+    "Suiriri-Cavaleiro",
+    "Lavadeira-Mascarada",
+    "Anu-Branco",  
+    "Beija-Flor-Tesoura", 
+    "Casaca-de-Couro-da-Lama",
+    "Garibaldi",
+    "Periquitão",
+    "Pombo-Doméstico",
+    "Quero-Quero",
+    "Rolinha-Roxa",
+    "Sabiá-Do-Campo",
+    "Urubu-de-Cabeça-Preta"
+  ]
+````
+Make the call for loading images. You could most likely make the call at the constructor.
+
+
+```typescript
+ngAfterViewInit(): void {
+    const options={ 
+      base: "./assets/dataset",//base where are your iamges
+      file_name:"image",//how your images are named
+      file_extension:"jpeg" //extension used
+    };
+
+    //Finally, call the load images methods
+    this.child.loadImages(5, options)
+  }
+```
+
+Finally, do not forget to add the HTML code
+
+```html
+<h1>Images used on the training</h1>
+<neuroevolution-display-panel></neuroevolution-display-panel>
+
+```
+
+You should see in our HTML file, in Angular, the images
+
+
+# Updates
+
+I have finished! Hope to publish a paper soon!
 
 # Further help
 

package/esm2022/lib/components/display-panel/display-panel.component.mjs

@@ -1,29 +1,15 @@
 import { Component } from '@angular/core';
 import { CommonModule } from '@angular/common';
+import { TeachableMobileNet } from '../../models/teachable-evolution';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 export class DisplayPanelComponent {
     constructor() {
         this.classes = [];
-        this.classes_names = [
-            "Canário-da-Terra",
-            "Pardal",
-            "Bem-Te-Vi",
-            "Suiriri-Cavaleiro",
-            "Lavadeira-Mascarada",
-            "Anu-Branco",
-            "Beija-Flor-Tesoura",
-            "Casaca-de-Couro-da-Lama",
-            "Garibaldi",
-            "Periquitão",
-            "Pombo-Doméstico",
-            "Quero-Quero",
-            "Rolinha-Roxa",
-            "Sabiá-Do-Campo",
-            "Urubu-de-Cabeça-Preta"
-        ];
     }
-    loadImages(number_of_species, options) {
+    loadImages(number_of_species, classes_names, options) {
+        this.classes_names = classes_names;
+        this.number_of_samples_per_class = number_of_species;
         this.add_species(number_of_species, options);
     }
     add_species(number_of_species, options) {
@@ -33,16 +19,41 @@ export class DisplayPanelComponent {
     }
     add_images(name, number_of_species, options) {
         const class_add = [];
-        for (let i = 1; i < number_of_species; i++) {
-            class_add.push(`${options.base}/${name}/${options.file_name} ${i}.${options.file_extension}`);
+        for (let i = 0; i < number_of_species; i++) {
+            class_add.push(`${options.base}/${name}/${options.file_name} ${i + 1}.${options.file_extension}`);
         }
         this.classes.push({ name: name, images: class_add });
     }
+    async addexamples() {
+        //This is needed to make sure it gives time for the images to upload
+        //The images upload very fast, what makes this method execute before the images are on HTML
+        //It can be removed if somehow this method is just called after the images are available.
+        // console.log("Loading examples as tensors....")
+        await this.delay(0);
+        for (let i = 0; i < this.classes_names.length; i++) {
+            await this.add_example(this.classes_names[i], this.number_of_samples_per_class);
+        }
+    }
+    async add_example(name, number_of_species) {
+        const class_add = [];
+        // console.log(name)
+        for (let i = 0; i < number_of_species; i++) {
+            //Collecting the images from HTML
+            const aux = document.getElementById(`class-${name}-${i}`);
+            //Adding the example
+            const index = this.classes_names.findIndex((elem) => elem === name);
+            await TeachableMobileNet.addExample(index, name, aux);
+        }
+        // this.classes.push({name: name, images: class_add})  
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: DisplayPanelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.4", type: DisplayPanelComponent, isStandalone: true, selector: "neuroevolution-display-panel", ngImport: i0, template: "<div *ngFor=\"let class of classes; index as i\">\r\n  <h1>{{class.name}}</h1>\r\n  <img  *ngFor=\"let item of class.images; index as i\" [src]=\"item\" width=\"10%\" height=\"10%\" [id]=\"'class-1-' + i\" crossorigin=\"anonymous\" >\r\n</div>\r\n", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.4", type: DisplayPanelComponent, isStandalone: true, selector: "neuroevolution-display-panel", ngImport: i0, template: "<div *ngFor=\"let class of classes; index as i\">\r\n  <h1>{{class.name}}</h1>\r\n  <img  *ngFor=\"let item of class.images; index as i\" [src]=\"item\" width=\"224\" height=\"224\" [id]=\"'class-' + class.name + '-' + i\" crossorigin=\"anonymous\" >\r\n</div>\r\n", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: DisplayPanelComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'neuroevolution-display-panel', standalone: true, imports: [CommonModule], template: "<div *ngFor=\"let class of classes; index as i\">\r\n  <h1>{{class.name}}</h1>\r\n  <img  *ngFor=\"let item of class.images; index as i\" [src]=\"item\" width=\"10%\" height=\"10%\" [id]=\"'class-1-' + i\" crossorigin=\"anonymous\" >\r\n</div>\r\n" }]
+            args: [{ selector: 'neuroevolution-display-panel', standalone: true, imports: [CommonModule], template: "<div *ngFor=\"let class of classes; index as i\">\r\n  <h1>{{class.name}}</h1>\r\n  <img  *ngFor=\"let item of class.images; index as i\" [src]=\"item\" width=\"224\" height=\"224\" [id]=\"'class-' + class.name + '-' + i\" crossorigin=\"anonymous\" >\r\n</div>\r\n" }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/custom-mobilenet.mjs

@@ -0,0 +1,182 @@
+import * as tf from '@tensorflow/tfjs';
+export const IMAGE_SIZE = 224;
+const DEFAULT_MOBILENET_VERSION = 2;
+const DEFAULT_TRAINING_LAYER_V1 = 'conv_pw_13_relu';
+const DEFAULT_TRAINING_LAYER_V2 = "out_relu";
+const DEFAULT_ALPHA_V1_v2 = 0.35;
+const DEFAULT_ALPHA_V1 = 0.25; //256
+const DEFAULT_ALPHA_V2 = 0.5; //512
+const DEFAULT_ALPHA_V3 = 0.75; //768 features
+const DEFAULT_ALPHA_V4 = 1; //1024 features
+const DEFAULT_ALPHA = 1; //1024 features
+// v2: 0.35, 0.50, 0.75 or 1.00.
+const isAlphaValid = (version, alpha) => {
+    if (version === 1) {
+        if (alpha !== 0.25 && alpha !== 0.5 && alpha !== 0.75 && alpha !== 1) {
+            console.warn("Invalid alpha. Options are: 0.25, 0.50, 0.75 or 1.00.");
+            console.log("Loading model with alpha: ", DEFAULT_ALPHA_V1.toFixed(2));
+            return DEFAULT_ALPHA_V1;
+        }
+    }
+    else {
+        if (alpha !== 0.35 && alpha !== 0.5 && alpha !== 0.75 && alpha !== 1) {
+            console.warn("Invalid alpha. Options are: 0.35, 0.50, 0.75 or 1.00.");
+            console.log("Loading model with alpha: ", DEFAULT_ALPHA_V2.toFixed(2));
+            return DEFAULT_ALPHA_V2;
+        }
+    }
+    return alpha;
+};
+const parseModelOptions = (options) => {
+    options = options || {};
+    if (options.checkpointUrl && options.trainingLayer) {
+        if (options.alpha || options.version) {
+            console.warn("Checkpoint URL passed to modelOptions, alpha options are ignored");
+        }
+        return [options.checkpointUrl, options.trainingLayer];
+    }
+    else {
+        options.version = options.version || DEFAULT_MOBILENET_VERSION;
+        if (options.version === 1) {
+            options.alpha = options.alpha || DEFAULT_ALPHA_V4;
+            options.alpha = isAlphaValid(options.version, options.alpha);
+            console.log(`Loading mobilenet ${options.version} and alpha ${options.alpha}`);
+            // exception is alpha o f 1 can only be 1.0
+            let alphaString = options.alpha.toFixed(2);
+            if (alphaString === "1.00") {
+                alphaString = "1.0";
+            }
+            console.log("Using the model: ");
+            return [
+                // tslint:disable-next-line:max-line-length
+                //They are loading MobileNet_v1        
+                `https://storage.googleapis.com/tfjs-models/tfjs/mobilenet_v1_${alphaString}_${IMAGE_SIZE}/model.json`,
+                DEFAULT_TRAINING_LAYER_V1
+            ];
+        }
+        else if (options.version === 2) {
+            options.alpha = options.alpha || DEFAULT_ALPHA_V4;
+            options.alpha = isAlphaValid(options.version, options.alpha);
+            console.log(`Loading mobilenet ${options.version} and alpha ${options.alpha}`);
+            console.log(`Loading mobilenet ${options.version} and alpha ${options.alpha}`);
+            return [
+                // tslint:disable-next-line:max-line-length        
+                `https://storage.googleapis.com/teachable-machine-models/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_${options.alpha.toFixed(2)}_${IMAGE_SIZE}_no_top/model.json`,
+                DEFAULT_TRAINING_LAYER_V2
+            ];
+        }
+        else {
+            throw new Error(`MobileNet V${options.version} doesn't exist`);
+        }
+    }
+};
+/**
+ * load the base mobilenet model
+ * @param modelOptions options determining what model to load
+ */
+export async function loadTruncatedMobileNet(modelOptions) {
+    const [checkpointUrl, trainingLayer] = parseModelOptions(modelOptions);
+    const mobilenet = await tf.loadLayersModel(checkpointUrl);
+    if (modelOptions && modelOptions.version === 1) {
+        const layer = mobilenet.getLayer(trainingLayer);
+        const truncatedModel = tf.model({ inputs: mobilenet.inputs, outputs: layer.output });
+        console.log("Feature model loaded, memory: ", tf.memory().numBytes);
+        const model = tf.sequential();
+        model.add(truncatedModel);
+        model.add(tf.layers.flatten());
+        return model;
+    }
+    else {
+        const layer = mobilenet.getLayer(trainingLayer);
+        const truncatedModel = tf.model({ inputs: mobilenet.inputs, outputs: layer.output });
+        console.log("Feature model loaded, memory: ", tf.memory().numBytes);
+        const model = tf.sequential();
+        model.add(truncatedModel);
+        model.add(tf.layers.globalAveragePooling2d({})); // go from shape [7, 7, 1280] to [1280]
+        return model;
+    }
+}
+export class CustomMobileNet {
+    static getinputShape() {
+        /**truncatedModel is the base model, the model used to apply transfer learning */
+        const inputShape = this.truncatedModel.outputs[0].shape.slice(1); // [ 7 x 7 x 1280] (not sure about those dimensions)
+        //   console.log("Input Shape(complete): ", this.truncatedModel.outputs[0].shape);
+        //   console.log("Input Shape: ", inputShape);
+        const inputSize = tf.util.sizeFromShape(inputShape);
+        //   console.log("Input Size: ", inputSize);
+        return inputSize;
+    }
+    static get EXPECTED_IMAGE_SIZE() {
+        return IMAGE_SIZE;
+    }
+    getMetadata() {
+        return this._metadata;
+    }
+    constructor() {
+        // this._metadata = fillMetadata(metadata);
+        //Loading the truncated model
+        // loadTruncatedMobileNet();
+        // this.loadFeatureModel();
+    }
+    static async loadFeatureModel() {
+        this.truncatedModel = await loadTruncatedMobileNet();
+    }
+    /**
+     * get the total number of classes existing within model
+     */
+    // getTotalClasses() {
+    //     const output = this.model.output as SymbolicTensor;
+    //     const totalClasses = output.shape[1];
+    //     return totalClasses;
+    // }
+    /**
+     * get the model labels
+     */
+    getClassLabels() {
+        return this._metadata.labels;
+    }
+    /**
+     * Given an image element, makes a prediction through mobilenet returning the
+     * probabilities of the top K classes.
+     * @param image the image to classify
+     * @param maxPredictions the maximum number of classification predictions
+     */
+    // async predictTopK(image: ClassifierInputSource, maxPredictions = 10, flipped = false) {
+    //     const croppedImage = cropTo(image, this._metadata.imageSize, flipped);
+    //     const logits = tf.tidy(() => {
+    //         const captured = capture(croppedImage, this._metadata.grayscale);
+    //         return this.model.predict(captured);
+    //     });
+    //     // Convert logits to probabilities and class names.
+    //     const classes = await getTopKClasses(this._metadata.labels, logits as tf.Tensor<tf.Rank>, maxPredictions);
+    //     dispose(logits);
+    //     return classes;
+    // }
+    /**
+     * Given an image element, makes a prediction through mobilenet returning the
+     * probabilities for ALL classes.
+     * @param image the image to classify
+     * @param flipped whether to flip the image on X
+     */
+    // async predict(image: ClassifierInputSource, flipped = false) {
+    //     const croppedImage = cropTo(image, this._metadata.imageSize, flipped);
+    //     const logits = tf.tidy(() => {
+    //         const captured = capture(croppedImage, this._metadata.grayscale);
+    //         return this.model.predict(captured);
+    //     });
+    //     const values = await (logits as tf.Tensor<tf.Rank>).data();
+    //     const classes = [];
+    //     for (let i = 0; i < values.length; i++) {
+    //         classes.push({
+    //             className: this._metadata.labels[i],
+    //             probability: values[i]
+    //         });
+    //     }
+    //     dispose(logits);
+    //     return classes;
+    // }
+    dispose() {
+        this.truncatedModel.dispose();
+    }
+} // end of CustomMobileNet
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-mobilenet.js","sourceRoot":"","sources":["../../../../../projects/tfjs-evolution/src/lib/models/custom-mobilenet.ts"],"names":[],"mappings":"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","sourcesContent":["\r\nimport * as tf from '@tensorflow/tfjs';\r\n\r\nimport { SymbolicTensor } from '@tensorflow/tfjs';\r\n\r\n\r\nexport const IMAGE_SIZE = 224;\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\nexport interface ModelOptions {\r\n    version?: number;\r\n    checkpointUrl?: string;\r\n    alpha?: number;\r\n    trainingLayer?: string;\r\n}\r\n\r\nconst DEFAULT_MOBILENET_VERSION = 2;\r\nconst DEFAULT_TRAINING_LAYER_V1 = 'conv_pw_13_relu';\r\nconst DEFAULT_TRAINING_LAYER_V2 = \"out_relu\"; \r\nconst DEFAULT_ALPHA_V1_v2 = 0.35;\r\nconst DEFAULT_ALPHA_V1 = 0.25;//256\r\nconst DEFAULT_ALPHA_V2 = 0.5; //512\r\nconst DEFAULT_ALPHA_V3 = 0.75;//768 features\r\nconst DEFAULT_ALPHA_V4 = 1;//1024 features\r\nconst DEFAULT_ALPHA = 1;//1024 features\r\n\r\n// v2: 0.35, 0.50, 0.75 or 1.00.\r\n\r\nconst isAlphaValid = (version: number, alpha: number) => {\r\n    if (version === 1) {\r\n        if (alpha !== 0.25 && alpha !== 0.5 && alpha !== 0.75 && alpha !== 1) {\r\n            console.warn(\"Invalid alpha. Options are: 0.25, 0.50, 0.75 or 1.00.\");\r\n            console.log(\"Loading model with alpha: \", DEFAULT_ALPHA_V1.toFixed(2)); \r\n            return DEFAULT_ALPHA_V1;\r\n        }\r\n    }\r\n    else {\r\n        if (alpha !== 0.35 && alpha !== 0.5 && alpha !== 0.75 && alpha !== 1) {\r\n            console.warn(\"Invalid alpha. Options are: 0.35, 0.50, 0.75 or 1.00.\");\r\n            console.log(\"Loading model with alpha: \", DEFAULT_ALPHA_V2.toFixed(2)); \r\n            return DEFAULT_ALPHA_V2;\r\n        }\r\n    }\r\n\r\n    return alpha;\r\n};\r\n\r\n\r\nconst parseModelOptions = (options?: ModelOptions) => {\r\n    options = options || {}\r\n\r\n    if (options.checkpointUrl && options.trainingLayer) {\r\n        if (options.alpha || options.version){\r\n            console.warn(\"Checkpoint URL passed to modelOptions, alpha options are ignored\");\r\n        }        \r\n        return [options.checkpointUrl, options.trainingLayer];\r\n    } else {\r\n        options.version = options.version || DEFAULT_MOBILENET_VERSION;\r\n        \r\n        if(options.version === 1){\r\n            options.alpha = options.alpha || DEFAULT_ALPHA_V4;  \r\n            options.alpha = isAlphaValid(options.version, options.alpha);\r\n\r\n            console.log(`Loading mobilenet ${options.version} and alpha ${options.alpha}`);\r\n            // exception is alpha o f 1 can only be 1.0\r\n            let alphaString = options.alpha.toFixed(2);\r\n            if (alphaString === \"1.00\") { alphaString = \"1.0\"; }\r\n\r\n            console.log(\"Using the model: \",  )\r\n\r\n            return [\r\n                // tslint:disable-next-line:max-line-length\r\n                //They are loading MobileNet_v1        \r\n                `https://storage.googleapis.com/tfjs-models/tfjs/mobilenet_v1_${alphaString}_${IMAGE_SIZE}/model.json`,\r\n                DEFAULT_TRAINING_LAYER_V1\r\n            ];\r\n        }\r\n        else if (options.version === 2){\r\n            options.alpha = options.alpha || DEFAULT_ALPHA_V4;  \r\n            options.alpha = isAlphaValid(options.version, options.alpha);\r\n\r\n            console.log(`Loading mobilenet ${options.version} and alpha ${options.alpha}`);\r\n            console.log(`Loading mobilenet ${options.version} and alpha ${options.alpha}`);\r\n\r\n            return [\r\n                // tslint:disable-next-line:max-line-length        \r\n                `https://storage.googleapis.com/teachable-machine-models/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_${options.alpha.toFixed(2)}_${IMAGE_SIZE}_no_top/model.json`,\r\n                DEFAULT_TRAINING_LAYER_V2\r\n            ];\r\n        } else {\r\n            throw new Error(`MobileNet V${options.version} doesn't exist`);\r\n        }   \r\n    }\r\n};\r\n\r\n\r\n/**\r\n * load the base mobilenet model\r\n * @param modelOptions options determining what model to load\r\n */\r\nexport async function loadTruncatedMobileNet(modelOptions?: ModelOptions) {\r\n    const [checkpointUrl, trainingLayer] = parseModelOptions(modelOptions);\r\n    \r\n    \r\n    const mobilenet = await tf.loadLayersModel(checkpointUrl);\r\n\r\n    if (modelOptions && modelOptions.version === 1){\r\n        const layer = mobilenet.getLayer(trainingLayer);\r\n        \r\n        const truncatedModel = tf.model({ inputs: mobilenet.inputs, outputs: layer.output });\r\n        console.log(\"Feature model loaded, memory: \", tf.memory().numBytes);\r\n\r\n        \r\n        const model = tf.sequential();\r\n        model.add(truncatedModel);\r\n        model.add(tf.layers.flatten());        \r\n        \r\n        \r\n        return model;\r\n    }\r\n    else {\r\n        const layer = mobilenet.getLayer(trainingLayer);\r\n        const truncatedModel = tf.model({ inputs: mobilenet.inputs, outputs: layer.output });\r\n        console.log(\"Feature model loaded, memory: \", tf.memory().numBytes);\r\n        const model = tf.sequential();\r\n        model.add(truncatedModel);\r\n        model.add(tf.layers.globalAveragePooling2d({})); // go from shape [7, 7, 1280] to [1280]\r\n        return model;\r\n    }\r\n}\r\n\r\n\r\nexport class CustomMobileNet {\r\n    /**\r\n     * the truncated mobilenet model we will train on top of\r\n     */\r\n    protected truncatedModel!: tf.LayersModel;\r\n    static truncatedModel: tf.Sequential;\r\n\r\nstatic getinputShape(){\r\n   /**truncatedModel is the base model, the model used to apply transfer learning */\r\n  const inputShape: any = this.truncatedModel.outputs[0].shape.slice(1); // [ 7 x 7 x 1280] (not sure about those dimensions)\r\n//   console.log(\"Input Shape(complete): \", this.truncatedModel.outputs[0].shape);\r\n//   console.log(\"Input Shape: \", inputShape);\r\n\r\n  const inputSize = tf.util.sizeFromShape(inputShape);\r\n\r\n//   console.log(\"Input Size: \", inputSize);\r\n\r\n  return inputSize;\r\n}\r\n\r\n    static get EXPECTED_IMAGE_SIZE() {\r\n        return IMAGE_SIZE;\r\n    }\r\n\r\n    protected _metadata!: Metadata;\r\n\r\n    public getMetadata() {\r\n        return this._metadata;\r\n    }\r\n\r\n    constructor() {\r\n        // this._metadata = fillMetadata(metadata);\r\n        //Loading the truncated model\r\n        // loadTruncatedMobileNet();\r\n        // this.loadFeatureModel();\r\n\r\n    }\r\n\r\n   static  async loadFeatureModel(){\r\n\r\n        this.truncatedModel = await loadTruncatedMobileNet();\r\n\r\n    }\r\n\r\n    /**\r\n     * get the total number of classes existing within model\r\n     */\r\n    // getTotalClasses() {\r\n    //     const output = this.model.output as SymbolicTensor;\r\n    //     const totalClasses = output.shape[1];\r\n    //     return totalClasses;\r\n    // }\r\n\r\n    /**\r\n     * get the model labels\r\n     */\r\n    getClassLabels() {\r\n        return this._metadata.labels;\r\n    }\r\n\r\n    /**\r\n     * Given an image element, makes a prediction through mobilenet returning the\r\n     * probabilities of the top K classes.\r\n     * @param image the image to classify\r\n     * @param maxPredictions the maximum number of classification predictions\r\n     */\r\n    // async predictTopK(image: ClassifierInputSource, maxPredictions = 10, flipped = false) {\r\n    //     const croppedImage = cropTo(image, this._metadata.imageSize, flipped);\r\n\r\n    //     const logits = tf.tidy(() => {\r\n    //         const captured = capture(croppedImage, this._metadata.grayscale);\r\n    //         return this.model.predict(captured);\r\n    //     });\r\n\r\n    //     // Convert logits to probabilities and class names.\r\n    //     const classes = await getTopKClasses(this._metadata.labels, logits as tf.Tensor<tf.Rank>, maxPredictions);\r\n    //     dispose(logits);\r\n\r\n    //     return classes;\r\n    // }\r\n\r\n    /**\r\n     * Given an image element, makes a prediction through mobilenet returning the\r\n     * probabilities for ALL classes.\r\n     * @param image the image to classify\r\n     * @param flipped whether to flip the image on X\r\n     */\r\n    // async predict(image: ClassifierInputSource, flipped = false) {\r\n    //     const croppedImage = cropTo(image, this._metadata.imageSize, flipped);\r\n\r\n    //     const logits = tf.tidy(() => {\r\n    //         const captured = capture(croppedImage, this._metadata.grayscale);\r\n    //         return this.model.predict(captured);\r\n    //     });\r\n\r\n    //     const values = await (logits as tf.Tensor<tf.Rank>).data();\r\n\r\n    //     const classes = [];\r\n    //     for (let i = 0; i < values.length; i++) {\r\n    //         classes.push({\r\n    //             className: this._metadata.labels[i],\r\n    //             probability: values[i]\r\n    //         });\r\n    //     }\r\n\r\n    //     dispose(logits);\r\n\r\n    //     return classes;\r\n    // }\r\n\r\n    public dispose() {\r\n        this.truncatedModel.dispose();\r\n    }\r\n}// end of CustomMobileNet\r\n"]}