tfjs-evolution 0.0.3 → 0.0.5

package/esm2022/lib/utils/util.mjs

@@ -0,0 +1,165 @@
+import * as tf from '@tensorflow/tfjs';
+export class Util {
+    /**
+     * 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]
+     */
+    capture(rasterElement, grayscale) {
+        return tf.tidy(() => {
+            const pixels = tf.browser.fromPixels(rasterElement);
+            // // crop the image so we're using the center square
+            const cropped = this.cropTensor(pixels, grayscale);
+            // // 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));
+        });
+    }
+    cropTensor(img, grayscaleModel, grayscaleInput) {
+        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);
+        if (grayscaleModel && !grayscaleInput) {
+            //cropped rgb data
+            let grayscale_cropped = img.slice([beginHeight, beginWidth, 0], [size, size, 3]);
+            grayscale_cropped = grayscale_cropped.reshape([size * size, 1, 3]);
+            const rgb_weights = [0.2989, 0.5870, 0.1140];
+            grayscale_cropped = tf.mul(grayscale_cropped, rgb_weights);
+            grayscale_cropped = grayscale_cropped.reshape([size, size, 3]);
+            grayscale_cropped = tf.sum(grayscale_cropped, -1);
+            grayscale_cropped = tf.expandDims(grayscale_cropped, -1);
+            return grayscale_cropped;
+        }
+        return img.slice([beginHeight, beginWidth, 0], [size, size, 3]);
+    }
+    /**
+     * This function will make a copy of a model on the weight level
+     * This is an attempt to avoid influencing the new mode when the old one
+     * is eliminated.
+     *
+     * @param originalModel - the model to be copied
+     * @param recipient - the new model
+     */
+    async copyModel_v3(originalModel, recipient) {
+        originalModel.layers.forEach((layer, index) => {
+            recipient.layers[index].setWeights(layer.getWeights());
+        });
+        // originalModel.dispose();
+    }
+    /**
+     * This function will make a copy of a TFJS model, as so it would be possible
+     * to erase the original.
+     * @param model - model to be copied
+     * @returns - copy of the model
+     */
+    async copyModel_v2(originalModel) {
+        // Serialize the original model
+        const modelTopology = originalModel.toJSON();
+        // Load the serialized model into a new model
+        const copiedModel = await tf.loadLayersModel(tf.io.fromMemory(modelTopology, undefined, undefined));
+        // Compile the copied model with the same settings as the original
+        copiedModel.compile({
+            loss: originalModel.loss,
+            optimizer: originalModel.optimizer
+        });
+        return copiedModel;
+    }
+    /**
+     * This function will make a copy of a TFJS model, as so it would be possible
+     * to erase the original.
+     * @param model - model to be copied
+     * @returns - copy of the model
+     */
+    copyModel(model) {
+        const copy = tf.sequential();
+        `
+        `;
+        model.layers.forEach(layer => {
+            const aux = layer;
+            // layer.dispose();
+            copy.add(aux);
+        });
+        copy.compile({
+            loss: model.loss,
+            optimizer: model.optimizer
+        });
+        return copy;
+    }
+    removeElementByIndex(arr, index) {
+        // Check if the index is within bounds
+        if (index >= 0 && index < arr.length) {
+            // Remove the element at the specified index
+            arr.splice(index, 1);
+        }
+        return arr;
+    }
+    removeElement(arr, element) {
+        // Remove all occurrences of the specified element from the array
+        return arr.filter((item) => item !== element);
+    }
+    clean_array_of_tensors(tensors) {
+        tensors.forEach((elem, index) => {
+            // if(!index_selection.includes(index))  
+            elem.dispose();
+        });
+    }
+    getClassNameBySignature(classes, signature) {
+        const class_name = classes.find(p => {
+            let match = true;
+            p.signature?.forEach((elem, index) => {
+                if (elem !== signature[index])
+                    match = false;
+            });
+            return match;
+        });
+        return class_name ? class_name.name : "not found";
+    }
+    identityMatrix(n) {
+        return Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => (i === j ? 1 : 0)));
+    }
+    indexOfMax(arr) {
+        if (arr.length === 0) {
+            return -1; // Return -1 for an empty array
+        }
+        let max = arr[0];
+        let maxIndex = 0;
+        for (let i = 1; i < arr.length; i++) {
+            if (arr[i] > max) {
+                maxIndex = i;
+                max = arr[i];
+            }
+        }
+        return maxIndex;
+    }
+    suffle(array1, array2) {
+        // Shuffle the order of elements
+        for (let i = array1.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            // Swap elements in both arrays
+            [array1[i], array1[j]] = [array1[j], array1[i]];
+            [array2[i], array2[j]] = [array2[j], array2[i]];
+        }
+    }
+    sortByValuePreservingIndex(arr1, arr2) {
+        // console.log("Vector for organizing: ", arr1)
+        // arr2[0].summary()
+        // Create an array of objects with value, index from arr1, and original index
+        const pairingArray = arr1.map((value, index) => ({
+            value,
+            index,
+            originalIndex: index,
+            elementFromArr2: arr2[index], // Preserve the corresponding element from arr2
+        }));
+        // Sort the pairing array by value (largest to smallest)
+        pairingArray.sort((a, b) => b.value - a.value);
+        // Extract the sorted elements from arr2 based on the original index
+        const sortedElementsFromArr2 = pairingArray.map(pair => pair.elementFromArr2);
+        return sortedElementsFromArr2;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../projects/tfjs-evolution/src/lib/utils/util.ts"],"names":[],"mappings":"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","sourcesContent":["\r\nimport {Class} from \"./class\"\r\nimport * as tf from '@tensorflow/tfjs';\r\n\r\n\r\nexport class Util {\r\n\r\n/**\r\n * Receives an image and normalizes it between -1 and 1.\r\n * Returns a batched image (1 - element batch) of shape [1, w, h, c]\r\n * @param rasterElement the element with pixels to convert to a Tensor\r\n * @param grayscale optinal flag that changes the crop to [1, w, h, 1]\r\n */\r\ncapture(rasterElement: HTMLImageElement | HTMLVideoElement | HTMLCanvasElement, grayscale?: boolean) {\r\n    return tf.tidy(() => {\r\n        const pixels = tf.browser.fromPixels(rasterElement);\r\n\r\n        // // crop the image so we're using the center square\r\n        const cropped = this.cropTensor(pixels, grayscale);\r\n\r\n        // // Expand the outer most dimension so we have a batch size of 1\r\n        const batchedImage = cropped.expandDims(0);\r\n\r\n        // // Normalize the image between -1 and a1. The image comes in between 0-255\r\n        // // so we divide by 127 and subtract 1.\r\n        return batchedImage.toFloat().div(tf.scalar(127)).sub(tf.scalar(1));    \r\n    });\r\n}    \r\n\r\n\r\ncropTensor( img: tf.Tensor3D, grayscaleModel?: boolean, grayscaleInput?: boolean ) : tf.Tensor3D {\r\n    const size = Math.min(img.shape[0], img.shape[1]);\r\n    const centerHeight = img.shape[0] / 2;\r\n    const beginHeight = centerHeight - (size / 2);\r\n    const centerWidth = img.shape[1] / 2;\r\n    const beginWidth = centerWidth - (size / 2);\r\n    \r\n    if (grayscaleModel && !grayscaleInput) {\r\n        //cropped rgb data\r\n        let grayscale_cropped = img.slice([beginHeight, beginWidth, 0], [size, size, 3]);\r\n        \r\n        grayscale_cropped = grayscale_cropped.reshape([size * size, 1, 3])\r\n        const rgb_weights = [0.2989, 0.5870, 0.1140]\r\n        grayscale_cropped = tf.mul(grayscale_cropped, rgb_weights)\r\n        grayscale_cropped = grayscale_cropped.reshape([size, size, 3]);\r\n    \r\n        grayscale_cropped = tf.sum(grayscale_cropped, -1)\r\n        grayscale_cropped = tf.expandDims(grayscale_cropped, -1)\r\n\r\n        return grayscale_cropped;\r\n    }\r\n    return img.slice([beginHeight, beginWidth, 0], [size, size, 3]);\r\n}\r\n\r\n\r\n\r\n\r\n/**\r\n * This function will make a copy of a model on the weight level\r\n * This is an attempt to avoid influencing the new mode when the old one\r\n * is eliminated. \r\n * \r\n * @param originalModel - the model to be copied \r\n * @param recipient - the new model\r\n */\r\nasync copyModel_v3 (originalModel: tf.Sequential, recipient: tf.Sequential)  {\r\n\r\n        originalModel.layers.forEach((layer, index)=>{\r\n            recipient.layers[index].setWeights(layer.getWeights())\r\n        })\r\n\r\n    // originalModel.dispose();\r\n}\r\n    \r\n/**\r\n * This function will make a copy of a TFJS model, as so it would be possible \r\n * to erase the original.\r\n * @param model - model to be copied\r\n * @returns - copy of the model\r\n */  \r\nasync copyModel_v2 (originalModel: tf.Sequential)  {\r\n        // Serialize the original model\r\n        const modelTopology = originalModel.toJSON();\r\n\r\n        // Load the serialized model into a new model\r\n        const copiedModel = await tf.loadLayersModel(\r\n            tf.io.fromMemory(modelTopology, undefined, undefined)\r\n        );\r\n    \r\n        // Compile the copied model with the same settings as the original\r\n        copiedModel.compile({\r\n            loss: originalModel.loss,\r\n            optimizer: originalModel.optimizer\r\n        });\r\n    \r\n        return copiedModel;\r\n}\r\n\r\n/**\r\n * This function will make a copy of a TFJS model, as so it would be possible \r\n * to erase the original.\r\n * @param model - model to be copied\r\n * @returns - copy of the model\r\n */  \r\ncopyModel (model: tf.Sequential)  {\r\n    \r\n        const copy = tf.sequential();`\r\n        `\r\n        model.layers.forEach(layer => {\r\n            const aux =layer;\r\n            // layer.dispose();\r\n            copy.add(aux);\r\n        });\r\n        copy.compile({\r\n            loss: model.loss,\r\n            optimizer: model.optimizer\r\n        });\r\n        return copy;\r\n    }\r\n\r\n\r\n    removeElementByIndex(arr: any, index: number): number[] {\r\n        // Check if the index is within bounds\r\n        if (index >= 0 && index < arr.length) {\r\n            // Remove the element at the specified index\r\n            arr.splice(index, 1);            \r\n        }\r\n        return arr;\r\n    }\r\n\r\n    removeElement(arr: any, element: any): number[] {\r\n        // Remove all occurrences of the specified element from the array\r\n        return arr.filter((item: any) => item !== element);\r\n    }\r\n\r\nclean_array_of_tensors(tensors: tf.Sequential[]) {\r\n\r\n    tensors.forEach((elem, index)=>{ \r\n        // if(!index_selection.includes(index))  \r\n            elem.dispose() \r\n        });\r\n\r\n}\r\n\r\n getClassNameBySignature(classes: Class[], signature: number[]) {           \r\n    \r\n        const class_name = classes.find(p => {\r\n            let match = true;\r\n            p.signature?.forEach ((elem,index)=>{ \r\n                if(elem!==signature[index])\r\n                    match=false;                \r\n            })\r\n\r\n            return match;\r\n        });\r\n\r\n        return class_name ? class_name.name : \"not found\";\r\n}\r\n\r\nidentityMatrix(n: number): number[][] {\r\n        return Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => (i === j ? 1 : 0)));\r\n}  \r\n\r\n\r\nindexOfMax(arr: number[]): number {\r\n        if (arr.length === 0) {\r\n            return -1; // Return -1 for an empty array\r\n        }\r\n    \r\n        let max = arr[0];\r\n        let maxIndex = 0;\r\n    \r\n        for (let i = 1; i < arr.length; i++) {\r\n            if (arr[i] > max) {\r\n                maxIndex = i;\r\n                max = arr[i];\r\n            }\r\n        }\r\n    \r\n        return maxIndex;\r\n    }\r\n\r\n\r\nsuffle(array1:any, array2: any){\r\n        // Shuffle the order of elements\r\n    for (let i = array1.length - 1; i > 0; i--) {\r\n    const j = Math.floor(Math.random() * (i + 1));\r\n\r\n    // Swap elements in both arrays\r\n    [array1[i], array1[j]] = [array1[j], array1[i]];\r\n    [array2[i], array2[j]] = [array2[j], array2[i]];\r\n      }\r\n    \r\n    \r\n    }\r\n\r\n    sortByValuePreservingIndex<T>(\r\n        arr1: number[],\r\n        arr2: any[]\r\n    ): T[] {\r\n\r\n        // console.log(\"Vector for organizing: \", arr1)\r\n        // arr2[0].summary()\r\n\r\n        // Create an array of objects with value, index from arr1, and original index\r\n        const pairingArray = arr1.map((value, index) => ({\r\n            value,\r\n            index,\r\n            originalIndex: index,\r\n            elementFromArr2: arr2[index], // Preserve the corresponding element from arr2\r\n        }));\r\n    \r\n        // Sort the pairing array by value (largest to smallest)\r\n        pairingArray.sort((a, b) => b.value - a.value);\r\n\r\n        \r\n    \r\n        // Extract the sorted elements from arr2 based on the original index\r\n        const sortedElementsFromArr2 = pairingArray.map(pair => pair.elementFromArr2);\r\n    \r\n        return sortedElementsFromArr2;\r\n    }    \r\n    \r\n}\r\n\r\n"]}