Upload 7 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+libriichi3p.so filter=lfs diff=lfs merge=lfs -text
+libriichiSanma.so filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,29 @@
+# 1. 使用轻量级的 Python 3.10 基础镜像
+FROM python:3.12-slim
+
+# 2. 设置环境变量，防止 python 缓冲 stdout 导致日志延迟
+ENV PYTHONUNBUFFERED=1
+
+# 3. [针对 Hugging Face 空间的特殊设置] 
+# 创建一个非 root 用户 user，UID 设置为 1000
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# 4. 设置工作目录
+WORKDIR /app
+
+# 5. 复制 requirements.txt 并安装依赖
+# (先复制这个文件可以利用 Docker 的缓存机制，加快后续构建速度)
+COPY --chown=user:user requirements.txt /app/
+# 强烈建议安装 CPU 版本的 PyTorch 以大幅缩减镜像体积
+RUN pip install --no-cache-dir --extra-index-url https://download.pytorch.org/whl/cpu -r requirements.txt
+
+# 6. 复制所有项目文件到工作目录下
+COPY --chown=user:user . /app/
+
+# 7. 暴露 Gradio 默认端口
+EXPOSE 7860
+
+# 8. 启动应用
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,330 @@
+import os
+import orjson
+import concurrent.futures
+import random
+import torch
+import threading
+import time
+import uuid
+import glob
+import gradio as gr
+import pandas as pd
+import matplotlib.pyplot as plt
+from huggingface_hub import snapshot_download, hf_hub_download, HfApi
+
+from riichienv import RiichiEnv, GameRule
+
+# 分别导入两个不同架构的加载函数，防止命名冲突
+from model3pLOCAL import load_model as load_model_local
+from model3pNEW import load_model as load_model_new
+
+# ==========================================
+# 0. 核心对抗配置开关 (在这里切换模式)
+# ==========================================
+# True: 1个 NEW架构(TEST_MODEL) VS 2个 LOCAL架构(EXAMINER_MODEL)
+# False: 1个 LOCAL架构(TEST_MODEL) VS 2个 NEW架构(EXAMINER_MODEL)
+ONE_NEW_VS_TWO_LOCAL = True  
+
+# ==========================================
+# 0. 分布式多开与云端持久化配置
+# ==========================================
+DATA_REPO_ID = "ffzeroHua/mj-eval-results"  # 📊 战绩数据集仓库
+MODEL_REPO_ID = "ffzeroHua/Riichi-Model-Repo" # 🧠 模型权重仓库
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+# 为当前节点生成唯一的 ID
+WORKER_ID = os.getenv("WORKER_ID", str(uuid.uuid4())[:6])
+
+# 根据开关状态自动调整保存的文件前缀
+BASE_REPORT_PREFIX = 'Step40800P42998_vs_9070_eval_report'
+if ONE_NEW_VS_TWO_LOCAL:
+    REPORT_FILE_PREFIX = BASE_REPORT_PREFIX
+else:
+    REPORT_FILE_PREFIX = f"inverse_{BASE_REPORT_PREFIX}"
+
+REPORT_FILE = f"{REPORT_FILE_PREFIX}_{WORKER_ID}.txt"
+
+api = HfApi()
+EVAL_RUNNING = True
+
+# 🚀 设定要从云端拉取并进行对抗的两个模型
+TEST_MODEL = "Elite3P_Step40800_P42998.pth"
+EXAMINER_MODEL = "Elite4z9070.pth"
+
+def sync_models_from_hub():
+    """启动时从指定的模型仓库拉取对战双方的权重文件"""
+    if HF_TOKEN and "你的用户名" not in MODEL_REPO_ID:
+        print(f"☁️ 正在从模型仓库 [{MODEL_REPO_ID}] 拉取评估模型...")
+        try:
+            hf_hub_download(repo_id=MODEL_REPO_ID, filename=TEST_MODEL, repo_type="model", local_dir=".", token=HF_TOKEN)
+            print(f"✅ 成功拉取测试模型: {TEST_MODEL}")
+            
+            hf_hub_download(repo_id=MODEL_REPO_ID, filename=EXAMINER_MODEL, repo_type="model", local_dir=".", token=HF_TOKEN)
+            print(f"✅ 成功拉取考官模型: {EXAMINER_MODEL}")
+            
+            print("🎉 模型环境准备完毕！")
+        except Exception as e:
+            print(f"❌ 拉取模型失败，请检查文件名或仓库权限: {e}")
+    else:
+        print("⚠️ 未配置有效 HF_TOKEN 或未修改 MODEL_REPO_ID，将尝试使用本地已存在的模型文件。")
+
+def sync_data_from_hub():
+    """启动时从数据集下载所有节点的战绩分片文件"""
+    if HF_TOKEN and "你的用户名" not in DATA_REPO_ID:
+        try:
+            print(f"🔄 正在从 Hub 拉取全局历史战绩数据 (前缀匹配: {REPORT_FILE_PREFIX})...")
+            snapshot_download(
+                repo_id=DATA_REPO_ID,
+                repo_type="dataset",
+                local_dir=".",
+                allow_patterns=REPORT_FILE_PREFIX + "_*.txt",
+                token=HF_TOKEN
+            )
+            print("✅ 历史数据拉取完成。")
+        except Exception as e:
+            print(f"⚠️ 拉取历史战绩失败: {e}")
+
+def sync_data_to_hub():
+    """将当前节点的战绩文件备份到数据集"""
+    if HF_TOKEN and "你的用户名" not in DATA_REPO_ID:
+        try:
+            api.upload_file(
+                path_or_fileobj=REPORT_FILE,
+                path_in_repo=REPORT_FILE,
+                repo_id=DATA_REPO_ID,
+                repo_type="dataset",
+                token=HF_TOKEN
+            )
+            print(f"☁️ 节点 {WORKER_ID} 战绩已同步至 Hub: {time.strftime('%H:%M:%S')}")
+        except Exception as e:
+            print(f"❌ 同步失败: {e}")
+
+# ==========================================
+# 1. 高频及模型加载逻辑
+# ==========================================
+def patch_event_fast(event_str):
+    if '"kita"' in event_str:
+        event_str = event_str.replace('"kita"', '"nukidora"')
+    
+    if '"start_kyoku"' in event_str or '"deltas"' in event_str:
+        event = orjson.loads(event_str)
+        if event.get('type') == 'start_kyoku':
+            scores = event.setdefault('scores', [])
+            while len(scores) < 4: scores.append(0)
+            tehais = event.setdefault('tehais', [])
+            while len(tehais) < 4: tehais.append(["?" for _ in range(13)])
+        if 'deltas' in event:
+            deltas = event['deltas']
+            while len(deltas) < 4: deltas.append(0)
+        return orjson.dumps(event).decode('utf-8')
+    return event_str
+
+def patch_resp_fast(resp_str):
+    if not resp_str: return resp_str
+    return resp_str.replace('"nukidora"', '"kita"')
+
+_MODEL_CACHE = {}
+
+def get_cached_model(player_id: int, model_file: str, arch_type: str):
+    """根据指定的架构类型 (new 或 local) 加载模型"""
+    key = (player_id, model_file, arch_type)
+    if key not in _MODEL_CACHE:
+        torch.set_num_threads(1) 
+        if arch_type == 'new':
+            _MODEL_CACHE[key] = load_model_new(player_id, model_file)
+        else:
+            _MODEL_CACHE[key] = load_model_local(player_id, model_file)
+    return _MODEL_CACHE[key]
+
+class MortalAgent:
+    def __init__(self, player_id: int, model_file: str, arch_type: str):
+        self.player_id = player_id
+        self.arch_type = arch_type
+        self.model = get_cached_model(player_id, model_file, arch_type)
+
+    def act(self, obs):
+        resp = None
+        for event in obs.new_events():
+            event_patched = patch_event_fast(event)
+            resp = patch_resp_fast(self.model.react(event_patched))
+        action = obs.select_action_from_mjai(resp)
+        assert action is not None, "Mortal must return a legal action"
+        return action
+
+# ==========================================
+# 2. 核心对局任务
+# ==========================================
+def play_one_game(game_index):
+    env = RiichiEnv(game_mode="3p-red-half", rule=GameRule.default_tenhou())
+    new_seat = random.randrange(3)
+    
+    agents = {}
+    for i in range(3):
+        if i == new_seat:
+            # 🚀 挑战者位
+            model_file = TEST_MODEL
+            arch = 'new' if ONE_NEW_VS_TWO_LOCAL else 'local'
+        else:
+            # 🚀 考官位
+            model_file = EXAMINER_MODEL
+            arch = 'local' if ONE_NEW_VS_TWO_LOCAL else 'new'
+            
+        agents[i] = MortalAgent(i, model_file, arch)
+    
+    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)
+        
+    scores = env.scores()
+    ranks = env.ranks()
+    return ranks[new_seat], scores[new_seat]
+
+# ==========================================
+# 3. 后台独立评估线程
+# ==========================================
+def background_eval_loop():
+    sync_models_from_hub() # 🚀 启动时从 Riichi-Model-Repo 拉取对战模型
+    sync_data_from_hub()   # 🚀 启动时从战绩仓库拉取历史战绩
+    
+    NUM_WORKERS = 1 
+    
+    mode_str = "1只 NEW 挑战 2只 LOCAL" if ONE_NEW_VS_TWO_LOCAL else "1只 LOCAL 挑战 2只 NEW"
+    print(f"🚀 节点 [{WORKER_ID}] 后台对战线程已启动: 模式为 [{mode_str}]")
+    
+    if not os.path.exists(REPORT_FILE):
+        open(REPORT_FILE, 'w').close()
+
+    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)}
+        games_completed = 0
+        
+        while EVAL_RUNNING and futures:
+            done, futures = concurrent.futures.wait(
+                futures, return_when=concurrent.futures.FIRST_COMPLETED
+            )
+            
+            with open(REPORT_FILE, "a") as f:
+                for future in done:
+                    try:
+                        rank, score = future.result()
+                        f.write(f"{rank} {score}\n")
+                        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))
+            
+            if games_since_last_sync >= 50:
+                sync_data_to_hub()
+                sync_data_from_hub()
+                games_since_last_sync = 0
+
+# ==========================================
+# 4. 前端 Gradio 实时展示面板 (全局汇总)
+# ==========================================
+def read_and_analyze():
+    all_files = glob.glob(f"{REPORT_FILE_PREFIX}_*.txt")
+    
+    main_arch = "NEW架构" if ONE_NEW_VS_TWO_LOCAL else "LOCAL架构"
+    opp_arch = "LOCAL架构" if ONE_NEW_VS_TWO_LOCAL else "NEW架构"
+    
+    if not all_files:
+        return f"⏳ 正在拉取模型并等待 [{main_arch}] `{TEST_MODEL}` VS [{opp_arch}] `{EXAMINER_MODEL}` 第一局完成...", None
+    
+    ranks, scores = [], []
+    try:
+        for file in all_files:
+            with open(file, "r") as f:
+                lines = f.readlines()
+                for line in lines:
+                    parts = line.strip().split()
+                    if len(parts) == 2:
+                        ranks.append(int(float(parts[0])))
+                        scores.append(float(parts[1]))
+        total = len(ranks)
+        if total == 0:
+            return f"⏳ 模型已就绪，正在进行第一局对抗...", None
+
+        avg_rank = sum(ranks) / total
+        avg_score = sum(scores) / total
+        rank1_rate = ranks.count(1) / total * 100
+        rank2_rate = ranks.count(2) / total * 100
+        rank3_rate = ranks.count(3) / total * 100
+
+        last_update = time.strftime('%Y-%m-%d %H:%M:%S')
+
+        md_text = f"""
+        ### 📊 对战简报
+        - ⚔️ **对抗阵容:** 1只 `{TEST_MODEL}` ({main_arch}) **VS** 2只 `{EXAMINER_MODEL}` ({opp_arch})
+        - 🧮 **总对局数:** {total} 局 (跨节点全局汇集)
+        - 🏆 **平均顺位:** {avg_rank:.3f}
+        - 💰 **平均得点:** {avg_score:.0f}
+        ---
+        - 🥇 **一位率:** {rank1_rate:.1f}%
+        - 🥈 **二位率:** {rank2_rate:.1f}%
+        - 🥉 **三位率:** {rank3_rate:.1f}%
+        ---
+        - 🌐 **当前节点 ID:** `{WORKER_ID}`
+        - 🕒 **刷新时间:** {last_update}
+        """
+
+        fig = plt.figure(figsize=(10, 4))
+        
+        ax1 = fig.add_subplot(121)
+        ax1.bar(['1st', '2nd', '3rd'], [rank1_rate, rank2_rate, rank3_rate], color=['#FFD700', '#C0C0C0', '#CD7F32'])
+        ax1.set_title(f'Rank Distribution for {TEST_MODEL}')
+        ax1.set_ylim(0, max(100, max([rank1_rate, rank2_rate, rank3_rate] + [0]) + 10))
+        for i, v in enumerate([rank1_rate, rank2_rate, rank3_rate]):
+            ax1.text(i, v + 2, f"{v:.1f}%", ha='center')
+
+        ax2 = fig.add_subplot(122)
+        df = pd.DataFrame({'score': scores})
+        df['ma'] = df['score'].rolling(window=min(10, max(1, len(df))), min_periods=1).mean()
+        ax2.plot(df['score'], alpha=0.3, color='gray', label='Raw Score')
+        ax2.plot(df['ma'], color='crimson', linewidth=2, label='Moving Avg (10)')
+        ax2.set_title('Score Trend')
+        ax2.legend()
+
+        plt.tight_layout()
+        return md_text, fig
+        
+    except Exception as e:
+        return f"❌ 数据解析出错: {e}", None
+
+# ==========================================
+# 5. 启动 Gradio 应用
+# ==========================================
+with gr.Blocks() as demo:
+    gr.Markdown("# 🀄 Mahjong AI 基准评估舱")
+    
+    header_main = "NEW架构" if ONE_NEW_VS_TWO_LOCAL else "LOCAL架构"
+    header_opp = "LOCAL架构" if ONE_NEW_VS_TWO_LOCAL else "NEW架构"
+    
+    gr.Markdown(f"当前正在评估: 1名 **{TEST_MODEL} ({header_main})** 单挑 2名 **{EXAMINER_MODEL} ({header_opp})**。启动时会自动拉取权重。")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            stats_output = gr.Markdown("🚀 正在初始化基准环境并连接模型仓库...")
+            refresh_btn = gr.Button("🔄 手动刷新全局战绩")
+        with gr.Column(scale=2):
+            plot_output = gr.Plot()
+
+    demo.load(fn=read_and_analyze, inputs=None, outputs=[stats_output, plot_output])
+    
+    timer = gr.Timer(15)
+    timer.tick(fn=read_and_analyze, inputs=None, outputs=[stats_output, plot_output])
+    
+    refresh_btn.click(fn=read_and_analyze, inputs=None, outputs=[stats_output, plot_output])
+
+if __name__ == "__main__":
+    t = threading.Thread(target=background_eval_loop, daemon=True)
+    t.start()
+    
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, theme=gr.themes.Soft())

