重磅升级：全面接入阿里 Qwen2.5-0.5B-Instruct 大语言模型作为文学翻译与润色中枢，赋予文本顶级的现代可读性与自然文学语感

app.py

@@ -10,30 +10,29 @@ import threading
 torch.cuda.is_available = lambda: False
 torch.cuda.is_initialized = lambda: False
 
-from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModelForSeq2SeqLM
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
 # 1. 载入英文基座生成模型 SmolLM2-360M
 BASE_MODEL_ID = "HuggingFaceTB/SmolLM2-360M"
-print(f"正在载入 Base 模型 {BASE_MODEL_ID}...")
-tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_ID)
-model = AutoModelForCausalLM.from_pretrained(
+print(f"正在载入 Base 生成模型 {BASE_MODEL_ID}...")
+base_tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_ID)
+base_model = AutoModelForCausalLM.from_pretrained(
     BASE_MODEL_ID,
     torch_dtype=torch.float32,
     low_cpu_mem_usage=True
 )
-print("Base 模型装载完毕。")
-
-# 2. 载入 Meta 现代 6 亿参数多语言高精度互译大模型 NLLB-200-600M
-TRANS_MODEL_ID = "facebook/nllb-200-distilled-600M"
-print(f"正在载入现代多语言翻译大模型 {TRANS_MODEL_ID}...")
-trans_tokenizer = AutoTokenizer.from_pretrained(TRANS_MODEL_ID, src_lang="eng_Latn")
-trans_model = AutoModelForSeq2SeqLM.from_pretrained(
-    TRANS_MODEL_ID,
+print("Base 生成模型装载完毕。")
+
+# 2. 载入阿里顶级大语言模型 Qwen2.5-0.5B-Instruct 作为文学翻译与润色中枢
+LLM_MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+print(f"正在载入文学翻译大语言模型 {LLM_MODEL_ID}...")
+llm_tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL_ID)
+llm_model = AutoModelForCausalLM.from_pretrained(
+    LLM_MODEL_ID,
     torch_dtype=torch.float32,
     low_cpu_mem_usage=True
 )
-target_lang_id = trans_tokenizer.convert_tokens_to_ids("zho_Hans")
-print(f"NLLB-200 翻译模型装载完毕，目标语言 ID (zho_Hans): {target_lang_id}")
+print("Qwen2.5-0.5B 大语言模型翻译中枢装载完毕。")
 
 crypto_rand = random.SystemRandom()
 
@@ -66,7 +65,7 @@ BANNED_STRINGS = [
 ]
 BAD_WORDS_IDS = []
 for item in BANNED_STRINGS:
-    tokens = tokenizer.encode(item, add_special_tokens=False)
+    tokens = base_tokenizer.encode(item, add_special_tokens=False)
     if tokens:
         BAD_WORDS_IDS.append(tokens)
 
@@ -74,44 +73,63 @@ def is_code_or_junk(text: str) -> bool:
     """检测是否为代码片段、语法乱码或技术文档垃圾"""
     if not text or len(text.strip()) < 10:
         return True
-    # 匹配编程语法符号 (花括号、分号、冒号运算符、指针等)
     if re.search(r"[\{\}\;\:\=\>\<\$\#\\\_\|\&\^\~\`]{2,}", text):
         return True
-    # 匹配编程关键字
     code_keywords = r"(?i)\b(?:function|def|return|package|import|class|var|const|void|null|undefined|console|include|typeof|lambda)\b"
     if re.search(code_keywords, text):
         return True
-    # 统计标点符号与非字母比例
     special_char_count = len(re.findall(r"[\{\}\(\)\[\]\;\:\=\+\-\*\/\<\>\&\|\$\#\\]", text))
     if special_char_count / max(len(text), 1) > 0.08:
         return True
     return False
 
-def translate_to_chinese(text: str) -> str:
-    """使用 Meta NLLB-200-600M 进行高质量中英互译，天然输出标准中文标点，杜绝断层与空格"""
-    if not text or len(text.strip()) < 3:
-        return text
-    inputs = trans_tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+def translate_with_llm(english_text: str) -> str:
+    """使用阿里 Qwen2.5 大语言模型进行高质量文学翻译与润色，赋予文本极高的现代可读性与自然语感"""
+    if not english_text or len(english_text.strip()) < 3:
+        return ""
+        
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "你是一位杰出的文学翻译家。你的任务是将英文意识流文本翻译为优美、通顺、极具现代文学可读性的中文长段落。\n"
+                "翻译准则：\n"
+                "1. 语言自然通畅，多用人称代词（我、你、他们），读起来像现代小说或散文随笔；\n"
+                "2. 严禁出现机翻生硬腔、英文残留、代码符号或方括号序号；\n"
+                "3. 仅输出最终中文译文，严禁输出任何解释、附言或前后缀标记。"
+            )
+        },
+        {
+            "role": "user",
+            "content": f"请将以下英文文本翻译并润色为一段地道通顺的中文：\n\n{english_text}"
+        }
+    ]
+    
+    prompt = llm_tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = llm_tokenizer(prompt, return_tensors="pt")
+    
     with torch.no_grad():
-        translated = trans_model.generate(
+        output_ids = llm_model.generate(
             **inputs,
-            forced_bos_token_id=target_lang_id,
-            max_new_tokens=256
+            max_new_tokens=256,
+            temperature=0.65,
+            top_p=0.88,
+            repetition_penalty=1.15
         )
-    result = trans_tokenizer.batch_decode(translated, skip_special_tokens=True)[0]
-    return result.strip()
+        
+    gen_tokens = output_ids[0][inputs.input_ids.shape[1]:]
+    chinese_text = llm_tokenizer.decode(gen_tokens, skip_special_tokens=True).strip()
+    return chinese_text
 
 def clean_output(text: str) -> str:
     """去除 HTML 标签、格式序号与维基百科引用 [1], [2], [note]"""
     text = re.sub(r"</?[a-zA-Z0-9]+[^>]*>", "", text)
     text = text.replace("<|endoftext|>", "").replace("<|im_end|>", "").replace("<|im_start|>", "")
-    # 彻底清除所有 [1], [2], [note 1], [citation needed], [a] 等维基百科脚注序号
     text = re.sub(r"\[[0-9a-zA-Z\s,\.\-_:\'\"]*\]", "", text)
     text = re.sub(r"(?m)^\s*(?:[0-9]+[.\、\)]|[一二三四五六七八九十]+[、\.]|[（\(][0-9一二三四五六七八九十]+[）\)]|[①②③④⑤⑥⑦⑧⑨⑩]|(?:第[一二三四五六七八九十0-9]+[条点个部分阶段、：:]))\s*", "", text)
     text = re.sub(r"\s+[0-9]+[.\、]\s*", " ", text)
     text = re.sub(r"\n{3,}", "\n\n", text)
     
-    # 截取到最后一个完整的标点符号收尾
     match = re.search(r"[.!?。！？\n][^.!?。！？\n]*$", text)
     if match and match.start() > 20:
         text = text[:match.start() + 1]
@@ -121,15 +139,14 @@ def clean_chinese(text: str) -> str:
     """彻底清除翻译后残留的希腊字母、英文字母、特殊符号与任何方括号注记，确保 100% 纯净可读中文"""
     if not text:
         return ""
-    # 1. 彻底清除所有希腊字母（Greek & Coptic: \u0370-\u03ff, Greek Extended: \u1f00-\u1fff）
+    # 彻底清除所有希腊字母与外文字母
     text = re.sub(r"[\u0370-\u03ff\u1f00-\u1fff]+", "", text)
-    # 2. 彻底清除未翻译的英文字符与拉丁残片
     text = re.sub(r"[a-zA-Z]+", "", text)
-    # 3. 清除所有方括号、花括号、分号、项目符号与无意义杂质符号
+    # 清除所有方括号、花括号、分号、项目符号与无意义杂质符号
     text = re.sub(r"\[[^\]]*\]", "", text)
     text = re.sub(r"【[^】]*】", "", text)
     text = re.sub(r"[\[\]【】\{\}\(\)\;\:\=\+\-\*\/\<\>\&\|\$\#\\•·~_\`]+", "", text)
-    # 4. 清除汉字间多余空格与重复堆叠标点
+    # 清除多余空格与重复标点
     text = re.sub(r"\s+", "", text)
     text = re.sub(r"[。\.]{2,}", "。", text)
     text = re.sub(r"[，,]{2,}", "，", text)
@@ -137,14 +154,8 @@ def clean_chinese(text: str) -> str:
     text = re.sub(r"[？?]{2,}", "？", text)
     text = re.sub(r"^[，。！？、；：\s]+", "", text)
     text = text.strip()
-    # 确保结尾有标点
     if text and text[-1] not in ["。", "！", "？", "”", "’"]:
         text += "。"
-        
-    # 如果中文被污染为大量编程术语，直接丢弃
-    if re.search(r"(?:函数|代码|未定义|程序包|参数从查询|返回值|变量名)", text) and len(text) < 60:
-        return ""
-        
     return text
 
 # 全局同步状态
@@ -168,7 +179,7 @@ def add_server_log(msg: str):
             GLOBAL_STATE["logs"] = GLOBAL_STATE["logs"][-20:]
 
 def background_generation_loop():
-    """后台无限生成线程，确保随时有文本供应"""
+    """后台无限生成线程，确保随时有高水准文学文本供应"""
     add_server_log("后台异步生成线程已就绪，启动自回归循环...")
     
     while True:
@@ -187,9 +198,8 @@ def background_generation_loop():
             if not raw_context or len(raw_context.strip()) < 10:
                 entry = crypto_rand.choice(GREEK_DICTIONARY)
                 seed = entry.get("single_word_seed", "Χάος")
-                # 人称代词驱动器：深度激发第一人称与第二人称叙事（我、你、你们、他们）
                 starter = crypto_rand.choice([
-                    "I ", "You ", "They ", "We ", "I remember ", "You told me that ", "When they look at us, ", "I say to you that ", "You always asked me "
+                    "I remember that ", "You once told me that ", "When they looked at us, ", "I said to you that ", "You always asked me if "
                 ])
                 prompt = f"{seed}\n{starter}"
                 add_server_log(f"注入希腊词源: 《{seed}》 (代词引导: {starter.strip()})")
@@ -203,40 +213,40 @@ def background_generation_loop():
                 GLOBAL_STATE["progress"] = 35
 
             device = "cpu"
-            model.to(device)
-            inputs = tokenizer(prompt, return_tensors="pt").to(device)
+            base_model.to(device)
+            inputs = base_tokenizer(prompt, return_tensors="pt").to(device)
 
-            add_server_log("SmolLM2-360M CPU 自回归推理中 (max_new_tokens=200, temp=0.72)...")
+            add_server_log("SmolLM2-360M CPU 自回归推理中 (max_new_tokens=180, temp=0.72)...")
             with torch.no_grad():
-                output_ids = model.generate(
+                output_ids = base_model.generate(
                     **inputs,
-                    max_new_tokens=200,
+                    max_new_tokens=180,
                     do_sample=True,
                     temperature=0.72,
                     top_p=0.88,
                     repetition_penalty=1.18,
                     bad_words_ids=BAD_WORDS_IDS,
-                    pad_token_id=tokenizer.eos_token_id
+                    pad_token_id=base_tokenizer.eos_token_id
                 )
 
             with state_lock:
-                GLOBAL_STATE["current_stage"] = "TRANSLATING_NLLB200"
+                GLOBAL_STATE["current_stage"] = "TRANSLATING_QWEN_LLM"
                 GLOBAL_STATE["progress"] = 70
 
             generated_tokens = output_ids[0][inputs.input_ids.shape[1]:]
-            decoded_suffix = tokenizer.decode(generated_tokens, skip_special_tokens=True)
+            decoded_suffix = base_tokenizer.decode(generated_tokens, skip_special_tokens=True)
             raw_content = (starter + decoded_suffix) if starter else decoded_suffix
             raw_content = clean_output(raw_content)
 
             if is_code_or_junk(raw_content):
-                add_server_log("拦截到编程代码/符号垃圾，主动丢弃并重新抽取文学种子。")
+                add_server_log("拦截到代码片段或技术符号，主动丢弃并重新抽取文学种子。")
                 with state_lock:
                     if len(GLOBAL_STATE["blocks"]) > 0:
                         GLOBAL_STATE["blocks"][-1]["raw_text"] = ""
                 continue
 
-            add_server_log(f"SmolLM2 生成完毕 ({len(raw_content)} 字符)，送入 Meta NLLB-200 高精度翻译中...")
-            translated = translate_to_chinese(raw_content)
+            add_server_log(f"SmolLM2 生成完毕 ({len(raw_content)} 字符)，送入 Qwen2.5 大模型文学翻译与润色中枢...")
+            translated = translate_with_llm(raw_content)
 
             with state_lock:
                 GLOBAL_STATE["current_stage"] = "STREAM_READY"
@@ -244,7 +254,7 @@ def background_generation_loop():
 
             cleaned = clean_chinese(translated)
 
-            if not cleaned or len(cleaned) < 5:
+            if not cleaned or len(cleaned) < 10:
                 add_server_log("翻译结果为空，重置上下文准备重新生成。")
                 with state_lock:
                     if len(GLOBAL_STATE["blocks"]) > 0:
@@ -261,14 +271,14 @@ def background_generation_loop():
                     GLOBAL_STATE["blocks"].append(new_block)
                     if len(GLOBAL_STATE["blocks"]) > 30:
                         GLOBAL_STATE["blocks"] = GLOBAL_STATE["blocks"][-30:]
-                add_server_log(f"新段落就绪并发布 (字数: {len(cleaned)}): {cleaned[:24]}...")
+                add_server_log(f"高可读性文学段落就绪 (字数: {len(cleaned)}): {cleaned[:24]}...")
 
         except Exception as e:
             add_server_log(f"生成管线异常: {e}")
         finally:
             with state_lock:
                 GLOBAL_STATE["is_generating"] = False
-            # 极速流水线：仅微休 2 秒即刻启动下一段生成，彻底消除 30 秒断流卡顿
+            # 极速流水线：微休 2 秒即刻启动下一段生成
             time.sleep(2)
 
 # 启动后台引擎

requirements.txt

@@ -4,4 +4,4 @@ accelerate
 gradio
 spaces
 sentencepiece
-sacremoses
+tiktoken