Datasets:

zhizeng115
/

EchoScout-FourTask

"""ST-Audio Encoder：时间分辨空间音频编码器（对齐 Oh et al. 2026）。
前端可配置（`audio_frontend`）：
  - "binaural"（默认）：BinauralFeatureExtractor(2ch→logmel×2+IPD×2=4ch) →
    conv_downsample(4→1)。conv_downsample/backbone/head(355)/fc_norm/pos_embed/cls_tokens
    全继承 BAT `finetuned.pth`（双声道域,零迁移）——即论文 stage1+2 已由 BAT 训好,只需训 stage3。
    **不建静态 DoA/dist 头**（stage1/2 跳过；静态定位 token 本就不进 LLM）。
  - "foa"：FOAFeatureExtractor(4ch→7ch) → foa_conv(7→1)（随机初始化,需 FOA 域 stage1+2）。
    建 doa_head/dist_head（论文 stage2 的静态全局定位头）。
公共结构：12 层 backbone → 3 全局 token(semantic[/DoA/dist]) + 512 patch；patch reshape
[T'=64,F'=8] → 频率维平均 → 插值 40 bin → 2 层时序 self-attn → 逐 bin 动态头
(activity/direction/log-distance)。送 LLM = [semantic_token] ++ [40 temporal] = 41 token。
命名约定（ckpt 继承）：binaural 前端 conv 用 `conv_downsample`(4→1) 以继承 finetuned.pth；
foa 前端 conv 用 `foa_conv`(7→1) 避开同名不同 shape 冲突（strict=False 仍会 raise size mismatch）。
"""

from dataclasses import dataclass
from functools import partial
from typing import Optional

import torch
import torch.nn as nn
import torch.nn.functional as F

from .binaural_features import BinauralFeatureExtractor
from .foa_features import FOAFeatureExtractor
from .spatial_ast import PatchEmbed_new, conv3x3
from .vision_transformer import Block, VisionTransformer


@dataclass
class STEncoderOutput:
    audio_tokens: torch.Tensor      # [B,41,768]
    semantic_logits: torch.Tensor   # [B,355]
    class75_logits: torch.Tensor    # [B,75]
    activity: torch.Tensor          # [B,40] logit
    direction: torch.Tensor         # [B,40,3] 单位向量
    log_distance: torch.Tensor      # [B,40]
    doa_vec: Optional[torch.Tensor] = None   # [B,3] 单位向量；仅 foa 前端(静态定位头)有
    dist: Optional[torch.Tensor] = None      # [B,1] log 距离；仅 foa 前端有


