079project 6.0.0 → 8.0.0

package/tools_install.js

@@ -0,0 +1,136 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+const CNPM_CMD = process.platform === 'win32' ? 'cnpm.cmd' : 'cnpm';
+const RETRY_LIMIT = 10;
+
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    console.error('[tools_install] Usage: node tools_install.js <target-file> [-- <args...>]');
+    process.exit(1);
+}
+
+const splitIndex = args.indexOf('--');
+const targetPath = path.resolve(splitIndex === -1 ? args[0] : args[0]);
+const targetArgs = splitIndex === -1 ? args.slice(1) : args.slice(splitIndex + 1);
+
+const attemptedInstalls = new Set();
+let retryCount = 0;
+
+function runTarget() {
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [targetPath, ...targetArgs], {
+            stdio: 'inherit'
+        });
+        child.on('exit', (code) => {
+            resolve({ code, signal: null });
+        });
+        child.on('error', (err) => {
+            console.error('[tools_install] Failed to start target process:', err.message);
+            resolve({ code: 1, signal: 'spawn-error' });
+        });
+    });
+}
+
+function parseMissingModule(stderrText) {
+    const regex = /Error: Cannot find module '([^']+)'/;
+    const match = regex.exec(stderrText);
+    if (match && match[1]) {
+        const moduleName = match[1];
+        if (moduleName.startsWith('.') || moduleName.startsWith('/')) {
+            return null;
+        }
+        return moduleName;
+    }
+    return null;
+}
+
+function installDependency(moduleName) {
+    return new Promise((resolve) => {
+        console.log(`[tools_install] Installing missing dependency: ${moduleName}`);
+        const installer = spawn(CNPM_CMD, ['install', moduleName], {
+            stdio: 'inherit',
+            shell: process.platform === 'win32'
+        });
+        installer.on('exit', (code) => {
+            if (code === 0) {
+                console.log(`[tools_install] Installed ${moduleName} successfully.`);
+                resolve(true);
+            } else {
+                console.error(`[tools_install] Failed to install ${moduleName} (exit code ${code}).`);
+                resolve(false);
+            }
+        });
+        installer.on('error', (err) => {
+            console.error('[tools_install] Failed to launch cnpm:', err.message);
+            if (err.code === 'ENOENT' || err.code === 'EINVAL') {
+                console.error('[tools_install] Hint: install cnpm globally via "npm install -g cnpm --registry=https://registry.npmmirror.com"');
+            }
+            resolve(false);
+        });
+    });
+}
+
+async function main() {
+    while (retryCount <= RETRY_LIMIT) {
+        const child = spawn(process.execPath, [targetPath, ...targetArgs], {
+            stdio: ['inherit', 'pipe', 'pipe']
+        });
+
+        let stderrBuffer = '';
+        child.stderr.on('data', (chunk) => {
+            const text = chunk.toString();
+            stderrBuffer += text;
+            process.stderr.write(chunk);
+        });
+        child.stdout.on('data', (chunk) => {
+            process.stdout.write(chunk);
+        });
+
+        const { code, missingModule } = await new Promise((resolve) => {
+            child.on('exit', (exitCode) => {
+                resolve({ code: exitCode, missingModule: parseMissingModule(stderrBuffer) });
+            });
+            child.on('error', (err) => {
+                console.error('[tools_install] Target process error:', err.message);
+                resolve({ code: 1, missingModule: null });
+            });
+        });
+
+        if (code === 0) {
+            process.exit(0);
+        }
+
+        if (!missingModule) {
+            console.error(`[tools_install] Target exited with code ${code}. No missing module detected.`);
+            process.exit(code || 1);
+        }
+
+        if (attemptedInstalls.has(missingModule)) {
+            console.error(`[tools_install] Already attempted to install ${missingModule}. Aborting.`);
+            process.exit(code || 1);
+        }
+
+        if (retryCount >= RETRY_LIMIT) {
+            console.error('[tools_install] Retry limit reached. Aborting.');
+            process.exit(code || 1);
+        }
+
+        attemptedInstalls.add(missingModule);
+        retryCount += 1;
+        const success = await installDependency(missingModule);
+        if (!success) {
+            process.exit(1);
+        }
+    }
+
+    console.error('[tools_install] Exceeded retry loop unexpectedly.');
+    process.exit(1);
+}
+
+main().catch((err) => {
+    console.error('[tools_install] Fatal error:', err);
+    process.exit(1);
+});

