fixed 3 issues

app.py

@@ -51,34 +51,29 @@ from sklearn.metrics import accuracy_score, f1_score
 from sklearn.preprocessing import StandardScaler
 
 # =========================
-# 4. LOAD LABELS (CORRECT)
+# 4. LOAD LABELS + SPLITS
 # =========================
-def load_labels():
-    df_train = pd.read_csv("train_split_Depression_AVEC2017.csv")
-    df_dev = pd.read_csv("dev_split_Depression_AVEC2017.csv")
-
-    df = pd.concat([df_train, df_dev])
-
-    # Clean column names
+def load_split(csv_file):
+    df = pd.read_csv(csv_file)
     df.columns = df.columns.str.strip()
 
-    labels = {}
+    split = {}
 
     for _, row in df.iterrows():
         try:
             pid = str(int(row["Participant_ID"]))
-
-            # ✅ FINAL LABEL
             label = int(row["PHQ8_Binary"])
-
-            labels[pid] = label
+            split[pid] = label
         except:
             continue
 
-    print("Total labels loaded:", len(labels))
-    return labels
+    return split
+
+train_labels = load_split("train_split_Depression_AVEC2017.csv")
+dev_labels = load_split("dev_split_Depression_AVEC2017.csv")
 
-labels_dict = load_labels()
+print("Train samples:", len(train_labels))
+print("Dev samples:", len(dev_labels))
 
 # =========================
 # 5. LOAD TEXT MODEL
@@ -138,80 +133,108 @@ def get_visual_features(folder_path):
     return np.concatenate(features)
 
 # =========================
-# 7. BUILD DATASET
+# 7. BUILD TRAIN + TEST SET
 # =========================
-print("\nBuilding dataset...")
+def build_dataset(label_dict):
+    X_text, X_audio, X_visual, y = [], [], [], []
 
-all_folders = [
-    f for f in os.listdir(DATA_PATH)
-    if os.path.isdir(os.path.join(DATA_PATH, f))
-]
+    for folder in os.listdir(DATA_PATH):
+        folder_path = os.path.join(DATA_PATH, folder)
 
-data = []
-used_folders = []
+        if not os.path.isdir(folder_path):
+            continue
 
-for folder in tqdm(all_folders):
-    pid = folder.split("_")[0]
+        pid = folder.split("_")[0]
 
-    if pid not in labels_dict:
-        continue
+        if pid not in label_dict:
+            continue
 
-    folder_path = os.path.join(DATA_PATH, folder)
+        text = load_text(folder_path)
+        X_text.append(get_text_embedding(text))
+        X_audio.append(get_audio_features(folder_path))
+        X_visual.append(get_visual_features(folder_path))
+        y.append(label_dict[pid])
 
-    text = load_text(folder_path)
-    text_feat = get_text_embedding(text)
-    audio_feat = get_audio_features(folder_path)
-    visual_feat = get_visual_features(folder_path)
+    return np.array(X_text), np.array(X_audio), np.array(X_visual), np.array(y)
 
-    combined = np.concatenate([text_feat, audio_feat, visual_feat])
-    label = labels_dict[pid]
+print("\nBuilding train set...")
+X_text_train, X_audio_train, X_visual_train, y_train = build_dataset(train_labels)
 
-    data.append((combined, label))
-    used_folders.append(folder)
+print("Building dev set...")
+X_text_test, X_audio_test, X_visual_test, y_test = build_dataset(dev_labels)
 
-print("Total valid samples:", len(data))
+print("Train size:", len(y_train))
+print("Test size:", len(y_test))
 
 # =========================
-# 8. PREPARE DATA
+# 8. NORMALIZATION
 # =========================
-X = np.array([d[0] for d in data])
-y = np.array([d[1] for d in data])
+scaler_text = StandardScaler()
+scaler_audio = StandardScaler()
+scaler_visual = StandardScaler()
 
-scaler = StandardScaler()
-X = scaler.fit_transform(X)
+X_text_train = scaler_text.fit_transform(X_text_train)
+X_audio_train = scaler_audio.fit_transform(X_audio_train)
+X_visual_train = scaler_visual.fit_transform(X_visual_train)
 
