learning_model 1.0.4 → 1.0.13

package/README.md

@@ -1,3 +1,17 @@
 ## learning 클래스 
-* image: 기본 CNN을 가지고 이미지 분류 작업 
+* image: 기본 CNN을 가지고 이미지 분류
 * mobilenet : 모바일넷 모델을 가지고 마지막 softmax층만 빼서 전이학습을 한 방법
+
+## 테스트 방법
+```
+yarn 
+yarn start
+```
+
+## npm 배포
+package.json 버전을 올린다. 
+```
+yarn build
+npm login 
+npm publish
+```

package/build/index.js

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

package/build/learning/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/learning/image.js

@@ -0,0 +1,252 @@
+"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

@@ -0,0 +1,256 @@
+"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;