|
|
|
|
|
|
|
|
|
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.
|
|
"""
|
|
|
|
|
|
|
|
|
|
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
|
|
hidden_size = 768
|
|
num_heads = 12
|
|
|
|
|
|
|
|
|
|
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
|
|
)
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
|
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
|
|
)
|
|
|
|
|
|
|
|
|
|
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}")
|
|
|
|
|
|
|
|
|
|
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
|
|
} |
