Update app.py

app.py

@@ -4,8 +4,15 @@ import seaborn as sns
 import gradio as gr
 import requests
 from bs4 import BeautifulSoup
+import io
+import os
+import base64
+import zipfile
+from PIL import Image
+from io import BytesIO
 
-# Local dataset (optional, for pre-loaded data)
+
+# Input data with links to Hugging Face repositories
 data_full = [
     ['CultriX/Qwen2.5-14B-SLERPv7', 'https://huggingface.co/CultriX/Qwen2.5-14B-SLERPv7', 0.7205, 0.8272, 0.7541, 0.6581, 0.5, 0.729],
     ['djuna/Q2.5-Veltha-14B-0.5', 'https://huggingface.co/djuna/Q2.5-Veltha-14B-0.5', 0.7492, 0.8386, 0.7305, 0.598, 0.43, 0.7817],
@@ -35,8 +42,159 @@ data_full = [
 ]
 
 columns = ["Model Configuration", "Model Link", "tinyArc", "tinyHellaswag", "tinyMMLU", "tinyTruthfulQA", "tinyTruthfulQA_mc1", "tinyWinogrande"]
+
+# Convert to DataFrame
 df_full = pd.DataFrame(data_full, columns=columns)
 
+# Visualization and analytics functions
+def plot_average_scores():
+    df_full["Average Score"] = df_full.iloc[:, 2:].mean(axis=1)
+    df_avg_sorted = df_full.sort_values(by="Average Score", ascending=False)
+
+    plt.figure(figsize=(12, 8))
+    plt.barh(df_avg_sorted["Model Configuration"], df_avg_sorted["Average Score"])
+    plt.title("Average Performance of Models Across Tasks", fontsize=16)
+    plt.xlabel("Average Score", fontsize=14)
+    plt.ylabel("Model Configuration", fontsize=14)
+    plt.gca().invert_yaxis()
+    plt.grid(axis='x', linestyle='--', alpha=0.7)
+    plt.tight_layout()
+    
+    img_buffer = io.BytesIO()
+    plt.savefig(img_buffer, format='png')
+    img_buffer.seek(0)
+    img_base64 = base64.b64encode(img_buffer.read()).decode('utf-8')
+    plt.close()
+
+    pil_image = Image.open(BytesIO(base64.b64decode(img_base64)))
+    return pil_image, "average_performance.png"
+
+
+def plot_task_performance():
+    df_full_melted = df_full.melt(id_vars=["Model Configuration", "Model Link"], var_name="Task", value_name="Score")
+
+    plt.figure(figsize=(14, 10))
+    for model in df_full["Model Configuration"]:
+        model_data = df_full_melted[df_full_melted["Model Configuration"] == model]
+        plt.plot(model_data["Task"], model_data["Score"], marker="o", label=model)
+
+    plt.title("Performance of All Models Across Tasks", fontsize=16)
+    plt.xlabel("Task", fontsize=14)
+    plt.ylabel("Score", fontsize=14)
+    plt.xticks(rotation=45)
+    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=9)
+    plt.grid(axis='y', linestyle='--', alpha=0.7)
+    plt.tight_layout()
+    
+    img_buffer = io.BytesIO()
+    plt.savefig(img_buffer, format='png')
+    img_buffer.seek(0)
+    img_base64 = base64.b64encode(img_buffer.read()).decode('utf-8')
+    plt.close()
+    pil_image = Image.open(BytesIO(base64.b64decode(img_base64)))
+    return pil_image, "task_performance.png"
+
+def plot_task_specific_top_models():
+    top_models = df_full.iloc[:, 2:].idxmax()
+    top_scores = df_full.iloc[:, 2:].max()
+
+    results = pd.DataFrame({"Top Model": top_models, "Score": top_scores}).reset_index().rename(columns={"index": "Task"})
+
+    plt.figure(figsize=(12, 6))
+    plt.bar(results["Task"], results["Score"])
+    plt.title("Task-Specific Top Models", fontsize=16)
+    plt.xlabel("Task", fontsize=14)
+    plt.ylabel("Score", fontsize=14)
+    plt.grid(axis="y", linestyle="--", alpha=0.7)
+    plt.tight_layout()
+
+    img_buffer = io.BytesIO()
+    plt.savefig(img_buffer, format='png')
+    img_buffer.seek(0)
+    img_base64 = base64.b64encode(img_buffer.read()).decode('utf-8')
+    plt.close()
+    pil_image = Image.open(BytesIO(base64.b64decode(img_base64)))
+    return pil_image, "task_specific_top_models.png"
+
+def scrape_mergekit_config(model_name):
+    """
+    Scrapes the Hugging Face model page for YAML configuration.
+    """
+    model_link = df_full.loc[df_full["Model Configuration"] == model_name, "Model Link"].values[0]
+    response = requests.get(model_link)
+    if response.status_code != 200:
+        return f"Failed to fetch model page for {model_name}. Please check the link."
+
+    soup = BeautifulSoup(response.text, "html.parser")
+    yaml_config = soup.find("pre")  # Assume YAML is in <pre> tags
+    if yaml_config:
+        return yaml_config.text.strip()
+    return f"No YAML configuration found for {model_name}."
+
+def plot_heatmap():
+    plt.figure(figsize=(12, 8))
+    sns.heatmap(df_full.iloc[:, 2:], annot=True, cmap="YlGnBu", xticklabels=columns[2:], yticklabels=df_full["Model Configuration"])
+    plt.title("Performance Heatmap", fontsize=16)
+    plt.tight_layout()
+    
+    img_buffer = io.BytesIO()
+    plt.savefig(img_buffer, format='png')
+    img_buffer.seek(0)
+    img_base64 = base64.b64encode(img_buffer.read()).decode('utf-8')
+    plt.close()
+    pil_image = Image.open(BytesIO(base64.b64decode(img_base64)))
+    return pil_image, "performance_heatmap.png"
+
+
+def download_yaml(yaml_content, model_name):
+    """
+    Generates a downloadable link for the scraped YAML content.
+    """
+    if "No YAML configuration found" in yaml_content or "Failed to fetch model page" in yaml_content:
+        return None  # Do not return a link if there's no config or a fetch error
+    
+    filename = f"{model_name.replace('/', '_')}_config.yaml"
+    return gr.File(value=yaml_content.encode(), filename=filename)
+
+def download_all_data():
+    # Prepare data to download
+    csv_buffer = io.StringIO()
+    df_full.to_csv(csv_buffer, index=False)
+    csv_data = csv_buffer.getvalue().encode('utf-8')
+    
+    # Prepare all plots
+    average_plot_pil, average_plot_name = plot_average_scores()
+    task_plot_pil, task_plot_name = plot_task_performance()
+    top_models_plot_pil, top_models_plot_name = plot_task_specific_top_models()
+    heatmap_plot_pil, heatmap_plot_name = plot_heatmap()
+
+    plot_dict = {
+        "average_performance": (average_plot_pil, average_plot_name),
+        "task_performance": (task_plot_pil, task_plot_name),
+        "top_models": (top_models_plot_pil, top_models_plot_name),
+        "heatmap": (heatmap_plot_pil, heatmap_plot_name)
+    }
+
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w') as zf:
+        zf.writestr("model_scores.csv", csv_data)
+
+        for name, (pil_image, filename) in plot_dict.items():
+            image_bytes = io.BytesIO()
+            pil_image.save(image_bytes, format='PNG')
+            image_bytes.seek(0)
+            zf.writestr(filename, image_bytes.read())
+
+
+        for model_name in df_full["Model Configuration"].to_list():
+            yaml_content = scrape_mergekit_config(model_name)
+            if "No YAML configuration found" not in yaml_content and "Failed to fetch model page" not in yaml_content:
+               zf.writestr(f"{model_name.replace('/', '_')}_config.yaml", yaml_content.encode())
+
+    zip_buffer.seek(0)
+    
+    return zip_buffer, "analysis_data.zip"
+
 def scrape_model_page(model_url):
     """
     Scrapes the Hugging Face model page for YAML configuration and other details.
@@ -69,21 +227,59 @@ def display_scraped_model_data(model_url):
     """
     return scrape_model_page(model_url)
 
