import torch import torch.nn as nn import torch.nn.functional as F import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns from sklearn.metrics import accuracy_score, classification_report, confusion_matrix from sklearn.model_selection import train_test_split from transformers import ( BertTokenizer, BertForSequenceClassification, BertModel, BertConfig, TrainingArguments, Trainer, DataCollatorWithPadding, TrainerCallback, EarlyStoppingCallback ) from torch.utils.data import Dataset, DataLoader, WeightedRandomSampler import logging import os from datetime import datetime import math import json from collections import defaultdict, Counter import copy # 禁用wandb和其他第三方报告工具 os.environ["WANDB_DISABLED"] = "true" os.environ["COMET_MODE"] = "disabled" os.environ["NEPTUNE_MODE"] = "disabled" # 设置日志 logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # 设置matplotlib中文字体 plt.rcParams['font.sans-serif'] = ['DejaVu Sans'] plt.rcParams['axes.unicode_minus'] = False def check_gpu_availability(): """检查GPU可用性 - V100 48GB优化版""" if not torch.cuda.is_available(): raise RuntimeError("❌ GPU不可用！此脚本需要GPU支持。") gpu_count = torch.cuda.device_count() gpu_name = torch.cuda.get_device_name(0) gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024 ** 3 logger.info(f"✅ GPU检查通过!") logger.info(f" 🔹 可用GPU数量: {gpu_count}") logger.info(f" 🔹 GPU型号: {gpu_name}") logger.info(f" 🔹 GPU内存: {gpu_memory:.1f} GB") # V100优化设置 + 对抗训练优化 torch.cuda.empty_cache() torch.backends.cudnn.benchmark = True torch.backends.cudnn.deterministic = False # 对抗训练时允许非确定性以提升性能 # 对抗训练内存优化 if gpu_memory >= 40: # V100 48GB logger.info("🚀 检测到V100大显存GPU，启用对抗训练优化配置") return True, gpu_memory, "v100_48gb" else: logger.info("⚠️ 检测到较小显存GPU，将使用保守的对抗训练配置") return True, gpu_memory, "standard" class AdversarialConfig: """对抗训练配置类 - 温和的扰动强度设置""" def __init__(self, imbalance_ratio=6.0, gpu_type="v100_48gb"): self.imbalance_ratio = imbalance_ratio self.gpu_type = gpu_type # 使用更温和的扰动强度 self.majority_class_eps = 0.05 # 降低多数类扰动 self.minority_class_eps = 0.1 # 降低少数类扰动，仍保持2倍差异 self.eps_ratio = 2.0 # 使用原始的Focal Loss参数，不做修改 self.focal_alpha = [0.1, 0.9] # 保持原始权重 self.focal_gamma = 3.0 # 保持原始gamma值 # 更温和的FreeLB参数 self.adv_steps = 3 # 减少对抗步数 self.adv_lr = 0.01 # 降低对抗学习率 self.norm_type = "l2" self.max_norm = 0.5 # 降低最大范数约束 # 温和的训练阶段参数 self.phase_configs = { 'adaptation': { # 适应期 (1-10 epochs) - 延长适应期 'eps': {'majority': 0.03, 'minority': 0.06}, # 非常温和的开始 'clean_ratio': 0.9, # 更多干净样本 'learning_rate': 2e-5, # 使用原始学习率 'adv_steps': 2 # 最少的对抗步数 }, 'enhancement': { # 强化期 (11-25 epochs) 'eps': {'majority': 0.05, 'minority': 0.1}, # 温和提升 'clean_ratio': 0.7, # 仍然更多干净样本 'learning_rate': 1.5e-5, # 温和降低 'adv_steps': 3 }, 'refinement': { # 精调期 (26+ epochs) 'eps': {'majority': 0.04, 'minority': 0.08}, # 回调扰动 'clean_ratio': 0.8, # 精调时更多干净样本 'learning_rate': 1e-5, # 精调阶段 'adv_steps': 2 } } # 更温和的类别差异化采样 self.sampling_configs = { 'adaptation': {'majority': 0.8, 'minority': 0.2}, # 接近原始分布 'enhancement': {'majority': 0.7, 'minority': 0.3}, # 温和调整 'refinement': {'majority': 0.6, 'minority': 0.4} # 最终稍微平衡 } logger.info(f"🎯 温和对抗训练配置初始化完成:") logger.info(f" 🔹 数据不平衡比例: {imbalance_ratio}:1") logger.info(f" 🔹 Focal Loss权重: {self.focal_alpha} (原始设置)") logger.info(f" 🔹 Focal Loss gamma: {self.focal_gamma} (原始设置)") logger.info(f" 🔹 温和扰动: 多数类{self.majority_class_eps} vs 少数类{self.minority_class_eps}") logger.info(f" 🔹 对抗步数: {self.adv_steps} (温和设置)") logger.info(f" 🔹 对抗学习率: {self.adv_lr} (温和设置)") logger.info(f" 🔹 GPU配置: {gpu_type}") class AdversarialPerturbationGenerator: """FreeLB对抗扰动生成器""" def __init__(self, config: AdversarialConfig): self.config = config def generate_perturbation(self, model, inputs, labels, current_phase='enhancement'): """生成对抗扰动""" device = next(model.parameters()).device # 获取当前阶段配置 phase_config = self.config.phase_configs[current_phase] # 获取输入嵌入 input_ids = inputs['input_ids'].to(device) attention_mask = inputs['attention_mask'].to(device) # 获取嵌入层 embedding_layer = model.roberta.embeddings.word_embeddings embeds = embedding_layer(input_ids) # 根据标签确定扰动强度 batch_eps = [] for label in labels: if label.item() == 0: # 多数类 batch_eps.append(phase_config['eps']['majority']) else: # 少数类 batch_eps.append(phase_config['eps']['minority']) batch_eps = torch.tensor(batch_eps, device=device).unsqueeze(-1).unsqueeze(-1) # 初始化扰动 delta = torch.zeros_like(embeds).uniform_(-1, 1) delta = delta * batch_eps * 0.1 # 初始化为小扰动 delta.requires_grad_(True) # 多步对抗扰动生成 for step in range(phase_config['adv_steps']): # 前向传播 perturbed_embeds = embeds + delta # 替换嵌入层输出 outputs = model( inputs_embeds=perturbed_embeds, attention_mask=attention_mask, labels=labels ) loss = outputs['loss'] # 计算梯度 grad = torch.autograd.grad( loss, delta, retain_graph=True if step < phase_config['adv_steps'] - 1 else False )[0] # 归一化梯度 if self.config.norm_type == "l2": grad_norm = torch.norm(grad, dim=-1, keepdim=True) grad = grad / (grad_norm + 1e-8) else: # linf grad = grad.sign() # 更新扰动 delta = delta + self.config.adv_lr * grad # 投影到约束球 if self.config.norm_type == "l2": delta_norm = torch.norm(delta, dim=-1, keepdim=True) delta = delta / torch.max(delta_norm / batch_eps, torch.ones_like(delta_norm)) else: delta = torch.clamp(delta, -batch_eps, batch_eps) delta = delta.detach() delta.requires_grad_(True) return embeds + delta.detach() class LossTracker(TrainerCallback): """增强的损失跟踪回调类 - 对抗训练版""" def __init__(self): self.train_losses = [] self.eval_losses = [] self.eval_accuracies = [] self.eval_minority_f1 = [] self.train_steps = [] self.eval_steps = [] self.epochs = [] self.current_epoch = 0 self.best_eval_accuracy = 0.0 self.best_minority_f1 = 0.0 self.best_epoch = 0 # 对抗训练特有指标 self.adversarial_losses = [] self.clean_losses = [] self.perturbation_norms = [] def on_log(self, args, state, control, logs=None, **kwargs): if logs: if 'loss' in logs: self.train_losses.append(logs['loss']) self.train_steps.append(state.global_step) if 'eval_loss' in logs: self.eval_losses.append(logs['eval_loss']) self.eval_steps.append(state.global_step) if 'eval_accuracy' in logs: self.eval_accuracies.append(logs['eval_accuracy']) if 'eval_minority_f1' in logs: self.eval_minority_f1.append(logs['eval_minority_f1']) # 更新最佳少数类F1 if logs['eval_minority_f1'] > self.best_minority_f1: self.best_minority_f1 = logs['eval_minority_f1'] self.best_epoch = self.current_epoch if 'eval_accuracy' in logs: if logs['eval_accuracy'] > self.best_eval_accuracy: self.best_eval_accuracy = logs['eval_accuracy'] def on_epoch_end(self, args, state, control, **kwargs): self.current_epoch = state.epoch self.epochs.append(state.epoch) class AdversarialValidationCallback(TrainerCallback): """对抗训练验证回调 - 每5个epoch生成详细分析""" def __init__(self, eval_dataset, tokenizer, output_dir, adv_config, epochs_interval=5): self.eval_dataset = eval_dataset self.tokenizer = tokenizer self.output_dir = output_dir self.adv_config = adv_config self.epochs_interval = epochs_interval self.confusion_matrices = {} self.detailed_metrics = {} def on_epoch_end(self, args, state, control, model=None, **kwargs): current_epoch = int(state.epoch) if current_epoch % self.epochs_interval == 0 or current_epoch == args.num_train_epochs: logger.info(f"📊 生成第{current_epoch}轮对抗训练验证分析...") model.eval() predictions = [] true_labels = [] prediction_probs = [] device = next(model.parameters()).device with torch.no_grad(): for i in range(len(self.eval_dataset)): item = self.eval_dataset[i] input_ids = item['input_ids'].unsqueeze(0).to(device) attention_mask = item['attention_mask'].unsqueeze(0).to(device) outputs = model(input_ids=input_ids, attention_mask=attention_mask) logits = outputs['logits'] probs = F.softmax(logits, dim=-1) pred = torch.argmax(logits, dim=-1).cpu().item() predictions.append(pred) true_labels.append(item['labels'].item()) prediction_probs.append(probs.cpu().numpy()) # 计算详细指标 cm = confusion_matrix(true_labels, predictions) self.confusion_matrices[current_epoch] = cm # 计算类别特定指标 if cm.shape == (2, 2): tn, fp, fn, tp = cm.ravel() else: # 处理可能的单类别或异常情况 logger.warning(f"Epoch {current_epoch}: 混淆矩阵形状异常: {cm.shape}") if len(np.unique(true_labels)) == 1: # 只有一个类别的情况 if true_labels[0] == 0: tn, fp, fn, tp = len(true_labels), 0, 0, 0 else: tn, fp, fn, tp = 0, 0, 0, len(true_labels) else: # 其他异常情况 tn, fp, fn, tp = 0, 0, 0, 0 # 少数类(1)指标 minority_precision = tp / (tp + fp) if (tp + fp) > 0 else 0 minority_recall = tp / (tp + fn) if (tp + fn) > 0 else 0 minority_f1 = 2 * (minority_precision * minority_recall) / (minority_precision + minority_recall) if (minority_precision + minority_recall) > 0 else 0 # 多数类(0)指标 majority_precision = tn / (tn + fn) if (tn + fn) > 0 else 0 majority_recall = tn / (tn + fp) if (tn + fp) > 0 else 0 majority_f1 = 2 * (majority_precision * majority_recall) / (majority_precision + majority_recall) if (majority_precision + majority_recall) > 0 else 0 overall_accuracy = (tp + tn) / (tp + tn + fp + fn) balanced_accuracy = (minority_recall + majority_recall) / 2 metrics = { 'overall_accuracy': overall_accuracy, 'balanced_accuracy': balanced_accuracy, 'minority_precision': minority_precision, 'minority_recall': minority_recall, 'minority_f1': minority_f1, 'majority_precision': majority_precision, 'majority_recall': majority_recall, 'majority_f1': majority_f1 } self.detailed_metrics[current_epoch] = metrics logger.info(f" 📈 Epoch {current_epoch} 详细指标:") logger.info(f" 总体准确率: {overall_accuracy:.4f}") logger.info(f" 平衡准确率: {balanced_accuracy:.4f}") logger.info(f" 少数类F1: {minority_f1:.4f}") logger.info(f" 多数类F1: {majority_f1:.4f}") self.save_adversarial_analysis(cm, metrics, current_epoch) model.train() def save_adversarial_analysis(self, cm, metrics, epoch): """保存对抗训练分析图表""" fig, axes = plt.subplots(2, 2, figsize=(15, 12)) # 混淆矩阵 sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[0,0], xticklabels=['Same Paragraph (0)', 'Different Paragraph (1)'], yticklabels=['Same Paragraph (0)', 'Different Paragraph (1)']) axes[0,0].set_title(f'Adversarial Validation CM - Epoch {epoch}') axes[0,0].set_xlabel('Predicted Label') axes[0,0].set_ylabel('True Label') # 类别性能对比 categories = ['Majority Class', 'Minority Class'] precision_scores = [metrics['majority_precision'], metrics['minority_precision']] recall_scores = [metrics['majority_recall'], metrics['minority_recall']] f1_scores = [metrics['majority_f1'], metrics['minority_f1']] x = np.arange(len(categories)) width = 0.25 axes[0,1].bar(x - width, precision_scores, width, label='Precision', alpha=0.8) axes[0,1].bar(x, recall_scores, width, label='Recall', alpha=0.8) axes[0,1].bar(x + width, f1_scores, width, label='F1-Score', alpha=0.8) axes[0,1].set_xlabel('Class') axes[0,1].set_ylabel('Score') axes[0,1].set_title(f'Class Performance - Epoch {epoch}') axes[0,1].set_xticks(x) axes[0,1].set_xticklabels(categories) axes[0,1].legend() axes[0,1].set_ylim(0, 1) # 准确率趋势 if len(self.detailed_metrics) > 1: epochs_list = sorted(self.detailed_metrics.keys()) overall_acc = [self.detailed_metrics[e]['overall_accuracy'] for e in epochs_list] balanced_acc = [self.detailed_metrics[e]['balanced_accuracy'] for e in epochs_list] minority_f1_trend = [self.detailed_metrics[e]['minority_f1'] for e in epochs_list] axes[1,0].plot(epochs_list, overall_acc, 'b-o', label='Overall Accuracy', linewidth=2) axes[1,0].plot(epochs_list, balanced_acc, 'g-o', label='Balanced Accuracy', linewidth=2) axes[1,0].plot(epochs_list, minority_f1_trend, 'r-o', label='Minority F1', linewidth=2) axes[1,0].set_xlabel('Epoch') axes[1,0].set_ylabel('Score') axes[1,0].set_title('Adversarial Training Progress') axes[1,0].legend() axes[1,0].grid(True, alpha=0.3) # 类别不平衡可视化 if cm.shape == (2, 2): class_counts = [cm[0,0] + cm[0,1], cm[1,0] + cm[1,1]] # 真实类别数量 predicted_counts = [cm[0,0] + cm[1,0], cm[0,1] + cm[1,1]] # 预测类别数量 x_pos = [0, 1] axes[1,1].bar([x - 0.2 for x in x_pos], class_counts, 0.4, label='True Distribution', alpha=0.7) axes[1,1].bar([x + 0.2 for x in x_pos], predicted_counts, 0.4, label='Predicted Distribution', alpha=0.7) axes[1,1].set_xlabel('Class') axes[1,1].set_ylabel('Count') axes[1,1].set_title('Class Distribution Analysis') axes[1,1].set_xticks(x_pos) axes[1,1].set_xticklabels(['Majority (0)', 'Minority (1)']) axes[1,1].legend() else: # 处理异常混淆矩阵的情况 axes[1,1].text(0.5, 0.5, f'Confusion Matrix Shape: {cm.shape}', ha='center', va='center', transform=axes[1,1].transAxes) axes[1,1].set_title('Class Distribution Analysis') # 添加性能文本 textstr = f'''Epoch {epoch} Performance: Overall Acc: {metrics['overall_accuracy']:.4f} Balanced Acc: {metrics['balanced_accuracy']:.4f} Minority F1: {metrics['minority_f1']:.4f} Minority Recall: {metrics['minority_recall']:.4f}''' props = dict(boxstyle='round', facecolor='wheat', alpha=0.8) fig.text(0.02, 0.98, textstr, transform=fig.transFigure, fontsize=10, verticalalignment='top', bbox=props) plt.tight_layout() save_path = os.path.join(self.output_dir, f'adversarial_analysis_epoch_{epoch}.png') plt.savefig(save_path, dpi=300, bbox_inches='tight') plt.close() logger.info(f" 💾 对抗训练分析图表已保存: {save_path}") class SentencePairDataset(Dataset): """句子对数据集类 - 对抗训练优化版""" def __init__(self, data, tokenizer, max_length=512, is_validation=False, adversarial_config=None): self.data = data self.tokenizer = tokenizer self.max_length = max_length self.is_validation = is_validation self.adversarial_config = adversarial_config self.valid_data = [item for item in data if item['label'] in [0, 1]] dataset_type = "验证" if is_validation else "训练" logger.info(f"原始{dataset_type}数据: {len(data)} 条，有效数据: {len(self.valid_data)} 条") self.sentence1_list = [item['sentence1'] for item in self.valid_data] self.sentence2_list = [item['sentence2'] for item in self.valid_data] self.labels = [item['label'] for item in self.valid_data] # 对抗训练专用的类别分析 if not is_validation and adversarial_config: self.class_counts = Counter(self.labels) self.class_weights = self._compute_adversarial_class_weights() self.sample_weights = self._compute_adversarial_sample_weights() logger.info(f"对抗训练类别权重: {self.class_weights}") def _compute_adversarial_class_weights(self): """计算对抗训练专用的类别权重 - 保持原始权重比例""" total_samples = len(self.labels) class_weights = {} # 使用与原始训练相同的权重计算方法 for label in [0, 1]: count = self.class_counts[label] class_weights[label] = total_samples / (2 * count) # 标准的平衡权重计算 return class_weights def _compute_adversarial_sample_weights(self): """计算对抗训练专用的样本权重""" sample_weights = [] for label in self.labels: sample_weights.append(self.class_weights[label]) return torch.tensor(sample_weights, dtype=torch.float) def get_weighted_sampler(self): """返回对抗训练优化的加权随机采样器""" if self.is_validation: raise ValueError("验证集不需要加权采样器") return WeightedRandomSampler( weights=self.sample_weights, num_samples=len(self.sample_weights), replacement=True ) def __len__(self): return len(self.valid_data) def __getitem__(self, idx): sentence1 = str(self.sentence1_list[idx]) sentence2 = str(self.sentence2_list[idx]) label = self.labels[idx] encoding = self.tokenizer( sentence1, sentence2, truncation=True, padding='max_length', max_length=self.max_length, return_tensors='pt' ) return { 'input_ids': encoding['input_ids'].flatten(), 'attention_mask': encoding['attention_mask'].flatten(), 'labels': torch.tensor(label, dtype=torch.long) } def load_and_split_data(train_file, validation_split=0.2, random_state=42): """加载数据并划分训练集和验证集 - 对抗训练版""" try: with open(train_file, 'r', encoding='utf-8') as f: all_data = json.load(f) logger.info(f"成功加载原始数据: {len(all_data)} 条记录") valid_data = [item for item in all_data if item['label'] in [0, 1]] logger.info(f"有效数据: {len(valid_data)} 条记录") labels = [item['label'] for item in valid_data] train_data, val_data = train_test_split( valid_data, test_size=validation_split, random_state=random_state, stratify=labels ) logger.info(f"对抗训练数据划分完成:") logger.info(f" 🔹 训练集: {len(train_data)} 条") logger.info(f" 🔹 验证集: {len(val_data)} 条") # 详细的类别不平衡分析 train_labels = [item['label'] for item in train_data] val_labels = [item['label'] for item in val_data] train_counts = Counter(train_labels) val_counts = Counter(val_labels) imbalance_ratio = train_counts[0] / train_counts[1] logger.info(f"📊 数据不平衡分析:") logger.info(f" 训练集 - 多数类:{train_counts[0]} 少数类:{train_counts[1]} 比例:{imbalance_ratio:.1f}:1") logger.info(f" 验证集 - 多数类:{val_counts[0]} 少数类:{val_counts[1]} 比例:{val_counts[0]/val_counts[1]:.1f}:1") return train_data, val_data, imbalance_ratio except Exception as e: logger.error(f"加载和划分数据失败: {str(e)}") return None, None, None def compute_adversarial_metrics(eval_pred): """计算对抗训练专用评估指标""" predictions, labels = eval_pred if isinstance(predictions, (list, tuple)): predictions = predictions[0] if not isinstance(predictions, np.ndarray): predictions = np.array(predictions) if len(predictions.shape) == 3: predictions = predictions[:, -1, :] elif len(predictions.shape) == 1: predictions = predictions.reshape(-1, 2) if len(predictions.shape) != 2: predictions = predictions.reshape(-1, 2) try: predictions = np.argmax(predictions, axis=1) except Exception as e: logger.error(f"预测处理错误: {e}") predictions = np.array([np.argmax(pred) if len(pred) > 1 else 0 for pred in predictions]) # 确保predictions和labels长度一致 min_length = min(len(predictions), len(labels)) predictions = predictions[:min_length] labels = labels[:min_length] logger.info(f"评估样本数量: predictions={len(predictions)}, labels={len(labels)}") # 计算详细指标 accuracy = accuracy_score(labels, predictions) # 计算混淆矩阵，确保样本数量一致 try: cm = confusion_matrix(labels, predictions) if cm.shape == (2, 2): tn, fp, fn, tp = cm.ravel() else: # 处理可能的单类别情况 logger.warning(f"混淆矩阵形状异常: {cm.shape}") if len(np.unique(labels)) == 1: # 只有一个类别的情况 if labels[0] == 0: tn, fp, fn, tp = len(labels), 0, 0, 0 else: tn, fp, fn, tp = 0, 0, 0, len(labels) else: # 其他异常情况，使用默认值 tn, fp, fn, tp = 0, 0, 0, 0 except Exception as e: logger.error(f"混淆矩阵计算错误: {e}") tn, fp, fn, tp = 0, 0, 0, 0 # 少数类指标 minority_precision = tp / (tp + fp) if (tp + fp) > 0 else 0 minority_recall = tp / (tp + fn) if (tp + fn) > 0 else 0 minority_f1 = 2 * (minority_precision * minority_recall) / (minority_precision + minority_recall) if (minority_precision + minority_recall) > 0 else 0 # 平衡准确率 majority_recall = tn / (tn + fp) if (tn + fp) > 0 else 0 balanced_accuracy = (minority_recall + majority_recall) / 2 return { 'accuracy': accuracy, 'balanced_accuracy': balanced_accuracy, 'minority_precision': minority_precision, 'minority_recall': minority_recall, 'minority_f1': minority_f1, } class FocalLoss(nn.Module): """保持原始设置的Focal Loss""" def __init__(self, alpha=None, gamma=3.0, reduction='mean'): # 使用原始gamma=3.0 super(FocalLoss, self).__init__() self.alpha = alpha self.gamma = gamma self.reduction = reduction def forward(self, inputs, targets): ce_loss = F.cross_entropy(inputs, targets, reduction='none') pt = torch.exp(-ce_loss) if self.alpha is not None: if self.alpha.type() != inputs.data.type(): self.alpha = self.alpha.type_as(inputs.data) at = self.alpha.gather(0, targets.data.view(-1)) ce_loss = ce_loss * at focal_weight = (1 - pt) ** self.gamma focal_loss = focal_weight * ce_loss if self.reduction == 'mean': return focal_loss.mean() elif self.reduction == 'sum': return focal_loss.sum() else: return focal_loss class ScaledDotProductAttention(nn.Module): """缩放点积注意力机制 - 对抗训练优化""" def __init__(self, d_model, dropout=0.1): super(ScaledDotProductAttention, self).__init__() self.d_model = d_model self.dropout = nn.Dropout(dropout) def forward(self, query, key, value, mask=None): batch_size, seq_len, d_model = query.size() scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_model) if mask is not None: mask_value = torch.finfo(scores.dtype).min scores = scores.masked_fill(mask == 0, mask_value) attention_weights = F.softmax(scores, dim=-1) attention_weights = self.dropout(attention_weights) output = torch.matmul(attention_weights, value) return output, attention_weights class RoBERTaWithAdversarialTraining(nn.Module): """带对抗训练的RoBERTa模型 - 保持原始参数设置""" def __init__(self, model_path, num_labels=2, dropout=0.1, focal_alpha=None, focal_gamma=3.0, adversarial_config=None): # 保持原始gamma=3.0 super(RoBERTaWithAdversarialTraining, self).__init__() self.roberta = BertModel.from_pretrained(model_path) self.config = self.roberta.config self.config.num_labels = num_labels self.adversarial_config = adversarial_config self.scaled_attention = ScaledDotProductAttention( d_model=self.config.hidden_size, dropout=dropout ) self.dropout = nn.Dropout(dropout) self.classifier = nn.Linear(self.config.hidden_size, num_labels) self.focal_loss = FocalLoss(alpha=focal_alpha, gamma=focal_gamma) # 对抗训练组件 self.perturbation_generator = AdversarialPerturbationGenerator(adversarial_config) self._init_weights() self.focal_alpha = focal_alpha self.focal_gamma = focal_gamma self.current_phase = 'adaptation' def _init_weights(self): """初始化新增层的权重""" nn.init.normal_(self.classifier.weight, std=0.02) nn.init.zeros_(self.classifier.bias) def set_training_phase(self, phase): """设置训练阶段""" if self.current_phase != phase: self.current_phase = phase # 只在阶段真正改变时记录日志 def forward(self, input_ids=None, attention_mask=None, token_type_ids=None, labels=None, inputs_embeds=None, adversarial_training=False): if adversarial_training and labels is not None and self.training: return self._adversarial_forward(input_ids, attention_mask, labels) else: return self._standard_forward(input_ids, attention_mask, token_type_ids, labels, inputs_embeds) def _standard_forward(self, input_ids, attention_mask, token_type_ids, labels, inputs_embeds): """标准前向传播""" roberta_outputs = self.roberta( input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, inputs_embeds=inputs_embeds, return_dict=True ) sequence_output = roberta_outputs.last_hidden_state enhanced_output, attention_weights = self.scaled_attention( query=sequence_output, key=sequence_output, value=sequence_output, mask=attention_mask.unsqueeze(1) if attention_mask is not None else None ) cls_output = enhanced_output[:, 0, :] cls_output = self.dropout(cls_output) logits = self.classifier(cls_output) loss = None if labels is not None: loss = self.focal_loss(logits, labels) return { 'loss': loss, 'logits': logits, 'hidden_states': enhanced_output, 'attention_weights': attention_weights } def _adversarial_forward(self, input_ids, attention_mask, labels): """对抗训练前向传播""" inputs = {'input_ids': input_ids, 'attention_mask': attention_mask} # 生成对抗扰动 perturbed_embeds = self.perturbation_generator.generate_perturbation( self, inputs, labels, self.current_phase ) # 使用扰动后的嵌入进行前向传播 return self._standard_forward( input_ids=None, attention_mask=attention_mask, token_type_ids=None, labels=labels, inputs_embeds=perturbed_embeds ) def save_pretrained(self, save_directory): """保存模型""" os.makedirs(save_directory, exist_ok=True) model_to_save = self.module if hasattr(self, 'module') else self torch.save(model_to_save.state_dict(), os.path.join(save_directory, 'pytorch_model.bin')) config_dict = { 'model_type': 'RoBERTaWithAdversarialTraining', 'base_model': 'chinese-roberta-wwm-ext', 'num_labels': self.config.num_labels, 'hidden_size': self.config.hidden_size, 'focal_alpha': self.focal_alpha.tolist() if self.focal_alpha is not None else None, 'focal_gamma': self.focal_gamma, 'has_scaled_attention': True, 'has_focal_loss': True, 'has_adversarial_training': True, 'adversarial_config': { 'imbalance_ratio': self.adversarial_config.imbalance_ratio, 'eps_ratio': self.adversarial_config.eps_ratio, 'adv_steps': self.adversarial_config.adv_steps, 'norm_type': self.adversarial_config.norm_type }, 'optimization_level': 'adversarial_training_with_best_validation' } with open(os.path.join(save_directory, 'config.json'), 'w', encoding='utf-8') as f: json.dump(config_dict, f, ensure_ascii=False, indent=2) class AdversarialTrainer(Trainer): """自定义对抗训练器""" def __init__(self, adversarial_config, weighted_sampler=None, *args, **kwargs): super().__init__(*args, **kwargs) self.adversarial_config = adversarial_config self.weighted_sampler = weighted_sampler self.current_epoch = 0 self.current_phase = 'adaptation' # 初始化当前阶段 self.phase_transitions = {8: 'enhancement', 25: 'refinement'} self._phase_logged = False # 避免重复日志 def get_train_dataloader(self): if self.train_dataset is None: raise ValueError("Trainer: training requires a train_dataset.") train_dataset = self.train_dataset if self.weighted_sampler is not None: train_sampler = self.weighted_sampler else: train_sampler = self._get_train_sampler() return DataLoader( train_dataset, batch_size=self.args.train_batch_size, sampler=train_sampler, collate_fn=self.data_collator, drop_last=self.args.dataloader_drop_last, num_workers=self.args.dataloader_num_workers, pin_memory=self.args.dataloader_pin_memory, ) def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): """自定义损失计算 - 混合对抗训练""" # 确定当前训练阶段（避免频繁调用） current_phase = self._get_current_phase() if current_phase != self.current_phase: self.current_phase = current_phase model.set_training_phase(current_phase) logger.info(f"🎯 切换到训练阶段: {current_phase}") elif not self._phase_logged: model.set_training_phase(current_phase) self._phase_logged = True # 获取阶段配置 phase_config = self.adversarial_config.phase_configs[current_phase] clean_ratio = phase_config['clean_ratio'] labels = inputs.get("labels") # 混合训练策略 if self.state.global_step % 1 == 0: # 每步都进行混合训练 batch_size = labels.size(0) clean_size = int(batch_size * clean_ratio) if clean_size > 0: # 干净样本训练 clean_inputs = {k: v[:clean_size] for k, v in inputs.items()} clean_outputs = model(**clean_inputs, adversarial_training=False) clean_loss = clean_outputs['loss'] else: clean_loss = 0 if clean_size < batch_size: # 对抗样本训练 adv_inputs = {k: v[clean_size:] for k, v in inputs.items()} adv_outputs = model(**adv_inputs, adversarial_training=True) adv_loss = adv_outputs['loss'] else: adv_loss = 0 # 组合损失 if isinstance(clean_loss, torch.Tensor) and isinstance(adv_loss, torch.Tensor): total_loss = clean_ratio * clean_loss + (1 - clean_ratio) * adv_loss outputs = clean_outputs if clean_size > 0 else adv_outputs elif isinstance(clean_loss, torch.Tensor): total_loss = clean_loss outputs = clean_outputs else: total_loss = adv_loss outputs = adv_outputs outputs['loss'] = total_loss else: # 标准训练 outputs = model(**inputs, adversarial_training=False) total_loss = outputs['loss'] return (total_loss, outputs) if return_outputs else total_loss def _get_current_phase(self): """根据当前epoch确定训练阶段 - 温和对抗训练版本""" current_epoch = int(self.state.epoch) if self.state.epoch else 0 if current_epoch < 10: # 延长适应期 return 'adaptation' elif current_epoch < 25: return 'enhancement' else: return 'refinement' def on_epoch_begin(self, args, state, control, **kwargs): """Epoch开始时的处理""" super().on_epoch_begin(args, state, control, **kwargs) current_epoch = int(state.epoch) # 调整阶段切换点以适应温和训练 phase_transitions = {10: 'enhancement', 25: 'refinement'} # 延长适应期到10轮 # 检查是否需要切换阶段 if current_epoch in phase_transitions: new_phase = phase_transitions[current_epoch] self.current_phase = new_phase self._phase_logged = False # 重置日志标志 logger.info(f"🔄 Epoch {current_epoch}: 切换到训练阶段 '{new_phase}' (温和对抗训练)") # 更新学习率 phase_config = self.adversarial_config.phase_configs[new_phase] new_lr = phase_config['learning_rate'] for param_group in self.optimizer.param_groups: param_group['lr'] = new_lr logger.info(f" 📉 学习率调整为: {new_lr}") def plot_adversarial_training_curves(loss_tracker, output_dir): """绘制对抗训练专用的可视化图表""" plt.figure(figsize=(20, 15)) # 1. 训练损失趋势 if loss_tracker.train_losses: plt.subplot(3, 3, 1) plt.plot(loss_tracker.train_steps, loss_tracker.train_losses, 'b-', label='Training Loss', linewidth=2, alpha=0.8) plt.title('Adversarial Training Loss', fontsize=14, fontweight='bold') plt.xlabel('Training Steps') plt.ylabel('Loss Value') plt.legend() plt.grid(True, alpha=0.3) # 2. 验证损失vs验证准确率 if loss_tracker.eval_losses and loss_tracker.eval_accuracies: plt.subplot(3, 3, 2) ax1 = plt.gca() ax2 = ax1.twinx() line1 = ax1.plot(loss_tracker.eval_steps, loss_tracker.eval_losses, 'r-', label='Validation Loss', linewidth=2) line2 = ax2.plot(loss_tracker.eval_steps, loss_tracker.eval_accuracies, 'g-', label='Validation Accuracy', linewidth=2) ax1.set_xlabel('Training Steps') ax1.set_ylabel('Loss', color='r') ax2.set_ylabel('Accuracy', color='g') ax1.set_title('Validation Metrics') lines = line1 + line2 labels = [l.get_label() for l in lines] ax1.legend(lines, labels, loc='center right') ax1.grid(True, alpha=0.3) # 3. 少数类F1趋势 if loss_tracker.eval_minority_f1: plt.subplot(3, 3, 3) plt.plot(loss_tracker.eval_steps[:len(loss_tracker.eval_minority_f1)], loss_tracker.eval_minority_f1, 'purple', label='Minority F1', linewidth=2, marker='o', markersize=4) plt.title('Minority Class F1 Score Progress', fontsize=14, fontweight='bold') plt.xlabel('Training Steps') plt.ylabel('F1 Score') plt.legend() plt.grid(True, alpha=0.3) # 标记最佳F1 if loss_tracker.best_minority_f1 > 0: plt.axhline(y=loss_tracker.best_minority_f1, color='red', linestyle='--', alpha=0.7) plt.text(0.02, 0.98, f'Best: {loss_tracker.best_minority_f1:.4f}', transform=plt.gca().transAxes, fontsize=10, verticalalignment='top', bbox=dict(boxstyle="round,pad=0.3", facecolor="yellow", alpha=0.7)) # 4. 训练vs验证准确率对比 if loss_tracker.eval_accuracies: plt.subplot(3, 3, 4) plt.plot(loss_tracker.eval_steps, loss_tracker.eval_accuracies, 'g-o', label='Validation Accuracy', linewidth=2, markersize=3) plt.title('Validation Accuracy Trend', fontsize=14, fontweight='bold') plt.xlabel('Training Steps') plt.ylabel('Accuracy') plt.legend() plt.grid(True, alpha=0.3) # 5. 损失收敛分析 if len(loss_tracker.train_losses) > 50: plt.subplot(3, 3, 5) # 计算移动平均 window_size = 20 train_ma = [] for i in range(window_size, len(loss_tracker.train_losses)): train_ma.append(np.mean(loss_tracker.train_losses[i-window_size:i])) plt.plot(loss_tracker.train_steps[window_size:], train_ma, 'b-', label=f'Training Loss MA({window_size})', linewidth=2) plt.title('Loss Convergence Analysis', fontsize=14, fontweight='bold') plt.xlabel('Training Steps') plt.ylabel('Moving Average Loss') plt.legend() plt.grid(True, alpha=0.3) # 6. 性能提升统计 plt.subplot(3, 3, 6) if loss_tracker.eval_accuracies and loss_tracker.eval_minority_f1: metrics_data = { 'Overall Accuracy': loss_tracker.eval_accuracies[-1] if loss_tracker.eval_accuracies else 0, 'Best Overall Acc': max(loss_tracker.eval_accuracies) if loss_tracker.eval_accuracies else 0, 'Minority F1': loss_tracker.eval_minority_f1[-1] if loss_tracker.eval_minority_f1 else 0, 'Best Minority F1': loss_tracker.best_minority_f1 } metrics_names = list(metrics_data.keys()) metrics_values = list(metrics_data.values()) bars = plt.bar(metrics_names, metrics_values, color=['skyblue', 'lightblue', 'lightcoral', 'coral']) plt.title('Performance Summary', fontsize=14, fontweight='bold') plt.ylabel('Score') plt.xticks(rotation=45) # 添加数值标签 for bar, value in zip(bars, metrics_values): plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01, f'{value:.3f}', ha='center', va='bottom') # 7. 训练阶段可视化 plt.subplot(3, 3, 7) if loss_tracker.epochs: phase_colors = [] for epoch in loss_tracker.epochs: if epoch < 8: phase_colors.append('lightgreen') # adaptation elif epoch < 25: phase_colors.append('orange') # enhancement else: phase_colors.append('red') # refinement plt.scatter(loss_tracker.epochs, [1]*len(loss_tracker.epochs), c=phase_colors, s=50, alpha=0.7) plt.title('Training Phases Timeline', fontsize=14, fontweight='bold') plt.xlabel('Epoch') plt.ylabel('Phase') plt.yticks([1], ['Phases']) # 添加图例 from matplotlib.patches import Patch legend_elements = [Patch(facecolor='lightgreen', label='Adaptation (1-8)'), Patch(facecolor='orange', label='Enhancement (9-25)'), Patch(facecolor='red', label='Refinement (26+)')] plt.legend(handles=legend_elements, loc='upper right') # 8. 对抗训练效果对比（如果有基准数据） plt.subplot(3, 3, 8) baseline_acc = 0.9451 # 从你的混淆矩阵获得 current_acc = loss_tracker.eval_accuracies[-1] if loss_tracker.eval_accuracies else 0 improvement = ((current_acc - baseline_acc) / baseline_acc * 100) if baseline_acc > 0 else 0 categories = ['Baseline\n(No Adversarial)', 'Current\n(Adversarial)'] accuracies = [baseline_acc, current_acc] colors = ['lightgray', 'lightgreen' if improvement > 0 else 'lightcoral'] bars = plt.bar(categories, accuracies, color=colors) plt.title('Adversarial Training Impact', fontsize=14, fontweight='bold') plt.ylabel('Accuracy') plt.ylim(0.9, 1.0) # 添加改进百分比 plt.text(0.5, 0.95, f'Improvement: {improvement:+.2f}%', transform=plt.gca().transAxes, ha='center', bbox=dict(boxstyle="round,pad=0.3", facecolor="lightgreen" if improvement > 0 else "lightcoral", alpha=0.7)) # 9. 训练时间分析 plt.subplot(3, 3, 9) if loss_tracker.train_steps: step_intervals = [] for i in range(1, len(loss_tracker.train_steps)): step_intervals.append(loss_tracker.train_steps[i] - loss_tracker.train_steps[i-1]) if step_intervals: plt.hist(step_intervals, bins=20, alpha=0.7, color='skyblue', edgecolor='black') plt.title('Training Step Intervals', fontsize=14, fontweight='bold') plt.xlabel('Steps Between Logs') plt.ylabel('Frequency') plt.grid(True, alpha=0.3) plt.tight_layout() # 保存综合对抗训练图表 curves_path = os.path.join(output_dir, 'comprehensive_adversarial_training_curves.png') plt.savefig(curves_path, dpi=300, bbox_inches='tight') plt.close() logger.info(f"📈 对抗训练综合曲线已保存: {curves_path}") # 单独保存重要指标图表 plt.figure(figsize=(15, 10)) # 少数类F1和整体准确率对比 plt.subplot(2, 2, 1) if loss_tracker.eval_accuracies and loss_tracker.eval_minority_f1: min_len = min(len(loss_tracker.eval_accuracies), len(loss_tracker.eval_minority_f1)) steps = loss_tracker.eval_steps[:min_len] acc = loss_tracker.eval_accuracies[:min_len] f1 = loss_tracker.eval_minority_f1[:min_len] plt.plot(steps, acc, 'b-o', label='Overall Accuracy', linewidth=2, markersize=4) plt.plot(steps, f1, 'r-o', label='Minority F1', linewidth=2, markersize=4) plt.title('Key Metrics Comparison', fontsize=16, fontweight='bold') plt.xlabel('Training Steps') plt.ylabel('Score') plt.legend() plt.grid(True, alpha=0.3) # 训练损失平滑曲线 plt.subplot(2, 2, 2) if len(loss_tracker.train_losses) > 10: # 应用高斯平滑 from scipy import ndimage smoothed_loss = ndimage.gaussian_filter1d(loss_tracker.train_losses, sigma=2) plt.plot(loss_tracker.train_steps, smoothed_loss, 'g-', linewidth=3, alpha=0.8) plt.title('Smoothed Training Loss', fontsize=16, fontweight='bold') plt.xlabel('Training Steps') plt.ylabel('Loss') plt.grid(True, alpha=0.3) # 性能改进总结 plt.subplot(2, 2, 3) if loss_tracker.eval_accuracies and loss_tracker.eval_minority_f1: initial_acc = loss_tracker.eval_accuracies[0] final_acc = loss_tracker.eval_accuracies[-1] initial_f1 = loss_tracker.eval_minority_f1[0] if loss_tracker.eval_minority_f1 else 0 final_f1 = loss_tracker.eval_minority_f1[-1] if loss_tracker.eval_minority_f1 else 0 improvements = { 'Overall Accuracy': ((final_acc - initial_acc) / initial_acc * 100) if initial_acc > 0 else 0, 'Minority F1': ((final_f1 - initial_f1) / initial_f1 * 100) if initial_f1 > 0 else 0 } colors = ['green' if imp > 0 else 'red' for imp in improvements.values()] bars = plt.bar(improvements.keys(), improvements.values(), color=colors, alpha=0.7) plt.title('Performance Improvements (%)', fontsize=16, fontweight='bold') plt.ylabel('Improvement (%)') plt.axhline(y=0, color='black', linestyle='-', alpha=0.3) for bar, imp in zip(bars, improvements.values()): plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.5, f'{imp:+.1f}%', ha='center', va='bottom') # 训练稳定性分析 plt.subplot(2, 2, 4) if len(loss_tracker.eval_accuracies) > 5: # 计算准确率的标准差（稳定性指标） acc_std = np.std(loss_tracker.eval_accuracies[-10:]) # 最后10个评估的标准差 plt.text(0.5, 0.7, f'Recent Stability\n(Last 10 evals)', ha='center', va='center', transform=plt.gca().transAxes, fontsize=14, fontweight='bold') plt.text(0.5, 0.5, f'Std Dev: {acc_std:.4f}', ha='center', va='center', transform=plt.gca().transAxes, fontsize=12) stability_rating = "High" if acc_std < 0.01 else "Medium" if acc_std < 0.02 else "Low" color = "green" if stability_rating == "High" else "orange" if stability_rating == "Medium" else "red" plt.text(0.5, 0.3, f'Rating: {stability_rating}', ha='center', va='center', transform=plt.gca().transAxes, fontsize=12, color=color, fontweight='bold') plt.axis('off') plt.tight_layout() key_metrics_path = os.path.join(output_dir, 'key_adversarial_metrics.png') plt.savefig(key_metrics_path, dpi=300, bbox_inches='tight') plt.close() logger.info(f"📈 关键对抗训练指标图表已保存: {key_metrics_path}") def train_adversarial_roberta_model(train_data, val_data, imbalance_ratio, base_model_path, model_path="/root/autodl-tmp/chinese-roberta-wwm-ext/chinese-roberta-wwm-ext/model", output_dir="/root/autodl-tmp/chinese-roberta-wwm-ext/chinese-roberta-wwm-ext/model_adversarial", checkpoint_dir="/root/autodl-tmp/chinese-roberta-wwm-ext/chinese-roberta-wwm-ext/output_adversarial"): """完整的对抗训练流程 - V100 48GB优化版""" gpu_available, gpu_memory, gpu_type = check_gpu_availability() device = torch.device('cuda') logger.info(f"🚀 使用GPU设备: {device} ({gpu_type})") # 初始化对抗训练配置 adv_config = AdversarialConfig(imbalance_ratio=imbalance_ratio, gpu_type=gpu_type) logger.info(f"📥 基于预训练模型进行对抗训练: {base_model_path}") tokenizer = BertTokenizer.from_pretrained(model_path) # 创建对抗训练优化的Focal Loss alpha_tensor = torch.tensor(adv_config.focal_alpha, dtype=torch.float).to(device) model = RoBERTaWithAdversarialTraining( model_path=model_path, num_labels=2, dropout=0.1, focal_alpha=alpha_tensor, focal_gamma=adv_config.focal_gamma, adversarial_config=adv_config ) # 如果有预训练的模型权重，加载它们 if os.path.exists(base_model_path): logger.info(f"🔄 加载预训练模型权重: {base_model_path}") try: checkpoint = torch.load(os.path.join(base_model_path, 'pytorch_model.bin'), map_location='cpu') model.load_state_dict(checkpoint, strict=False) logger.info("✅ 预训练模型权重加载成功") except Exception as e: logger.warning(f"⚠️ 无法加载预训练权重，使用默认初始化: {str(e)}") model = model.to(device) logger.info(f"✅ 对抗训练模型已加载到GPU: {next(model.parameters()).device}") total_params = sum(p.numel() for p in model.parameters()) trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) logger.info(f"📊 对抗训练模型参数统计:") logger.info(f" 🔹 总参数量: {total_params:,}") logger.info(f" 🔹 可训练参数: {trainable_params:,}") logger.info("📋 准备对抗训练数据集...") train_dataset = SentencePairDataset(train_data, tokenizer, max_length=512, is_validation=False, adversarial_config=adv_config) val_dataset = SentencePairDataset(val_data, tokenizer, max_length=512, is_validation=True) weighted_sampler = train_dataset.get_weighted_sampler() logger.info(f" 🔹 训练集大小: {len(train_dataset)}") logger.info(f" 🔹 验证集大小: {len(val_dataset)}") # V100 48GB对抗训练优化配置 if gpu_type == "v100_48gb": batch_size = 12 # 对抗训练需要更多内存，适当降低 gradient_accumulation = 3 # 保持有效批次大小36 max_grad_norm = 1.0 fp16 = True dataloader_num_workers = 4 else: batch_size = 8 gradient_accumulation = 4 max_grad_norm = 0.5 fp16 = True dataloader_num_workers = 2 effective_batch_size = batch_size * gradient_accumulation # 确保输出目录存在 os.makedirs(output_dir, exist_ok=True) os.makedirs(checkpoint_dir, exist_ok=True) training_args = TrainingArguments( output_dir=checkpoint_dir, num_train_epochs=30, # 减少总轮次，温和对抗训练 per_device_train_batch_size=batch_size, per_device_eval_batch_size=batch_size, gradient_accumulation_steps=gradient_accumulation, eval_strategy="epoch", eval_steps=1, save_strategy="epoch", save_steps=10, # 改为每10个epoch保存一次 logging_strategy="steps", logging_steps=100, # 进一步减少日志频率 warmup_ratio=0.15, # 使用原始warmup比例 weight_decay=0.01, learning_rate=2e-5, # 使用原始学习率 load_best_model_at_end=True, remove_unused_columns=False, dataloader_pin_memory=True, fp16=fp16, dataloader_num_workers=dataloader_num_workers, group_by_length=True, report_to=[], adam_epsilon=1e-8, max_grad_norm=max_grad_norm, save_total_limit=1, # 只保留1个最新checkpoint skip_memory_metrics=True, disable_tqdm=False, lr_scheduler_type="cosine", warmup_steps=0, metric_for_best_model="eval_accuracy", # 使用原始的准确率指标 greater_is_better=True, ) logger.info(f"🎯 对抗训练参数配置:") logger.info(f" 🔹 训练轮数: {training_args.num_train_epochs} (分3个阶段)") logger.info(f" 🔹 批次大小: {batch_size}") logger.info(f" 🔹 梯度累积: {gradient_accumulation}") logger.info(f" 🔹 有效批次大小: {effective_batch_size}") logger.info(f" 🔹 起始学习率: {training_args.learning_rate}") logger.info(f" 🔹 主要评估指标: 少数类F1分数") logger.info(f" 🔹 GPU优化配置: {gpu_type}") logger.info(f"🎯 对抗训练阶段设置:") for phase, config in adv_config.phase_configs.items(): epochs = "1-8" if phase == "adaptation" else "9-25" if phase == "enhancement" else "26+" logger.info(f" 🔹 {phase.capitalize()} ({epochs}): eps={config['eps']}, lr={config['learning_rate']}, clean_ratio={config['clean_ratio']}") data_collator = DataCollatorWithPadding(tokenizer=tokenizer) # 创建回调函数 loss_tracker = LossTracker() adv_validation_callback = AdversarialValidationCallback( eval_dataset=val_dataset, tokenizer=tokenizer, output_dir=checkpoint_dir, adv_config=adv_config, epochs_interval=5 ) trainer = AdversarialTrainer( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=val_dataset, tokenizer=tokenizer, data_collator=data_collator, compute_metrics=compute_adversarial_metrics, callbacks=[loss_tracker, adv_validation_callback], adversarial_config=adv_config, weighted_sampler=weighted_sampler ) logger.info("🏃‍♂️ 开始完整的FreeLB对抗训练...") logger.info("🎯 对抗训练特性:") logger.info(" ✅ FreeLB多步对抗扰动生成") logger.info(" ✅ 类别差异化扰动强度 (少数类2.5倍)") logger.info(" ✅ 混合训练策略 (干净+对抗样本)") logger.info(" ✅ 三阶段渐进式训练") logger.info(" ✅ 强化版Focal Loss (gamma=4.0)") logger.info(" ✅ 动态学习率调整") logger.info(" ✅ 少数类F1优化目标") logger.info(" ✅ V100 48GB内存优化") logger.info(" ✅ 实时对抗效果监控") start_time = datetime.now() try: trainer.train() logger.info(f"🏆 对抗训练完成！") logger.info(f" 🔹 最佳少数类F1: {loss_tracker.best_minority_f1:.4f}") logger.info(f" 🔹 最佳整体准确率: {loss_tracker.best_eval_accuracy:.4f}") logger.info(f" 🔹 最佳模型来自: Epoch {loss_tracker.best_epoch}") except RuntimeError as e: if "out of memory" in str(e).lower(): logger.error("❌ GPU内存不足！") logger.error("💡 建议减小批次大小或对抗步数") raise else: raise end_time = datetime.now() training_duration = end_time - start_time logger.info(f"🎉 对抗训练完成! 耗时: {training_duration}") logger.info("📈 生成对抗训练可视化图表...") plot_adversarial_training_curves(loss_tracker, checkpoint_dir) logger.info(f"💾 保存最佳对抗训练模型到: {output_dir}") # 保存最佳模型 trainer.model.save_pretrained(output_dir) tokenizer.save_pretrained(output_dir) # 保存对抗训练历史记录 adversarial_history = { 'train_losses': loss_tracker.train_losses, 'train_steps': loss_tracker.train_steps, 'eval_losses': loss_tracker.eval_losses, 'eval_steps': loss_tracker.eval_steps, 'eval_accuracies': loss_tracker.eval_accuracies, 'eval_minority_f1': loss_tracker.eval_minority_f1, 'epochs': loss_tracker.epochs, 'best_eval_accuracy': loss_tracker.best_eval_accuracy, 'best_minority_f1': loss_tracker.best_minority_f1, 'best_epoch': loss_tracker.best_epoch, 'adversarial_config': { 'imbalance_ratio': adv_config.imbalance_ratio, 'focal_alpha': adv_config.focal_alpha, 'focal_gamma': adv_config.focal_gamma, 'phase_configs': adv_config.phase_configs, 'sampling_configs': adv_config.sampling_configs } } with open(os.path.join(checkpoint_dir, 'adversarial_training_history.json'), 'w', encoding='utf-8') as f: json.dump(adversarial_history, f, ensure_ascii=False, indent=2) # 保存详细的对抗训练信息 adversarial_info = { "model_name": model_path, "model_type": "Chinese-RoBERTa-WWM-Ext with FreeLB Adversarial Training", "base_model_path": base_model_path, "optimization_level": "freelb_adversarial_training", "training_duration": str(training_duration), "num_train_samples": len(train_dataset), "num_val_samples": len(val_dataset), "data_imbalance_ratio": imbalance_ratio, "adversarial_training_config": { "method": "FreeLB (Free Large-Batch)", "adversarial_steps": adv_config.adv_steps, "perturbation_type": "embedding_level", "norm_type": adv_config.norm_type, "max_norm": adv_config.max_norm, "adversarial_lr": adv_config.adv_lr, "class_differential_perturbation": True, "majority_class_eps_range": "0.08-0.12", "minority_class_eps_range": "0.2-0.3", "eps_ratio": adv_config.eps_ratio }, "training_phases": { "adaptation_phase": { "epochs": "1-8", "description": "温和对抗训练适应期", "clean_ratio": 0.8, "learning_rate": "8e-6", "perturbation_strength": "低" }, "enhancement_phase": { "epochs": "9-25", "description": "强化对抗训练期", "clean_ratio": 0.5, "learning_rate": "5e-6", "perturbation_strength": "中高" }, "refinement_phase": { "epochs": "26+", "description": "精调优化期", "clean_ratio": 0.2, "learning_rate": "2e-6", "perturbation_strength": "中" } }, "best_model_info": { "best_minority_f1": float(loss_tracker.best_minority_f1), "best_overall_accuracy": float(loss_tracker.best_eval_accuracy), "best_epoch": int(loss_tracker.best_epoch), "model_selection_criterion": "minority_f1_score", "load_best_model_at_end": True }, "focal_loss_enhancement": { "alpha_weights": adv_config.focal_alpha, "gamma": adv_config.focal_gamma, "optimization": "adversarial_training_specific", "minority_class_focus": "aggressive_9x_weight" }, "performance_targets": { "primary_target": "minority_class_f1_improvement", "secondary_target": "overall_accuracy_maintenance", "expected_minority_f1_gain": "15-30%", "expected_robustness_improvement": "significant" }, "gpu_optimization": { "gpu_name": torch.cuda.get_device_name(0), "gpu_memory_gb": gpu_memory, "optimization_target": gpu_type, "effective_batch_size": effective_batch_size, "memory_optimization": "adversarial_training_specific", "batch_size_reduction": "12 (from 16 for memory)" }, "training_args": { "num_train_epochs": training_args.num_train_epochs, "per_device_train_batch_size": training_args.per_device_train_batch_size, "gradient_accumulation_steps": training_args.gradient_accumulation_steps, "learning_rate": training_args.learning_rate, "warmup_ratio": training_args.warmup_ratio, "weight_decay": training_args.weight_decay, "fp16": training_args.fp16, "metric_for_best_model": training_args.metric_for_best_model, "load_best_model_at_end": training_args.load_best_model_at_end }, "adversarial_innovations": [ "FreeLB多步梯度扰动生成", "类别差异化扰动强度 (2.5倍比例)", "三阶段渐进式对抗训练", "混合训练策略 (干净+对抗样本)", "少数类F1优化目标", "动态学习率阶段调整", "强化版Focal Loss (gamma=4.0)", "V100大显存充分利用", "实时对抗效果监控", "类别平衡采样策略" ], "expected_improvements": [ "少数类召回率提升 20-35%", "少数类F1分数提升 15-30%", "模型鲁棒性显著增强", "对输入扰动的稳定性提升", "泛化能力改善", "整体准确率维持或轻微提升" ], "paths": { "base_model_path": base_model_path, "model_output_path": output_dir, "checkpoint_output_path": checkpoint_dir, "training_logs": checkpoint_dir }, "visualization_files": { "comprehensive_curves": "comprehensive_adversarial_training_curves.png", "key_metrics": "key_adversarial_metrics.png", "adversarial_analysis": [f"adversarial_analysis_epoch_{i}.png" for i in range(5, 36, 5)], "training_history": "adversarial_training_history.json" }, "training_completed": end_time.isoformat() } with open(os.path.join(checkpoint_dir, 'adversarial_training_info.json'), 'w', encoding='utf-8') as f: json.dump(adversarial_info, f, ensure_ascii=False, indent=2) # 在模型目录保存对抗训练摘要 adversarial_summary = { "adversarial_model_info": { "best_minority_f1": float(loss_tracker.best_minority_f1), "best_overall_accuracy": float(loss_tracker.best_eval_accuracy), "best_epoch": int(loss_tracker.best_epoch), "training_method": "FreeLB_Adversarial_Training", "selection_criterion": "minority_f1_score" }, "adversarial_config": adversarial_info } with open(os.path.join(output_dir, 'adversarial_model_info.json'), 'w', encoding='utf-8') as f: json.dump(adversarial_summary, f, ensure_ascii=False, indent=2) logger.info("📋 对抗训练信息和模型记录已保存") return trainer, trainer.model, tokenizer, loss_tracker, adv_validation_callback def main(): """主函数 - 完整的对抗训练流程""" logger.info("=" * 120) logger.info("🚀 Chinese-RoBERTa-WWM-Ext FreeLB对抗训练 (存储优化版)") logger.info("=" * 120) # 配置路径 train_file = "/root/autodl-tmp/chinese-roberta-wwm-ext/chinese-roberta-wwm-ext/Data/train_dataset.json" model_path = "/root/autodl-tmp/chinese-roberta-wwm-ext/chinese-roberta-wwm-ext/model" base_model_path = "/root/autodl-tmp/chinese-roberta-wwm-ext/chinese-roberta-wwm-ext/model_train" # 预训练模型路径 output_dir = "/root/autodl-tmp/chinese-roberta-wwm-ext/chinese-roberta-wwm-ext/model_adversarial" checkpoint_dir = "/root/autodl-tmp/chinese-roberta-wwm-ext/chinese-roberta-wwm-ext/output_adversarial" # 检查磁盘空间 import shutil total, used, free = shutil.disk_usage("/root/autodl-tmp") free_gb = free // (1024**3) logger.info(f"📁 磁盘空间检查:") logger.info(f" 🔹 可用空间: {free_gb} GB") if free_gb < 5: logger.warning("⚠️ 磁盘空间不足，建议清理后再运行训练") logger.info("💡 建议执行以下命令清理空间:") logger.info(" rm -rf /root/.cache/*") logger.info(" rm -rf /tmp/*") logger.info(" find /root/autodl-tmp -name 'checkpoint-*' -type d | head -10 | xargs rm -rf") return # 确保所有输出目录存在 os.makedirs(output_dir, exist_ok=True) os.makedirs(checkpoint_dir, exist_ok=True) logger.info(f"📁 确保输出目录存在:") logger.info(f" 🔹 对抗训练模型输出: {output_dir}") logger.info(f" 🔹 对抗训练记录: {checkpoint_dir}") logger.info(f"\n📋 FreeLB对抗训练配置 (存储优化版):") logger.info(f" 🔹 训练数据: {train_file}") logger.info(f" 🔹 基础模型: {model_path}") logger.info(f" 🔹 预训练模型: {base_model_path}") logger.info(f" 🔹 对抗训练方法: FreeLB (温和版本)") logger.info(f" 🔹 存储优化: 每10轮保存，仅保留1个checkpoint") logger.info(f" 🔹 硬件: V100 48GB GPU优化") logger.info(f"\n🎯 温和对抗训练特性:") logger.info(f" 🔹 温和扰动强度 (多数类0.05, 少数类0.1)") logger.info(f" 🔹 减少对抗步数 (3步)") logger.info(f" 🔹 延长适应期 (前10轮)") logger.info(f" 🔹 更多干净样本混合") logger.info(f" 🔹 存储空间最小化") # 加载和划分数据 train_data, val_data, imbalance_ratio = load_and_split_data(train_file, validation_split=0.2, random_state=42) if train_data is None or val_data is None: logger.error("❌ 无法加载和划分数据，程序退出") return logger.info(f"📊 数据不平衡分析: {imbalance_ratio:.1f}:1") try: # 执行完整的对抗训练 trainer, best_model, tokenizer, loss_tracker, adv_callback = train_adversarial_roberta_model( train_data, val_data, imbalance_ratio, base_model_path=base_model_path, model_path=model_path, output_dir=output_dir, checkpoint_dir=checkpoint_dir ) logger.info("=" * 120) logger.info("🎉 FreeLB温和对抗训练完成!") logger.info("=" * 120) logger.info(f"🏆 最佳对抗训练模型信息:") logger.info(f" 🔹 少数类F1分数: {loss_tracker.best_minority_f1:.4f}") logger.info(f" 🔹 整体准确率: {loss_tracker.best_eval_accuracy:.4f}") logger.info(f" 🔹 最佳模型来自: Epoch {loss_tracker.best_epoch}") logger.info(f" 🔹 选择标准: 整体准确率最高") # 计算改进效果 baseline_acc = 0.9451 # 原始模型准确率 if loss_tracker.best_eval_accuracy > 0: acc_improvement = ((loss_tracker.best_eval_accuracy - baseline_acc) / baseline_acc * 100) logger.info(f" 🔹 准确率改进: {acc_improvement:+.2f}%") logger.info(f"\n📁 文件输出位置:") logger.info(f" 🔹 最佳对抗训练模型: {output_dir}") logger.info(f" 🔹 训练记录: {checkpoint_dir}") logger.info("🔥 温和FreeLB对抗训练的核心优势:") logger.info(" ✅ 平稳的性能提升过程") logger.info(" ✅ 温和但有效的鲁棒性增强") logger.info(" ✅ 避免性能大幅下降") logger.info(" ✅ 存储空间最小化") logger.info(" ✅ 适合有限资源环境") logger.info(f"\n🎯 温和对抗训练完成，模型已优化并保存!") except Exception as e: logger.error(f"❌ 对抗训练过程中出现错误: {str(e)}") import traceback traceback.print_exc() raise if __name__ == "__main__": main()