incorporated the usage of csv files

app.py

@@ -1,24 +1,14 @@
-import os
-import zipfile
-import requests
-import numpy as np
-import pandas as pd
-import librosa
-import torch
-import gradio as gr
-
-from transformers import AutoTokenizer, AutoModel
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import accuracy_score, f1_score
-from sklearn.model_selection import train_test_split
-
 # =========================
-# 1. DOWNLOAD & EXTRACT DATASET
+# 1. DOWNLOAD DATASET
 # =========================
+import os, requests, zipfile
+
 url = "https://huggingface.co/datasets/ananyakarn/DAIC_WOZ_Data/resolve/main/DAIC_WOZ_Data.zip"
 zip_path = "data.zip"
 
+if not os.path.exists("data"):
+    os.makedirs("data", exist_ok=True)
+
 print("Downloading dataset...")
 r = requests.get(url, stream=True)
 with open(zip_path, "wb") as f:
@@ -27,28 +17,62 @@ with open(zip_path, "wb") as f:
 
 print("Extracting dataset...")
 with zipfile.ZipFile(zip_path, "r") as zip_ref:
-    zip_ref.extractall(".")
+    zip_ref.extractall("data")
 
 # =========================
-# 2. AUTO-DETECT DATASET FOLDER
+# 2. FIND DATASET ROOT
 # =========================
 def find_dataset_root():
-    for root, dirs, files in os.walk("."):
+    for root, dirs, files in os.walk("data"):
         for d in dirs:
             if "_P" in d or "_C" in d:
                 return root
     return None
 
-extract_path = find_dataset_root()
+DATA_PATH = find_dataset_root()
 
-if extract_path is None:
-    raise Exception("Dataset folders not found!")
+if DATA_PATH is None:
+    raise Exception("Dataset not found!")
+
+print("Dataset path:", DATA_PATH)
+
+# =========================
+# 3. IMPORT LIBRARIES
+# =========================
+import numpy as np
+import pandas as pd
+import librosa
+import torch
+import torch.nn as nn
 
-print("Final dataset path:", extract_path)
-print("Sample folders:", os.listdir(extract_path)[:10])
+from tqdm import tqdm
+from transformers import AutoTokenizer, AutoModel
+from sklearn.metrics import accuracy_score, f1_score
+from sklearn.preprocessing import StandardScaler
 
 # =========================
-# 2. LOAD LIGHTWEIGHT BERT
+# 4. LOAD LABELS (AVEC CSV)
+# =========================
+def load_labels():
+    df_train = pd.read_csv("train_split_Depression_AVEC2017.csv")
+    df_dev = pd.read_csv("dev_split_Depression_AVEC2017.csv")
+    df_test = pd.read_csv("test_split_Depression_AVEC2017.csv")
+
+    df = pd.concat([df_train, df_dev, df_test])
+
+    labels = {}
+    for _, row in df.iterrows():
+        pid = str(int(row["Participant_ID"]))
+        phq = row["PHQ8_Score"]
+        label = 1 if phq >= 10 else 0
+        labels[pid] = label
+
+    return labels
+
+labels_dict = load_labels()
+
+# =========================
+# 5. LOAD TEXT MODEL
 # =========================
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
@@ -57,127 +81,163 @@ bert = AutoModel.from_pretrained("distilbert-base-uncased").to(device)
 bert.eval()
 
 # =========================
-# 3. FEATURE FUNCTIONS
+# 6. FEATURE FUNCTIONS
 # =========================
+def load_text(folder_path):
+    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())
+    except:
+        return ""
+
 def get_text_embedding(text):
-    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=128).to(device)
+    if text == "":
+        return np.zeros(768)
+
+    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()
 
-def get_audio_features(folder):
+def get_audio_features(folder_path):
     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)
-        mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=20)
+        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)
+        mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40)
         return np.mean(mfcc.T, axis=0)
     except:
-        return np.zeros(20)
+        return np.zeros(40)
 
-def load_text(folder):
-    try:
-        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).tolist())
-    except:
-        return ""
+def get_visual_features(folder_path):
+    features = []
 
-def get_label(folder):
-    return 1 if "_P" in folder else 0
+    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))
 
-# =========================
-# 4. BUILD BALANCED DATASET
-# =========================
-print("Building balanced dataset...")
+            cols = [c for c in df.columns if any(k in c.lower() for k in ["au", "pose", "gaze"])]
+            df = df[cols]
 
-all_folders = [f for f in os.listdir(extract_path) if os.path.isdir(os.path.join(extract_path, f))]
+            feat = np.concatenate([df.mean().values, df.std().values])
+            features.append(feat)
+        except:
+            features.append(np.zeros(20))
 
