learning_model 1.0.18 → 1.0.22

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

@@ -1,42 +0,0 @@
-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/dist/types/learning/mobilenet_image.js

@@ -1,262 +0,0 @@
-"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, learningRate = 0.001, } = {}) {
-        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.onEvents = () => { };
-        this.onTrainBegin = () => { };
-        this.onTrainEnd = () => { };
-        this.model = null;
-        this.epochs = epochs;
-        this.batchSize = batchSize;
-        this.learningRate = learningRate;
-        this.labels = [];
-        this.modelURL = modelURL;
-        this.isRunning = false;
-        this.isReady = false;
-        this.limitSize = limitSize;
-    }
-    // 학습 데이타 등록 
-    addData(label, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 Promise.resolve();
-            }
-            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) => {
-                    console.log(`Epoch ${epoch + 1} is starting.`, logs);
-                },
-                onEpochEnd: (epoch, logs) => {
-                    console.log(`Epoch ${epoch + 1} has ended.`);
-                    console.log('Loss:', logs);
-                    this.onLoss(logs.loss);
-                    this.onProgress(epoch + 1);
-                    this.onEvents(logs);
-                }
-            };
-            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) {
-                return Promise.reject(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'
-                }));
-                const optimizer = tf.train.adam(this.learningRate); // Optimizer를 생성하고 학습률을 설정합니다.
-                model.compile({
-                    loss: (numClasses === 2) ? 'binaryCrossentropy' : 'categoricalCrossentropy',
-                    optimizer: optimizer,
-                    metrics: ['accuracy', 'acc']
-                });
-                model.summary();
-                return model;
-            }
-            catch (error) {
-                console.error('Failed to load model', error);
-                throw error;
-            }
-        });
-    }
-}
-exports.default = LearningMobilenetImage;

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

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

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

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

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

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

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

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

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

@@ -1,42 +0,0 @@
-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/public/index.css

@@ -1,7 +0,0 @@
-#container {
-  position: relative;
-}
-
-#canvas {
-  margin-bottom: 20px; /* 간격을 조정할 값 */
-}

package/public/index.html

@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <link rel="stylesheet" href="index.css">
-  <title>My CNN Module</title>
-</head>
-<body>
-  <div id="loss-bar"></div>
-  <div id="progress-bar"></div>
-  <div id="root"></div>
-  <div id="container">
-    <canvas id="canvas"></canvas>
-  </div>
-</body>
-</html>

package/public/index.ts

