added attention model also

app.py

@@ -7,75 +7,46 @@ np.random.seed(42)
 random.seed(42)
 
 # =========================
-# 1. SAFE DOWNLOAD
+# 1. IMPORTS
 # =========================
-import os, requests, zipfile, time
+import os, pandas as pd, librosa
+import torch.nn as nn
+from tqdm import tqdm
+from transformers import AutoTokenizer, AutoModel
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import accuracy_score, f1_score
+from sklearn.ensemble import RandomForestClassifier
 
-def safe_download(url, path):
-    if os.path.exists(path):
-        return
-    for _ in range(3):
-        try:
-            r = requests.get(url, stream=True, timeout=60)
-            with open(path, "wb") as f:
-                for chunk in r.iter_content(8192):
-                    if chunk:
-                        f.write(chunk)
-            return
-        except:
-            time.sleep(3)
-    raise Exception("Download failed")
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 # =========================
 # 2. LOAD LABELS
 # =========================
-import pandas as pd
-
 def load_split(csv_file):
     df = pd.read_csv(csv_file)
     df.columns = df.columns.str.strip()
     split = {}
+
     for _, row in df.iterrows():
         try:
             pid = str(int(row["Participant_ID"]))
             split[pid] = int(row["PHQ8_Binary"])
         except:
             continue
+
     return split
 
 train_labels = load_split("train_split_Depression_AVEC2017.csv")
 dev_labels = load_split("dev_split_Depression_AVEC2017.csv")
 
-REQUIRED_IDS = set(list(train_labels.keys()) + list(dev_labels.keys()))
-
 # =========================
-# 3. DOWNLOAD + EXTRACT
+# 3. GET DATA PATHS
 # =========================
-urls = [
-    "https://huggingface.co/datasets/ananyakarn/DAIC_WOZ_Data/resolve/main/DAIC_WOZ_Data.zip",
-    "https://huggingface.co/datasets/ananyakarn/DAIC_WOZ_Data/resolve/main/DAIC_WOZ_Data-2.zip"
-]
-
-os.makedirs("data", exist_ok=True)
+DATA_PATH = "data"  # 🔥 IMPORTANT: upload dataset manually here
 
-if len(os.listdir("data")) == 0:
-    for i, url in enumerate(urls):
-        zip_path = f"temp_{i}.zip"
-        safe_download(url, zip_path)
-
-        with zipfile.ZipFile(zip_path, "r") as z:
-            for file in z.namelist():
-                if any(pid in file for pid in REQUIRED_IDS):
-                    z.extract(file, "data")
-
-        os.remove(zip_path)
-
-# =========================
-# 4. GET PATHS
-# =========================
 def get_paths():
     paths = []
-    for root, dirs, _ in os.walk("data"):
+    for root, dirs, _ in os.walk(DATA_PATH):
         for d in dirs:
             if "_P" in d or "_C" in d:
                 paths.append(os.path.join(root, d))
@@ -83,39 +54,23 @@ def get_paths():
 
 ALL_PATHS = get_paths()
 
-# ✅ FILTER VALID PARTICIPANTS (IMPORTANT FIX)
+# Filter valid IDs only
 ALL_PATHS = [
     p for p in ALL_PATHS
-    if os.path.basename(p).split("_")[0] in REQUIRED_IDS
+    if os.path.basename(p).split("_")[0] in set(train_labels) | set(dev_labels)
 ]
 
-print("Usable participants:", len(ALL_PATHS))
-
-if len(ALL_PATHS) < 10:
-    raise Exception("Too few participants extracted!")
-
-# =========================
-# 5. LIBRARIES
-# =========================
-import librosa
-import torch.nn as nn
-from tqdm import tqdm
-from transformers import AutoTokenizer, AutoModel
-from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import accuracy_score, f1_score
-from sklearn.ensemble import RandomForestClassifier
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print("Total usable participants:", len(ALL_PATHS))
 
 # =========================
-# 6. BERT
+# 4. LOAD BERT
 # =========================
 tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
 bert = AutoModel.from_pretrained("distilbert-base-uncased").to(device)
 bert.eval()
 
 # =========================
-# 7. FEATURES
+# 5. FEATURE FUNCTIONS
 # =========================
 def load_text(folder):
     try:
@@ -133,22 +88,26 @@ def get_text_embedding(text):
                        truncation=True, padding=True, max_length=128).to(device)
     with torch.no_grad():
         out = bert(**inputs)