libriichi3p.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03900834051021f662fec35c6e9608f4d4c5aa61b4c4ce37b49fa2e861bf619b
+size 1873424

libriichiSanma.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c35adaace110bde0dc896f742b1e1b3ad50213cf7dbafb858a774e46f5b5cf32
+size 3631184

model3pLOCAL.py

@@ -0,0 +1,452 @@
+import json
+import gzip
+import torch
+import pathlib
+import requests
+import traceback
+import numpy as np
+
+from torch import nn, Tensor
+from torch.nn import functional as F
+from torch.nn.utils.rnn import pack_padded_sequence, pad_sequence
+from torch.distributions import Normal, Categorical
+from typing import *
+from functools import partial
+from itertools import permutations
+try:
+    from libriichi3p.mjai import Bot
+    from libriichi3p.consts import obs_shape, oracle_obs_shape, ACTION_SPACE, GRP_SIZE
+except:
+    import importlib.util
+    import sys
+    import os
+
+    # ⚠️ 这里必须填入你在 Colab 中的绝对路径！
+    # 假设你的文件在云盘的 MahjongTest 文件夹下，名字叫 libriichi3p.so
+    # 如果你的文件叫别的名字，或者在别的文件夹，请务必修改这行路径
+    SO_FILE_PATH = "/content/drive/MyDrive/MahjongTest/libriichi3p.so"
+
+    # 1. 检查文件到底存不存在
+    if not os.path.exists(SO_FILE_PATH):
+        print(f"❌ 致命错误：在路径 {SO_FILE_PATH} 下根本找不到文件！请检查路径拼写。")
+    else:
+        print(f"✅ 找到文件: {SO_FILE_PATH}，正在尝试强行加载...")
+        
+        try:
+            # 2. 根据绝对路径创建模块加载规范 (spec)
+            # 第一个参数是你想给它起的名字（供 Python 内部识别），第二个参数是文件路径
+            spec = importlib.util.spec_from_file_location("libriichi3p", SO_FILE_PATH)
+            
+            # 3. 实例化模块
+            libriichi3p_module = importlib.util.module_from_spec(spec)
+            
+            # 4. 注册到系统的模块字典里 (非常重要！这样后续其他文件 import libriichi3p 就能直接用)
+            sys.modules["libriichi3p"] = libriichi3p_module
+            
+            # 5. 执行底层代码加载
+            spec.loader.exec_module(libriichi3p_module)
+            
+            print("🎉 强行导入成功！现在可以在代码里正常使用了。")
+            
+        except Exception as e:
+            print(f"❌ 导入失败，暴露出真实报错: {e}")
+# ========== Online Server =========== #
+OT_REQUEST_TIMEOUT = 2
+ot_settings = {
+    "server": "http://example.com",
+    "online": False,
+    "api_key": "example_api_key",
+}
+is_online = False
+
+def online_settings_init():
+    global ot_settings
+    # Check if the file exists
+    if (pathlib.Path(__file__).parent / 'ot_settings.json').exists():
+        with open(pathlib.Path(__file__).parent / 'ot_settings.json', 'r') as f:
+            ot_settings = json.load(f)
+
+online_settings_init()
+# ==================================== #
+
+class ChannelAttention(nn.Module):
+    def __init__(self, channels, ratio=16, actv_builder=nn.ReLU, bias=True):
+        super().__init__()
+        self.shared_mlp = nn.Sequential(
+            nn.Linear(channels, channels // ratio, bias=bias),
+            actv_builder(),
+            nn.Linear(channels // ratio, channels, bias=bias),
+        )
+        if bias:
+            for mod in self.modules():
+                if isinstance(mod, nn.Linear):
+                    nn.init.constant_(mod.bias, 0)
+
+    def forward(self, x: Tensor):
+        avg_out = self.shared_mlp(x.mean(-1))
+        max_out = self.shared_mlp(x.amax(-1))
+        weight = (avg_out + max_out).sigmoid()
+        x = weight.unsqueeze(-1) * x
+        return x
+
+class ResBlock(nn.Module):
+    def __init__(
+        self,
+        channels,
+        *,
+        norm_builder = nn.Identity,
+        actv_builder = nn.ReLU,
+        pre_actv = False,
+    ):
+        super().__init__()
+        self.pre_actv = pre_actv
+
+        if pre_actv:
+            self.res_unit = nn.Sequential(
+                norm_builder(),
+                actv_builder(),
+                nn.Conv1d(channels, channels, kernel_size=3, padding=1, bias=False),
+                norm_builder(),
+                actv_builder(),
+                nn.Conv1d(channels, channels, kernel_size=3, padding=1, bias=False),
+            )
+        else:
+            self.res_unit = nn.Sequential(
+                nn.Conv1d(channels, channels, kernel_size=3, padding=1, bias=False),
+                norm_builder(),
+                actv_builder(),
+                nn.Conv1d(channels, channels, kernel_size=3, padding=1, bias=False),
+                norm_builder(),
+            )
+            self.actv = actv_builder()
+        self.ca = ChannelAttention(channels, actv_builder=actv_builder, bias=True)
+
+    def forward(self, x):
+        out = self.res_unit(x)
+        out = self.ca(out)
+        out = out + x
+        if not self.pre_actv:
+            out = self.actv(out)
+        return out
+
+class ResNet(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        conv_channels,
+        num_blocks,
+        *,
+        norm_builder = nn.Identity,
+        actv_builder = nn.ReLU,
+        pre_actv = False,
+    ):
+        super().__init__()
+
+        blocks = []
+        for _ in range(num_blocks):
+            blocks.append(ResBlock(
+                conv_channels,
+                norm_builder = norm_builder,
+                actv_builder = actv_builder,
+                pre_actv = pre_actv,
+            ))
+
+        layers = [nn.Conv1d(in_channels, conv_channels, kernel_size=3, padding=1, bias=False)]
+        if pre_actv:
+            layers += [*blocks, norm_builder(), actv_builder()]
+        else:
+            layers += [norm_builder(), actv_builder(), *blocks]
+        layers += [
+            nn.Conv1d(conv_channels, 32, kernel_size=3, padding=1),
+            actv_builder(),
+            nn.Flatten(),
+            nn.Linear(32 * 34, 1024),
+        ]
+        self.net = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.net(x)
+
+class Brain(nn.Module):
+    def __init__(self, *, conv_channels, num_blocks, is_oracle=False, version=1):
+        super().__init__()
+        self.is_oracle = is_oracle
+        self.version = version
+
+        in_channels = obs_shape(version)[0]
+        if is_oracle:
+            in_channels += oracle_obs_shape(version)[0]
+
+        norm_builder = partial(nn.BatchNorm1d, conv_channels, momentum=0.01)
+        actv_builder = partial(nn.Mish, inplace=True)
+        pre_actv = True
+
+        match version:
+            case 1:
+                actv_builder = partial(nn.ReLU, inplace=True)
+                pre_actv = False
+                self.latent_net = nn.Sequential(
+                    nn.Linear(1024, 512),
+                    nn.ReLU(inplace=True),
+                )
+                self.mu_head = nn.Linear(512, 512)
+                self.logsig_head = nn.Linear(512, 512)
+            case 2:
+                pass
+            case 3 | 4:
+                norm_builder = partial(nn.BatchNorm1d, conv_channels, momentum=0.01, eps=1e-3)
+            case _:
+                raise ValueError(f'Unexpected version {self.version}')
+
+        self.encoder = ResNet(
+            in_channels = in_channels,
+            conv_channels = conv_channels,
+            num_blocks = num_blocks,
+            norm_builder = norm_builder,
+            actv_builder = actv_builder,
+            pre_actv = pre_actv,
+        )
+        self.actv = actv_builder()
+
+        # always use EMA or CMA when True
+        self._freeze_bn = False
+
+    def forward(self, obs: Tensor, invisible_obs: Optional[Tensor] = None) -> Union[Tuple[Tensor, Tensor], Tensor]:
+        if self.is_oracle:
+            assert invisible_obs is not None
+            obs = torch.cat((obs, invisible_obs), dim=1)
+        phi = self.encoder(obs)
+        phi = F.dropout(phi, p=0.1, training=self.training)
+        match self.version:
+            case 1:
+                latent_out = self.latent_net(phi)
+                mu = self.mu_head(latent_out)
+                logsig = self.logsig_head(latent_out)
+                return mu, logsig
+            case 2 | 3 | 4:
+                return self.actv(phi)
+            case _:
+                raise ValueError(f'Unexpected version {self.version}')
+
+    def train(self, mode=True):
+        super().train(mode)
+        if self._freeze_bn:
+            for mod in self.modules():
+                if isinstance(mod, nn.BatchNorm1d):
+                    mod.eval()
+                    # I don't think this benefits
+                    # module.requires_grad_(False)
+        return self
+
+    def reset_running_stats(self):
+        for mod in self.modules():
+            if isinstance(mod, nn.BatchNorm1d):
+                mod.reset_running_stats()
+
+    def freeze_bn(self, value: bool):
+        self._freeze_bn = value
+        return self.train(self.training)
+
+class AuxNet(nn.Module):
+    def __init__(self, dims=None):
+        super().__init__()
+        self.dims = dims
+        self.net = nn.Linear(1024, sum(dims), bias=False)
+
+    def forward(self, x):
+        return self.net(x).split(self.dims, dim=-1)
+
+class DQN(nn.Module):
+    def __init__(self, *, version=1):
+        super().__init__()
+        self.version = version
+        match version:
+            case 1:
+                self.v_head = nn.Linear(512, 1)
+                self.a_head = nn.Linear(512, ACTION_SPACE)
+            case 2 | 3:
+                hidden_size = 512 if version == 2 else 256
+                self.v_head = nn.Sequential(
+                    nn.Linear(1024, hidden_size),
+                    nn.Mish(inplace=True),
+                    nn.Linear(hidden_size, 1),
+                )
+                self.a_head = nn.Sequential(
+                    nn.Linear(1024, hidden_size),
+                    nn.Mish(inplace=True),
+                    nn.Linear(hidden_size, ACTION_SPACE),
+                )
+            case 4:
+                self.net = nn.Linear(1024, 1 + ACTION_SPACE)
+                nn.init.constant_(self.net.bias, 0)
+
+    def forward(self, phi, mask):
+        if self.version == 4:
+            v, a = self.net(phi).split((1, ACTION_SPACE), dim=-1)
+        else:
+            v = self.v_head(phi)
+            a = self.a_head(phi)
+        a_sum = a.masked_fill(~mask, 0.).sum(-1, keepdim=True)
+        mask_sum = mask.sum(-1, keepdim=True)
+        a_mean = a_sum / mask_sum
+        q = (v + a - a_mean).masked_fill(~mask, -1e9)
+        return q
+
+
+class MortalEngine:
+    def __init__(
+        self,
+        brain,
+        dqn,
+        is_oracle,
+        version,
+        device = None,
+        stochastic_latent = False,
+        enable_amp = False,
+        enable_quick_eval = True,
+        enable_rule_based_agari_guard = False,
+        name = 'NoName',
+        boltzmann_epsilon = 0,
+        boltzmann_temp = 1,
+        top_p = 1,
+    ):
+        self.engine_type = 'mortal'
+        self.device = device or torch.device('cpu')
+        assert isinstance(self.device, torch.device)
+        self.brain = brain.to(self.device).eval()
+        self.dqn = dqn.to(self.device).eval()
+        self.is_oracle = is_oracle
+        self.version = version
+        self.stochastic_latent = stochastic_latent
+
+        self.enable_amp = enable_amp
+        self.enable_quick_eval = enable_quick_eval
+        self.enable_rule_based_agari_guard = enable_rule_based_agari_guard
+        self.name = name
+
+        self.boltzmann_epsilon = boltzmann_epsilon
+        self.boltzmann_temp = boltzmann_temp
+        self.top_p = top_p
+
+    def react_batch(self, obs, masks, invisible_obs):
+        # ========== Online Server =========== #
+        global ot_settings, is_online
+        # print('Reacting Batch')
+        if ot_settings['online']:
+            try:
+                list_obs = [o.tolist() for o in obs]
+                list_masks = [m.tolist() for m in masks]
+                post_data = {
+                    'obs': list_obs,
+                    'masks': list_masks,
+                }
+                data = json.dumps(post_data, separators=(',', ':'))
+                compressed_data = gzip.compress(data.encode('utf-8'))
+                headers = {
+                    'Authorization': ot_settings['api_key'],
+                    'Content-Encoding': 'gzip',
+                }
+                r = requests.post(
+                    f'{ot_settings["server"]}/react_batch_3p',
+                    headers=headers,
+                    data=compressed_data,
+                    timeout=OT_REQUEST_TIMEOUT
+                )
+                assert r.status_code == 200
+                is_online = True
+                r_json = r.json()
+                return r_json['actions'], r_json['q_out'], r_json['masks'], r_json['is_greedy']
+            except:
+                is_online = False
+                pass
+        # ==================================== #
+        try:
+            with (
+                torch.autocast(self.device.type, enabled=self.enable_amp),
+                torch.inference_mode(),
+            ):
+                return self._react_batch(obs, masks, invisible_obs)
+        except Exception as ex:
+            raise Exception(f'{ex}\n{traceback.format_exc()}')
+
+    def _react_batch(self, obs, masks, invisible_obs):
+        obs = torch.as_tensor(np.stack(obs, axis=0), device=self.device)
+        masks = torch.as_tensor(np.stack(masks, axis=0), device=self.device)
+        invisible_obs = None
+        if self.is_oracle:
+            invisible_obs = torch.as_tensor(np.stack(invisible_obs, axis=0), device=self.device)
+        batch_size = obs.shape[0]
+
+        match self.version:
+            case 1:
+                mu, logsig = self.brain(obs, invisible_obs)
+                if self.stochastic_latent:
+                    latent = Normal(mu, logsig.exp() + 1e-6).sample()
+                else:
+                    latent = mu
+                q_out = self.dqn(latent, masks)
+            case 2 | 3 | 4:
+                phi = self.brain(obs)
+                q_out = self.dqn(phi, masks)
+
+        if self.boltzmann_epsilon > 0:
+            is_greedy = torch.full((batch_size,), 1-self.boltzmann_epsilon, device=self.device).bernoulli().to(torch.bool)
+            logits = (q_out / self.boltzmann_temp).masked_fill(~masks, -torch.inf)
+            sampled = sample_top_p(logits, self.top_p)
+            actions = torch.where(is_greedy, q_out.argmax(-1), sampled)
+        else:
+            is_greedy = torch.ones(batch_size, dtype=torch.bool, device=self.device)
+            actions = q_out.argmax(-1)
+        return actions.tolist(), q_out.tolist(), masks.tolist(), is_greedy.tolist()
+
+def sample_top_p(logits, p):
+    if p >= 1:
+        return Categorical(logits=logits).sample()
+    if p <= 0:
+        return logits.argmax(-1)
+    probs = logits.softmax(-1)
+    probs_sort, probs_idx = probs.sort(-1, descending=True)
+    probs_sum = probs_sort.cumsum(-1)
+    mask = probs_sum - probs_sort > p
+    probs_sort[mask] = 0.
+    sampled = probs_idx.gather(-1, probs_sort.multinomial(1)).squeeze(-1)
+    return sampled
+
+def load_model(seat: int, model: str) -> Bot:
+    # check if GPU is available
+    if torch.cuda.is_available():
+        device = torch.device('cuda')
+    else:
+        device = torch.device('cpu')
+
+    # latest binary model
+    if model == None:
+        model = 'Elite4zWeightedBest5.pth'
+    model = str(model).split('？')[0]
+    control_state_file = model
+    print(control_state_file, 'loaded')
+
+    # Get the path of control_state_file = current directory / control_state_file
+    control_state_file = pathlib.Path(__file__).parent / control_state_file
+    state = torch.load(control_state_file, map_location=device)
+
+    mortal = Brain(version=state['config']['control']['version'], conv_channels=state['config']['resnet']['conv_channels'], num_blocks=state['config']['resnet']['num_blocks']).eval()
+    dqn = DQN(version=state['config']['control']['version']).eval()
+    mortal.load_state_dict(state['mortal'])
+    dqn.load_state_dict(state['current_dqn'])
+
+    engine = MortalEngine(
+        mortal,
+        dqn,
+        is_oracle = False,
+        version = state['config']['control']['version'],
+        device = device,
+        enable_amp = False,
+        enable_quick_eval = False,
+        enable_rule_based_agari_guard = True,
+        name = 'mortal',
+        top_p = 1,
+    )
+
+    bot = Bot(engine, seat)
+    return bot

model3pNEW.py

@@ -0,0 +1,445 @@
+import json
+import gzip
+import torch
+import pathlib
+import requests
+import traceback
+import numpy as np
+
+from torch import nn, Tensor
+from torch.nn import functional as F
+from torch.nn.utils.rnn import pack_padded_sequence, pad_sequence
+from torch.distributions import Normal, Categorical
+from typing import *
+from functools import partial
+from itertools import permutations
+try:
+    from libriichi.mjai import Bot
+    from libriichi.consts import obs_shape, oracle_obs_shape, ACTION_SPACE, GRP_SIZE
+except:
+    import importlib.util
+    import sys
+    import os
+    SO_FILE_PATH = "/content/drive/MyDrive/MahjongTest/libriichi.so"
+
+    # 1. 检查文件到底存不存在
+    if not os.path.exists(SO_FILE_PATH):
+        print(f"❌ 致命错误：在路径 {SO_FILE_PATH} 下根本找不到文件！请检查路径拼写。")
+    else:
+        print(f"✅ 找到文件: {SO_FILE_PATH}，正在尝试强行加载...")
+        
+        try:
+            # 2. 根据绝对路径创建模块加载规范 (spec)
+            # 第一个参数是你想给它起的名字（供 Python 内部识别），第二个参数是文件路径
+            spec = importlib.util.spec_from_file_location("libriichi", SO_FILE_PATH)
+            
+            # 3. 实例化模块
+            libriichi_module = importlib.util.module_from_spec(spec)
+            
+            # 4. 注册到系统的模块字典里 (非常重要！这样后续其他文件 import libriichi3p 就能直接用)
+            sys.modules["libriichi"] = libriichi_module
+            
+            # 5. 执行底层代码加载
+            spec.loader.exec_module(libriichi_module)
+            
+            print("🎉 强行导入成功！现在可以在代码里正常使用了。")
+            
+        except Exception as e:
+            print(f"❌ 导入失败，暴露出真实报错: {e}")
+# ========== Online Server =========== #
+OT_REQUEST_TIMEOUT = 2
+ot_settings = {
+    "server": "http://example.com",
+    "online": False,
+    "api_key": "example_api_key",
+}
+is_online = False
+
+def online_settings_init():
+    global ot_settings
+    # Check if the file exists
+    if (pathlib.Path(__file__).parent / 'ot_settings.json').exists():
+        with open(pathlib.Path(__file__).parent / 'ot_settings.json', 'r') as f:
+            ot_settings = json.load(f)
+
+online_settings_init()
+# ==================================== #
+
+class ChannelAttention(nn.Module):
+    def __init__(self, channels, ratio=16, actv_builder=nn.ReLU, bias=True):
+        super().__init__()
+        self.shared_mlp = nn.Sequential(
+            nn.Linear(channels, channels // ratio, bias=bias),
+            actv_builder(),
+            nn.Linear(channels // ratio, channels, bias=bias),
+        )
+        if bias:
+            for mod in self.modules():
+                if isinstance(mod, nn.Linear):
+                    nn.init.constant_(mod.bias, 0)
+
+    def forward(self, x: Tensor):
+        avg_out = self.shared_mlp(x.mean(-1))
+        max_out = self.shared_mlp(x.amax(-1))
+        weight = (avg_out + max_out).sigmoid()
+        x = weight.unsqueeze(-1) * x
+        return x
+
+class ResBlock(nn.Module):
+    def __init__(
+        self,
+        channels,
+        *,
+        norm_builder = nn.Identity,
+        actv_builder = nn.ReLU,
+        pre_actv = False,
+    ):
+        super().__init__()
+        self.pre_actv = pre_actv
+
+        if pre_actv:
+            self.res_unit = nn.Sequential(
+                norm_builder(),
+                actv_builder(),
+                nn.Conv1d(channels, channels, kernel_size=3, padding=1, bias=False),
+                norm_builder(),
+                actv_builder(),
+                nn.Conv1d(channels, channels, kernel_size=3, padding=1, bias=False),
+            )
+        else:
+            self.res_unit = nn.Sequential(
+                nn.Conv1d(channels, channels, kernel_size=3, padding=1, bias=False),
+                norm_builder(),
+                actv_builder(),
+                nn.Conv1d(channels, channels, kernel_size=3, padding=1, bias=False),
+                norm_builder(),
+            )
+            self.actv = actv_builder()
+        self.ca = ChannelAttention(channels, actv_builder=actv_builder, bias=True)
+
+    def forward(self, x):
+        out = self.res_unit(x)
+        out = self.ca(out)
+        out = out + x
+        if not self.pre_actv:
+            out = self.actv(out)
+        return out
+
+class ResNet(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        conv_channels,
+        num_blocks,
+        *,
+        norm_builder = nn.Identity,
+        actv_builder = nn.ReLU,
+        pre_actv = False,
+    ):
+        super().__init__()
+
+        blocks = []
+        for _ in range(num_blocks):
+            blocks.append(ResBlock(
+                conv_channels,
+                norm_builder = norm_builder,
+                actv_builder = actv_builder,
+                pre_actv = pre_actv,
+            ))
+
+        layers = [nn.Conv1d(in_channels, conv_channels, kernel_size=3, padding=1, bias=False)]
+        if pre_actv:
+            layers += [*blocks, norm_builder(), actv_builder()]
+        else:
+            layers += [norm_builder(), actv_builder(), *blocks]
+        layers += [
+            nn.Conv1d(conv_channels, 32, kernel_size=3, padding=1),
+            actv_builder(),
+            nn.Flatten(),
+            nn.Linear(32 * 34, 1024),
+        ]
+        self.net = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.net(x)
+
+class Brain(nn.Module):
+    def __init__(self, *, conv_channels, num_blocks, is_oracle=False, version=1):
+        super().__init__()
+        self.is_oracle = is_oracle
+        self.version = version
+
+        in_channels = obs_shape(version)[0]
+        if is_oracle:
+            in_channels += oracle_obs_shape(version)[0]
+
+        norm_builder = partial(nn.BatchNorm1d, conv_channels, momentum=0.01)
+        actv_builder = partial(nn.Mish, inplace=True)
+        pre_actv = True
+
+        match version:
+            case 1:
+                actv_builder = partial(nn.ReLU, inplace=True)
+                pre_actv = False
+                self.latent_net = nn.Sequential(
+                    nn.Linear(1024, 512),
+                    nn.ReLU(inplace=True),
+                )
+                self.mu_head = nn.Linear(512, 512)
+                self.logsig_head = nn.Linear(512, 512)
+            case 2:
+                pass
+            case 3 | 4:
+                norm_builder = partial(nn.BatchNorm1d, conv_channels, momentum=0.01, eps=1e-3)
+            case _:
+                raise ValueError(f'Unexpected version {self.version}')
+
+        self.encoder = ResNet(
+            in_channels = in_channels,
+            conv_channels = conv_channels,
+            num_blocks = num_blocks,
+            norm_builder = norm_builder,
+            actv_builder = actv_builder,
+            pre_actv = pre_actv,
+        )
+        self.actv = actv_builder()
+
+        # always use EMA or CMA when True
+        self._freeze_bn = False
+
+    def forward(self, obs: Tensor, invisible_obs: Optional[Tensor] = None) -> Union[Tuple[Tensor, Tensor], Tensor]:
+        if self.is_oracle:
+            assert invisible_obs is not None
+            obs = torch.cat((obs, invisible_obs), dim=1)
+        phi = self.encoder(obs)
+
+        match self.version:
+            case 1:
+                latent_out = self.latent_net(phi)
+                mu = self.mu_head(latent_out)
+                logsig = self.logsig_head(latent_out)
+                return mu, logsig
+            case 2 | 3 | 4:
+                return self.actv(phi)
+            case _:
+                raise ValueError(f'Unexpected version {self.version}')
+
+    def train(self, mode=True):
+        super().train(mode)
+        if self._freeze_bn:
+            for mod in self.modules():
+                if isinstance(mod, nn.BatchNorm1d):
+                    mod.eval()
+                    # I don't think this benefits
+                    # module.requires_grad_(False)
+        return self
+
+    def reset_running_stats(self):
+        for mod in self.modules():
+            if isinstance(mod, nn.BatchNorm1d):
+                mod.reset_running_stats()
+
+    def freeze_bn(self, value: bool):
+        self._freeze_bn = value
+        return self.train(self.training)
+
+class AuxNet(nn.Module):
+    def __init__(self, dims=None):
+        super().__init__()
+        self.dims = dims
+        self.net = nn.Linear(1024, sum(dims), bias=False)
+
+    def forward(self, x):
+        return self.net(x).split(self.dims, dim=-1)
+
+class DQN(nn.Module):
+    def __init__(self, *, version=1):
+        super().__init__()
+        self.version = version
+        match version:
+            case 1:
+                self.v_head = nn.Linear(512, 1)
+                self.a_head = nn.Linear(512, ACTION_SPACE)
+            case 2 | 3:
+                hidden_size = 512 if version == 2 else 256
+                self.v_head = nn.Sequential(
+                    nn.Linear(1024, hidden_size),
+                    nn.Mish(inplace=True),
+                    nn.Linear(hidden_size, 1),
+                )
+                self.a_head = nn.Sequential(
+                    nn.Linear(1024, hidden_size),
+                    nn.Mish(inplace=True),
+                    nn.Linear(hidden_size, ACTION_SPACE),
+                )
+            case 4:
+                self.net = nn.Linear(1024, 1 + ACTION_SPACE)
+                nn.init.constant_(self.net.bias, 0)
+
+    def forward(self, phi, mask):
+        if self.version == 4:
+            v, a = self.net(phi).split((1, ACTION_SPACE), dim=-1)
+        else:
+            v = self.v_head(phi)
+            a = self.a_head(phi)
+        a_sum = a.masked_fill(~mask, 0.).sum(-1, keepdim=True)
+        mask_sum = mask.sum(-1, keepdim=True)
+        a_mean = a_sum / mask_sum
+        q = (v + a - a_mean).masked_fill(~mask, -torch.inf)
+        return q
+
+
+class MortalEngine:
+    def __init__(
+        self,
+        brain,
+        dqn,
+        is_oracle,
+        version,
+        device = None,
+        stochastic_latent = False,
+        enable_amp = False,
+        enable_quick_eval = True,
+        enable_rule_based_agari_guard = False,
+        name = 'NoName',
+        boltzmann_epsilon = 0,
+        boltzmann_temp = 1,
+        top_p = 1,
+    ):
+        self.engine_type = 'mortal'
+        self.device = device or torch.device('cpu')
+        assert isinstance(self.device, torch.device)
+        self.brain = brain.to(self.device).eval()
+        self.dqn = dqn.to(self.device).eval()
+        self.is_oracle = is_oracle
+        self.version = version
+        self.stochastic_latent = stochastic_latent
+
+        self.enable_amp = enable_amp
+        self.enable_quick_eval = enable_quick_eval
+        self.enable_rule_based_agari_guard = enable_rule_based_agari_guard
+        self.name = name
+
+        self.boltzmann_epsilon = boltzmann_epsilon
+        self.boltzmann_temp = boltzmann_temp
+        self.top_p = top_p
+
+    def react_batch(self, obs, masks, invisible_obs):
+        # ========== Online Server =========== #
+        global ot_settings, is_online
+        if ot_settings['online']:
+            try:
+                list_obs = [o.tolist() for o in obs]
+                list_masks = [m.tolist() for m in masks]
+                post_data = {
+                    'obs': list_obs,
+                    'masks': list_masks,
+                }
+                data = json.dumps(post_data, separators=(',', ':'))
+                compressed_data = gzip.compress(data.encode('utf-8'))
+                headers = {
+                    'Authorization': ot_settings['api_key'],
+                    'Content-Encoding': 'gzip',
+                }
+                r = requests.post(
+                    f'{ot_settings["server"]}/react_batch',
+                    headers=headers,
+                    data=compressed_data,
+                    timeout=OT_REQUEST_TIMEOUT
+                )
+                assert r.status_code == 200
+                is_online = True
+                r_json = r.json()
+                return r_json['actions'], r_json['q_out'], r_json['masks'], r_json['is_greedy']
+            except:
+                is_online = False
+                pass
+        # ==================================== #
+        try:
+            with (
+                torch.autocast(self.device.type, enabled=self.enable_amp),
+                torch.inference_mode(),
+            ):
+                return self._react_batch(obs, masks, invisible_obs)
+        except Exception as ex:
+            raise Exception(f'{ex}\n{traceback.format_exc()}')
+
+    def _react_batch(self, obs, masks, invisible_obs):
+        obs = torch.as_tensor(np.stack(obs, axis=0), device=self.device)
+        masks = torch.as_tensor(np.stack(masks, axis=0), device=self.device)
+        invisible_obs = None
+        if self.is_oracle:
+            invisible_obs = torch.as_tensor(np.stack(invisible_obs, axis=0), device=self.device)
+        batch_size = obs.shape[0]
+
+        match self.version:
+            case 1:
+                mu, logsig = self.brain(obs, invisible_obs)
+                if self.stochastic_latent:
+                    latent = Normal(mu, logsig.exp() + 1e-6).sample()
+                else:
+                    latent = mu
+                q_out = self.dqn(latent, masks)
+            case 2 | 3 | 4:
+                phi = self.brain(obs)
+                q_out = self.dqn(phi, masks)
+
+        if self.boltzmann_epsilon > 0:
+            is_greedy = torch.full((batch_size,), 1-self.boltzmann_epsilon, device=self.device).bernoulli().to(torch.bool)
+            logits = (q_out / self.boltzmann_temp).masked_fill(~masks, -torch.inf)
+            sampled = sample_top_p(logits, self.top_p)
+            actions = torch.where(is_greedy, q_out.argmax(-1), sampled)
+        else:
+            is_greedy = torch.ones(batch_size, dtype=torch.bool, device=self.device)
+            actions = q_out.argmax(-1)
+
+        return actions.tolist(), q_out.tolist(), masks.tolist(), is_greedy.tolist()
+
+def sample_top_p(logits, p):
+    if p >= 1:
+        return Categorical(logits=logits).sample()
+    if p <= 0:
+        return logits.argmax(-1)
+    probs = logits.softmax(-1)
+    probs_sort, probs_idx = probs.sort(-1, descending=True)
+    probs_sum = probs_sort.cumsum(-1)
+    mask = probs_sum - probs_sort > p
+    probs_sort[mask] = 0.
+    sampled = probs_idx.gather(-1, probs_sort.multinomial(1)).squeeze(-1)
+    return sampled
+
+def load_model(seat: int, model_type) -> Bot:
+    # check if GPU is available
+    # device = torch.device('cpu')
+    if torch.cuda.is_available():
+        device = torch.device('cuda')
+    else:
+        device = torch.device('cpu')
+
+    # latest binary model
+    control_state_file = "./Elite4z-Mowang_epoch_10.pth"
+    print('model.py loading', control_state_file)
+
+    # Get the path of control_state_file = current directory / control_state_file
+    control_state_file = pathlib.Path(__file__).parent / control_state_file
+    state = torch.load(control_state_file, map_location=device)
+
+    mortal = Brain(version=state['config']['control']['version'], conv_channels=state['config']['resnet']['conv_channels'], num_blocks=state['config']['resnet']['num_blocks']).eval()
+    dqn = DQN(version=state['config']['control']['version']).eval()
+    mortal.load_state_dict(state['mortal'])
+    dqn.load_state_dict(state['current_dqn'])
+
+    engine = MortalEngine(
+        mortal,
+        dqn,
+        is_oracle = False,
+        version = state['config']['control']['version'],
+        device = device,
+        enable_amp = False,
+        enable_quick_eval = False,
+        enable_rule_based_agari_guard = True,
+        name = 'mortal',
+    )
+
+    bot = Bot(engine, seat)
+    return bot

requirements.txt

@@ -0,0 +1,7 @@
+torch
+orjson
+gradio
+matplotlib
+pandas
+riichienv
+requests