predict.py

import os
import argparse
from glob import glob

import numpy as np
import torch
from PIL import Image, ImageDraw, ImageFont, ImageOps
from torchvision import transforms

from models.hdcnet import build_model

def _build_model_from_ckpt(ckpt, device, img_size_default: int = 224):
sd = ckpt['model']
cfg = ckpt.get('model_cfg', {})

text
base_c = cfg.get('base_c', 64)
rh_embed_dim = cfg.get('rh_embed_dim', 64)
ppm_bins = cfg.get('ppm_bins', [0, 0.5, 1, 1.5, 2, 3, 4, 5, 10])
offset_limit = cfg.get('offset_limit', 0.8)
rh_range = tuple(cfg.get('rh_range', (70.0, 90.0)))
scale_limit = cfg.get('scale_limit', 0.35)
shift_limit = cfg.get('shift_limit', 1.0)
droppath_max = cfg.get('droppath_max', 0.12)
global_bias_limit = cfg.get('global_bias_limit', 0.3)
ref_rh = cfg.get('ref_rh', 80.0)

model = build_model(ppm_bins=ppm_bins, base_c=base_c,
                    rh_embed_dim=rh_embed_dim,
                    offset_limit=offset_limit, rh_range=rh_range,
                    scale_limit=scale_limit, shift_limit=shift_limit,
                    droppath_max=droppath_max, global_bias_limit=global_bias_limit,
                    ref_rh=ref_rh).to(device)
model.load_state_dict(sd, strict=True)
model.eval()

img_size = ckpt.get('img_size', img_size_default)
tf = transforms.Compose([
    transforms.Resize((img_size, img_size)),
    transforms.ToTensor(),
    transforms.ConvertImageDtype(torch.float32),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225]),
])
return model, tf, img_size

def load_model(weights_path: str, device: torch.device, img_size_default: int = 224):
ckpt = torch.load(weights_path, map_location=device)
return _build_model_from_ckpt(ckpt, device, img_size_default)

@torch.no_grad()
def _run_once(model, tf, device, pil_img):
x = tf(pil_img).unsqueeze(0).to(device)
conc_pred, rh_pred = model(x)
return float(conc_pred.item()), float(rh_pred.item())

@torch.no_grad()
def predict_one(model, tf, device, img_path, tta: bool = True):
img = Image.open(img_path).convert('RGB')
if not tta:
c, r = _run_once(model, tf, device, img)
return img, c, r
# 仅水平镜像的 TTA（避免竖直翻转破坏物理）
views = [img, ImageOps.mirror(img)]
cs, rs = [], []
for im in views:
c, r = _run_once(model, tf, device, im)
cs.append(c); rs.append(r)
return img, float(np.mean(cs)), float(np.mean(rs))

def annotate_and_save(img, conc, rh, save_path):
img = img.copy()
draw = ImageDraw.Draw(img)
text = f"Pred: {conc:.3f} ppm | {rh:.1f}%RH"
try:
font = ImageFont.truetype("arial.ttf", 22)
except Exception:
font = ImageFont.load_default()
w = draw.textlength(text, font=font); h = 24
draw.rectangle([5, 5, 10 + w, 5 + h + 6], fill=(0, 0, 0))
draw.text((10, 8), text, fill=(255, 255, 255), font=font)
os.makedirs(os.path.dirname(save_path) or '.', exist_ok=True)
img.save(save_path)

def collect_images(path: str):
exts = ('.png', '.jpg', '.jpeg', '.bmp', '.PNG', '.JPG', '.JPEG', '.BMP')
if os.path.isdir(path):
paths = []
for ext in exts:
paths += glob(os.path.join(path, '**', f'*{ext}'), recursive=True)
return sorted(list(dict.fromkeys(paths)))
else:
return [path]

def main():
parser = argparse.ArgumentParser()
parser.add_argument('--weights', type=str, default='best_model.pth')
parser.add_argument('--input', type=str, default='predict')
parser.add_argument('--output', type=str, default='predict.png')
parser.add_argument('--no_tta', action='store_true', help='关闭 TTA 推理')
args = parser.parse_args()

text
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model, tf, _ = load_model(args.weights, device)

paths = collect_images(args.input)
if len(paths) == 0:
    raise RuntimeError(f'在 {args.input} 下未发现可用图片。')

if len(paths) == 1 and not os.path.isdir(args.input):
    img, conc, rh = predict_one(model, tf, device, paths[0], tta=(not args.no_tta))
    annotate_and_save(img, conc, rh, args.output)
    print(f"{paths[0]} --> conc={conc:.4f} ppm, RH={rh:.2f}% | saved: {args.output}")
else:
    base_dir = args.input if os.path.isdir(args.input) else os.path.dirname(paths[0]) or '.'
    out_dir = os.path.join(base_dir, 'results'); os.makedirs(out_dir, exist_ok=True)
    for p in paths:
        try:
            img, conc, rh = predict_one(model, tf, device, p, tta=(not args.no_tta))
            filename = os.path.splitext(os.path.basename(p))[0]
            out = os.path.join(out_dir, f"pred_{filename}.png")
            annotate_and_save(img, conc, rh, out)
            print(f"{p} --> conc={conc:.4f} ppm, RH={rh:.2f}% | saved: {out}")
        except Exception as e:
            print(f"[跳过] {p} 发生错误：{e}")

if name == 'main':
main()import argparse
import subprocess
import sys

def main():
parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest='cmd')

text
tr = sub.add_parser('train', help='训练模型')
tr.add_argument('--data_dir', default='data')
tr.add_argument('--epochs', type=int, default=80)
tr.add_argument('--batch_size', type=int, default=16)
tr.add_argument('--img_size', type=int, default=224)
tr.add_argument('--lr', type=float, default=2e-4)
tr.add_argument('--val_ratio', type=float, default=0.2)
tr.add_argument('--w_rh', type=float, default=0.3)
tr.add_argument('--save', default='runs/best_model.pth')

pr = sub.add_parser('predict', help='单图/文件夹预测')
pr.add_argument('--weights', default='runs/best_model.pth')
pr.add_argument('--input', required=True)
pr.add_argument('--output', default='predict/predict.png')
pr.add_argument('--img_size', type=int, default=None)