+
     return out.last_hidden_state.mean(dim=1).squeeze().cpu().numpy()
 
 def get_audio(folder):
     try:
         file = [f for f in os.listdir(folder) if f.endswith("_AUDIO.wav")][0]
         y, sr = librosa.load(os.path.join(folder, file), sr=16000)
-        return np.mean(librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40).T, axis=0)
+        mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40)
+        return np.mean(mfcc.T, axis=0)
     except:
         return np.zeros(40)
 
 def get_visual(folder):
     feats = []
+
     for key in ["AUs", "pose", "gaze"]:
         try:
             file = [f for f in os.listdir(folder) if key in f][0]
             df = pd.read_csv(os.path.join(folder, file))
+
             df = df.select_dtypes(include=[np.number])
             df.replace(-100, np.nan, inplace=True)
             df.fillna(0, inplace=True)
@@ -156,16 +115,18 @@ def get_visual(folder):
             feats.append(np.concatenate([df.mean().values, df.std().values]))
         except:
             feats.append(np.zeros(20))
+
     return np.concatenate(feats)
 
 # =========================
-# 8. BUILD DATA
+# 6. BUILD DATASET
 # =========================
 def build(labels):
     Xt, Xa, Xv, y = [], [], [], []
 
     for p in tqdm(ALL_PATHS):
         pid = os.path.basename(p).split("_")[0]
+
         if pid not in labels:
             continue
 
@@ -182,12 +143,8 @@ Xt_test, Xa_test, Xv_test, y_test = build(dev_labels)
 print("Train size:", len(y_train))
 print("Test size:", len(y_test))
 
-# ✅ SAFETY CHECK
-if len(set(y_train)) < 2 or len(set(y_test)) < 2:
-    raise Exception("Dataset has only one class!")
-
 # =========================
-# 9. NORMALIZATION
+# 7. NORMALIZATION
 # =========================
 sc_t, sc_a, sc_v = StandardScaler(), StandardScaler(), StandardScaler()
 
@@ -200,12 +157,18 @@ Xa_test = sc_a.transform(Xa_test)
 Xv_test = sc_v.transform(Xv_test)
 
 # =========================
-# 10. RANDOM FOREST
+# 8. RANDOM FOREST (IMPROVED)
 # =========================
-X_train_rf = np.concatenate([Xt, Xa, Xv], axis=1)
-X_test_rf = np.concatenate([Xt_test, Xa_test, Xv_test], axis=1)
+Xt_rf = Xt[:, :128]
+Xv_rf = Xv[:, :50]
 
-rf = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
+Xt_test_rf = Xt_test[:, :128]
+Xv_test_rf = Xv_test[:, :50]
+
+X_train_rf = np.concatenate([Xt_rf, Xa, Xv_rf], axis=1)
+X_test_rf = np.concatenate([Xt_test_rf, Xa_test, Xv_test_rf], axis=1)
+
+rf = RandomForestClassifier(n_estimators=200, max_depth=5, random_state=42)
 
 print("\nTraining Random Forest...")
 rf.fit(X_train_rf, y_train)
@@ -216,60 +179,115 @@ rf_acc = accuracy_score(y_test, rf_preds)
 rf_f1 = f1_score(y_test, rf_preds)
 
 # =========================
-# 11. TORCH MODEL
+# 9. TORCH DATA
 # =========================
-Xt = torch.tensor(Xt, dtype=torch.float32).to(device)
-Xa = torch.tensor(Xa, dtype=torch.float32).to(device)
-Xv = torch.tensor(Xv, dtype=torch.float32).to(device)
+Xt_t = torch.tensor(Xt, dtype=torch.float32).to(device)
+Xa_t = torch.tensor(Xa, dtype=torch.float32).to(device)
+Xv_t = torch.tensor(Xv, dtype=torch.float32).to(device)
 yt = torch.tensor(y_train, dtype=torch.float32).to(device)
 
-Xt_test = torch.tensor(Xt_test, dtype=torch.float32).to(device)
-Xa_test = torch.tensor(Xa_test, dtype=torch.float32).to(device)
-Xv_test = torch.tensor(Xv_test, dtype=torch.float32).to(device)
+Xt_test_t = torch.tensor(Xt_test, dtype=torch.float32).to(device)
+Xa_test_t = torch.tensor(Xa_test, dtype=torch.float32).to(device)
+Xv_test_t = torch.tensor(Xv_test, dtype=torch.float32).to(device)
 
