인공지능 학습하기

import { IDataApi, IUploadModel, apiData } from 'entry-ml';
import _throttle from 'lodash/throttle';
import { API_PREFIX, CDN_PREFIX } from 'constant';
import saveAs from 'file-saver';
import localforage from 'localforage';
import { CommonUtil } from 'utils/common';
import pako from 'pako';
import untar from 'js-untar';
import utf8 from 'utf8';
import Tar from 'tar-js';

const ONE_DATA_TYPE = ['decisionTree', 'cluster', 'text', 'number', 'svm', 'regression', 'logisticRegression'];
const LOCAL_STORAGE_KEY = 'entryml_filesystem';

class FileSystemApi implements IDataApi {
    temp:{[key:string]: any} = {};
    removeTemp: Array<string> = [];
    store: any;

    async createDb() {
        if (this.store) {
            return;
        }
        this.store = {
            data: localforage.createInstance({
                name: LOCAL_STORAGE_KEY,
                driver: localforage.INDEXEDDB,
                storeName: 'learningData',
                description : 'entry ml learning data',
                version     : 1.0,
            }),
            models: localforage.createInstance({
                name: LOCAL_STORAGE_KEY,
                driver: localforage.INDEXEDDB,
                storeName: 'models',
                description : 'entry ml models',
                version     : 1.0,
            }),
            tfModelInfo: localforage.createInstance({
                name: 'tensorflowjs',
                driver: localforage.INDEXEDDB,
                storeName: 'model_info_store',
            }),
            tfModel: localforage.createInstance({
                name: 'tensorflowjs',
                driver: localforage.INDEXEDDB,
                storeName: 'models_store',
            })
        };
    }

    async getItem(table: string, id: string) {
        if (this.temp[`${table}_${id}`]) {
            return this.temp[`${table}_${id}`];
        }
        await this.createDb();
        return await this.store[table].getItem(id);
    }

    async getAll(table: string) {
        await this.createDb();
        const keys = await this.store[table].keys();
        return await Promise.all(keys.map((key: string) => this.store[table].getItem(key)));
    }

    async setItem(table: string, id: string, data: any) {
        this.temp[`${table}_${id}`] = data;
        await this.createDb();
        this.store[table].setItem(id, data);
    }

    async deleteItem(table: string, id: string) {
        delete  this.temp[`${table}_${id}`];
        await this.createDb();
        await this.store[table].removeItem(id);
    }

    getModelSaveUrl = (modelId: string) => {
        const url = `indexeddb://${modelId}`;
        this.saveModel(modelId, { url });
        return url; 
    };

    getModelDownloadUrl(basePath: string) {
        if (basePath?.indexOf('indexeddb') > -1) {
            return basePath;
        }
        return `https://entry-cdn.pstatic.net/uploads/${basePath}/model.json`;
    }

