Download code/section42_cwt.py from qinxunhui/deepellipse-circleid: direct link, hf CLI and curl.
- Browser
- Download file 11.6 kB
-
https://huggingface.co/qinxunhui/deepellipse-circleid/resolve/main/code/section42_cwt.py
- Command line
-
hf download hf://qinxunhui/deepellipse-circleid/code/section42_cwt.py
-
curl -L -o section42_cwt.py https://huggingface.co/qinxunhui/deepellipse-circleid/resolve/main/code/section42_cwt.py
11.6 kB
| """ | |
| §4.2 扩展:CWT 角向谱先验 φ(t)。 | |
| 从 S_res 或预计算 scalogram 构造逐角位 Query 特征,供 §4.3 CWT-GAPA 使用。 | |
| """ | |
| from __future__ import annotations | |
| from dataclasses import dataclass | |
| from typing import Dict, List, Optional, Tuple, TYPE_CHECKING | |
| import numpy as np | |
| import torch | |
| import torch.nn as nn | |
| from elipse_feature import ( | |
| CWT_N_SCALES_DEFAULT, | |
| CWT_WAVELET_DEFAULT, | |
| S_RES_CHANNELS, | |
| compute_cwt_scalogram, | |
| default_cwt_scale_indices, | |
| default_cwt_scales, | |
| ) | |
| from section41 import ( | |
| Section41Encoder, | |
| ) | |
| from section42 import Section42Encoder | |
| from section43 import ( | |
| build_enc43_valid_mask_kwargs, | |
| forward_pipeline_batch_to_upstream, | |
| ) | |
| from section43_v3 import ConvNeXt1DPyramid | |
| if TYPE_CHECKING: | |
| from section43 import Section43Encoder | |
| class Section42CWTConfig: | |
| d_phi: int = 64 | |
| n_scales: int = CWT_N_SCALES_DEFAULT | |
| wavelet: str = CWT_WAVELET_DEFAULT | |
| mlp_hidden: int = 128 | |
| dropout: float = 0.1 | |
| scale_affinity: bool = False | |
| scale_index_mode: str = "uniform" # uniform | physics | |
| n_stages: int = 4 | |
| def _numpy_cwt_batch(s_res: torch.Tensor, cfg: Section42CWTConfig) -> torch.Tensor: | |
| """s_res (B, N, 4) → cwt_scalo (B, 4, K, N) on CPU numpy。""" | |
| arr = s_res.detach().cpu().numpy() | |
| scales = default_cwt_scales(cfg.n_scales) | |
| batch = [] | |
| for i in range(arr.shape[0]): | |
| batch.append(compute_cwt_scalogram(arr[i], scales=scales, wavelet=cfg.wavelet)) | |
| out = np.stack(batch, axis=0) | |
| return torch.from_numpy(out) | |
| class CWTPhiEncoder(nn.Module): | |
| """ | |
| scalogram |W(a,b)| → φ(t)。 | |
| 统一 MLP(scale_affinity=False):四通道×K 尺度展平 → φ(t) ∈ R^{d_phi}。 | |
| scale_affinity=True 时由 §4.3 CWTAngularStagePool 按 stage 子集编码。 | |
| """ | |
| def __init__(self, cfg: Optional[Section42CWTConfig] = None): | |
| super().__init__() | |
| self.config = cfg or Section42CWTConfig() | |
| c = self.config | |
| in_dim = S_RES_CHANNELS * c.n_scales | |
| self.mlp = nn.Sequential( | |
| nn.Linear(in_dim, c.mlp_hidden), | |
| nn.GELU(), | |
| nn.Dropout(c.dropout), | |
| nn.Linear(c.mlp_hidden, c.d_phi), | |
| ) | |
| def raw_dim(self) -> int: | |
| return S_RES_CHANNELS * self.config.n_scales | |
| def encode_scalogram(self, cwt_scalo: torch.Tensor) -> torch.Tensor: | |
| """ | |
| cwt_scalo: (B, 4, K, N_theta) | |
| → phi_cwt: (B, N_theta, d_phi) | |
| """ | |
| b, _, k, n = cwt_scalo.shape | |
| flat = cwt_scalo.permute(0, 3, 1, 2).reshape(b * n, -1) | |
| phi = self.mlp(flat).reshape(b, n, -1) | |
| return phi | |
| def forward( | |
| self, | |
| s_res: torch.Tensor, | |
| *, | |
| cwt_scalo: Optional[torch.Tensor] = None, | |
| return_scalogram: bool = False, | |
| ) -> Dict[str, torch.Tensor]: | |
| """ | |
| s_res: (B, N_theta, 4) 或 (N_theta, 4) | |
| cwt_scalo: 可选预计算 (B, 4, K, N_theta) | |
| """ | |
| batched = s_res.dim() == 3 | |
| if not batched: | |
| s_res = s_res.unsqueeze(0) | |
| if cwt_scalo is not None and cwt_scalo.dim() == 3: | |
| cwt_scalo = cwt_scalo.unsqueeze(0) | |
| if cwt_scalo is None: | |
| cwt_scalo = _numpy_cwt_batch(s_res, self.config).to( | |
| device=s_res.device, dtype=s_res.dtype | |
| ) | |
| else: | |
| cwt_scalo = cwt_scalo.to(device=s_res.device, dtype=s_res.dtype) | |
| out: Dict[str, torch.Tensor] = {"cwt_scalo": cwt_scalo} | |
| if not self.config.scale_affinity: | |
| out["phi_cwt"] = self.encode_scalogram(cwt_scalo) | |
| if not batched: | |
| squeezed: Dict[str, torch.Tensor] = {} | |
| for k, v in out.items(): | |
| squeezed[k] = v.squeeze(0) | |
| out = squeezed | |
| return out | |
| class CWTStagePhiEncoder(nn.Module): | |
| """scale_affinity=True:每 stage 独立 MLP,输入为该 stage 尺度子集。""" | |
| def __init__(self, cfg: Section42CWTConfig, scale_indices: List[List[int]]): | |
| super().__init__() | |
| self.scale_indices = scale_indices | |
| self.mlps = nn.ModuleList() | |
| for idx in scale_indices: | |
| in_dim = S_RES_CHANNELS * len(idx) | |
| self.mlps.append( | |
| nn.Sequential( | |
| nn.Linear(in_dim, cfg.mlp_hidden), | |
| nn.GELU(), | |
| nn.Dropout(cfg.dropout), | |
| nn.Linear(cfg.mlp_hidden, cfg.d_phi), | |
| ) | |
| ) | |
| def forward(self, cwt_scalo: torch.Tensor) -> List[torch.Tensor]: | |
| """ | |
| cwt_scalo: (B, 4, K, N) | |
| → list of phi_s_full (B, N, d_phi),长度 = n_stages | |
| """ | |
| b, _, _, n = cwt_scalo.shape | |
| outputs: List[torch.Tensor] = [] | |
| for mlp, idx in zip(self.mlps, self.scale_indices): | |
| sub = cwt_scalo[:, :, idx, :] | |
| flat = sub.permute(0, 3, 1, 2).reshape(b * n, -1) | |
| phi = mlp(flat).reshape(b, n, -1) | |
| outputs.append(phi) | |
| return outputs | |
| class CWTStagePhiEncoderValid(nn.Module): | |
| """ | |
| E2b:scale 子集展平 + valid embedding → MLP → φ_raw。 | |
| valid_ang: (B, N) 或 None(默认全 1)。 | |
| """ | |
| def __init__( | |
| self, | |
| cfg: Section42CWTConfig, | |
| scale_indices: List[List[int]], | |
| valid_emb_dim: int = 8, | |
| ): | |
| super().__init__() | |
| self.valid_emb_dim = valid_emb_dim | |
| self.scale_indices = scale_indices | |
| self.valid_emb = nn.Embedding(2, valid_emb_dim) | |
| self.mlps = nn.ModuleList() | |
| for idx in scale_indices: | |
| in_dim = S_RES_CHANNELS * len(idx) + valid_emb_dim | |
| self.mlps.append( | |
| nn.Sequential( | |
| nn.Linear(in_dim, cfg.mlp_hidden), | |
| nn.GELU(), | |
| nn.Dropout(cfg.dropout), | |
| nn.Linear(cfg.mlp_hidden, cfg.d_phi), | |
| ) | |
| ) | |
| def forward( | |
| self, | |
| cwt_scalo: torch.Tensor, | |
| valid_ang: Optional[torch.Tensor] = None, | |
| ) -> List[torch.Tensor]: | |
| b, _, _, n = cwt_scalo.shape | |
| if valid_ang is None: | |
| valid_ang = torch.ones( | |
| b, n, device=cwt_scalo.device, dtype=cwt_scalo.dtype | |
| ) | |
| elif valid_ang.dim() == 1: | |
| valid_ang = valid_ang.unsqueeze(0).expand(b, -1) | |
| valid_idx = valid_ang.long().clamp(0, 1) | |
| valid_emb = self.valid_emb(valid_idx) | |
| outputs: List[torch.Tensor] = [] | |
| for mlp, idx in zip(self.mlps, self.scale_indices): | |
| sub = cwt_scalo[:, :, idx, :] | |
| flat = sub.permute(0, 3, 1, 2).reshape(b * n, -1) | |
| vemb = valid_emb.reshape(b * n, self.valid_emb_dim) | |
| x = torch.cat([flat, vemb], dim=-1) | |
| phi = mlp(x).reshape(b, n, -1) | |
| outputs.append(phi) | |
| return outputs | |
| def build_scale_indices( | |
| cfg: Section42CWTConfig, | |
| *, | |
| n_theta: int = 360, | |
| ) -> List[List[int]]: | |
| if cfg.scale_index_mode == "physics": | |
| try: | |
| from elipse_feature import physics_cwt_scale_indices | |
| except ImportError as exc: | |
| raise ImportError( | |
| "cwt scale_index_mode=physics 需要新版 elipse_feature.py " | |
| "(含 physics_cwt_scale_indices);请同步 elipse_feature.py " | |
| "或改用 scale_index_mode=uniform(E2b 默认)" | |
| ) from exc | |
| return physics_cwt_scale_indices( | |
| cfg.n_scales, | |
| cfg.n_stages, | |
| n_theta=n_theta, | |
| wavelet=cfg.wavelet, | |
| ) | |
| return default_cwt_scale_indices(cfg.n_scales, cfg.n_stages) | |
| def flatten_scalogram(cwt_scalo: torch.Tensor) -> torch.Tensor: | |
| """ | |
| cwt_scalo (B, 4, K, N_theta) → (B, 4*K, N_theta) 供 1D CNN 金字塔。 | |
| """ | |
| b, c, k, n = cwt_scalo.shape | |
| return cwt_scalo.permute(0, 3, 1, 2).reshape(b, n, c * k).transpose(1, 2) | |
| class CWTPyramid(nn.Module): | |
| """ | |
| Scalogram 1D CNN 金字塔,结构与 ConvNeXt1DPyramid 同构(360→180→90→45→22)。 | |
| """ | |
| def __init__( | |
| self, | |
| in_channels: int, | |
| dims: Tuple[int, ...] = (96, 192, 384, 768), | |
| depths: Tuple[int, ...] = (3, 3, 9, 3), | |
| *, | |
| stem_kernel: int = 4, | |
| stem_stride: int = 2, | |
| dw_kernel: int = 7, | |
| mlp_ratio: int = 4, | |
| ): | |
| super().__init__() | |
| self.pyramid = ConvNeXt1DPyramid( | |
| in_channels=in_channels, | |
| dims=dims, | |
| depths=depths, | |
| stem_kernel=stem_kernel, | |
| stem_stride=stem_stride, | |
| dw_kernel=dw_kernel, | |
| mlp_ratio=mlp_ratio, | |
| ) | |
| def forward(self, cwt_scalo: torch.Tensor) -> List[torch.Tensor]: | |
| """ | |
| cwt_scalo: (B, 4, K, N) | |
| → list of H_cwt^s (B, C_s, L_s),长度 = n_stages | |
| """ | |
| x = flatten_scalogram(cwt_scalo) | |
| _, pyramid_feats = self.pyramid(x) | |
| return pyramid_feats | |
| def cwt_pyramid_in_channels(n_scales: int, n_ch: int = S_RES_CHANNELS) -> int: | |
| return n_ch * n_scales | |
| class CWTStageProjector(nn.Module): | |
| """各 CWT pyramid stage 投影到 d_h。""" | |
| def __init__(self, stage_dims: Tuple[int, ...], d_h: int): | |
| super().__init__() | |
| self.projs = nn.ModuleList([nn.Linear(c, d_h) for c in stage_dims]) | |
| def forward(self, stage_idx: int, x: torch.Tensor) -> torch.Tensor: | |
| """x: (B, C_s, L_s) → (B, L_s, d_h)""" | |
| return self.projs[stage_idx](x.transpose(1, 2)) | |
| def enrich_o42_with_cwt( | |
| o42: Dict[str, torch.Tensor], | |
| s_res_b: torch.Tensor, | |
| cwt_phi_encoder: nn.Module, | |
| cwt_scalo_batch: Optional[torch.Tensor], | |
| device: torch.device, | |
| ) -> Dict[str, torch.Tensor]: | |
| """将 CWT 角向特征注入 §4.2 输出,供 §4.3 CWT-GAPA 使用。""" | |
| cwt_out = cwt_phi_encoder( | |
| s_res_b, | |
| cwt_scalo=cwt_scalo_batch.to(device) if cwt_scalo_batch is not None else None, | |
| ) | |
| if "phi_cwt" in cwt_out: | |
| o42["phi_cwt"] = cwt_out["phi_cwt"] | |
| o42["cwt_scalo"] = cwt_out["cwt_scalo"] | |
| return o42 | |
| def forward_pipeline_batch_from_dataloader_cwt( | |
| fea_tensor, | |
| img_tensor: torch.Tensor, | |
| enc41: Section41Encoder, | |
| enc42: Section42Encoder, | |
| enc43: "Section43Encoder", | |
| *, | |
| half_norm: float, | |
| e_pen: Optional[torch.Tensor] = None, | |
| training: bool = False, | |
| cwt_phi_encoder: nn.Module, | |
| cwt_scalo_batch: Optional[torch.Tensor] = None, | |
| ) -> Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor], Dict[str, torch.Tensor]]: | |
| """ | |
| CWT-GAPA:复用 section43 原始 §4.1/§4.2 流水线,仅在 enc43 前注入 CWT。 | |
| §4.3 ConvNeXt1D 金字塔与 stage_proj 与 DBSA/global 完全一致,便于从旧 checkpoint 微调。 | |
| """ | |
| device = next(enc43.parameters()).device | |
| o41, o42 = forward_pipeline_batch_to_upstream( | |
| fea_tensor, img_tensor, enc41, enc42, half_norm=half_norm | |
| ) | |
| s_res_b = fea_tensor.fields.s_res.float().to(device) | |
| o42 = enrich_o42_with_cwt(o42, s_res_b, cwt_phi_encoder, cwt_scalo_batch, device) | |
| enc43_kwargs = build_enc43_valid_mask_kwargs(enc43, fea_tensor, device) | |
| o43 = enc43.forward_from_upstream( | |
| o41, o42, e_pen, training=training, return_details=not training, **enc43_kwargs | |
| ) | |
| return o41, o42, o43 | |
| if __name__ == "__main__": | |
| enc = CWTPhiEncoder() | |
| s_res = torch.randn(2, 360, 4) | |
| out = enc(s_res, return_scalogram=True) | |
| print("phi_cwt", tuple(out["phi_cwt"].shape)) | |
| print("cwt_scalo", tuple(out["cwt_scalo"].shape)) | |