files updation

gem_trainer.py

@@ -0,0 +1,248 @@
+# ================================================
+# GEM Model Trainer & Evaluator - Callable Version
+# ================================================
+
+import torch
+import torch.quantization
+from transformers import AutoTokenizer, AutoModel, AutoModelForSequenceClassification, get_linear_schedule_with_warmup
+from sklearn.cluster import MiniBatchKMeans
+from torch.utils.data import DataLoader
+import torch.nn as nn
+import torch.nn.functional as F
+from tqdm import tqdm
+import numpy as np
+
+def run_gem_pipeline(
+    dataset,
+    model_name="bert-base-uncased",
+    num_classes=77,
+    num_epochs=3,
+    batch_size=16,
+    learning_rate=2e-5,
+    max_seq_length=128,
+    gradient_accum_steps=2,
+    cluster_size=256,
+    threshold=0.65
+):
+    """
+    Runs the GEM model training & evaluation pipeline on a custom dataset.
+    
+    Args:
+        dataset: HuggingFace DatasetDict or custom dataset (must have 'train' and 'test').
+        model_name: Name of the transformer model.
+        num_classes: Number of output classes.
+        num_epochs: Training epochs.
+        batch_size: Batch size for dataloaders.
+        learning_rate: Learning rate for optimizer.
+        max_seq_length: Max sequence length for tokenizer.
+        gradient_accum_steps: Gradient accumulation steps.
+        cluster_size: Number of clusters for routing.
+        threshold: Routing threshold.
+        
+    Returns:
+        final_accuracy: Final evaluation accuracy on test set.
+        avg_loss: Average training loss.
+    """
+    
+    # ========================
+    # Config
+    # ========================
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    hidden_size = 768
+    num_heads = 12
+
+    # ========================
+    # Tokenizer & Dataloaders
+    # ========================
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+    def tokenize_fn(examples):
+        return tokenizer(
+            examples['text'],
+            padding='max_length',
+            truncation=True,
+            max_length=max_seq_length
+        )
+
+    dataset = dataset.map(tokenize_fn, batched=True)
+
+    def collate_fn(batch):
+        return {
+            'input_ids': torch.stack([torch.tensor(x['input_ids']) for x in batch]),
+            'attention_mask': torch.stack([torch.tensor(x['attention_mask']) for x in batch]),
+            'labels': torch.tensor([x['label'] for x in batch])
+        }
+
+    train_loader = DataLoader(
+        dataset['train'],
+        batch_size=batch_size,
+        shuffle=True,
+        collate_fn=collate_fn
+    )
+
+    test_loader = DataLoader(
+        dataset['test'],
+        batch_size=batch_size,
+        collate_fn=collate_fn
+    )
+
+    # ========================
+    # GEM Model (Modular)
+    # ========================
+    class QuantizedBERT(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.bert = AutoModel.from_pretrained(model_name)
+            self.quant = torch.quantization.QuantStub()
+            self.dequant = torch.quantization.DeQuantStub()
+
+        def forward(self, input_ids, attention_mask=None):
+            outputs = self.bert(input_ids, attention_mask=attention_mask)
+            return self.dequant(self.quant(outputs.last_hidden_state))
+
+    class TokenRouter(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.clusterer = MiniBatchKMeans(n_clusters=cluster_size)
+            self.W_r = nn.Parameter(torch.randn(num_classes, hidden_size))
+            self.threshold = threshold
+
+        def forward(self, x):
+            cluster_input = x.detach().cpu().numpy().reshape(-1, x.shape[-1])
+            cluster_ids = self.clusterer.fit_predict(cluster_input)
+            cluster_ids = torch.tensor(cluster_ids, device=device).reshape(x.shape[:2])
+
+            domain_logits = torch.einsum('bsh,nh->bsn', x, self.W_r.to(x.device))
+            domain_probs = F.softmax(domain_logits, dim=-1)
+            routing_mask = (domain_probs.max(-1).values > self.threshold).long()
+
+            return domain_probs, routing_mask, cluster_ids
+
+    class SCAR(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.num_heads = num_heads
+            self.head_dim = hidden_size // num_heads
+            self.qkv = nn.Linear(hidden_size, 3 * hidden_size)
+            self.out = nn.Linear(hidden_size, hidden_size)
+
+        def create_mask(self, cluster_ids, routing_mask):
+            cluster_mask = (cluster_ids.unsqueeze(-1) == cluster_ids.unsqueeze(-2))
+            domain_mask = (routing_mask.unsqueeze(-1) == routing_mask.unsqueeze(-2))
+            return cluster_mask | domain_mask
+
+        def forward(self, x, cluster_ids, routing_mask):
+            B, N, _ = x.shape
+            qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+            q, k, v = qkv[0], qkv[1], qkv[2]
+
+            attn = (q @ k.transpose(-2, -1)) / np.sqrt(self.head_dim)
+            mask = self.create_mask(cluster_ids, routing_mask).unsqueeze(1)
+            attn = attn.masked_fill(~mask, -1e9)
+
+            attn = F.softmax(attn, dim=-1)
+            x = (attn @ v).transpose(1, 2).reshape(B, N, -1)
+            return self.out(x)
+
+    class GEM(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.bert = QuantizedBERT()
+            self.router = TokenRouter()
+            self.scar = SCAR()
+            self.classifier = nn.Linear(hidden_size, num_classes)
+
+            self.teacher = AutoModelForSequenceClassification.from_pretrained(
+                model_name, num_labels=num_classes
+            ).eval().to(device).requires_grad_(False)
+
+        def forward(self, input_ids, attention_mask=None):
+            x = self.bert(input_ids, attention_mask)
+            domain_probs, routing_mask, cluster_ids = self.router(x)
+            x = self.scar(x, cluster_ids, routing_mask)
+            return self.classifier(x[:, 0, :])
+
+        def qakp_loss(self, outputs, labels, input_ids):
+            task_loss = F.cross_entropy(outputs, labels)
+            quant_error = F.mse_loss(self.bert.quant(self.bert.dequant(outputs)), outputs)
+
+            with torch.no_grad():
+                teacher_logits = self.teacher(input_ids).logits
+
+            kd_loss = F.kl_div(
+                F.log_softmax(outputs, dim=-1),
+                F.softmax(teacher_logits, dim=-1),
+                reduction='batchmean'
+            )
+
+            return task_loss + 0.3 * quant_error + 0.7 * kd_loss
+
+    # ========================
+    # Training Setup
+    # ========================
+    model = GEM().to(device)
+
+    if torch.cuda.device_count() > 1:
+        model = nn.DataParallel(model, device_ids=list(range(torch.cuda.device_count())))
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
+    scheduler = get_linear_schedule_with_warmup(
+        optimizer,
+        num_warmup_steps=100,
+        num_training_steps=len(train_loader) * num_epochs
+    )
+
+    # ========================
+    # Training Loop
+    # ========================
+    model.train()
+    avg_loss = 0
+
+    for epoch in range(num_epochs):
+        total_loss = 0
+
+        for step, batch in enumerate(tqdm(train_loader)):
+            input_ids = batch['input_ids'].to(device)
+            attention_mask = batch['attention_mask'].to(device)
+            labels = batch['labels'].to(device)
+
+            outputs = model(input_ids, attention_mask)
+            loss = model.module.qakp_loss(outputs, labels, input_ids) if hasattr(model, 'module') else model.qakp_loss(outputs, labels, input_ids)
+
+            loss.backward()
+
+            if (step + 1) % gradient_accum_steps == 0:
+                optimizer.step()
+                scheduler.step()
+                optimizer.zero_grad()
+
+            total_loss += loss.item()
+
+        avg_loss = total_loss / len(train_loader)
+        print(f"Epoch {epoch+1}/{num_epochs} | Avg Loss: {avg_loss:.4f}")
+
+    # ========================
+    # Evaluation Loop
+    # ========================
+    model.eval()
+    correct = total = 0
+
+    with torch.no_grad():
+        for batch in tqdm(test_loader):
+            input_ids = batch['input_ids'].to(device)
+            attention_mask = batch['attention_mask'].to(device)
+            labels = batch['labels'].to(device)
+
+            outputs = model(input_ids, attention_mask)
+            preds = outputs.argmax(dim=-1)
+
+            correct += (preds == labels).sum().item()
+            total += labels.size(0)
+
+    final_accuracy = 100 * correct / total
+    print(f"Final Accuracy: {final_accuracy:.2f}%")
+
+    return {
+        'accuracy': final_accuracy,
+        'average_loss': avg_loss
+    }

requirements.txt

@@ -0,0 +1,6 @@
+torch
+transformers
+scikit-learn
+tqdm
+numpy
+datasets