问题是由于错误的修改导致的..此讨论的数据无效

[CHANGNIANLE]

 在conv_channels = 48  num_blocks = 12 配置下,达到mortal params: 12,777,658  占用更少的显存 支持更大的batch_size

精度...不确定.......(都没有online训练)..但我之前训练模型比不上网页版的Mortal4.0

      振听立直问题仍然存在....
      振听解决思路(似乎只能影响立直?):
      给模型添加"听牌层" 加入待听的牌(或许能鼓励换牌?)      添加一层表示舍牌振听(影响立直)

另外..我的Rust好像坏掉了..编译的libriichi.pyd 无法调用(即使我重新下载libriichi源码编译)..之前编译的可以.Rust升级到最新也这样...
最后...

DenseNet-BC:
conv_channels = 48
num_blocks = 12 (Brain中一共有4个DenseBlock块 )

这样设置是因为对标原始
nn.Linear(32 * 34, 1024) 也就是 nn.Linear(1088 1024)
这样设置能达到nn.Linear(1086, 1024) (最接近..)

enable_cudnn_benchmark 必须关闭(特别慢..)
在获取version的代码下添加修改 如:
version = config['control']['version']
dense = config['control'].get('dense', False)

model.py 修改:

class BottleneckBlock(nn.Module):
def init(self, in_planes, out_planes):
super(BottleneckBlock, self).init()
inter_planes = out_planes * 4
self.bn1 = nn.BatchNorm1d(in_planes)
self.mish = nn.Mish(inplace=True)
self.conv1 = nn.Conv1d(in_planes, inter_planes, kernel_size=1, stride=1,
padding=0, bias=False)
self.bn2 = nn.BatchNorm1d(inter_planes)
self.conv2 = nn.Conv1d(inter_planes, out_planes, kernel_size=3, stride=1,
padding=1, bias=False)

def forward(self, x):
    out = self.bn1(x)
    out = self.mish(out)
    out = self.conv1(out)
    out = self.conv2(self.mish(self.bn2(out)))
    return torch.cat([x, out], 1)

def TransitionBlock(input_channels, num_channels):
return nn.Sequential(
nn.BatchNorm1d(input_channels), nn.Mish(),
nn.Conv1d(input_channels, num_channels, kernel_size=1),
nn.AvgPool1d(kernel_size=2, stride=2))

class DenseBlock(nn.Module):
def init(self, num_convs, input_channels, num_channels):
super(DenseBlock, self).init()
layer = []
for i in range(num_convs):
layer.append(BottleneckBlock(
num_channels * i + input_channels, num_channels))

    self.net = nn.Sequential(*layer)

def forward(self, x):
    return self.net(x)

class DenseNet(nn.Module):
def init(
self,
in_channels,
conv_channels,
num_blocks,
):
super().init()
z = 4

    layers = [nn.Conv1d(in_channels, conv_channels, kernel_size=3, padding=1, bias=False),
              nn.BatchNorm1d(conv_channels),
                  nn.Mish(),
              nn.MaxPool1d(kernel_size=3, stride=2, padding=1)

              ]

    lz = conv_channels

    for i in range(z):
        layers += [DenseBlock(num_blocks, lz, conv_channels)]
        lz = conv_channels * num_blocks + lz
        if i != z - 1:
            layers += [TransitionBlock(lz, int(math.floor(lz * 0.5)))]
            lz = int(math.floor(lz * 0.5))

    layers += [
        nn.Conv1d(lz, lz, kernel_size=3, padding=1, bias=False),
        nn.BatchNorm1d(lz), nn.Mish(),
        nn.AdaptiveAvgPool1d(1),
        nn.Flatten(),
        nn.Linear(lz, 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, dense=False):
    super().__init__()
    self.is_oracle = is_oracle
    self.version = version
    self.dense = dense

    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}')

    if not self.dense:
        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,
        )

    else:
        self.encoder = DenseNet(
            in_channels=in_channels,
            conv_channels=conv_channels,
            num_blocks=num_blocks,
        )

    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)

[Nitasurin]

也许你的DenseNet-BC改进主要受益于有限VRAM下更大的batchszie（至少对于Resnet版本，更大的batchsize可以提升表现）。

[CHANGNIANLE]

没错.是这样的.

[hyskylord]

对麻将的信息进行降采样效果是否存疑？我在Resnet中尝试过类似的做法但是效果不佳，而且数据只有一维的情况下计算量减少也不太多。

[Nitasurin]

或许你可以用akagi的模型作为baseline？

已经使用了...如果我没用错的话.... 优于 model_v4_20240308_mortal_min 16.88pt 优于 bot_20240110_best. 21.12 ranking: 0.37 0.274 0.182 0.174

