considering both the sets of data

app.py

@@ -1,40 +1,42 @@
 # =========================
-# 1. DOWNLOAD DATASET
+# 1. DOWNLOAD BOTH DATASETS
 # =========================
 import os, requests, zipfile
 
-url = "https://huggingface.co/datasets/ananyakarn/DAIC_WOZ_Data/resolve/main/DAIC_WOZ_Data.zip"
-zip_path = "data.zip"
+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"
+]
 
-if not os.path.exists("data"):
-    os.makedirs("data", exist_ok=True)
+os.makedirs("data", exist_ok=True)
 
-print("Downloading dataset...")
-r = requests.get(url, stream=True)
-with open(zip_path, "wb") as f:
-    for chunk in r.iter_content(8192):
-        f.write(chunk)
+for i, url in enumerate(urls):
+    zip_path = f"data_{i}.zip"
 
-print("Extracting dataset...")
-with zipfile.ZipFile(zip_path, "r") as zip_ref:
-    zip_ref.extractall("data")
+    if not os.path.exists(zip_path):
+        print(f"Downloading dataset {i+1}...")
+        r = requests.get(url, stream=True)
+        with open(zip_path, "wb") as f:
+            for chunk in r.iter_content(8192):
+                f.write(chunk)
+
+        print(f"Extracting dataset {i+1}...")
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            zip_ref.extractall(f"data/set_{i}")
 
 # =========================
-# 2. FIND DATASET ROOT
+# 2. GET ALL PARTICIPANTS
 # =========================
-def find_dataset_root():
-    for root, dirs, files in os.walk("data"):
+def get_all_participant_paths():
+    paths = []
+    for root, dirs, _ in os.walk("data"):
         for d in dirs:
             if "_P" in d or "_C" in d:
-                return root
-    return None
-
-DATA_PATH = find_dataset_root()
+                paths.append(os.path.join(root, d))
+    return paths
 
-if DATA_PATH is None:
-    raise Exception("Dataset not found!")
-
-print("Dataset path:", DATA_PATH)
+ALL_PATHS = get_all_participant_paths()
+print("Total participant folders:", len(ALL_PATHS))
 
 # =========================
 # 3. IMPORT LIBRARIES
@@ -51,29 +53,26 @@ from sklearn.metrics import accuracy_score, f1_score
 from sklearn.preprocessing import StandardScaler
 
 # =========================
-# 4. LOAD LABELS + SPLITS
+# 4. LOAD SPLITS
 # =========================
 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"]))
-            label = int(row["PHQ8_Binary"])
-            split[pid] = label
+            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")
 
-print("Train samples:", len(train_labels))
-print("Dev samples:", len(dev_labels))
+print("Train labels:", len(train_labels))
+print("Dev labels:", len(dev_labels))
 
 # =========================
 # 5. LOAD TEXT MODEL
@@ -87,11 +86,11 @@ bert.eval()
 # =========================
 # 6. FEATURE FUNCTIONS
 # =========================
-def load_text(folder_path):
+def load_text(folder):
     try:
-        file = [f for f in os.listdir(folder_path) if "TRANSCRIPT" in f][0]
-        df = pd.read_csv(os.path.join(folder_path, file))
-        return " ".join(df.iloc[:, -1].astype(str).tolist())
+        file = [f for f in os.listdir(folder) if "TRANSCRIPT" in f][0]
+        df = pd.read_csv(os.path.join(folder, file))
+        return " ".join(df.iloc[:, -1].astype(str))
     except:
         return ""
 
@@ -102,166 +101,144 @@ def get_text_embedding(text):
     inputs = tokenizer(text, return_tensors="pt",
                        truncation=True, padding=True, max_length=256).to(device)
     with torch.no_grad():
-        outputs = bert(**inputs)
-    return outputs.last_hidden_state.mean(dim=1).squeeze().cpu().numpy()
+        out = bert(**inputs)
+    return out.last_hidden_state.mean(dim=1).squeeze().cpu().numpy()
 
-def get_audio_features(folder_path):
+def get_audio_features(folder):
     try:
-        file = [f for f in os.listdir(folder_path) if f.endswith("_AUDIO.wav")][0]
-        y, sr = librosa.load(os.path.join(folder_path, file), sr=16000)
+        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)
         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_features(folder_path):
-    features = []
+def get_visual_features(folder):
+    feats = []
 
     for key in ["AUs", "pose", "gaze"]:
         try:
-            file = [f for f in os.listdir(folder_path) if key in f][0]
-            df = pd.read_csv(os.path.join(folder_path, file))
+            file = [f for f in os.listdir(folder) if key in f][0]
+            df = pd.read_csv(os.path.join(folder, file))
 
-            cols = [c for c in df.columns if any(k in c.lower() for k in ["au", "pose", "gaze"])]
+            cols = [c for c in df.columns if key.lower() in c.lower()]
             df = df[cols]
 
             feat = np.concatenate([df.mean().values, df.std().values])
-            features.append(feat)
+            feats.append(feat)
         except:
-            features.append(np.zeros(20))
+            feats.append(np.zeros(20))
 