+
+# Gradio app
 with gr.Blocks() as demo:
-    gr.Markdown("# Model Performance Analysis with Live Scraping")
+    gr.Markdown("# Comprehensive Model Performance Analysis with Hugging Face Links")
+
+    with gr.Row():
+        btn1 = gr.Button("Show Average Performance")
+        img1 = gr.Image(type="pil", label="Average Performance Plot")
+        img1_download = gr.File(label="Download Average Performance")
+        btn1.click(plot_average_scores, outputs=[img1,img1_download])
+        
+    with gr.Row():
+        btn2 = gr.Button("Show Task Performance")
+        img2 = gr.Image(type="pil", label="Task Performance Plot")
+        img2_download = gr.File(label="Download Task Performance")
+        btn2.click(plot_task_performance, outputs=[img2, img2_download])
+
+    with gr.Row():
+        btn3 = gr.Button("Task-Specific Top Models")
+        img3 = gr.Image(type="pil", label="Task-Specific Top Models Plot")
+        img3_download = gr.File(label="Download Top Models")
+        btn3.click(plot_task_specific_top_models, outputs=[img3, img3_download])
+    
+    with gr.Row():
+      btn4 = gr.Button("Plot Performance Heatmap")
+      heatmap_img = gr.Image(type="pil", label="Performance Heatmap")
+      heatmap_download = gr.File(label="Download Heatmap")
+      btn4.click(plot_heatmap, outputs=[heatmap_img, heatmap_download])
 
