SignX/smkd/seq_scripts.py

import os
import pdb
import sys
import copy
import torch
import torch.distributed as dist
import h5py
import numpy as np
import torch.nn as nn
from tqdm import tqdm
import torch.nn.functional as F
import contextlib

try:
    from torch.distributed.algorithms.join import Join
except ImportError:  # pragma: no cover
    Join = None

try:
    from evaluation.slr_eval.wer_calculation import evaluate
    from utils.sample_utils import extract_sample_id
except:
    from .evaluation.slr_eval.wer_calculation import evaluate
    from .utils.sample_utils import extract_sample_id


def _unwrap_model(model):
    return model.module if hasattr(model, "module") else model


def seq_train(loader, model, optimizer, device, epoch_idx, recoder,
              is_master=True, rank=0, log_bad_samples=True):
    model.train()
    base_model = _unwrap_model(model)
    loss_value = []
    total_loss_sum = 0.0
    total_loss_count = 0
    bad_sample_ids = [] if log_bad_samples else None
    clr = [group['lr'] for group in optimizer.optimizer.param_groups]
    join_context = contextlib.nullcontext()
    if Join is not None and dist.is_available() and dist.is_initialized():
        join_context = Join([model])
    with join_context:
        for batch_idx, data in enumerate(tqdm(loader, disable=not is_master)):
            vid = device.data_to_device(data[0])
            vid_lgt = device.data_to_device(data[1])
            label = device.data_to_device(data[2])
            label_lgt = device.data_to_device(data[3])
            ret_dict = model(vid, vid_lgt, label=label, label_lgt=label_lgt)
            loss = base_model.criterion_calculation(ret_dict, label, label_lgt)
            loss_item = loss.detach().item()
            finite = np.isfinite(loss_item)
            if not finite:
                batch_ids = []
                if log_bad_samples:
                    for info in data[-1]:
                        sid = extract_sample_id(info)
                        if sid:
                            batch_ids.append(sid)
                    if batch_ids and bad_sample_ids is not None:
                        bad_sample_ids.extend(batch_ids)
                    msg = f"[rank {rank}] Non-finite loss at epoch {epoch_idx}, batch {batch_idx}, sample {batch_ids or data[-1]}"
                    if recoder is not None and is_master:
                        recoder.print_log(msg)
                    else:
                        print(msg)
                loss = torch.nan_to_num(loss, nan=0.0, posinf=0.0, neginf=0.0)
            else:
                total_loss_sum += float(loss_item)
                total_loss_count += 1
            optimizer.zero_grad()
            loss.backward()
            # nn.utils.clip_grad_norm_(model.rnn.parameters(), 5)
            optimizer.step()
            loss_value.append(loss_item if finite else np.nan)
            if batch_idx % recoder.log_interval == 0:
                # Check if pose assistance is enabled and get current weight
                log_msg = '\tEpoch: {}, Batch({}/{}) done. Loss: {:.8f}  lr:{:.6f}'.format(
                    epoch_idx, batch_idx, len(loader),
                    loss_item if finite else 0.0, clr[0])

                # Add pose assist weight if enabled
                if hasattr(base_model, 'multimodal_pose_assist') and base_model.multimodal_pose_assist:
                    try:
                        current_weight = base_model.get_pose_assist_weight()
                        if isinstance(current_weight, torch.Tensor):
                            current_weight = current_weight.item()
                        # 计算当前权重占初始权重的百分比
                        weight_percentage = (current_weight / base_model.pose_assist_weight_init * 100) if base_model.pose_assist_weight_init > 0 else 0
                        log_msg += '  pose_w:{:.6f}({:.1f}%)'.format(current_weight, weight_percentage)
                    except:
                        pass  # 如果获取权重失败，不影响正常日志

                recoder.print_log(log_msg)
        optimizer.scheduler.step()
    valid_losses = np.array([lv for lv in loss_value if np.isfinite(lv)], dtype=np.float64)
    if valid_losses.size > 0:
        mean_loss = float(valid_losses.mean())
    else:
        mean_loss = float('nan')
    recoder.print_log('\tMean training loss: {:.10f}.'.format(mean_loss))

    # Print pose assist weight summary at epoch end
    if hasattr(base_model, 'multimodal_pose_assist') and base_model.multimodal_pose_assist:
        try:
            current_weight = base_model.get_pose_assist_weight()
            if isinstance(current_weight, torch.Tensor):
                current_weight = current_weight.item()
            weight_percentage = (current_weight / base_model.pose_assist_weight_init * 100) if base_model.pose_assist_weight_init > 0 else 0

            if base_model.pose_assist_learnable:
                # 可学习权重，显示参数值和sigmoid后的alpha
                param_value = base_model.pose_assist_weight_param.item()
                alpha = torch.sigmoid(torch.tensor(param_value)).item()
                recoder.print_log(
                    '\tPose Assist Weight: {:.6f} ({:.1f}% of max={:.6f}) [learnable_param={:.4f}, sigmoid={:.4f}]'.format(
                        current_weight, weight_percentage, base_model.pose_assist_weight_init, param_value, alpha))
            else:
                # 固定权重
                recoder.print_log(
                    '\tPose Assist Weight: {:.6f} (FIXED)'.format(current_weight))
        except:
            pass

    return total_loss_sum, total_loss_count, bad_sample_ids if log_bad_samples else None


