10.20-10.25微调问答内容(二)

16、基于 Swin-Transformer 微调方案

代码说明：

①、数据集包含image（JPEG 二进制）和label（0/1）列；

②、若有真实篡改区域掩码标注，可在CustomTrainer的compute_loss中替换fake_mask为真实掩码，提升 Dice Loss 的有效性；

③、训练完成后，模型可用于提取图像特征，重点捕捉篡改痕迹和质量异常，为后续多模态融合提供支持。

import osimport torchimport pandas as pdimport pyarrow.parquet as pqimport numpy as npfrom PIL import Imagefrom io import BytesIOfrom torch.utils.data import Dataset, DataLoaderfrom torch import nnimport torch.nn.functional as Ffrom transformers import (AutoModelForImageClassification,AutoImageProcessor,TrainingArguments,Trainer,EarlyStoppingCallback)from sklearn.model_selection import train_test_splitfrom sklearn.metrics import f1_score, accuracy_scoreclass SwinFinetuner:def __init__(self,data_path="./swin_transformer-data.parquet",output_dir="./swin_finetuned",log_dir="./logs/swin",batch_size=4,  # 图像数据量大，小批次learning_rate=1e-5,  # 5e-6 ~ 2e-5num_epochs=5,img_size=(224, 224),  # Swin默认输入尺寸freeze_layers=4,  # 冻结前4层，解冻中层model_name="microsoft/swin-tiny-patch4-window7-224"):"""初始化Swin-Transformer微调器，聚焦图像篡改特征捕捉"""# 设备配置self.device = "cuda" if torch.cuda.is_available() else "cpu"print(f"使用设备: {self.device}")# 路径参数self.data_path = data_pathself.output_dir = output_dirself.log_dir = log_diros.makedirs(self.output_dir, exist_ok=True)os.makedirs(self.log_dir, exist_ok=True)# 训练参数self.batch_size = batch_sizeself.learning_rate = learning_rateself.num_epochs = num_epochsself.img_size = img_sizeself.freeze_layers = freeze_layers  # 冻结前4层self.model_name = model_name# 初始化组件self.image_processor = Noneself.model = Noneself.train_dataset = Noneself.val_dataset = Noneself.train_images = Noneself.val_images = Noneself.train_labels = Noneself.val_labels = None# 内部数据集类（处理图像二进制数据）class TamperedImageDataset(Dataset):def __init__(self, images, labels, processor, img_size):self.images = images  # 二进制图像数据列表self.labels = labels  # 0=真，1=假（含篡改/图文不符）self.processor = processor  # 图像处理器self.img_size = img_sizedef __len__(self):return len(self.images)def __getitem__(self, idx):# 从二进制数据加载图像img_bytes = self.images[idx]image = Image.open(BytesIO(img_bytes)).convert("RGB")  # 转为RGB格式label = self.labels[idx]# 图像预处理（缩放、归一化等）encoding = self.processor(image,resize_size=self.img_size,return_tensors="pt")return {"pixel_values": encoding["pixel_values"].squeeze(0),  # 移除batch维度"labels": torch.tensor(label, dtype=torch.long)}def load_data(self):"""加载Parquet数据集（含二进制图像和标签）"""# 读取Parquet文件table = pq.read_table(self.data_path)df = table.to_pandas()# 验证必要列required_cols = ['image', 'label']if not set(required_cols).issubset(df.columns):raise ValueError(f"Parquet文件缺少必要列，需包含：{required_cols}")# 提取图像二进制数据和标签（label: 0=真，1=假）images = df['image'].tolist()  # 二进制图像数据列表labels = df['label'].astype(int).tolist()# 划分训练集和验证集（8:2）self.train_images, self.val_images, self.train_labels, self.val_labels = train_test_split(images, labels, test_size=0.2, random_state=42, stratify=labels)print(f"训练集样本数：{len(self.train_images)}，验证集样本数：{len(self.val_images)}")return selfdef load_model(self):"""加载Swin模型并配置冻结策略（解冻中层特征层）"""# 加载图像处理器和预训练模型self.image_processor = AutoImageProcessor.from_pretrained(self.model_name)self.model = AutoModelForImageClassification.from_pretrained(self.model_name,num_labels=2,  # 二分类：0=真，1=假（含篡改）ignore_mismatched_sizes=True)# 冻结底层特征提取层（前freeze_layers层），解冻中层特征层# Swin的层结构：model.swin.layers[0...n-1]for param in self.model.swin.parameters():param.requires_grad = False  # 先冻结所有层# 解冻中层2-3层（例如：总层数为4时，解冻中间2层）total_layers = len(self.model.swin.layers)middle_layers = range(self.freeze_layers, min(self.freeze_layers + 3, total_layers))for layer_idx in middle_layers:for param in self.model.swin.layers[layer_idx].parameters():param.requires_grad = True# 移动模型到设备self.model = self.model.to(self.device)print(f"模型加载完成，冻结前{self.freeze_layers}层，解冻中层{len(middle_layers)}层（索引：{list(middle_layers)}）")return selfdef create_datasets(self):"""创建训练集和验证集的Dataset对象"""if not all([self.train_images, self.val_images, self.train_labels, self.val_labels]):raise ValueError("请先调用load_data()加载数据")if not self.image_processor:raise ValueError("请先调用load_model()加载图像处理器")self.train_dataset = self.TamperedImageDataset(self.train_images, self.train_labels, self.image_processor, self.img_size)self.val_dataset = self.TamperedImageDataset(self.val_images, self.val_labels, self.image_processor, self.img_size)return selfdef compute_metrics(self, pred):"""计算评估指标（聚焦篡改检测F1和准确率）"""labels = pred.label_idspreds = pred.predictions.argmax(-1)return {"accuracy": accuracy_score(labels, preds),"f1": f1_score(labels, preds)  # 方案中强调的篡改检测F1指标}def train(self):"""训练模型（含多任务损失适配）"""if not all([self.model, self.image_processor, self.train_dataset, self.val_dataset]):raise ValueError("请先完成数据加载、模型加载和数据集创建")# 训练参数配置（图像模型学习率更低）training_args = TrainingArguments(output_dir=self.output_dir,per_device_train_batch_size=self.batch_size,per_device_eval_batch_size=self.batch_size * 2,learning_rate=self.learning_rate,num_train_epochs=self.num_epochs,logging_dir=self.log_dir,logging_steps=50,  # 图像训练步数少，日志间隔小evaluation_strategy="epoch",save_strategy="epoch",load_best_model_at_end=True,metric_for_best_model="f1",  # 以F1作为核心指标（篡改检测）weight_decay=0.001,  # 图像模型轻量化正则fp16=torch.cuda.is_available(),  # 启用混合精度训练remove_unused_columns=False)# 自定义Trainer，支持多任务损失（方案要求）class CustomTrainer(Trainer):def compute_loss(self, model, inputs, return_outputs=False):labels = inputs.get("labels")outputs = model(**inputs)logits = outputs.get("logits")# 1. 分类损失（交叉熵，用于真假判断）cls_loss = F.cross_entropy(logits, labels)# 2. 模拟篡改区域检测损失（Dice Loss，方案要求）# 注：若有篡改区域掩码标注，可替换为真实掩码计算# 此处用随机掩码模拟（实际使用时需传入真实掩码）batch_size = logits.shape[0]fake_mask = torch.rand(batch_size, 1, *self.img_size).to(self.device)  # 模拟篡改区域pred_mask = torch.sigmoid(model.swin(inputs["pixel_values"]).last_hidden_state[:, :1, ...])  # 提取中层特征作为掩码预测dice_loss = self.dice_loss(pred_mask, fake_mask)# 总损失：分类损失 + 0.3*Dice损失（权重可调整）total_loss = cls_loss + 0.3 * dice_lossreturn (total_loss, outputs) if return_outputs else total_loss@staticmethoddef dice_loss(pred, target, smooth=1e-5):"""Dice Loss用于篡改区域检测（精准定位篡改痕迹）"""intersection = (pred * target).sum()return 1 - (2. * intersection + smooth) / (pred.sum() + target.sum() + smooth)# 初始化自定义Trainertrainer = CustomTrainer(model=self.model,args=training_args,train_dataset=self.train_dataset,eval_dataset=self.val_dataset,compute_metrics=self.compute_metrics,callbacks=[EarlyStoppingCallback(early_stopping_patience=2)]  # 早停策略)# 开始微调print("开始微调Swin-Transformer模型...")trainer.train()# 保存最终模型final_model_path = os.path.join(self.output_dir, "final_model")self.model.save_pretrained(final_model_path)self.image_processor.save_pretrained(final_model_path)print(f"模型已保存至：{final_model_path}")return self# 使用示例if __name__ == "__main__":# 初始化微调器（图像模型批次更小）finetuner = SwinFinetuner(data_path="./swin_transformer-data.parquet",batch_size=4,learning_rate=1e-5,num_epochs=5,freeze_layers=4  # 冻结前4层，解冻中层)# 执行微调流程finetuner.load_data() \.load_model() \.create_datasets() \.train()

17、模型微调的数据量

维度	文本大模型（如 deepseek-R1）	图像模型（如 Swin-Transformer）
最小有效量	5,000 ~ 10,000 条	1,000 ~ 3,000 张
推荐量	10,000 ~ 50,000 条	3,000 ~ 10,000 张
核心需求	覆盖语义特征多样性（来源、逻辑等）	覆盖视觉特征多样性（篡改类型、场景）
质量关键点	标签的语义精准性	篡改区域标注的空间精准性

18、标签的映射

新增 map_label 函数，手动将 “真” 映射为 1、“假” 映射为 0（根据你的实际标签定义调整，若标签是 “Likely”“Unlikely” 也可对应修改）；

用 df['label'].apply(map_label) 批量转换所有标签，确保输出为整数列表。

def load_data(self):"""加载Parquet数据集（含二进制图像和标签）"""# 读取Parquet文件table = pq.read_table(self.data_path)df = table.to_pandas()# 验证必要列required_cols = ['image', 'label']if not set(required_cols).issubset(df.columns):raise ValueError(f"Parquet文件缺少必要列，需包含：{required_cols}")# 提取图像二进制数据images = df['image'].tolist()  # 二进制图像数据列表# --------------------------# 关键修改：处理标签转换# --------------------------# 定义标签映射：将"真"/"假"转换为1/0（根据实际标签值调整）def map_label(label):if label == "真":return 1elif label == "假":return 0else:# 若有其他标签值，可在此处补充处理（如抛出异常或默认值）raise ValueError(f"未知标签值：{label}，仅支持'真'或'假'")# 应用映射函数转换标签labels = df['label'].apply(map_label).tolist()# 划分训练集和验证集（8:2）self.train_images, self.val_images, self.train_labels, self.val_labels = train_test_split(images, labels, test_size=0.2, random_state=42, stratify=labels)print(f"训练集样本数：{len(self.train_images)}，验证集样本数：{len(self.val_images)}")return self

19、核心报错：AttributeError: 'SwinModel' object has no attribute 'layers'

SwinForImageClassification（或基础的 SwinModel），其内部结构中，swin 模块的层级属性并非 layers。查看 Hugging Face 的 Swin 模型源码可知，swin 模块下的层级结构属性名为 blocks（而非 layers），即正确的访问路径应为 self.model.swin.blocks。

代码中错误地写成了 self.model.swin.layers，导致找不到该属性，触发 AttributeError。

核心改点：

①、将 total_layers = len(self.model.swin.layers)改为 total_layers = len(self.model.swin.encoder.layers)

②、将 for param in self.model.swin.layers[layer_idx].parameters()改为 for param in self.model.swin.encoder.layers[layer_idx].parameters()

20、evaluation_strategy 参数与eval_strategy 参数问题

evaluation_strategy 参数被重命名为 eval_strategy 是 Transformers 库 4.4.0 版本（2021 年 3 月发布）的变更。从 Transformers 4.20.0 版本（2022 年 5 月发布）开始，旧参数 evaluation_strategy 被彻底移除，若继续使用会直接报错，必须改用 eval_strategy 才能兼容。

4.4.0 及以上版本：推荐使用 eval_strategy（旧参数仍可运行但会警告）。

4.20.0 及以上版本：强制使用 eval_strategy（旧参数完全失效）

21、accelerate 库

"C:\Users\HP\AppData\Roaming\Python\Python39\site-packages\transformers\training_args.py", line 2167, in _setup_devices raise ImportError( ImportError: Using the `Trainer` with `PyTorch` requires `accelerate>=0.26.0`: Please run `pip install transformers[torch]` or `pip install 'accelerate>=0.26.0'`

这是库版本和依赖缺失的问题，具体来说是 accelerate 库未安装或版本过低导致的。

transformers 库的 Trainer 类（用于模型训练）依赖 accelerate 库来处理分布式训练、混合精度等功能。你的环境中要么没有安装 accelerate，要么安装的版本低于要求的 0.26.0，导致无法正常初始化 TrainingArguments。

这是典型的依赖版本问题，而非库不存在，但本质是缺少符合版本要求的依赖库。

解决方法：

①、更新或安装库

②、用原生 PyTorch 训练循环替代 Trainer

def train(self):"""使用原生PyTorch训练循环，不依赖accelerate库"""if not all([self.model, self.image_processor, self.train_dataset, self.val_dataset]):raise ValueError("请先完成数据加载、模型加载和数据集创建")# 创建数据加载器train_loader = DataLoader(self.train_dataset,batch_size=self.batch_size,shuffle=True,num_workers=2  # 根据CPU核心数调整)val_loader = DataLoader(self.val_dataset,batch_size=self.batch_size * 2,shuffle=False,num_workers=2)# 优化器和学习率调度器optimizer = torch.optim.AdamW(self.model.parameters(),lr=self.learning_rate,weight_decay=0.001)scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9)# 早停策略参数best_f1 = 0.0early_stopping_counter = 0patience = 2# 开始训练for epoch in range(self.num_epochs):self.model.train()total_train_loss = 0.0# 训练循环for batch in train_loader:# 数据移至设备pixel_values = batch["pixel_values"].to(self.device)labels = batch["labels"].to(self.device)# 前向传播outputs = self.model(pixel_values=pixel_values, labels=labels)logits = outputs.logits# 1. 分类损失（交叉熵）cls_loss = F.cross_entropy(logits, labels)# 2. 篡改区域检测损失（Dice Loss）batch_size = logits.shape[0]fake_mask = torch.rand(batch_size, 1, *self.img_size).to(self.device)pred_mask = torch.sigmoid(self.model.swin(pixel_values).last_hidden_state[:, :1, ...])dice_loss = self.dice_loss(pred_mask, fake_mask)# 总损失total_loss = cls_loss + 0.3 * dice_loss# 反向传播optimizer.zero_grad()total_loss.backward()optimizer.step()total_train_loss += total_loss.item()# 计算平均训练损失avg_train_loss = total_train_loss / len(train_loader)print(f"Epoch {epoch+1}/{self.num_epochs} - 训练损失: {avg_train_loss:.4f}")# 验证循环self.model.eval()all_preds = []all_labels = []total_val_loss = 0.0with torch.no_grad():for batch in val_loader:pixel_values = batch["pixel_values"].to(self.device)labels = batch["labels"].to(self.device)outputs = self.model(pixel_values=pixel_values, labels=labels)logits = outputs.logits# 计算验证损失cls_loss = F.cross_entropy(logits, labels)fake_mask = torch.rand(labels.shape[0], 1, *self.img_size).to(self.device)pred_mask = torch.sigmoid(self.model.swin(pixel_values).last_hidden_state[:, :1, ...])dice_loss = self.dice_loss(pred_mask, fake_mask)total_loss = cls_loss + 0.3 * dice_losstotal_val_loss += total_loss.item()# 收集预测结果preds = logits.argmax(dim=1).cpu().numpy()all_preds.extend(preds)all_labels.extend(labels.cpu().numpy())# 计算验证指标avg_val_loss = total_val_loss / len(val_loader)val_accuracy = accuracy_score(all_labels, all_preds)val_f1 = f1_score(all_labels, all_preds)print(f"Epoch {epoch+1}/{self.num_epochs} - 验证损失: {avg_val_loss:.4f}, 准确率: {val_accuracy:.4f}, F1: {val_f1:.4f}")# 早停策略if val_f1 > best_f1:best_f1 = val_f1early_stopping_counter = 0# 保存最优模型final_model_path = os.path.join(self.output_dir, "final_model")self.model.save_pretrained(final_model_path)self.image_processor.save_pretrained(final_model_path)print(f"最优模型已保存至：{final_model_path}")else:early_stopping_counter += 1if early_stopping_counter >= patience:print(f"早停触发（{patience}轮未提升）")breakscheduler.step()print("训练完成")return self
# 新增静态方法：Dice Loss@staticmethoddef dice_loss(pred, target, smooth=1e-5):intersection = (pred * target).sum()return 1 - (2. * intersection + smooth) / (pred.sum() + target.sum() + smooth)  

22、PROTOCOL_TLS常量

PROTOCOL_TLS 是 urllib3 中用于指定 TLS 协议的常量，多个库（如 botocore、requests 等）都会依赖它。当 urllib3 版本过低或文件损坏时，会导致该常量缺失，进而引发依赖它的库（包括 transformers 及其依赖的 accelerate）无法正常导入。

23、数据集加载时的数据格式错误

"C:\Users\HP\AppData\Roaming\Python\Python39\site-packages\torch\utils\data\_utils\fetch.py", line 52, in <listcomp> data = [self.dataset[idx] for idx in possibly_batched_index] File "C:\Ranall\model\run1020\partTrain\swinTrain.py", line 77, in __getitem__ image = Image.open(BytesIO(img_bytes)).convert("RGB") # 转为RGB格式 TypeError: a bytes-like object is required, not 'dict' 0%| | 0/3000 [00:00<?, ?it/s]

变量 img_bytes 实际是一个字典（dict），但代码期望它是字节流（bytes-like），导致 BytesIO 无法处理，进而触发类型错误。修正 __getitem__ 方法中获取图像字节的逻辑，确保 img_bytes 是真正的字节流，而非字典。

24、从字典中提取'bytes'键对应的二进制数据

提取二进制数据：通过extract_image_bytes函数，从每个image字典中精准获取'bytes'键对应的二进制数据（你的数据中'bytes'键的值正是 JPEG 图像的二进制内容）。
异常排查：添加格式校验，若遇到不包含'bytes'键的字典，会抛出明确错误，方便定位异常数据。
标签处理：保留之前的字符串标签转整数逻辑，确保标签格式符合模型要求。

核心代码：

# 核心函数：从 image 字典中提取 'bytes' 键对应的二进制数据
def extract_image_bytes(img_dict):# 1. 校验格式（确保是字典且包含 'bytes' 键）if isinstance(img_dict, dict) and 'bytes' in img_dict:# 2. 核心提取：返回 'bytes' 键对应的二进制数据（解决 Type 错误的关键）return img_dict['bytes']else:raise ValueError(f"image 字典缺少 'bytes' 键，实际数据：{img_dict}")# 批量应用：处理整个数据集的 image 列
images = df['image'].apply(extract_image_bytes).tolist()

25、img_size问题

"C:\Users\HP\AppData\Roaming\Python\Python39\site-packages\transformers\trainer.py", line 3736, in training_step loss = self.compute_loss(model, inputs, num_items_in_batch=num_items_in_batch) File "C:\Ranall\model\run1020\partTrain\swinTrain.py", line 231, in compute_loss fake_mask = torch.rand(batch_size, 1, *self.img_size).to(self.device) TypeError: Value after * must be an iterable, not NoneType 0%| | 0/3000 [00:01<?, ?it/s] 进程已结束,退出代码1

*self.img_size 用于将图像尺寸（如 (224, 224)）拆分为两个参数，供 torch.rand 生成对应形状的掩码。如果 self.img_size 为 None，则 *self.img_size 会报错。

通过上述修改，确保 img_size 从 SwinFinetuner 正确传递到 CustomTrainer 并被赋值，即可解决该错误。

CustomTrainer 接收 img_size：

1. 在 CustomTrainer 的 __init__ 方法中，将 img_size 设为必填参数（移除默认值 None），确保其被正确传入。
2. 初始化 CustomTrainer 时，显式传递 img_size=self.img_size，使内部能访问图像尺寸。

避免解冻 0 层：

1. 将 freeze_layers 从 4 改为 2（在 __main__ 中），因为 Swin-Tiny 模型通常只有 4 层，冻结 4 层会导致无层可解冻（中层 0 层），改为 2 可解冻中层 2-3 层。

其他细节：

1. 图像预处理使用 size=self.img_size 而非 resize_size，消除警告。
2. 确保 device 在生成掩码时正确使用（to(self.device)）。

26、 CustomTrainer 类中没有 device 属性

这个错误是因为 CustomTrainer 类中没有 device 属性，导致在执行 fake_mask = torch.rand(...).to(self.device) 时无法找到 device，引发 AttributeError: 'CustomTrainer' object has no attribute 'device'。

解决方案：将 device 传递给 CustomTrainer：

需要像传递 img_size 一样，将外层 SwinFinetuner 类的 self.device 传递给 CustomTrainer，并在 CustomTrainer 中保存为实例属性。​​​​​​​

修改 CustomTrainer 的 __init__ 方法，新增 device 参数：

class CustomTrainer(Trainer):# 新增device参数，接收设备信息def __init__(self, *args, img_size, device, **kwargs):super().__init__(*args, **kwargs)self.img_size = img_size  # 保存图像尺寸self.device = device  # 保存设备信息（关键新增）

初始化 CustomTrainer 时，传递 self.device：

trainer = CustomTrainer(model=self.model,args=training_args,train_dataset=self.train_dataset,eval_dataset=self.val_dataset,compute_metrics=self.compute_metrics,callbacks=[EarlyStoppingCallback(early_stopping_patience=2)],img_size=self.img_size,  # 已有的图像尺寸参数device=self.device  # 新增：传递设备信息)

27、

"C:\Ranall\model\run1020\partTrain\swinTrain.py", line 209, in dice_loss intersection = (pred * target).sum() RuntimeError: The size of tensor a (1024) must match the size of tensor b (224) at non-singleton dimension 3 0%| | 0/3000 [00:01<?, ?it/s] 进程已结束,退出代码1 问题描述

这个错误的核心原因是 pred_mask（模型预测的掩码）和 fake_mask（模拟的篡改区域掩码）的尺寸不匹配，具体表现为在第 3 个维度上，pred_mask 的尺寸是 1024，而 fake_mask 的尺寸是 224，导致两者无法进行元素级运算（如 pred * target），从而引发 RuntimeError。

详细分析：

fake_mask 的尺寸：代码中通过 torch.rand(batch_size, 1, *self.img_size) 生成，其中 self.img_size=(224, 224)，因此 fake_mask 的形状为 (batch_size, 1, 224, 224)（对应 [批次大小，通道数，高度，宽度]）。

pred_mask 的尺寸：代码中通过 model.swin(inputs["pixel_values"]).last_hidden_state[:, :1, ...] 提取，而 Swin-Transformer 的输出特征图尺寸与输入图像尺寸不同（经过多次下采样）。对于输入尺寸为 224x224 的图像，Swin-Tiny 模型的 last_hidden_state 特征图尺寸通常为 14x14 或 7x7（而非 224x224），导致 pred_mask 的形状为 (batch_size, 1, 14, 14) 或类似，与 fake_mask 的 224x224 不匹配。

错误日志中提到的 “1024” 可能是特征图展平后的尺寸，本质是特征图空间尺寸与 fake_mask 不匹配。

解决方案：

需要将 pred_mask 上采样到与 fake_mask 相同的尺寸（224x224），确保两者可进行元素级运算。

def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):labels = inputs.get("labels")outputs = model(**inputs)logits = outputs.get("logits")# 1. 分类损失（交叉熵）cls_loss = F.cross_entropy(logits, labels)# 2. 篡改区域检测损失（Dice Loss）batch_size = logits.shape[0]# 生成模拟掩码（尺寸：[batch, 1, 224, 224]）fake_mask = torch.rand(batch_size, 1, *self.img_size).to(self.device)# 提取模型特征并上采样到与fake_mask相同的尺寸swin_output = model.swin(inputs["pixel_values"])pred_mask_raw = swin_output.last_hidden_state[:, :1, ...]  # 原始特征图（如[batch, 1, 14, 14]）# 上采样：使用双线性插值将pred_mask调整为224x224pred_mask = torch.nn.functional.interpolate(pred_mask_raw,size=self.img_size,  # 目标尺寸：(224, 224)mode='bilinear',    # 双线性插值（适合图像）align_corners=False)pred_mask = torch.sigmoid(pred_mask)  # 激活函数保持在0-1之间# 计算Dice损失（此时尺寸匹配）dice_loss = self.dice_loss(pred_mask, fake_mask)# 总损失total_loss = cls_loss + 0.3 * dice_lossreturn (total_loss, outputs) if return_outputs else total_loss