Upload 8 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
+libriichi.so filter=lfs diff=lfs merge=lfs -text
+libriichi3p.so filter=lfs diff=lfs merge=lfs -text

Backup_B50_Rank1.75_Rwd0.12_Ent0.149.pth

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

Bot.py

@@ -0,0 +1,235 @@
+import json
+import sys
+import model
+import model3p
+import numpy as np
+
+tiles_tenhou = {
+    '1m': 0, '2m': 1, '3m': 2, '4m': 3, '5m': 4, '5mr': 4.5, '6m': 5, '7m': 6, '8m': 7, '9m': 8,
+    '1p': 9, '2p': 10, '3p': 11, '4p': 12, '5p': 13, '5pr': 13.5, '6p': 14, '7p': 15, '8p': 16, '9p': 17,
+    '1s': 18, '2s': 19, '3s': 20, '4s': 21, '5s': 22, '5sr': 22.5, '6s': 23, '7s': 24, '8s': 25, '9s': 26,
+    'E': 27, 'S': 28, 'W': 29, 'N': 30, 'P': 31, 'F': 32, 'C': 33
+}
+
+MASK_4P = [
+    "1m", "2m", "3m", "4m", "5m", "6m", "7m", "8m", "9m",
+    "1p", "2p", "3p", "4p", "5p", "6p", "7p", "8p", "9p",
+    "1s", "2s", "3s", "4s", "5s", "6s", "7s", "8s", "9s",
+    "E",  "S",  "W",  "N",  "P",  "F",  "C",
+    '5mr', '5pr', '5sr', 
+    'reach', 'chi_low', 'chi_mid', 'chi_high', 'pon', 'kan', 'hora', 'ryukyoku', 'none'
+]
+
+MASK_3P = [
+    "1m", "2m", "3m", "4m", "5m", "6m", "7m", "8m", "9m",
+    "1p", "2p", "3p", "4p", "5p", "6p", "7p", "8p", "9p",
+    "1s", "2s", "3s", "4s", "5s", "6s", "7s", "8s", "9s",
+    "E",  "S",  "W",  "N",  "P",  "F",  "C",
+    '5mr', '5pr', '5sr', 
+    'reach', 'pon', 'kan', 'nukidora', 'hora', 'ryukyoku', 'none'
+]
+
+def SoftMax(arr, temperature=1.0):
+    arr = np.array(arr, dtype=float)  # Ensure the input is a numpy array of floats    
+    if arr.size == 0:
+        return arr  # Return the empty array if input is empty
+    if not temperature == 1.0:
+        arr /= temperature  # Scale by temperature if temperature is not approximately 1
+    # Shift values by max for numerical stability
+    max_val = np.max(arr)
+    arr = arr - max_val    
+    # Apply the softmax transformation
+    exp_arr = np.exp(arr)
+    sum_exp = np.sum(exp_arr)    
+    softmax_arr = exp_arr / sum_exp    
+    return softmax_arr
+
+def ToBinStr(mask_bits):
+    binary_string = bin(mask_bits)[2:]
+    binary_string = binary_string.zfill(46)
+    return binary_string
+
+
+def ToBoolList(mask_bits):
+    binary_string = ToBinStr(mask_bits)
+    bool_list = []
+    for bit in binary_string[::-1]:
+        bool_list.append(bit == '1')
+    return bool_list
+
+def ParseMeta(is_3p, meta):
+    if is_3p:
+        mask_list = MASK_3P
+    else:
+        mask_list = MASK_4P
+    
+    q_values = meta['q_values']
+    mask_bits = meta['mask_bits']
+    mask = ToBoolList(mask_bits)
+    weight_values = SoftMax(q_values)
+    
+    q_value_idx = 0
+    option_list = []
+    for i in range(46):
+        if mask[i]:
+            option_list.append((mask_list[i], weight_values[q_value_idx]))
+            q_value_idx += 1
+
+    option_list = sorted(option_list, key=lambda x: x[1], reverse=True)
+    return option_list
+
+
+class Bot:
+    def __init__(self):
+        self.player_id: int = None
+        self.model = None
+
+    def react(self, events: str):
+        events = json.loads(events)
+        return_action = None
+        for e in events:
+            if e["type"] == "start_game":
+                self.player_id = e["id"]
+                model_type = e.get('model')
+                self.model = model3p.load_model(self.player_id, model_type)
+                continue
+            if self.model is None or self.player_id is None:
+                raise Exception(f"Model is not loaded yet")
+                continue
+            if e["type"] == "end_game":
+                self.player_id = None
+                self.model = None
+                continue
+            return_action = self.model.react(json.dumps(e, separators=(",", ":")))
+        return return_action
+
+class Bot4P:
+    def __init__(self):
+        self.player_id: int = None
+        self.model = None
+
+    def react(self, events: str, H = True):
+        events = json.loads(events)
+        return_action = None
+        for e in events:
+            if e["type"] == "start_game":
+                self.player_id = e["id"]
+                model_type = e.get('model')
+                self.model = model.load_model(self.player_id, model_type)
+                continue
+            if self.model is None or self.player_id is None:
+                raise Exception(f"Model is not loaded yet")
+                continue
+            if e["type"] == "end_game":
+                self.player_id = None
+                self.model = None
+                continue
+            return_action = self.model.react(json.dumps(e, separators=(",", ":")))
+        if H:
+            return return_action
+        if return_action == None:
+            return None
+        original = json.loads(return_action)
+        return Select(original, ParseMeta(False, original['meta']))
+false = False
+true = True
+if __name__ == '__main__':
+    bot = Bot4P()
+    print(bot)
+
+    events = {
+  "is3p": false,
+  "model": "v2-a",
+  "events": [
+    {
+      "id": 0,
+      "type": "start_game"
+    },
+    {
+      "oya": 0,
+      "type": "start_kyoku",
+      "honba": 0,
+      "kyoku": 1,
+      "bakaze": "E",
+      "scores": [
+        25000,
+        25000,
+        25000,
+        0
+      ],
+      "tehais": [
+        [
+          "1m",
+          "2s",
+          "3s",
+          "3p",
+          "4p",
+          "5p",
+          "5s",
+          "6s",
+          "7s",
+          "N",
+          "N",
+          "S",
+          "W"
+        ],
+        [
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?"
+        ],
+        [
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?"
+        ],
+        [
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?",
+          "?"
+        ]
+      ],
+      "kyotaku": 0,
+      "dora_marker": "9m"
+    },
+    {
+      "pai": "1p",
+      "type": "tsumo",
+      "actor": 0
+    }
+  ],
+  "timestamp": "2025-09-22T15:03:13.873Z"
+}
+
+    res = bot.react(json.dumps(events['events']))
+    print(res)