-p_folders = [f for f in all_folders if "_P" in f]
-c_folders = [f for f in all_folders if "_C" in f]
+    return np.concatenate(features)
 
-# 🔥 pick equal samples
-num_samples = min(10, len(p_folders), len(c_folders))
+# =========================
+# 7. BUILD DATASET (ONLY VALID LABELS)
+# =========================
+print("\nBuilding dataset...")
 
-p_folders = p_folders[:num_samples]
-c_folders = c_folders[:num_samples]
+all_folders = [
+    f for f in os.listdir(DATA_PATH)
+    if os.path.isdir(os.path.join(DATA_PATH, f))
+]
 
-folders = p_folders + c_folders
+data = []
+used_folders = []
 
-print(f"Using {len(p_folders)} depressed and {len(c_folders)} control samples")
+for folder in tqdm(all_folders):
+    pid = folder.split("_")[0]
 
-# =========================
-# 5. FEATURE EXTRACTION
-# =========================
-X, y = [], []
+    if pid not in labels_dict:
+        continue
 
-for folder in folders:
-    path = os.path.join(extract_path, folder)
+    folder_path = os.path.join(DATA_PATH, folder)
 
-    text = load_text(path)
+    text = load_text(folder_path)
     text_feat = get_text_embedding(text)
-    audio_feat = get_audio_features(path)
+    audio_feat = get_audio_features(folder_path)
+    visual_feat = get_visual_features(folder_path)
 
-    combined = np.concatenate([text_feat, audio_feat])
+    combined = np.concatenate([text_feat, audio_feat, visual_feat])
+    label = labels_dict[pid]
 
-    X.append(combined)
-    y.append(get_label(folder))
+    data.append((combined, label))
+    used_folders.append(folder)
 
-X = np.array(X)
-y = np.array(y)
+print("Total valid samples:", len(data))
 
 # =========================
-# 6. TRAIN-TEST SPLIT
+# 8. PREPARE DATA
 # =========================
-X_train, X_test, y_train, y_test = train_test_split(
-    X, y, test_size=0.3, random_state=42, stratify=y
-)
+X = np.array([d[0] for d in data])
+y = np.array([d[1] for d in data])
 
 scaler = StandardScaler()
-X_train = scaler.fit_transform(X_train)
-X_test = scaler.transform(X_test)
+X = scaler.fit_transform(X)
+
+# Split using AVEC logic (simple split for now)
+split = int(0.7 * len(X))
+X_train, X_test = X[:split], X[split:]
+y_train, y_test = y[:split], y[split:]
+
+# =========================
+# 9. MODEL
+# =========================
+class MultiModalNN(nn.Module):
+    def __init__(self, input_dim):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, 256),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(256, 64),
+            nn.ReLU(),
+            nn.Linear(64, 1)
+        )
 
-# =========================
-# 7. TRAIN MODEL
-# =========================
-print("Training model...")
+    def forward(self, x):
+        return self.net(x)
 
-model = RandomForestClassifier(n_estimators=50, random_state=42)
-model.fit(X_train, y_train)
+model = MultiModalNN(X.shape[1]).to(device)
 
-print("Model ready!")
+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)
+
+X_test_t = torch.tensor(X_test, dtype=torch.float32).to(device)
+y_test_t = torch.tensor(y_test, dtype=torch.float32).to(device)
 
 # =========================
-# 8. RUN EVALUATION
+# 10. TRAIN
 # =========================
-def run_on_dataset():
+print("\nTraining model...")
 
-    preds = model.predict(X_test)
+for epoch in range(10):
+    model.train()
 
-    acc = accuracy_score(y_test, preds)
-    f1 = f1_score(y_test, preds)
+    optimizer.zero_grad()
+    outputs = model(X_train_t).squeeze()
+    loss = criterion(outputs, y_train_t)
 
-    results = []
-    for i, pred in enumerate(preds):
-        label = y_test[i]
-        results.append(
-            f"Sample {i+1} → Pred: {'Depressed' if pred else 'Control'} | True: {'Depressed' if label else 'Control'}"
-        )
+    loss.backward()
+    optimizer.step()
 
-    output = "\n".join(results)
-    output += f"\n\nAccuracy: {acc:.3f}"
-    output += f"\nF1 Score: {f1:.3f}"
+    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
 
-    return output
+print("Model ready!")
 
 # =========================
-# 9. GRADIO UI
+# 11. EVALUATION
 # =========================
-app = gr.Interface(
-    fn=run_on_dataset,
-    inputs=[],
-    outputs="text",
-    title="Multimodal Depression Detection",
-    description="Balanced dataset training + evaluation (text + audio)"
-)
+model.eval()
+
+with torch.no_grad():
+    outputs = model(X_test_t).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))
 
-app.launch()
+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}")