    loadModel = async ({
        model,
        weight,
        url,
        modelId
    }: {
        model?: File;
        weight?: File;
        url?: string;
        modelId?: string;
    }): Promise<any> => {
        if (modelId) {
            const model = await this.getItem('models', modelId);
            return model?.file;
        }
        return ;
    };
    async loadModels(project?: string): Promise<Array<any>> {
        return await this.getAll('models') || [];
    }
    saveModel = async (modelId: string, project: IUploadModel): Promise<{ data:IUploadModel }> => {
        const loadedModel = await this.getItem('models', modelId) || {};
        const data = {
            ...loadedModel,
            ...project,
            version: 1,
        };
        if (!data._id) {
            data._id = data.id;
        }
        await this.setItem('models', modelId, data);
        return {
            data,
        };
    };
    saveModelFile = async (url: string, formData: FormData) => {
        const modelId = url.replace(API_PREFIX, '').replace('indexeddb://', '');
        const form = Object.fromEntries(formData);
        const file = form.file as Blob;
        const data = await blobToStr(file) as string;
        const savedUrl = `indexeddb://${modelId}`;
        await this.saveModel(modelId, {
            file : JSON.parse(data),
            url: savedUrl,
        });
        return savedUrl;
    };
    async deleteModel(modelId: string): Promise<any> {
        await this.createDb();
        const keys = await this.store.data.keys();
        await Promise.all(keys.map((key:string) => {
            if (key.indexOf(modelId) >= 0) {
                return this.store.data.removeItem(key);
            }
        }));
        await this.deleteItem('models', modelId);
    }
    async copyModel(modelId: string): Promise<any> {
        const { file, modelJSON, weightJSON, info } = await this.exportModel(modelId);
        const newId = CommonUtil?.generateObjectId();
        const newModelInfo = {
            ...info,
            name: `${info.name}의 복사본`,
            _id: newId,
            id: newId,
            url: `indexeddb://${newId}`,
            parent: info._id,
        };
        await Promise.all(newModelInfo.classes.map(async (clazz: any) => {
            const saveDatas = await this.getGroupData(info.id, clazz.id);
            saveDatas.map(async (saveData: any) => {
                await this.saveData({ projectId: newId, classId: clazz.id, saveData });
            });
        }));
        if (file) {
            await this.saveModel(newId, {
                file,
                ...newModelInfo
            });
            return newModelInfo;
        } else {
            if (modelJSON) {
                saveWithkeyPath(
                    this.store.tfModel,
                    { ...modelJSON, modelPath: newId }
                );
            }
            if (weightJSON) {
                saveWithkeyPath(
                    this.store.tfModelInfo,
                    { ...weightJSON, modelPath: newId }
                );
            }
            await this.saveModel(newId, newModelInfo);
            return newModelInfo;
        }
    }
    async exportModel(modelId: string) {
        const loadedModel = await this.getItem('models', modelId);
        if (!loadedModel) {
            throw new Error('no model');
        }
        const { file, ...info } = loadedModel;
        if (file) {
            return {
                info,
                file
            };
        } else {
            const modelData = await this.store.tfModel.getItem(info.id);
            const modelInfoData = await this.store.tfModelInfo.getItem(info.id);
            return {
                info,
                modelJSON: modelData,
                weightJSON: modelInfoData,
            };
        }
    }

    async downloadModel(modelId: string): Promise<any> {
        const { file, modelJSON, weightJSON, info } = await this.exportModel(modelId);
        const files: Array<{ name: string, content: string }> = [
            { name: 'temp/info.json', content: JSON.stringify(info)}
        ];
        if (file) {
            files.push({ name: 'temp/model.json', content: JSON.stringify(file)});
        } else if (modelJSON && weightJSON) {
            files.push({ name: 'temp/model.json', content: JSON.stringify(modelJSON)});
            files.push({ name: 'temp/weight.json', content: JSON.stringify(weightJSON)});
        }
        const tarData = createTar(files);
        const gzippedData = pako.gzip(new Uint8Array(tarData));
        const blob = new Blob([gzippedData], { type: 'application/gzip' });
        saveAs(blob, `${info.name}.entm`);
    }

    async uploadModel(data: FormData): Promise<any> {
        await this.createDb();
        const zipFile = data.get('files') as File;
        if (!zipFile) {
            console.log('no file');
            return ;
        }
        const blob = zipFile.slice(0, zipFile.size, 'application/zip'); 
        const newFile = new File([blob], 'temp.zip', { type: 'application/zip' });
        const { key, saveData, info } = await loadZip(newFile, this.store);
        await this.saveModel(key, saveData);
        return info;
    }
    async getGroupData(modelId: string, groupId: string): Promise<any> {
        const id = modelId + groupId;
        const items = await this.getItem('data', id) || [];
        return items;
    }

