mm_os 4.2.6 → 4.2.8

package/com/cmd/nlp.js

@@ -1,525 +0,0 @@
-require('mm_expand');
-const { Nlp } = require('@nlpjs/basic');
-
-/**
- * 自然语言处理类
- */
-class NLP {
-  static config = {
-    languages: ['zh', 'en'],
-    language: 'zh',
-    dir: './nlp',
-    // 模型文件
-    model: './model.nlp',
-    // 正则表达式文件
-    regex: './regex.json'
-  };
-
-  /**
-   * 构造函数
-   * @param {Object} config - 配置参数
-   */
-  constructor(config) {
-    this.config = {
-      ...NLP.config,
-      ...config
-    };
-    this._preset();
-  }
-}
-
-/**
- * 获取模型文件路径
- * @returns {string} 模型文件路径
- */
-NLP.prototype.getModelFile = function () {
-  return this.config.model.fullname(this.config.dir);
-};
-
-/**
- * 获取正则表达式文件路径
- * @returns {string} 正则表达式文件路径
- */
-NLP.prototype.getRegexFile = function () {
-  return this.config.regex.fullname(this.config.dir);
-};
-
-/**
- * 预设
- * @returns {string} 语言
- */
-NLP.prototype._preset = function () {
-  console.log('[_init] 开始初始化NLP管理器');
-  console.log('[_init] 配置:', JSON.stringify(this.config, null, 2));
-
-  // 初始化NLP管理器
-  this.nlp = new Nlp(this.config);
-  console.log('[_init] NLP管理器创建成功');
-
-  this.load();
-  console.log('[_init] 初始化完成');
-};
-
-/**
- * 加载模型
- * @param {string} model_file - 模型文件路径
- * @param {string} regex_file - 正则表达式文件路径
- */
-NLP.prototype.load = function (model_file, regex_file) {
-  this.loadRegex(regex_file);
-  this.loadModel(model_file);
-};
-
-/**
- * 加载模型
- * @param {string} file - 模型文件路径
- */
-NLP.prototype.loadModel = async function (file) {
-  let f = file || this.getModelFile();
-  console.log(`[loadModel] 加载模型文件: ${f}`);
-  let json = f.loadJson();
-  if (json) {
-    this.nlp.fromJSON(json);
-  }
-};
-
-/**
- * 加载正则表达式
- * @param {string} file - 正则表达式文件路径
- */
-NLP.prototype.loadRegex = function (file) {
-  let f = file || this.getRegexFile();
-  console.log(`[loadRegex] 加载正则表达式文件: ${f}`);
-  this.regex = f.loadJson();
-};
-
-/**
- * 保存模型
- * @param {string} model_file - 模型文件路径
- * @param {string} regex_file - 正则表达式文件路径
- */
-NLP.prototype.save = function (model_file, regex_file) {
-  console.log(`[save] 开始保存模型...`);
-  // 保存模型
-  this.saveModel(model_file);
-  console.log(`[save] 模型保存成功`);
-
-  // 保存正则表达式
-  this.saveRegex(regex_file);
-  console.log(`[save] 正则表达式保存成功`);
-};
-
-/**
- * 保存模型
- * @param {string} file - 模型文件路径
- */
-NLP.prototype.saveModel = function (file) {
-  let model = this.nlp.toJSON();
-  let f = file || this.getModelFile();
-  console.log(`[saveModel] 保存模型文件: ${f}`);
-  f.saveJson(model);
-};
-
-/**
- * 保存正则表达式
- * @param {string} file - 正则表达式文件路径
- */
-NLP.prototype.saveRegex = function (file) {
-  let f = file || this.getRegexFile();
-  console.log(`[saveRegex] 保存正则表达式文件: ${f}`);
-  f.saveJson(this.regex);
-};
-
-/**
- * 添加文档
- * @param {string} doc - 文档
- * @param {string} intent - 指令
- */
-NLP.prototype.addDocument = function (doc, intent) {
-  console.log(`[addDocument] 添加文档: "${doc}" -> "${intent}"`);
-  console.log(`[addDocument] 语言配置: ${this.config.language}`);
-
-  try {
-    // 明确指定locale
-    this.nlp.addDocument(this.config.language, doc, intent);
-    console.log(`[addDocument] 文档添加完成`);
-  } catch (error) {
-    console.log(`[addDocument] 添加文档失败:`, error.message);
-    throw error;
-  }
-};
-
-/**
- * 添加命名实体识别文本
- * @param {string} name - 命名实体名称
- * @param {string} value - 值
- * @param {Array} langs - 语言数组
- * @param {Array} values - 值数组
- */
-NLP.prototype.addNamedEntityText = function (name, value, langs, values) {
-  this.nlp.addNamedEntityText(name, value, langs, values);
-};
-
-/**
- * 处理文本
- * @param {string} text - 输入文本
- * @returns {Object} 响应对象
- */
-NLP.prototype.process = async function (text) {
-  let res = await this.nlp.process(this.config.language, text);
-  return res;
-};
-
-/**
- * 提取参数词汇
- * @param {Object} params - 参数
- * @returns {Array} 词汇数组
- */
-NLP.prototype._extractWords = function (params) {
-  let words = [];
-
-  if (!Array.isArray(params)) {
-    return words;
-  }
-
-  for (let i = 0; i < params.length; i++) {
-    let param = params[i];
-    if (!param || !param.example) {
-      continue;
-    }
-    let arr = param.example.split('；');
-    for (let n = 0; n < arr.length; n++) {
-      let text = arr[n];
-      let values = text.split('|');
-      // 提取所有值，而不仅仅是第一个
-      for (let k = 0; k < values.length; k++) {
-        let value = values[k].trim();
-        if (value) {
-          words.push({
-            name: param.name,
-            value,
-            values
-          });
-        }
-      }
-    }
-  }
-  return words;
-};
-
-/**
- * 训练文档
- * @param {string} intent - 指令
- * @param {Array} examples - 示例数组
- * @param {Array} words - 词汇数组
- */
-NLP.prototype._trainDocuments = function (intent, examples, words) {
-  if (!Array.isArray(examples)) {
-    return;
-  }
-
-  for (const tpl of examples) {
-    if (tpl.indexOf('](') === -1) {
-      let docs = this.toDocs(tpl, words);
-      for (const doc of docs) {
-        this.addDocument(doc, intent);
-      }
-    }
-    else {
-      this.addDocument(tpl, intent);
-    }
-  }
-};
-
-/**
- * 训练命名实体识别模型
- * @param {Array} words - 词汇数组
- * @param {string} lang - 语言
- */
-NLP.prototype._trainNamedEntities = function (words, lang) {
-  if (!Array.isArray(words)) {
-    return;
-  }
-
-  for (const word of words) {
-    let { name, value, values } = word;
-    this.addNamedEntityText(name, value, [lang], values);
-  }
-};
-
-/**
- * 训练模型
- * @param {string} intent - 指令，格式xxx_xxx
- * @param {string} example - 示例组
- * @param {Object} params - 参数
- */
-NLP.prototype.train = async function (intent, example, params) {
-  console.log(`[train] 开始训练模型，意图: "${intent}"`);
-  console.log(`[train] 示例组: "${example}"`);
-  console.log(`[train] 参数:`, JSON.stringify(params, null, 2));
-
-  // 参数校验
-  if (typeof intent !== 'string') {
-    throw new TypeError('指令必须是字符串');
-  }
-  if (typeof example !== 'string') {
-    throw new TypeError('示例组必须是字符串');
-  }
-  if (!Array.isArray(params)) {
-    throw new TypeError('参数必须是数组');
-  }
-
-  try {
-    let lang = this.config.language;
-    let examples = example.split('；');
-    console.log(`[train] 拆分后的示例:`, examples);
-
-    let words = this._extractWords(params);
-    console.log(`[train] 提取的词汇:`, words);
-
-    this._trainDocuments(intent, examples, words);
-    console.log(`[train] 文档训练完成`);
-
-    this._trainNamedEntities(words, lang);
-    console.log(`[train] 命名实体训练完成`);
-
-    // 训练模型
-    console.log(`[train] 开始模型训练...`);
-    try {
-      await this.nlp.train({
-        trainByDomain: false,
-        useNeural: false,
-        log: false
-      });
-      console.log(`[train] 模型训练完成`);
-    } catch (error) {
-      // 如果训练过程中出现文件保存错误，继续执行
-      if (error.message.includes('File cannot be written in web')) {
-        console.log(`[train] 模型训练完成（文件保存错误已忽略）`);
-      } else {
-        throw error;
-      }
-    }
-  } catch (error) {
-    console.log(`[train] 训练失败:`, error.message);
-    console.log(`[train] 错误堆栈:`, error.stack);
-    // 异步方法返回相应类型值，这里返回undefined
-    return undefined;
-  }
-};
-
-/**
- * 转为文档
- * @param {string} tpl - 模板
- * @param {Array} words - 词汇数组
- */
-NLP.prototype.toDocs = function (tpl, words) {
-  let docs = [tpl]; // 先添加原始模板
-
-  // 将大白话转为训练文档，例如：“我想听邓紫棋的喜欢你”转换为“我想听[邓紫棋](singer)的[喜欢你](music_name)”
-  // 正确的逻辑：模板包含value字段的词，替换为values中的词加上标注
-  
-  // 第一步：收集所有词汇的替换信息
-  let word_replacements = [];
-  
-  for (let i = 0; i < words.length; i++) {
-    let word = words[i];
-    if (!word || !word.value) continue;
-    let { name, value, values } = word;
-    
-    // 检查模板是否包含value字段的词
-    if (!tpl.includes(value)) {
-      continue;
-    }
-    
-    let replacements = [];
-    
-    // 处理每个词汇的values数组
-    for (let j = 0; j < values.length; j++) {
-      let value_str = values[j];
-      let value_arr = value_str.split('|');
-      
-      for (let k = 0; k < value_arr.length; k++) {
-        let val = value_arr[k].trim();
-        if (val) {
-          replacements.push({
-            name: name,
-            original_value: value, // 模板中实际出现的词
-            replacement_value: val, // 要替换成的词
-            replacement: `[${val}](${name})`
-          });
-        }
-      }
-    }
-    
-    if (replacements.length > 0) {
-      word_replacements.push(replacements);
-    }
-  }
-  
-  // 第二步：生成所有词汇值的笛卡尔积组合
-  if (word_replacements.length > 0) {
-    let combinations = this._generateCartesianProduct(word_replacements);
-    
-    for (let combination of combinations) {
-      let doc = tpl;
-      
-      for (let replacement of combination) {
-        // 将模板中的original_value替换为replacement
-        doc = doc.replace(replacement.original_value, replacement.replacement);
-      }
-      
-      if (!docs.includes(doc)) {
-        docs.push(doc);
-      }
-    }
-  }
-
-  return docs;
-};
-
-/**
- * 生成笛卡尔积
- * @param {Array} arrays - 输入数组的数组
- * @returns {Array} 笛卡尔积结果
- */
-NLP.prototype._generateCartesianProduct = function (arrays) {
-  if (arrays.length === 0) return [[]];
-  
-  let result = [];
-  
-  function cartesianHelper(arr, index, current) {
-    if (index === arrays.length) {
-      result.push([...current]);
-      return;
-    }
-    
-    for (let i = 0; i < arrays[index].length; i++) {
-      current.push(arrays[index][i]);
-      cartesianHelper(arr, index + 1, current);
-      current.pop();
-    }
-  }
-  
-  cartesianHelper(arrays, 0, []);
-  return result;
-};
-
-/**
- * 生成正则表达式
- * @returns {Object} 正则表达式对象
- */
-NLP.prototype.genRegex = function (examples) {
-  // 生成正则表达式
-  let regex = {};
-  for (const example of examples) {
-    let res = this.process(example);
-    let intent = res.intent;
-    if (!regex[intent]) {
-      regex[intent] = [];
-    }
-    let rules = this.buildRule(example, res);
-    regex[intent].push(...rules);
-  }
-  return regex;
-};
-
-/**
- * 构建正则表达式
- * @param {string} text - 文本
- * @param {Object} res - 处理结果
- * @returns {array} 正则表达式数组
- */
-NLP.prototype.buildRule = function (text, res) {
-  let rules = [];
-  for (const entity of res.entities) {
-    let regex =
-      rules.push({
-        // 正则表达式
-        regex,
-        // 参数名
-        props: []
-      });
-  }
-  return rules;
-};
-
-/**
- * 获取正则表达式数组
- * @returns {array} 正则表达式数组
- */
-NLP.prototype._getRegexs = function () {
-  let regexs = ['[a-zA-Z0-9_]+', '[\\u4e00-\\u9fa5]+', '[\\s\\S]+', '\\d+', '\\w+', '\\S+', '(.*)'];
-  return regexs;
-};
-
-/**
- * 获取符合的正则表达式
- * @param {string} text - 文本
- * @returns {array} 符合的正则表达式数组
- */
-NLP.prototype._extractRegexs = function (text) {
-  let regexs = this._getRegexs();
-  let arr = [];
-  for (const re of regexs) {
-    let m = text.match(re);
-    if (m) {
-      arr.push(re);
-    }
-  }
-  return arr;
-};
-
-/**
- * 通过正则表达式提取关键词
- * @param {string} regex - 正则表达式
- * @param {string} text - 文本
- * @returns {array} 关键词数组
- */
-NLP.prototype._extractKeywords = function (regex, text) {
-  let matches = text.match(regex);
-  return matches;
-};
-
-/**
- * 聊天
- * @param {string} text - 输入文本
- * @returns {Object} 响应对象
- */
-NLP.prototype.chat = async function (text) {
-  // 先尝试能否有输出
-  let res = await this.process(text);
-  // 如果没有尝试正则匹配
-  if (!res.intent) {
-    let matches = this._tryMatches(text);
-  }
-  return res;
-};
-
-/**
- * 尝试匹配正则表达式
- * @param {string} text - 文本
- * @returns {array} 符合的正则表达式数组
- */
-NLP.prototype._tryMatches = function (text) {
-  let dict = this.regex;
-  let intent = null;
-  let words = [];
-  for (const key of dict) {
-    let regexs = dict[key];
-    for (let i = 0; i < regexs.length; i++) {
-      let matches = this._extractKeywords(regexs[i], text);
-      if (matches) {
-        intent = key;
-        words.push(...matches);
-        break;
-      }
-    }
-  }
-  return {
-    intent,
-    words
-  };
-};
-
-module.exports = { NLP };