Update app.py

app.py

@@ -1,30 +1,13 @@
-# Importing necessary libraries
-import re
-import streamlit as st
-import requests
-import pandas as pd
-from io import StringIO
-import plotly.graph_objs as go
-from huggingface_hub import HfApi
-from huggingface_hub.utils import RepositoryNotFoundError, RevisionNotFoundError
-from yall import create_yall
-from functools import cache
-
-
-# Importing necessary libraries
+# Import necessary libraries
 import streamlit as st
 import pandas as pd
-from io import StringIO
-import plotly.graph_objs as go
 from huggingface_hub import HfApi
 from huggingface_hub.utils import RepositoryNotFoundError, RevisionNotFoundError
 from itertools import combinations
-import time
-from collections import Counter
 import re
 from functools import cache
 
-# Function to get model info from Hugging Face API using caching
+# Define function to cache model info from Hugging Face API
 @cache
 def cached_model_info(api, model):
     try:
@@ -32,11 +15,11 @@ def cached_model_info(api, model):
     except (RepositoryNotFoundError, RevisionNotFoundError):
         return None
 
-# Function to convert markdown table to DataFrame and extract Hugging Face URLs
+# Convert markdown table to DataFrame and extract Hugging Face URLs
 def convert_markdown_table_to_dataframe(md_content):
     cleaned_content = re.sub(r'\|\s*$', '', re.sub(r'^\|\s*', '', md_content, flags=re.MULTILINE), flags=re.MULTILINE)
-    df = pd.read_csv(StringIO(cleaned_content), sep="\|", engine='python')
-    df = df.drop(0, axis=0)
+    df = pd.read_csv(pd.compat.StringIO(cleaned_content), sep="\|", engine='python')
+    df = df.drop(0).reset_index(drop=True)
     df.columns = df.columns.str.strip()
     model_link_pattern = r'\[(.*?)\]\((.*?)\)\s*\[.*?\]\(.*?\)'
     df['URL'] = df['Model'].apply(lambda x: re.search(model_link_pattern, x).group(2) if re.search(model_link_pattern, x) else None)
@@ -52,29 +35,42 @@ def get_and_update_model_info(df):
             df.loc[index, 'Likes'] = model_info.likes
             df.loc[index, 'Tags'] = ', '.join(model_info.tags)
         else:
-            df.loc[index, 'Likes'] = -1
+            df.loc[index, 'Likes'] = -1  # Indicates missing info
             df.loc[index, 'Tags'] = ''
     return df
 
+    
+
+# Function to get model info from Hugging Face API using caching
+@cache
+def cached_model_info(api, model):
+    try:
+        return api.model_info(repo_id=str(model))
+    except (RepositoryNotFoundError, RevisionNotFoundError):
+        return None
+
 # Define the score columns
 score_columns = ['Average', 'AGIEval', 'GPT4All', 'TruthfulQA', 'Bigbench']
 
-# Function to calculate the highest combined score for a given column
+
+
+# Calculate the highest combined score for a given column
 def calculate_highest_combined_score(data, column):
-    scores = data[column].dropna().tolist()  # Ensure to drop NaN values to avoid calculation errors
-    models = data['Model'].dropna().tolist()
-    top_combinations = {2: [], 3: [], 4: [], 5: [], 6: []}
+    scores = data[column].dropna().tolist()
+    models = data['Model'].tolist()
+    top_combinations = {r: [] for r in range(2, 7)}
     for r in range(2, 7):
         for combination in combinations(zip(scores, models), r):
             combined_score = sum(score for score, _ in combination)
             top_combinations[r].append((combined_score, tuple(model for _, model in combination)))
-        top_combinations[r] = sorted(top_combinations[r], key=lambda x: x[0], reverse=True)[:3]
+        top_combinations[r].sort(key=lambda x: x[0], reverse=True)
+        top_combinations[r] = top_combinations[r][:3]
     return column, top_combinations
 
-# Function to display the results of the highest combined scores
-def display_highest_combined_scores(data):
+# Display the results of the highest combined scores
+def display_highest_combined_scores(data, score_columns):
     for column in score_columns:
-        if column in data:
+        if column in data.columns:
             _, top_combinations = calculate_highest_combined_score(data, column)
             st.subheader(f"Top Combinations for {column}")
             for r, combinations in top_combinations.items():
@@ -83,30 +79,6 @@ def display_highest_combined_scores(data):
                     st.write(f"Score: {score}, Models: {', '.join(combination)}")
 
 
-
-# Function to get model info from DataFrame and update it with likes and tags
-@st.cache
-def get_model_info(df):
-    api = HfApi()
-
-    for index, row in df.iterrows():
-        model_info = cached_model_info(api, row['Model'].strip())
-        if model_info:
-            df.loc[index, 'Likes'] = model_info.likes
-            df.loc[index, 'Tags'] = ', '.join(model_info.tags)
-        else:
-            df.loc[index, 'Likes'] = -1
-            df.loc[index, 'Tags'] = ''
-    return df
-
-# Function to get model info from Hugging Face API using caching
-@cache
-def cached_model_info(api, model):
-    try:
-        return api.model_info(repo_id=str(model))
-    except (RepositoryNotFoundError, RevisionNotFoundError):
-        return None
-
 # Function to calculate the highest combined score for a given column
 def calculate_highest_combined_score(data, column):
     scores = data[column].tolist()
@@ -119,32 +91,6 @@ def calculate_highest_combined_score(data, column):
         top_combinations[r] = sorted(top_combinations[r], key=lambda x: x[0], reverse=True)[:3]
     return column, top_combinations
 
-
-# Function to create and display charts (existing functions can be reused or modified as needed)
-
-
-@st.cache_data
-def get_model_info(df):
-    api = HfApi()
-
-    # Initialize new columns for likes and tags
-    df['Likes'] = None
-    df['Tags'] = None
-
-    # Iterate through DataFrame rows
-    for index, row in df.iterrows():
-        model = row['Model'].strip()
-        try:
-            model_info = api.model_info(repo_id=str(model))
-            df.loc[index, 'Likes'] = model_info.likes
-            df.loc[index, 'Tags'] = ', '.join(model_info.tags)
-
-        except (RepositoryNotFoundError, RevisionNotFoundError):
-            df.loc[index, 'Likes'] = -1
-            df.loc[index, 'Tags'] = ''
-
-    return df
-
 # Function to create bar chart for a given category
 def create_bar_chart(df, category):
     """Create and display a bar chart for a given category."""