import os import sys import torch import torch.nn as nn import torch.nn.functional as F import torchvision.models as models try: import timm except ImportError: timm = None try: import utils from modules.criterions import SeqKD from modules import BiLSTMLayer, TemporalConv except: from . import utils from .modules.criterions import SeqKD from .modules import BiLSTMLayer, TemporalConv # PoseAssistEncoder is defined below in this file, so always available POSE_ASSIST_AVAILABLE = True # 全局日志文件路径（会在第一次使用时设置） _MODEL_LOG_FILE = None def _log_model_info(msg): """同时输出到stdout和日志文件""" print(msg, flush=True) sys.stdout.flush() # 强制刷新stdout global _MODEL_LOG_FILE if _MODEL_LOG_FILE is None: # 尝试找到work_dir import glob work_dirs = glob.glob('work_dir/*/log.txt') if work_dirs: log_path = work_dirs[0] _MODEL_LOG_FILE = log_path if _MODEL_LOG_FILE and os.path.exists(os.path.dirname(_MODEL_LOG_FILE)): try: with open(_MODEL_LOG_FILE, 'a') as f: f.write(msg + '\n') f.flush() except: pass # 如果写入失败，至少print了 class Identity(nn.Module): def __init__(self): super(Identity, self).__init__() def forward(self, x): return x class NormLinear(nn.Module): def __init__(self, in_dim, out_dim): super(NormLinear, self).__init__() self.weight = nn.Parameter(torch.Tensor(in_dim, out_dim)) nn.init.xavier_uniform_(self.weight, gain=nn.init.calculate_gain('relu')) def forward(self, x): outputs = torch.matmul(x, F.normalize(self.weight, dim=0)) return outputs class TimmBackbone(nn.Module): """Small wrapper so timm backbones behave like torchvision CNNs.""" def __init__(self, model): super().__init__() self.model = model def forward(self, x): outputs = self.model(x) if isinstance(outputs, (tuple, list)): outputs = outputs[0] # ViT-style models can return (B, Tokens, Dim); take CLS token. if outputs.dim() == 3: outputs = outputs[:, 0] return outputs class PoseAssistEncoder(nn.Module): """Simplified pose assistance encoder using ViT backbone with frozen weights.""" def __init__(self, target_dim=512, checkpoint_path=None): super().__init__() _log_model_info("=" * 70) _log_model_info("[PoseAssist] Initializing Pose Assistance Encoder") _log_model_info("=" * 70) _log_model_info("[PoseAssist] Loading ViT-base-patch16-224 from timm...") _log_model_info("[PoseAssist] This may take a moment if downloading pretrained weights...") import time start_time = time.time() # Use ViT-base for feature extraction self.backbone = timm.create_model('vit_base_patch16_224', pretrained=True, num_classes=0) load_time = time.time() - start_time _log_model_info(f"[PoseAssist] ✓ ViT backbone loaded in {load_time:.2f} seconds") # Count parameters vit_params = sum(p.numel() for p in self.backbone.parameters()) _log_model_info(f"[PoseAssist] ViT parameters: {vit_params:,}") _log_model_info("[PoseAssist] Initializing temporal attention and projection layers...") self.temporal_attention = nn.MultiheadAttention(768, num_heads=8) self.temporal_norm = nn.LayerNorm(768) # Project to match ResNet output dimension self.projection = nn.Linear(768, target_dim) _log_model_info(f"[PoseAssist] Projection layer: 768 → {target_dim}") # Load from checkpoint if provided if checkpoint_path and os.path.exists(checkpoint_path): _log_model_info(f"[PoseAssist] Found video2text checkpoint: {checkpoint_path}") self._load_from_video2text_checkpoint(checkpoint_path) else: if checkpoint_path: _log_model_info(f"[PoseAssist] ⚠ Checkpoint not found: {checkpoint_path}") _log_model_info("[PoseAssist] Using timm pretrained ViT weights only") # Freeze all parameters _log_model_info("[PoseAssist] Freezing all parameters...") for param in self.parameters(): param.requires_grad = False total_params = sum(p.numel() for p in self.parameters()) trainable_params = sum(p.numel() for p in self.parameters() if p.requires_grad) _log_model_info(f"[PoseAssist] Total parameters: {total_params:,}") _log_model_info(f"[PoseAssist] Trainable parameters: {trainable_params:,}") _log_model_info(f"[PoseAssist] ✓ All parameters frozen (requires_grad=False)") _log_model_info("=" * 70) def _load_from_video2text_checkpoint(self, checkpoint_path): """Load weights from video2text checkpoint.""" try: _log_model_info(f"[PoseAssist] Loading weights from {checkpoint_path}") checkpoint = torch.load(checkpoint_path, map_location='cpu') # Extract video2pose state dict if 'model_state_dict' in checkpoint: model_state = checkpoint['model_state_dict'] # Filter video2pose weights video2pose_state = { k.replace('video2pose.', ''): v for k, v in model_state.items() if k.startswith('video2pose.') } if video2pose_state: # Load matching weights (strict=False to allow partial loading) missing, unexpected = self.load_state_dict(video2pose_state, strict=False) _log_model_info(f"[PoseAssist] Loaded weights from checkpoint") if missing: _log_model_info(f"[PoseAssist] Missing keys: {len(missing)}") if unexpected: _log_model_info(f"[PoseAssist] Unexpected keys: {len(unexpected)}") else: _log_model_info("[PoseAssist] No video2pose weights found in checkpoint, using pretrained ViT") else: _log_model_info("[PoseAssist] Checkpoint format not recognized, using pretrained ViT") except Exception as e: _log_model_info(f"[PoseAssist] Failed to load checkpoint: {e}, using pretrained ViT") def forward(self, x): """ Args: x: [B*F, 3, H, W] frames Returns: features: [B*F, target_dim] frame-level features """ with torch.no_grad(): # Ensure no gradients # Extract features using ViT features = self.backbone(x) # [B*F, 768] features = self.projection(features) # [B*F, target_dim] return features class SLRModel(nn.Module): def __init__( self, num_classes, c2d_type, conv_type, use_bn=False, hidden_size=1024, gloss_dict=None, loss_weights=None, weight_norm=True, share_classifier=True, backbone_weights=None, backbone_checkpoint=False, multimodal_pose_assist=False, pose_assist_checkpoint=None, pose_assist_weight=0.01, pose_assist_learnable=True, pose_assist_dropout=0.0 ): super(SLRModel, self).__init__() self.decoder = None self.loss = dict() self.criterion_init() self.num_classes = num_classes self.loss_weights = loss_weights self.multimodal_pose_assist = multimodal_pose_assist self.pose_assist_weight_init = pose_assist_weight # 保存初始值 self.pose_assist_learnable = pose_assist_learnable self.pose_assist_dropout_rate = pose_assist_dropout self.conv2d, self.backbone_feat_dim = self._init_backbone( c2d_type, backbone_weights, backbone_checkpoint ) # Initialize pose assistance encoder if enabled self.pose_assist_encoder = None self.pose_assist_weight_param = None self.pose_assist_dropout = None if self.multimodal_pose_assist: if not POSE_ASSIST_AVAILABLE: _log_model_info("[Warning] multimodal_pose_assist=True but pose assist not available, disabling") self.multimodal_pose_assist = False else: _log_model_info(f"[SLRModel] Enabling multimodal pose assistance (initial_weight={pose_assist_weight})") self.pose_assist_encoder = PoseAssistEncoder( target_dim=self.backbone_feat_dim, checkpoint_path=pose_assist_checkpoint ) # 创建可学习的权重参数 if pose_assist_learnable: # 使用sigmoid约束，确保权重在[0, initial_weight]范围内 # weight = initial_weight * sigmoid(learnable_param) # 初始化使得sigmoid(0) = 0.5，即初始权重为 0.5 * initial_weight # 如果想初始就是initial_weight，需要让sigmoid→1，即param→+∞ # 折中方案：初始化为2.0，sigmoid(2.0)≈0.88 self.pose_assist_weight_param = nn.Parameter(torch.tensor(2.0)) _log_model_info(f"[SLRModel] Pose assist weight is LEARNABLE (max={pose_assist_weight})") else: # 固定权重，不学习 self.register_buffer('pose_assist_weight_param', torch.tensor(1.0)) _log_model_info(f"[SLRModel] Pose assist weight is FIXED at {pose_assist_weight}") # 创建dropout层（用于regularization，防止过度依赖pose特征） if pose_assist_dropout > 0: self.pose_assist_dropout = nn.Dropout(p=pose_assist_dropout) _log_model_info(f"[SLRModel] Pose assist dropout enabled (p={pose_assist_dropout})") else: _log_model_info(f"[SLRModel] Pose assist dropout disabled") _log_model_info(f"[SLRModel] Pose assist encoder initialized") self.conv1d = TemporalConv(input_size=self.backbone_feat_dim, hidden_size=hidden_size, conv_type=conv_type, use_bn=use_bn, num_classes=num_classes) self.decoder = utils.Decode(gloss_dict, num_classes, 'beam') self.temporal_model = BiLSTMLayer(rnn_type='LSTM', input_size=hidden_size, hidden_size=hidden_size, num_layers=2, bidirectional=True) if weight_norm: self.classifier = NormLinear(hidden_size, self.num_classes) self.conv1d.fc = NormLinear(hidden_size, self.num_classes) else: self.classifier = nn.Linear(hidden_size, self.num_classes) self.classifier = nn.Linear(hidden_size, self.num_classes) if share_classifier: self.conv1d.fc = self.classifier self.register_backward_hook(self.backward_hook) def backward_hook(self, module, grad_input, grad_output): for g in grad_input: g[g != g] = 0 def get_pose_assist_weight(self): """ 获取当前的姿势辅助权重 如果learnable=True: weight = initial_weight * sigmoid(param) 如果learnable=False: weight = initial_weight 约束：权重永远不超过initial_weight """ if not self.multimodal_pose_assist or self.pose_assist_weight_param is None: return 0.0 if self.pose_assist_learnable: # 使用sigmoid约束到[0, 1]，然后乘以初始权重 # 这确保了权重范围是 [0, initial_weight] alpha = torch.sigmoid(self.pose_assist_weight_param) weight = self.pose_assist_weight_init * alpha else: # 固定权重 weight = self.pose_assist_weight_init return weight def _init_backbone(self, c2d_type, backbone_weights, backbone_checkpoint): """ Build the requested visual backbone. Falls back to timm when torchvision does not provide the requested architecture. """ if hasattr(models, c2d_type): backbone = getattr(models, c2d_type)(pretrained=True) feat_dim = self._infer_backbone_dim(backbone) if hasattr(backbone, 'fc'): backbone.fc = Identity() return backbone, feat_dim if timm is None: raise ValueError( f"Backbone '{c2d_type}' is not part of torchvision.models and timm " f"is not installed. Install timm>=1.0.20 to use DINO/DINOv3 models." ) pool_type = 'token' name_lower = c2d_type.lower() if 'convnext' in name_lower or 'cnn' in name_lower: pool_type = 'avg' # 明确打印权重加载方式 use_pretrained = not bool(backbone_weights) _log_model_info(f"[SLRModel] 初始化 backbone: {c2d_type}") _log_model_info(f"[SLRModel] backbone_weights参数: {backbone_weights}") _log_model_info(f"[SLRModel] 使用timm预训练权重: {use_pretrained}") model = timm.create_model( c2d_type, pretrained=use_pretrained, num_classes=0, global_pool=pool_type, ) _log_model_info(f"[SLRModel] timm模型创建完成, num_features={getattr(model, 'num_features', 'unknown')}") if backbone_weights: state_dict = self._load_external_state(backbone_weights) missing, unexpected = model.load_state_dict(state_dict, strict=False) if missing: _log_model_info(f"[SLRModel] Warning: missing keys when loading {c2d_type}: {missing[:5]}...") if unexpected: _log_model_info(f"[SLRModel] Warning: unexpected keys when loading {c2d_type}: {unexpected[:5]}...") if backbone_checkpoint and hasattr(model, 'set_grad_checkpointing'): model.set_grad_checkpointing(True) elif backbone_checkpoint and hasattr(model, 'grad_checkpointing'): model.grad_checkpointing = True feat_dim = getattr(model, 'num_features', None) if feat_dim is None: raise ValueError(f"Unable to infer feature dim for backbone '{c2d_type}'") # 检查并打印训练模式 trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) total_params = sum(p.numel() for p in model.parameters()) _log_model_info(f"[SLRModel] Backbone参数统计:") _log_model_info(f"[SLRModel] 可训练参数: {trainable_params:,} / {total_params:,}") _log_model_info(f"[SLRModel] 训练模式: {'全量训练 (所有层)' if trainable_params == total_params else '微调 (部分层冻结)'}") return TimmBackbone(model), feat_dim @staticmethod def _load_external_state(weight_path): if not os.path.isfile(weight_path): raise FileNotFoundError(f"Backbone weights not found: {weight_path}") try: checkpoint = torch.load(weight_path, map_location='cpu', weights_only=True) except TypeError: checkpoint = torch.load(weight_path, map_location='cpu') if isinstance(checkpoint, dict): if 'model' in checkpoint: checkpoint = checkpoint['model'] elif 'state_dict' in checkpoint: checkpoint = checkpoint['state_dict'] return checkpoint @staticmethod def _infer_backbone_dim(backbone): if hasattr(backbone, 'fc') and hasattr(backbone.fc, 'in_features'): return backbone.fc.in_features if hasattr(backbone, 'classifier') and hasattr(backbone.classifier, 'in_features'): return backbone.classifier.in_features if hasattr(backbone, 'num_features'): return backbone.num_features raise ValueError("Unable to infer feature dimension from backbone.") def masked_bn(self, inputs, len_x): def pad(tensor, length): return torch.cat([tensor, tensor.new(length - tensor.size(0), *tensor.size()[1:]).zero_()]) x = torch.cat([inputs[len_x[0] * idx:len_x[0] * idx + lgt] for idx, lgt in enumerate(len_x)]) # Extract ResNet features resnet_features = self.conv2d(x) # Add pose assistance features if enabled AND in training mode # Disable during evaluation to save memory if self.multimodal_pose_assist and self.pose_assist_encoder is not None and self.training: pose_features = self.pose_assist_encoder(inputs) # Use original inputs pose_features = torch.cat([pose_features[len_x[0] * idx:len_x[0] * idx + lgt] for idx, lgt in enumerate(len_x)]) # Apply dropout to pose features (only during training) # This helps prevent over-reliance on pose features and improves robustness if self.pose_assist_dropout is not None: pose_features = self.pose_assist_dropout(pose_features) # 获取动态计算的权重（可能是可学习的） current_weight = self.get_pose_assist_weight() # Combine features: ResNet + dynamic_weight * PoseAssist combined_features = resnet_features + current_weight * pose_features else: combined_features = resnet_features x = torch.cat([pad(combined_features[sum(len_x[:idx]):sum(len_x[:idx + 1])], len_x[0]) for idx, lgt in enumerate(len_x)]) return x def forward(self, x, len_x, label=None, label_lgt=None): if len(x.shape) == 5: # videos batch, temp, channel, height, width = x.shape inputs = x.reshape(batch * temp, channel, height, width) framewise = self.masked_bn(inputs, len_x) framewise = framewise.reshape(batch, temp, -1).transpose(1, 2) else: # frame-wise features framewise = x conv1d_outputs = self.conv1d(framewise, len_x) # x: T, B, C x = conv1d_outputs['visual_feat'] lgt = conv1d_outputs['feat_len'] tm_outputs = self.temporal_model(x, lgt) outputs = self.classifier(tm_outputs['predictions']) pred = None if self.training \ else self.decoder.decode(outputs, lgt, batch_first=False, probs=False) conv_pred = None if self.training \ else self.decoder.decode(conv1d_outputs['conv_logits'], lgt, batch_first=False, probs=False) return { "framewise_features": framewise, "visual_features": x, "feat_len": lgt, "conv_logits": conv1d_outputs['conv_logits'], "sequence_logits": outputs, "conv_sents": conv_pred, "recognized_sents": pred, } def criterion_calculation(self, ret_dict, label, label_lgt): loss = 0 for k, weight in self.loss_weights.items(): if k == 'ConvCTC': loss += weight * self.loss['CTCLoss'](ret_dict["conv_logits"].log_softmax(-1), label.cpu().int(), ret_dict["feat_len"].cpu().int(), label_lgt.cpu().int()).mean() elif k == 'SeqCTC': loss += weight * self.loss['CTCLoss'](ret_dict["sequence_logits"].log_softmax(-1), label.cpu().int(), ret_dict["feat_len"].cpu().int(), label_lgt.cpu().int()).mean() elif k == 'Dist': loss += weight * self.loss['distillation'](ret_dict["conv_logits"], ret_dict["sequence_logits"].detach(), use_blank=False) return loss def criterion_init(self): self.loss['CTCLoss'] = torch.nn.CTCLoss(reduction='none', zero_infinity=False) self.loss['distillation'] = SeqKD(T=8) return self.loss