args = parser.parse_args()

if args.cmd == 'train':
    cmd = [sys.executable, 'runs/train.py',
           '--data_dir', args.data_dir,
           '--epochs', str(args.epochs),
           '--batch_size', str(args.batch_size),
           '--img_size', str(args.img_size),
           '--lr', str(args.lr),
           '--val_ratio', str(args.val_ratio),
           '--w_rh', str(args.w_rh),
           '--save', args.save]
    subprocess.run(cmd, check=True)
elif args.cmd == 'predict':
    cmd = [sys.executable, 'predict.py',
           '--weights', args.weights,
           '--input', args.input,
           '--output', args.output]
    if args.img_size is not None:
        cmd += ['--img_size', str(args.img_size)]
    subprocess.run(cmd, check=True)
else:
    parser.print_help()

if name == 'main':
main()# train.py
import os
import argparse
from typing import Tuple

import numpy as np
from sklearn.model_selection import train_test_split
from tqdm import tqdm

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader, Subset, WeightedRandomSampler
from torch.optim.swa_utils import AveragedModel, SWALR, update_bn

from dataset import GasResponseDataset
from models.hdcnet import build_model

=============== 工具 ===============

def seed_everything(seed: int = 42):
import random
random.seed(seed); np.random.seed(seed)
torch.manual_seed(seed); torch.cuda.manual_seed_all(seed)

def split_idx(n: int, val_ratio: float = 0.2, seed: int = 42):
idx = np.arange(n)
tr, val = train_test_split(idx, test_size=val_ratio, random_state=seed, shuffle=True)
return tr, val

def pinball_loss(pred: torch.Tensor, target: torch.Tensor, tau: float = 0.7):
e = target - pred # e>0（低估）→ 惩罚系数 tau
return torch.mean(torch.where(e >= 0, tau * e, (1 - tau) * (-e)))

def build_sampler_for_subset(subset: Subset):
# (RH, conc) 组内平衡
from collections import Counter
base = subset.dataset; idxs = subset.indices
keys = [(round(base.samples[i][2], 2), round(base.samples[i][1], 3)) for i in idxs]
cnt = Counter(keys)
weights = [1.0 / cnt[(round(base.samples[i][2], 2), round(base.samples[i][1], 3))] for i in idxs]
return WeightedRandomSampler(weights, num_samples=len(weights), replacement=True)

class WarmupCosine(torch.optim.lr_scheduler._LRScheduler):
def init(self, optimizer, warmup_steps, max_steps, min_lr=1e-6, last_epoch=-1):
self.warmup_steps = warmup_steps; self.max_steps = max_steps; self.min_lr = min_lr
super().init(optimizer, last_epoch)
def get_lr(self):
step = self.last_epoch + 1
lrs = []
for base_lr in self.base_lrs:
if step <= self.warmup_steps:
lrs.append(base_lr * step / max(1, self.warmup_steps))
else:
t = (step - self.warmup_steps) / max(1, self.max_steps - self.warmup_steps)
lrs.append(self.min_lr + 0.5 * (base_lr - self.min_lr) * (1 + np.cos(np.pi * t)))
return lrs

=============== Ordinal 软目标 ===============

def ordinal_soft_targets(conc_gt: torch.Tensor, bins: torch.Tensor, tau: float = 0.25):
device = conc_gt.device
bins = bins.to(device)
thetas = 0.5 * (bins[:-1] + bins[1:]) # (K-1,)
diff = (conc_gt - thetas.view(1, -1)) / tau
return torch.sigmoid(diff) # (B,K-1)

=============== 评估 ===============

@torch.no_grad()
def evaluate(model, loader, device):
model.eval()
mse_sum = c_mae = r_mae = c_rmse = r_rmse = 0.0
mse = nn.MSELoss(reduction='sum')
for imgs, targets, _ in tqdm(loader, desc='Val', leave=False):
imgs = imgs.to(device, non_blocking=True)
conc_gt = targets[:, 0:1].to(device)
rh_gt = targets[:, 1:2].to(device)
conc_pred, rh_pred = model(imgs)
mse_sum += (mse(conc_pred, conc_gt) + mse(rh_pred, rh_gt)).item()
c_mae += torch.sum(torch.abs(conc_gt - conc_pred)).item()
r_mae += torch.sum(torch.abs(rh_gt - rh_pred)).item()
c_rmse += torch.sum((conc_gt - conc_pred) ** 2).item()
r_rmse += torch.sum((rh_gt - rh_pred) ** 2).item()
n = len(loader.dataset)
return (mse_sum / n, c_mae / n, r_mae / n, np.sqrt(c_rmse / n), np.sqrt(r_rmse / n))

=============== 主函数 ===============

def main():
parser = argparse.ArgumentParser(description='HDC-Net: Humidity-Drift Counteraction Attention CNN')
parser.add_argument('--data_dir', type=str, default='data')
parser.add_argument('--epochs', type=int, default=420)
parser.add_argument('--batch_size', type=int, default=16)
parser.add_argument('--img_size', type=int, default=256)
parser.add_argument('--lr', type=float, default=3e-4)
parser.add_argument('--warmup_epochs', type=int, default=10)
parser.add_argument('--val_ratio', type=float, default=0.2)

text
# 损失与正则
parser.add_argument('--w_ord', type=float, default=0.9)
parser.add_argument('--w_low', type=float, default=1.6, help='低浓度段（<=1ppm）加权')
parser.add_argument('--w_inv', type=float, default=0.06, help='跨湿度一致性权重')
parser.add_argument('--w_pin0', type=float, default=0.5)
parser.add_argument('--w_pin1', type=float, default=0.85)
parser.add_argument('--tau0', type=float, default=0.72)
parser.add_argument('--tau1', type=float, default=0.90)
parser.add_argument('--ord_tau', type=float, default=0.25)
parser.add_argument('--w_scale_smooth', type=float, default=0.02)

# 训练技巧
parser.add_argument('--mixup', type=float, default=0.2)
parser.add_argument('--consis', type=float, default=0.05)
parser.add_argument('--tf_decay_until', type=int, default=210)

