Upload 5 files

app.py

@@ -0,0 +1,45 @@
+import gradio as gr
+from huggingface_hub import HfApi
+from matchmaking import *
+from background_task import init_matchmaking, get_elo_data
+from apscheduler.schedulers.background import BackgroundScheduler
+from utils import *
+
+matchmaking = Matchmaking()
+api = HfApi()
+
+# launch
+scheduler = BackgroundScheduler()
+scheduler.add_job(func=init_matchmaking, trigger="interval", seconds=300)
+scheduler.start()
+
+
+def update_elos():
+    matchmaking.read_history()
+    matchmaking.compute_elo()
+    matchmaking.save_elo_data()
+
+
+with gr.Blocks() as block:
+    gr.Markdown(f"""
+        # 🏆 AI vs. AI SoccerTwos Leaderboard ⚽ 
+
+        In this leaderboard, you can find the ELO score and the rank of your trained model for the SoccerTwos environment.
+
+        If you want to know more about a model, just **copy the username and model and paste them into the search bar**.
+
+        👀 To visualize your agents competing check this demo: https://huggingface.co/spaces/unity/ML-Agents-SoccerTwos
+
+        🤖 For more information about this AI vs. AI challenge and to participate? [Check this](https://huggingface.co/deep-rl-course/unit7)
+        """)
+    with gr.Row():
+        output = gr.components.Dataframe(
+            value=get_elo_data,
+            headers=["Ranking 🏆", "User 🤗", "Model id 🤖", "ELO 🚀", "Games played 🎮"],
+            datatype=["number", "markdown", "markdown", "number", "number"]
+        )
+    with gr.Row():
+        refresh = gr.Button("Refresh")
+        refresh.click(get_elo_data, inputs=[], outputs=output)
+
+block.launch()

background_task.py