-    # Pre-loaded dataset features
     with gr.Row():
-        btn1 = gr.Button("Show Summary Statistics")
-        stats_output = gr.Dataframe()
-        btn1.click(lambda: df_full.describe().T, outputs=stats_output)
+        model_selector = gr.Dropdown(choices=df_full["Model Configuration"].tolist(), label="Select a Model")
+        with gr.Column():
+          scrape_btn = gr.Button("Scrape MergeKit Configuration")
+          yaml_output = gr.Textbox(lines=10, placeholder="YAML Configuration will appear here.")
+          scrape_btn.click(scrape_mergekit_config, inputs=model_selector, outputs=yaml_output)
+        with gr.Column():
+          save_yaml_btn = gr.Button("Save MergeKit Configuration")
+          yaml_download = gr.File(label="Download MergeKit Configuration")
+          save_yaml_btn.click(download_yaml, inputs=[yaml_output, model_selector], outputs=yaml_download)
+
 
+    with gr.Row():
+        download_all_btn = gr.Button("Download Everything")
+        all_downloads = gr.File(label="Download All Data")
+        download_all_btn.click(download_all_data, outputs=all_downloads)
+        
     # Live scraping feature
     gr.Markdown("## Live Scraping Features")
     with gr.Row():
         url_input = gr.Textbox(label="Enter Hugging Face Model URL", placeholder="https://huggingface.co/<model>")
-        scrape_btn = gr.Button("Scrape Model Page")
-        scrape_output = gr.Textbox(label="Scraped Data", lines=15)
-        scrape_btn.click(display_scraped_model_data, inputs=url_input, outputs=scrape_output)
+        live_scrape_btn = gr.Button("Scrape Model Page")
+        live_scrape_output = gr.Textbox(label="Scraped Data", lines=15)
+        live_scrape_btn.click(display_scraped_model_data, inputs=url_input, outputs=live_scrape_output)
+
 
 demo.launch()