package/model_RNN.py

@@ -1,209 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import numpy as np
-from flask import Flask, request, jsonify
-from tensorflow.keras.models import Model, load_model
-from tensorflow.keras.layers import Input, Embedding, LSTM, Dense
-from tensorflow.keras.preprocessing.text import Tokenizer
-from tensorflow.keras.preprocessing.sequence import pad_sequences
-import random
-import json
-import re
-import glob
-import time
-
-app = Flask(__name__)
-
-# 模型与分词器保存路径
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-MODEL_PATH = os.path.join(BASE_DIR, 'serializer_seq2seq.h5')
-TOKENIZER_PATH = os.path.join(BASE_DIR, 'tokenizer.json')
-
-# 语料目录（可用环境变量覆盖），默认使用当前目录下 robots/
-ROBOTS_DIR = os.environ.get('ROBOTS_DIR', os.path.join(BASE_DIR, 'robots'))
-
-# 超参（可外部环境变量覆盖）
-max_words = int(os.environ.get('MAX_WORDS', '5000'))
-max_len = int(os.environ.get('MAX_LEN', '12'))
-embedding_dim = int(os.environ.get('EMB_DIM', '64'))
-lstm_units = int(os.environ.get('LSTM_UNITS', '64'))
-epochs = int(os.environ.get('EPOCHS', '40'))
-batch_size = int(os.environ.get('BATCH_SIZE', '32'))
-max_files = int(os.environ.get('MAX_FILES', '64'))
-max_lines = int(os.environ.get('MAX_LINES', '800'))
-min_line_len = int(os.environ.get('MIN_LINE_LEN', '6'))
-force_retrain = os.environ.get('FORCE_RETRAIN', '0') == '1'
-
-random.seed(42)
-
-def clean_line(s: str) -> str:
-    if not s:
-        return ''
-    s = s.strip()
-    # 去掉URL、重复空格、控制字符
-    s = re.sub(r'https?://\S+', ' ', s)
-    s = re.sub(r'[\t\r\n]+', ' ', s)
-    s = re.sub(r'\s{2,}', ' ', s)
-    # 限长
-    if len(s) > 256:
-        s = s[:256]
-    return s.strip()
-
-def load_corpus(robots_dir: str):
-    if not os.path.isdir(robots_dir):
-        print(f'[CORPUS] 目录不存在: {robots_dir}')
-        return []
-    files = sorted(glob.glob(os.path.join(robots_dir, '*.txt')))[:max_files]
-    lines = []
-    for fp in files:
-        try:
-            with open(fp, 'r', encoding='utf-8', errors='ignore') as f:
-                for ln in f:
-                    if len(lines) >= max_lines:
-                        break
-                    ln = clean_line(ln)
-                    if len(ln) >= min_line_len:
-                        lines.append(ln)
-        except Exception as e:
-            print(f'[CORPUS] 读取失败 {fp}: {e}')
-        if len(lines) >= max_lines:
-            break
-    print(f'[CORPUS] 收集行数: {len(lines)} (files={len(files)})')
-    return lines
-
-def make_pairs(sentences):
-    pairs_in = []
-    pairs_out = []
-    for s in sentences:
-        toks = s.split()
-        if len(toks) == 0:
-            continue
-        shuffled = toks[:]
-        random.shuffle(shuffled)
-        pairs_in.append(' '.join(shuffled))
-        pairs_out.append(' '.join(toks))
-    return pairs_in, pairs_out
-
-def build_or_load_tokenizer(inputs, outputs):
-    if os.path.exists(TOKENIZER_PATH) and not force_retrain:
-        try:
-            with open(TOKENIZER_PATH, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-            tokenizer = Tokenizer.from_json(json.dumps(data))
-            print('[TOKENIZER] 已加载现有 tokenizer')
-            return tokenizer
-        except Exception as e:
-            print('[TOKENIZER] 加载失败, 重新创建:', e)
-
-    tokenizer = Tokenizer(num_words=max_words, filters='', lower=True, oov_token='<UNK>')
-    tokenizer.fit_on_texts(inputs + outputs)
-    with open(TOKENIZER_PATH, 'w', encoding='utf-8') as f:
-        f.write(tokenizer.to_json())
-    print('[TOKENIZER] 已创建并保存')
-    return tokenizer
-
-def prepare_sequences(tokenizer, inputs, outputs):
-    X = tokenizer.texts_to_sequences(inputs)
-    Y = tokenizer.texts_to_sequences(outputs)
-    X = pad_sequences(X, maxlen=max_len, padding='post')
-    Y = pad_sequences(Y, maxlen=max_len, padding='post')
-    return X, Y
-
-def build_model(vocab_size):
-    encoder_inputs = Input(shape=(max_len,))
-    x = Embedding(vocab_size, embedding_dim, mask_zero=True)(encoder_inputs)
-    encoder_outputs, state_h, state_c = LSTM(lstm_units, return_state=True)(x)
-    encoder_states = [state_h, state_c]
-
-    decoder_inputs = Input(shape=(max_len,))
-    y = Embedding(vocab_size, embedding_dim, mask_zero=True)(decoder_inputs)
-    decoder_lstm = LSTM(lstm_units, return_sequences=True, return_state=True)
-    decoder_outputs, _, _ = decoder_lstm(y, initial_state=encoder_states)
-    decoder_dense = Dense(vocab_size, activation='softmax')
-    decoder_outputs = decoder_dense(decoder_outputs)
-
-    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
-    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
-    return model
-
-def train_if_needed():
-    # 加载语料
-    sentences = load_corpus(ROBOTS_DIR)
-    if not sentences:
-        # 回退到简单句子
-        sentences = [
-            "i am a person",
-            "you are a student",
-            "he is a teacher",
-            "she is my friend",
-            "this is a book",
-            "we are happy",
-            "they are here",
-            "it is raining",
-            "the cat is black"
-        ]
-        print('[CORPUS] 使用内置 fallback 语料')
-
-    inputs, outputs = make_pairs(sentences)
-    tokenizer = build_or_load_tokenizer(inputs, outputs)
-    X, Y = prepare_sequences(tokenizer, inputs, outputs)
-    vocab_size = len(tokenizer.word_index) + 1
-
-    # 如果模型存在且不强制重训 => 直接加载
-    if os.path.exists(MODEL_PATH) and not force_retrain:
-        print('[MODEL] 加载现有模型:', MODEL_PATH)
-        model = load_model(MODEL_PATH)
-        return model, tokenizer
-
-    print('[MODEL] 训练新模型...')
-    model = build_model(vocab_size)
-
-    decoder_input_data = np.zeros_like(Y)
-    decoder_input_data[:, 1:] = Y[:, :-1]
-    decoder_target_data = np.expand_dims(Y, -1)
-
-    model.fit(
-        [X, decoder_input_data],
-        decoder_target_data,
-        batch_size=batch_size,
-        epochs=epochs,
-        verbose=2
-    )
-    model.save(MODEL_PATH)
-    print('[MODEL] 训练完成并保存')
-    return model, tokenizer
-
-model, tokenizer = train_if_needed()
-print('[READY] 模型 & tokenizer 就绪')
-
-def predict_sequence(input_words):
-    seq = tokenizer.texts_to_sequences([' '.join(input_words)])[0]
-    seq = pad_sequences([seq], maxlen=max_len, padding='post')
-    decoder_input = np.zeros((1, max_len), dtype='int32')
-    output_sentence = []
-    for i in range(max_len):
-        preds = model.predict([seq, decoder_input], verbose=0)
-        next_token = np.argmax(preds[0, i])
-        if next_token == 0:
-            break
-        w = tokenizer.index_word.get(next_token, '')
-        if w and w not in output_sentence:
-            output_sentence.append(w)
-        decoder_input[0, i] = next_token
-    return ' '.join(output_sentence).strip()
-
-@app.route('/api/serialize', methods=['POST'])
-def serialize():
-    data = request.json
-    words = data.get('words')
-    if not words or not isinstance(words, list):
-        return jsonify({'error': 'words must be a list'}), 400
-    sentence = predict_sequence(words)
-    return jsonify({'sentence': sentence})
-
-@app.route('/health', methods=['GET'])
-def health():
-    return jsonify({'ok': True, 'time': time.time()})
-
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=5008)