@@ -0,0 +1,247 @@
+import os
+import random
+import subprocess
+import pandas as pd
+from datetime import datetime
+from huggingface_hub import HfApi, Repository
+from utils import *
+
+DATASET_REPO_URL = "https://huggingface.co/datasets/huggingface-projects/bot-fight-data"
+DATASET_TEMP_REPO_URL = "https://huggingface.co/datasets/huggingface-projects/temp-match-results"
+FILTER_FILE = "https://huggingface.co/datasets/huggingface-projects/filter-bad-models/raw/main/bad_models.csv"
+ELO_FILENAME = "soccer_elo.csv"
+HISTORY_FILENAME = "soccer_history.csv"
+TEMP_FILENAME = "results.csv"
+ELO_DIR = "soccer_elo"
+TEMP_DIR = "temp"
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+repo = Repository(
+    local_dir=ELO_DIR, clone_from=DATASET_REPO_URL, use_auth_token=HF_TOKEN
+)
+repo_temp = Repository(
+    local_dir=TEMP_DIR, clone_from=DATASET_TEMP_REPO_URL, use_auth_token=HF_TOKEN
+)
+
+api = HfApi()
+os.chmod('./SoccerTows.x86_64', 0o755)
+
+
+class Model:
+    """
+    Class containing the info of a model.
+
+    :param name: Name of the model
+    :param elo: Elo rating of the model
+    :param games_played: Number of games played by the model (useful if we implement sigma uncertainty)
+    """
+
+    def __init__(self, author, name, elo=1200, games_played=0):
+        self.author = author
+        self.name = name
+        self.elo = elo
+        self.games_played = games_played
+
+
+class Matchmaking:
+    """
+    Class managing the matchmaking between the models.
+
+    :param models: List of models
+    :param queue: Temporary list of models used for the matching process
+    :param k: Dev coefficient
+    :param max_diff: Maximum difference considered between two models' elo
+    :param matches: Dictionary containing the match history (to later upload as CSV)
+    """
+
+    def __init__(self, models):
+        self.models = models
+        self.queue = self.models.copy()
+        self.k = 20
+        self.max_diff = 500
+        self.matches = {
+            "model1": [],
+            "model2": [],
+            "timestamp": [],
+            "result": [],
+        }
+
+    def run(self):
+        """
+        Run the matchmaking process.
+        Add models to the queue, shuffle it, and match the models one by one to models with close ratings.
+        Compute the new elo for each model after each match and add the match to the match history.
+        """
+        self.queue = self.models.copy()
+        random.shuffle(self.queue)
+        while len(self.queue) > 1:
+            print(f"Queue length: {len(self.queue)}")
+            model1 = self.queue.pop(0)
+            model2 = self.queue.pop(self.find_n_closest_indexes(model1, 10))
+            match(model1, model2)
+        self.load_results()
+
+    def load_results(self):
+        """ Load the match history from the hub. """
+        repo.git_pull()
+        results = pd.read_csv(
+            "https://huggingface.co/datasets/huggingface-projects/temp-match-results/raw/main/results.csv"
+        )
+        # while len(results) < len(self.matches["model1"]):
+        #     time.sleep(60)
+        #     results = pd.read_csv(
+        #         "https://huggingface.co/datasets/huggingface-projects/temp-match-results/raw/main/results.csv"
+        #     )
+
+        for i, row in results.iterrows():
+            model1 = row["model1"].split("/")
+            model2 = row["model2"].split("/")
+            model1 = self.find_model(model1[0], model1[1])
+            model2 = self.find_model(model2[0], model2[1])
+            result = row["result"]
+            if model1 is not None or model2 is not None:
+                self.compute_elo(model1, model2, row["result"])
+                self.matches["model1"].append(model1.author + "/" + model1.name)
+                self.matches["model2"].append(model2.author + "/" + model2.name)
+                self.matches["result"].append(result)
+                self.matches["timestamp"].append(row["timestamp"])
+                model1.games_played += 1
+                model2.games_played += 1
+        data_dict = {"model1": [], "model2": [], "timestamp": [], "result": []}
+        df = pd.DataFrame(data_dict)
+        print(df.head())
+        repo_temp.git_pull()
+        df.to_csv(os.path.join(TEMP_DIR, TEMP_FILENAME), index=False)
+        repo_temp.push_to_hub(commit_message="Reset results.csv")
+
+    def find_model(self, author, name):
+        """ Find a model in the models list. """
+        for model in self.models:
+            if model.author == author and model.name == name:
+                return model
+        return None
+
+    def compute_elo(self, model1, model2, result):
+        """ Compute the new elo for each model based on a match result. """
+        delta = model1.elo - model2.elo
+        win_probability = 1 / (1 + 10 ** (-delta / 500))
+        model1.elo += self.k * (result - win_probability)
+        model2.elo -= self.k * (result - win_probability)
+
+    def find_n_closest_indexes(self, model, n) -> int:
+        """
+        Get a model index with a fairly close rating. If no model is found, return the last model in the queue.
+        We don't always pick the closest rating to add variety to the matchups.
+
+        :param model: Model to compare
+        :param n: Number of close models from which to pick a candidate
+        :return: id of the chosen candidate
+        """
+        if len(self.queue) == 1:
+            return 0
+        indexes = []
+        closest_diffs = [9999999] * n
+        for i, m in enumerate(self.queue):
+            modelid1 = model.author + "/" + model.name
+            modelid2 = m.author + "/" + m.name
+            if modelid1 == modelid2:
+                continue
+            diff = abs(m.elo - model.elo)
+            if diff < max(closest_diffs):
+                closest_diffs.append(diff)
+                closest_diffs.sort()
+                closest_diffs.pop()
+                indexes.append(i)
+        random.shuffle(indexes)
+        return indexes[0]
+
+    def to_csv(self):
+        """ Save the match history as a CSV file to the hub. """
+        data_dict = {"rank": [], "author": [], "model": [], "elo": [], "games_played": []}
+        sorted_models = sorted(self.models, key=lambda x: x.elo, reverse=True)
+        for i, model in enumerate(sorted_models):
+            data_dict["rank"].append(i + 1)
+            data_dict["author"].append(model.author)
+            data_dict["model"].append(model.name)
+            data_dict["elo"].append(model.elo)
+            data_dict["games_played"].append(model.games_played)
+        df = pd.DataFrame(data_dict)
+        print(df.head())
+        repo.git_pull()
+        history = pd.read_csv(os.path.join(ELO_DIR, HISTORY_FILENAME))
+        new_history = pd.DataFrame(self.matches)
+        history = pd.concat([history, new_history])
+        history.to_csv(os.path.join(ELO_DIR, HISTORY_FILENAME), index=False)
+        df.to_csv(os.path.join(ELO_DIR, ELO_FILENAME), index=False)
+        repo.push_to_hub(commit_message="Update ELO")
+
+
+def match(model1, model2):
+    """
+    Simulate a match between two models using the Unity environment.
+
+    :param model1: First Model object
+    :param model2: Second Model object
+    :return: match result (0: model1 lost, 0.5: draw, 1: model1 won)
+    """
+    model1_id = model1.author + "/" + model1.name
+    model2_id = model2.author + "/" + model2.name
+    print(f"Running {model1_id} against {model2_id}...")
+    subprocess.run(["./SoccerTows.x86_64", "-model1", model1_id, "-model2", model2_id, "-nographics", "-batchmode"])
+    print(f"Match {model1_id} against {model2_id} ended.")
+
+
+def get_models_list(filter_bad_models) -> list:
+    """
+    Get the list of models from the hub and the ELO file.
+
+    :return: list of Model objects
+    """
+    models = []
+    models_ids = []
+    data = pd.read_csv(os.path.join(DATASET_REPO_URL, "resolve", "main", ELO_FILENAME))
+    models_on_hub = api.list_models(filter=["reinforcement-learning", "ml-agents", "ML-Agents-SoccerTwos", "onnx"])
+    for i, row in data.iterrows():
+        model_id = row["author"] + "/" + row["model"]
+        if model_id in filter_bad_models:
+            continue
+        models.append(Model(row["author"], row["model"], row["elo"], row["games_played"]))
+        models_ids.append(model_id)
+    for model in models_on_hub:
+        if model.modelId in filter_bad_models:
+            continue
+        author, name = model.modelId.split("/")[0], model.modelId.split("/")[1]
+        if model.modelId not in models_ids:
+            models.append(Model(author, name))
+            print("New model found: ", author, "-", name)
+    return models
+
+
+def get_elo_data() -> pd.DataFrame:
+    """
+    Get the ELO data from the hub for all the models that have played at least one game.
+
+    :return: ELO data as a pandas DataFrame
+    """
+    repo.git_pull()
+    data = pd.read_csv(os.path.join(DATASET_REPO_URL, "resolve", "main", ELO_FILENAME))    
+    
+    return data
+
+
+def init_matchmaking():
+    """
+    Run the matchmaking algorithm and save the results to the hub.
+
+    1. Get the list of models from the hub and the ELO data
+    2. Match models together based on their ELO rating
+    3. Simulate the matches using Unity to get the match result
+    4. Compute the new ELO rating for each model
+    5. Save the results to the hub
+    """
+    filter_bad_models = pd.read_csv(FILTER_FILE)["model"].tolist()
+    models = get_models_list(filter_bad_models)
+    matchmaking = Matchmaking(models)
+    matchmaking.run()
+    matchmaking.to_csv()
+    print("Matchmaking done --", datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f"))

matchmaking.py

@@ -0,0 +1,76 @@
+import random
+import pandas as pd
+import os
+
+
+class Model:
+    """
+    Class containing the info of a model.
+
+    :param name: Name of the model
+    :param elo: Elo rating of the model
+    :param games_played: Number of games played by the model (useful if we implement sigma uncertainty)
+    """
+    def __init__(self, name, elo):
+        self.name = name
+        self.elo = elo
+        self.games_played = 0
+
+
+class Matchmaking:
+    """
+    Class managing the matchmaking between the models.
+
+    :param models: List of models
+    :param queue: Temporary list of models used for the matching process
+    :param k: Dev coefficient
+    :param max_diff: Maximum difference considered between two models' elo
+    :param matches: Dictionary containing the match history (to later upload as CSV)
+    """
+    def __init__(self):
+        self.models = []
+        self.queue = []
+        self.start_elo = 1200
+        self.k = 20
+        self.max_diff = 500
+        self.matches = pd.DataFrame()
+
+    def read_history(self):
+        """ Read the match history from the CSV files, concat the Dataframes and sort them by datetime. """
+        path = "match_history"
+        files = os.listdir(path)
+        for file in files:
+            self.matches = pd.concat([self.matches, pd.read_csv(os.path.join(path, file))], ignore_index=True)
+        self.matches["datetime"] = pd.to_datetime(self.matches["datetime"], format="%Y-%m-%d %H:%M:%S.%f", errors="coerce")
+        self.matches = self.matches.dropna()
+        self.matches = self.matches.sort_values("datetime")
+        self.matches.reset_index(drop=True, inplace=True)
+        model_names = self.matches["model1"].unique()
+        self.models = [Model(name, self.start_elo) for name in model_names]
+
+    def compute_elo(self):
+        """ Compute the elo for each model after each match. """
+        for i, row in self.matches.iterrows():
+            model1 = self.get_model(row["model1"])
+            model2 = self.get_model(row["model2"])
+            result = row["result"]
+            delta = model1.elo - model2.elo
+            win_probability = 1 / (1 + 10 ** (-delta / 500))
+            model1.elo += self.k * (result - win_probability)
+            model2.elo -= self.k * (result - win_probability)
+            model1.games_played += 1
+            model2.games_played += 1
+
+    def save_elo_data(self):
+        """ Save the match history as a CSV file to the hub. """
+        df = pd.DataFrame(columns=['name', 'elo'])
+        for model in self.models:
+            df = pd.concat([df, pd.DataFrame([[model.name, model.elo]], columns=['name', 'elo'])])
+        df.to_csv('elo.csv', index=False)
+
+    def get_model(self, name):
+        """ Return the Model with the given name. """
+        for model in self.models:
+            if model.name == name:
+                return model
+        return None

requirements.txt

@@ -0,0 +1,5 @@
+requests~=2.28.1
+gradio~=3.14.0
+pandas~=1.5.2
+datasets~=2.8.0
+APScheduler~=3.9.1.post1

utils.py

@@ -0,0 +1,13 @@
+# 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>'