class STAudioEncoder(VisionTransformer):
    def __init__(self, audio_frontend="binaural", num_classes=355, embed_dim=768,
                 depth=12, num_heads=12, audio_bins=40, temporal_layers=2,
                 mlp_ratio=4, qkv_bias=True, drop_path_rate=0.1, patch_size=16,
                 norm_layer=partial(nn.LayerNorm, eps=1e-6)):
        super().__init__(
            num_classes=num_classes, drop_path_rate=drop_path_rate,
            patch_size=patch_size, embed_dim=embed_dim, depth=depth,
            num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias,
            norm_layer=norm_layer,
        )
        if audio_frontend not in ("binaural", "foa"):
            raise ValueError(f"audio_frontend must be 'binaural' or 'foa', got {audio_frontend!r}")
        self.audio_frontend = audio_frontend
        img_size = (1024, 128)
        self.audio_bins = audio_bins

        # 3 个静态全局 token：semantic / DoA / distance（继承 finetuned.pth cls_tokens(1,3,768)）
        del self.cls_token
        self.num_cls_tokens = 3
        self.cls_tokens = nn.Parameter(torch.zeros(1, 3, embed_dim))

        self.patch_embed = PatchEmbed_new(
            img_size=img_size, patch_size=(16, 16), in_chans=1,
            embed_dim=embed_dim, stride=16,
        )
        num_patches = self.patch_embed.num_patches           # 64*8 = 512
        self.patch_hw = self.patch_embed.patch_hw            # (64, 8)
        self.pos_embed = nn.Parameter(
            torch.zeros(1, num_patches + 1, embed_dim), requires_grad=False
        )

        # 前端 + 通道下采样 conv（命名决定能否继承 finetuned.pth）
        if audio_frontend == "binaural":
            self.in_chans = 2
            self.binaural = BinauralFeatureExtractor()
            self.conv_downsample = nn.Sequential(conv3x3(4, 1), nn.BatchNorm2d(1), nn.GELU())
            self.doa_head = None     # stage1/2 跳过：无静态定位头
            self.dist_head = None
        else:  # foa
            self.in_chans = 4
            self.foa = FOAFeatureExtractor()
            self.foa_conv = nn.Sequential(conv3x3(7, 1), nn.BatchNorm2d(1), nn.GELU())
            self.doa_head = nn.Linear(embed_dim, 3)
            self.dist_head = nn.Linear(embed_dim, 1)

        # 语义头 self.head(355) 与 fc_norm 继承自基类/ckpt
        self.fc_norm = norm_layer(embed_dim)
        self.class75_head = nn.Linear(embed_dim, 75)

        # 时序分支（stage3 新增,随机初始化）
        dpr = [0.0] * temporal_layers
        self.temporal_blocks = nn.ModuleList([
            Block(dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio,
                  qkv_bias=qkv_bias, drop_path=dpr[i], norm_layer=norm_layer)
            for i in range(temporal_layers)
        ])
        self.act_head = nn.Linear(embed_dim, 1)
        self.dir_head = nn.Linear(embed_dim, 3)
        self.logdist_head = nn.Linear(embed_dim, 1)

        del self.norm  # 与原 Spatial-AST 一致：不在 backbone 末尾再 norm

    def _frontend(self, waveforms):
        if self.audio_frontend == "binaural":
            return self.conv_downsample(self.binaural(waveforms))   # [B,1,1024,128]
        return self.foa_conv(self.foa(waveforms))                   # [B,1,1024,128]

    def forward_backbone(self, waveforms):
        if waveforms.dim() != 3 or waveforms.shape[1] != self.in_chans:
            raise ValueError(
                f"audio_frontend={self.audio_frontend!r} 需要 [B,{self.in_chans},T] 波形，"
                f"收到 {tuple(waveforms.shape)}"
            )
        x = self._frontend(waveforms)               # [B,1,1024,128]
        x = self.patch_embed(x)                     # [B,512,768]
        x = x + self.pos_embed[:, 1:, :]
        cls = self.cls_tokens.expand(x.shape[0], -1, -1)
        x = torch.cat([cls, x], dim=1)              # [B,515,768]
        x = self.pos_drop(x)
        for blk in self.blocks:
            x = blk(x)
        return x                                    # [B,515,768]

    def forward(self, waveforms):
        x = self.forward_backbone(waveforms)
        B = x.shape[0]
        sem_t, doa_t, dist_t = x[:, 0], x[:, 1], x[:, 2]
        patches = x[:, 3:]                          # [B,512,768]

        norm_sem = self.fc_norm(sem_t)
        semantic_logits = self.head(norm_sem)
        class75_logits = self.class75_head(norm_sem)
        doa_vec = dist = None
        if self.doa_head is not None:               # 仅 foa 前端
            doa_vec = F.normalize(self.doa_head(self.fc_norm(doa_t)), dim=-1)
            dist = self.dist_head(self.fc_norm(dist_t))

        # patch → [T'=64, F'=8] → 频率平均 → 插值 40 → 时序 self-attn
        Tp, Fp = self.patch_hw
        grid = patches.reshape(B, Tp, Fp, -1).mean(dim=2)      # [B,64,768]
        temporal = F.interpolate(
            grid.transpose(1, 2), size=self.audio_bins,
            mode="linear", align_corners=False,
        ).transpose(1, 2)                                      # [B,40,768]
        for blk in self.temporal_blocks:
            temporal = blk(temporal)

        activity = self.act_head(temporal).squeeze(-1)         # [B,40]
        direction = F.normalize(self.dir_head(temporal), dim=-1)  # [B,40,3]
        log_distance = self.logdist_head(temporal).squeeze(-1) # [B,40]

        audio_tokens = torch.cat([sem_t.unsqueeze(1), temporal], dim=1)  # [B,41,768]

        return STEncoderOutput(
            audio_tokens=audio_tokens,
            semantic_logits=semantic_logits,
            class75_logits=class75_logits,
            activity=activity, direction=direction, log_distance=log_distance,
            doa_vec=doa_vec, dist=dist,
        )

	"""ST-Audio Encoder：时间分辨空间音频编码器（对齐 Oh et al. 2026）。

	前端可配置（`audio_frontend`）：
	- "binaural"（默认）：BinauralFeatureExtractor(2ch→logmel×2+IPD×2=4ch) →
	conv_downsample(4→1)。conv_downsample/backbone/head(355)/fc_norm/pos_embed/cls_tokens
	全继承 BAT `finetuned.pth`（双声道域,零迁移）——即论文 stage1+2 已由 BAT 训好,只需训 stage3。
	不建静态 DoA/dist 头（stage1/2 跳过；静态定位 token 本就不进 LLM）。
	- "foa"：FOAFeatureExtractor(4ch→7ch) → foa_conv(7→1)（随机初始化,需 FOA 域 stage1+2）。
	建 doa_head/dist_head（论文 stage2 的静态全局定位头）。

	公共结构：12 层 backbone → 3 全局 token(semantic[/DoA/dist]) + 512 patch；patch reshape
	[T'=64,F'=8] → 频率维平均 → 插值 40 bin → 2 层时序 self-attn → 逐 bin 动态头
	(activity/direction/log-distance)。送 LLM = [semantic_token] ++ [40 temporal] = 41 token。

	命名约定（ckpt 继承）：binaural 前端 conv 用 `conv_downsample`(4→1) 以继承 finetuned.pth；
	foa 前端 conv 用 `foa_conv`(7→1) 避开同名不同 shape 冲突（strict=False 仍会 raise size mismatch）。
	"""

	from dataclasses import dataclass
	from functools import partial
	from typing import Optional

	import torch
	import torch.nn as nn
	import torch.nn.functional as F

	from .binaural_features import BinauralFeatureExtractor
	from .foa_features import FOAFeatureExtractor
	from .spatial_ast import PatchEmbed_new, conv3x3
	from .vision_transformer import Block, VisionTransformer


	@dataclass
	class STEncoderOutput:
	audio_tokens: torch.Tensor # [B,41,768]
	semantic_logits: torch.Tensor # [B,355]
	class75_logits: torch.Tensor # [B,75]
	activity: torch.Tensor # [B,40] logit
	direction: torch.Tensor # [B,40,3] 单位向量
	log_distance: torch.Tensor # [B,40]
	doa_vec: Optional[torch.Tensor] = None # [B,3] 单位向量；仅 foa 前端(静态定位头)有
	dist: Optional[torch.Tensor] = None # [B,1] log 距离；仅 foa 前端有


	class STAudioEncoder(VisionTransformer):
	def __init__(self, audio_frontend="binaural", num_classes=355, embed_dim=768,
	depth=12, num_heads=12, audio_bins=40, temporal_layers=2,
	mlp_ratio=4, qkv_bias=True, drop_path_rate=0.1, patch_size=16,
	norm_layer=partial(nn.LayerNorm, eps=1e-6)):
	super().__init__(
	num_classes=num_classes, drop_path_rate=drop_path_rate,
	patch_size=patch_size, embed_dim=embed_dim, depth=depth,
	num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias,
	norm_layer=norm_layer,
	)
	if audio_frontend not in ("binaural", "foa"):
	raise ValueError(f"audio_frontend must be 'binaural' or 'foa', got {audio_frontend!r}")
	self.audio_frontend = audio_frontend
	img_size = (1024, 128)
	self.audio_bins = audio_bins

	# 3 个静态全局 token：semantic / DoA / distance（继承 finetuned.pth cls_tokens(1,3,768)）
	del self.cls_token
	self.num_cls_tokens = 3
	self.cls_tokens = nn.Parameter(torch.zeros(1, 3, embed_dim))

	self.patch_embed = PatchEmbed_new(
	img_size=img_size, patch_size=(16, 16), in_chans=1,
	embed_dim=embed_dim, stride=16,
	)
	num_patches = self.patch_embed.num_patches # 64*8 = 512
	self.patch_hw = self.patch_embed.patch_hw # (64, 8)
	self.pos_embed = nn.Parameter(
	torch.zeros(1, num_patches + 1, embed_dim), requires_grad=False
	)

	# 前端 + 通道下采样 conv（命名决定能否继承 finetuned.pth）
	if audio_frontend == "binaural":
	self.in_chans = 2
	self.binaural = BinauralFeatureExtractor()
	self.conv_downsample = nn.Sequential(conv3x3(4, 1), nn.BatchNorm2d(1), nn.GELU())
	self.doa_head = None # stage1/2 跳过：无静态定位头
	self.dist_head = None
	else: # foa
	self.in_chans = 4
	self.foa = FOAFeatureExtractor()
	self.foa_conv = nn.Sequential(conv3x3(7, 1), nn.BatchNorm2d(1), nn.GELU())
	self.doa_head = nn.Linear(embed_dim, 3)
	self.dist_head = nn.Linear(embed_dim, 1)

	# 语义头 self.head(355) 与 fc_norm 继承自基类/ckpt
	self.fc_norm = norm_layer(embed_dim)
	self.class75_head = nn.Linear(embed_dim, 75)

	# 时序分支（stage3 新增,随机初始化）
	dpr = [0.0] * temporal_layers
	self.temporal_blocks = nn.ModuleList([
	Block(dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio,
	qkv_bias=qkv_bias, drop_path=dpr[i], norm_layer=norm_layer)
	for i in range(temporal_layers)
	])
	self.act_head = nn.Linear(embed_dim, 1)
	self.dir_head = nn.Linear(embed_dim, 3)
	self.logdist_head = nn.Linear(embed_dim, 1)

	del self.norm # 与原 Spatial-AST 一致：不在 backbone 末尾再 norm

	def _frontend(self, waveforms):
	if self.audio_frontend == "binaural":
	return self.conv_downsample(self.binaural(waveforms)) # [B,1,1024,128]
	return self.foa_conv(self.foa(waveforms)) # [B,1,1024,128]

	def forward_backbone(self, waveforms):
	if waveforms.dim() != 3 or waveforms.shape[1] != self.in_chans:
	raise ValueError(
	f"audio_frontend={self.audio_frontend!r} 需要 [B,{self.in_chans},T] 波形，"
	f"收到 {tuple(waveforms.shape)}"
	)
	x = self._frontend(waveforms) # [B,1,1024,128]
	x = self.patch_embed(x) # [B,512,768]
	x = x + self.pos_embed[:, 1:, :]
	cls = self.cls_tokens.expand(x.shape[0], -1, -1)
	x = torch.cat([cls, x], dim=1) # [B,515,768]
	x = self.pos_drop(x)
	for blk in self.blocks:
	x = blk(x)
	return x # [B,515,768]

	def forward(self, waveforms):
	x = self.forward_backbone(waveforms)
	B = x.shape[0]
	sem_t, doa_t, dist_t = x[:, 0], x[:, 1], x[:, 2]
	patches = x[:, 3:] # [B,512,768]

	norm_sem = self.fc_norm(sem_t)
	semantic_logits = self.head(norm_sem)
	class75_logits = self.class75_head(norm_sem)
	doa_vec = dist = None
	if self.doa_head is not None: # 仅 foa 前端
	doa_vec = F.normalize(self.doa_head(self.fc_norm(doa_t)), dim=-1)
	dist = self.dist_head(self.fc_norm(dist_t))

	# patch → [T'=64, F'=8] → 频率平均 → 插值 40 → 时序 self-attn
	Tp, Fp = self.patch_hw
	grid = patches.reshape(B, Tp, Fp, -1).mean(dim=2) # [B,64,768]
	temporal = F.interpolate(
	grid.transpose(1, 2), size=self.audio_bins,
	mode="linear", align_corners=False,
	).transpose(1, 2) # [B,40,768]
	for blk in self.temporal_blocks:
	temporal = blk(temporal)

	activity = self.act_head(temporal).squeeze(-1) # [B,40]
	direction = F.normalize(self.dir_head(temporal), dim=-1) # [B,40,3]
	log_distance = self.logdist_head(temporal).squeeze(-1) # [B,40]

	audio_tokens = torch.cat([sem_t.unsqueeze(1), temporal], dim=1) # [B,41,768]

	return STEncoderOutput(
	audio_tokens=audio_tokens,
	semantic_logits=semantic_logits,
	class75_logits=class75_logits,
	activity=activity, direction=direction, log_distance=log_distance,
	doa_vec=doa_vec, dist=dist,
	)