try remote test

about_content.py

@@ -8,7 +8,7 @@ This application is a demonstration of KV Cache Benchmarking. It allows users to
 #### Features:
 - Interactive filtering by model types and datasets
 - Real-time updates of benchmark results
-- Visualization of Quality and TTFT metrics
+- Visualization of Quality and TTFT (s) metrics
 
 #### Contact:
 For more information, please contact us at [email@example.com](mailto:email@example.com).

app.py

@@ -36,34 +36,46 @@ def filter_and_display(selected_columns, model_types, datasets, stage):
     if not filtered.empty:
         # Adjust aggregation based on stage
         if stage == "decode":
-            filtered = filtered.groupby(["Method", "Model"], as_index=False).agg({
+            filtered = filtered.groupby(["Method", "Model", "Dataset"], as_index=False).agg({
                 "Throughput (token/s)": "mean",
                 "Quality": "mean",
                 "Link": "first"
             })
         else:
-            filtered = filtered.groupby(["Method", "Model"], as_index=False).agg({
+            filtered = filtered.groupby(["Method", "Model", "Dataset"], as_index=False).agg({
                 "Quality": "mean",
-                "TTFT": "mean",
+                "TTFT (s)": "mean",
                 "Link": "first"
             })
 
     # Select columns to display
-    display_columns = ["Method", "Model"] + [col for col in selected_columns if col in filtered.columns]
+    display_columns = ["Method", "Model", "Dataset"] + [col for col in selected_columns if col in filtered.columns]
     return filtered[display_columns] if not filtered.empty else pd.DataFrame(columns=display_columns)
 
 def create_prefill_visualization(filtered_data):
     if filtered_data.empty:
         return None
-    fig = px.bar(filtered_data, x='Model', y='Quality', color='Method', barmode='group',
-                 title='Prefill Stage: Quality by Model and Method')
+    fig = px.scatter(
+        filtered_data, 
+        x='TTFT (s)', 
+        y='Quality', 
+        color='Method', 
+        hover_data=['Model', 'Dataset'],
+        title='Prefill Stage: Quality vs TTFT (s) by Method'
+    )
     return fig
 
 def create_decode_visualization(filtered_data):
     if filtered_data.empty:
         return None
-    fig = px.bar(filtered_data, x='Model', y='Throughput (token/s)', color='Method', barmode='group',
-                 title='Decode Stage: Throughput by Model and Method')
+    fig = px.scatter(
+        filtered_data, 
+        x='Throughput (token/s)', 
+        y='Quality', 
+        color='Method', 
+        hover_data=['Model', 'Dataset'],
+        title='Decode Stage: Quality vs Throughput by Method'
+    )
     return fig
 
 # Load the data from the /data folder
@@ -77,21 +89,21 @@ def create_gradio_app():
             gr.Markdown(
                 """# KV Cache Benchmark
 ### Demo leaderboard  
-This demo leaderboard allows users to explore and compare different KV cache implementations across various models and datasets. It provides interactive filtering options and real-time updates of benchmark results, including visualization of Quality and TTFT metrics.
+This demo leaderboard allows users to explore and compare different KV cache implementations across various models and datasets. It provides interactive filtering options and real-time updates of benchmark results, including visualization of Quality and TTFT (s) metrics.
 """)
         
         with gr.Tabs():
             with gr.TabItem("KV Cache Benchmark"):
                 # Prefill-stage selection
                 with gr.Row():
-                    gr.Markdown("## Prefill-stage Selection")
+                    gr.Markdown("## Prefill-Stage KV Cache Compression")
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("#### Select Columns to Display")
                         prefill_columns_to_display = gr.CheckboxGroup(
-                            choices=["Quality", "TTFT", "Link"],
+                            choices=["Quality", "TTFT (s)", "Link"],
                             label="Columns",
-                            value=["Quality", "TTFT"]
+                            value=["Quality", "TTFT (s)"]
                         )
 
                     with gr.Column():
@@ -112,18 +124,31 @@ This demo leaderboard allows users to explore and compare different KV cache imp
 
                 # Prefill-stage compression results
                 with gr.Row():
-                    gr.Markdown("## Prefill-stage Compression Results")
+                    gr.Markdown("## Results")
                 
-                prefill_results = gr.Dataframe(value=filter_and_display(["Quality", "TTFT"], list(data["Model"].unique()), list(data["Dataset"].unique()), "prefill"), headers=["Method", "Model", "Quality", "TTFT", "Link"])
+                # Initialize the Prefill Dataframe with default data
+                prefill_default = filter_and_display(
+                    ["Quality", "TTFT (s)"], 
+                    list(data["Model"].unique()), 
+                    list(data[data["Stage"] == "prefill"]["Dataset"].unique()), 
+                    "prefill"
+                )
+                prefill_results = gr.Dataframe(
+                    value=prefill_default
+                )
 
-                # Prefill-stage visualization
+                # Prefill-stage visualization (Static initially)
+                
                 with gr.Row():
                     gr.Markdown("### Prefill-stage Visualization")
-                    prefill_plot = gr.Plot(value=create_prefill_visualization(filter_and_display(["Quality"], list(data["Model"].unique()), list(data["Dataset"].unique()), "prefill")))
+                with gr.Row():
+                    prefill_plot = gr.Plot(
+                        value=create_prefill_visualization(prefill_default)
+                    )
 
                 # Decode-stage selection
                 with gr.Row():
-                    gr.Markdown("## Decode-stage Selection")
+                    gr.Markdown("## Decode-Stage KV Cache Compression")
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("#### Select Columns to Display")
@@ -151,46 +176,88 @@ This demo leaderboard allows users to explore and compare different KV cache imp
 
                 # Decode-stage compression results
                 with gr.Row():
-                    gr.Markdown("## Decode-stage Compression Results")
+                    gr.Markdown("## Results")
+
+                # Initialize the Decode Dataframe with default data
+                decode_default = filter_and_display(
+                    ["Throughput (token/s)", "Quality"], 
+                    list(data["Model"].unique()), 
+                    list(data[data["Stage"] == "decode"]["Dataset"].unique()), 
+                    "decode"
+                )
+                decode_results = gr.Dataframe(
+                    value=decode_default
+                )
+
+                # Decode-stage visualization (Static initially)
                 
-                decode_results = gr.Dataframe(value=filter_and_display(["Throughput (token/s)", "Quality"], list(data["Model"].unique()), list(data["Dataset"].unique()), "decode"), headers=["Method", "Model", "Throughput (token/s)", "Quality", "Link"])
 
-                # Decode-stage visualization
                 with gr.Row():
-                    gr.Markdown("### Decode-stage Visualization")
-                    decode_plot = gr.Plot(value=create_decode_visualization(filter_and_display(["Throughput (token/s)"], list(data["Model"].unique()), list(data["Dataset"].unique()), "decode")))
+                    gr.Markdown("### Decode-Stage Visualization")
+                with gr.Row():
+                    decode_plot = gr.Plot(
+                        value=create_decode_visualization(decode_default)
+                    )
+
+                # AUTO-UPDATE FUNCTIONS:
+                # (We only update the DataFrame, NOT the Plot)
 
                 def auto_update_prefill(selected_columns, model_types, datasets):
                     if not model_types or not datasets:
-                        return pd.DataFrame(columns=["Method", "Model"] + selected_columns), None
+                        # Return an empty DataFrame if no selection is made
+                        return pd.DataFrame(columns=["Method", "Model"] + selected_columns)
                     filtered_data = filter_and_display(selected_columns, model_types, datasets, "prefill")
-                    return filtered_data, create_prefill_visualization(filtered_data)
+                    return filtered_data
 
                 def auto_update_decode(selected_columns, model_types, datasets):
                     if not model_types or not datasets:
-                        return pd.DataFrame(columns=["Method", "Model"] + selected_columns), None
+                        # Return an empty DataFrame if no selection is made
+                        return pd.DataFrame(columns=["Method", "Model"] + selected_columns)
                     filtered_data = filter_and_display(selected_columns, model_types, datasets, "decode")
-                    return filtered_data, create_decode_visualization(filtered_data)
+                    return filtered_data
 
-                prefill_columns_to_display.change(auto_update_prefill, inputs=[prefill_columns_to_display, prefill_model_types, prefill_datasets], outputs=[prefill_results, prefill_plot])
-                prefill_model_types.change(auto_update_prefill, inputs=[prefill_columns_to_display, prefill_model_types, prefill_datasets], outputs=[prefill_results, prefill_plot])
-                prefill_datasets.change(auto_update_prefill, inputs=[prefill_columns_to_display, prefill_model_types, prefill_datasets], outputs=[prefill_results, prefill_plot])
+                # Only update the tables when filters change
+                prefill_columns_to_display.change(
+                    auto_update_prefill, 
+                    inputs=[prefill_columns_to_display, prefill_model_types, prefill_datasets], 
+                    outputs=[prefill_results]
+                )
+                prefill_model_types.change(
+                    auto_update_prefill, 
+                    inputs=[prefill_columns_to_display, prefill_model_types, prefill_datasets], 
+                    outputs=[prefill_results]
+                )
+                prefill_datasets.change(
+                    auto_update_prefill, 
+                    inputs=[prefill_columns_to_display, prefill_model_types, prefill_datasets], 
+                    outputs=[prefill_results]
+                )
 
-                decode_columns_to_display.change(auto_update_decode, inputs=[decode_columns_to_display, decode_model_types, decode_datasets], outputs=[decode_results, decode_plot])
-                decode_model_types.change(auto_update_decode, inputs=[decode_columns_to_display, decode_model_types, decode_datasets], outputs=[decode_results, decode_plot])
-                decode_datasets.change(auto_update_decode, inputs=[decode_columns_to_display, decode_model_types, decode_datasets], outputs=[decode_results, decode_plot])
+                decode_columns_to_display.change(
+                    auto_update_decode, 
+                    inputs=[decode_columns_to_display, decode_model_types, decode_datasets], 
+                    outputs=[decode_results]
+                )
+                decode_model_types.change(
+                    auto_update_decode, 
+                    inputs=[decode_columns_to_display, decode_model_types, decode_datasets], 
+                    outputs=[decode_results]
+                )
+                decode_datasets.change(
+                    auto_update_decode, 
+                    inputs=[decode_columns_to_display, decode_model_types, decode_datasets], 
+                    outputs=[decode_results]
+                )
 
-                # Add a reload button
-                def reload_data():
-                    global data
-                    data = load_data(data_dir)
-                    return (filter_and_display(prefill_columns_to_display.value, prefill_model_types.value, prefill_datasets.value, "prefill"),
-                            filter_and_display(decode_columns_to_display.value, decode_model_types.value, decode_datasets.value, "decode"),
-                            create_prefill_visualization(filter_and_display(prefill_columns_to_display.value, prefill_model_types.value, prefill_datasets.value, "prefill")),
-                            create_decode_visualization(filter_and_display(decode_columns_to_display.value, decode_model_types.value, decode_datasets.value, "decode")))
+                # Reload button to restart the whole website
+                def reload_website():
+                    # This function will trigger a page reload using JavaScript
+                    return gr.JS("window.location.reload();")
 
                 reload_button = gr.Button("Reload Data")
-                reload_button.click(reload_data, outputs=[prefill_results, decode_results, prefill_plot, decode_plot])
+                reload_button.click(
+                    reload_website
+                )
 
             with gr.TabItem("About"):
                 gr.Markdown(about_markdown)  # Use the imported about page content
@@ -202,4 +269,4 @@ This demo leaderboard allows users to explore and compare different KV cache imp
 
 if __name__ == "__main__":
     app = create_gradio_app()
-    app.launch()
+    app.launch()

data/prefill_CacheGen_Mistral-7B-v0.3_NarrativeQA.json

@@ -1,5 +1,5 @@
 {
     "Quality": 29.53,
-    "TTFT": 2.5,
+    "TTFT (s)": 2.5,
     "Link": "www.google.com"
 }

data/prefill_KIVI_Mistral-7B-v0.3_NarrativeQA.json

@@ -1,5 +1,5 @@
 {
     "Quality": 27.27,
-    "TTFT": 3.3,
+    "TTFT (s)": 3.3,
     "Link": "www.google.com"
 }

data/prefill_vLLM_Mistral-7B-v0.3_NarrativeQA.json

@@ -1,5 +1,5 @@
 {
     "Quality": 29.26,
-    "TTFT": 4.8,
+    "TTFT (s)": 4.8,
     "Link": "www.google.com"
 }