import torch from torch.utils.data import DataLoader from transformers import AdamW, get_linear_schedule_with_warmup from tqdm import tqdm import time import json import os from models import PersonaAssigner, PreferencePredictor, BERTEncoder from data_utils import load_chatbot_data, load_personas, ChatbotDataset from torch.cuda.amp import autocast, GradScaler import sys class SimpleDashboard: def __init__(self): self.stats = { 'iteration': 0, 'total_iterations': 500, 'batch': 0, 'total_batches': 575, 'baseline_loss': 0, 'baseline_accuracy': 0, 'enhanced_loss': 0, 'enhanced_accuracy': 0, 'last_save': '', } self.history = { 'baseline_loss': [], 'baseline_accuracy': [], 'enhanced_loss': [], 'enhanced_accuracy': [], } def update_stats(self, **kwargs): self.stats.update(kwargs) for key in ['baseline_loss', 'baseline_accuracy', 'enhanced_loss', 'enhanced_accuracy']: if key in kwargs: self.history[key].append(kwargs[key]) if len(self.history[key]) > 50: # Keep only last 50 points self.history[key] = self.history[key][-50:] def draw_ascii_chart(self, data, title, width=50, height=10): if not data: return "" min_val, max_val = min(data), max(data) range_val = max_val - min_val if max_val > min_val else 1 lines = [f"{title} (min: {min_val:.4f}, max: {max_val:.4f})"] for i in range(height - 1, -1, -1): line = "" for val in data[-width:]: if (val - min_val) / range_val > i / (height - 1): line += "█" else: line += " " lines.append(line) return "\n".join(lines) def draw(self): os.system('cls' if os.name == 'nt' else 'clear') print(f"Experiment Progress:") print(f"Iteration: {self.stats['iteration']}/{self.stats['total_iterations']}") print(f"Batch: {self.stats['batch']}/{self.stats['total_batches']}") print(f"Baseline Loss: {self.stats['baseline_loss']:.4f}") print(f"Baseline Accuracy: {self.stats['baseline_accuracy']:.2%}") print(f"Enhanced Loss: {self.stats['enhanced_loss']:.4f}") print(f"Enhanced Accuracy: {self.stats['enhanced_accuracy']:.2%}") print(f"Last Save: {self.stats['last_save']}") print("\n" + self.draw_ascii_chart(self.history['baseline_loss'], "Baseline Loss")) print("\n" + self.draw_ascii_chart(self.history['enhanced_loss'], "Enhanced Loss")) print("\n" + self.draw_ascii_chart(self.history['baseline_accuracy'], "Baseline Accuracy")) print("\n" + self.draw_ascii_chart(self.history['enhanced_accuracy'], "Enhanced Accuracy")) class ComparativeExperiment: def __init__(self, batch_size=4, accumulation_steps=8, max_length=64): print("Initializing ComparativeExperiment...") self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f"Using device: {self.device}") self.batch_size = batch_size self.accumulation_steps = accumulation_steps self.max_length = max_length print("Initializing models...") self.bert_encoder = BERTEncoder().to(self.device) self.persona_assigner = PersonaAssigner(768, 256, 768).to(self.device) self.enhanced_predictor = PreferencePredictor(768 * 3).to(self.device) self.baseline_predictor = PreferencePredictor(768 * 3).to(self.device) print("Initializing optimizer...") self.optimizer = AdamW([ {'params': self.persona_assigner.parameters()}, {'params': self.enhanced_predictor.parameters()}, {'params': self.baseline_predictor.parameters()} ], lr=1e-4) self.criterion = torch.nn.CrossEntropyLoss() self.scaler = GradScaler() self.current_iteration = 0 self.current_step = 0 self.training_log = [] self.dashboard = SimpleDashboard() print("ComparativeExperiment initialized.") def train_iteration(self, batch): self.persona_assigner.train() self.enhanced_predictor.train() self.baseline_predictor.train() with autocast(): prompt_embeds = self.bert_encoder( input_ids=batch['prompt']['input_ids'].squeeze(1), attention_mask=batch['prompt']['attention_mask'].squeeze(1) ) response_a_embeds = self.bert_encoder( input_ids=batch['response_a']['input_ids'].squeeze(1), attention_mask=batch['response_a']['attention_mask'].squeeze(1) ) response_b_embeds = self.bert_encoder( input_ids=batch['response_b']['input_ids'].squeeze(1), attention_mask=batch['response_b']['attention_mask'].squeeze(1) ) labels = batch['label'].to(self.device) baseline_inputs = torch.cat([prompt_embeds, response_a_embeds, response_b_embeds], dim=1) baseline_outputs = self.baseline_predictor(baseline_inputs) baseline_loss = self.criterion(baseline_outputs, labels) baseline_accuracy = (baseline_outputs.argmax(dim=1) == labels).float().mean().item() prompt_personas = self.persona_assigner(prompt_embeds.detach()) response_a_personas = self.persona_assigner(response_a_embeds.detach()) response_b_personas = self.persona_assigner(response_b_embeds.detach()) combined_prompt = prompt_embeds + prompt_personas combined_response_a = response_a_embeds + response_a_personas combined_response_b = response_b_embeds + response_b_personas enhanced_inputs = torch.cat([combined_prompt, combined_response_a, combined_response_b], dim=1) enhanced_outputs = self.enhanced_predictor(enhanced_inputs) enhanced_loss = self.criterion(enhanced_outputs, labels) enhanced_accuracy = (enhanced_outputs.argmax(dim=1) == labels).float().mean().item() total_loss = baseline_loss + enhanced_loss scaled_loss = self.scaler.scale(total_loss) scaled_loss.backward() return baseline_loss.item(), baseline_accuracy, enhanced_loss.item(), enhanced_accuracy def save_state(self, filename='experiment_state.pth'): print(f"Saving state to {filename}...") torch.save({ 'current_iteration': self.current_iteration, 'current_step': self.current_step, 'bert_encoder': self.bert_encoder.state_dict(), 'persona_assigner': self.persona_assigner.state_dict(), 'enhanced_predictor': self.enhanced_predictor.state_dict(), 'baseline_predictor': self.baseline_predictor.state_dict(), 'optimizer': self.optimizer.state_dict(), 'scaler': self.scaler.state_dict(), }, filename) with open('training_log.json', 'w') as f: json.dump(self.training_log, f) self.dashboard.update_stats(last_save=time.strftime("%Y-%m-%d %H:%M:%S")) print("State saved successfully.") def load_state(self, filename='experiment_state.pth'): if os.path.exists(filename): print(f"Loading state from {filename}...") state = torch.load(filename) self.current_iteration = state['current_iteration'] self.current_step = state['current_step'] print(f"Loaded iteration: {self.current_iteration}, step: {self.current_step}") self.bert_encoder.load_state_dict(state['bert_encoder']) self.persona_assigner.load_state_dict(state['persona_assigner']) self.enhanced_predictor.load_state_dict(state['enhanced_predictor']) self.baseline_predictor.load_state_dict(state['baseline_predictor']) self.optimizer.load_state_dict(state['optimizer']) self.scaler.load_state_dict(state['scaler']) if os.path.exists('training_log.json'): with open('training_log.json', 'r') as f: self.training_log = json.load(f) print(f"Loaded training log with {len(self.training_log)} entries.") print("State loaded successfully.") return True else: print(f"No saved state found at {filename}.") return False def run_experiment(self, train_loader, num_iterations=500): print(f"Starting experiment. Total iterations: {num_iterations}") self.dashboard.update_stats( total_iterations=num_iterations, total_batches=len(train_loader) ) try: for iteration in range(self.current_iteration, num_iterations): print(f"Starting iteration {iteration + 1}/{num_iterations}") self.current_iteration = iteration for i, batch in enumerate(train_loader): batch = {k: v.to(self.device) for k, v in batch.items()} baseline_loss, baseline_accuracy, enhanced_loss, enhanced_accuracy = self.train_iteration(batch) self.current_step += 1 if self.current_step % self.accumulation_steps == 0: self.scaler.step(self.optimizer) self.scaler.update() self.optimizer.zero_grad() self.training_log.append({ 'iteration': iteration + 1, 'batch': i + 1, 'baseline_loss': baseline_loss, 'baseline_accuracy': baseline_accuracy, 'enhanced_loss': enhanced_loss, 'enhanced_accuracy': enhanced_accuracy, 'timestamp': time.strftime("%Y-%m-%d %H:%M:%S") }) self.dashboard.update_stats( iteration=iteration + 1, batch=i + 1, baseline_loss=baseline_loss, baseline_accuracy=baseline_accuracy, enhanced_loss=enhanced_loss, enhanced_accuracy=enhanced_accuracy ) if (i + 1) % 10 == 0: # Update every 10 batches self.dashboard.draw() print(f"Completed iteration {iteration + 1}/{num_iterations}") # Save state after each iteration self.save_state() self.dashboard.draw() # Draw dashboard after each iteration self.save_state('final_experiment_state.pth') print("Experiment completed.") except KeyboardInterrupt: print("Experiment interrupted. Saving state...") self.save_state('interrupted_experiment_state.pth') print("State saved. You can resume later by loading 'interrupted_experiment_state.pth'") except Exception as e: print(f"An error occurred: {str(e)}") self.save_state('error_experiment_state.pth') print("State saved due to error. You can resume later by loading 'error_experiment_state.pth'") raise def setup_experiment(train_data, train_labels, batch_size=4, max_length=64): from transformers import BertTokenizer print("Setting up experiment...") print("Initializing tokenizer...") tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') print("Creating dataset...") train_dataset = ChatbotDataset( train_data['prompt'].tolist(), train_data['response_a'].tolist(), train_data['response_b'].tolist(), train_labels, tokenizer, max_length=max_length ) print(f"Creating DataLoader with batch size {batch_size}...") train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) print("Initializing ComparativeExperiment...") experiment = ComparativeExperiment(batch_size=batch_size, max_length=max_length) print("Experiment setup completed.") return experiment, train_loader