learning_model 1.0.4 → 1.0.13

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

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

package/types/index.d.ts

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

package/types/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/types/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/types/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/types/learning/mobilenet_image.test.d.ts

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

package/types/public/index.d.ts

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

package/types/src/index.d.ts

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

package/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/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/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;