-    return np.concatenate(features)
+    return np.concatenate(feats)
 
 # =========================
-# 7. BUILD TRAIN + TEST SET
+# 7. BUILD DATASETS
 # =========================
 def build_dataset(label_dict):
-    X_text, X_audio, X_visual, y = [], [], [], []
-
-    for folder in os.listdir(DATA_PATH):
-        folder_path = os.path.join(DATA_PATH, folder)
-
-        if not os.path.isdir(folder_path):
-            continue
+    X_t, X_a, X_v, y = [], [], [], []
 
-        pid = folder.split("_")[0]
+    for path in tqdm(ALL_PATHS):
+        pid = os.path.basename(path).split("_")[0]
 
         if pid not in label_dict:
             continue
 
-        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))
+        X_t.append(get_text_embedding(load_text(path)))
+        X_a.append(get_audio_features(path))
+        X_v.append(get_visual_features(path))
         y.append(label_dict[pid])
 
-    return np.array(X_text), np.array(X_audio), np.array(X_visual), np.array(y)
+    return np.array(X_t), np.array(X_a), np.array(X_v), np.array(y)
 
-print("\nBuilding train set...")
-X_text_train, X_audio_train, X_visual_train, y_train = build_dataset(train_labels)
+print("\nBuilding train...")
+Xt, Xa, Xv, y_train = build_dataset(train_labels)
 
-print("Building dev set...")
-X_text_test, X_audio_test, X_visual_test, y_test = build_dataset(dev_labels)
+print("Building dev...")
+Xt_test, Xa_test, Xv_test, y_test = build_dataset(dev_labels)
 
 print("Train size:", len(y_train))
 print("Test size:", len(y_test))
 
+if len(y_train) == 0 or len(y_test) == 0:
+    raise Exception("Dataset still empty → check upload")
+
 # =========================
-# 8. NORMALIZATION
+# 8. NORMALIZE
 # =========================
-scaler_text = StandardScaler()
-scaler_audio = StandardScaler()
-scaler_visual = StandardScaler()
+sc_t, sc_a, sc_v = StandardScaler(), StandardScaler(), StandardScaler()
 
-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)
+Xt = sc_t.fit_transform(Xt)
+Xa = sc_a.fit_transform(Xa)
+Xv = sc_v.fit_transform(Xv)
 
-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)
+Xt_test = sc_t.transform(Xt_test)
+Xa_test = sc_a.transform(Xa_test)
+Xv_test = sc_v.transform(Xv_test)
 
 # =========================
-# 9. MULTIMODAL MODEL (CORRECT)
+# 9. MODEL
 # =========================
-class MultiModalModel(nn.Module):
-    def __init__(self):
+class Model(nn.Module):
+    def __init__(self, vdim):
         super().__init__()
 
-        # 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.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(vdim,64), 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),
+        self.f = nn.Sequential(
+            nn.Linear(224,64),
             nn.ReLU(),
             nn.Dropout(0.3),
-            nn.Linear(64, 1)
+            nn.Linear(64,1)
         )
 
-    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)
+    def forward(self, t,a,v):
+        t = self.t(t)
+        a = self.a(a)
+        v = self.v(v)
+        return self.f(torch.cat([t,a,v],1))
 
-model = MultiModalModel().to(device)
+model = Model(Xv.shape[1]).to(device)
 
-optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
-criterion = nn.BCEWithLogitsLoss()
+opt = torch.optim.Adam(model.parameters(), lr=1e-4)
+loss_fn = nn.BCEWithLogitsLoss()
 
-# 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)
+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)
 yt = torch.tensor(y_train, 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)
+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)
 
 # =========================
 # 10. TRAIN
 # =========================
-print("\nTraining model...")
+print("\nTraining...")
 
-for epoch in range(10):
+for e in range(10):
     model.train()
+    opt.zero_grad()
 
-    optimizer.zero_grad()
-    outputs = model(Xt, Xa, Xv).squeeze()
-    loss = criterion(outputs, yt)
+    out = model(Xt,Xa,Xv).squeeze()
+    loss = loss_fn(out, yt)
 
     loss.backward()
-    optimizer.step()
+    opt.step()
 
-    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
+    print(f"Epoch {e+1}: {loss.item():.4f}")
 
 # =========================
-# 11. EVALUATE
+# 11. EVAL
 # =========================
 model.eval()
 
 with torch.no_grad():
-    outputs = model(Xt_test, Xa_test, Xv_test).squeeze()
-    preds = (torch.sigmoid(outputs) > 0.5).int().cpu().numpy()
+    out = model(Xt_test,Xa_test,Xv_test).squeeze()
+    pred = (torch.sigmoid(out)>0.5).int().cpu().numpy()
 
-print("\n========== RESULTS ==========")
-print("Accuracy:", accuracy_score(y_test, preds))
-print("F1 Score:", f1_score(y_test, preds))
+print("\nRESULTS")
+print("Accuracy:", accuracy_score(y_test, pred))
+print("F1:", f1_score(y_test, pred))