|
|
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 |