parser.add_argument('--save', type=str, default='best_model.pth')
parser.add_argument('--num_workers', type=int, default=0)
parser.add_argument('--ema', action='store_true')
parser.add_argument('--balance', action='store_true')

# SWA
parser.add_argument('--swa', action='store_true')
parser.add_argument('--swa_start', type=int, default=340)
parser.add_argument('--swa_lr', type=float, default=1e-4)

# 校准微调
parser.add_argument('--calib_ft_epochs', type=int, default=15)
parser.add_argument('--calib_ft_lr', type=float, default=5e-5)

args = parser.parse_args()
seed_everything(42)
os.makedirs(os.path.dirname(args.save) or '.', exist_ok=True)

full_train = GasResponseDataset(args.data_dir, image_size=args.img_size, augment=True, erase=True)
full_eval  = GasResponseDataset(args.data_dir, image_size=args.img_size, augment=False, erase=False)

ppm_bins = sorted({conc for _, conc, _ in full_train.samples})
print("ppm bins:", ppm_bins)
bins_t = torch.tensor(ppm_bins, dtype=torch.float32)

tr_idx, val_idx = split_idx(len(full_train), val_ratio=args.val_ratio, seed=42)
train_ds = Subset(full_train, tr_idx)
val_ds   = Subset(full_eval,  val_idx)

if args.balance:
    sampler = build_sampler_for_subset(train_ds)
    train_loader = DataLoader(train_ds, batch_size=args.batch_size, sampler=sampler,
                              num_workers=args.num_workers, pin_memory=True)
else:
    train_loader = DataLoader(train_ds, batch_size=args.batch_size, shuffle=True,
                              num_workers=args.num_workers, pin_memory=True)
val_loader = DataLoader(val_ds, batch_size=args.batch_size, shuffle=False,
                        num_workers=args.num_workers, pin_memory=True)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = build_model(ppm_bins=ppm_bins, base_c=64, offset_limit=0.8,
                    rh_range=(70.0, 90.0), scale_limit=0.35, shift_limit=1.0,
                    droppath_max=0.12, global_bias_limit=0.3, ref_rh=80.0).to(device)

optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1e-4)
scheduler = WarmupCosine(optimizer,
                         warmup_steps=args.warmup_epochs * max(1, len(train_loader)),
                         max_steps=args.epochs * max(1, len(train_loader)),
                         min_lr=1e-6)
scaler = torch.cuda.amp.GradScaler(enabled=(device.type == 'cuda'))

# EMA（简单滑动）
ema = None
if args.ema:
    import copy
    ema = copy.deepcopy(model).eval()
    for p in ema.parameters(): p.requires_grad_(False)

swa_model = AveragedModel(model) if args.swa else None
swa_scheduler = SWALR(optimizer, swa_lr=args.swa_lr) if args.swa else None

l1 = nn.SmoothL1Loss()

best_score = float('inf')
patience, no_improve = 70, 0
T_total = max(1, args.epochs)

