File size: 12,883 Bytes
519ab98
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
"""
论文 §4.3 修订方案(v2):角向预平滑 + 可选池化(max / mean / SP)。

与 section43.py 中 Section43Encoder(v1:直接抽帧 + MaxPool)并存,供消融对比。
默认:预平滑 + SP → f_ellipse∈R^512;可通过 use_pre_smooth / pool_mode 做 2×2 消融。
"""

from __future__ import annotations

from dataclasses import dataclass
from typing import Dict, List, Literal, Optional, Union

PoolMode = Literal["max", "mean", "sp"]
POOL_MODES: tuple[str, ...] = ("max", "mean", "sp")

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

from section42 import responsibility_indices
from section43 import (
    DEFAULT_SCALES,
    FreqGuidedScaleAttention,
    Section43Config,
    SharedMultiscaleStem,
    align_H_to_segment,
    build_segment_geometry,
    multiscale_sample_indices,
)


@dataclass
class Section43ConfigV2(Section43Config):
    """§4.3 v2 超参(继承 v1,新增预平滑与可切换池化)。"""

    use_pre_smooth: bool = True
    pool_mode: PoolMode = "sp"
    pre_smooth_kernel: int = 7
    pre_smooth_avg_kernel: int = 3
    n_sp: int = 4
    d_sp: int = 128

    @property
    def d_ellipse(self) -> int:
        if self.pool_mode == "sp":
            return self.n_sp * self.d_sp
        return self.d_h

    def scheme_label(self) -> str:
        pre = "pre" if self.use_pre_smooth else "no-pre"
        return f"v2({pre}+{self.pool_mode})"


def v2_needs_valid_mask(enc43: nn.Module) -> bool:
    """仅 SP 池化需要 valid 掩码。"""
    if not isinstance(enc43, Section43EncoderV2):
        return False
    return enc43.config.pool_mode == "sp"


def _circular_pad1d(x: torch.Tensor, pad: int) -> torch.Tensor:
    """x: (B, C, L) → 圆周 padding。"""
    if pad <= 0:
        return x
    return torch.cat([x[..., -pad:], x, x[..., :pad]], dim=-1)


class AngularPreSmooth(nn.Module):
    """§4.3.1.0:圆周 Conv1d + 残差 LN + stride=1 AvgPool。"""

    def __init__(self, d_seq: int, kernel: int = 7, avg_kernel: int = 3):
        super().__init__()
        self.pad = kernel // 2
        self.conv = nn.Conv1d(d_seq, d_seq, kernel_size=kernel, padding=0, bias=True)
        self.norm = nn.LayerNorm(d_seq)
        self.avg_kernel = avg_kernel
        self.avg_pad = avg_kernel // 2

    def forward(self, s_seq: torch.Tensor) -> torch.Tensor:
        """
        s_seq: (B, N_theta, d_seq)
        返回 s_smooth: 同形状
        """
        x = s_seq.transpose(1, 2)
        x = _circular_pad1d(x, self.pad)
        x = self.conv(x)
        x = x.transpose(1, 2)
        x = self.norm(x)
        out = s_seq + x
        out = out.transpose(1, 2)
        out = _circular_pad1d(out, self.avg_pad)
        out = F.avg_pool1d(out, kernel_size=self.avg_kernel, stride=1, padding=0)
        return out.transpose(1, 2)


class SelectivePool1d(nn.Module):
    """
    §4.3.3 SP 模块:N_sp 个子空间各自可学习 query,将 (B, L, C) 汇聚为 (B, N_sp*d_sp)。
    """

    def __init__(self, in_features: int, d_head: int, num_heads: int):
        super().__init__()
        self.keys = nn.Parameter(torch.empty(num_heads, d_head))
        self.w_q = nn.Conv1d(in_features, d_head * num_heads, kernel_size=1)
        self.norm = 1.0 / np.sqrt(d_head)
        self.d_head = d_head
        self.num_heads = num_heads
        self._reset_parameters()

    def _reset_parameters(self) -> None:
        nn.init.orthogonal_(self.keys, gain=1.0)
        nn.init.kaiming_normal_(self.w_q.weight, a=1.0)
        nn.init.zeros_(self.w_q.bias)

    def forward(
        self,
        x: torch.Tensor,
        mask: Optional[torch.Tensor] = None,
    ) -> torch.Tensor:
        """
        x: (B, L, C)
        mask: (B, L) 有效角位 1/0,可选
        返回: (B, num_heads * d_head)
        """
        x_ch = x.transpose(1, 2)
        qv = self.w_q(x_ch).transpose(1, 2).view(x.size(0), x.size(1), self.num_heads, self.d_head)
        logits = torch.sum(qv * self.keys.view(1, 1, self.num_heads, self.d_head), dim=-1)
        logits = logits * self.norm
        if mask is not None:
            logits = logits - (1.0 - mask.to(x.device)).unsqueeze(-1) * 1e3
        attn = F.softmax(logits, dim=1)
        pooled = torch.sum(qv * attn.unsqueeze(-1), dim=1)
        return pooled.reshape(x.size(0), -1)


