标题：2026-04-09 AI麻将助手核心技术：从原理剖析到面试考点

 传统规则驱动的出牌逻辑（伪代码）
def decide_discard(hand_tiles):
     规则1：优先打掉孤立风牌
    for tile in hand_tiles:
        if is_wind_tile(tile) and not is_part_of_pattern(tile):
            return tile
    
     规则2：保留顺子搭子
    for pattern in find_complete_patterns(hand_tiles):
        if pattern.is_complete():
            continue
    
     规则3：打掉字牌
    for tile in hand_tiles:
        if is_honor_tile(tile) and tile not in valuable_combos:
            return tile
    
     规则4：打掉幺九牌
    for tile in hand_tiles:
        if is_terminal_tile(tile):
            return tile
    
    return hand_tiles[0]

class MCTSNode:
    def __init__(self, state):
        self.state = state           牌局状态
        self.visits = 0              被访问次数
        self.value = 0.0             累计价值
        self.children = {}           子节点：动作 -> 节点
        self.parent = None

def ucb_score(node, parent_visits):
     UCB1公式：平衡探索(exploration)与利用(exploitation)
    return node.value / node.visits + C  sqrt(log(parent_visits) / node.visits)

def mcts_search(root_state, iterations=1000):
    root = MCTSNode(root_state)
    
    for _ in range(iterations):
         1. Selection：从根节点出发，用UCB公式选择最优路径
        node = root
        while node.children:
             选择UCB值最大的子节点
            node = max(node.children.values(), 
                       key=lambda n: ucb_score(n, node.visits))
        
         2. Expansion：如果当前节点不是终局，创建一个新子节点
        if not is_terminal(node.state):
            legal_actions = get_legal_actions(node.state)
            action = random.choice(legal_actions)
            new_state = apply_action(node.state, action)
            node.children[action] = MCTSNode(new_state)
            node = node.children[action]
        
         3. Simulation：用默认策略（如随机出牌）模拟对局至结束
        result = simulate_to_end(node.state)   返回排名/得分
        
         4. Backpropagation：将模拟结果沿路径回传，更新各节点统计信息
        while node:
            node.visits += 1
            node.value += result
            node = node.parent
    
     选择访问次数最多的动作（或价值最高的动作）
    return max(root.children.items(), key=lambda item: item[1].visits)[0]

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
from collections import deque
import random

 简化版：将手牌编码为34维one-hot向量（麻将共有34种牌）
 实际生产环境（如Mortal）会编码更多特征：牌河信息、副露、宝牌、场风自风等
def encode_hand(hand_tiles):
    vec = np.zeros(34, dtype=np.float32)
    for tile in hand_tiles:
        vec[tile] += 1
     归一化处理，便于神经网络训练
    return vec / 34.0

class SimpleResNet(nn.Module):
    """麻将AI决策网络的ResNet骨架"""
    def __init__(self, input_dim=34, hidden_dim=128, output_dim=34):
        super().__init__()
         输入层：34维手牌向量 -> 128维特征
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.bn1 = nn.BatchNorm1d(hidden_dim)
        
         残差块1：核心设计——输入与输出直接相加
        self.res_block1 = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim)
        )
        
         残差块2
        self.res_block2 = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim)
        )
        
         输出层：34维动作价值（每张牌一个Q值）
        self.fc_out = nn.Linear(hidden_dim, output_dim)
        
    def forward(self, x):
         输入层 + ReLU激活
        x = torch.relu(self.bn1(self.fc1(x)))
        
         残差连接1：identity shortcut
        residual = x
        x = self.res_block1(x)
        x = x + residual   关键：跳跃连接，梯度畅通无阻
        
         残差连接2
        residual = x
        x = self.res_block2(x)
        x = x + residual
        
        return self.fc_out(x)   输出每个动作的Q值

class MinimalMahjongAI:
    def __init__(self):
        self.model = SimpleResNet()
        self.target_model = SimpleResNet()   目标网络，提升训练稳定性
        self.target_model.load_state_dict(self.model.state_dict())
        
        self.optimizer = optim.Adam(self.model.parameters(), lr=0.001)
        self.memory = deque(maxlen=10000)   经验回放池
        self.gamma = 0.99   折扣因子
        
    def update_target_network(self):
        """每N步将主网络参数复制到目标网络"""
        self.target_model.load_state_dict(self.model.state_dict())
    
    def train_step(self, batch_size=32):
        if len(self.memory) < batch_size:
            return
        
         从经验池中随机采样一批数据（打破时序相关性）
        batch = random.sample(self.memory, batch_size)
        states, actions, rewards, next_states, dones = zip(batch)
        
         转换为tensor
        states = torch.FloatTensor(np.array(states))
        next_states = torch.FloatTensor(np.array(next_states))
        actions = torch.LongTensor(actions)
        rewards = torch.FloatTensor(rewards)
        dones = torch.FloatTensor(dones)
        
         计算当前Q值
        current_q = self.model(states).gather(1, actions.unsqueeze(1))
        
         计算目标Q值（使用目标网络计算）
        with torch.no_grad():
            next_q = self.target_model(next_states).max(1)[0]
            target_q = rewards + self.gamma  next_q  (1 - dones)
        
         损失函数：MSE
        loss = nn.MSELoss()(current_q.squeeze(), target_q)
        
         反向传播更新参数
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()
        
        return loss.item()

 训练示意
ai = MinimalMahjongAI()
 实际训练需要结合麻将环境（如mjalib），循环执行：
 state -> model预测动作 -> 执行动作 -> 获取reward -> 存入memory -> train_step
print("AI麻将助手决策模型骨架构建完成，经过约1000万局实战数据训练后即可达到专业级水平[reference:11]")