learning_model 1.0.51 → 1.0.53

package/dist/lib/utils/tf.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTensor = isTensor;
+exports.loadModel = loadModel;
+exports.mobileNetURL = mobileNetURL;
+exports.imageToTensor = imageToTensor;
+exports.capture = capture;
+exports.cropTensor = cropTensor;
+const tf = __importStar(require("@tensorflow/tfjs"));
+function isTensor(c) {
+    return typeof c.dataId === 'object' && typeof c.shape === 'object';
+}
+function loadModel() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const trainLayerV1 = 'conv_pw_13_relu';
+        const trainLayerV2 = 'out_relu';
+        var mobileNetVersion = 2;
+        const modelURL = mobileNetURL(mobileNetVersion);
+        const load_model = yield tf.loadLayersModel(modelURL);
+        if (mobileNetVersion == 1) {
+            const layer = load_model.getLayer(trainLayerV1);
+            const truncatedModel = tf.model({
+                inputs: load_model.inputs,
+                outputs: layer.output
+            });
+            const model = tf.sequential();
+            model.add(truncatedModel);
+            model.add(tf.layers.flatten());
+            return model;
+        }
+        else {
+            const layer = load_model.getLayer(trainLayerV2);
+            const truncatedModel = tf.model({
+                inputs: load_model.inputs,
+                outputs: layer.output
+            });
+            const model = tf.sequential();
+            model.add(truncatedModel);
+            model.add(tf.layers.globalAveragePooling2d({})); // go from shape [7, 7, 1280] to [1280]
+            return model;
+        }
+    });
+}
+function mobileNetURL(version) {
+    if (version == 1) {
+        return "https://storage.googleapis.com/tfjs-models/tfjs/mobilenet_v1_1.0_224/model.json";
+    }
+    return "https://storage.googleapis.com/teachable-machine-models/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224_no_top/model.json";
+}
+function imageToTensor(data) {
+    let tensor;
+    if (data instanceof tf.Tensor) {
+        tensor = data;
+    }
+    else {
+        // MobileNet 모델 로드
+        tensor = tf.browser.fromPixels(data);
+    }
+    return tensor;
+}
+function capture(rasterElement, grayscale) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return tf.tidy(() => {
+            const pixels = tf.browser.fromPixels(rasterElement);
+            // crop the image so we're using the center square
+            const cropped = 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));
+        });
+    });
+}
+function 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]);
+}

package/lib/learning/mobilenet.ts

@@ -5,7 +5,7 @@
 ///////////////////////////////////////////////////////////////////////////
 
 import * as tf from '@tensorflow/tfjs';
-import '@tensorflow/tfjs-backend-wasm';  // WebAssembly 백엔드 추가
+import { setWasmPaths } from '@tensorflow/tfjs-backend-wasm';
 import { dispose } from '@tensorflow/tfjs';
 import { io } from '@tensorflow/tfjs-core';
 import LearningInterface from './base';
@@ -201,8 +201,6 @@ class LearningMobilenet implements LearningInterface {
   private async setupBackend() {
     const isWasmSupported = await this.checkWasmSupport();
     if (isWasmSupported) {
-      await tf.setBackend('wasm');
-      await tf.ready();
       console.log('Backend is set to WebAssembly');
     } else {
       await tf.setBackend('cpu');
@@ -213,6 +211,8 @@ class LearningMobilenet implements LearningInterface {
 
   private async checkWasmSupport(): Promise<boolean> {
     try {
+      const wasmVersion = (tf.version as Record<string, string>)['tfjs-backend-wasm'] || tf.version['tfjs-core'];
+      setWasmPaths(`https://cdn.jsdelivr.net/npm/@tensorflow/tfjs-backend-wasm@${wasmVersion}/dist/`);
       await tf.setBackend('wasm');
       await tf.ready();
       return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "learning_model",
-  "version": "1.0.51",
+  "version": "1.0.53",
   "description": "learning model develop",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,8 +21,7 @@
     "@tensorflow/tfjs": "^4.6.0",
     "@tensorflow/tfjs-layers": "^4.6.0",
     "@tensorflow/tfjs-backend-wasm": "^4.20.0",
-    "canvas": "^2.11.2",
-    "learning_model": "^1.0.0"
+    "canvas": "^2.11.2"
   },
   "devDependencies": {
     "@babel/core": "^7.15.0",

package/tsconfig.json

@@ -3,6 +3,7 @@
     "target": "ES6",
     "module": "CommonJS",
     "outDir": "dist",
+    "rootDir": "lib",
     "strict": true,
     "esModuleInterop": true,
     "declarationDir": "./dist",