Fixed md loop

.ipynb_checkpoints/README-checkpoint.md

@@ -0,0 +1,13 @@
+---
+title: Deep Reinforcement Learning Leaderboard
+emoji: 🚀
+colorFrom: green
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.12.0
+app_file: app.py
+pinned: false
+startup_duration_timeout: 2h
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference

.ipynb_checkpoints/app-checkpoint.py

@@ -0,0 +1,189 @@
+import os
+import json
+import requests
+import gradio as gr
+import pandas as pd
+from huggingface_hub import HfApi, hf_hub_download, snapshot_download
+from huggingface_hub.repocard import metadata_load
+from apscheduler.schedulers.background import BackgroundScheduler
+from tqdm.contrib.concurrent import thread_map
+from utils import *
+
+DATASET_REPO_URL = "https://huggingface.co/datasets/huggingface-projects/drlc-leaderboard-data"
+DATASET_REPO_ID = "huggingface-projects/drlc-leaderboard-data"
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+block = gr.Blocks()
+api = HfApi(token=HF_TOKEN)
+
+# Define RL environments
+rl_envs = [
+    {"rl_env_beautiful": "LunarLander-v2 🚀", "rl_env": "LunarLander-v2", "video_link": "", "global": None},
+    {"rl_env_beautiful": "CartPole-v1", "rl_env": "CartPole-v1", "video_link": "https://huggingface.co/sb3/ppo-CartPole-v1/resolve/main/replay.mp4", "global": None},
+    {"rl_env_beautiful": "FrozenLake-v1-4x4-no_slippery ❄️", "rl_env": "FrozenLake-v1-4x4-no_slippery", "video_link": "", "global": None},
+    {"rl_env_beautiful": "FrozenLake-v1-8x8-no_slippery ❄️", "rl_env": "FrozenLake-v1-8x8-no_slippery", "video_link": "", "global": None},
+    {"rl_env_beautiful": "FrozenLake-v1-4x4 ❄️", "rl_env": "FrozenLake-v1-4x4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "FrozenLake-v1-8x8 ❄️", "rl_env": "FrozenLake-v1-8x8", "video_link": "", "global": None},
+    {"rl_env_beautiful": "Taxi-v3 🚖", "rl_env": "Taxi-v3", "video_link": "", "global": None},
+    {"rl_env_beautiful": "CarRacing-v0 🏎️", "rl_env": "CarRacing-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "CarRacing-v2 🏎️", "rl_env": "CarRacing-v2", "video_link": "", "global": None},
+    {"rl_env_beautiful": "MountainCar-v0 ⛰️", "rl_env": "MountainCar-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "SpaceInvadersNoFrameskip-v4 👾", "rl_env": "SpaceInvadersNoFrameskip-v4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "PongNoFrameskip-v4 🎾", "rl_env": "PongNoFrameskip-v4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "BreakoutNoFrameskip-v4 🧱", "rl_env": "BreakoutNoFrameskip-v4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "QbertNoFrameskip-v4 🐦", "rl_env": "QbertNoFrameskip-v4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "BipedalWalker-v3", "rl_env": "BipedalWalker-v3", "video_link": "", "global": None},
+    {"rl_env_beautiful": "Walker2DBulletEnv-v0", "rl_env": "Walker2DBulletEnv-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "AntBulletEnv-v0", "rl_env": "AntBulletEnv-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "HalfCheetahBulletEnv-v0", "rl_env": "HalfCheetahBulletEnv-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "PandaReachDense-v2", "rl_env": "PandaReachDense-v2", "video_link": "", "global": None},
+    {"rl_env_beautiful": "PandaReachDense-v3", "rl_env": "PandaReachDense-v3", "video_link": "", "global": None},
+    {"rl_env_beautiful": "Pixelcopter-PLE-v0", "rl_env": "Pixelcopter-PLE-v0", "video_link": "", "global": None}
+]
+
+# -------------------- Utility Functions --------------------
+
+def restart():
+    """Restart the Hugging Face Space."""
+    print("RESTARTING SPACE...")
+    api.restart_space(repo_id="huggingface-projects/Deep-Reinforcement-Learning-Leaderboard")
+
+def download_leaderboard_dataset():
+    """Download leaderboard dataset once at startup."""
+    print("Downloading leaderboard dataset...")
+    return snapshot_download(repo_id=DATASET_REPO_ID, repo_type="dataset")
+
+def get_metadata(model_id):
+    """Fetch metadata for a given model from Hugging Face."""
+    try:
+        readme_path = hf_hub_download(model_id, filename="README.md", etag_timeout=180)
+        return metadata_load(readme_path)
+    except requests.exceptions.HTTPError:
+        return None  # 404 README.md not found
+
+def parse_metrics_accuracy(meta):
+    """Extract accuracy metrics from metadata."""
+    if "model-index" not in meta:
+        return None
+    result = meta["model-index"][0]["results"]
+    metrics = result[0]["metrics"]
+    return metrics[0]["value"]
+
+def parse_rewards(accuracy):
+    """Extract mean and std rewards from accuracy metrics."""
+    default_std = -1000
+    default_reward = -1000
+    if accuracy is not None:
+        parsed = str(accuracy).split('+/-')
+        mean_reward = float(parsed[0].strip()) if parsed[0] else default_reward
+        std_reward = float(parsed[1].strip()) if len(parsed) > 1 else 0
+    else:
+        mean_reward, std_reward = default_reward, default_std
+    return mean_reward, std_reward
+
+def get_model_ids(rl_env):
+    """Retrieve models matching the given RL environment."""
+    return [x.modelId for x in api.list_models(filter=rl_env)]
+
+def update_leaderboard_dataset_parallel(rl_env, path):
+    """Parallelized update of leaderboard dataset for a given RL environment."""
+    model_ids = get_model_ids(rl_env)
+
+    def process_model(model_id):
+        meta = get_metadata(model_id)
+        if not meta:
+            return None
+        user_id = model_id.split('/')[0]
+        row = {
+            "User": user_id,
+            "Model": model_id,
+            "Results": None,
+            "Mean Reward": None,
+            "Std Reward": None
+        }
+        accuracy = parse_metrics_accuracy(meta)
+        mean_reward, std_reward = parse_rewards(accuracy)
+        row["Results"] = mean_reward - std_reward
+        row["Mean Reward"] = mean_reward
+        row["Std Reward"] = std_reward
+        return row
+
+    data = list(thread_map(process_model, model_ids, desc="Processing models"))
+    data = [row for row in data if row is not None]
+
+    ranked_dataframe = rank_dataframe(pd.DataFrame.from_records(data))
+    ranked_dataframe.to_csv(os.path.join(path, f"{rl_env}.csv"), index=False)
+
+    return ranked_dataframe
+
+def rank_dataframe(dataframe):
+    """Sort models by results and assign ranking."""
+    dataframe = dataframe.sort_values(by=['Results', 'User', 'Model'], ascending=False)
+    dataframe.insert(0, 'Ranking', range(1, len(dataframe) + 1))
+    return dataframe
+
+def run_update_dataset():
+    """Update dataset periodically using the scheduler."""
+    path_ = download_leaderboard_dataset()
+    for env in rl_envs:
+        update_leaderboard_dataset_parallel(env["rl_env"], path_)
+
+    print("Uploading updated dataset...")
+    api.upload_folder(
+        folder_path=path_,
+        repo_id=DATASET_REPO_ID,
+        repo_type="dataset",
+        commit_message="Update dataset"
+    )
+
+def filter_data(rl_env, path, user_id):
+    """Filter dataset for a specific user ID."""
+    data_df = pd.read_csv(os.path.join(path, f"{rl_env}.csv"))
+    return data_df[data_df["User"] == user_id]
+
+# -------------------- Gradio UI --------------------
+
+print("Initializing dataset...")
+path_ = download_leaderboard_dataset()
+
+with block:
+    gr.Markdown("""
+    # 🏆 Deep Reinforcement Learning Course Leaderboard 🏆
+
+    This leaderboard displays trained agents from the [Deep Reinforcement Learning Course](https://huggingface.co/learn/deep-rl-course/unit0/introduction?fw=pt).
+    
+    **Models are ranked using `mean_reward - std_reward`.**
+    
+    If you can't find your model, please wait for the next update (every 2 hours).
+    """)
+
+    grpath = gr.State(path_)  # Store dataset path as a state variable
+
+    for env in rl_envs:
+        with gr.TabItem(env["rl_env_beautiful"]):
+            gr.Markdown(f"## {env['rl_env_beautiful']}")
+            user_id = gr.Textbox(label="Your user ID")
+            search_btn = gr.Button("Search 🔎")
+            reset_btn = gr.Button("Clear Search")
+            env_state = gr.State(env["rl_env"])  # Store environment name as a state variable
+
+            gr_dataframe = gr.Dataframe(
+                value=pd.read_csv(os.path.join(path_, f"{env['rl_env']}.csv")),
+                headers=["Ranking 🏆", "User 🤗", "Model 🤖", "Results", "Mean Reward", "Std Reward"],
+                datatype=["number", "markdown", "markdown", "number", "number", "number"],
+                row_count=(100, 'fixed')
+            )
+
+            # ✅ Corrected: Use `gr.State()` for env["rl_env"] and `grpath`
+            search_btn.click(fn=filter_data, inputs=[env_state, grpath, user_id], outputs=gr_dataframe)
+            reset_btn.click(fn=lambda: pd.read_csv(os.path.join(path_, f"{env['rl_env']}.csv")), inputs=[], outputs=gr_dataframe)
+
+
+# -------------------- Scheduler --------------------
+
+scheduler = BackgroundScheduler()
+scheduler.add_job(run_update_dataset, 'interval', hours=2)  # Update dataset every 2 hours
+scheduler.add_job(restart, 'interval', hours=3)  # Restart space every 3 hours
+scheduler.start()
+
+block.launch()

.ipynb_checkpoints/requirements-checkpoint.txt

@@ -0,0 +1,4 @@
+APScheduler==3.10.1
+gradio==4.0
+httpx==0.24.0
+tqdm

.ipynb_checkpoints/utils-checkpoint.py

@@ -0,0 +1,14 @@
+# Based on Omar Sanseviero work
+# Make model clickable link
+def make_clickable_model(model_name):
+    # remove user from model name
+    model_name_show = ' '.join(model_name.split('/')[1:])
+
+    link = "https://huggingface.co/" + model_name
+    return f'<a target="_blank" href="{link}">{model_name_show}</a>'
+
+# Make user clickable link
+def make_clickable_user(user_id):
+    link = "https://huggingface.co/" + user_id
+    return f'<a  target="_blank" href="{link}">{user_id}</a>'
+    

app.py

@@ -1,15 +1,12 @@
 import os
 import json
 import requests
-
 import gradio as gr
 import pandas as pd
 from huggingface_hub import HfApi, hf_hub_download, snapshot_download
 from huggingface_hub.repocard import metadata_load
 from apscheduler.schedulers.background import BackgroundScheduler
-
 from tqdm.contrib.concurrent import thread_map
-
 from utils import *
 
 DATASET_REPO_URL = "https://huggingface.co/datasets/huggingface-projects/drlc-leaderboard-data"
@@ -19,394 +16,174 @@ HF_TOKEN = os.environ.get("HF_TOKEN")
 block = gr.Blocks()
 api = HfApi(token=HF_TOKEN)
 
-# Containing the data
+# Define RL environments
 rl_envs = [
-{
-"rl_env_beautiful": "LunarLander-v2 🚀",
-"rl_env": "LunarLander-v2",
-"video_link": "",
-"global": None
-},    
-{
-"rl_env_beautiful": "CartPole-v1",
-"rl_env": "CartPole-v1",
-"video_link": "https://huggingface.co/sb3/ppo-CartPole-v1/resolve/main/replay.mp4",
-"global": None
-},
-{
-"rl_env_beautiful": "FrozenLake-v1-4x4-no_slippery ❄️",
-"rl_env": "FrozenLake-v1-4x4-no_slippery",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "FrozenLake-v1-8x8-no_slippery ❄️",
-"rl_env": "FrozenLake-v1-8x8-no_slippery",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "FrozenLake-v1-4x4 ❄️",
-"rl_env": "FrozenLake-v1-4x4",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "FrozenLake-v1-8x8 ❄️",
-"rl_env": "FrozenLake-v1-8x8",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "Taxi-v3 🚖",
-"rl_env": "Taxi-v3",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "CarRacing-v0 🏎️",
-"rl_env": "CarRacing-v0",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "CarRacing-v2 🏎️",
-"rl_env": "CarRacing-v2",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "MountainCar-v0 ⛰️",
-"rl_env": "MountainCar-v0",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "SpaceInvadersNoFrameskip-v4 👾",
-"rl_env": "SpaceInvadersNoFrameskip-v4",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "PongNoFrameskip-v4 🎾",
-"rl_env": "PongNoFrameskip-v4",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "BreakoutNoFrameskip-v4 🧱",
-"rl_env": "BreakoutNoFrameskip-v4",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "QbertNoFrameskip-v4 🐦",
-"rl_env": "QbertNoFrameskip-v4",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "BipedalWalker-v3",
-"rl_env": "BipedalWalker-v3",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "Walker2DBulletEnv-v0",
-"rl_env": "Walker2DBulletEnv-v0",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "AntBulletEnv-v0",
-"rl_env": "AntBulletEnv-v0",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "HalfCheetahBulletEnv-v0",
-"rl_env": "HalfCheetahBulletEnv-v0",
-"video_link": "",
-"global": None
-},
-{
-"rl_env_beautiful": "PandaReachDense-v2",
-"rl_env": "PandaReachDense-v2",
-"video_link": "",
-"global": None
-},  
-{
-"rl_env_beautiful": "PandaReachDense-v3",
-"rl_env": "PandaReachDense-v3",
-"video_link": "",
-"global": None
-},  
-{
-"rl_env_beautiful": "Pixelcopter-PLE-v0",
-"rl_env": "Pixelcopter-PLE-v0",
-"video_link": "",
-"global": None
-}
+    {"rl_env_beautiful": "LunarLander-v2 🚀", "rl_env": "LunarLander-v2", "video_link": "", "global": None},
+    {"rl_env_beautiful": "CartPole-v1", "rl_env": "CartPole-v1", "video_link": "https://huggingface.co/sb3/ppo-CartPole-v1/resolve/main/replay.mp4", "global": None},
+    {"rl_env_beautiful": "FrozenLake-v1-4x4-no_slippery ❄️", "rl_env": "FrozenLake-v1-4x4-no_slippery", "video_link": "", "global": None},
+    {"rl_env_beautiful": "FrozenLake-v1-8x8-no_slippery ❄️", "rl_env": "FrozenLake-v1-8x8-no_slippery", "video_link": "", "global": None},
+    {"rl_env_beautiful": "FrozenLake-v1-4x4 ❄️", "rl_env": "FrozenLake-v1-4x4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "FrozenLake-v1-8x8 ❄️", "rl_env": "FrozenLake-v1-8x8", "video_link": "", "global": None},
+    {"rl_env_beautiful": "Taxi-v3 🚖", "rl_env": "Taxi-v3", "video_link": "", "global": None},
+    {"rl_env_beautiful": "CarRacing-v0 🏎️", "rl_env": "CarRacing-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "CarRacing-v2 🏎️", "rl_env": "CarRacing-v2", "video_link": "", "global": None},
+    {"rl_env_beautiful": "MountainCar-v0 ⛰️", "rl_env": "MountainCar-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "SpaceInvadersNoFrameskip-v4 👾", "rl_env": "SpaceInvadersNoFrameskip-v4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "PongNoFrameskip-v4 🎾", "rl_env": "PongNoFrameskip-v4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "BreakoutNoFrameskip-v4 🧱", "rl_env": "BreakoutNoFrameskip-v4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "QbertNoFrameskip-v4 🐦", "rl_env": "QbertNoFrameskip-v4", "video_link": "", "global": None},
+    {"rl_env_beautiful": "BipedalWalker-v3", "rl_env": "BipedalWalker-v3", "video_link": "", "global": None},
+    {"rl_env_beautiful": "Walker2DBulletEnv-v0", "rl_env": "Walker2DBulletEnv-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "AntBulletEnv-v0", "rl_env": "AntBulletEnv-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "HalfCheetahBulletEnv-v0", "rl_env": "HalfCheetahBulletEnv-v0", "video_link": "", "global": None},
+    {"rl_env_beautiful": "PandaReachDense-v2", "rl_env": "PandaReachDense-v2", "video_link": "", "global": None},
+    {"rl_env_beautiful": "PandaReachDense-v3", "rl_env": "PandaReachDense-v3", "video_link": "", "global": None},
+    {"rl_env_beautiful": "Pixelcopter-PLE-v0", "rl_env": "Pixelcopter-PLE-v0", "video_link": "", "global": None}
 ]
 
+# -------------------- Utility Functions --------------------
+
 def restart():
-    print("RESTART")
+    """Restart the Hugging Face Space."""
+    print("RESTARTING SPACE...")
     api.restart_space(repo_id="huggingface-projects/Deep-Reinforcement-Learning-Leaderboard")
 
+def download_leaderboard_dataset():
+    """Download leaderboard dataset once at startup."""
+    print("Downloading leaderboard dataset...")
+    return snapshot_download(repo_id=DATASET_REPO_ID, repo_type="dataset")
+
 def get_metadata(model_id):
+    """Fetch metadata for a given model from Hugging Face."""
     try:
         readme_path = hf_hub_download(model_id, filename="README.md", etag_timeout=180)
         return metadata_load(readme_path)
     except requests.exceptions.HTTPError:
-        # 404 README.md not found
-        return None
-        
+        return None  # 404 README.md not found
+
 def parse_metrics_accuracy(meta):
+    """Extract accuracy metrics from metadata."""
     if "model-index" not in meta:
         return None
     result = meta["model-index"][0]["results"]
     metrics = result[0]["metrics"]
-    accuracy = metrics[0]["value"]
-    return accuracy
+    return metrics[0]["value"]
 
-# We keep the worst case episode
 def parse_rewards(accuracy):
+    """Extract mean and std rewards from accuracy metrics."""
     default_std = -1000
-    default_reward=-1000
-    if accuracy !=  None:
-        accuracy = str(accuracy)
-        parsed =  accuracy.split('+/-')
-        if len(parsed)>1:
-            mean_reward = float(parsed[0].strip())
-            std_reward =  float(parsed[1].strip())
-        elif len(parsed)==1: #only mean reward
-            mean_reward = float(parsed[0].strip())
-            std_reward =  float(0) 
-        else: 
-            mean_reward = float(default_std)
-            std_reward = float(default_reward)
-
+    default_reward = -1000
+    if accuracy is not None:
+        parsed = str(accuracy).split('+/-')
+        mean_reward = float(parsed[0].strip()) if parsed[0] else default_reward
+        std_reward = float(parsed[1].strip()) if len(parsed) > 1 else 0
     else:
-        mean_reward = float(default_std)
-        std_reward = float(default_reward)
+        mean_reward, std_reward = default_reward, default_std
     return mean_reward, std_reward
 
-
 def get_model_ids(rl_env):
-    api = HfApi()
-    models = api.list_models(filter=rl_env)
-    model_ids = [x.modelId for x in models]
-    return model_ids
+    """Retrieve models matching the given RL environment."""
+    return [x.modelId for x in api.list_models(filter=rl_env)]
 
-# Parralelized version
 def update_leaderboard_dataset_parallel(rl_env, path):
-    # Get model ids associated with rl_env
+    """Parallelized update of leaderboard dataset for a given RL environment."""
     model_ids = get_model_ids(rl_env)
 
     def process_model(model_id):
         meta = get_metadata(model_id)
-        #LOADED_MODEL_METADATA[model_id] = meta if meta is not None else ''
-        if meta is None:
+        if not meta:
             return None
         user_id = model_id.split('/')[0]
-        row = {}
-        row["User"] = user_id
-        row["Model"] = model_id
+        row = {
+            "User": user_id,
+            "Model": model_id,
+            "Results": None,
+            "Mean Reward": None,
+            "Std Reward": None
+        }
         accuracy = parse_metrics_accuracy(meta)
         mean_reward, std_reward = parse_rewards(accuracy)
-        mean_reward = mean_reward if not pd.isna(mean_reward) else 0
-        std_reward = std_reward if not pd.isna(std_reward) else 0
         row["Results"] = mean_reward - std_reward
         row["Mean Reward"] = mean_reward
         row["Std Reward"] = std_reward
         return row
 
     data = list(thread_map(process_model, model_ids, desc="Processing models"))
-
-    # Filter out None results (models with no metadata)
     data = [row for row in data if row is not None]
 
     ranked_dataframe = rank_dataframe(pd.DataFrame.from_records(data))
-    new_history = ranked_dataframe
-    file_path = path + "/" + rl_env + ".csv"
-    new_history.to_csv(file_path, index=False)
-
-    return ranked_dataframe
-
-
-def update_leaderboard_dataset(rl_env, path):
-    # Get model ids associated with rl_env
-    model_ids = get_model_ids(rl_env)
-    data = []
-    for model_id in model_ids:
-        """
-        readme_path = hf_hub_download(model_id, filename="README.md")
-        meta = metadata_load(readme_path)
-        """
-        meta = get_metadata(model_id)
-        #LOADED_MODEL_METADATA[model_id] = meta if meta is not None else ''
-        if meta is None:
-            continue
-        user_id = model_id.split('/')[0]
-        row = {}
-        row["User"] = user_id
-        row["Model"] = model_id
-        accuracy = parse_metrics_accuracy(meta)
-        mean_reward, std_reward = parse_rewards(accuracy)
-        mean_reward = mean_reward if not pd.isna(mean_reward) else 0
-        std_reward = std_reward if not pd.isna(std_reward) else 0
-        row["Results"] = mean_reward - std_reward
-        row["Mean Reward"] = mean_reward
-        row["Std Reward"] = std_reward
-        data.append(row)
-
-    ranked_dataframe = rank_dataframe(pd.DataFrame.from_records(data))
-    new_history = ranked_dataframe
-    file_path = path + "/" + rl_env + ".csv"
-    new_history.to_csv(file_path, index=False)
+    ranked_dataframe.to_csv(os.path.join(path, f"{rl_env}.csv"), index=False)
 
     return ranked_dataframe
 
-def download_leaderboard_dataset():
-    path = snapshot_download(repo_id=DATASET_REPO_ID, repo_type="dataset")
-    return path
-
-def get_data(rl_env, path) -> pd.DataFrame:
-    """
-    Get data from rl_env
-    :return: data as a pandas DataFrame
-    """
-    csv_path = path + "/" + rl_env + ".csv"
-    data = pd.read_csv(csv_path)
-
-    for index, row in data.iterrows():
-        user_id = row["User"]
-        data.loc[index, "User"] = make_clickable_user(user_id)
-        model_id = row["Model"]
-        data.loc[index, "Model"] = make_clickable_model(model_id)
-        
-    return data
-
-def get_data_no_html(rl_env, path) -> pd.DataFrame:
-    """
-    Get data from rl_env
-    :return: data as a pandas DataFrame
-    """
-    csv_path = path + "/" + rl_env + ".csv"
-    data = pd.read_csv(csv_path)
-
-    return data
-    
 def rank_dataframe(dataframe):
+    """Sort models by results and assign ranking."""
     dataframe = dataframe.sort_values(by=['Results', 'User', 'Model'], ascending=False)
-    if not 'Ranking' in dataframe.columns:
-        dataframe.insert(0, 'Ranking', [i for i in range(1,len(dataframe)+1)])
-    else:
-        dataframe['Ranking'] =   [i for i in range(1,len(dataframe)+1)]
+    dataframe.insert(0, 'Ranking', range(1, len(dataframe) + 1))
     return dataframe
 
-
 def run_update_dataset():
+    """Update dataset periodically using the scheduler."""
     path_ = download_leaderboard_dataset()
-    for i in range(0, len(rl_envs)):
-        rl_env = rl_envs[i]
-        update_leaderboard_dataset_parallel(rl_env["rl_env"], path_)
+    for env in rl_envs:
+        update_leaderboard_dataset_parallel(env["rl_env"], path_)
 
+    print("Uploading updated dataset...")
     api.upload_folder(
-    folder_path=path_,
-    repo_id="huggingface-projects/drlc-leaderboard-data",
-    repo_type="dataset",
-    commit_message="Update dataset")
+        folder_path=path_,
+        repo_id=DATASET_REPO_ID,
+        repo_type="dataset",
+        commit_message="Update dataset"
+    )
 
 def filter_data(rl_env, path, user_id):
-    data_df = get_data_no_html(rl_env, path)
-    models = []
-    models = data_df[data_df["User"] == user_id]
-
-    for index, row in models.iterrows():
-        user_id = row["User"]
-        models.loc[index, "User"] = make_clickable_user(user_id)
-        model_id = row["Model"]
-        models.loc[index, "Model"] = make_clickable_model(model_id)
-        
+    """Filter dataset for a specific user ID."""
+    data_df = pd.read_csv(os.path.join(path, f"{rl_env}.csv"))
+    return data_df[data_df["User"] == user_id]
 
-    return models
+# -------------------- Gradio UI --------------------
 
-run_update_dataset()
+print("Initializing dataset...")
+path_ = download_leaderboard_dataset()
 
 with block:
-    gr.Markdown(f"""
-    # 🏆 The Deep Reinforcement Learning Course Leaderboard 🏆 
-    
-    This is the leaderboard of trained agents during the <a href="https://huggingface.co/learn/deep-rl-course/unit0/introduction?fw=pt">Deep Reinforcement Learning Course</a>. A free course from beginner to expert.
-    
-    ### We only display the best 100 models
-    If you want to **find yours, type your user id and click on Search my models.**
-    You **can click on the model's name** to be redirected to its model card, including documentation.
-    
-    ### How are the results calculated?
-    We use **lower bound result to sort the models: mean_reward - std_reward.**
+    gr.Markdown("""
+    # 🏆 Deep Reinforcement Learning Course Leaderboard 🏆
 
-    ### I can't find my model 😭
-    The leaderboard is **updated every two hours** if you can't find your models, just wait for the next update.
+    This leaderboard displays trained agents from the [Deep Reinforcement Learning Course](https://huggingface.co/learn/deep-rl-course/unit0/introduction?fw=pt).
+    
+    **Models are ranked using `mean_reward - std_reward`.**
     
-    ### The Deep RL Course
-    🤖 You want to try to train your agents? <a href="https://huggingface.co/deep-rl-course/unit0/introduction?fw=pt" target="_blank"> Check the Hugging Face free Deep Reinforcement Learning Course 🤗 </a>.
-        
-    🔧 There is an **environment missing?** Please open an issue.
+    If you can't find your model, please wait for the next update (every 2 hours).
     """)
-    path_ = download_leaderboard_dataset()
 
-    for i in range(0, len(rl_envs)):
-        rl_env = rl_envs[i]
-        with gr.TabItem(rl_env["rl_env_beautiful"]) as rl_tab:
-            with gr.Row():
-                markdown = """
-                    # {name_leaderboard}
-                    
-                    """.format(name_leaderboard = rl_env["rl_env_beautiful"], video_link = rl_env["video_link"])
-                gr.Markdown(markdown)
-                
-            
-            with gr.Row():
-                gr.Markdown("""
-                    ## Search your models
-                    Simply type your user id to find your models
-                    """)
-                
-            with gr.Row():
-                user_id = gr.Textbox(label= "Your user id")
-                search_btn = gr.Button("Search my models 🔎")
-                reset_btn = gr.Button("Clear my search")
-                env = gr.State(rl_env["rl_env"])
-                grpath = gr.State(path_)
-            with gr.Row():
-                gr_dataframe = gr.components.Dataframe(value=get_data(rl_env["rl_env"], path_), headers=["Ranking 🏆", "User 🤗", "Model id 🤖", "Results", "Mean Reward", "Std Reward"], datatype=["number", "markdown", "markdown", "number", "number", "number"],  row_count=(100, 'fixed'))
-             
-            with gr.Row():
-                #gr_search_dataframe = gr.components.Dataframe(headers=["Ranking 🏆", "User 🤗", "Model id 🤖", "Results", "Mean Reward", "Std Reward"], datatype=["number", "markdown", "markdown", "number", "number", "number"], visible=False)
-                search_btn.click(fn=filter_data, inputs=[env, grpath, user_id], outputs=gr_dataframe, api_name="filter_data")
+    grpath = gr.State(path_)  # Store dataset path as a state variable
+
+    for env in rl_envs:
+        with gr.TabItem(env["rl_env_beautiful"]):
+            gr.Markdown(f"## {env['rl_env_beautiful']}")
+            user_id = gr.Textbox(label="Your user ID")
+            search_btn = gr.Button("Search 🔎")
+            reset_btn = gr.Button("Clear Search")
+            env_state = gr.State(env["rl_env"])  # Store environment name as a state variable
+
+            gr_dataframe = gr.Dataframe(
+                value=pd.read_csv(os.path.join(path_, f"{env['rl_env']}.csv")),
+                headers=["Ranking 🏆", "User 🤗", "Model 🤖", "Results", "Mean Reward", "Std Reward"],
+                datatype=["number", "markdown", "markdown", "number", "number", "number"],
+                row_count=(100, 'fixed')
+            )
+
+            # ✅ Corrected: Use `gr.State()` for env["rl_env"] and `grpath`
+            search_btn.click(fn=filter_data, inputs=[env_state, grpath, user_id], outputs=gr_dataframe)
+            reset_btn.click(fn=lambda: pd.read_csv(os.path.join(path_, f"{env['rl_env']}.csv")), inputs=[], outputs=gr_dataframe)
 
-            with gr.Row():
-                search_btn.click(fn=filter_data, inputs=[env, grpath, user_id], outputs=gr_dataframe, api_name="filter_data")
-                reset_btn.click(fn=get_data, inputs=[env, grpath], outputs=gr_dataframe, api_name="get_data")
-    """
-    block.load(
-        download_leaderboard_dataset,
-        inputs=[],
-        outputs=[
-            grpath
-        ],
-    )
-    """
 
+# -------------------- Scheduler --------------------
 
 scheduler = BackgroundScheduler()
-# Refresh every hour
-#scheduler.add_job(func=run_update_dataset, trigger="interval", seconds=3600)
-#scheduler.add_job(download_leaderboard_dataset, 'interval', seconds=3600)
-#scheduler.add_job(run_update_dataset, 'interval', seconds=3600)
-scheduler.add_job(restart, 'interval', seconds=10800)
+scheduler.add_job(run_update_dataset, 'interval', hours=2)  # Update dataset every 2 hours
+scheduler.add_job(restart, 'interval', hours=3)  # Restart space every 3 hours
 scheduler.start()
 
-block.launch()
+block.launch()