def build_pool_valid_mask(
    valid: torch.Tensor,
    geom,
    n_segments: int,
    s_l: int,
) -> torch.Tensor:
    """
    valid: (B, N_theta),1=实测角位
    返回: (B, T_ell) 与 H_ell 行对齐
    """
    idx_list = []
    for m in range(n_segments):
        idx_list.append(responsibility_indices(m, geom))
    all_idx = np.concatenate(idx_list, axis=0)
    return valid[:, all_idx]


def pool_sequence(
    H_ell: torch.Tensor,
    pool_mode: PoolMode,
    *,
    selective_pool: Optional[SelectivePool1d] = None,
    valid_mask: Optional[torch.Tensor] = None,
) -> torch.Tensor:
    """H_ell (B,L,D) → f_ellipse;max/mean 与 v1 对齐为 D_h,sp 为 N_sp*d_sp。"""
    if pool_mode == "max":
        return H_ell.max(dim=1).values
    if pool_mode == "mean":
        if valid_mask is not None:
            w = valid_mask.to(H_ell.device).unsqueeze(-1)
            denom = w.sum(dim=1).clamp(min=1.0)
            return (H_ell * w).sum(dim=1) / denom
        return H_ell.mean(dim=1)
    if pool_mode == "sp":
        if selective_pool is None:
            raise ValueError("pool_mode='sp' 需要 selective_pool 模块")
        return selective_pool(H_ell, valid_mask)
    raise ValueError(f"未知 pool_mode: {pool_mode}")


class Section43EncoderV2(nn.Module):
    """§4.3 v2:可选预平滑 + 角向抽帧 + FiLM + Transformer + 可选池化。"""

    def __init__(self, config: Optional[Section43ConfigV2] = None):
        super().__init__()
        self.config = config or Section43ConfigV2()
        cfg = self.config
        if cfg.pool_mode not in POOL_MODES:
            raise ValueError(f"pool_mode 须为 {POOL_MODES},got {cfg.pool_mode!r}")
        self.scales = list(cfg.scales)
        self.n_scales = len(self.scales)
        self.geom = build_segment_geometry(cfg.n_theta, cfg.n_segments)
        self.s_l = self.geom.s_l
        self.M = self.geom.n_segments

        if cfg.use_pre_smooth:
            self.pre_smooth = AngularPreSmooth(
                cfg.d_seq,
                kernel=cfg.pre_smooth_kernel,
                avg_kernel=cfg.pre_smooth_avg_kernel,
            )
        else:
            self.pre_smooth = None
        self.ms_stem = SharedMultiscaleStem(cfg, self.n_scales)
        self.scale_attn = FreqGuidedScaleAttention(cfg, self.n_scales)

        enc_layer = nn.TransformerEncoderLayer(
            d_model=cfg.d_h,
            nhead=cfg.n_heads_ell,
            dim_feedforward=cfg.ffn_ell,
            batch_first=True,
            norm_first=True,
            activation="gelu",
        )
        self.ell_transformer = nn.TransformerEncoder(enc_layer, num_layers=cfg.l_ell)
        if cfg.pool_mode == "sp":
            self.selective_pool = SelectivePool1d(cfg.d_h, cfg.d_sp, cfg.n_sp)
        else:
            self.selective_pool = None

    def _encode_scale(
        self,
        s_smooth: torch.Tensor,
        k: int,
        scale_id: int,
        training: bool,
    ) -> torch.Tensor:
        n = s_smooth.shape[1]
        idx = multiscale_sample_indices(n, k, training=training).to(s_smooth.device)
        bar_s = s_smooth[:, idx, :]
        return self.ms_stem(bar_s, scale_id)

    def _align_all_segments(self, H_k: torch.Tensor, k: int) -> torch.Tensor:
        out = []
        for m in range(self.M):
            seg_idx = responsibility_indices(m, self.geom)
            h_m = align_H_to_segment(H_k, seg_idx, self.config.n_theta, k)
            out.append(h_m.unsqueeze(1))
        return torch.cat(out, dim=1)

    def forward(
        self,
        s_seq: torch.Tensor,
        f_freq: torch.Tensor,
        g_vec: torch.Tensor,
        e_pen: Optional[torch.Tensor] = None,
        *,
        valid_mask: Optional[torch.Tensor] = None,
        training: bool = False,
        return_details: bool = True,
    ) -> Dict[str, torch.Tensor]:
        cfg = self.config
        batched = s_seq.dim() == 3
        if not batched:
            s_seq = s_seq.unsqueeze(0)
            f_freq = f_freq.unsqueeze(0)
            g_vec = g_vec.unsqueeze(0)
            if valid_mask is not None and valid_mask.dim() == 1:
                valid_mask = valid_mask.unsqueeze(0)

        b = s_seq.size(0)
        device = s_seq.device

        if e_pen is None:
            e_pen = torch.zeros(b, cfg.d_pen, device=device, dtype=s_seq.dtype)
        elif e_pen.dim() == 1:
            e_pen = e_pen.unsqueeze(0).expand(b, -1)

        s_smooth = self.pre_smooth(s_seq) if self.pre_smooth is not None else s_seq
        f_bar = f_freq.mean(dim=-1)

        H_aligned: List[torch.Tensor] = []
        for sid, k in enumerate(self.scales):
            H_k = self._encode_scale(s_smooth, k, sid, training)
            H_tilde = self._align_all_segments(H_k, k)
            H_aligned.append(H_tilde)

        H_stack = torch.stack(H_aligned, dim=2)

        F_seg = torch.zeros(b, self.M, self.s_l, cfg.d_h, device=device, dtype=s_seq.dtype)
        W_all = torch.zeros(b, self.M, self.n_scales, device=device, dtype=s_seq.dtype)
        beta_all = torch.zeros(b, self.M, cfg.h_scale, self.n_scales, device=device)

        for m in range(self.M):
            t_stack = H_stack[:, m, :, :].mean(dim=2)
            W_m, beta_m = self.scale_attn(f_bar[:, m], g_vec, e_pen, t_stack)
            W_all[:, m] = W_m
            beta_all[:, m] = beta_m
            for sid in range(self.n_scales):
                F_seg[:, m] = F_seg[:, m] + W_m[:, sid : sid + 1, None] * H_stack[:, m, sid]

        H_ell = F_seg.reshape(b, self.M * self.s_l, cfg.d_h)
        H_ell = self.ell_transformer(H_ell)
        f_ellipse = pool_sequence(
            H_ell,
            cfg.pool_mode,
            selective_pool=self.selective_pool,
            valid_mask=valid_mask if cfg.pool_mode == "sp" else None,
        )

        out: Dict[str, torch.Tensor] = {
            "f_ellipse": f_ellipse,
            "H_ell": H_ell,
            "F_segment": F_seg,
            "W_scale": W_all,
            "s_smooth": s_smooth,
        }
        if return_details:
            out["H_aligned"] = H_stack
            out["beta_heads"] = beta_all
            out["f_bar"] = f_bar

        if not batched:
            out = {k: v.squeeze(0) for k, v in out.items()}
        return out

    def forward_from_upstream(
        self,
        o41: Dict[str, torch.Tensor],
        o42: Dict[str, torch.Tensor],
        e_pen: Optional[torch.Tensor] = None,
        *,
        valid_mask: Optional[torch.Tensor] = None,
        training: bool = False,
        return_details: bool = True,
    ) -> Dict[str, torch.Tensor]:
        return self.forward(
            o41["s_seq"],
            o42["f_freq"],
            o41["g_vec"],
            e_pen,
            valid_mask=valid_mask,
            training=training,
            return_details=return_details,
        )

    def save_checkpoint(self, path, extra: Optional[dict] = None) -> None:
        torch.save(
            {"config": self.config, "state_dict": self.state_dict(), "extra": extra or {}, "scheme": "v2"},
            path,
        )

    @classmethod
    def load_checkpoint(cls, path, map_location=None, strict: bool = True) -> "Section43EncoderV2":
        payload = torch.load(path, map_location=map_location, weights_only=False)
        cfg = payload.get("config") or Section43ConfigV2()
        if isinstance(cfg, dict):
            cfg = Section43ConfigV2(**cfg)
        elif isinstance(cfg, Section43Config) and not isinstance(cfg, Section43ConfigV2):
            cfg = Section43ConfigV2(**vars(cfg))
        model = cls(cfg)
        model.load_state_dict(payload["state_dict"], strict=strict)
        return model


def build_section43_encoder(
    config: Optional[Section43Config] = None,
    *,
    use_v2: bool = False,
    use_v3: bool = False,
    use_v3_1: bool = False,
) -> nn.Module:
    """兼容入口:实现见 section43_v3 / section43_v3_1。"""
    if use_v3_1:
        from section43_v3_1 import Section43ConfigV3_1, Section43EncoderV3_1

        if config is None:
            return Section43EncoderV3_1()
        if isinstance(config, Section43ConfigV3_1):
            return Section43EncoderV3_1(config)
        return Section43EncoderV3_1(
            Section43ConfigV3_1(
                **{
                    k: v
                    for k, v in vars(config).items()
                    if k in Section43ConfigV3_1.__dataclass_fields__
                }
            )
        )

    from section43_v3 import build_section43_encoder as _build

    return _build(config, use_v2=use_v2, use_v3=use_v3)