Upload 17 files

datasets/clip-rcnn-attn/test_clip_rcnn_attn.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4cbb9b8b72c2d8247937828728ef60bab8e33851111a89c23eb88ae1d9e59c8
+size 23798911

datasets/clip-rcnn-attn/train_clip_rcnn_attn.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f002f6063c4f5b8999d573b12ce59700caf04aff6573a64e23c9b1091b168159
+size 22960039

datasets/clip-rcnn-attn/val_clip_rcnn_attn.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa0f76bc5caddc13b21755bab9aa90aee56b9d3dae6ebae442ea2142dffae1dc
+size 3548069

datasets/obj_feat/test_obj_feat.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00bf63d3d41aec578d5f9b39e513a3208bb6caa15d5bef709d2c0af32ce87673
+size 50525738

datasets/obj_feat/test_obj_feat_am.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df050c80857983e9c95a346d892864f39e2f04cc67a75d990a73a443c867ac6e
+size 49656750

datasets/obj_feat/train_obj_feat.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47dd3070d6fb0a409cfeed60959f3e869f28606955736ae7b0fd12646eee9bb8
+size 82895569

datasets/obj_feat/train_obj_feat_am.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3343cdd0b2fc69177ab1d374f829675634126715f7919d217b7fd611779021af
+size 43735055

datasets/obj_feat/val_obj_feat.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da3af1552bb745bd3c5023429b07b9b75737dce2f3174282f193f8d95e5cab53
+size 6994081

datasets/obj_feat/val_obj_feat_am.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:202a34593e1980ec15f110c18d20312158a6e10eea3b599679be35f07e790456
+size 6899385

datasets/train.pyy