Elite4z9070.pth

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

libriichi.so

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

libriichi3p.so

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

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

requirements.txt

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

本地训练器.py

@@ -0,0 +1,130 @@
+import os
+
+import orjson
+import concurrent.futures
+import random
+import torch
+from riichienv import RiichiEnv, GameRule
+from model3pLOCAL import load_model
+
+# ==========================================
+# 1. 高性能 Patch 逻辑 (保持不变)
+# ==========================================
+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"')
+
+# ==========================================
+# 2. 全局模型缓存
+# ==========================================
+_MODEL_CACHE = {}
+
+def get_cached_model(player_id: int, model_file: str):
+    key = (player_id, model_file)
+    if key not in _MODEL_CACHE:
+        _MODEL_CACHE[key] = load_model(player_id, model_file)
+    return _MODEL_CACHE[key]
+
+class MortalAgent:
+    def __init__(self, player_id: int, model_file: str):
+        self.player_id = player_id
+        self.model = get_cached_model(player_id, model_file)
+
+    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
+
+# ==========================================
+# 3. 单局游戏任务 (加入随机座次)
+# ==========================================
+def play_one_game(game_index):
+    env = RiichiEnv(game_mode="3p-red-half", rule=GameRule.default_tenhou())
+    
+    # --- 随机分配座次 ---
+    # 随机选一个位置给 NEW_MODEL (0, 1, 或 2)
+    new_seat = random.randrange(3)
+    
+    agents = {}
+    for i in range(3):
+        model_file = "Backup_B50_Rank1.75_Rwd0.12_Ent0.149.pth" if i == new_seat else "Elite4z9070.pth"
+        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)
+        
+    scores = env.scores()
+    ranks = env.ranks()
+    
+    # 根据随机到的 new_seat 提取新模型的成绩
+    # 顺位：ranks[new_seat], 分数：scores[new_seat]
+    return ranks[new_seat], scores[new_seat]
+
+# ==========================================
+# 4. 多进程调度主循环
+# ==========================================
+if __name__ == "__main__":
+    REPORT_FILE = "训练报告-9070旧-W5新.txt"
+    NUM_WORKERS = 1  # 建议设为 CPU 核心数或稍小
+    
+    print(f"🚀 启动评估程序，当前多开数: {NUM_WORKERS}")
+    print(f"📝 成绩将随机化座次并追加写入到 {REPORT_FILE}")
+    print("⏹️  随时按 Ctrl+C 即可安全停止\n")
+
+    try:
+        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 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
+                            print(f"[{games_completed}局完成] 新模型成绩 -> 顺位: {rank}, 分数: {score}")
+                            
+                        except Exception as e:
+                            print(f"⚠️ 异常: {e}")
+                            
+                        # 补齐新任务
+                        futures.add(executor.submit(play_one_game, games_completed))
+
+    except KeyboardInterrupt:
+        print("\n🛑 评估已手动停止。")