learning_model 1.0.14 → 1.0.15

package/build/index.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LearningMobilenetImage = exports.LearningImage = void 0;
-const image_1 = __importDefault(require("./learning/image"));
+var image_1 = __importDefault(require("./learning/image"));
 exports.LearningImage = image_1.default;
-const mobilenet_image_1 = __importDefault(require("./learning/mobilenet_image"));
+var mobilenet_image_1 = __importDefault(require("./learning/mobilenet_image"));
 exports.LearningMobilenetImage = mobilenet_image_1.default;

package/dist/types/learning/image.js

@@ -0,0 +1,321 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var tf = __importStar(require("@tensorflow/tfjs"));
+var LearningImage = /** @class */ (function () {
+    function LearningImage(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.epochs, epochs = _c === void 0 ? 10 : _c, _d = _b.batchSize, batchSize = _d === void 0 ? 16 : _d, _e = _b.limitSize, limitSize = _e === void 0 ? 2 : _e, _f = _b.learningRate, learningRate = _f === void 0 ? 0.001 : _f;
+        this.trainImages = [];
+        this.MOBILE_NET_INPUT_WIDTH = 224;
+        this.MOBILE_NET_INPUT_HEIGHT = 224;
+        this.MOBILE_NET_INPUT_CHANNEL = 3;
+        this.IMAGE_NORMALIZATION_FACTOR = 255.0;
+        this.onProgress = function () { };
+        this.onLoss = function () { };
+        this.onEvents = function () { };
+        this.onTrainBegin = function () { };
+        this.onTrainEnd = function () { };
+        this.model = null;
+        this.epochs = epochs;
+        this.batchSize = batchSize;
+        this.learningRate = learningRate;
+        this.labels = [];
+        this.isRunning = false;
+        this.isReady = false;
+        this.limitSize = 2;
+    }
+    // 학습 데이타 등록 
+    LearningImage.prototype.addData = function (label, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tensor;
+            return __generator(this, function (_a) {
+                try {
+                    tensor = tf.browser.fromPixels(data);
+                    console.log('addData', tensor);
+                    this.trainImages.push(tensor);
+                    this.labels.push(label);
+                    if (this.labels.length >= this.limitSize) {
+                        this.isReady = true;
+                    }
+                    return [2 /*return*/, Promise.resolve()];
+                }
+                catch (error) {
+                    console.error('Model training failed', error);
+                    throw error;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    // 모델 학습 처리
+    LearningImage.prototype.train = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var customCallback, _a, inputData, targetData, history_1, error_1;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.isRunning) {
+                            return [2 /*return*/, Promise.reject(new Error('Training is already in progress.'))];
+                        }
+                        customCallback = {
+                            onTrainBegin: function (log) {
+                                _this.onTrainBegin(log);
+                                console.log('Training has started.');
+                            },
+                            onTrainEnd: function (log) {
+                                _this.onTrainEnd(log);
+                                console.log('Training has ended.');
+                                _this.isRunning = false;
+                            },
+                            onBatchBegin: function (batch, logs) {
+                                console.log("Batch ".concat(batch, " is starting."));
+                            },
+                            onBatchEnd: function (batch, logs) {
+                                console.log("Batch ".concat(batch, " has ended."));
+                            },
+                            onEpochBegin: function (epoch, logs) {
+                                console.log("Epoch ".concat(epoch + 1, " is starting."), logs);
+                            },
+                            onEpochEnd: function (epoch, logs) {
+                                console.log("Epoch ".concat(epoch + 1, " has ended."));
+                                _this.onLoss(logs.loss);
+                                console.log('Loss:', logs);
+                                _this.onEvents(logs);
+                                _this.onProgress(epoch + 1);
+                            }
+                        };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        this.isRunning = true;
+                        if (this.labels.length < this.limitSize) {
+                            return [2 /*return*/, Promise.reject(new Error('Please train Data need over 2 data length'))];
+                        }
+                        _a = this;
+                        return [4 /*yield*/, this._createModel(this.labels.length)];
+                    case 2:
+                        _a.model = _b.sent();
+                        inputData = this._preprocessedInputData(this.model);
+                        console.log('inputData', inputData);
+                        targetData = this._preprocessedTargetData();
+                        console.log('targetData', targetData);
+                        return [4 /*yield*/, this.model.fit(inputData, targetData, {
+                                epochs: this.epochs,
+                                batchSize: this.batchSize,
+                                callbacks: customCallback
+                            })];
+                    case 3:
+                        history_1 = _b.sent();
+                        console.log('Model training completed', history_1);
+                        return [2 /*return*/, history_1];
+                    case 4:
+                        error_1 = _b.sent();
+                        this.isRunning = false;
+                        console.error('Model training failed', error_1);
+                        throw error_1;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // 추론하기
+    LearningImage.prototype.infer = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tensor, resizedTensor, reshapedTensor, predictions, predictionsData, classProbabilities, i, className, probability, existingProbability, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.model === null) {
+                            throw new Error('Model is null');
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        tensor = tf.browser.fromPixels(data);
+                        resizedTensor = tf.image.resizeBilinear(tensor, [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT]);
+                        reshapedTensor = resizedTensor.expandDims(0);
+                        predictions = this.model.predict(reshapedTensor);
+                        return [4 /*yield*/, predictions.data()];
+                    case 2:
+                        predictionsData = _a.sent();
+                        classProbabilities = new Map();
+                        for (i = 0; i < predictionsData.length; i++) {
+                            className = this.labels[i];
+                            probability = predictionsData[i];
+                            existingProbability = classProbabilities.get(className);
+                            if (existingProbability !== undefined) {
+                                classProbabilities.set(className, existingProbability + probability);
+                            }
+                            else {
+                                classProbabilities.set(className, probability);
+                            }
+                        }
+                        console.log('Class Probabilities:', classProbabilities);
+                        return [2 /*return*/, classProbabilities];
+                    case 3:
+                        error_2 = _a.sent();
+                        throw error_2;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // 모델 저장
+    LearningImage.prototype.saveModel = function () {
+        console.log('saved model');
+    };
+    // 진행중 여부
+    LearningImage.prototype.running = function () {
+        return this.isRunning;
+    };
+    LearningImage.prototype.ready = function () {
+        return this.isReady;
+    };
+    // target 라벨 데이타
+    LearningImage.prototype._preprocessedTargetData = function () {
+        var _this = this;
+        // 라벨 unique 처리 & 배열 리턴
+        console.log('uniqueLabels.length', this.labels, this.labels.length);
+        var labelIndices = this.labels.map(function (label) { return _this.labels.indexOf(label); });
+        console.log('labelIndices', labelIndices);
+        var oneHotEncode = tf.oneHot(tf.tensor1d(labelIndices, 'int32'), this.labels.length);
+        console.log('oneHotEncode', oneHotEncode);
+        return oneHotEncode;
+    };
+    // 입력 이미지 데이타 
+    LearningImage.prototype._preprocessedInputData = function (model) {
+        var _this = this;
+        // 이미지 배열을 배치로 변환 - [null, 224, 224, 3]
+        var inputShape = model.inputs[0].shape;
+        console.log('inputShape', inputShape);
+        // inputShape를 이와 같이 포멧 맞춘다. for reshape to [224, 224, 3]
+        var inputShapeArray = inputShape.slice(1);
+        console.log('inputShapeArray', inputShapeArray);
+        var inputBatch = tf.stack(this.trainImages.map(function (image) {
+            // 이미지 전처리 및 크기 조정 등을 수행한 후에
+            // 모델의 입력 형태로 변환하여 반환
+            var xs = _this._preprocessData(image); // 전처리 함수는 사용자 정의해야 함
+            return tf.reshape(xs, inputShapeArray);
+        }));
+        return inputBatch;
+    };
+    // 모델 학습하기 위한 데이타 전처리 단계
+    LearningImage.prototype._preprocessData = function (tensor) {
+        try {
+            // mobilenet model summary를 하면 위와 같이 224,224 사이즈의 입력값 설정되어 있다. ex) input_1 (InputLayer) [null,224,224,3]
+            var resizedImage = tf.image.resizeBilinear(tensor, [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT]);
+            // 이미지를 [0,1] 범위로 정규화 255로 나뉜 픽셀값
+            var normalizedImage = resizedImage.div(this.IMAGE_NORMALIZATION_FACTOR);
+            // expandDims(0)을 하여 차원을 추가하여 4D텐서 반환
+            return normalizedImage.expandDims(0);
+        }
+        catch (error) {
+            console.error('Failed to _preprocessData data', error);
+            throw error;
+        }
+    };
+    // 모델 저장
+    LearningImage.prototype._createModel = function (numClasses) {
+        return __awaiter(this, void 0, void 0, function () {
+            var inputShape, model, optimizer;
+            return __generator(this, function (_a) {
+                try {
+                    inputShape = [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT, this.MOBILE_NET_INPUT_CHANNEL];
+                    model = tf.sequential();
+                    model.add(tf.layers.conv2d({
+                        inputShape: inputShape,
+                        filters: 32,
+                        kernelSize: 3,
+                        activation: 'relu'
+                    }));
+                    model.add(tf.layers.maxPooling2d({ poolSize: 2 }));
+                    model.add(tf.layers.conv2d({
+                        filters: 64,
+                        kernelSize: 3,
+                        activation: 'relu'
+                    }));
+                    model.add(tf.layers.maxPooling2d({ poolSize: 2 }));
+                    model.add(tf.layers.flatten());
+                    model.add(tf.layers.dense({
+                        units: numClasses,
+                        activation: 'softmax'
+                    }));
+                    optimizer = tf.train.adam(this.learningRate);
+                    model.compile({
+                        loss: (numClasses === 2) ? 'binaryCrossentropy' : 'categoricalCrossentropy',
+                        optimizer: optimizer,
+                        metrics: ['accuracy', 'acc']
+                    });
+                    model.summary();
+                    return [2 /*return*/, model];
+                }
+                catch (error) {
+                    console.error('Failed to load model', error);
+                    throw error;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return LearningImage;
+}());
+exports.default = LearningImage;

package/dist/types/learning/mobilenet_image.js

@@ -0,0 +1,329 @@
+"use strict";
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// mobilenet 모델을 이용한 전이학습 방법 
+///////////////////////////////////////////////////////////////////////////
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var tf = __importStar(require("@tensorflow/tfjs"));
+var LearningMobilenetImage = /** @class */ (function () {
+    function LearningMobilenetImage(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.modelURL, modelURL = _c === void 0 ? 'https://storage.googleapis.com/tfjs-models/tfjs/mobilenet_v1_0.25_224/model.json' : _c, // 디폴트 mobilenet 이미지 
+        _d = _b.epochs, // 디폴트 mobilenet 이미지 
+        epochs = _d === void 0 ? 10 : _d, _e = _b.batchSize, batchSize = _e === void 0 ? 16 : _e, _f = _b.limitSize, limitSize = _f === void 0 ? 2 : _f, _g = _b.learningRate, learningRate = _g === void 0 ? 0.001 : _g;
+        this.trainImages = [];
+        this.MOBILE_NET_INPUT_WIDTH = 224;
+        this.MOBILE_NET_INPUT_HEIGHT = 224;
+        this.MOBILE_NET_INPUT_CHANNEL = 3;
+        this.IMAGE_NORMALIZATION_FACTOR = 255.0;
+        // 진행 상태를 나타내는 이벤트를 정의합니다.
+        this.onProgress = function () { };
+        this.onLoss = function () { };
+        this.onEvents = function () { };
+        this.onTrainBegin = function () { };
+        this.onTrainEnd = function () { };
+        this.model = null;
+        this.epochs = epochs;
+        this.batchSize = batchSize;
+        this.learningRate = learningRate;
+        this.labels = [];
+        this.modelURL = modelURL;
+        this.isRunning = false;
+        this.isReady = false;
+        this.limitSize = limitSize;
+    }
+    // 학습 데이타 등록 
+    LearningMobilenetImage.prototype.addData = function (label, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tensor;
+            return __generator(this, function (_a) {
+                try {
+                    tensor = tf.browser.fromPixels(data);
+                    console.log('addData', tensor);
+                    this.trainImages.push(tensor);
+                    this.labels.push(label);
+                    if (this.labels.length >= this.limitSize) {
+                        this.isReady = true;
+                    }
+                    return [2 /*return*/, Promise.resolve()];
+                }
+                catch (error) {
+                    console.error('Model training failed', error);
+                    throw error;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    // 모델 학습 처리
+    LearningMobilenetImage.prototype.train = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var customCallback, _a, inputData, targetData, history_1, error_1;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.isRunning) {
+                            return [2 /*return*/, Promise.reject(new Error('Training is already in progress.'))];
+                        }
+                        customCallback = {
+                            onTrainBegin: function (log) {
+                                _this.onTrainBegin(log);
+                                console.log('Training has started.');
+                            },
+                            onTrainEnd: function (log) {
+                                _this.onTrainEnd(log);
+                                console.log('Training has ended.');
+                                _this.isRunning = false;
+                            },
+                            onBatchBegin: function (batch, logs) {
+                                console.log("Batch ".concat(batch, " is starting."));
+                            },
+                            onBatchEnd: function (batch, logs) {
+                                console.log("Batch ".concat(batch, " has ended."));
+                            },
+                            onEpochBegin: function (epoch, logs) {
+                                console.log("Epoch ".concat(epoch + 1, " is starting."), logs);
+                            },
+                            onEpochEnd: function (epoch, logs) {
+                                console.log("Epoch ".concat(epoch + 1, " has ended."));
+                                console.log('Loss:', logs);
+                                _this.onLoss(logs.loss);
+                                _this.onProgress(epoch + 1);
+                                _this.onEvents(logs);
+                            }
+                        };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        this.isRunning = true;
+                        if (this.labels.length < this.limitSize) {
+                            return [2 /*return*/, Promise.reject(new Error('Please train Data need over 2 data length'))];
+                        }
+                        _a = this;
+                        return [4 /*yield*/, this._createModel(this.labels.length)];
+                    case 2:
+                        _a.model = _b.sent();
+                        inputData = this._preprocessedInputData(this.model);
+                        targetData = this._preprocessedTargetData();
+                        return [4 /*yield*/, this.model.fit(inputData, targetData, {
+                                epochs: this.epochs,
+                                batchSize: this.batchSize,
+                                callbacks: customCallback
+                            })];
+                    case 3:
+                        history_1 = _b.sent();
+                        console.log('Model training completed', history_1);
+                        return [2 /*return*/, history_1];
+                    case 4:
+                        error_1 = _b.sent();
+                        this.isRunning = false;
+                        console.error('Model training failed', error_1);
+                        throw error_1;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // 추론하기
+    LearningMobilenetImage.prototype.infer = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tensor, resizedTensor, reshapedTensor, predictions, predictionsData, classProbabilities, i, className, probability, existingProbability, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.model === null) {
+                            return [2 /*return*/, Promise.reject(new Error('Model is Null'))];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        tensor = tf.browser.fromPixels(data);
+                        resizedTensor = tf.image.resizeBilinear(tensor, [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT]);
+                        reshapedTensor = resizedTensor.expandDims(0);
+                        predictions = this.model.predict(reshapedTensor);
+                        return [4 /*yield*/, predictions.data()];
+                    case 2:
+                        predictionsData = _a.sent();
+                        classProbabilities = new Map();
+                        for (i = 0; i < predictionsData.length; i++) {
+                            className = this.labels[i];
+                            probability = predictionsData[i];
+                            existingProbability = classProbabilities.get(className);
+                            if (existingProbability !== undefined) {
+                                classProbabilities.set(className, existingProbability + probability);
+                            }
+                            else {
+                                classProbabilities.set(className, probability);
+                            }
+                        }
+                        console.log('Class Probabilities:', classProbabilities);
+                        return [2 /*return*/, classProbabilities];
+                    case 3:
+                        error_2 = _a.sent();
+                        throw error_2;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // 모델 저장
+    LearningMobilenetImage.prototype.saveModel = function () {
+        console.log('saved model');
+    };
+    // 진행중 여부
+    LearningMobilenetImage.prototype.running = function () {
+        return this.isRunning;
+    };
+    LearningMobilenetImage.prototype.ready = function () {
+        return this.isReady;
+    };
+    // target 라벨 데이타
+    LearningMobilenetImage.prototype._preprocessedTargetData = function () {
+        var _this = this;
+        // 라벨 unique 처리 & 배열 리턴
+        console.log('uniqueLabels.length', this.labels, this.labels.length);
+        var labelIndices = this.labels.map(function (label) { return _this.labels.indexOf(label); });
+        console.log('labelIndices', labelIndices);
+        var oneHotEncode = tf.oneHot(tf.tensor1d(labelIndices, 'int32'), this.labels.length);
+        console.log('oneHotEncode', oneHotEncode);
+        return oneHotEncode;
+    };
+    // 입력 이미지 데이타 
+    LearningMobilenetImage.prototype._preprocessedInputData = function (model) {
+        var _this = this;
+        // 이미지 배열을 배치로 변환 - [null, 224, 224, 3]
+        var inputShape = model.inputs[0].shape;
+        console.log('inputShape', inputShape);
+        // inputShape를 이와 같이 포멧 맞춘다. for reshape to [224, 224, 3]
+        var inputShapeArray = inputShape.slice(1);
+        console.log('inputShapeArray', inputShapeArray);
+        var inputBatch = tf.stack(this.trainImages.map(function (image) {
+            // 이미지 전처리 및 크기 조정 등을 수행한 후에
+            // 모델의 입력 형태로 변환하여 반환
+            var xs = _this._preprocessData(image); // 전처리 함수는 사용자 정의해야 함
+            return tf.reshape(xs, inputShapeArray);
+        }));
+        return inputBatch;
+    };
+    // 모델 학습하기 위한 데이타 전처리 단계
+    LearningMobilenetImage.prototype._preprocessData = function (tensor) {
+        try {
+            // mobilenet model summary를 하면 위와 같이 224,224 사이즈의 입력값 설정되어 있다. ex) input_1 (InputLayer) [null,224,224,3]
+            var resizedImage = tf.image.resizeBilinear(tensor, [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT]);
+            // 이미지를 [0,1] 범위로 정규화 255로 나뉜 픽셀값
+            var normalizedImage = resizedImage.div(this.IMAGE_NORMALIZATION_FACTOR);
+            // expandDims(0)을 하여 차원을 추가하여 4D텐서 반환
+            return normalizedImage.expandDims(0);
+        }
+        catch (error) {
+            console.error('Failed to _preprocessData data', error);
+            throw error;
+        }
+    };
+    // 모델 저장
+    LearningMobilenetImage.prototype._createModel = function (numClasses) {
+        return __awaiter(this, void 0, void 0, function () {
+            var load_model, truncatedModel, _i, _a, layer, model, optimizer, error_3;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, tf.loadLayersModel(this.modelURL)];
+                    case 1:
+                        load_model = _b.sent();
+                        truncatedModel = tf.model({
+                            inputs: load_model.inputs,
+                            outputs: load_model.layers[load_model.layers.length - 2].output
+                        });
+                        // 모델을 학습 가능하게 설정하고 선택한 레이어까지 고정
+                        for (_i = 0, _a = truncatedModel.layers; _i < _a.length; _i++) {
+                            layer = _a[_i];
+                            layer.trainable = false;
+                        }
+                        model = tf.sequential();
+                        model.add(truncatedModel);
+                        model.add(tf.layers.flatten()); // 필요한 경우 Flatten 레이어 추가
+                        model.add(tf.layers.dense({
+                            units: numClasses,
+                            activation: 'softmax'
+                        }));
+                        optimizer = tf.train.adam(this.learningRate);
+                        model.compile({
+                            loss: (numClasses === 2) ? 'binaryCrossentropy' : 'categoricalCrossentropy',
+                            optimizer: optimizer,
+                            metrics: ['accuracy', 'acc']
+                        });
+                        model.summary();
+                        return [2 /*return*/, model];
+                    case 2:
+                        error_3 = _b.sent();
+                        console.error('Failed to load model', error_3);
+                        throw error_3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return LearningMobilenetImage;
+}());
+exports.default = LearningMobilenetImage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "learning_model",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "learning model develop",
   "main": "dist/index.bundle.js",
   "types": "dist/types/index.d.ts",

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "target": "ES5",
     "module": "CommonJS",
-    "outDir": "dist",
+    "outDir": "build",
     "strict": true,
     "esModuleInterop": true,
     "declarationDir": "./types",

package/build/learning/image.js

@@ -1,252 +0,0 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __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 });
-const tf = __importStar(require("@tensorflow/tfjs"));
-class LearningImage {
-    constructor({ epochs = 10, batchSize = 16, limitSize = 2, } = {}) {
-        this.trainImages = [];
-        this.MOBILE_NET_INPUT_WIDTH = 224;
-        this.MOBILE_NET_INPUT_HEIGHT = 224;
-        this.MOBILE_NET_INPUT_CHANNEL = 3;
-        this.IMAGE_NORMALIZATION_FACTOR = 255.0;
-        this.onProgress = () => { };
-        this.onLoss = () => { };
-        this.onTrainBegin = () => { };
-        this.onTrainEnd = () => { };
-        this.model = null;
-        this.epochs = epochs;
-        this.batchSize = batchSize;
-        this.labels = [];
-        this.isRunning = false;
-        this.isReady = false;
-        this.limitSize = 2;
-    }
-    // 학습 데이타 등록 
-    addData(label, data) {
-        try {
-            const tensor = tf.browser.fromPixels(data);
-            console.log('addData', tensor);
-            this.trainImages.push(tensor);
-            this.labels.push(label);
-            if (this.labels.length >= this.limitSize) {
-                this.isReady = true;
-            }
-            return;
-        }
-        catch (error) {
-            console.error('Model training failed', error);
-            throw error;
-        }
-    }
-    // 모델 학습 처리
-    train() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isRunning) {
-                return Promise.reject(new Error('Training is already in progress.'));
-            }
-            // 콜백 정의
-            const customCallback = {
-                onTrainBegin: (log) => {
-                    this.onTrainBegin(log);
-                    console.log('Training has started.');
-                },
-                onTrainEnd: (log) => {
-                    this.onTrainEnd(log);
-                    console.log('Training has ended.');
-                    this.isRunning = false;
-                },
-                onBatchBegin: (batch, logs) => {
-                    console.log(`Batch ${batch} is starting.`);
-                },
-                onBatchEnd: (batch, logs) => {
-                    console.log(`Batch ${batch} has ended.`);
-                },
-                onEpochBegin: (epoch, logs) => {
-                    //const progress = Math.floor(((epoch + 1) / this.epochs) * 100);
-                    this.onProgress(epoch + 1);
-                    console.log(`Epoch ${epoch + 1} is starting.`);
-                },
-                onEpochEnd: (epoch, logs) => {
-                    console.log(`Epoch ${epoch + 1} has ended.`);
-                    this.onLoss(logs.loss);
-                    console.log('Loss:', logs.loss);
-                }
-            };
-            try {
-                this.isRunning = true;
-                if (this.labels.length < this.limitSize) {
-                    return Promise.reject(new Error('Please train Data need over 2 data length'));
-                }
-                this.model = yield this._createModel(this.labels.length);
-                const inputData = this._preprocessedInputData(this.model);
-                const targetData = this._preprocessedTargetData();
-                const history = yield this.model.fit(inputData, targetData, {
-                    epochs: this.epochs,
-                    batchSize: this.batchSize,
-                    callbacks: customCallback
-                });
-                console.log('Model training completed', history);
-                return history;
-            }
-            catch (error) {
-                this.isRunning = false;
-                console.error('Model training failed', error);
-                throw error;
-            }
-        });
-    }
-    // 추론하기
-    infer(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.model === null) {
-                throw new Error('Model is null');
-            }
-            try {
-                const tensor = tf.browser.fromPixels(data);
-                const resizedTensor = tf.image.resizeBilinear(tensor, [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT]);
-                const reshapedTensor = resizedTensor.expandDims(0); // 배치 크기 1을 추가하여 4차원으로 변환
-                const predictions = this.model.predict(reshapedTensor);
-                const predictionsData = yield predictions.data(); // 예측 텐서의 데이터를 비동기로 가져옴
-                const classProbabilities = new Map(); // 클래스별 확률 누적값을 저장할 맵
-                for (let i = 0; i < predictionsData.length; i++) {
-                    const className = this.labels[i]; // 클래스 이름
-                    const probability = predictionsData[i];
-                    const existingProbability = classProbabilities.get(className);
-                    if (existingProbability !== undefined) {
-                        classProbabilities.set(className, existingProbability + probability);
-                    }
-                    else {
-                        classProbabilities.set(className, probability);
-                    }
-                }
-                console.log('Class Probabilities:', classProbabilities);
-                return classProbabilities;
-            }
-            catch (error) {
-                throw error;
-            }
-        });
-    }
-    // 모델 저장
-    saveModel() {
-        console.log('saved model');
-    }
-    // 진행중 여부
-    running() {
-        return this.isRunning;
-    }
-    ready() {
-        return this.isReady;
-    }
-    // target 라벨 데이타
-    _preprocessedTargetData() {
-        // 라벨 unique 처리 & 배열 리턴
-        console.log('uniqueLabels.length', this.labels, this.labels.length);
-        const labelIndices = this.labels.map((label) => this.labels.indexOf(label));
-        console.log('labelIndices', labelIndices);
-        const oneHotEncode = tf.oneHot(tf.tensor1d(labelIndices, 'int32'), this.labels.length);
-        console.log('oneHotEncode', oneHotEncode);
-        return oneHotEncode;
-    }
-    // 입력 이미지 데이타 
-    _preprocessedInputData(model) {
-        // 이미지 배열을 배치로 변환 - [null, 224, 224, 3]
-        const inputShape = model.inputs[0].shape;
-        console.log('inputShape', inputShape);
-        // inputShape를 이와 같이 포멧 맞춘다. for reshape to [224, 224, 3]
-        const inputShapeArray = inputShape.slice(1);
-        console.log('inputShapeArray', inputShapeArray);
-        const inputBatch = tf.stack(this.trainImages.map((image) => {
-            // 이미지 전처리 및 크기 조정 등을 수행한 후에
-            // 모델의 입력 형태로 변환하여 반환
-            const xs = this._preprocessData(image); // 전처리 함수는 사용자 정의해야 함
-            return tf.reshape(xs, inputShapeArray);
-        }));
-        return inputBatch;
-    }
-    // 모델 학습하기 위한 데이타 전처리 단계
-    _preprocessData(tensor) {
-        try {
-            // mobilenet model summary를 하면 위와 같이 224,224 사이즈의 입력값 설정되어 있다. ex) input_1 (InputLayer) [null,224,224,3]
-            const resizedImage = tf.image.resizeBilinear(tensor, [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT]);
-            // 이미지를 [0,1] 범위로 정규화 255로 나뉜 픽셀값
-            const normalizedImage = resizedImage.div(this.IMAGE_NORMALIZATION_FACTOR);
-            // expandDims(0)을 하여 차원을 추가하여 4D텐서 반환
-            return normalizedImage.expandDims(0);
-        }
-        catch (error) {
-            console.error('Failed to _preprocessData data', error);
-            throw error;
-        }
-    }
-    // 모델 저장
-    _createModel(numClasses) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const inputShape = [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT, this.MOBILE_NET_INPUT_CHANNEL];
-                const model = tf.sequential();
-                model.add(tf.layers.conv2d({
-                    inputShape,
-                    filters: 32,
-                    kernelSize: 3,
-                    activation: 'relu'
-                }));
-                model.add(tf.layers.maxPooling2d({ poolSize: 2 }));
-                model.add(tf.layers.conv2d({
-                    filters: 64,
-                    kernelSize: 3,
-                    activation: 'relu'
-                }));
-                model.add(tf.layers.maxPooling2d({ poolSize: 2 }));
-                model.add(tf.layers.flatten());
-                model.add(tf.layers.dense({
-                    units: numClasses,
-                    activation: 'softmax'
-                }));
-                model.compile({
-                    loss: (numClasses === 2) ? 'binaryCrossentropy' : 'categoricalCrossentropy',
-                    optimizer: tf.train.adam(),
-                    metrics: ['accuracy']
-                });
-                model.summary();
-                return model;
-            }
-            catch (error) {
-                console.error('Failed to load model', error);
-                throw error;
-            }
-        });
-    }
-}
-exports.default = LearningImage;

package/build/learning/mobilenet_image.js

@@ -1,256 +0,0 @@
-"use strict";
-///////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-// mobilenet 모델을 이용한 전이학습 방법 
-///////////////////////////////////////////////////////////////////////////
-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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __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 });
-const tf = __importStar(require("@tensorflow/tfjs"));
-class LearningMobilenetImage {
-    constructor({ modelURL = 'https://storage.googleapis.com/tfjs-models/tfjs/mobilenet_v1_0.25_224/model.json', // 디폴트 mobilenet 이미지 
-    epochs = 10, batchSize = 16, limitSize = 2, } = {}) {
-        this.trainImages = [];
-        this.MOBILE_NET_INPUT_WIDTH = 224;
-        this.MOBILE_NET_INPUT_HEIGHT = 224;
-        this.MOBILE_NET_INPUT_CHANNEL = 3;
-        this.IMAGE_NORMALIZATION_FACTOR = 255.0;
-        // 진행 상태를 나타내는 이벤트를 정의합니다.
-        this.onProgress = () => { };
-        this.onLoss = () => { };
-        this.onTrainBegin = () => { };
-        this.onTrainEnd = () => { };
-        this.model = null;
-        this.epochs = epochs;
-        this.batchSize = batchSize;
-        this.labels = [];
-        this.modelURL = modelURL;
-        this.isRunning = false;
-        this.isReady = false;
-        this.limitSize = limitSize;
-    }
-    // 학습 데이타 등록 
-    addData(label, data) {
-        try {
-            const tensor = tf.browser.fromPixels(data);
-            console.log('addData', tensor);
-            this.trainImages.push(tensor);
-            this.labels.push(label);
-            if (this.labels.length >= this.limitSize) {
-                this.isReady = true;
-            }
-            return;
-        }
-        catch (error) {
-            console.error('Model training failed', error);
-            throw error;
-        }
-    }
-    // 모델 학습 처리
-    train() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isRunning) {
-                return Promise.reject(new Error('Training is already in progress.'));
-            }
-            // 콜백 정의
-            const customCallback = {
-                onTrainBegin: (log) => {
-                    this.onTrainBegin(log);
-                    console.log('Training has started.');
-                },
-                onTrainEnd: (log) => {
-                    this.onTrainEnd(log);
-                    console.log('Training has ended.');
-                    this.isRunning = false;
-                },
-                onBatchBegin: (batch, logs) => {
-                    console.log(`Batch ${batch} is starting.`);
-                },
-                onBatchEnd: (batch, logs) => {
-                    console.log(`Batch ${batch} has ended.`);
-                },
-                onEpochBegin: (epoch, logs) => {
-                    //const progress = Math.floor(((epoch + 1) / this.epochs) * 100);
-                    this.onProgress(epoch + 1);
-                    console.log(`Epoch ${epoch + 1} is starting.`);
-                },
-                onEpochEnd: (epoch, logs) => {
-                    console.log(`Epoch ${epoch + 1} has ended.`);
-                    console.log('Loss:', logs.loss);
-                }
-            };
-            try {
-                this.isRunning = true;
-                if (this.labels.length < this.limitSize) {
-                    return Promise.reject(new Error('Please train Data need over 2 data length'));
-                }
-                this.model = yield this._createModel(this.labels.length);
-                const inputData = this._preprocessedInputData(this.model);
-                const targetData = this._preprocessedTargetData();
-                const history = yield this.model.fit(inputData, targetData, {
-                    epochs: this.epochs,
-                    batchSize: this.batchSize,
-                    callbacks: customCallback
-                });
-                console.log('Model training completed', history);
-                return history;
-            }
-            catch (error) {
-                this.isRunning = false;
-                console.error('Model training failed', error);
-                throw error;
-            }
-        });
-    }
-    // 추론하기
-    infer(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.model === null) {
-                throw new Error('Model is null');
-            }
-            try {
-                const tensor = tf.browser.fromPixels(data);
-                const resizedTensor = tf.image.resizeBilinear(tensor, [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT]);
-                const reshapedTensor = resizedTensor.expandDims(0); // 배치 크기 1을 추가하여 4차원으로 변환
-                const predictions = this.model.predict(reshapedTensor);
-                const predictionsData = yield predictions.data(); // 예측 텐서의 데이터를 비동기로 가져옴
-                const classProbabilities = new Map(); // 클래스별 확률 누적값을 저장할 맵
-                for (let i = 0; i < predictionsData.length; i++) {
-                    const className = this.labels[i]; // 클래스 이름
-                    const probability = predictionsData[i];
-                    const existingProbability = classProbabilities.get(className);
-                    if (existingProbability !== undefined) {
-                        classProbabilities.set(className, existingProbability + probability);
-                    }
-                    else {
-                        classProbabilities.set(className, probability);
-                    }
-                }
-                console.log('Class Probabilities:', classProbabilities);
-                return classProbabilities;
-            }
-            catch (error) {
-                throw error;
-            }
-        });
-    }
-    // 모델 저장
-    saveModel() {
-        console.log('saved model');
-    }
-    // 진행중 여부
-    running() {
-        return this.isRunning;
-    }
-    ready() {
-        return this.isReady;
-    }
-    // target 라벨 데이타
-    _preprocessedTargetData() {
-        // 라벨 unique 처리 & 배열 리턴
-        console.log('uniqueLabels.length', this.labels, this.labels.length);
-        const labelIndices = this.labels.map((label) => this.labels.indexOf(label));
-        console.log('labelIndices', labelIndices);
-        const oneHotEncode = tf.oneHot(tf.tensor1d(labelIndices, 'int32'), this.labels.length);
-        console.log('oneHotEncode', oneHotEncode);
-        return oneHotEncode;
-    }
-    // 입력 이미지 데이타 
-    _preprocessedInputData(model) {
-        // 이미지 배열을 배치로 변환 - [null, 224, 224, 3]
-        const inputShape = model.inputs[0].shape;
-        console.log('inputShape', inputShape);
-        // inputShape를 이와 같이 포멧 맞춘다. for reshape to [224, 224, 3]
-        const inputShapeArray = inputShape.slice(1);
-        console.log('inputShapeArray', inputShapeArray);
-        const inputBatch = tf.stack(this.trainImages.map((image) => {
-            // 이미지 전처리 및 크기 조정 등을 수행한 후에
-            // 모델의 입력 형태로 변환하여 반환
-            const xs = this._preprocessData(image); // 전처리 함수는 사용자 정의해야 함
-            return tf.reshape(xs, inputShapeArray);
-        }));
-        return inputBatch;
-    }
-    // 모델 학습하기 위한 데이타 전처리 단계
-    _preprocessData(tensor) {
-        try {
-            // mobilenet model summary를 하면 위와 같이 224,224 사이즈의 입력값 설정되어 있다. ex) input_1 (InputLayer) [null,224,224,3]
-            const resizedImage = tf.image.resizeBilinear(tensor, [this.MOBILE_NET_INPUT_WIDTH, this.MOBILE_NET_INPUT_HEIGHT]);
-            // 이미지를 [0,1] 범위로 정규화 255로 나뉜 픽셀값
-            const normalizedImage = resizedImage.div(this.IMAGE_NORMALIZATION_FACTOR);
-            // expandDims(0)을 하여 차원을 추가하여 4D텐서 반환
-            return normalizedImage.expandDims(0);
-        }
-        catch (error) {
-            console.error('Failed to _preprocessData data', error);
-            throw error;
-        }
-    }
-    // 모델 저장
-    _createModel(numClasses) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const load_model = yield tf.loadLayersModel(this.modelURL);
-                // 기존 MobileNet 모델에서 마지막 레이어 제외
-                const truncatedModel = tf.model({
-                    inputs: load_model.inputs,
-                    outputs: load_model.layers[load_model.layers.length - 2].output
-                });
-                // 모델을 학습 가능하게 설정하고 선택한 레이어까지 고정
-                for (let layer of truncatedModel.layers) {
-                    layer.trainable = false;
-                }
-                const model = tf.sequential();
-                model.add(truncatedModel);
-                model.add(tf.layers.flatten()); // 필요한 경우 Flatten 레이어 추가
-                model.add(tf.layers.dense({
-                    units: numClasses,
-                    activation: 'softmax'
-                }));
-                model.compile({
-                    loss: (numClasses === 2) ? 'binaryCrossentropy' : 'categoricalCrossentropy',
-                    optimizer: tf.train.adam(),
-                    metrics: ['accuracy']
-                });
-                model.summary();
-                return model;
-            }
-            catch (error) {
-                console.error('Failed to load model', error);
-                throw error;
-            }
-        });
-    }
-}
-exports.default = LearningMobilenetImage;