@@ -0,0 +1,277 @@
+#######################################
+## Gated and Modal Alignment methods ##
+######################################
+
+import pickle
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader
+from transformers import BertTokenizer, BertModel
+from torch.nn.utils.rnn import pad_sequence
+from torch.cuda.amp import GradScaler, autocast
+from torch.optim.lr_scheduler import ReduceLROnPlateau, LambdaLR
+from sklearn.preprocessing import LabelEncoder
+import pandas as pd
+from tqdm import tqdm
+import os
+import matplotlib.pyplot as plt
+from torch.utils.tensorboard import SummaryWriter
+
+# Configuration
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+d_model = 2048
+batch_size = 24
+num_epochs = 30
+lr = 1e-4
+
+# Load data
+train_df = pd.read_csv('/home/amerti/Documents/MSC/VQAGen/datasets/qa/train_amharic.csv')
+val_df   = pd.read_csv('/home/amerti/Documents/MSC/VQAGen/datasets/qa/val_amahric.csv')
+test_df  = pd.read_csv('/home/amerti/Documents/MSC/VQAGen/datasets/qa/test_amharic.csv')
+
+with open('/home/amerti/Documents/MSC/VQAGen/datasets/clip-rcnn-attn/train_clip_rcnn_attn.pkl','rb') as f:
+    train_feat = pickle.load(f)
+with open('/home/amerti/Documents/MSC/VQAGen/datasets/clip-rcnn-attn/val_clip_rcnn_attn.pkl','rb') as f:
+    val_feat = pickle.load(f)
+with open('/home/amerti/Documents/MSC/VQAGen/datasets/clip-rcnn-attn/test_clip_rcnn_attn.pkl','rb') as f:
+    test_feat = pickle.load(f)
+
+with open('train_temp_spa_all_features.pkl','rb') as f:
+    train_ts = pickle.load(f)
+with open('val_temp_spa_all_features.pkl','rb') as f:
+    val_ts = pickle.load(f)
+with open('test_temp_spa_all_features.pkl','rb') as f:
+    test_ts = pickle.load(f)
+
+# Tokenizer & BERT
+tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+bert_model = BertModel.from_pretrained('bert-base-uncased').to(device).eval()
+bert_dim = bert_model.config.hidden_size
+
+# Label encoding
+le = LabelEncoder().fit(
+    pd.concat([train_df['answer'], val_df['answer'], test_df['answer']])
+)
+for df in (train_df, val_df, test_df):
+    df.dropna(subset=['question','answer'], inplace=True)
+    df['label'] = le.transform(df['answer'])
+
+class QAGraphDataset(Dataset):
+    def __init__(self, df, feat, ts, d_model, bert_dim):
+        self.df = df.reset_index(drop=True)
+        self.feat = feat
+        self.ts = ts
+        self.d_model = d_model
+        self.bert_dim = bert_dim
+
+        sample = next(iter(feat.values()))
+        self.frame_dim = sample['frame_features'][0].shape[-1]
+        self.temp_dim = 514
+        self.spat_dim = 515
+
+        self.video_proj = nn.Linear(4, d_model).to(device)
+        self.attn_proj  = nn.Linear(512, d_model).to(device)
+        self.frame_proj = nn.Linear(self.frame_dim, d_model).to(device)
+        self.temp_proj  = nn.Linear(self.temp_dim, d_model).to(device)
+        self.spat_proj  = nn.Linear(self.spat_dim, d_model).to(device)
+        self.txt_proj   = nn.Linear(bert_dim, d_model).to(device)
+
+    def __len__(self):
+        return len(self.df)
+
+    def __getitem__(self, idx):
+        row = self.df.iloc[idx]
+        vid = row['video_id']
+        ques, ans, lbl = row['question'], row['answer'], row['label']
+
+        # Visual features
+        v = torch.tensor(self.feat[vid]['video_feature'], dtype=torch.float, device=device)
+        a = torch.tensor(self.feat[vid]['attn_feature'],   dtype=torch.float, device=device)
+        fr = torch.stack([
+            torch.tensor(x, dtype=torch.float, device=device)
+            for x in self.feat[vid]['frame_features']
+        ]).mean(dim=0)
+
+        # Temporal features
+        t_data = self.ts[vid].get('temporal_features', [])
+        if t_data:
+            tem = torch.cat([
+                torch.tensor([x['displacement'] for x in t_data], device=device).mean().unsqueeze(0),
+                torch.tensor([x['emb_diff'] for x in t_data],       device=device).mean().unsqueeze(0),
+                torch.stack([torch.tensor(x['emb_from'], device=device) for x in t_data]).mean(dim=0)
+            ], dim=0).float()
+        else:
+            tem = torch.zeros(self.temp_dim, dtype=torch.float, device=device)
+
+        # Spatial features
+        s_data = self.ts[vid].get('spatial_features', [])
+        if s_data:
+            sp = torch.cat([
+                torch.tensor([x['distance'] for x in s_data],        device=device).mean().unsqueeze(0),
+                torch.tensor([x['horizontal_offset'] for x in s_data],device=device).mean().unsqueeze(0),
+                torch.tensor([x['emb_similarity'] for x in s_data],   device=device).mean().unsqueeze(0),
+                torch.stack([torch.tensor(x['obj1_emb'], device=device) for x in s_data]).mean(dim=0)
+            ], dim=0).float()
+        else:
+            sp = torch.zeros(self.spat_dim, dtype=torch.float, device=device)
+
+        # Text features
+        inp = tokenizer(
+            ques, ans, return_tensors='pt', padding=True,
+            truncation=True, max_length=512
+        ).to(device)
+        txt = bert_model(**inp).last_hidden_state.squeeze(0).float()
+
+        # Projections
+        v_p   = self.video_proj(v).unsqueeze(0)
+        a_p   = self.attn_proj(a).unsqueeze(0)
+        fr_p  = self.frame_proj(fr).unsqueeze(0)
+        t_p   = self.temp_proj(tem).unsqueeze(0)
+        sp_p  = self.spat_proj(sp).unsqueeze(0)
+        txt_p = self.txt_proj(txt)
+
+        tokens = torch.cat([txt_p, v_p, a_p, fr_p, t_p, sp_p], dim=0).float()
+        return tokens, torch.tensor(lbl, device=device)
+
+# Collate: ensure float32 dtype
+def collate_fn(batch):
+    toks, labs = zip(*batch)
+    pad = pad_sequence(toks, batch_first=True, padding_value=0.0).float()
+    return pad, torch.stack(labs)
+
+class UnifiedTransformerClassifier(nn.Module):
+    def __init__(self, d_model, num_classes, nhead=4, num_layers=2):
+        super().__init__()
+        layer = nn.TransformerEncoderLayer(
+            d_model, nhead, dim_feedforward=d_model*4, batch_first=True
+        )
+        self.encoder    = nn.TransformerEncoder(layer, num_layers)
+        self.classifier = nn.Linear(d_model, num_classes)
+
+    def forward(self, x):
+        x = x.float()
+        enc = self.encoder(x)
+        rep = enc[:, 0]
+        return self.classifier(rep)
+
+# Prepare datasets & loaders
+train_ds = QAGraphDataset(train_df, train_feat, train_ts, d_model, bert_dim)
+val_ds   = QAGraphDataset(val_df,   val_feat,   val_ts,   d_model, bert_dim)
+test_ds  = QAGraphDataset(test_df,  test_feat,  test_ts,  d_model, bert_dim)
+
+train_loader = DataLoader(train_ds, batch_size, shuffle=True, collate_fn=collate_fn)
+val_loader   = DataLoader(val_ds,   batch_size, shuffle=False, collate_fn=collate_fn)
+test_loader  = DataLoader(test_ds,  batch_size, shuffle=False, collate_fn=collate_fn)
+
+# Model, optimizer, loss, schedulers
+model   = UnifiedTransformerClassifier(d_model, len(le.classes_)).to(device)
+if torch.cuda.device_count()>1:
+    model = nn.DataParallel(model)
+opt     = torch.optim.Adam(model.parameters(), lr=lr)
+crit    = nn.CrossEntropyLoss()
+scaler  = GradScaler()
+sched   = ReduceLROnPlateau(opt, 'max', factor=0.5, patience=3, verbose=True)
+wup     = LambdaLR(opt, lambda e: (e+1)/5 if e<5 else 1.0)
+writer  = SummaryWriter()
+
+# Training & validation with unified progress bar per epoch
+train_losses, train_accs, val_losses, val_accs = [], [], [], []
+best_acc, patience_cnt = 0, 0
+epoch_bar = tqdm(range(1, num_epochs+1), desc='Epochs')
+
+for epoch in epoch_bar:
+    total_train_loss = train_correct = train_total = 0
+    total_val_loss = val_correct = val_total = 0
+
+    # Single progress bar for both training and validation
+    total_batches = len(train_loader) + len(val_loader)
+    batch_bar = tqdm(total=total_batches, desc=f'Epoch {epoch} (Train/Val)', leave=False)
+
+    # Training phase
+    model.train()
+    for x, y in train_loader:
+        if y[0] < 0:
+            batch_bar.update(1)
+            continue
+        x, y = x.to(device), y.to(device)
+        opt.zero_grad()
+        with autocast():
+            out = model(x)
+            loss = crit(out, y)
+        scaler.scale(loss).backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        scaler.step(opt)
+        scaler.update()
+        total_train_loss += loss.item() * x.size(0)
+        train_correct += (out.argmax(1) == y).sum().item()
+        train_total += y.size(0)
+        batch_bar.update(1)
+        batch_bar.set_postfix(
+            train_loss=f"{total_train_loss/train_total:.4f}",
+            train_acc=f"{100.*train_correct/train_total:.2f}%"
+        )
+
+    # Validation phase
+    model.eval()
+    with torch.no_grad():
+        for x, y in val_loader:
+            x, y = x.to(device), y.to(device)
+            out = model(x)
+            loss = crit(out, y)
+            total_val_loss += loss.item() * y.size(0)
+            val_correct += (out.argmax(1) == y).sum().item()
+            val_total += y.size(0)
+            batch_bar.update(1)
+            batch_bar.set_postfix(
+                val_loss=f"{total_val_loss/val_total:.4f}",
+                val_acc=f"{100.*val_correct/val_total:.2f}%"
+            )
+
+    batch_bar.close()
+
+    # Compute epoch metrics
+    train_loss = total_train_loss / train_total
+    train_acc = 100. * train_correct / train_total
+    val_loss = total_val_loss / val_total
+    val_acc = 100. * val_correct / val_total
+
+    # Store metrics
+    train_losses.append(train_loss)
+    train_accs.append(train_acc)
+    val_losses.append(val_loss)
+    val_accs.append(val_acc)
+
+    # Update epoch progress
+    epoch_bar.set_postfix(
+        train_loss=f"{train_loss:.4f}",
+        train_acc=f"{train_acc:.2f}%",
+        val_loss=f"{val_loss:.4f}",
+        val_acc=f"{val_acc:.2f}%"
+    )
+
+    # Schedulers & early stopping
+    if epoch < 5:
+        wup.step()
+    else:
+        sched.step(val_acc)
+    if val_acc > best_acc:
+        best_acc, patience_cnt = val_acc, 0
+        torch.save(model.state_dict(), '/kaggle/working/best.pt')
+    else:
+        patience_cnt += 1
+        if patience_cnt >= 5:
+            break
+
+# Final plot & test (remains unchanged)
+plt.figure(figsize=(12,5))
+plt.subplot(1,2,1); plt.plot(train_losses, label='Train Loss'); plt.plot(val_losses, label='Val Loss'); plt.legend()
+plt.subplot(1,2,2); plt.plot(train_accs,  label='Train Acc');  plt.plot(val_accs,  label='Val Acc');  plt.legend()
+plt.tight_layout(); plt.savefig('/kaggle/working/metrics_plot.png'); plt.close()
+
+test_acc = 0; model.eval()
+with torch.no_grad():
+    for x,y in test_loader:
+        x, y = x.to(device), y.to(device)
+        out = model(x); test_acc += (out.argmax(1)==y).sum().item()
+    test_acc = test_acc/len(test_ds)*100
+print(f"Final Test Acc: {test_acc:.2f}%")