| | 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: |
| | 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: |
| | self.dashboard.draw() |
| |
|
| | print(f"Completed iteration {iteration + 1}/{num_iterations}") |
| | |
| | self.save_state() |
| | self.dashboard.draw() |
| |
|
| | 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 |
