# -*- coding: utf-8 -*- """对比方法 (CATCH、时序 library ...
Tạo vào: 19 tháng 11, 2026
Trả lời bằng GPT-6 Thinking bởi Chat01
Tạo vào: 19 tháng 11, 2026
Trả lời bằng GPT-6 Thinking bởi Chat01
"""对比方法 (CATCH、时序 library 各模型、DCdetector / AnomalyTransformer / DualTF / ModernTCN)
的效率测量, 口径与 efficiency.py 完全一致。
模型代码全部来自 CATCH-master/ts_benchmark/baselines (不修改源码):
CATCH catch/
Autoformer ... Transformer (16 个) time_series_library/models/
DCdetector AnomalyTransformer
DualTF ModernTCN self_impl/
用法:
python efficiency_baselines.py --dataset CalIt2 --device cuda:0 # 全部方法
python efficiency_baselines.py --dataset GECCO --methods CATCH TimesNet iTransformer
python efficiency_baselines.py --dataset CalIt2 --protocol native # 各方法自己的窗口长度
公平性约定:
数据 所有方法读同一个 LongCSVSegLoader (同一份 CSV、同样的划分和标准化)。
取窗 shared (默认): 与 DistillAD 完全相同的窗口 —— 长度 64、相同训练步长、
相同的训练/测试 batch 大小、测试不重叠取窗。各方法的 seq_len 被覆盖为 64。
例外: DualTF 的频域分支要对 (子窗口数 x 频点数) 个 token 做注意力, 512 的 batch 放不进
显存, 它在两种协议下都用自己官方脚本里的 batch 大小 (窗口仍与其他方法相同)。
native: 各方法用自己配置里的 seq_len 和 batch 大小, 训练步长 1。每个 epoch 的
窗口数与 DistillAD 不同, 时间不能直接横向比。
超参 优先取 CATCH-master/scripts/multivariate_detection/detect_score/<dataset>_script/<方法>.sh
里的官方超参 (CSV 的 config 列记为 official); 该数据集没有官方脚本的方法用
benchmark 适配器的默认超参 (记为 default)。默认值直接从源码里读, 不在这里另抄一份。
训练 每个方法按自己的官方流程做一步更新 (损失函数、优化器与源码一致), 不含验证和早停。
推理 搬到设备 + 前向 + 计算逐点异常分数 + 取回 CPU, 不含取数据和算指标。
DualTF 的频域变换 (子窗口 FFT) 算在训练和推理时间内; 它在 numpy 里对重叠窗口
分数做的聚合属于后处理, 不计。
结构约束 个别模型对窗口长度有整除要求, 窗口改成 64 后按最接近的合法值调整:
LightTS 的 chunk_size、DCdetector 的 patch_size (官方 [3,5,7] -> [2,4,8])。
计数 Parameters 为模型全部参数; MACs 为推理一个多变量窗口的乘加次数,
只统计 Conv / Linear (同 efficiency.py 的 MacCounter)。
结果按 (method, dataset) 写入 results/efficiency.csv, 并重新生成 efficiency_table_<dataset>.tex。
"""
import argparse
import ast
import copy
import importlib
import json
import os
import re
import sys
import time
import traceback
import types
import numpy as np
import torch
import torch.nn as nn
from ablation import PROJECT_DIR, build_loaders, setseed, sync
from dataset import LONG_CSV_META
from efficiency import MacCounter, build_latex, count_params, read_rows, upsert_row
CATCH_DIR = os.path.join(PROJECT_DIR, 'CATCH-master')
BASELINES_DIR = os.path.join(CATCH_DIR, 'ts_benchmark', 'baselines')
TSLIB_METHODS = ['Autoformer', 'Crossformer', 'DLinear', 'ETSformer', 'FEDformer', 'FiLM',
'Informer', 'iTransformer', 'LightTS', 'MICN',
'Nonstationary_Transformer', 'PatchTST', 'Pyraformer', 'Reformer',
'TimesNet', 'Transformer']
SELF_IMPL_METHODS = ['DCdetector', 'AnomalyTransformer', 'DualTF', 'ModernTCN']
ALL_METHODS = ['CATCH'] + SELF_IMPL_METHODS + TSLIB_METHODS
_DEFAULT_VAR = 'DEFAULT_TRANSFORMER_BASED_HYPER_PARAMS'
METHOD_INFO = {
'CATCH': ('catch/CATCH.py', _DEFAULT_VAR, 'seq_len'),
'DCdetector': ('self_impl/DCdetector/DCdetector.py', _DEFAULT_VAR, 'win_size'),
'AnomalyTransformer': ('self_impl/Anomaly_trans/AnomalyTransformer.py', _DEFAULT_VAR, 'win_size'),
'DualTF': ('self_impl/DualTF/DualTF.py', 'DEFAULT_DUAL_TF_BASED_HYPER_PARAMS', 'seq_len'),
'ModernTCN': ('self_impl/ModernTCN/ModernTCN.py', _DEFAULT_VAR, 'seq_len'),
}
_TSLIB_INFO = ('time_series_library/adapters_for_transformers.py', _DEFAULT_VAR, 'seq_len')
def _register_packages():
"""把 ts_benchmark 注册成只有路径的空包。
text源码里用的是绝对导入 (ts_benchmark.baselines.xxx), 但各级 __init__.py 会连带导入 整个 benchmark 框架 (ray / darts 等), 这里跳过 __init__ 只按路径找子模块。 """ for name, path in [ ('ts_benchmark', os.path.join(CATCH_DIR, 'ts_benchmark')), ('ts_benchmark.baselines', BASELINES_DIR), ('ts_benchmark.baselines.catch', os.path.join(BASELINES_DIR, 'catch')), ('ts_benchmark.baselines.time_series_library', os.path.join(BASELINES_DIR, 'time_series_library')), ('ts_benchmark.baselines.self_impl', os.path.join(BASELINES_DIR, 'self_impl')), ]: if name not in sys.modules: pkg = types.ModuleType(name) pkg.__path__ = [path] sys.modules[name] = pkg try: # DCdetector 从 _tkinter 借了一个展平嵌套列表的函数; 无图形库的服务器上没有这个模块 import _tkinter # noqa: F401 except ImportError: def _flatten(seq): out = [] for item in seq: out.extend(_flatten(item) if isinstance(item, (list, tuple)) else [item]) return tuple(out) stub = types.ModuleType('_tkinter') stub._flatten = _flatten sys.modules['_tkinter'] = stub
def _source_defaults(rel_path, var_name):
"""从源码文件里读出默认超参字典 (字面量), 不执行该文件。"""
with open(os.path.join(BASELINES_DIR, rel_path), encoding='utf-8') as f:
tree = ast.parse(f.read())
for node in tree.body:
if isinstance(node, ast.Assign) and any(getattr(t, 'id', None) == var_name for t in node.targets):
return ast.literal_eval(node.value)
raise RuntimeError(f"{rel_path} 里找不到 {var_name}")
def official_hyper_params(method, dataset):
"""官方脚本里该 (方法, 数据集) 的超参; 没有脚本返回 None。"""
path = os.path.join(CATCH_DIR, 'scripts', 'multivariate_detection', 'detect_score',
f'{dataset}_script', f'{method}.sh')
if not os.path.exists(path):
return None
with open(path, encoding='utf-8') as f:
m = re.search(r"--model-hyper-params\s+'({.*?})'", f.read(), re.S)
return json.loads(m.group(1)) if m else None
def _patch_etsformer_fourier():
"""ETSformer 的 FourierLayer 在 GPU 上会报错: 频率向量 f 建在 CPU 上, 却用 GPU 上的 top-k
下标去索引它。这里换成一个只改了 f 所在设备的 forward, 计算内容与源码相同。"""
layers = importlib.import_module('ts_benchmark.baselines.time_series_library.layers.ETSformer_EncDec')
if getattr(layers.FourierLayer, '_device_patched', False):
return
textdef forward(self, x): b, t, d = x.shape x_freq = torch.fft.rfft(x, dim=1) f = torch.fft.rfftfreq(t, device=x.device) if t % 2 == 0: x_freq, f = x_freq[:, self.low_freq:-1], f[self.low_freq:-1] else: x_freq, f = x_freq[:, self.low_freq:], f[self.low_freq:] x_freq, index_tuple = self.topk_freq(x_freq) f = layers.repeat(f, 'f -> b f d', b=x_freq.size(0), d=x_freq.size(2)) f = layers.rearrange(f[index_tuple], 'b f d -> b f () d') return self.extrapolate(x_freq, f, t) layers.FourierLayer.forward = forward layers.FourierLayer._device_patched = True
class TSLibMethod:
"""时序 library 的重构式异常检测: loss = MSE(model(x), x), 分数 = 逐点重构误差。"""
textdef __init__(self, name, hp, n_channels, device): cfg = _source_defaults('time_series_library/adapters_for_transformers.py', 'DEFAULT_TRANSFORMER_BASED_HYPER_PARAMS') cfg.update({'horizon': 0, 'norm': True}) cfg.update(hp) cfg.update({'enc_in': n_channels, 'dec_in': n_channels, 'c_out': n_channels, 'label_len': 48, 'task_name': 'anomaly_detection', 'freq': 'h'}) cfg['pred_len'] = cfg['horizon'] extra = {} if name == 'ETSformer': cfg['d_layers'] = cfg['e_layers'] # 模型要求编码器和解码器层数相等 _patch_etsformer_fourier() if name == 'LightTS': # 模型要求 seq_len 能被 chunk_size 整除; 取不超过源码默认值 24 的最大约数 extra['chunk_size'] = max(k for k in range(1, 25) if cfg['seq_len'] % k == 0) self.cfg = types.SimpleNamespace(**cfg) module = importlib.import_module(f'ts_benchmark.baselines.time_series_library.models.{name}') if hasattr(module, 'device'): # FiLM 用模块级全局变量决定设备 module.device = device self.model = getattr(module, name)(self.cfg, **extra).to(device) for m in self.model.modules(): # MICN 把设备写死成 cuda:0 if isinstance(getattr(m, 'device', None), (str, torch.device)): m.device = device self.modules = [self.model] self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.cfg.lr) self.criterion = nn.MSELoss() def train_step(self, x, i, n_batches): self.optimizer.zero_grad() out = self.model(x, None, None, None) loss = self.criterion(out, x) loss.backward() self.optimizer.step() def score(self, x): out = self.model(x, None, None, None) return torch.mean((x - out) ** 2, dim=-1)
class CATCHMethod:
"""CATCH: 时域重构 + 频域辅助损失 + 通道相关性损失, 主网络和掩码生成器各一个优化器。"""
textdef __init__(self, hp, n_channels, device): cfg = _source_defaults('catch/CATCH.py', 'DEFAULT_TRANSFORMER_BASED_HYPER_PARAMS') cfg.update(hp) cfg.update({'enc_in': n_channels, 'dec_in': n_channels, 'c_out': n_channels, 'c_in': n_channels, 'label_len': 48, 'task_name': 'anomaly_detection'}) cfg['pred_len'] = cfg['seq_len'] # 推理时的频域打分 patch 不能比窗口还长 cfg['inference_patch_size'] = min(cfg['inference_patch_size'], cfg['seq_len']) self.cfg = types.SimpleNamespace(**cfg) CATCHModel = importlib.import_module('ts_benchmark.baselines.catch.models.CATCH_model').CATCHModel fre = importlib.import_module('ts_benchmark.baselines.catch.utils.fre_rec_loss') self.model = CATCHModel(self.cfg).to(device) self.modules = [self.model] main_params = [p for n, p in self.model.named_parameters() if 'mask_generator' not in n] self.optimizer = torch.optim.Adam(main_params, lr=self.cfg.lr) self.optimizerM = torch.optim.Adam(self.model.mask_generator.parameters(), lr=self.cfg.Mlr) self.criterion = nn.MSELoss() self.auxi_loss = fre.frequency_loss(self.cfg) self.freq_criterion = fre.frequency_criterion(self.cfg) def train_step(self, x, i, n_batches): cfg = self.cfg self.optimizer.zero_grad() out, out_complex, dcloss = self.model(x) rec_loss = self.criterion(out, x) norm_x = self.model.revin_layer(x, 'transform') auxi = self.auxi_loss(out_complex, norm_x) loss = rec_loss + cfg.dc_lambda * dcloss + cfg.auxi_lambda * auxi if (i + 1) % min(n_batches, 100) == 0: # 与源码一致: 掩码生成器每隔若干步更新一次 self.optimizerM.step() self.optimizerM.zero_grad() loss.backward() self.optimizer.step() def score(self, x): out, _, _ = self.model(x) temp = torch.mean((x - out) ** 2, dim=-1) freq = torch.mean(self.freq_criterion(x, out), dim=-1) return temp + self.cfg.score_lambda * freq
def _kl(p, q):
res = p * (torch.log(p + 0.0001) - torch.log(q + 0.0001))
return torch.mean(torch.sum(res, dim=-1), dim=1)
def _association_losses(series, prior):
"""AnomalyTransformer 系列训练用的关联差异 (series / prior 两个方向), 与源码逐项一致。"""
series_loss = prior_loss = 0.0
for s, p in zip(series, prior):
p = p / torch.sum(p, dim=-1, keepdim=True)
series_loss = series_loss + torch.mean(_kl(s, p.detach())) + torch.mean(_kl(p.detach(), s))
prior_loss = prior_loss + torch.mean(_kl(p, s.detach())) + torch.mean(_kl(s.detach(), p))
return series_loss / len(prior), prior_loss / len(prior)
def _association_metric(series, prior, temperature=50):
"""推理时的关联差异权重 softmax(-series - prior), 与源码逐项一致。"""
series_loss = prior_loss = 0.0
for s, p in zip(series, prior):
p = p / torch.sum(p, dim=-1, keepdim=True)
series_loss = series_loss + _kl(s, p.detach()) * temperature
prior_loss = prior_loss + _kl(p, s.detach()) * temperature
return torch.softmax(-series_loss - prior_loss, dim=-1)
def _minimax_step(model, optimizer, x, k):
"""AnomalyTransformer 的 minimax 更新: 两个损失各反传一次, 再更新一步。"""
optimizer.zero_grad()
out, series, prior, _ = model(x)
series_loss, prior_loss = _association_losses(series, prior)
rec_loss = torch.mean((out - x) ** 2)
(rec_loss - k * series_loss).backward(retain_graph=True)
(rec_loss + k * prior_loss).backward()
optimizer.step()
def _at_score(model, x):
out, series, prior, _ = model(x)
return _association_metric(series, prior) * torch.mean((x - out) ** 2, dim=-1)
class AnomalyTransformerMethod:
def init(self, hp, n_channels, device):
cfg = _source_defaults(*METHOD_INFO['AnomalyTransformer'][:2])
cfg.update(hp)
self.cfg = types.SimpleNamespace(**cfg)
cls = importlib.import_module(
'ts_benchmark.baselines.self_impl.Anomaly_trans.AnomalyTransformer_model').AnomalyTransformer_model
self.model = cls(win_size=cfg['win_size'], enc_in=n_channels, c_out=n_channels, e_layers=3).to(device)
self.modules = [self.model]
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.cfg.lr)
textdef train_step(self, x, i, n_batches): _minimax_step(self.model, self.optimizer, x, self.cfg.k) def score(self, x): return _at_score(self.model, x)
class DCdetectorMethod:
def init(self, hp, n_channels, device):
cfg = _source_defaults(*METHOD_INFO['DCdetector'][:2])
cfg.update(hp)
win = cfg['win_size']
if any(win % p for p in cfg['patch_size']):
# 模型要求窗口长度能被每个 patch 大小整除: 逐个换成最接近的约数 (距离相同取小的)
divisors = [d for d in range(2, win) if win % d == 0]
fixed = sorted({min(divisors, key=lambda d: (abs(d - p), d)) for p in cfg['patch_size']})
print(f"[DCdetector] patch_size {cfg['patch_size']} 不能整除窗口 {win}, 改用 {fixed}")
cfg['patch_size'] = fixed
self.cfg = types.SimpleNamespace(**cfg)
cls = importlib.import_module(
'ts_benchmark.baselines.self_impl.DCdetector.DCdetector_model').DCdetector_model
self.model = cls(win_size=win, enc_in=n_channels, c_out=n_channels, n_heads=cfg['n_heads'],
d_model=cfg['d_model'], e_layers=cfg['e_layers'], patch_size=cfg['patch_size'],
channel=n_channels).to(device)
self.modules = [self.model]
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.cfg.lr)
textdef train_step(self, x, i, n_batches): self.optimizer.zero_grad() series, prior = self.model(x) series_loss, prior_loss = _association_losses(series, prior) (prior_loss - series_loss).backward() self.optimizer.step() def score(self, x): series, prior = self.model(x) return _association_metric(series, prior)
class DualTFMethod:
"""DualTF: 时域和频域各一个 AnomalyTransformer, 分别训练、分别打分。"""
own_batch_size = True # 见文件头: 频域分支的注意力放不下 512 的 batch
textdef __init__(self, hp, n_channels, device): cfg = _source_defaults(*METHOD_INFO['DualTF'][:2]) cfg.update(hp) cfg['nest_len'] = cfg['seq_len'] // 2 self.cfg = types.SimpleNamespace(**cfg) self.fre_win = (cfg['seq_len'] - cfg['nest_len'] + 1) * (cfg['nest_len'] // 2) base = 'ts_benchmark.baselines.self_impl.DualTF.model.' time_cls = importlib.import_module(base + 'TimeTransformer').AnomalyTransformer fre_cls = importlib.import_module(base + 'FrequencyTransformer').FrequencyTransformer self.time_model = time_cls(win_size=cfg['seq_len'], enc_in=n_channels, c_out=n_channels, e_layers=3).to(device) self.fre_model = fre_cls(win_size=self.fre_win, enc_in=n_channels, c_out=n_channels, e_layers=3).to(device) self.model = nn.ModuleList([self.time_model, self.fre_model]) self.modules = [self.model] self.time_opt = torch.optim.Adam(self.time_model.parameters(), lr=self.cfg.lr) self.fre_opt = torch.optim.Adam(self.fre_model.parameters(), lr=self.cfg.lr) def _grand_window(self, x): """[B, T, C] -> [B, 子窗口数 * nest_len/2, C]: 每个子窗口做 FFT 取前一半频点的幅值。""" nest = self.cfg.nest_len sub = x.unfold(1, nest, self.cfg.step).permute(0, 1, 3, 2) # [B, n_sub, nest, C] amp = torch.abs(torch.fft.fft(sub, dim=2) / nest)[:, :, :nest // 2, :] return amp.reshape(x.shape[0], -1, x.shape[-1]) def train_step(self, x, i, n_batches): _minimax_step(self.fre_model, self.fre_opt, self._grand_window(x), self.cfg.k) _minimax_step(self.time_model, self.time_opt, x, self.cfg.k) def score(self, x): time_score = _at_score(self.time_model, x) # [B, T] fre_score = _at_score(self.fre_model, self._grand_window(x)) # [B, fre_win] return torch.cat([time_score, fre_score], dim=1)
class ModernTCNMethod:
def init(self, hp, n_channels, device):
cfg = _source_defaults(*METHOD_INFO['ModernTCN'][:2])
cfg.update({'dropout': 0.1, 'head_dropout': 0.0})
cfg.update(hp)
cfg.update({'enc_in': n_channels, 'dec_in': n_channels, 'c_out': n_channels, 'label_len': 48,
'task_name': 'anomaly_detection', 'freq': 'h', 'horizon': cfg['seq_len']})
cfg['pred_len'] = cfg['horizon']
self.cfg = types.SimpleNamespace(**cfg)
cls = importlib.import_module(
'ts_benchmark.baselines.self_impl.ModernTCN.models.ModernTCN_model').ModernTCNModel
self.model = cls(self.cfg).to(device)
self.modules = [self.model]
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.cfg.lr)
textdef train_step(self, x, i, n_batches): self.optimizer.zero_grad() out = self.model(x, None, None, None)[:, -self.cfg.horizon:, :] torch.mean((out - x) ** 2).backward() self.optimizer.step() def score(self, x): out = self.model(x, None, None, None) return torch.mean((x - out) ** 2, dim=-1)
METHOD_CLASSES = {'CATCH': CATCHMethod, 'DCdetector': DCdetectorMethod,
'AnomalyTransformer': AnomalyTransformerMethod, 'DualTF': DualTFMethod,
'ModernTCN': ModernTCNMethod}
def profile(method_name, args):
setseed(args.seed)
device = torch.device(args.device)
is_cuda = device.type == 'cuda'
texthp = official_hyper_params(method_name, args.dataset) cfg_source = 'official' if hp is not None else 'default' hp = dict(hp or {}) defaults_file, defaults_var, win_key = METHOD_INFO.get(method_name, _TSLIB_INFO) defaults = _source_defaults(defaults_file, defaults_var) method_cls = METHOD_CLASSES.get(method_name) loader_args = copy.copy(args) if args.protocol == 'shared': hp[win_key] = args.win_size else: hp.setdefault(win_key, defaults.get(win_key, 100)) loader_args.win_size = hp[win_key] loader_args.train_step = 1 if args.protocol == 'native' or getattr(method_cls, 'own_batch_size', False): loader_args.batch_size = loader_args.test_batch = hp.get('batch_size', defaults['batch_size']) train_loader, test_loader = build_loaders(loader_args) n_channels = train_loader.dataset.n_channels if method_cls is not None: method = method_cls(hp, n_channels, device) else: method = TSLibMethod(method_name, hp, n_channels, device) model = method.model def train_epoch(): model.train() n_batches = len(train_loader) sync(device) t = time.perf_counter() for i, (x, _) in enumerate(train_loader): method.train_step(x.float().to(device), i, n_batches) sync(device) return time.perf_counter() - t def infer_pass(): model.eval() total, n = 0.0, 0 with torch.no_grad(): for x, _ in test_loader: sync(device) t = time.perf_counter() method.score(x.float().to(device)).cpu().numpy() sync(device) total += time.perf_counter() - t n += x.shape[0] return total, n # ---- 训练耗时 / 显存 ---- train_epoch() # 预热 if is_cuda: torch.cuda.reset_peak_memory_stats(device) epoch_times = [train_epoch() for _ in range(args.timed_epochs)] peak_train = torch.cuda.max_memory_allocated(device) / 2 ** 20 if is_cuda else float('nan') # ---- 推理耗时 / 显存 ---- infer_pass() # 预热 if is_cuda: torch.cuda.reset_peak_memory_stats(device) infer_times = [] for _ in range(args.infer_repeats): t, n_test = infer_pass() infer_times.append(t) peak_infer = torch.cuda.max_memory_allocated(device) / 2 ** 20 if is_cuda else float('nan') # ---- 参数量 / MACs (单个窗口) ---- model.eval() window = next(iter(test_loader))[0][:1].float().to(device) with torch.no_grad(), MacCounter(method.modules) as mc: method.score(window) row = { 'method': method_name.replace('Nonstationary_Transformer', 'Nonstationary Transformer'), 'dataset': args.dataset, 'device': str(device), 'config': cfg_source, 'params_M': count_params(method.modules) / 1e6, 'params_heads_M': 0.0, 'params_teacher_M': float('nan'), 'macs_G': mc.macs / 1e9, 'macs_teacher_G': float('nan'), 'train_s_per_epoch': float(np.mean(epoch_times)), 'peak_mem_mb': peak_train, 'infer_s': float(np.mean(infer_times)), 'infer_ms_per_win': float(np.mean(infer_times)) / n_test * 1e3, 'peak_mem_infer_mb': peak_infer, 'n_train_win': len(train_loader.dataset), 'n_test_win': n_test, } row = {k: (round(v, 6) if isinstance(v, float) else v) for k, v in row.items()} print(f"[{method_name}] config={cfg_source} window={tuple(window.shape)} batch={train_loader.batch_size} " f"params={row['params_M']}M macs={row['macs_G']}G train={row['train_s_per_epoch']}s/epoch " f"infer={row['infer_s']}s peak_mem={row['peak_mem_mb']}MB") return row
def main():
parser = argparse.ArgumentParser(description='Baseline efficiency profiling (CATCH + time-series library)')
parser.add_argument('--dataset', default='GECCO', choices=list(LONG_CSV_META))
parser.add_argument('--methods', nargs='+', default=['all'],
help=f"all 或以下若干个: {' '.join(ALL_METHODS)}")
parser.add_argument('--protocol', default='shared', choices=['shared', 'native'])
parser.add_argument('--device', default='cuda:0')
parser.add_argument('--seed', type=int, default=2025)
# 以下 5 项只在 shared 协议下生效, 默认值与 ablation.py 相同
parser.add_argument('--win_size', type=int, default=64)
parser.add_argument('--batch_size', type=int, default=512)
parser.add_argument('--test_batch', type=int, default=256)
parser.add_argument('--train_step', type=int, default=None)
parser.add_argument('--test_step', type=int, default=None)
parser.add_argument('--timed_epochs', type=int, default=5)
parser.add_argument('--infer_repeats', type=int, default=10)
parser.add_argument('--csv', default=os.path.join('results', 'efficiency.csv'))
parser.add_argument('--tex', default=None, help='默认 results/efficiency_table_<dataset>.tex')
args = parser.parse_args()
if args.tex is None:
args.tex = os.path.join(os.path.dirname(args.csv) or '.', f'efficiency_table_{args.dataset}.tex')
methods = ALL_METHODS if args.methods == ['all'] else args.methods
unknown = [m for m in methods if m not in ALL_METHODS]
if unknown:
parser.error(f"未知方法 {unknown}, 可选: {ALL_METHODS}")
text_register_packages() if torch.device(args.device).type != 'cuda': # 部分源码写死了 .cuda() (AutoCorrelation 等); 在 CPU 上试跑时让它变成空操作 torch.Tensor.cuda = lambda self, *a, **k: self failed = [] for name in methods: print(f"\n>>> {name} on {args.dataset}") try: row = profile(name, args) except Exception: traceback.print_exc() failed.append(name) continue upsert_row(args.csv, row) if torch.cuda.is_available(): torch.cuda.empty_cache() rows = read_rows(args.csv) if rows: tex = build_latex(rows, args.dataset) with open(args.tex, 'w', encoding='utf-8') as f: f.write(tex) print(f"\nLaTeX 表已写入 {args.tex}\n") print(tex) if failed: raise SystemExit(f"[error] 以下方法测量失败 (详见上面的报错): {failed}")
if name == 'main':
main()
这个计算FLOPs (浮点运算次数) 和MACs(乘加操作数)的方法和Pytorch-OpCounter(THOP)计算相比,有什么区别呢,为什么出来的结果不一样
我会对照 THOP 的实际计数规则和你这段代码的统计入口,区分“单位换算造成的差异”和“哪些运算被漏计或重复计数”。其中 MacCounter 的具体实现不在这段代码里,我会把能确定的结论和需要核对的部分分开说明。
你这份 efficiency_baselines.py 和 PyTorch-OpCounter(THOP) 计算出来的 MACs / FLOPs 不一样,主要原因是:** 两者统计的运算范围可能不同,而且 FLOPs 和 MACs 本身不是同一个指标。**
结合你提供的代码,以及 THOP 的实现,我认为差异主要来自以下几个方面,尤其是 Transformer、CATCH、DCdetector、AnomalyTransformer 和 DualTF 这类包含大量注意力计算的模型。
你代码中负责计算运算量的部分是:
pythonmodel.eval() window = next(iter(test_loader))[0][:1].float().to(device) with torch.no_grad(), MacCounter(method.modules) as mc: method.score(window) row['macs_G'] = mc.macs / 1e9
其中 MacCounter 是从 efficiency.py 导入的:
pythonfrom efficiency import MacCounter
根据文件开头的约定:
MACs 为推理一个多变量窗口的乘加次数,只统计 Conv / Linear。
也就是说,你现在计算的是:
模型在处理一个输入窗口时,卷积层和线性层产生的 MACs。
它并不是模型完整的 FLOPs,也不一定等于 THOP 输出的 MACs。
MACs(Multiply–Accumulate Operations) 表示乘加操作数量。
FLOPs(Floating-Point Operations) 表示浮点运算次数,通常将一次乘法和一次加法分别计数。
例如,一个矩阵乘法:
其 MACs 为:
使用常见的近似约定:
因此,对于以矩阵乘法为主的网络:
需要注意,这只是常见换算约定,不是严格适用于全部运算的等式。Softmax、归一化、FFT 等操作无法简单地用一个固定系数统一换算。
THOP 原始项目也明确区分 MACs 与 FLOPs,并说明常见的 FLOPs 数值是通过 MACs 乘以 2 得到的近似值。(github.com)
所以,如果你的代码输出:
textMACs = 0.50 G
而其他论文或代码报告:
textFLOPs = 1.00 G
在统计范围完全一致的前提下,这两者并不矛盾。
但如果你的 MACs 是 0.50 G,而 THOP 的 MACs 是 0.85 G,那就不是简单的单位换算问题,而是统计规则、执行路径或输入配置不同。
根据你文件的说明,可以先做如下比较。
| 运算类型 | 你的 MacCounter(按文件说明) | THOP |
|---|---|---|
nn.Linear | 统计 | 统计 |
nn.Conv1d/2d/3d | 统计 | 统计 |
| 注意力中的 Q/K/V 线性投影 | 统计 | 统计 |
Q @ Kᵀ 注意力矩阵乘法 | 不统计 | 取决于版本与实现 |
Attention @ V | 不统计 | 取决于版本与实现 |
torch.bmm / matmul | 不统计 | 新版本可统计部分 |
nn.LayerNorm | 不统计 | 有专门的规则 |
nn.Softmax | 不统计 | 有专门的规则 |
| 池化与激活函数 | 不统计 | 部分支持 |
torch.fft | 不统计 | 默认通常不统计 |
| 普通逐元素加减乘除 | 不统计 | 大多不完整统计 |
| 自定义 Python / PyTorch 运算 | 除非内部调用被统计的层 | 需要支持规则或自定义计数 |
这里有一个非常重要的版本区别:
torch.matmul、torch.bmm 编写的注意力运算。einsum、F.linear 和函数式多头注意力等支持。(github.com github.com)因此,不能简单地说“THOP 一定统计注意力计算”或者“THOP 一定不统计注意力计算”,必须看你的安装版本和模型的具体实现。
这也是为什么不同人使用 THOP 统计同一个 Transformer,可能得到不同的 MACs。
假设标准 Self-Attention 的输入为:
注意力通常包含:
接着计算:
假设采用普通多头注意力,隐藏维度为 ,序列长度为 ,那么:
| 计算过程 | MACs(近似) | 你的计数器 |
|---|---|---|
| Q、K、V 的线性投影 | 统计 | |
| 不统计 | ||
| 不统计 | ||
| 输出线性投影 | 统计 |
所以,忽略 Softmax 等其他运算时,标准多头注意力的主要 MACs 约为:
但按照你当前文件声明的 Conv / Linear 口径,只统计到:
两者相差:
例如,一个注意力模块设置为:
则:
只计算 Q/K/V/O 投影
MACs / 窗口
再加入两个注意力矩阵乘法
MACs / 窗口
在这个简化例子中,漏掉的注意力矩阵乘法占完整注意力主要 MACs 的约 20%(尚未计算 FFN 和其他运算)。
窗口越长,差异可能越明显,因为注意力矩阵乘法复杂度是 ,而线性投影是 。
对于 DCdetector 和 AnomalyTransformer 这种大量使用关联矩阵的模型,这一点尤其值得检查。
你在 DualTFMethod 中定义:
pythonself.time_model = time_cls(...) self.fre_model = fre_cls(...) self.model = nn.ModuleList([ self.time_model, self.fre_model ])
推理时:
pythondef score(self, x): time_score = _at_score(self.time_model, x) fre_score = _at_score( self.fre_model, self._grand_window(x) ) return torch.cat([time_score, fre_score], dim=1)
你的 MacCounter 会统计两个 Transformer 内部经过的 Conv / Linear 层,但不会统计 _grand_window() 内的 FFT,也不会统计普通的函数式注意力矩阵乘法。
更重要的是,DualTF 的频域 token 数量可能远大于输入窗口长度。
在你当前配置中:
pythonseq_len = 64 nest_len = seq_len // 2 # 32 fre_win = (64 - 32 + 1) * (32 // 2) # 528
当子窗口步长为 1 时,时域 Transformer 处理 64 个位置,而频域 Transformer 处理 528 个 token。
DualTF 两个分支的 token 数量
时域
64
频域
528
假设两个分支的注意力维度相同,频域分支单层标准全注意力的 QKᵀ / AV 计算量可达到时域分支的约 68 倍。这是理论比例,并非 DualTF 总计算量比例。
这意味着:你的 MacCounter 可能明显低估 DualTF 频域注意力相对于其他操作的计算负担。 但旧版 THOP 同样可能漏计这些操作,因此换成 THOP 并不自动解决问题。
例如 CATCH 的推理打分:
pythondef score(self, x): out, _, _ = self.model(x) temp = torch.mean((x - out) ** 2, dim=-1) freq = torch.mean(self.freq_criterion(x, out), dim=-1) return temp + self.cfg.score_lambda * freq
这里的:
如果没有通过被计数器识别的模块执行,就不会被计入 Conv / Linear MACs。
因此,MACs 较小,不一定代表实际推理更快。 频域模型可能在 MACs 指标上看起来很轻量,但 FFT、数据重排、内存访问等操作仍然消耗时间。
这也是为什么你已经测量的 infer_ms_per_win 很有价值:它可以反映 MACs 计数器没有覆盖的实际执行开销。
这是另一个非常关键的问题。
你的计数入口是:
pythonmethod.score(window)
它不是简单的:
pythonmethod.model(window)
区别如下:
| 方法 | method.score() 除模型前向之外还会做什么 |
|---|---|
| TimesNet、iTransformer 等 | 重构误差计算 |
| CATCH | 时域和频域异常评分 |
| AnomalyTransformer | 关联差异与重构误差计算 |
| DCdetector | Series / Prior 关联差异评分 |
| DualTF | 时域分支 + FFT + 频域分支 + 评分 |
| ModernTCN | 重构误差计算 |
假设你使用 THOP 时执行:
pythonmacs, params = thop.profile( method.model, inputs=(window,) )
但使用 MacCounter 时执行:
pythonmethod.score(window)
那么就不能保证它们调用了相同的计算图。
对于 DualTF,method.model 甚至是 nn.ModuleList,没有定义可直接使用的整体推理 forward()。
因此,即便使用同一个计数工具,也必须确保执行路径一致。
建议你在 profile() 函数中,原来的 MACs 统计位置加入以下代码。
关键是把 method.score() 包装成一个标准的 nn.Module,使 THOP 也能执行完整的异常检测评分流程。
pythonfrom thop import profile as thop_profile class ScoreWrapper(nn.Module): def __init__(self, method): super().__init__() self.network = method.model self._score_fn = method.score def forward(self, x): return self._score_fn(x) # 在 profile() 中,构造好 method 之后执行: model.eval() window = next(iter(test_loader))[0][:1].float().to(device) # 1. 原来的 MacCounter with torch.no_grad(), MacCounter(method.modules) as mc: method.score(window) custom_macs = mc.macs # 2. THOP:执行相同的 score() 路径 wrapped = ScoreWrapper(method).to(device).eval() thop_macs, thop_params = thop_profile( wrapped, inputs=(window,), verbose=False, report_missing=True ) print(f"Input shape: {tuple(window.shape)}") print(f"MacCounter MACs: {custom_macs / 1e9:.6f} G") print(f"THOP MACs: {thop_macs / 1e9:.6f} G") print(f"THOP 2x MACs: {2 * thop_macs / 1e9:.6f} GFLOPs (approx)") print(f"THOP Params: {thop_params / 1e6:.6f} M") print(f"MACs ratio: {thop_macs / max(custom_macs, 1):.4f}")
这个对照有几个好处:
[1, 64, C](shared 协议、窗口长度为 64 时)。method.score(),包括 DualTF 的两个分支。需要注意,report_missing=True 可以提示缺少计数规则的模块,但不代表所有提示的模块都完全漏计:其内部已被支持的子模块仍可能被正常计数。
你还应检查本地 THOP 的实际版本和来源:
bashpython -m pip show thop ultralytics-thop
THOP 不同版本支持的运算不同,升级版本本身就可能改变测量结果,而不改变模型。
可以按以下顺序排查。
| 观察到的情况 | 优先排查 |
|---|---|
| 一个结果刚好约为另一个的 2 倍 | FLOPs 与 MACs 的换算 |
| THOP MACs 明显更大 | LayerNorm、Softmax、注意力矩阵乘法等额外计数 |
| THOP MACs 明显更小 | THOP 未识别的自定义运算、输入或执行路径不同 |
| Parameters 都不一致 | 模型配置、模型包装、参数注册方式是否一致 |
| DualTF 的差异远大于 DLinear | 频域注意力规模、FFT、计数覆盖范围 |
| 相同方法换数据集后差异很大 | 通道数、窗口长度、官方超参数不同 |
另外,你的 --protocol shared 和 --protocol native 会影响输入长度与模型配置,而注意力计算对长度尤其敏感。不能把 64 长度的结果和 100 长度的结果直接比较。
对于你这份异常检测 benchmark,我建议把指标分成两类。
第一类:结构复杂度。
继续使用 MacCounter,但在论文里明确写成:
Conv/Linear MACs per input window
它代表 Conv / Linear 组成部分的理论乘加计算量,而不是完整模型的运算量。
第二类:端到端推理效率。
保留你已经实现的:
infer_ms_per_winpeak_mem_infer_mbtrain_s_per_epochparams_M这些指标可以更直接地体现真实的计算开销,特别是对于 CATCH、DualTF、FEDformer 等包含频域运算的模型。
如果论文必须报告完整的 FLOPs,建议增加一套统一的算子级计数规则,至少覆盖 Conv、Linear、MatMul / BMM、注意力、FFT,并声明 Softmax、归一化以及其他逐元素运算如何处理。
THOP 可以作为基础,但它并不是所有 PyTorch 运算的完整 FLOPs 计数器。即使使用 PyTorch 自带的 torch.profiler(with_flops=True),其官方说明也指出,该选项只对部分矩阵乘法和二维卷积算子提供 FLOPs 估计。(docs.pytorch.org)
另外,不建议直接把训练一轮的时间或者训练步骤数乘以某个固定倍数来估算训练 FLOPs,因为不同模型的反向传播过程并不相同。
针对你这份代码,最重要的是以下三点:
1. 你现在的 macs_G 并非完整模型 FLOPs。 它的预定统计范围只是 Conv / Linear,因此对于注意力和频域模型,可能遗漏大量实际执行的运算。
2. THOP 也不一定给出完整 FLOPs。 它通常返回 MACs,覆盖哪些运算取决于版本、模型实现和自定义计数规则。不能认为 THOP 的结果就一定比你的结果更准确。
3. 公平对比的关键,是统一统计口径。 如果所有模型都用你现在的 MacCounter,可以比较 Conv / Linear 的计算复杂度;如果使用 THOP,就应让所有模型使用同一个版本、同一个计算入口和同一套规则。
还有一个决定性的信息目前缺失:你没有贴出 efficiency.py 中 MacCounter 类的具体实现。
如果你把 MacCounter 类的完整代码,以及一个实际例子(例如 TimesNet 或 DCdetector 分别通过两种方法算出的 MACs 数值)发给我,我可以进一步逐行核对它与 THOP 的 count_convNd、count_linear 等计数公式,判断差异究竟来自计算公式、遗漏的算子,还是模型执行路径,并给出对应的修改代码。