from openllm import *
import requests
import pandas as pd
from bs4 import BeautifulSoup
from tqdm import tqdm
from huggingface_hub import HfApi
import gradio as gr
import datetime
api = HfApi()
def get_most(df_for_most_function):
download_sorted_df = df_for_most_function.sort_values(by=['downloads'], ascending=False)
most_downloaded = download_sorted_df.iloc[0]
like_sorted_df = df_for_most_function.sort_values(by=['likes'], ascending=False)
most_liked = like_sorted_df.iloc[0]
return {"Most Download": {"id": most_downloaded['id'], "downloads": most_downloaded['downloads'],
"likes": most_downloaded['likes']},
"Most Likes": {"id": most_liked['id'], "downloads": most_liked['downloads'], "likes": most_liked['likes']}}
def get_sum(df_for_sum_function):
sum_downloads = sum(df_for_sum_function['downloads'].tolist())
sum_likes = sum(df_for_sum_function['likes'].tolist())
return {"Downloads": sum_downloads, "Likes": sum_likes}
def get_openllm_leaderboard():
data = get_json_format_data()
finished_models = get_datas(data)
df = pd.DataFrame(finished_models)
return df['Model'].tolist()
def get_ranking(model_list, target_org):
if not model_list:
return "Error on Leaderboard"
for index, model in enumerate(model_list):
if model.split("/")[0].lower() == target_org.lower():
return [index + 1, model]
return "Not Found"
def get_models(which_one):
if which_one == "models":
data = api.list_models()
elif which_one == "datasets":
data = api.list_datasets()
elif which_one == "spaces":
data = api.list_spaces()
all_list = []
for i in tqdm(data, desc=f"Scraping {which_one}", position=0, leave=True):
i = i.__dict__
id = i["id"].split("/")
if len(id) != 1:
json_format_data = {"author": id[0], "id": "/".join(id), "downloads": i['downloads'],
"likes": i['likes']} if which_one != "spaces" else {"author": id[0], "id": "/".join(id),
"downloads": 0, "likes": i['likes']}
all_list.append(json_format_data)
return all_list
def search(models_dict, author_name):
return pd.DataFrame(models_dict.get(author_name, []))
def group_models_by_author(all_things):
models_by_author = {}
for model in all_things:
author_name = model['author']
if author_name not in models_by_author:
models_by_author[author_name] = []
models_by_author[author_name].append(model)
return models_by_author
def make_leaderboard(orgs, users, which_one, data):
data_rows = []
open_llm_leaderboard = get_openllm_leaderboard() if which_one == "models" else None
trend = get_trending_list(1, which_one)
hepsi = [orgs, users]
for index, orgs in enumerate(hepsi):
org_or_user = "Organization" if index == 0 else "User"
for org in tqdm(orgs, desc=f"Proccesing: ({which_one}) ({org_or_user})", position=0, leave=True):
rank = get_ranking_trend(trend, org)
df = search(data, org)
if len(df) == 0:
continue
num_things = len(df)
sum_info = get_sum(df)
most_info = get_most(df)
if which_one == "models":
open_llm_leaderboard_get_org = get_ranking(open_llm_leaderboard, org)
data_rows.append({
"Author Name": org,
"Total Downloads": sum_info["Downloads"],
"Total Likes": sum_info["Likes"],
"Number of Models": num_things,
"Best Model On Open LLM Leaderboard": open_llm_leaderboard_get_org[1] if open_llm_leaderboard_get_org != "Not Found" else open_llm_leaderboard_get_org,
"Best Rank On Open LLM Leaderboard": open_llm_leaderboard_get_org[0] if open_llm_leaderboard_get_org != "Not Found" else open_llm_leaderboard_get_org,
"Average Downloads per Model": int(sum_info["Downloads"] / num_things) if num_things != 0 else 0,
"Average Likes per Model": int(sum_info["Likes"] / num_things) if num_things != 0 else 0,
"Most Downloaded Model": most_info["Most Download"]["id"],
"Most Download Count": most_info["Most Download"]["downloads"],
"Most Liked Model": most_info["Most Likes"]["id"],
"Most Like Count": most_info["Most Likes"]["likes"],
"Trending Model": rank['id'],
"Best Rank at Trending Models": rank['rank'],
"Type": org_or_user
})
elif which_one == "datasets":
data_rows.append({
"Author Name": org,
"Total Downloads": sum_info["Downloads"],
"Total Likes": sum_info["Likes"],
"Number of Datasets": num_things,
"Average Downloads per Dataset": int(sum_info["Downloads"] / num_things) if num_things != 0 else 0,
"Average Likes per Dataset": int(sum_info["Likes"] / num_things) if num_things != 0 else 0,
"Most Downloaded Dataset": most_info["Most Download"]["id"],
"Most Download Count": most_info["Most Download"]["downloads"],
"Most Liked Dataset": most_info["Most Likes"]["id"],
"Most Like Count": most_info["Most Likes"]["likes"],
"Trending Dataset": rank['id'],
"Best Rank at Trending Datasets": rank['rank'],
"Type": org_or_user
})
elif which_one == "spaces":
data_rows.append({
"Author Name": org,
"Total Likes": sum_info["Likes"],
"Number of Spaces": num_things,
"Average Likes per Space": int(sum_info["Likes"] / num_things) if num_things != 0 else 0,
"Most Liked Space": most_info["Most Likes"]["id"],
"Most Like Count": most_info["Most Likes"]["likes"],
"Trending Space": rank['id'],
"Best Rank at Trending Spaces": rank['rank'],
"Type": org_or_user
})
leaderboard = pd.DataFrame(data_rows)
temp = ["Total Downloads"] if which_one != "spaces" else ["Total Likes"]
leaderboard = leaderboard.sort_values(by=temp, ascending=False)
leaderboard.insert(0, "Serial Number", range(1, len(leaderboard) + 1))
return leaderboard
def clickable(x, which_one):
if which_one == "models":
if x != "Not Found":
return f'{x}'
else:
return "Not Found"
else:
if x != "Not Found":
return f'{x}'
return "Not Found"
def models_df_to_clickable(df, columns, which_one):
for column in columns:
if column == "Author Name":
df[column] = df[column].apply(lambda x: clickable(x, "models"))
else:
df[column] = df[column].apply(lambda x: clickable(x, which_one))
return df
def get_trending_list(pages, which_one):
trending_list = []
for i in range(pages):
json_data = requests.get(f"https://huggingface.co/{which_one}-json?p={i}").json()
for thing in json_data[which_one]:
id = thing["id"]
likes = thing["likes"]
if which_one != "spaces":
downloads = thing["downloads"]
trending_list.append({"id": id, "downloads": downloads, "likes": likes})
else:
trending_list.append({"id": id, "likes": likes})
return trending_list
def get_ranking_trend(json_data, org_name):
names = [item['id'].split("/")[0] for item in json_data]
models = [item['id'] for item in json_data]
if org_name in names:
temp = names.index(org_name)
return {"id": models[temp], "rank": temp + 1}
else:
return {"id": "Not Found", "rank": "Not Found"}
with open("org_names.txt", "r") as f:
org_names_in_list = [i.rstrip("\n") for i in f.readlines()]
with open("user_names.txt", "r") as f:
user_names_in_list = [i.rstrip("\n") for i in f.readlines()]
datetime_now = str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
INTRODUCTION_TEXT = f"""
🎯 The Leaderboard aims to track users and organizations rankings and stats. This space is inspired by the [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard).
## Available Dataframes:
- 🏛️ Models
- 📊 Datasets
- 🚀 Spaces
## Backend
🛠️ The leaderboard's backend mainly runs on the [Hugging Face Hub API](https://huggingface.co/docs/huggingface_hub/v0.5.1/en/package_reference/hf_api).
**🌐 Note:** In the model's dataframe, there are some columns related to the [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard). This data is also retrieved through web scraping.
**🌐 Note:** In trending models/datasets/spaces, first 300 models/datasets/spaces is being retrieved from huggingface.
## 🔍 Searching Organizations and Users
You can search for organizations and users in the Search tab. In this tab, you can view an author's stats even if they are not at the top of the leaderboard.
## Filtering Organizations and Users
🧮 You can filter the dataset to show only Organizations or Users!
✅ Use checkboxs for this!
## Last Update
⌛ This space is last updated in **{datetime_now}**.
"""
def get_avatar(user_name, user):
try:
url = f"https://huggingface.co/{user_name}"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")
if user:
avatar = soup.find("img", {"class": "h-32 w-32 overflow-hidden rounded-full shadow-inner lg:h-48 lg:w-48"})['src']
full = soup.find("span", {"class": "mr-3 leading-6"}).text
return [avatar, full]
else:
avatar = soup.find("img", {"class": "mb-2 mr-4 h-12 w-12 flex-none overflow-hidden rounded-lg sm:mb-0 sm:h-20 sm:w-20"})['src']
full = soup.find("h1", {"class": "mb-2 mr-3 text-2xl font-bold md:mb-0"}).text
return [avatar, full]
except Exception as e:
print(e)
return "Error"
def update_table(orgs, users, how_much=400, return_all=False):
dataFrame = models_df
if not orgs and users:
filtered_df = dataFrame[(dataFrame['Type'] != 'Organization') | (dataFrame['Type'] == 'User')]
elif orgs and not users:
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] != 'User')]
elif orgs and users:
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] == 'User')]
else:
return dataFrame.head(0)
if return_all:
return filtered_df
else:
return filtered_df.head(how_much)
def update_table_datasets(orgs, users, how_much=250, return_all=False):
dataFrame = dataset_df
if not orgs and users:
filtered_df = dataFrame[(dataFrame['Type'] != 'Organization') | (dataFrame['Type'] == 'User')]
elif orgs and not users:
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] != 'User')]
elif orgs and users:
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] == 'User')]
else:
return dataFrame.head(0)
if return_all:
return filtered_df
else:
return filtered_df.head(how_much)
def update_table_spaces(orgs, users, how_much=200, return_all=False):
dataFrame = spaces_df
if not orgs and users:
filtered_df = dataFrame[(dataFrame['Type'] != 'Organization') | (dataFrame['Type'] == 'User')]
elif orgs and not users:
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] != 'User')]
elif orgs and users:
filtered_df = dataFrame[(dataFrame['Type'] == 'Organization') | (dataFrame['Type'] == 'User')]
else:
return dataFrame.head(0)
if return_all:
return filtered_df
else:
return filtered_df.head(how_much)
def search_df(author):
sonuc_models, sonuc_datasets, sonuc_spaces =[], [], []
org_or_user = "User" if author in user_names_in_list else "Org"
a = get_avatar(author, True if org_or_user=="User" else False)
if a == "Error":
return "Error happened, maybe author name is not valid."
# Search in models_df
df = models_df
for index, item in enumerate(df['Author Name'].tolist()):
if f'"https://huggingface.co/{author}"' in item:
sonuc_models = df.iloc[index]
break # Break out of the loop once a match is found
# Search in dataset_df
df = dataset_df
for index, item in enumerate(df['Author Name'].tolist()):
if f'"https://huggingface.co/{author}"' in item:
sonuc_datasets = df.iloc[index]
break # Break out of the loop once a match is found
# Search in spaces_df
df = spaces_df
for index, item in enumerate(df['Author Name'].tolist()):
if f'"https://huggingface.co/{author}"' in item:
sonuc_spaces = df.iloc[index]
break # Break out of the loop once a match is found
author_name = sonuc_models['Author Name'] if len(sonuc_models) > 0 else "Not Found"
global_rank = sonuc_models['Serial Number'] if len(sonuc_models) > 0 else "Not Found"
if len(sonuc_models) > 0:
if org_or_user == "User":
user_rank = filtered_model_users.index(f'{author}')
else:
user_rank = filtered_model_orgs.index(f'{author}')
else:
user_rank = "Not Found"
global_datasets = sonuc_datasets['Serial Number'] if len(sonuc_datasets) > 0 else "Not Found"
if len(sonuc_datasets) > 0:
if org_or_user == "User":
user_datasets = filtered_datasets_users.index(f'{author}')
else:
user_datasets = filtered_datasets_orgs.index(f'{author}')
else:
user_datasets = "Not Found"
global_spaces = sonuc_spaces['Serial Number'] if len(sonuc_spaces) > 0 else "Not Found"
if len(sonuc_spaces) > 0:
if org_or_user == "User":
user_spaces = filtered_spaces_users.index(f'{author}')
else:
user_spaces = filtered_spaces_orgs.index(f'{author}')
else:
user_spaces = "Not Found"
total_model_downloads = sonuc_models['Total Downloads'] if len(sonuc_models) > 0 else "Not Found"
total_model_likes = sonuc_models['Total Likes'] if len(sonuc_models) > 0 else "Not Found"
model_count = sonuc_models['Number of Models'] if len(sonuc_models) > 0 else "Not Found"
total_dataset_downloads = sonuc_datasets['Total Downloads'] if len(sonuc_datasets) > 0 else "Not Found"
total_dataset_likes = sonuc_datasets['Total Likes'] if len(sonuc_datasets) > 0 else "Not Found"
dataset_count = sonuc_datasets['Number of Datasets'] if len(sonuc_datasets) > 0 else "Not Found"
total_space_likes = sonuc_spaces['Total Likes'] if len(sonuc_spaces) > 0 else "Not Found"
space_count = sonuc_spaces['Number of Spaces'] if len(sonuc_spaces) > 0 else "Not Found"
markdown_text = f'''
{author_name} ({a[1]})
## 🏆 Ranks
- Global: {global_rank}
- Models in authors category: {user_rank}
- Datasets (global): {global_datasets}
- Datasets in authors category: {user_datasets}
- Spaces (global): {global_spaces}
- Spaces in authors category: {user_spaces}
## 🤖 Models
- Total downloads: {total_model_downloads}
- Total Likes: {total_model_likes}
- Model count: {model_count}
## 📊 Datasets
- Total downloads: {total_dataset_downloads}
- Total Likes: {total_dataset_likes}
- Dataset count: {dataset_count}
## 🚀 Spaces
- Total Likes: {total_space_likes}
- Spaces count: {space_count}
'''
return markdown_text
with gr.Blocks() as demo:
gr.Markdown("""🤗 Huggingface Leaderboard
""")
gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
all_models = get_models("models")
all_datasets = get_models("datasets")
all_spaces = get_models("spaces")
with gr.Column(min_width=320):
with gr.Box():
orgs = gr.Checkbox(value=True, label="Show Organizations", interactive=True)
users = gr.Checkbox(value=True, label="Show users", interactive=True)
with gr.TabItem("🏛️ Models", id=1):
columns_to_convert = ["Author Name", "Best Model On Open LLM Leaderboard", "Most Downloaded Model",
"Most Liked Model", "Trending Model"]
models_df = make_leaderboard(org_names_in_list, user_names_in_list, "models", group_models_by_author(all_models))
models_df = models_df_to_clickable(models_df, columns_to_convert, "models")
headers = ["🔢 Serial Number", "👤 Author Name", "📥 Total Downloads", "👍 Total Likes", "🤖 Number of Models",
"🏆 Best Model On Open LLM Leaderboard", "🥇 Best Rank On Open LLM Leaderboard",
"📊 Average Downloads per Model", "📈 Average Likes per Model", "🚀 Most Downloaded Model",
"📈 Most Download Count", "❤️ Most Liked Model", "👍 Most Like Count", "🔥 Trending Model",
"👑 Best Rank at Trending Models", "🏷️ Type"]
gr_models = gr.Dataframe(models_df.head(400), headers=headers, interactive=True,
datatype=["str", "markdown", "str", "str", "str", "markdown", "str", "str", "str",
"markdown", "str", "markdown", "str", "markdown", "str", "str"])
with gr.TabItem("📊 Datasets", id=2):
columns_to_convert = ["Author Name", "Most Downloaded Dataset", "Most Liked Dataset", "Trending Dataset"]
dataset_df = make_leaderboard(org_names_in_list, user_names_in_list, "datasets", group_models_by_author(all_datasets))
dataset_df = models_df_to_clickable(dataset_df, columns_to_convert, "datasets")
headers = ["🔢 Serial Number", "👤 Author Name", "📥 Total Downloads", "👍 Total Likes", "📊 Number of Datasets",
"📊 Average Downloads per Dataset", "📈 Average Likes per Dataset", "🚀 Most Downloaded Dataset",
"📈 Most Download Count", "❤️ Most Liked Dataset", "👍 Most Like Count", "🔥 Trending Dataset",
"👑 Best Rank at Trending Datasets", "🏷️ Type"]
gr_datasets = gr.Dataframe(dataset_df.head(250), headers=headers, interactive=False,
datatype=["str", "markdown", "str", "str", "str", "str", "str", "markdown", "str",
"markdown", "str", "markdown", "str", "str"])
with gr.TabItem("🚀 Spaces", id=3):
columns_to_convert = ["Author Name", "Most Liked Space", "Trending Space"]
spaces_df = make_leaderboard(org_names_in_list, user_names_in_list, "spaces", group_models_by_author(all_spaces))
spaces_df = models_df_to_clickable(spaces_df, columns_to_convert, "spaces")
headers = ["🔢 Serial Number", "👤 Author Name", "👍 Total Likes", "🚀 Number of Spaces", "📈 Average Likes per Space",
"❤️ Most Liked Space", "👍 Most Like Count", "🔥 Trending Space", "👑 Best Rank at Trending Spaces",
"🏷️ Type"]
gr_spaces = gr.Dataframe(spaces_df.head(200), headers=headers, interactive=False,
datatype=["str", "markdown", "str", "str", "str", "markdown", "str", "markdown", "str",
"str"])
with gr.TabItem("🔍 Search", id=4):
with gr.Column(min_width=320):
search_bar = gr.Textbox(
placeholder=" 🔍 Search for your author and press ENTER",
show_label=False)
run_btn = gr.Button("Show stats for author")
yazi = gr.Markdown()
run_btn.click(fn=search_df, inputs=search_bar, outputs=yazi)
search_bar.submit(fn=search_df, inputs=search_bar, outputs=yazi)
orgs.change(fn=update_table, inputs=[orgs, users], outputs=gr_models)
orgs.change(fn=update_table_datasets, inputs=[orgs, users], outputs=gr_datasets)
orgs.change(fn=update_table_spaces, inputs=[orgs, users], outputs=gr_spaces)
users.change(fn=update_table, inputs=[orgs, users], outputs=gr_models)
users.change(fn=update_table_datasets, inputs=[orgs, users], outputs=gr_datasets)
users.change(fn=update_table_spaces, inputs=[orgs, users], outputs=gr_spaces)
filtered_model_users = update_table(orgs=False, users=True, return_all=True)['Author Name'].tolist()
filtered_model_orgs = update_table(orgs=True, users=False, return_all=True)['Author Name'].tolist()
filtered_datasets_users = update_table_datasets(orgs=False, users=True, return_all=True)['Author Name'].tolist()
filtered_datasets_orgs = update_table_datasets(orgs=True, users=False, return_all=True)['Author Name'].tolist()
filtered_spaces_users = update_table_spaces(orgs=False, users=True, return_all=True)['Author Name'].tolist()
filtered_spaces_orgs = update_table_spaces(orgs=True, users=False, return_all=True)['Author Name'].tolist()
demo.launch(debug=True)