-class Simple(nn.Module):
+# =========================
+# 10. MODELS
+# =========================
+class SimpleNN(nn.Module):
     def __init__(self, v):
         super().__init__()
         self.net = nn.Sequential(
             nn.Linear(768+40+v,128),
             nn.ReLU(),
+            nn.Dropout(0.3),
             nn.Linear(128,1)
         )
-
     def forward(self,t,a,v):
         return self.net(torch.cat([t,a,v],1))
 
-model = Simple(Xv.shape[1]).to(device)
+class AttentionModel(nn.Module):
+    def __init__(self, v):
+        super().__init__()
+        self.t = nn.Sequential(nn.Linear(768,128), nn.ReLU())
+        self.a = nn.Sequential(nn.Linear(40,32), nn.ReLU())
+        self.v = nn.Sequential(nn.Linear(v,64), nn.ReLU())
+
+        self.attn = nn.Sequential(
+            nn.Linear(224,64),
+            nn.Tanh(),
+            nn.Linear(64,3)
+        )
+
+        self.final = nn.Sequential(
+            nn.Linear(224,64),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(64,1)
+        )
+
+    def forward(self,t,a,v):
+        t_feat = self.t(t)
+        a_feat = self.a(a)
+        v_feat = self.v(v)
+
+        combined = torch.cat([t_feat,a_feat,v_feat],1)
+        weights = torch.softmax(self.attn(combined), dim=1)
+
+        fused = torch.cat([
+            weights[:,0:1]*t_feat,
+            weights[:,1:2]*a_feat,
+            weights[:,2:3]*v_feat
+        ],1)
+
+        return self.final(fused)
+
+# =========================
+# 11. TRAIN MODELS
+# =========================
+baseline = SimpleNN(Xv.shape[1]).to(device)
+attention = AttentionModel(Xv.shape[1]).to(device)
+
+opt1 = torch.optim.Adam(baseline.parameters(), lr=1e-4)
+opt2 = torch.optim.AdamW(attention.parameters(), lr=1e-4)
 
-opt = torch.optim.Adam(model.parameters(), lr=1e-4)
 loss_fn = nn.BCEWithLogitsLoss()
 
-print("\nTraining Neural Model...")
+print("\nTraining Baseline NN...")
+for e in range(5):
+    opt1.zero_grad()
+    loss = loss_fn(baseline(Xt_t,Xa_t,Xv_t).squeeze(), yt)
+    loss.backward()
+    opt1.step()
+    print(f"Epoch {e+1}, Loss: {loss.item():.4f}")
 
-for epoch in range(5):
-    opt.zero_grad()
-    loss = loss_fn(model(Xt,Xa,Xv).squeeze(), yt)
+print("\nTraining Attention Model...")
+for e in range(5):
+    opt2.zero_grad()
+    loss = loss_fn(attention(Xt_t,Xa_t,Xv_t).squeeze(), yt)
     loss.backward()
-    opt.step()
-    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
+    opt2.step()
+    print(f"Epoch {e+1}, Loss: {loss.item():.4f}")
 
 # =========================
 # 12. EVALUATION
 # =========================
 with torch.no_grad():
-    preds = (torch.sigmoid(
-        model(Xt_test,Xa_test,Xv_test).squeeze()
-    ) > 0.5).int().cpu().numpy()
+    pred_base = (torch.sigmoid(baseline(Xt_test_t,Xa_test_t,Xv_test_t).squeeze())>0.5).int().cpu().numpy()
+    pred_attn = (torch.sigmoid(attention(Xt_test_t,Xa_test_t,Xv_test_t).squeeze())>0.5).int().cpu().numpy()
 
 # =========================
 # 13. RESULTS
 # =========================
-print("\n===== FINAL RESULTS =====")
+print("\n===== FINAL COMPARISON =====")
 
 print("\nRandom Forest:")
 print("Accuracy:", rf_acc)
 print("F1:", rf_f1)
 
-print("\nNeural Model:")
-print("Accuracy:", accuracy_score(y_test, preds))
-print("F1:", f1_score(y_test, preds))
+print("\nBaseline NN:")
+print("Accuracy:", accuracy_score(y_test, pred_base))
+print("F1:", f1_score(y_test, pred_base))
+
+print("\nAttention Model:")
+print("Accuracy:", accuracy_score(y_test, pred_attn))
+print("F1:", f1_score(y_test, pred_attn))