Upload sweep9.py with huggingface_hub

sweep9.py

@@ -0,0 +1,388 @@
+import transformers
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.utils.data import DataLoader
+import numpy as np
+import matplotlib.pyplot as plt
+import json
+from tqdm.auto import tqdm
+import random
+from scipy.signal import savgol_filter
+import wandb
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import os
+from itertools import product
+import pandas as pd
+import multiprocessing as mp
+from functools import partial
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class Config:
+    def __init__(self):
+        self.model_name = "Qwen/Qwen2-0.5B"
+        self.data_dir = "dataset_chunks"
+        self.max_length = 1024
+        self.batch_size = 32
+        self.num_seeds = 10000
+        self.num_lr_steps = 10000
+        self.min_lr = 1e-8
+        self.max_lr = 10
+        self.hidden_dim_ratio = 0.5
+        self.dropout = 0.1
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.num_workers = mp.cpu_count()
+
+class ImprovedAutoencoder(nn.Module):
+    def __init__(self, input_dim, hidden_dim, num_layers, dropout):
+        super().__init__()
+        self.encoder = nn.ModuleList([
+            nn.Linear(input_dim if i == 0 else hidden_dim, hidden_dim, dtype=torch.bfloat16)
+            for i in range(num_layers)
+        ])
+        self.decoder = nn.ModuleList([
+            nn.Linear(hidden_dim, hidden_dim if i < num_layers - 1 else input_dim, dtype=torch.bfloat16)
+            for i in range(num_layers)
+        ])
+        self.layer_norms = nn.ModuleList([
+            nn.LayerNorm(hidden_dim, dtype=torch.bfloat16)
+            for _ in range(num_layers * 2 - 1)
+        ])
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x):
+        for enc, norm in zip(self.encoder, self.layer_norms[:len(self.encoder)]):
+            x = F.relu(norm(enc(x)))
+            x = self.dropout(x)
+        for dec, norm in zip(self.decoder[:-1], self.layer_norms[len(self.encoder):]):
+            x = F.relu(norm(dec(x)))
+            x = self.dropout(x)
+        x = self.decoder[-1](x)
+        return x
+
+class TokenizedDataset(torch.utils.data.Dataset):
+    def __init__(self, file_paths):
+        self.data = []
+        for file_path in tqdm(file_paths, desc="Loading data chunks"):
+            chunk_data = torch.load(file_path)
+            logger.info(f"Loaded data from {file_path}")
+            logger.info(f"Type of loaded data: {type(chunk_data)}")
+
+            if isinstance(chunk_data, dict):  # Handle dictionary format (if present)
+                logger.info(f"Keys in the dictionary: {chunk_data.keys()}")
+                logger.info(f"Shape of input_ids: {chunk_data['input_ids'].shape}")
+                self.data.append(chunk_data)
+            elif isinstance(chunk_data, transformers.tokenization_utils_base.BatchEncoding): 
+                logger.info(f"Keys in the BatchEncoding: {chunk_data.keys()}")
+                logger.info(f"Shape of input_ids: {chunk_data['input_ids'].shape}")
+                self.data.append(chunk_data) # Handle BatchEncoding format
+            else:
+                logger.warning(f"Unexpected data type: {type(chunk_data)}")
+
+        logger.info(f"Loaded {len(self.data)} chunks of data")
+
+    def __len__(self):
+        return sum(len(chunk['input_ids']) for chunk in self.data)
+
+    def __getitem__(self, idx):
+        for chunk in self.data:
+            if idx < len(chunk['input_ids']):
+                return {k: v[idx] for k, v in chunk.items()}
+            idx -= len(chunk['input_ids'])
+        raise IndexError("Index out of range")
+
+def set_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+def load_data(config):
+    logger.info(f"Looking for data in directory: {config.data_dir}")
+    chunk_files = [f for f in os.listdir(config.data_dir) if f.endswith('_tokenized.pt')]
+    logger.info(f"Found {len(chunk_files)} chunk files: {chunk_files}")
+    
+    if not chunk_files:
+        raise ValueError(f"No tokenized data files found in {config.data_dir}")
+    
+    chunk_files.sort(key=lambda x: int(x.split('_')[1]))
+    chunk_files = [os.path.join(config.data_dir, f) for f in chunk_files]
+    
+    dataset = TokenizedDataset(chunk_files[:1])  # Load only the first chunk for now
+    logger.info(f"Created dataset with {len(dataset)} samples")
+    
+    return DataLoader(dataset, batch_size=config.batch_size, shuffle=True, num_workers=config.num_workers)
+
+def extract_hidden_states(batch, model):
+    with torch.no_grad():
+        outputs = model(**batch, output_hidden_states=True)
+    return outputs.hidden_states[0], outputs.hidden_states[-1]
+
+class KLDivergenceLoss(nn.Module):
+    def forward(self, pred, target):
+        pred = F.log_softmax(pred, dim=-1)
+        target = F.softmax(target, dim=-1)
+        return F.kl_div(pred, target, reduction='batchmean', log_target=False)
+
+def lr_finder(model, autoencoder, loss_fn, optimizer, train_loader, config):
+    model.eval()
+    autoencoder.train()
+    log_lrs, losses = [], []
+    best_loss, best_lr = float('inf'), None
+
+    pbar = tqdm(total=config.num_lr_steps, desc="LR Finder")
+    for batch_idx, batch in enumerate(train_loader):
+        if batch_idx >= config.num_lr_steps:
+            break
+
+        lr = config.min_lr * (config.max_lr / config.min_lr) ** (batch_idx / (config.num_lr_steps - 1))
+        optimizer.param_groups[0]['lr'] = lr
+
+        batch = {k: v.to(config.device) for k, v in batch.items()}
+        first_states, last_states = extract_hidden_states(batch, model)
+
+        optimizer.zero_grad()
+        reconstructed = autoencoder(first_states)
+        loss = loss_fn(reconstructed, last_states)
+        loss.backward()
+        optimizer.step()
+
+        if loss < best_loss:
+            best_loss = loss.item()
+            best_lr = lr
+
+        log_lrs.append(lr)
+        losses.append(loss.item())
+
+        pbar.update(1)
+        pbar.set_postfix({"Loss": f"{loss.item():.4f}", "LR": f"{lr:.2e}"})
+
+    pbar.close()
+    return log_lrs, losses, best_lr, best_loss
+
+def run_experiment(config, model, train_loader, num_layers, seed):
+    set_seed(seed)
+    input_dim = model.config.hidden_size
+    hidden_dim = int(input_dim * config.hidden_dim_ratio)
+    autoencoder = ImprovedAutoencoder(input_dim, hidden_dim, num_layers, config.dropout).to(config.device)
+
+    loss_fn = KLDivergenceLoss()
+    optimizer = optim.AdamW(autoencoder.parameters(), lr=config.min_lr)
+
+    log_lrs, losses = [], []
+    best_loss, best_lr = float('inf'), None
+
+    pbar = tqdm(total=config.num_lr_steps, desc=f"LR Finder (Layers: {num_layers}, Seed: {seed})")
+    for batch_idx, batch in enumerate(train_loader):
+        if batch_idx >= config.num_lr_steps:
+            break
+
+        lr = config.min_lr * (config.max_lr / config.min_lr) ** (batch_idx / (config.num_lr_steps - 1))
+        optimizer.param_groups[0]['lr'] = lr
+
+        batch = {k: v.to(config.device) for k, v in batch.items()}
+        first_states, last_states = extract_hidden_states(batch, model)
+
+        optimizer.zero_grad()
+        reconstructed = autoencoder(first_states)
+        loss = loss_fn(reconstructed, last_states)
+        loss.backward()
+        optimizer.step()
+
+        if loss < best_loss:
+            best_loss = loss.item()
+            best_lr = lr
+
+        log_lrs.append(lr)
+        losses.append(loss.item())
+
+        # Log to wandb at every step
+        wandb.log({
+            "loss": loss.item(),
+            "lr": lr,
+            "batch_idx": batch_idx,
+            "num_layers": num_layers,
+            "seed": seed,
+            "best_loss": best_loss,
+            "best_lr": best_lr
+        })
+
+        pbar.update(1)
+        pbar.set_postfix({"Loss": f"{loss.item():.4f}", "LR": f"{lr:.2e}"})
+
+    pbar.close()
+
+    result = {
+        'seed': seed,
+        'num_layers': num_layers,
+        'hidden_dim_ratio': config.hidden_dim_ratio,
+        'dropout': config.dropout,
+        'final_loss': losses[-1],
+        'final_lr': log_lrs[-1],
+        'best_lr': best_lr,
+        'best_loss': best_loss
+    }
+
+    logger.info(f"Experiment completed: {result}")
+    return result
+
+def main():
+    config = Config()
+    wandb.init(project="qwen-autoencoder-lr-finder", config=config.__dict__)
+
+    logger.info("Loading Qwen model and tokenizer...")
+    model = AutoModelForCausalLM.from_pretrained(config.model_name, torch_dtype=torch.bfloat16).to(config.device)
+    tokenizer = AutoTokenizer.from_pretrained(config.model_name)
+
+    logger.info("Loading data...")
+    train_loader = load_data(config)
+
+    logger.info("Starting experiments...")
+    results = []
+    for num_layers in range(4, 9):
+        for seed in range(1, config.num_seeds + 1):
+            # Start a new wandb run for each experiment
+            with wandb.init(project="qwen-autoencoder-lr-finder", 
+                            config=config.__dict__, 
+                            group=f"layers_{num_layers}",
+                            name=f"seed_{seed}",
+                            job_type="experiment",
+                            reinit=True):
+                
+                result = run_experiment(config, model, train_loader, num_layers, seed)
+                results.append(result)
+                
+                # Save results after each experiment
+                with open('lr_finder_results.jsonl', 'a') as f:
+                    json.dump(result, f)
+                    f.write('\n')
+                
+                # Log final results to wandb
+                wandb.log(result)
+
+    logger.info("Creating visualizations...")
+    plot_results(results)
+    create_heatmap(results)
+    create_parallel_coordinates_plot(results)
+    create_3d_scatter(results)
+
+    logger.info("Experiment completed. Check WandB for detailed results and visualizations.")
+
+if __name__ == "__main__":
+    main()
+def run_experiments_sequential(config, model, train_loader):
+    results = []
+    for num_layers in tqdm(range(4, 9), desc="Number of Layers"):
+        for seed in tqdm(range(1, config.num_seeds + 1), desc="Seeds", leave=False):
+            result = run_experiment(config, model, train_loader, num_layers, seed)
+            results.append(result)
+    return results
+
+def plot_results(results):
+    fig, axs = plt.subplots(3, 2, figsize=(20, 30))
+    fig.suptitle('Learning Rate Finder Results')
+
+    for i, num_layers in enumerate(range(4, 9)):
+        layer_results = [r for r in results if r['num_layers'] == num_layers]
+        best_lrs = [r['Best'] for r in layer_results]
+        best_losses = [r['best_loss'] for r in layer_results]
+
+        axs[i // 2, i % 2].scatter(best_lrs, best_losses, alpha=0.5)
+        axs[i // 2, i % 2].set_xlabel('Best Learning Rate')
+        axs[i // 2, i % 2].set_ylabel('Best Loss')
+        axs[i // 2, i % 2].set_title(f'{num_layers} Layers')
+        axs[i // 2, i % 2].set_xscale('log')
+        axs[i // 2, i % 2].set_yscale('log')
+
+    plt.tight_layout()
+    wandb.log({"lr_loss_relationships": wandb.Image(plt)})
+    plt.close()
+
+def create_heatmap(results):
+    layer_counts = len(set(r['num_layers'] for r in results))
+    seed_counts = len(set(r['seed'] for r in results))
+    
+    heatmap_data = np.zeros((layer_counts, seed_counts))
+    for r in results:
+        layer_idx = r['num_layers'] - 4
+        seed_idx = r['seed'] - 1
+        heatmap_data[layer_idx, seed_idx] = r['best_loss']
+    
+    plt.figure(figsize=(20, 10))
+    plt.imshow(heatmap_data, aspect='auto', cmap='viridis')
+    plt.colorbar(label='Best Loss')
+    plt.xlabel('Seed')
+    plt.ylabel('Number of Layers')
+    plt.title('Heatmap of Best Loss across Layers and Seeds')
+    plt.tight_layout()
+    wandb.log({"loss_heatmap": wandb.Image(plt)})
+    plt.close()
+
+def create_parallel_coordinates_plot(results):
+    df = pd.DataFrame(results)
+    
+    plt.figure(figsize=(20, 10))
+    pd.plotting.parallel_coordinates(df, 'num_layers', colormap='viridis')
+    plt.title('Parallel Coordinates Plot of Hyperparameters')
+    plt.tight_layout()
+    wandb.log({"parallel_coordinates": wandb.Image(plt)})
+    plt.close()
+
+def create_3d_scatter(results):
+    fig = plt.figure(figsize=(15, 15))
+    ax = fig.add_subplot(111, projection='3d')
+    
+    for num_layers in range(4, 9):
+        layer_results = [r for r in results if r['num_layers'] == num_layers]
+        x = [r['Best'] for r in layer_results]
+        y = [r['best_loss'] for r in layer_results]
+        z = [r['seed'] for r in layer_results]
+        ax.scatter(x, y, z, label=f'{num_layers} Layers')
+    
+    ax.set_xlabel('Best Learning Rate')
+    ax.set_ylabel('Best Loss')
+    ax.set_zlabel('Seed')
+    ax.set_xscale('log')
+    ax.set_yscale('log')
+    ax.legend()
+    plt.title('3D Scatter Plot of Best LR, Loss, and Seed')
+    plt.tight_layout()
+    wandb.log({"3d_scatter": wandb.Image(plt)})
+    plt.close()
+
+def main():
+    mp.set_start_method('spawn')
+    config = Config()
+    wandb.init(project="qwen-autoencoder-lr-finder", config=config.__dict__)
+
+    logger.info("Loading Qwen model and tokenizer...")
+    model = AutoModelForCausalLM.from_pretrained(config.model_name, torch_dtype=torch.bfloat16).to(config.device)
+    tokenizer = AutoTokenizer.from_pretrained(config.model_name)
+
+    logger.info("Loading data...")
+    train_loader = load_data(config)
+
+    logger.info("Starting experiments...")
+    results = run_experiments_sequential(config, model, train_loader)
+
+    logger.info("Saving results...")
+    with open('lr_finder_results.jsonl', 'w') as f:
+        for result in results:
+            json.dump(result, f)
+            f.write('\n')
+
+    logger.info("Creating visualizations...")
+    plot_results(results)
+    create_heatmap(results)
+    create_parallel_coordinates_plot(results)
+    create_3d_scatter(results)
+
+    logger.info("Experiment completed. Check WandB for detailed results and visualizations.")
+    wandb.finish()
+
+if __name__ == "__main__":
+    main()