Update app.py

app.py

@@ -11,6 +11,18 @@ from yall import create_yall
 from functools import cache
 
 
+# Importing 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
 @cache
@@ -20,11 +32,20 @@ def cached_model_info(api, model):
     except (RepositoryNotFoundError, RevisionNotFoundError):
         return None
 
-# Function to get model info from DataFrame and update it with likes and tags
-@st.cache
-def get_model_info(df):
-    api = HfApi()
+# Function to 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.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)
+    df['Model'] = df['Model'].apply(lambda x: re.sub(model_link_pattern, r'\1', x))
+    return df
 
+# Function to get and update model info in the DataFrame
+def get_and_update_model_info(df):
+    api = HfApi()
     for index, row in df.iterrows():
         model_info = cached_model_info(api, row['Model'].strip())
         if model_info:
@@ -35,57 +56,39 @@ def get_model_info(df):
             df.loc[index, 'Tags'] = ''
     return df
 
-# Function to convert markdown table to DataFrame and extract Hugging Face URLs
-def convert_markdown_table_to_dataframe(md_content):
-    """
-    Converts markdown table to Pandas DataFrame, handling special characters and links,
-    extracts Hugging Face URLs, and adds them to a new column.
-    """
-    # Remove leading and trailing | characters
-    cleaned_content = re.sub(r'\|\s*$', '', re.sub(r'^\|\s*', '', md_content, flags=re.MULTILINE), flags=re.MULTILINE)
-
-    # Create DataFrame from cleaned content
-    df = pd.read_csv(StringIO(cleaned_content), sep="\|", engine='python')
-
-    # Remove the first row after the header
-    df = df.drop(0, axis=0)
-
-    # Strip whitespace from column names
-    df.columns = df.columns.str.strip()
+# Define the score columns
+score_columns = ['Average', 'AGIEval', 'GPT4All', 'TruthfulQA', 'Bigbench']
 
-    # Extract Hugging Face URLs and add them to a new column
-    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)
+# Function to 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: []}
+    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]
+    return column, top_combinations
 
-    # Clean Model column to have only the model link text
-    df['Model'] = df['Model'].apply(lambda x: re.sub(model_link_pattern, r'\1', x))
+# Function to display the results of the highest combined scores
+def display_highest_combined_scores(data):
+    for column in score_columns:
+        if column in data:
+            _, top_combinations = calculate_highest_combined_score(data, column)
+            st.subheader(f"Top Combinations for {column}")
+            for r, combinations in top_combinations.items():
+                st.write(f"**Number of Models: {r}**")
+                for score, combination in combinations:
+                    st.write(f"Score: {score}, Models: {', '.join(combination)}")
 
-    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 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.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)
-    df['Model'] = df['Model'].apply(lambda x: re.sub(model_link_pattern, r'\1', x))
-    return df
 
 # Function to get model info from DataFrame and update it with likes and tags
 @st.cache
 def get_model_info(df):
     api = HfApi()
-    df['Likes'] = None
-    df['Tags'] = None
+
     for index, row in df.iterrows():
         model_info = cached_model_info(api, row['Model'].strip())
         if model_info:
@@ -96,8 +99,13 @@ def get_model_info(df):
             df.loc[index, 'Tags'] = ''
     return df
 
-# Define the score columns (global for use in calculations)
-score_columns = ['Average', 'AGIEval', 'GPT4All', 'TruthfulQA', 'Bigbench']
+# 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):
@@ -111,16 +119,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 display the results of the highest combined scores
-def display_highest_combined_scores(data):
-    with st.spinner('Calculating highest combined scores...'):
-        results = [calculate_highest_combined_score(data, col) for col in score_columns]
-        for column, top_combinations in results:
-            st.subheader(f"Top Combinations for {column}")
-            for r, combinations in top_combinations.items():
-                st.write(f"**Number of Models: {r}**")
-                for score, combination in combinations:
-                    st.write(f"Score: {score}, Models: {', '.join(combination)}")
 
 # Function to create and display charts (existing functions can be reused or modified as needed)