我不认为16.88pt是一个正常的pt优势值。对于DRL，Backbone的神经网络改进不会产生如此大的差距。
一般是以下两种情况：
1.你的统计方式存在问题
2.baseline过于弱、没有经过训练或者加载过程存在问题。

[CHANGNIANLE]

> > > 或许你可以用akagi的模型作为baseline？

已经使用了...如果我没用错的话....优于 model_v4_20240308_mortal_min 16.88pt 优于 bot_20240110_best.21.12 排名： 0.37 0.274 0.182 0.174

我不认为16.88pt是一个正常的pt优势值。对于DRL，Encoder的神经网络改进不会产生如此大的差距。 一般是以下两种情况： 1.你的统计方式存在问题 2.baseline过于弱、没有经过训练或者加载过程存在问题。

没错..16.88pt是一个很离谱的值.....神经网络改进确实不会产生这么大的差距..

但根据排名： 0.37 0.274 0.182 0.174 无论如何计算都具有很大优势....统计方式不应当存在问题

baseline过于弱 baseline也是使用discord上发布的Akagi的模型....但也可能是我的修改错误导致的(可能性很大..)

或者对战 1000场太少....(改为了对战10000 10小时还没算完..? 大概我CPU太差..)

或者数据集问题....(可能性也很大..) 这是我使用的筛选方法.. 我排除了区间得分低于0的对局 (也排除了同场对局的其他玩家的操作数据)
所以筛选后的数据集优于凤凰桌平均 至少11.25pt
使用高负和的计算方式 [75., 30, 0, -150.] (75+30+0-150) /4 = -11.25

[数据集筛选的具体方法](#74 #discussioncomment-10031603)

[Nitasurin]

是的,我不确定效果..

首先他们的在不同batch_size上对比的 在显存接近的情况下...很抱歉没说明白......

另外我之前训练的模型已经被远远超越了(不单单换了DenseNet-BC 使用更大batchszie 还筛选了数据集..甚至数据集替换过多次).......

在 avg_pt = stat.avg_pt([75, 30, 0, -150]) + 11.25 计算下已经拉开了19pt以上差距....

甚至还在随着训练拉开差距...这意味着我之前的模型有多么的差...但不能说明现在的模型优秀..

所以我现在没有任何有效数据....

@CHANGNIANLE

1. 1000半庄数量太少，Mortal文档使用了100万半庄测试，我个人认为5万以上比较可靠(请使用GPU进行测试)。
2. 浏览你的回复，我认为在你的环境中，Baseline模型存在加载问题(某些错误Torch并不会报错)或者其决策被错误执行了。

[adsf0427]

或许你可以用akagi的模型作为baseline？

已经使用了...如果我没用错的话.... 或许对战 1000场 太少了..

你的模型是纯offline训练的结果？

[CHANGNIANLE]

或许你可以用akagi的模型作为baseline？

已经使用了...如果我没用错的话....或许对战 1000场 太少了..

你的模型是纯offline训练的结果？

online = false

[CHANGNIANLE]

@hyskylord @adsf0427 @Nitasurin @smly

pt过大的原因找到了..我的修改损坏 Resnet版本的模型 导致模型输出异常...

异常代码修复:
这个 dqn_losstrain 咋来的我都不知道....
def dqn_losstrain(self, mode=True): -> def train(self, mode=True):
return phi -> return self.actv(phi)

下面是正常的对战数据 初步效果... 由于对战数量较低和模型未完全收敛....没多大意义..

池层替换为步长为2的卷积层.......
在2000 batch size 其余 config.toml 默认的情况下 训练58k步后..(前16800步 512 batch size)
dqn_loss=0.436 cql_loss=0.620 next_rank_loss=0.861 loss=3.70 还没有完全收敛...
对战 2000场 计算方式:avg_pt = stat.avg_pt([75, 30, 0, -150]) + 11.25
baseline 是 model_v4_20240308_best_min
ranking: 0.281 0.247 0.216 0.256
[562 494 432 512] (2.447, 1.3350000000000009pt)

[adsf0427]

我很好奇你是如何修改resnet但是还能保持原版的模型能正常输出的。建议对局1W场以上，akagi的模型应该有魂天的实力。

[CHANGNIANLE]

我很好奇你是如何修改resnet，但是还能保持原版的模型能正常输出的。建议对局1W场以上，akagi的模型应该有魂天的实力。

错误的代码能在之前编辑中看到....
总之就是 模型shape未改变...但少了使用了一次激活函数
和 class Brain -> def train 因为名字改变的原因未调用..因为train是覆写的方法 所以没有报错.....

等模型完全收敛..会进行更多的对局....因为之前的差距实在是太大了..