checking data access

app.py

@@ -24,13 +24,18 @@ def get_base(filename):
         return BASE["cory"]
 from datasets import load_dataset
 
+import pandas as pd
+
+metadata_file = os.path.join(data_dir, "metadata.csv")
+df = pd.read_csv(metadata_file)
+print(df.head())  # Print first few rows
 
 # Load dataset
-dataset = load_dataset("IndoorOutdoor/1090dumpData")
+# dataset = load_dataset("IndoorOutdoor/1090dumpData")
 
-# Get dataset cache directory (where files are stored)
-dataset_dir = dataset.cache_files
-print("Dataset directory:", dataset_dir)
+# # Get dataset cache directory (where files are stored)
+# dataset_dir = dataset.cache_files
+# print("Dataset directory:", dataset_dir)
 
 #for root, dirs, files in os.walk(dataset_dir):
 #    for file in files:
@@ -155,77 +160,51 @@ HF_STORAGE_DIR = "data"
 if not os.path.exists(HF_STORAGE_DIR):
     os.makedirs(HF_STORAGE_DIR)
 
-
-def evaluate_model(username, file):
+def evaluate_model(username):
     global leaderboard_data
 
     username = username.strip()
     if not username:
         return leaderboard_data.values.tolist()
 
-    if isinstance(file, str):  
-        temp_file_path = file
-    else:
-        temp_file_path = os.path.join(HF_STORAGE_DIR, f"{username}_model.pt")
-        with open(temp_file_path, "wb") as temp_file:
-            temp_file.write(file.read())
+    dataset_directory = "/data"  # Path where files are stored in Hugging Face Spaces
 
     try:
-        exp = read_configuration(dataset["metadata.csv"])
-        # stats_model_sectors = []
-        # stats_model_in_out = []
-        # for key in exp:
-        #     filename = exp[key]['file']
-        #     #Groundtruth for each dataset
-        #     indoor_gt = exp[key]['indoor']
-        #     sectors_gt = exp[key]["sectors"]
-        #     print("Dataset: ", filename)
-        #     print("Indoor:\t", indoor_gt)
-        #     print("Ground Truth sectors:\t", sectors_gt)
-        
-        
-        #     #Do clustering for each sector. This will be used later to figure out sector-based and non-sector-based classification
-        #     sectors_model = # TODO: CALL USER FTN   
-        #     print("Estimated sectors:\t", sectors_model)
-        #     stats_model_sectors.append(compute_stats_sector(sectors_model, sectors_gt))
-        #     stats_model_in_out.append(compute_stats_in_out(sectors_model, indoor_gt))
-        
-        # print("----------------------------")
+        # Load metadata
+        metadata_path = os.path.join(dataset_directory, "metadata.csv")
+        exp = read_configuration(metadata_path)  # Use your existing function
+
+        stats_model_sectors = []
+        stats_model_in_out = []
+
+        for key in exp:
+            filename = exp[key]['file']
+            indoor_gt = exp[key]['indoor']
+            sectors_gt = exp[key]["sectors"]
+
+            file_path = os.path.join(dataset_directory, filename)
+
+            # Run your clustering model
+            sectors_model = model_based_clustering(dataset_directory, filename)
+
+            # Compute statistics
+            stats_model_sectors.append(compute_stats_sector(sectors_model, sectors_gt))
+            stats_model_in_out.append(compute_stats_in_out(sectors_model, indoor_gt))
         
-        # TP = np.mean([x[0] for x in stats_model_sectors])
-        # FP = np.mean([x[1] for x in stats_model_sectors])
-        # FN = np.mean([x[2] for x in stats_model_sectors])
-        # TN = np.mean([x[3] for x in stats_model_sectors])
-        # print(TP, FP, FN, TN)
-        # TP = np.mean([x[0] for x in stats_model_in_out])
-        # FP = np.mean([x[1] for x in stats_model_in_out])
-        # FN = np.mean([x[2] for x in stats_model_in_out])
-        # TN = np.mean([x[3] for x in stats_model_in_out])
-        # print(TP, FP, FN, TN)
-        # end_time = time.time()
-        # exec_time = end_time - start_time
-        # print(f"Execution Time: {exec_time} seconds")
-    except Exception as e:
-        leaderboard_data = pd.concat([leaderboard_data, pd.DataFrame([[username, float("inf"), 0, f"Model Load Error: {str(e)}"]], 
-                             columns=["Username", "Execution Time (s)", "Accuracy", "Status"])], ignore_index=True)
-        return leaderboard_data.values.tolist()
+        TP = np.mean([x[0] for x in stats_model_sectors])
+        FP = np.mean([x[1] for x in stats_model_sectors])
+        FN = np.mean([x[2] for x in stats_model_sectors])
+        TN = np.mean([x[3] for x in stats_model_sectors])
 
-    # Measure execution time
-    start_time = time.time()
-    correct = 0
-    total = 0
+        execution_time = round(time.time() - start_time, 4)
+        accuracy = round((TP + TN) / (TP + TN + FP + FN), 2)
 
-    # Run inference on test dataset
-    with torch.no_grad():
-        for images, labels in test_loader:
-            outputs = model(images)
-            _, predicted = torch.max(outputs, 1)
-            correct += (predicted == labels).sum().item()
-            total += labels.size(0)
+        status = "Success" if accuracy > 0 else "Incorrect Model"
 
-    execution_time = round(time.time() - start_time, 4)
-    accuracy = round(100 * correct / total, 2)
-    status = "Success" if accuracy > 0 else "Incorrect Model"
+    except Exception as e:
+        leaderboard_data = pd.concat([leaderboard_data, pd.DataFrame([[username, float("inf"), 0, f"Model Error: {str(e)}"]], 
+                             columns=["Username", "Execution Time (s)", "Accuracy", "Status"])], ignore_index=True)
+        return leaderboard_data.values.tolist()
 
     # Append to leaderboard
     new_entry = pd.DataFrame([[username, execution_time, accuracy, status]], 
@@ -237,7 +216,8 @@ def evaluate_model(username, file):
     leaderboard_data = leaderboard_data.sort_values(by=["Accuracy", "Execution Time (s)"], 
                                                     ascending=[False, True]).reset_index(drop=True)
 
-    return leaderboard_data.values.tolist() 
+    return leaderboard_data.values.tolist()
+
 
 # Create Gradio UI
 with gr.Blocks() as demo: