Update app.py

app.py

@@ -11,6 +11,7 @@ import gradio as gr
 import pandas as pd
 import matplotlib.pyplot as plt
 from huggingface_hub import snapshot_download, hf_hub_download, HfApi
+import secrets
 
 from riichienv import RiichiEnv, GameRule
 from model3pLOCAL import load_model
@@ -24,7 +25,7 @@ HF_TOKEN = os.getenv("HF_TOKEN")
 
 # 为当前节点生成唯一的 ID
 WORKER_ID = os.getenv("WORKER_ID", str(uuid.uuid4())[:6])
-REPORT_FILE_PREFIX = 'Step40800P42998_vs_9070_eval_report'
+REPORT_FILE_PREFIX = 'Step40800P42998_vs_9070_Fair_eval_report'
 REPORT_FILE = f"{REPORT_FILE_PREFIX}_{WORKER_ID}.txt"
 
 api = HfApi()
@@ -130,36 +131,48 @@ class MortalAgent:
         return action
 
 # ==========================================
-# 2. 核心对局任务
+# 2. 核心对局任务 (复式评测：同种子 3 局轮换)
 # ==========================================
-def play_one_game(game_index):
-    env = RiichiEnv(game_mode="3p-red-half", rule=GameRule.default_tenhou())
-    new_seat = random.randrange(3)
+def play_three_games_with_seed(seed):
+    """
+    接收一个全局唯一的随机种子，让测试模型在 0, 1, 2 三个位置各打一局。
+    返回 3 局的成绩列表。
+    """
+    results = []
     
-    agents = {}
-    for i in range(3):
-        # 🚀 固定对抗：主角 1 vs 考官 2
-        model_file = TEST_MODEL if i == new_seat else EXAMINER_MODEL
-        agents[i] = MortalAgent(i, model_file)
-    
-    obs_dict = env.reset()
-    while not env.done():
-        actions = {pid: agents[pid].act(obs) for pid, obs in obs_dict.items()}
-        obs_dict = env.step(actions)
+    # 轮换测试模型的位置
+    for test_seat in range(3):
+        env = RiichiEnv(game_mode="3p-red-half", rule=GameRule.default_tenhou())
+        agents = {}
+        for i in range(3):
+            # 测试模型坐在 test_seat，其他位置是考官模型
+            model_file = TEST_MODEL if i == test_seat else EXAMINER_MODEL
+            agents[i] = MortalAgent(i, model_file)
+        
+        # 🚀 关键：注入指定的种子！这样三次循环生成的牌山是完全一致的
+        obs_dict = env.reset(seed=seed)
+        
+        while not env.done():
+            actions = {pid: agents[pid].act(obs) for pid, obs in obs_dict.items()}
+            obs_dict = env.step(actions)
+            
+        scores = env.scores()
+        ranks = env.ranks()
         
-    scores = env.scores()
-    ranks = env.ranks()
-    return ranks[new_seat], scores[new_seat]
+        # 记录测试模型在这一局的表现
+        results.append((ranks[test_seat], scores[test_seat]))
+        
+    return results
 
 # ==========================================
 # 3. 后台独立评估线程
 # ==========================================
 def background_eval_loop():
-    sync_models_from_hub() # 🚀 启动时从 Riichi-Model-Repo 拉取对战模型
-    sync_data_from_hub()   # 🚀 启动时从战绩仓库拉取历史战绩
+    sync_models_from_hub() # 启动时从 Riichi-Model-Repo 拉取对战模型
+    sync_data_from_hub()   # 启动时从战绩仓库拉取历史战绩
     
-    NUM_WORKERS = 2
-    print(f"🚀 节点 [{WORKER_ID}] 后台对战线程已启动: {TEST_MODEL} 挑战双 {EXAMINER_MODEL}")
+    NUM_WORKERS = 1 
+    print(f"🚀 节点 [{WORKER_ID}] 后台对战线程已启动: {TEST_MODEL} 挑战双 {EXAMINER_MODEL} (复式打法)")
     
     if not os.path.exists(REPORT_FILE):
         open(REPORT_FILE, 'w').close()
@@ -167,7 +180,8 @@ def background_eval_loop():
     games_since_last_sync = 0
 
     with concurrent.futures.ProcessPoolExecutor(max_workers=NUM_WORKERS) as executor:
-        futures = {executor.submit(play_one_game, i) for i in range(NUM_WORKERS * 2)}
+        # 🚀 使用 secrets.randbits(31) 生成跨节点绝对不冲突的 31 位正整数种子
+        futures = {executor.submit(play_three_games_with_seed, secrets.randbits(31)) for _ in range(NUM_WORKERS * 2)}
         games_completed = 0
         
         while EVAL_RUNNING and futures:
@@ -178,19 +192,23 @@ def background_eval_loop():
             with open(REPORT_FILE, "a") as f:
                 for future in done:
                     try:
-                        rank, score = future.result()
-                        f.write(f"{rank} {score}\n")
+                        # 现在 future.result() 返回的是包含 3 局结果的列表
+                        batch_results = future.result()
+                        for rank, score in batch_results:
+                            f.write(f"{rank} {score}\n")
+                            games_completed += 1
+                            games_since_last_sync += 1
+                            print(f"[节点 {WORKER_ID}] 完成复式对局: 顺位 {rank}, 得点 {score}")
                         f.flush()
-                        games_completed += 1
-                        games_since_last_sync += 1
-                        print(f"[节点 {WORKER_ID}] 完成 {games_completed} 局: 顺位 {rank}, 得点 {score}")
                     except Exception as e:
                         print(f"对局异常: {e}")
                     
                     if EVAL_RUNNING:
-                        futures.add(executor.submit(play_one_game, games_completed))
+                        # 完成了一轮复式，再投递一个全新的安全种子
+                        futures.add(executor.submit(play_three_games_with_seed, secrets.randbits(31)))
             
-            if games_since_last_sync >= 50:
+            # 由于一次产出 3 局，同步频率可以保持在累计完成 50 局左右时触发
+            if games_since_last_sync >= 60:
                 sync_data_to_hub()
                 sync_data_from_hub()
                 games_since_last_sync = 0
@@ -284,14 +302,7 @@ with gr.Blocks() as demo:
     
     refresh_btn.click(fn=read_and_analyze, inputs=None, outputs=[stats_output, plot_output])
 
-import multiprocessing
-
 if __name__ == "__main__":
-    # 强制使用 spawn，解决 Rust FFI 多进程死锁问题
-    multiprocessing.set_start_method('spawn', force=True)
-    
-    # 修复后，你可以安全地将 NUM_WORKERS 调大
-    # HF Space 免费层通常有 2 vCPU，可以设为 2。如果是更高配置的机器，设为 os.cpu_count() - 1
     t = threading.Thread(target=background_eval_loop, daemon=True)
     t.start()