    async saveData({ projectId, classId, saveData }: apiData) {
        const id = `${projectId}_${classId}`;
        const { type } = saveData;
        const items = await this.getItem('data', id) || [];
        const _id = CommonUtil?.generateObjectId();
        const data = {
            ...saveData,
            class: classId,
            model: projectId,
            _id,
            id:_id,
        };
        if (data.classes) {
            data.classes = JSON.parse(data.classes);
            await this.saveModel(projectId, {
                classes: data.classes,
                id: projectId,
                type,
            });
            delete data.classes;
        }
        if (ONE_DATA_TYPE.includes(type)) {
            items[0] = data;
        } else {
            items.push(data);
        }
        await this.setItem('data', id, items);
        return { data };
    }
    async deleteData(key: string): Promise<void> {
        await this.deleteItem('data', key);
    }
    async getImageFile({ filename = '', _id: id, data }:{ filename:string; _id: string; data: any; }) {
        return dataURLtoFile(data, `${filename}.png`);
    }
    async getSoundData({ filename = '', _id: id, data }:{ filename:string; _id: string; data: any; }) {
        const blob = dataURLtoBlob(data);
        const buffer = await blob.arrayBuffer();
        return { dataUrl: data, buffer };
    }
}

export default FileSystemApi;

const blobToStr = (blob: Blob) => new Promise((resolve) => {
    const reader = new FileReader();
    reader.onload = function() {
        resolve(reader.result);
    };
    reader.readAsText(blob);
});

function dataURLtoFile(dataurl: string, filename: string) {
    const arr = dataurl.split(',');
    const mime = arr[0].match(/:(.*?);/)?.[1];
    const bstr = atob(arr[arr.length - 1]);
    let n = bstr.length;
    const u8arr = new Uint8Array(n);
    while (n--) {
        u8arr[n] = bstr.charCodeAt(n);
    }
    return new File([u8arr], filename, { type: mime });
}

function dataURLtoBlob(dataurl: string) {
    const arr = dataurl.split(',');
    const mime = arr[0].match(/:(.*?);/)?.[1];
    const bstr = atob(arr[1]);
    let n = bstr.length;
    const u8arr = new Uint8Array(n);
    while (n--) {
        u8arr[n] = bstr.charCodeAt(n);
    }
    return new Blob([u8arr], { type:mime });
}

const saveWithkeyPath = (store: any, data: any) => {
    store.ready().then(() => {
        const dbInfo = store._dbInfo;
        const tx = dbInfo.db.transaction(dbInfo.storeName, 'readwrite');
        const objectStore = tx.objectStore(dbInfo.storeName);
        if (data[objectStore.keyPath]) {
            objectStore.put(data);
        } else {
            throw new Error(`no key ${objectStore.keyPath}`);
        }
    });
};

const unzipModel = (fileBuffer: ArrayBuffer): Promise<{ info?: any; model?: any; weight?: any; }> => 
    new Promise((resolve) => {
        const pBuffer = pako.ungzip(fileBuffer);
        untar(pBuffer.buffer).then((extractedFiles: Array<any>) => {
            const result: { [key:string]: any} = {};
            extractedFiles.forEach((file) => {
                if (file.size > 0) {
                    const key = file.name.replace('temp', '').replace('/', '').replace('.json', '');
                    const str = file.readAsString();
                    if (key === 'model.weights.bin') {
                        return;
                    }
                    try {
                        const utf8Str = utf8.decode(str);
                        result[key] = JSON.parse(utf8Str);
                    } catch (e) {
                        console.log('no decode', key, e);
                        result[key] = JSON.parse(str);
                    }
                }
            });
            resolve(result);
        });
    });

const loadZip = async (file: File, store: any) => {
    const fileBuffer = await file.arrayBuffer();
    const { info, model, weight } = await unzipModel(fileBuffer);
    const newId = CommonUtil?.generateObjectId();
    const modelInfoJSON = { ...info };
    modelInfoJSON.id = newId;
    modelInfoJSON._id = newId;
    modelInfoJSON.uploaded = new Date();
    modelInfoJSON.isActive = true;
    let saveData = modelInfoJSON;
    if (weight) {
        if (model) {
            saveWithkeyPath(
                store.tfModel,
                { ...model, modelPath: newId }
            );
        }
        if (weight) {
            saveWithkeyPath(
                store.tfModelInfo,
                { ...weight, modelPath: newId }
            );
        }
    } else if (info && model) {
        saveData = {
            ...modelInfoJSON,
            file: model,
        };
    }
    return {
        key: newId,
        info: modelInfoJSON,
        saveData,
    };
};

