learning_model 1.0.5 → 1.0.14

package/dist/types/learning/base.d.ts

@@ -1,19 +1,17 @@
 import * as tf from '@tensorflow/tfjs';
 interface LearningInterface {
     model: tf.LayersModel | null;
-    epochs: number;
-    batchSize: number;
     labels: string[];
     isRunning: boolean;
     isReady: boolean;
-    limitSize: number;
     onProgress(progress: number): void;
     onLoss(loss: number): void;
+    onEvents(logs: any): void;
     onTrainBegin(log: any): void;
     onTrainEnd(log: any): void;
-    addData(label: string, data: any): void;
+    addData(label: string, data: any): Promise<void>;
     train(): Promise<tf.History>;
-    infer(data: any): Promise<Map<string, number>>;
+    infer(data: any): Promise<any>;
     saveModel(): void;
     running(): boolean;
     ready(): boolean;

package/dist/types/learning/image.d.ts

@@ -4,6 +4,7 @@ declare class LearningImage implements LearningInterface {
     model: tf.LayersModel | null;
     epochs: number;
     batchSize: number;
+    learningRate: number;
     labels: string[];
     isRunning: boolean;
     isReady: boolean;
@@ -13,17 +14,19 @@ declare class LearningImage implements LearningInterface {
     readonly MOBILE_NET_INPUT_HEIGHT = 224;
     readonly MOBILE_NET_INPUT_CHANNEL = 3;
     readonly IMAGE_NORMALIZATION_FACTOR = 255;
-    constructor({ epochs, batchSize, limitSize, }?: {
+    constructor({ epochs, batchSize, limitSize, learningRate, }?: {
         modelURL?: string;
         epochs?: number;
         batchSize?: number;
         limitSize?: number;
+        learningRate?: number;
     });
     onProgress: (progress: number) => void;
     onLoss: (loss: number) => void;
+    onEvents: (logs: any) => void;
     onTrainBegin: (log: any) => void;
     onTrainEnd: (log: any) => void;
-    addData(label: string, data: any): void;
+    addData(label: string, data: any): Promise<void>;
     train(): Promise<tf.History>;
     infer(data: any): Promise<Map<string, number>>;
     saveModel(): void;

package/dist/types/learning/mobilenet_image.d.ts

@@ -4,6 +4,7 @@ declare class LearningMobilenetImage implements LearningInterface {
     model: tf.LayersModel | null;
     epochs: number;
     batchSize: number;
+    learningRate: number;
     labels: string[];
     modelURL: string;
     isRunning: boolean;
@@ -15,17 +16,19 @@ declare class LearningMobilenetImage implements LearningInterface {
     readonly MOBILE_NET_INPUT_CHANNEL = 3;
     readonly IMAGE_NORMALIZATION_FACTOR = 255;
     constructor({ modelURL, // 디폴트 mobilenet 이미지 
-    epochs, batchSize, limitSize, }?: {
+    epochs, batchSize, limitSize, learningRate, }?: {
         modelURL?: string;
         epochs?: number;
         batchSize?: number;
         limitSize?: number;
+        learningRate?: number;
     });
     onProgress: (progress: number) => void;
     onLoss: (loss: number) => void;
+    onEvents: (logs: any) => void;
     onTrainBegin: (log: any) => void;
     onTrainEnd: (log: any) => void;
-    addData(label: string, data: any): void;
+    addData(label: string, data: any): Promise<void>;
     train(): Promise<tf.History>;
     infer(data: any): Promise<Map<string, number>>;
     saveModel(): void;

package/dist/types/learning/mobilenet_image.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/public/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/index.d.ts

@@ -0,0 +1,3 @@
+import LearningImage from './learning/image';
+import LearningMobilenetImage from './learning/mobilenet_image';
+export { LearningImage, LearningMobilenetImage };

package/dist/types/src/learning/base.d.ts

@@ -0,0 +1,19 @@
+import * as tf from '@tensorflow/tfjs';
+interface LearningInterface {
+    model: tf.LayersModel | null;
+    labels: string[];
+    isRunning: boolean;
+    isReady: boolean;
+    onProgress(progress: number): void;
+    onLoss(loss: number): void;
+    onEvents(logs: any): void;
+    onTrainBegin(log: any): void;
+    onTrainEnd(log: any): void;
+    addData(label: string, data: any): Promise<void>;
+    train(): Promise<tf.History>;
+    infer(data: any): Promise<any>;
+    saveModel(): void;
+    running(): boolean;
+    ready(): boolean;
+}
+export default LearningInterface;

package/dist/types/src/learning/image.d.ts

@@ -0,0 +1,40 @@
+import * as tf from '@tensorflow/tfjs';
+import LearningInterface from './base';
+declare class LearningImage implements LearningInterface {
+    model: tf.LayersModel | null;
+    epochs: number;
+    batchSize: number;
+    learningRate: number;
+    labels: string[];
+    isRunning: boolean;
+    isReady: boolean;
+    limitSize: number;
+    trainImages: tf.Tensor3D[];
+    readonly MOBILE_NET_INPUT_WIDTH = 224;
+    readonly MOBILE_NET_INPUT_HEIGHT = 224;
+    readonly MOBILE_NET_INPUT_CHANNEL = 3;
+    readonly IMAGE_NORMALIZATION_FACTOR = 255;
+    constructor({ epochs, batchSize, limitSize, learningRate, }?: {
+        modelURL?: string;
+        epochs?: number;
+        batchSize?: number;
+        limitSize?: number;
+        learningRate?: number;
+    });
+    onProgress: (progress: number) => void;
+    onLoss: (loss: number) => void;
+    onEvents: (logs: any) => void;
+    onTrainBegin: (log: any) => void;
+    onTrainEnd: (log: any) => void;
+    addData(label: string, data: any): Promise<void>;
+    train(): Promise<tf.History>;
+    infer(data: any): Promise<Map<string, number>>;
+    saveModel(): void;
+    running(): boolean;
+    ready(): boolean;
+    private _preprocessedTargetData;
+    private _preprocessedInputData;
+    private _preprocessData;
+    private _createModel;
+}
+export default LearningImage;

package/dist/types/src/learning/mobilenet_image.d.ts

@@ -0,0 +1,42 @@
+import * as tf from '@tensorflow/tfjs';
+import LearningInterface from './base';
+declare class LearningMobilenetImage implements LearningInterface {
+    model: tf.LayersModel | null;
+    epochs: number;
+    batchSize: number;
+    learningRate: number;
+    labels: string[];
+    modelURL: string;
+    isRunning: boolean;
+    isReady: boolean;
+    limitSize: number;
+    trainImages: tf.Tensor3D[];
+    readonly MOBILE_NET_INPUT_WIDTH = 224;
+    readonly MOBILE_NET_INPUT_HEIGHT = 224;
+    readonly MOBILE_NET_INPUT_CHANNEL = 3;
+    readonly IMAGE_NORMALIZATION_FACTOR = 255;
+    constructor({ modelURL, // 디폴트 mobilenet 이미지 
+    epochs, batchSize, limitSize, learningRate, }?: {
+        modelURL?: string;
+        epochs?: number;
+        batchSize?: number;
+        limitSize?: number;
+        learningRate?: number;
+    });
+    onProgress: (progress: number) => void;
+    onLoss: (loss: number) => void;
+    onEvents: (logs: any) => void;
+    onTrainBegin: (log: any) => void;
+    onTrainEnd: (log: any) => void;
+    addData(label: string, data: any): Promise<void>;
+    train(): Promise<tf.History>;
+    infer(data: any): Promise<Map<string, number>>;
+    saveModel(): void;
+    running(): boolean;
+    ready(): boolean;
+    private _preprocessedTargetData;
+    private _preprocessedInputData;
+    private _preprocessData;
+    private _createModel;
+}
+export default LearningMobilenetImage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "learning_model",
-  "version": "1.0.5",
+  "version": "1.0.14",
   "description": "learning model develop",
   "main": "dist/index.bundle.js",
   "types": "dist/types/index.d.ts",
@@ -8,7 +8,8 @@
     "start": "webpack serve --open --mode development",
     "watch": "webpack --watch --mode=development",
     "build": "tsc && webpack",
-    "tsc": "tsc"
+    "tsc": "tsc",
+    "test": "jest"
   },
   "keywords": [
     "tensorflow"
@@ -20,11 +21,13 @@
     "@tensorflow/tfjs": "^4.6.0",
     "@tensorflow/tfjs-layers": "^4.6.0",
     "canvas": "^2.11.2",
+    "jest": "^29.5.0",
     "learning_model": "^1.0.0"
   },
   "devDependencies": {
     "@babel/core": "^7.15.0",
     "@babel/preset-env": "^7.15.0",
+    "@types/jest": "^29.5.2",
     "babel-loader": "^8.2.2",
     "clean-webpack-plugin": "^4.0.0",
     "copy-webpack-plugin": "^11.0.0",

package/public/index.ts

@@ -1,5 +1,5 @@
 
-import LearningImage from '../src/learning/image';
+import LearningMobilenetImage from '../src/learning/mobilenet_image';
 
 // 프로그레스 바를 표시하는 클래스
 class StatusBar {
@@ -12,9 +12,9 @@ class StatusBar {
 
 async function appRun() {
   //////////////////////////////////////////////////////////////////////////////////////////
-  const learningImage = new LearningImage({
-    epochs: 30,
-    batchSize: 32
+  const learningImage = new LearningMobilenetImage({
+    epochs: 10,
+    batchSize: 4
   });
   learningImage.onProgress = (progress: number) => {
     const element = document.getElementById('progress-bar');

package/src/learning/base.ts

@@ -4,18 +4,12 @@ import * as tf from '@tensorflow/tfjs';
 interface LearningInterface {
     // tf 모델
     model: tf.LayersModel | null;
-    // epoch 훈련 개수
-    epochs: number;
-    // 배치 사이즈 
-    batchSize: number;
     // 라벨 array
     labels: string[];
     // 이미 train중인지 여부 - 이미 진행중인경우 취소
     isRunning: boolean;
     // 준비 
     isReady: boolean;
-    // 데이타 사이즈
-    limitSize: number;
     
     // 진행상태 이벤트
     onProgress(progress: number): void;
@@ -23,21 +17,31 @@ interface LearningInterface {
     // loss 정보
     onLoss(loss: number): void;
 
+    // 이벤트 로그 정보
+    onEvents(logs: any): void;
+
+    // 학습 시작 이벤트
     onTrainBegin(log: any): void;
 
+    // 학습 종료 이벤트
     onTrainEnd(log: any): void;
 
     // 학습 데이타 추가 data는 다른 클래스에 맞게 any로 설정
-    addData(label: string, data: any): void;
+    addData(label: string, data: any): Promise<void>;
+
     // 학습 진행
     train(): Promise<tf.History>;
-    // 추론 
-    infer(data: any): Promise<Map<string, number>>;
+
+    // 추론하기
+    infer(data: any): Promise<any>;
+
     // 모델 저장
     saveModel(): void;
-    //
+
+    // 학습 진행 여부
     running(): boolean;
-    //
+
+    // 모델 준비 여부
     ready(): boolean;
 }  
 

package/src/learning/image.ts

@@ -5,6 +5,7 @@ class LearningImage implements LearningInterface {
   model: tf.LayersModel | null;
   epochs: number;
   batchSize: number;
+  learningRate: number;
   labels: string[];
   isRunning: boolean;
   isReady: boolean;
@@ -20,10 +21,12 @@ class LearningImage implements LearningInterface {
     epochs = 10,
     batchSize = 16,
     limitSize = 2,
-  }: { modelURL?: string, epochs?: number, batchSize?: number, limitSize?: number} = {}) {
+    learningRate = 0.001,
+  }: { modelURL?: string, epochs?: number, batchSize?: number, limitSize?: number, learningRate?: number} = {}) {
     this.model = null;
     this.epochs = epochs;
     this.batchSize = batchSize;
+    this.learningRate = learningRate;
     this.labels = [];
     this.isRunning = false;
     this.isReady = false;
@@ -34,12 +37,14 @@ class LearningImage implements LearningInterface {
 
   public onLoss: (loss: number) => void = () => {};
 
+  public onEvents: (logs: any) => void = () => {};
+
   public onTrainBegin: (log: any) => void = () => {};
 
   public onTrainEnd: (log: any) => void = () => {};
 
   // 학습 데이타 등록 
-  public addData(label: string, data: any): void {
+  public async addData(label: string, data: any): Promise<void> {
     try {
       const tensor = tf.browser.fromPixels(data);
       console.log('addData', tensor);
@@ -48,7 +53,7 @@ class LearningImage implements LearningInterface {
       if(this.labels.length >= this.limitSize) {
         this.isReady = true;
       }
-      return;
+      return Promise.resolve();
     } catch (error) {
       console.error('Model training failed', error);
       throw error;
@@ -79,14 +84,14 @@ class LearningImage implements LearningInterface {
         console.log(`Batch ${batch} has ended.`);
       },
       onEpochBegin: (epoch: number, logs: any) => {
-        //const progress = Math.floor(((epoch + 1) / this.epochs) * 100);
-        this.onProgress(epoch+1);
-        console.log(`Epoch ${epoch+1} is starting.`);
+        console.log(`Epoch ${epoch+1} is starting.`, logs);
       },
       onEpochEnd: (epoch: number, logs: any) => {
         console.log(`Epoch ${epoch+1} has ended.`);
         this.onLoss(logs.loss);
-        console.log('Loss:', logs.loss);
+        console.log('Loss:', logs);
+        this.onEvents(logs);
+        this.onProgress(epoch+1);
       }
     };
 
@@ -97,7 +102,9 @@ class LearningImage implements LearningInterface {
       }
       this.model = await this._createModel(this.labels.length);
       const inputData = this._preprocessedInputData(this.model);
+      console.log('inputData', inputData);
       const targetData = this._preprocessedTargetData();
+      console.log('targetData', targetData);
       const history = await this.model.fit(inputData, targetData, {
         epochs: this.epochs,
         batchSize: this.batchSize,
@@ -229,10 +236,12 @@ class LearningImage implements LearningInterface {
         units: numClasses,
         activation: 'softmax'
       }));
+
+      const optimizer = tf.train.adam(this.learningRate); // Optimizer를 생성하고 학습률을 설정합니다.
       model.compile({
         loss: (numClasses === 2) ? 'binaryCrossentropy': 'categoricalCrossentropy',
-        optimizer: tf.train.adam(),
-        metrics: ['accuracy']
+        optimizer: optimizer,
+        metrics: ['accuracy', 'acc']
       });
       model.summary();
       return model;

package/src/learning/mobilenet_image.test.ts

@@ -0,0 +1,63 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as tf from '@tensorflow/tfjs';
+import LearningMobilenetImage from './mobilenet_image';
+
+describe('LearningMobilenetImage', () => {
+  let learning: LearningMobilenetImage;
+  const imagePath = path.join(__dirname, 'data/images/image.jpg'); // 이미지 파일 경로
+
+  beforeEach(() => {
+    learning = new LearningMobilenetImage({});
+  });
+
+  afterEach(() => {
+    // 테스트 후에 모델 저장
+    learning.saveModel();
+  });
+
+  it('should add data', () => {
+    const label = 'label1';
+    const image = fs.readFileSync(imagePath); // 이미지 파일 읽어오기
+
+    learning.addData(label, image);
+
+    expect(learning.labels).toContain(label);
+    expect(learning.trainImages.length).toBe(1);
+  });
+
+  it('should not train if data is insufficient', async () => {
+    spyOn(console, 'error'); // 콘솔 에러 로그를 가로채기 위해 spyOn 사용
+
+    const result = await learning.train().catch((error: any) => error);
+
+    expect(result).toBeInstanceOf(Error);
+    expect(result.message).toBe('Please train Data need over 2 data length');
+    expect(console.error).toHaveBeenCalledWith('Model training failed', result);
+    expect(learning.model).toBeNull();
+  });
+
+  it('should train and infer', async () => {
+    const label1 = 'label1';
+    const image1 = fs.readFileSync(imagePath); // 이미지 파일 읽어오기
+    const label2 = 'label2';
+    const image2 = fs.readFileSync(imagePath); // 이미지 파일 읽어오기
+    const testData = fs.readFileSync(imagePath); // 테스트 데이터 읽어오기
+
+    learning.addData(label1, image1);
+    learning.addData(label2, image2);
+
+    const history = await learning.train();
+
+    expect(history).toBeDefined();
+    expect(learning.model).toBeInstanceOf(tf.LayersModel);
+    expect(learning.isRunning).toBe(false);
+
+    const predictions = await learning.infer(testData);
+
+    expect(predictions).toBeInstanceOf(Map);
+    expect(predictions.size).toBe(2);
+    // expect(predictions.get(label1)).toBeCloseTo(/* 예측값 */);
+    // expect(predictions.get(label2)).toBeCloseTo(/* 예측값 */);
+  });
+});

package/src/learning/mobilenet_image.ts

@@ -11,6 +11,7 @@ class LearningMobilenetImage implements LearningInterface {
   model: tf.LayersModel | null;
   epochs: number;
   batchSize: number;
+  learningRate: number;
   labels: string[];
   modelURL: string;
   isRunning: boolean;
@@ -28,10 +29,12 @@ class LearningMobilenetImage implements LearningInterface {
     epochs = 10,
     batchSize = 16,
     limitSize = 2,
-  }: { modelURL?: string, epochs?: number, batchSize?: number, limitSize?: number} = {}) {
+    learningRate = 0.001,
+  }: { modelURL?: string, epochs?: number, batchSize?: number, limitSize?: number, learningRate?: number} = {}) {
     this.model = null;
     this.epochs = epochs;
     this.batchSize = batchSize;
+    this.learningRate = learningRate;
     this.labels = [];
     this.modelURL = modelURL;
     this.isRunning = false;
@@ -44,12 +47,14 @@ class LearningMobilenetImage implements LearningInterface {
 
   public onLoss: (loss: number) => void = () => {};
 
+  public onEvents: (logs: any) => void = () => {};
+
   public onTrainBegin: (log: any) => void = () => {};
 
   public onTrainEnd: (log: any) => void = () => {};
 
   // 학습 데이타 등록 
-  public addData(label: string, data: any): void {
+  public async addData(label: string, data: any): Promise<void> {
     try {
       const tensor = tf.browser.fromPixels(data);
       console.log('addData', tensor);
@@ -58,7 +63,7 @@ class LearningMobilenetImage implements LearningInterface {
       if(this.labels.length >= this.limitSize) {
         this.isReady = true;
       }
-      return;
+      return Promise.resolve();
     } catch (error) {
       console.error('Model training failed', error);
       throw error;
@@ -89,13 +94,14 @@ class LearningMobilenetImage implements LearningInterface {
         console.log(`Batch ${batch} has ended.`);
       },
       onEpochBegin: (epoch: number, logs: any) => {
-        //const progress = Math.floor(((epoch + 1) / this.epochs) * 100);
-        this.onProgress(epoch+1);
-        console.log(`Epoch ${epoch+1} is starting.`);
+        console.log(`Epoch ${epoch+1} is starting.`, logs);
       },
       onEpochEnd: (epoch: number, logs: any) => {
         console.log(`Epoch ${epoch+1} has ended.`);
-        console.log('Loss:', logs.loss);
+        console.log('Loss:', logs);
+        this.onLoss(logs.loss);
+        this.onProgress(epoch+1);
+        this.onEvents(logs);
       }
     };
 
@@ -124,7 +130,7 @@ class LearningMobilenetImage implements LearningInterface {
   // 추론하기
   public async infer(data: any): Promise<Map<string, number>> {
     if (this.model === null) {
-      throw new Error('Model is null');
+      return Promise.reject(new Error('Model is Null'));
     }
   
     try {
@@ -234,11 +240,12 @@ class LearningMobilenetImage implements LearningInterface {
             units: numClasses,
             activation: 'softmax'
         }));
-
+        
+        const optimizer = tf.train.adam(this.learningRate); // Optimizer를 생성하고 학습률을 설정합니다.
         model.compile({
             loss: (numClasses === 2) ? 'binaryCrossentropy': 'categoricalCrossentropy',
-            optimizer: tf.train.adam(),
-            metrics: ['accuracy']
+            optimizer: optimizer,
+            metrics: ['accuracy', 'acc']
         });
         model.summary();
         return model;

package/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    "target": "ES6",
+    "target": "ES5",
     "module": "CommonJS",
-    "outDir": "build",
+    "outDir": "dist",
     "strict": true,
     "esModuleInterop": true,
     "declarationDir": "./types",
@@ -13,6 +13,8 @@
     "src/**/*.ts"
   ],
   "exclude": [
-    "node_modules"
+    "node_modules", 
+    "src/**/*.test.ts",
+    "dist"
   ]
 }

package/types/learning/base.d.ts

@@ -1,19 +1,17 @@
 import * as tf from '@tensorflow/tfjs';
 interface LearningInterface {
     model: tf.LayersModel | null;
-    epochs: number;
-    batchSize: number;
     labels: string[];
     isRunning: boolean;
     isReady: boolean;
-    limitSize: number;
     onProgress(progress: number): void;
     onLoss(loss: number): void;
+    onEvents(logs: any): void;
     onTrainBegin(log: any): void;
     onTrainEnd(log: any): void;
-    addData(label: string, data: any): void;
+    addData(label: string, data: any): Promise<void>;
     train(): Promise<tf.History>;
-    infer(data: any): Promise<Map<string, number>>;
+    infer(data: any): Promise<any>;
     saveModel(): void;
     running(): boolean;
     ready(): boolean;

package/types/learning/image.d.ts

@@ -4,6 +4,7 @@ declare class LearningImage implements LearningInterface {
     model: tf.LayersModel | null;
     epochs: number;
     batchSize: number;
+    learningRate: number;
     labels: string[];
     isRunning: boolean;
     isReady: boolean;
@@ -13,17 +14,19 @@ declare class LearningImage implements LearningInterface {
     readonly MOBILE_NET_INPUT_HEIGHT = 224;
     readonly MOBILE_NET_INPUT_CHANNEL = 3;
     readonly IMAGE_NORMALIZATION_FACTOR = 255;
-    constructor({ epochs, batchSize, limitSize, }?: {
+    constructor({ epochs, batchSize, limitSize, learningRate, }?: {
         modelURL?: string;
         epochs?: number;
         batchSize?: number;
         limitSize?: number;
+        learningRate?: number;
     });
     onProgress: (progress: number) => void;
     onLoss: (loss: number) => void;
+    onEvents: (logs: any) => void;
     onTrainBegin: (log: any) => void;
     onTrainEnd: (log: any) => void;
-    addData(label: string, data: any): void;
+    addData(label: string, data: any): Promise<void>;
     train(): Promise<tf.History>;
     infer(data: any): Promise<Map<string, number>>;
     saveModel(): void;

package/types/learning/mobilenet_image.d.ts

@@ -4,6 +4,7 @@ declare class LearningMobilenetImage implements LearningInterface {
     model: tf.LayersModel | null;
     epochs: number;
     batchSize: number;
+    learningRate: number;
     labels: string[];
     modelURL: string;
     isRunning: boolean;
@@ -15,17 +16,19 @@ declare class LearningMobilenetImage implements LearningInterface {
     readonly MOBILE_NET_INPUT_CHANNEL = 3;
     readonly IMAGE_NORMALIZATION_FACTOR = 255;
     constructor({ modelURL, // 디폴트 mobilenet 이미지 
-    epochs, batchSize, limitSize, }?: {
+    epochs, batchSize, limitSize, learningRate, }?: {
         modelURL?: string;
         epochs?: number;
         batchSize?: number;
         limitSize?: number;
+        learningRate?: number;
     });
     onProgress: (progress: number) => void;
     onLoss: (loss: number) => void;
+    onEvents: (logs: any) => void;
     onTrainBegin: (log: any) => void;
     onTrainEnd: (log: any) => void;
-    addData(label: string, data: any): void;
+    addData(label: string, data: any): Promise<void>;
     train(): Promise<tf.History>;
     infer(data: any): Promise<Map<string, number>>;
     saveModel(): void;

package/types/learning/mobilenet_image.test.d.ts

@@ -0,0 +1 @@
+export {};