@@ -1,153 +0,0 @@
-
-import LearningMobilenetImage from '../src/learning/mobilenet_image';
-
-// 프로그레스 바를 표시하는 클래스
-class StatusBar {
-  constructor(private container: HTMLElement) {}
-  update(status: number, message: string) {
-    this.container.innerText = `Status: ${status} ${message}`;
-  }
-}
-
-
-async function appRun() {
-  //////////////////////////////////////////////////////////////////////////////////////////
-  const learningImage = new LearningMobilenetImage({
-    epochs: 10,
-    batchSize: 4
-  });
-  learningImage.onProgress = (progress: number) => {
-    const element = document.getElementById('progress-bar');
-    if (element !== null) {
-      const bar = new StatusBar(element);
-      bar.update(progress, '%');
-    }
-  }
-  learningImage.onLoss = (loss: number) => {
-    const element = document.getElementById('loss-bar');
-    if (element !== null) {
-      const bar = new StatusBar(element);
-      bar.update(loss, 'loss');
-    }
-  }
-  //////////////////////////////////////////////////////////////////////////////////////////
-  //////////////////////////////////////////////////////////////////////////////////////////
-  //////////////////////////////////////////////////////////////////////////////////////////
-
-  // root UI
-  const container = document.createElement('div');
-  container.id = 'root';
-
-  // learning 준비 체크
-  const learningReadyCheck = () => {
-    if (!learningImage.ready()) {
-      window.alert('준비된 데이터가 없습니다.');
-      return false;
-    }
-    if (learningImage.running()) {
-      window.alert('이미 진행 중입니다.');
-      return false;
-    }
-    return true;
-  };
-
-  // 이미지 저장 버튼 클릭
-  async function handleImageButtonClick(label: string) {
-    // Canvas 생성
-    const canvas = document.createElement('canvas');
-    const video = document.createElement('video');
-  
-    // 웹캠 활성화
-    if (navigator.mediaDevices.getUserMedia) {
-      const stream = await navigator.mediaDevices.getUserMedia({ video: true });
-      video.srcObject = stream;
-    }
-    
-    // 비디오가 메타데이터 로딩되면 캔버스에 그리고 이미지 캡처
-    video.addEventListener('loadedmetadata', () => {
-      video.play(); // 비디오 플레이 시작
-    });
-
-    // 비디오가 메타데이터 로딩되면 캔버스에 그리고 이미지 캡처
-    video.addEventListener('play', () => {
-      canvas.width = 128;
-      canvas.height = 128;
-      const context = canvas.getContext('2d');
-      if (context) {
-        context.drawImage(video, 0, 0, canvas.width, canvas.height);
-        learningImage.addData(label, context.getImageData(0, 0, canvas.width, canvas.height));
-      }
-    });
-    container.appendChild(canvas);
-  }
-
-  // 추론하기 버튼
-  async function handleInferButtonClick() {
-    if(!learningReadyCheck()) {
-      return;
-    }
-
-    // Canvas 생성
-    const canvas = document.createElement('canvas');
-    const video = document.createElement('video');
-  
-    // 웹캠 활성화
-    if (navigator.mediaDevices.getUserMedia) {
-      const stream = await navigator.mediaDevices.getUserMedia({ video: true });
-      video.srcObject = stream;
-    }
-    
-    // 비디오가 메타데이터 로딩되면 캔버스에 그리고 이미지 캡처
-    video.addEventListener('loadedmetadata', () => {
-      video.play(); // 비디오 플레이 시작
-    });
-
-    // 비디오가 메타데이터 로딩되면 캔버스에 그리고 이미지 캡처
-    video.addEventListener('play', () => {
-      canvas.width = 128;
-      canvas.height = 128;
-      const context = canvas.getContext('2d');
-      if (context) {
-        context.drawImage(video, 0, 0, canvas.width, canvas.height);
-        learningImage.infer(context.getImageData(0, 0, canvas.width, canvas.height));
-      }
-    });
-    container.appendChild(canvas);
-  }
-
-  // Train 학습하기 버튼
-  async function handleTrainButtonClick() {
-    if(learningReadyCheck()) {
-      await learningImage.train();
-    } 
-  }
-
-  // image button UI
-  const image1Button = document.createElement('button');
-  image1Button.textContent = '라벨1 이미지';
-  image1Button.addEventListener('click', () => handleImageButtonClick('라벨1 이미지'));
-  container.appendChild(image1Button);
-
-  // image button UI
-  const image2Button = document.createElement('button');
-  image2Button.textContent = '라벨2 이미지';
-  image2Button.addEventListener('click', () => handleImageButtonClick('라벨2 이미지'));
-  container.appendChild(image2Button);
-
-  // save button UI
-  const trainButton = document.createElement('button');
-  trainButton.textContent = '모델 Train';
-  trainButton.addEventListener('click', handleTrainButtonClick);
-  container.appendChild(trainButton);
-  document.body.appendChild(container);
-
-  // image button UI
-  const inferButton = document.createElement('button');
-  inferButton.textContent = '예측하기';
-  inferButton.addEventListener('click', () => handleInferButtonClick());
-  container.appendChild(inferButton);
-
-  
-}
-
-appRun();

package/src/learning/mobilenet_image.test.ts

@@ -1,63 +0,0 @@
-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/types/index.d.ts

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