function createTar(files) {
    const tar = new Tar();
    
    files.forEach(file => {
        const encoder = new TextEncoder();
        const encodedStr = encoder.encode(file.content);
        tar.append(file.name, encodedStr);
    });

    return tar.out;
}

import axios from 'axios';
import Utils from 'utils';

class CustomEntryApi {
    getModelSaveUrl = (modelId) => `/rest/learning/${modelId}`;
    getModelDownloadUrl(basePath) {
        const time = new Date().getTime();
        return `/uploads/${basePath}/model.json?${time}`;
    }

    loadModel = async ({ url }) => {
        if (url) {
            const { data } = await axios.get(url);
            return data;
        }
        throw new Error('not fully param');
    };

    async loadModels(project) {
        const param = project ? `?project=${project}` : '';
        const { data } = await axios.get(`/api/learning/models${param}`);
        return data || [];
    }
  
    saveModel = async (modelId, modelData) =>
        await axios.post(`/api/learning/${modelId}`, modelData);
    saveModelFile = async (url, formData) => {
        const { data } = await axios.post(url, formData);
        return data?.basePath;
    };
  
    async deleteModel(modelId) {
        await axios({
            url: `/rest/learning/${modelId}`,
            method: 'DELETE',
        });
    }
  
    async copyModel(modelId) {
        const { data } = await axios({
            url: `/rest/learning/copy/${modelId}`,
            method: 'POST',
        });
        return data;
    }
  
    async downloadModel(modelId) {
      	const response = await axios({
            url: `/rest/learning/download/${modelId}`,
            method: 'POST',
		        responseType: 'blob',
        });
				// response 기반으로 다운로드 로직
    }
  
    async uploadModel(data) {
        const { data: model } = await axios({
            url: '/rest/learning/upload',
            data,
            method: 'POST',
        });
        return model;
    }

    async getGroupData(modelId, groupId) {
        const { data } = await axios.get(`/api/learning/${modelId}/${groupId}`);
        return data;
    }
  
    async saveData({ projectId, classId, saveData }) {
        const { data, classes, type, recordTime } = saveData;
        let dataType = type;
        const formData = new FormData();
        formData.append('data', data);
        if (type === 'speech') {
            formData.append('recordTime', `${recordTime}`);
        }
        if (type === 'image' || type === 'speech') {
            formData.append('classes', classes);
        } else {
            formData.append('classes', JSON.stringify(classes));
        }
        if (
            [
                'regression',
                'cluster',
                'number',
                'logisticRegression',
                'decisionTree',
                'svm',
            ].includes(type)
        ) {
            dataType = 'table';
        }
        return await axios({
            url: `/rest/learning/${dataType}/${projectId}/${classId}`,
            data: formData,
            method: 'POST',
        });
    }
  
    async deleteData(key) {
        await axios({
            url: `/rest/learning/data/${key}`,
            method: 'DELETE',
        });
    }

    async _urlToFile(src, fileName, fileType) {
        const { data } = await axios.get(`${src}`, { responseType: 'blob' });
        try {
            return new File([data], fileName, { type: fileType });
        } catch {
            return data;
        }
    }

    async getImageFile({ filename = '', _id: id, data }) {
        const url = `/uploads/learning/${filename.substr(0, 2)}/${filename.substr(2, 2)}/${filename}`; 
        return await this._urlToFile(url, id, 'png');
    }

    // url?: string;
    // dataUrl?: string;
    // buffer?: ArrayBuffer
    async getSoundData({ filename = '', _id: id, data }) {
        const url = `/uploads/learning/${filename.substr(0, 2)}/${filename.substr(2, 2)}/${filename}`;
        return { url };
    }
}

export default CustomEntryApi;