for epoch in range(1, args.epochs + 1):
    model.train()
    ep_loss = ep_ord = ep_pin = ep_inv = ep_scale = 0.0
    c_mae = r_mae = 0.0

    tf_p = max(0.0, 1.0 - epoch / max(1, args.tf_decay_until))
    t = (epoch - 1) / (T_total - 1)
    tau_dyn = args.tau0 + (args.tau1 - args.tau0) * t
    w_pin_dyn = args.w_pin0 + (args.w_pin1 - args.w_pin0) * t

    K = len(ppm_bins); T_ord = K - 1
    idx = torch.arange(T_ord, device=device).float()
    pos_weight = (1.25 + 0.75 * (idx / max(1, T_ord - 1)))
    idx_weight = (1.0 + 0.5 * (idx / max(1, T_ord - 1))).view(1, -1)

    # —— 修复 scheduler 提醒：首个 batch 不 step
    stepped_once = False

    for imgs, targets, _ in tqdm(train_loader, desc=f'Train {epoch}/{args.epochs} (TF={tf_p:.2f}, tau={tau_dyn:.2f}, wpin={w_pin_dyn:.2f})'):
        imgs = imgs.to(device, non_blocking=True)
        targets = targets.to(device)
        conc_gt = targets[:, 0:1]
        rh_gt = targets[:, 1:2]

        # mixup
        if args.mixup > 0:
            lam = np.random.beta(args.mixup, args.mixup)
            idx_shuf = torch.randperm(imgs.size(0), device=device)
            imgs = lam * imgs + (1 - lam) * imgs[idx_shuf]
            targets = lam * targets + (1 - lam) * targets[idx_shuf]
            conc_gt = targets[:, 0:1]; rh_gt = targets[:, 1:2]

        with torch.no_grad():
            conc_free, rh_free = model(imgs)
            mask = (torch.rand_like(rh_gt) < tf_p).float()
            rh_override = mask * rh_gt + (1 - mask) * rh_free

        optimizer.zero_grad(set_to_none=True)
        with torch.cuda.amp.autocast(enabled=(device.type == 'cuda')):
            (conc_final, rh_pred, ord_logits, m_raw, m_corr, s, b, conc_ord, conc_m,
             log_s_conc, log_s_rh, g_bias) = model(imgs, rh_override=rh_override, return_extra=True)

            # Ordinal 软目标：低浓度阈值额外加权
            ord_targets = ordinal_soft_targets(conc_gt, bins_t, tau=args.ord_tau).to(device)
            low_mask = (bins_t[:-1] <= 1.0).float().view(1, -1).to(device)
            weight = idx_weight.expand_as(ord_logits) * (1.0 + (args.w_low - 1.0) * low_mask)
            loss_ord = F.binary_cross_entropy_with_logits(ord_logits, ord_targets,
                                                          weight=weight, pos_weight=pos_weight)

            # 回归与 RH（不确定性加权）
            loss_conc = torch.exp(-2 * log_s_conc) * l1(conc_final, conc_gt) + log_s_conc
            loss_rh   = torch.exp(-2 * log_s_rh)   * l1(rh_pred,  rh_gt)   + log_s_rh

            # pinball：抑制低估
            loss_pin = pinball_loss(conc_final, conc_gt, tau=tau_dyn)

            # —— 跨湿度一致性（用“离散浓度档位”分组，避免 mixup 后无法匹配）
            with torch.no_grad():
                # 将连续 conc_gt 映射到最近的离散 ppm_bin id
                bins_dev = bins_t.to(device).view(1, -1)  # (1,K)
                # 最近 bin（按平方差）
                bin_ids = torch.argmin((conc_gt - bins_dev) ** 2, dim=1)  # (B,)
            z = torch.cat([conc_ord.detach(), conc_m.detach()], dim=1)  # (B,2)
            # 仅约束“同 bin 不同 RH”的 pair
            eq_conc = bin_ids.unsqueeze(1) == bin_ids.unsqueeze(0)
            diff_rh = torch.gt(torch.abs(rh_gt - rh_gt.t()), 0.1)
            mask_pair = torch.triu((eq_conc & diff_rh), diagonal=1)
            if mask_pair.any():
                zi = z.unsqueeze(1).expand(-1, z.size(0), -1)
                zj = z.unsqueeze(0).expand(z.size(0), -1, -1)
                d2 = ((zi - zj) ** 2).sum(dim=-1)
                loss_inv = d2[mask_pair].mean()
            else:
                loss_inv = torch.tensor(0.0, device=device)

            # s(RH) 平滑正则
            order = torch.argsort(rh_gt.view(-1))
            s_sorted = s[order].view(-1)
            loss_scale_smooth = torch.mean((s_sorted[1:] - s_sorted[:-1]) ** 2) if s_sorted.numel() > 1 else torch.tensor(0.0, device=device)

            loss = (loss_conc + loss_rh +
                    args.w_ord * loss_ord +
                    w_pin_dyn * loss_pin +
                    args.w_inv * loss_inv +
                    args.w_scale_smooth * loss_scale_smooth)

        scaler.scale(loss).backward()
        scaler.unscale_(optimizer)
        nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        scaler.step(optimizer)
        scaler.update()

        # —— 从第二个 batch 开始再 step 学习率（避免提示）
        if stepped_once:
            scheduler.step()
        else:
            stepped_once = True

        if ema:
            with torch.no_grad():
                for p_m, p_e in zip(model.parameters(), ema.parameters()):
                    if p_e.data.dtype.is_floating_point:
                        p_e.data.mul_(0.999).add_(p_m.data * (1 - 0.999))
                    else:
                        p_e.data = p_m.data

        if args.swa and epoch >= args.swa_start:
            swa_model.update_parameters(model)
            swa_scheduler.step()

        # 统计
        bs = imgs.size(0)
        ep_loss += loss.item() * bs
        ep_ord  += loss_ord.item() * bs
        ep_pin  += loss_pin.item() * bs
        ep_inv  += loss_inv.item() * bs
        ep_scale+= loss_scale_smooth.item() * bs
        c_mae   += (torch.abs(conc_gt - conc_final)).sum().item()
        r_mae   += (torch.abs(rh_gt - rh_pred)).sum().item()

    n_tr = len(train_loader.dataset)
    print(f'[Epoch {epoch:03d}] train_loss={ep_loss/n_tr:.4f} | conc_MAE={c_mae/n_tr:.4f} | RH_MAE={r_mae/n_tr:.4f} | '
          f'loss_ord={ep_ord/n_tr:.4f} | loss_pin={ep_pin/n_tr:.4f} | loss_inv={ep_inv/n_tr:.4f} | s_smooth={ep_scale/n_tr:.4f}')

    # 验证：优先 SWA 其次 EMA
    eval_model = model
    if args.swa and epoch >= args.swa_start:
        update_bn(train_loader, swa_model, device=device)
        eval_model = swa_model
    elif ema:
        eval_model = ema

    val_loss, vc_mae, vr_mae, vc_rmse, vr_rmse = evaluate(eval_model, val_loader, device)
    print(f'           val_loss={val_loss:.4f} | conc_MAE={vc_mae:.4f} (RMSE {vc_rmse:.4f}) | RH_MAE={vr_mae:.4f} (RMSE {vr_rmse:.4f})')

    score = vc_mae + 0.2 * vr_mae
    if score < best_score:
        best_score = score
        torch.save({
            'model': eval_model.state_dict(),
            'img_size': args.img_size,
            'model_cfg': {
                'base_c': 64, 'rh_embed_dim': 64,
                'ppm_bins': ppm_bins, 'offset_limit': 0.8,
                'rh_range': (70.0, 90.0),
                'scale_limit': 0.35, 'shift_limit': 1.0,
                'droppath_max': 0.12, 'global_bias_limit': 0.3, 'ref_rh': 80.0
            }
        }, args.save)
        print(f'** Saved best to {args.save} (score={score:.4f}) **')
        no_improve = 0
    else:
        no_improve += 1
        if no_improve >= patience:
            print('Early stopping.')
            break

# ===== 校准微调（仅缩放/融合小头） =====
if args.calib_ft_epochs > 0:
    print(f'\n[Calibration Fine-Tune] epochs={args.calib_ft_epochs}, lr={args.calib_ft_lr}')
    model.eval()
    for p in model.parameters(): p.requires_grad_(False)
    for n, p in model.named_parameters():
        if any(k in n for k in ['scaler', 'conc_from_m', 'fuse_head', 'global_bias_raw']):
            p.requires_grad_(True)

    opt_calib = torch.optim.AdamW(filter(lambda p: p.requires_grad, model.parameters()),
                                  lr=args.calib_ft_lr, weight_decay=0.0)
    l1 = nn.SmoothL1Loss()
    for e in range(1, args.calib_ft_epochs + 1):
        model.train()
        run_loss = 0.0; c_mae = 0.0
        for imgs, targets, _ in tqdm(train_loader, desc=f'CalibFT {e}/{args.calib_ft_epochs}'):
            imgs = imgs.to(device); targets = targets.to(device)
            conc_gt = targets[:, 0:1]; rh_gt = targets[:, 1:2]
            opt_calib.zero_grad(set_to_none=True)
            conc_pred, rh_pred = model(imgs)
            loss = l1(conc_pred, conc_gt) + 0.25 * l1(rh_pred, rh_gt)
            loss.backward(); opt_calib.step()
            run_loss += loss.item() * imgs.size(0)
            c_mae += (torch.abs(conc_gt - conc_pred)).sum().item()
        print(f'   [CalibFT] loss={run_loss/len(train_loader.dataset):.4f} | conc_MAE={c_mae/len(train_loader.dataset):.4f}')

    torch.save({
        'model': model.state_dict(),
        'img_size': args.img_size,
        'model_cfg': {
            'base_c': 64, 'rh_embed_dim': 64,
            'ppm_bins': ppm_bins, 'offset_limit': 0.8,
            'rh_range': (70.0, 90.0),
            'scale_limit': 0.35, 'shift_limit': 1.0,
            'droppath_max': 0.12, 'global_bias_limit': 0.3, 'ref_rh': 80.0
        }
    }, args.save)
    print(f'** Saved calibrated model to {args.save} **')