-split = int(0.7 * len(X))
-X_train, X_test = X[:split], X[split:]
-y_train, y_test = y[:split], y[split:]
+X_text_test = scaler_text.transform(X_text_test)
+X_audio_test = scaler_audio.transform(X_audio_test)
+X_visual_test = scaler_visual.transform(X_visual_test)
 
 # =========================
-# 9. MODEL
+# 9. MULTIMODAL MODEL (CORRECT)
 # =========================
-class MultiModalNN(nn.Module):
-    def __init__(self, input_dim):
+class MultiModalModel(nn.Module):
+    def __init__(self):
         super().__init__()
-        self.net = nn.Sequential(
-            nn.Linear(input_dim, 256),
+
+        # modality-specific encoders
+        self.text_net = nn.Sequential(
+            nn.Linear(768, 128),
+            nn.ReLU()
+        )
+
+        self.audio_net = nn.Sequential(
+            nn.Linear(40, 32),
+            nn.ReLU()
+        )
+
+        self.visual_net = nn.Sequential(
+            nn.Linear(X_visual_train.shape[1], 64),
+            nn.ReLU()
+        )
+
+        # fusion
+        self.fusion = nn.Sequential(
+            nn.Linear(128 + 32 + 64, 64),
             nn.ReLU(),
             nn.Dropout(0.3),
-            nn.Linear(256, 64),
-            nn.ReLU(),
             nn.Linear(64, 1)
         )
 
-    def forward(self, x):
-        return self.net(x)
+    def forward(self, t, a, v):
+        t = self.text_net(t)
+        a = self.audio_net(a)
+        v = self.visual_net(v)
+
+        x = torch.cat([t, a, v], dim=1)
+        return self.fusion(x)
 
-model = MultiModalNN(X.shape[1]).to(device)
+model = MultiModalModel().to(device)
 
 optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
 criterion = nn.BCEWithLogitsLoss()
 
-X_train_t = torch.tensor(X_train, dtype=torch.float32).to(device)
-y_train_t = torch.tensor(y_train, dtype=torch.float32).to(device)
+# tensors
+Xt = torch.tensor(X_text_train, dtype=torch.float32).to(device)
+Xa = torch.tensor(X_audio_train, dtype=torch.float32).to(device)
+Xv = torch.tensor(X_visual_train, dtype=torch.float32).to(device)
+yt = torch.tensor(y_train, dtype=torch.float32).to(device)
 
-X_test_t = torch.tensor(X_test, dtype=torch.float32).to(device)
-y_test_t = torch.tensor(y_test, dtype=torch.float32).to(device)
+Xt_test = torch.tensor(X_text_test, dtype=torch.float32).to(device)
+Xa_test = torch.tensor(X_audio_test, dtype=torch.float32).to(device)
+Xv_test = torch.tensor(X_visual_test, dtype=torch.float32).to(device)
+yt_test = torch.tensor(y_test, dtype=torch.float32).to(device)
 
 # =========================
 # 10. TRAIN
@@ -222,30 +245,23 @@ for epoch in range(10):
     model.train()
 
     optimizer.zero_grad()
-    outputs = model(X_train_t).squeeze()
-    loss = criterion(outputs, y_train_t)
+    outputs = model(Xt, Xa, Xv).squeeze()
+    loss = criterion(outputs, yt)
 
     loss.backward()
     optimizer.step()
 
     print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
 
-print("Model ready!")
-
 # =========================
-# 11. EVALUATION
+# 11. EVALUATE
 # =========================
 model.eval()
 
 with torch.no_grad():
-    outputs = model(X_test_t).squeeze()
+    outputs = model(Xt_test, Xa_test, Xv_test).squeeze()
     preds = (torch.sigmoid(outputs) > 0.5).int().cpu().numpy()
 
 print("\n========== RESULTS ==========")
 print("Accuracy:", accuracy_score(y_test, preds))
-print("F1 Score:", f1_score(y_test, preds))
-
-print("\nSample Predictions:")
-for i in range(min(10, len(preds))):
-    label = "Depressed" if preds[i] == 1 else "Control"
-    print(f"{used_folders[split+i]} → {label}")
+print("F1 Score:", f1_score(y_test, preds))