def seq_eval(cfg, loader, model, device, mode, epoch, work_dir, recoder,
             evaluate_tool="python", is_master=True):
    model.eval()
    eval_model = _unwrap_model(model)
    total_sent = []
    total_info = []
    total_conv_sent = []
    stat = {i: [0, 0] for i in range(len(loader.dataset.dict))}
    for batch_idx, data in enumerate(tqdm(loader, disable=not is_master)):
        recoder.record_timer("device")
        vid = device.data_to_device(data[0])
        vid_lgt = device.data_to_device(data[1])
        label = device.data_to_device(data[2])
        label_lgt = device.data_to_device(data[3])
        with torch.no_grad():
            ret_dict = eval_model(vid, vid_lgt, label=label, label_lgt=label_lgt)

        total_info += [file_name[2] for file_name in data[-1]]
        total_sent += ret_dict['recognized_sents']
        total_conv_sent += ret_dict['conv_sents']
    try:
        python_eval = True if evaluate_tool == "python" else False
        write2file(work_dir + "output-hypothesis-{}.ctm".format(mode), total_info, total_sent)
        write2file(work_dir + "output-hypothesis-{}-conv.ctm".format(mode), total_info,
                   total_conv_sent)
        conv_ret = evaluate(
            prefix=work_dir, mode=mode, output_file="output-hypothesis-{}-conv.ctm".format(mode),
            evaluate_dir=cfg.dataset_info['evaluation_dir'],
            dataset_dir=cfg.dataset_info['dataset_root'],
            evaluate_prefix=cfg.dataset_info['evaluation_prefix'],
            output_dir="epoch_{}_result/".format(epoch),
            python_evaluate=python_eval,
        )
        lstm_ret = evaluate(
            prefix=work_dir, mode=mode, output_file="output-hypothesis-{}.ctm".format(mode),
            evaluate_dir=cfg.dataset_info['evaluation_dir'],
            dataset_dir=cfg.dataset_info['dataset_root'],
            evaluate_prefix=cfg.dataset_info['evaluation_prefix'],
            output_dir="epoch_{}_result/".format(epoch),
            python_evaluate=python_eval,
            triplet=True,
        )
    except:
        print("Unexpected error:", sys.exc_info()[0])
        lstm_ret = 100.0
    finally:
        pass
    recoder.print_log(f"Epoch {epoch}, {mode} {lstm_ret: 2.2f}%", f"{work_dir}/{mode}.txt")
    return lstm_ret


def seq_feature_generation(loader, model, device, mode, recoder, is_master=True):
    model.eval()
    feature_model = _unwrap_model(model)

    tgt_path = os.path.abspath(f"./features/{mode}")
    if not os.path.exists("./features/"):
        os.makedirs("./features/")

    features = {}
    for batch_idx, data in tqdm(enumerate(loader), disable=not is_master):
        recoder.record_timer("device")
        vid = device.data_to_device(data[0])
        vid_lgt = device.data_to_device(data[1])
        with torch.no_grad():
            ret_dict = feature_model(vid, vid_lgt)

        feat_len = ret_dict['feat_len'].cpu().detach().numpy().astype(np.int32)
        visual_features = ret_dict['visual_features'].permute(1, 0, 2)
        for sample_idx in range(len(vid)):
            visual_feature = visual_features[sample_idx][:feat_len[sample_idx]].cpu().detach().numpy().astype(np.float32)
            features[data[-1][sample_idx][1]] = visual_feature

    hf = h5py.File(tgt_path + ".h5", 'w')
    fkeys = sorted(list(features.keys()))
    for i, dkey in enumerate(fkeys):
        feature = features[dkey]
        hf.create_dataset("%s" % i, data=feature)

    hf.close()


def write2file(path, info, output):
    filereader = open(path, "w")
    for sample_idx, sample in enumerate(output):
        for word_idx, word in enumerate(sample):
            filereader.writelines(
                "{} 1 {:.2f} {:.2f} {}\n".format(info[sample_idx],
                                                 word_idx * 1.0 / 100,
                                                 (word_idx + 1) * 1.0 / 100,
                                                 word[0]))