learning_model 1.0.51 → 1.0.53

package/Makefile

@@ -2,4 +2,10 @@ install:
 	npm install --save-dev ts-jest
 
 ts:
-	yarn test
+	yarn test
+
+build:
+	npm run tsc
+
+publish: build
+	npm publish

package/dist/learning/mobilenet.d.ts

@@ -1,5 +1,4 @@
 import * as tf from '@tensorflow/tfjs';
-import '@tensorflow/tfjs-backend-wasm';
 import { io } from '@tensorflow/tfjs-core';
 import LearningInterface from './base';
 declare class LearningMobilenet implements LearningInterface {

package/dist/learning/mobilenet.js

@@ -38,7 +38,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const tf = __importStar(require("@tensorflow/tfjs"));
-require("@tensorflow/tfjs-backend-wasm"); // WebAssembly 백엔드 추가
+const tfjs_backend_wasm_1 = require("@tensorflow/tfjs-backend-wasm");
 const tfjs_1 = require("@tensorflow/tfjs");
 const tf_1 = require("../utils/tf");
 const canvas_1 = require("../utils/canvas");
@@ -187,8 +187,6 @@ class LearningMobilenet {
         return __awaiter(this, void 0, void 0, function* () {
             const isWasmSupported = yield this.checkWasmSupport();
             if (isWasmSupported) {
-                yield tf.setBackend('wasm');
-                yield tf.ready();
                 console.log('Backend is set to WebAssembly');
             }
             else {
@@ -201,6 +199,8 @@ class LearningMobilenet {
     checkWasmSupport() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                const wasmVersion = tf.version['tfjs-backend-wasm'] || tf.version['tfjs-core'];
+                (0, tfjs_backend_wasm_1.setWasmPaths)(`https://cdn.jsdelivr.net/npm/@tensorflow/tfjs-backend-wasm@${wasmVersion}/dist/`);
                 yield tf.setBackend('wasm');
                 yield tf.ready();
                 return true;

package/dist/lib/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.DataModel = exports.LearningMobilenet = void 0;
+const mobilenet_1 = __importDefault(require("./learning/mobilenet"));
+exports.LearningMobilenet = mobilenet_1.default;
+const data_model_1 = __importDefault(require("./learning/data_model"));
+exports.DataModel = data_model_1.default;

package/dist/lib/learning/base.js

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

package/dist/lib/learning/data_model.js

@@ -0,0 +1,215 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tf = __importStar(require("@tensorflow/tfjs"));
+const data_manager_1 = __importDefault(require("../utils/data_manager"));
+class DataModel {
+    constructor({ epochs = 50, batchSize = 16, limitSize = 2, learningRate = 0.001, validateRate = 0.15, } = {}) {
+        this.model = null;
+        this.dataManager = new data_manager_1.default();
+        this.epochs = epochs;
+        this.batchSize = batchSize;
+        this.learningRate = learningRate;
+        this.validateRate = validateRate;
+        this.isRunning = false;
+        this.isReady = false;
+        this.isTrainedDone = false;
+        this.limitSize = limitSize;
+    }
+    onProgress(progress) {
+        console.log(`Training progress: ${progress}%`);
+    }
+    onLoss(loss) {
+        console.log(`Loss: ${loss}`);
+    }
+    onTrainBegin(log) {
+        console.log('Training started', log);
+    }
+    onTrainEnd(log) {
+        console.log('Training ended', log);
+    }
+    onEpochEnd(epoch, logs) {
+        console.log(`Epoch ${epoch} ended with logs:`, logs);
+    }
+    addData(label, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const normalizedData = this.normalizeData(data);
+            const augmentedData = this.augmentData(normalizedData);
+            yield this.dataManager.addData(label, augmentedData);
+        });
+    }
+    augmentData(data) {
+        return data.map(value => value + (Math.random() * 0.1 - 0.05)); // 약간의 노이즈 추가
+    }
+    normalizeData(data) {
+        const mean = data.reduce((sum, value) => sum + value, 0) / data.length;
+        const std = Math.sqrt(data.reduce((sum, value) => sum + Math.pow(value - mean, 2), 0) / data.length);
+        return data.map(value => (value - mean) / std);
+    }
+    train() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isRunning) {
+                throw new Error('Training is already in progress');
+            }
+            const { xs, ys } = this.dataManager.convertToTensors();
+            const jointModel = tf.sequential();
+            jointModel.add(tf.layers.dense({
+                units: 32,
+                activation: 'relu',
+                inputShape: [xs.shape[1]],
+                kernelRegularizer: tf.regularizers.l2({ l2: 0.01 }) // L2 정규화 추가
+            }));
+            jointModel.add(tf.layers.dropout({ rate: 0.5 })); // 드롭아웃 레이어 추가
+            jointModel.add(tf.layers.dense({
+                units: 16,
+                activation: 'relu',
+                kernelRegularizer: tf.regularizers.l2({ l2: 0.01 }) // L2 정규화 추가
+            }));
+            jointModel.add(tf.layers.dropout({ rate: 0.5 })); // 드롭아웃 레이어 추가
+            jointModel.add(tf.layers.dense({ units: Object.keys(this.dataManager.getLabelMap()).length, activation: 'softmax' }));
+            jointModel.compile({
+                optimizer: tf.train.adam(this.learningRate), // 학습률 조정
+                loss: 'sparseCategoricalCrossentropy',
+                metrics: ['accuracy']
+            });
+            this.model = jointModel;
+            this.isRunning = true;
+            const history = yield jointModel.fit(xs, ys, {
+                epochs: this.epochs,
+                batchSize: this.batchSize,
+                validationSplit: 0.2,
+                callbacks: {
+                    onEpochEnd: (epoch, logs) => this.onEpochEnd(epoch, logs),
+                    onBatchEnd: (batch, logs) => {
+                    },
+                    onTrainBegin: (logs) => this.onTrainBegin(logs),
+                    onTrainEnd: (logs) => {
+                        this.isRunning = false;
+                        this.isReady = true;
+                        this.onTrainEnd(logs);
+                    },
+                }
+            });
+            return history;
+        });
+    }
+    infer(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isReady || !this.model) {
+                throw new Error('Model is not ready');
+            }
+            // 입력 데이터를 텐서로 변환
+            const input = tf.tensor2d([data], [1, data.length], 'float32');
+            try {
+                // 모델 예측 수행
+                const prediction = this.model.predict(input);
+                // 예측 결과 값들을 추출
+                const values = yield prediction.data();
+                // 클래스 이름과 확률을 저장할 Map 생성
+                const classProbabilities = new Map();
+                const EPSILON = 1e-6; // 매우 작은 값을 표현하기 위한 엡실론
+                // 라벨 맵을 가져옴
+                const labelMap = this.dataManager.getLabelMap();
+                const reverseLabelMap = Object.entries(labelMap).reduce((acc, [key, value]) => {
+                    acc[value] = key;
+                    return acc;
+                }, {});
+                // 각 클래스의 확률 계산 및 조정
+                for (let i = 0; i < values.length; i++) {
+                    let probability = Math.max(0, Math.min(1, values[i])); // 확률 값을 0과 1 사이로 조정
+                    probability = probability < EPSILON ? 0 : probability; // 매우 작은 확률 값을 0으로 간주
+                    const className = reverseLabelMap[i]; // 클래스 이름을 문자열로 가져옴
+                    if (className) {
+                        const existingProbability = classProbabilities.get(className);
+                        if (existingProbability !== undefined) {
+                            classProbabilities.set(className, existingProbability + probability);
+                        }
+                        else {
+                            classProbabilities.set(className, probability);
+                        }
+                    }
+                }
+                // 텐서 해제
+                prediction.dispose();
+                input.dispose();
+                console.log('classProbabilities', classProbabilities);
+                return classProbabilities;
+            }
+            catch (error) {
+                // 텐서 해제
+                input.dispose();
+                throw error;
+            }
+        });
+    }
+    saveModel(handlerOrURL, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.model) {
+                throw new Error('No model to save');
+            }
+            yield this.model.save(handlerOrURL, config);
+        });
+    }
+    running() {
+        return this.isRunning;
+    }
+    ready() {
+        return this.isReady;
+    }
+    load(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ jsonURL, labels }) {
+            this.model = yield tf.loadLayersModel(jsonURL);
+            this.isReady = true;
+            // Assuming the labels are provided in the correct order
+            this.dataManager = new data_manager_1.default();
+            labels.forEach((label, index) => {
+                this.dataManager.getLabelMap()[label] = index;
+            });
+        });
+    }
+}
+exports.default = DataModel;

