background_task.py

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"))