learning_model 1.0.46 → 1.0.47

package/dist/learning/data_model.d.ts

@@ -29,7 +29,7 @@ declare class DataModel implements LearningInterface {
     augmentData(data: number[]): number[];
     normalizeData(data: number[]): number[];
     train(): Promise<tf.History>;
-    infer(data: number[]): Promise<any>;
+    infer(data: number[]): Promise<Map<string, number>>;
     saveModel(handlerOrURL: io.IOHandler | string, config?: io.SaveConfig): Promise<void>;
     running(): boolean;
     ready(): boolean;

package/dist/learning/data_model.js

@@ -132,10 +132,48 @@ class DataModel {
             if (!this.isReady || !this.model) {
                 throw new Error('Model is not ready');
             }
+            // 입력 데이터를 텐서로 변환
             const input = tf.tensor2d([data], [1, data.length], 'float32');
-            const prediction = this.model.predict(input);
-            const result = prediction.argMax(-1).dataSync()[0];
-            return Object.keys(this.dataManager.getLabelMap()).find(key => this.dataManager.getLabelMap()[key] === result);
+            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) {

package/dist/learning/data_model.test.js

@@ -16,7 +16,9 @@ const data_model_1 = __importDefault(require("./data_model"));
 describe('LearningModel', () => {
     let learningModel;
     beforeEach(() => {
-        learningModel = new data_model_1.default();
+        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* () {
         // 훈련 데이터 생성
@@ -39,6 +41,7 @@ describe('LearningModel', () => {
             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();
@@ -49,6 +52,5 @@ describe('LearningModel', () => {
         console.log('result', result);
         // 결과 평가
         expect(result).toBeDefined();
-        expect(['class1', 'class2']).toContain(result);
     }), 30000);
 });

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

@@ -29,7 +29,7 @@ declare class DataModel implements LearningInterface {
     augmentData(data: number[]): number[];
     normalizeData(data: number[]): number[];
     train(): Promise<tf.History>;
-    infer(data: number[]): Promise<any>;
+    infer(data: number[]): Promise<Map<string, number>>;
     saveModel(handlerOrURL: io.IOHandler | string, config?: io.SaveConfig): Promise<void>;
     running(): boolean;
     ready(): boolean;

package/lib/learning/data_model.test.ts

@@ -4,7 +4,9 @@ describe('LearningModel', () => {
   let learningModel: LearningModel;
 
   beforeEach(() => {
-    learningModel = new LearningModel();
+    learningModel = new LearningModel({
+      epochs: 10,
+    });
   });
 
   it('should add sufficient data and train the model', async () => {
@@ -32,6 +34,7 @@ describe('LearningModel', () => {
       const classLabel = i % 2 === 0 ? 'class1' : 'class2'; // 두 개의 클래스를 번갈아가며 생성
       const data = Array.from({ length: 3 }, () => Math.random() * 10); // 임의의 데이터 생성
       await learningModel.addData(classLabel, data);
+      await learningModel.addData(classLabel, [1,2,4]);
     }
 
     // 모델 훈련
@@ -46,6 +49,5 @@ describe('LearningModel', () => {
     
     // 결과 평가
     expect(result).toBeDefined();
-    expect(['class1', 'class2']).toContain(result);
   }, 30000);
 });

package/lib/learning/data_model.ts

@@ -122,17 +122,63 @@ class DataModel implements LearningInterface {
     return history;
   }
 
-  async infer(data: number[]): Promise<any> {
+  public async infer(data: number[]): Promise<Map<string, number>> {
     if (!this.isReady || !this.model) {
       throw new Error('Model is not ready');
     }
 
+    // 입력 데이터를 텐서로 변환
     const input = tf.tensor2d([data], [1, data.length], 'float32');
-    const prediction = this.model.predict(input) as tf.Tensor;
-    const result = prediction.argMax(-1).dataSync()[0];
 
-    return Object.keys(this.dataManager.getLabelMap()).find(key => this.dataManager.getLabelMap()[key] === result);
+    try {
+      // 모델 예측 수행
+      const prediction = this.model.predict(input) as tf.Tensor<tf.Rank>;
+
+      // 예측 결과 값들을 추출
+      const values = await prediction.data();
+
+      // 클래스 이름과 확률을 저장할 Map 생성
+      const classProbabilities = new Map<string, number>();
+      const EPSILON = 1e-6; // 매우 작은 값을 표현하기 위한 엡실론
+
+      // 라벨 맵을 가져옴
+      const labelMap = this.dataManager.getLabelMap();
+      const reverseLabelMap = Object.entries(labelMap).reduce((acc, [key, value]) => {
+        acc[value] = key;
+        return acc;
+      }, {} as { [key: number]: string });
+
+      // 각 클래스의 확률 계산 및 조정
+      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;
+    }
   }
+  
+  
+  
+  
 
   async saveModel(handlerOrURL: io.IOHandler | string, config?: io.SaveConfig): Promise<void> {
     if (!this.model) {

package/package.json

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