if name == 'main':
main()# models/hdcnet.py
import math
from typing import List, Optional, Tuple

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

-------------------- 基础组件 --------------------

class DropPath(nn.Module):
def init(self, drop_prob: float = 0.0):
super().init()
self.drop_prob = drop_prob
def forward(self, x):
if self.drop_prob == 0.0 or not self.training:
return x
keep = 1.0 - self.drop_prob
shape = (x.shape[0],) + (1,) * (x.ndim - 1)
mask = x.new_empty(shape).bernoulli_(keep)
return x / keep * mask

class ConvBNAct(nn.Module):
def init(self, in_c, out_c, k=3, s=1, p=None, groups=1, d=1):
super().init()
if p is None:
p = ((k - 1) // 2) * d
self.conv = nn.Conv2d(in_c, out_c, k, s, p, groups=groups, bias=False, dilation=d)
self.bn = nn.BatchNorm2d(out_c)
self.act = nn.SiLU(inplace=True)
def forward(self, x):
return self.act(self.bn(self.conv(x)))

class SEBlock(nn.Module):
def init(self, c, r=16):
super().init()
mid = max(1, c // r)
self.fc1 = nn.Conv2d(c, mid, 1)
self.fc2 = nn.Conv2d(mid, c, 1)
def forward(self, x):
w = F.adaptive_avg_pool2d(x, 1)
w = F.silu(self.fc1(w))
w = torch.sigmoid(self.fc2(w))
return x * w

class SpatialAttention(nn.Module):
def init(self, k=7):
super().init()
self.conv = nn.Conv2d(2, 1, k, padding=(k - 1) // 2, bias=False)
def forward(self, x):
avg = torch.mean(x, dim=1, keepdim=True)
mx, _ = torch.max(x, dim=1, keepdim=True)
a = torch.sigmoid(self.conv(torch.cat([avg, mx], dim=1)))
return x * a

class CBAM(nn.Module):
def init(self, c, r=16):
super().init()
self.se = SEBlock(c, r=r)
self.sa = SpatialAttention()
def forward(self, x):
return self.sa(self.se(x))

class FiLM(nn.Module):
"""FiLM：RH 嵌入调制 x -> x*(1+γ)+β"""
def init(self, feat_c: int, emb_dim: int):
super().init()
self.fc = nn.Sequential(
nn.Linear(emb_dim, 2 * feat_c),
nn.SiLU(),
nn.Linear(2 * feat_c, 2 * feat_c)
)
def forward(self, x: torch.Tensor, emb: torch.Tensor):
gb = self.fc(emb)
gamma, beta = torch.chunk(gb, 2, dim=1)
return x * (1 + gamma.unsqueeze(-1).unsqueeze(-1)) + beta.unsqueeze(-1).unsqueeze(-1)

class RHGuidedCrossAttention(nn.Module):
"""
RH 引导的多头交叉注意力：
- Query 来自 RH 嵌入（映射为通道维度的门控）
- Key/Value 来自图像特征 token
"""
def init(self, in_c: int, emb_dim: int, num_heads: int = 4):
super().init()
assert in_c % num_heads == 0, "in_c 必须能被 num_heads 整除"
self.num_heads = num_heads
self.q_proj = nn.Linear(emb_dim, in_c)
self.k_proj = nn.Linear(in_c, in_c)
self.v_proj = nn.Linear(in_c, in_c)
self.out = nn.Linear(in_c, in_c)

text
def forward(self, feat_2d: torch.Tensor, rh_emb: torch.Tensor):
    B, C, H, W = feat_2d.shape
    N = H * W
    tokens = feat_2d.flatten(2).transpose(1, 2)   # (B,N,C)
    Q = self.q_proj(rh_emb).unsqueeze(1)          # (B,1,C)
    K = self.k_proj(tokens)                       # (B,N,C)
    V = self.v_proj(tokens)                       # (B,N,C)

    head_dim = C // self.num_heads
    def split(x):  # (B,T,C)->(B,heads,T,head_dim)
        return x.view(B, -1, self.num_heads, head_dim).transpose(1, 2)
    Qh = split(Q)          # (B,h,1,d)
    Kh = split(K)          # (B,h,N,d)
    Vh = split(V)          # (B,h,N,d)

    attn = torch.softmax((Qh @ Kh.transpose(-2, -1)) / math.sqrt(head_dim), dim=-1)  # (B,h,1,N)
    out = (attn @ Vh).transpose(1, 2).reshape(B, 1, C)  # (B,1,C)
    out = self.out(out).squeeze(1)                      # (B,C)
    gate = torch.sigmoid(out).unsqueeze(-1).unsqueeze(-1)
    return feat_2d * (1.0 + gate)

class Bottleneck(nn.Module):
"""残差 + CBAM + DropPath（支持空洞）"""
def init(self, in_c, out_c, stride=1, drop: float = 0.0, dilation: int = 1):
super().init()
self.conv1 = ConvBNAct(in_c, out_c, 3, stride, d=dilation)
self.conv2 = ConvBNAct(out_c, out_c, 3, 1, d=dilation)
self.attn = CBAM(out_c)
self.drop = DropPath(drop)
self.use_short = (stride != 1) or (in_c != out_c)
self.short = nn.Identity() if not self.use_short else nn.Conv2d(in_c, out_c, 1, stride, bias=False)
def forward(self, x):
y = self.conv2(self.conv1(x))
y = self.attn(y)
y = self.drop(y)
s = self.short(x) if self.use_short else x
return y + s

-------------------- 主网络：HDC-Net --------------------

class HDCNet(nn.Module):
"""
Humidity-Drift Counteraction Network
- 深残差 + CBAM
- RH 回归 -> FiLM + RH 引导跨注意力
- 幅值代理 m + RH 缩放/偏移 s(RH), b(RH) 做补偿（对齐不同 RH 的幅值漂移）
- 浓度：Ordinal(CORAL)+offset 路径 与 幅值补偿路径 融合
- 训练期带不确定性加权
"""
def init(self,
in_c: int = 3,
base_c: int = 64,
rh_embed_dim: int = 64,
ppm_bins: Optional[List[float]] = None,
offset_limit: float = 0.8,
rh_range: Tuple[float, float] = (70.0, 90.0),
scale_limit: float = 0.35,
shift_limit: float = 1.0,
droppath_max: float = 0.12,
global_bias_limit: float = 0.3,
ref_rh: float = 80.0):
super().init()
self.ppm_bins = torch.tensor(sorted(ppm_bins or [0, 0.5, 1, 1.5, 2, 3, 4, 5, 10]), dtype=torch.float32)
self.register_buffer("ppm_bins_buf", self.ppm_bins)
self.offset_limit = float(offset_limit)
self.rh_min, self.rh_max = rh_range
self.scale_limit = float(scale_limit)
self.shift_limit = float(shift_limit)
self.global_bias_limit = float(global_bias_limit)
self.ref_rh = float(ref_rh)

text
    c1, c2, c3, c4 = base_c, base_c * 2, base_c * 4, base_c * 8
    self.stem = nn.Sequential(ConvBNAct(in_c, c1, 3, 2), ConvBNAct(c1, c1, 3, 1), CBAM(c1))
    def dp(i, n): return droppath_max * (i + 1) / n
    self.stage2 = nn.Sequential(
        Bottleneck(c1, c2, stride=2, drop=dp(0, 12)),
        Bottleneck(c2, c2, 1, drop=dp(1, 12)),
        Bottleneck(c2, c2, 1, drop=dp(2, 12)),
        Bottleneck(c2, c2, 1, drop=dp(3, 12)),
    )
    self.stage3 = nn.Sequential(
        Bottleneck(c2, c3, stride=2, drop=dp(4, 12)),
        Bottleneck(c3, c3, 1, drop=dp(5, 12), dilation=2),
        Bottleneck(c3, c3, 1, drop=dp(6, 12), dilation=2),
        Bottleneck(c3, c3, 1, drop=dp(7, 12), dilation=2),
        Bottleneck(c3, c3, 1, drop=dp(8, 12), dilation=2),
    )
    self.stage4 = nn.Sequential(
        Bottleneck(c3, c4, stride=2, drop=dp(9, 12)),
        Bottleneck(c4, c4, 1, drop=dp(10, 12), dilation=2),
        Bottleneck(c4, c4, 1, drop=dp(11, 12), dilation=2),
    )
    self.gap = nn.AdaptiveAvgPool2d(1)
    feat_c = c4

    # RH 预测分支
    self.rh_head = nn.Sequential(
        nn.Flatten(), nn.Linear(feat_c, rh_embed_dim), nn.SiLU(), nn.Dropout(0.2), nn.Linear(rh_embed_dim, 1)
    )
    self.rh_proj = nn.Sequential(nn.Linear(1, rh_embed_dim), nn.SiLU())
    self.film = FiLM(feat_c, rh_embed_dim)
    self.rh_cross_attn = RHGuidedCrossAttention(in_c=feat_c, emb_dim=rh_embed_dim, num_heads=4)

    # Ordinal(CORAL) + 偏移（RH 条件化）
    T = max(1, len(self.ppm_bins) - 1)
    self.cls_pre = nn.Sequential(
        nn.Conv2d(feat_c, feat_c // 2, 1, bias=False),
        nn.BatchNorm2d(feat_c // 2),
        nn.SiLU(inplace=True),
        CBAM(feat_c // 2),
        nn.AdaptiveAvgPool2d(1),
        nn.Flatten(),
        nn.Dropout(0.2),
    )
    self.cls_fc = nn.Linear(feat_c // 2 + rh_embed_dim, T)

    self.off_pre = nn.Sequential(
        nn.Conv2d(feat_c, feat_c // 2, 1, bias=False),
        nn.BatchNorm2d(feat_c // 2),
        nn.SiLU(inplace=True),
        nn.AdaptiveAvgPool2d(1),
        nn.Flatten(),
        nn.Dropout(0.1),
    )
    self.off_fc = nn.Sequential(nn.Linear(feat_c // 2 + rh_embed_dim, feat_c // 4), nn.SiLU(), nn.Linear(feat_c // 4, 1))

    # 幅值代理 & RH 缩放补偿
    self.mod_head = nn.Sequential(
        nn.Conv2d(feat_c, feat_c // 4, 1, bias=False),
        nn.BatchNorm2d(feat_c // 4),
        nn.SiLU(inplace=True),
        nn.AdaptiveAvgPool2d(1),
        nn.Flatten(),
        nn.Linear(feat_c // 4, 64),
        nn.SiLU(),
        nn.Linear(64, 1)  # m: 幅值代理
    )
    self.scaler = nn.Sequential(  # RH -> s,b
        nn.Linear(rh_embed_dim, 64), nn.SiLU(),
        nn.Linear(64, 2)
    )
    self.conc_from_m = nn.Sequential(
        nn.Linear(1 + rh_embed_dim, 64), nn.SiLU(), nn.Linear(64, 1)
    )

    # 融合头
    self.fuse_head = nn.Sequential(
        nn.Linear(2 + rh_embed_dim, 64), nn.SiLU(), nn.Linear(64, 1)
    )

    # 全局偏置
    self.global_bias_raw = nn.Parameter(torch.tensor(0.1))

    # 不确定性
    self.log_sigma_conc = nn.Parameter(torch.zeros(1))
    self.log_sigma_rh   = nn.Parameter(torch.zeros(1))

# ---------- utils ----------
def backbone(self, x):
    x = self.stem(x); x = self.stage2(x); x = self.stage3(x); x = self.stage4(x)
    return x

def _scale_rh(self, x):
    return torch.sigmoid(x) * (self.rh_max - self.rh_min) + self.rh_min

def _ordinal_to_probs(self, ord_p: torch.Tensor) -> torch.Tensor:
    B, T = ord_p.shape
    ones = ord_p.new_ones(B, 1)
    p_ge = torch.cat([ones, ord_p], dim=1)
    p_lt = torch.cat([ord_p, ord_p.new_zeros(B, 1)], dim=1)
    probs = torch.clamp(p_ge - p_lt, 1e-6, 1-1e-6)
    return probs

# ---------- forward ----------
def forward(self, x,
            rh_override: Optional[torch.Tensor] = None,
            return_extra: bool = False):
    feats = self.backbone(x)            # (B,C,H,W)
    g = self.gap(feats)
    g_flat = g.flatten(1)

    # 1) RH
    rh_raw = self.rh_head(g)
    rh_pred = self._scale_rh(rh_raw)
    rh_for_film = rh_override if rh_override is not None else rh_pred.detach()
    rh_emb = self.rh_proj(torch.tanh(rh_for_film))

    # 2) RH 条件化（FiLM + RH cross-attn）
    feats_mod = self.film(feats, rh_emb)
    feats_mod = self.rh_cross_attn(feats_mod, rh_emb)

    # 3) Ordinal+offset
    cls_feat = self.cls_pre(feats_mod)
    ord_logits = self.cls_fc(torch.cat([cls_feat, rh_emb], dim=1))  # (B,K-1)
    ord_p = torch.sigmoid(ord_logits)
    probs = self._ordinal_to_probs(ord_p)
    bins = self.ppm_bins_buf.view(1, -1)
    exp_val = torch.sum(probs * bins, dim=1, keepdim=True)
    off_feat = self.off_pre(feats_mod)
    offset = torch.tanh(self.off_fc(torch.cat([off_feat, rh_emb], dim=1))) * self.offset_limit
    conc_ord = exp_val + offset

    # 4) m(RH) 缩放补偿
    m_raw = self.mod_head(feats_mod)
    sb = self.scaler(rh_emb)
    s = 1.0 + torch.tanh(sb[:, 0:1]) * self.scale_limit
    b = torch.tanh(sb[:, 1:2]) * self.shift_limit
    m_corr = m_raw / s + b
    conc_m = self.conc_from_m(torch.cat([m_corr, rh_emb], dim=1))

    # 5) 融合 + 全局偏置
    conc_final = self.fuse_head(torch.cat([conc_ord, conc_m, rh_emb], dim=1))
    global_bias = torch.tanh(self.global_bias_raw) * self.global_bias_limit
    conc_final = conc_final + global_bias

    if return_extra:
        return (conc_final, rh_pred, ord_logits, m_raw, m_corr, s, b, conc_ord, conc_m,
                self.log_sigma_conc, self.log_sigma_rh, global_bias)
    return conc_final, rh_pred

def build_model(ppm_bins: Optional[List[float]] = None,
in_c: int = 3,
base_c: int = 64,
rh_embed_dim: int = 64,
offset_limit: float = 0.8,
rh_range: Tuple[float, float] = (70.0, 90.0),
scale_limit: float = 0.35,
shift_limit: float = 1.0,
droppath_max: float = 0.12,
global_bias_limit: float = 0.3,
ref_rh: float = 80.0):
return HDCNet(in_c=in_c,
base_c=base_c,
rh_embed_dim=rh_embed_dim,
ppm_bins=ppm_bins,
offset_limit=offset_limit,
rh_range=rh_range,
scale_limit=scale_limit,
shift_limit=shift_limit,
droppath_max=droppath_max,
global_bias_limit=global_bias_limit,
ref_rh=ref_rh)这是我模型目前的所有结构，请你进行学习

现在我需要进行一项工作，就是我的用stm32和传感器采样后的数据会上传到华为云云端平台，然后我会把我的模型部署到云端平台，对采样得到的数据进行预测，由于我得到的是数据而不是图片，所以不能直接进行预测，我需要在预测前将其化为图片形式，请你帮我思考应该如何加入呢，我之前训练集的绘图代码如下，你得保证在预测前绘制出来的图片与我的训练集样式一致否则会在后续预测中产生严重误差。import os
import pandas as pd
from openpyxl import load_workbook
from openpyxl.styles import Font, Alignment, Border

def process_and_split_data(file_path, save_dir, chunk_size=400):
"""
处理数据分割函数

text
参数:
    file_path: Excel文件路径
    save_dir: 保存分割后文件的目录
    chunk_size: 每个数据块的大小(默认400)
"""
# 读取Excel文件
try:
    df = pd.read_excel(file_path, header=None)
    print(f"成功读取文件，总行数: {len(df)}")
except Exception as e:
    print(f"读取文件失败: {e}")
    return

# 删除前两列（只保留第三列及之后的数据）
if df.shape[1] >= 2:
    df = df.iloc[:, 2:]
print(f"删除前两列后，数据形状: {df.shape}")

# 确保保存目录存在
os.makedirs(save_dir, exist_ok=True)

# 计算需要分割的组数（每组401行，包含400个新数据点+1个重叠点）
total_rows = len(df)
group_size = chunk_size + 1  # 每组401行
num_groups = (total_rows - 1) // chunk_size  # 计算完整组数

print(f"将分割为 {num_groups} 组数据，每组 {group_size} 行")

# 创建并保存每组数据
for i in range(num_groups):
    start_idx = i * chunk_size
    end_idx = start_idx + group_size

    # 确保不超出数据范围
    if end_idx > total_rows:
        break

    # 提取当前组的数据
    group_data = df.iloc[start_idx:end_idx].copy()

    # 重置索引为1-401
    group_data.index = range(1, len(group_data) + 1)

    # 设置文件名和保存路径
    filename = f"{i+1}.xlsx"
    save_path = os.path.join(save_dir, filename)

    # 保存为Excel文件
    group_data.to_excel(save_path, index=True, header=False)

    # 应用格式设置：Times New Roman字体、居中、不加粗、无边框
    apply_excel_formatting(save_path)

    print(f"已保存第 {i+1} 组数据: {save_path} (行 {start_idx+1}-{end_idx})")

print("数据分割完成!")

def apply_excel_formatting(file_path):
"""
应用Excel格式设置：Times New Roman字体、居中对齐、不加粗、无边框
"""
# 加载工作簿
wb = load_workbook(file_path)
ws = wb.active

text
# 创建样式
font_style = Font(name='Times New Roman', bold=False)  # Times New Roman字体，不加粗
alignment_style = Alignment(horizontal='center', vertical='center')  # 居中对齐
no_border = Border(left=None, right=None, top=None, bottom=None)  # 无边框

# 应用样式到所有单元格
for row in ws.iter_rows():
    for cell in row:
        cell.font = font_style
        cell.alignment = alignment_style
        cell.border = no_border

# 调整列宽以适应内容
for column in ws.columns:
    max_length = 0
    column_letter = column[0].column_letter
    for cell in column:
        try:
            if len(str(cell.value)) > max_length:
                max_length = len(str(cell.value))
        except:
            pass
    adjusted_width = min(max_length + 2, 50)  # 限制最大列宽
    ws.column_dimensions[column_letter].width = adjusted_width

# 保存修改
wb.save(file_path)

主程序

if name == "main":
# 设置文件路径和保存目录
file_path = r"C:\Users\lenovo\Desktop\数据\数据\90%RH\90-10.xls"
save_dir = r"C:\Users\lenovo\Desktop\数据\数据\90%RH\90-10"

text
# 处理数据分割
process_and_split_data(file_path, save_dir, chunk_size=400)

注意我的训练集就是通过刚才代码生成的照片，我不理解你说的转PDF什么是干吗的，重新思考理解我的意思！！！现在我需要进行一项工作，就是我的用stm32和传感器采样后的数据会上传到华为云云端平台，然后我会把我的模型部署到云端平台，对采样得到的数据进行预测，由于我得到的是数据而不是图片，所以不能直接进行预测，我需要在预测前将其化为图片形式，请你帮我思考应该如何加入呢，我之前训练集的绘图代码如下，你得保证在预测前绘制出来的图片与我的训练集样式一致否则会在后续预测中产生严重误差。import os
import pandas as pd
from openpyxl import load_workbook
from openpyxl.styles import Font, Alignment, Border

def process_and_split_data(file_path, save_dir, chunk_size=400):
"""
处理数据分割函数

text
参数:
    file_path: Excel文件路径
    save_dir: 保存分割后文件的目录
    chunk_size: 每个数据块的大小(默认400)
"""
# 读取Excel文件
try:
    df = pd.read_excel(file_path, header=None)
    print(f"成功读取文件，总行数: {len(df)}")
except Exception as e:
    print(f"读取文件失败: {e}")
    return

# 删除前两列（只保留第三列及之后的数据）
if df.shape[1] >= 2:
    df = df.iloc[:, 2:]
print(f"删除前两列后，数据形状: {df.shape}")

# 确保保存目录存在
os.makedirs(save_dir, exist_ok=True)

# 计算需要分割的组数（每组401行，包含400个新数据点+1个重叠点）
total_rows = len(df)
group_size = chunk_size + 1  # 每组401行
num_groups = (total_rows - 1) // chunk_size  # 计算完整组数

print(f"将分割为 {num_groups} 组数据，每组 {group_size} 行")

# 创建并保存每组数据
for i in range(num_groups):
    start_idx = i * chunk_size
    end_idx = start_idx + group_size

    # 确保不超出数据范围
    if end_idx > total_rows:
        break

    # 提取当前组的数据
    group_data = df.iloc[start_idx:end_idx].copy()

    # 重置索引为1-401
    group_data.index = range(1, len(group_data) + 1)

    # 设置文件名和保存路径
    filename = f"{i+1}.xlsx"
    save_path = os.path.join(save_dir, filename)

    # 保存为Excel文件
    group_data.to_excel(save_path, index=True, header=False)

    # 应用格式设置：Times New Roman字体、居中、不加粗、无边框
    apply_excel_formatting(save_path)

    print(f"已保存第 {i+1} 组数据: {save_path} (行 {start_idx+1}-{end_idx})")

print("数据分割完成!")

def apply_excel_formatting(file_path):
"""
应用Excel格式设置：Times New Roman字体、居中对齐、不加粗、无边框
"""
# 加载工作簿
wb = load_workbook(file_path)
ws = wb.active

text
# 创建样式
font_style = Font(name='Times New Roman', bold=False)  # Times New Roman字体，不加粗
alignment_style = Alignment(horizontal='center', vertical='center')  # 居中对齐
no_border = Border(left=None, right=None, top=None, bottom=None)  # 无边框

# 应用样式到所有单元格
for row in ws.iter_rows():
    for cell in row:
        cell.font = font_style
        cell.alignment = alignment_style
        cell.border = no_border

# 调整列宽以适应内容
for column in ws.columns:
    max_length = 0
    column_letter = column[0].column_letter
    for cell in column:
        try:
            if len(str(cell.value)) > max_length:
                max_length = len(str(cell.value))
        except:
            pass
    adjusted_width = min(max_length + 2, 50)  # 限制最大列宽
    ws.column_dimensions[column_letter].width = adjusted_width

# 保存修改
wb.save(file_path)

主程序

if name == "main":
# 设置文件路径和保存目录
file_path = r"C:\Users\lenovo\Desktop\数据\数据\90%RH\90-10.xls"
save_dir = r"C:\Users\lenovo\Desktop\数据\数据\90%RH\90-10"

text
# 处理数据分割
process_and_split_data(file_path, save_dir, chunk_size=400)

我的y轴是固定的就是我给你的画图代码中给你的那个，我的意思就是说之前我的输入预测是画出的照片形式，但是现在我要改成数据输入，然后把数据再转化为我之前的照片形式，请你理解我之前的所有对话，告诉我我应该如何实现呢？给我具体的步骤，你要认认真真进行思考！！！

给我所有部分的完整代码！！！