package/dist/lib/learning/data_model.test.js

@@ -0,0 +1,56 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_model_1 = __importDefault(require("./data_model"));
+describe('LearningModel', () => {
+    let learningModel;
+    beforeEach(() => {
+        learningModel = new data_model_1.default({
+            epochs: 10,
+        });
+    });
+    it('should add sufficient data and train the model', () => __awaiter(void 0, void 0, void 0, function* () {
+        // 훈련 데이터 생성
+        const numSamples = 2000; // 훈련 데이터 샘플 수
+        for (let i = 0; i < numSamples; i++) {
+            const classLabel = i % 2 === 0 ? 'class1' : 'class2'; // 두 개의 클래스를 번갈아가며 생성
+            const data = Array.from({ length: 3 }, () => Math.random() * 10); // 임의의 데이터 생성
+            yield learningModel.addData(classLabel, data);
+        }
+        // 모델 훈련
+        const history = yield learningModel.train();
+        // 훈련 결과 평가
+        expect(history).toBeDefined();
+        expect(learningModel.ready()).toBe(true);
+    }), 30000); // 타임아웃을 15초로 설정
+    it('should make predictions', () => __awaiter(void 0, void 0, void 0, function* () {
+        // 훈련 데이터 생성
+        const numSamples = 100; // 훈련 데이터 샘플 수
+        for (let i = 0; i < numSamples; i++) {
+            const classLabel = i % 2 === 0 ? 'class1' : 'class2'; // 두 개의 클래스를 번갈아가며 생성
+            const data = Array.from({ length: 3 }, () => Math.random() * 10); // 임의의 데이터 생성
+            yield learningModel.addData(classLabel, data);
+            yield learningModel.addData(classLabel, [1, 2, 4]);
+        }
+        // 모델 훈련
+        yield learningModel.train();
+        // 테스트 데이터 생성
+        const testData = [4.0, 3.1, 5.2]; // 테스트할 데이터 생성
+        // 예측 수행
+        const result = yield learningModel.infer(testData);
+        console.log('result', result);
+        // 결과 평가
+        expect(result).toBeDefined();
+    }), 30000);
+});

package/dist/lib/learning/mobilenet.d.ts

@@ -1,5 +1,4 @@
 import * as tf from '@tensorflow/tfjs';
-import '@tensorflow/tfjs-backend-wasm';
 import { io } from '@tensorflow/tfjs-core';
 import LearningInterface from './base';
 declare class LearningMobilenet implements LearningInterface {