filter failing models

app.py

@@ -62,6 +62,34 @@ def model_has_failures(model_name):
         nvidia_single_failures > 0,
     ])
 
+def model_has_amd_failures(model_name):
+    """Check if a model has AMD failures."""
+    if Ci_results.df is None or Ci_results.df.empty:
+        return False
+    
+    model_name_lower = model_name.lower()
+    if model_name_lower not in Ci_results.df.index:
+        return False
+    row = Ci_results.df.loc[model_name_lower]
+    
+    amd_multi_failures = row.get('failed_multi_no_amd', 0)
+    amd_single_failures = row.get('failed_single_no_amd', 0)
+    return amd_multi_failures > 0 or amd_single_failures > 0
+
+def model_has_nvidia_failures(model_name):
+    """Check if a model has NVIDIA failures."""
+    if Ci_results.df is None or Ci_results.df.empty:
+        return False
+    
+    model_name_lower = model_name.lower()
+    if model_name_lower not in Ci_results.df.index:
+        return False
+    row = Ci_results.df.loc[model_name_lower]
+    
+    nvidia_multi_failures = row.get('failed_multi_no_nvidia', 0)
+    nvidia_single_failures = row.get('failed_single_no_nvidia', 0)
+    return nvidia_multi_failures > 0 or nvidia_single_failures > 0
+
 
 # Function to get current description text
 def get_description_text():
@@ -128,14 +156,6 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css(), js=js_func)
                 interactive=True,
                 elem_classes=["history-view-button"]
             )
-            
-            # Toggle to show only failing models
-            show_only_failing = gr.Checkbox(
-                label="Show only failing models",
-                value=False,
-                interactive=True,
-                elem_classes=["failing-models-toggle"]
-            )
 
 
             # Model selection header (clickable toggle)
@@ -147,21 +167,42 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css(), js=js_func)
 
             # Model buttons container (collapsible) - start folded
             with gr.Column(elem_classes=["model-list", "model-list-hidden"]) as model_list_container:
+                # Toggles for filtering failing models by device
+                with gr.Row(elem_classes=["failing-models-filter-row"]):
+                    show_amd_failures = gr.Checkbox(
+                        label="AMD failures",
+                        value=False,
+                        interactive=True,
+                        elem_classes=["failing-models-toggle", "amd-toggle"]
+                    )
+                    show_nvidia_failures = gr.Checkbox(
+                        label="NVIDIA failures",
+                        value=False,
+                        interactive=True,
+                        elem_classes=["failing-models-toggle", "nvidia-toggle"]
+                    )
                 # Create individual buttons for each model
                 model_buttons = []
                 model_choices = [model.lower() for model in Ci_results.available_models] if Ci_results.available_models else ["auto", "bert", "clip", "llama"]
                 
-                # Separate failing and passing models
-                failing_models = []
+                # Categorize models by failure type
+                amd_failing_models = []
+                nvidia_failing_models = []
+                both_failing_models = []
                 passing_models = []
                 
                 print(f"Creating {len(model_choices)} model buttons: {model_choices}")
 
                 for model_name in model_choices:
-                    # Check if model has failures to determine styling
-                    has_failures = model_has_failures(model_name)
-                    if has_failures:
-                        failing_models.append(model_name)
+                    has_amd = model_has_amd_failures(model_name)
+                    has_nvidia = model_has_nvidia_failures(model_name)
+                    
+                    if has_amd and has_nvidia:
+                        both_failing_models.append(model_name)
+                    elif has_amd:
+                        amd_failing_models.append(model_name)
+                    elif has_nvidia:
+                        nvidia_failing_models.append(model_name)
                     else:
                         passing_models.append(model_name)
                 
@@ -181,17 +222,44 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css(), js=js_func)
                         )
                         model_buttons.append(btn)
                 
-                # Container for failing models only (hidden by default)
-                failing_buttons = []
-                with gr.Column(visible=False, elem_classes=["failing-models-container"]) as failing_models_container:
-                    for model_name in failing_models:
+                # Container for AMD failures (hidden by default)
+                amd_buttons = []
+                with gr.Column(visible=False, elem_classes=["amd-failures-container"]) as amd_failures_container:
+                    amd_models_to_show = amd_failing_models + both_failing_models
+                    for model_name in sorted(amd_models_to_show):
+                        btn = gr.Button(
+                            model_name,
+                            variant="secondary",
+                            size="sm",
+                            elem_classes=["model-button", "model-button-failed"]
+                        )
+                        amd_buttons.append(btn)
+                
+                # Container for NVIDIA failures (hidden by default)
+                nvidia_buttons = []
+                with gr.Column(visible=False, elem_classes=["nvidia-failures-container"]) as nvidia_failures_container:
+                    nvidia_models_to_show = nvidia_failing_models + both_failing_models
+                    for model_name in sorted(nvidia_models_to_show):
+                        btn = gr.Button(
+                            model_name,
+                            variant="secondary",
+                            size="sm",
+                            elem_classes=["model-button", "model-button-failed"]
+                        )
+                        nvidia_buttons.append(btn)
+                
+                # Container for both AMD and NVIDIA failures (hidden by default)
+                both_buttons = []
+                with gr.Column(visible=False, elem_classes=["both-failures-container"]) as both_failures_container:
+                    all_failing = list(set(amd_failing_models + nvidia_failing_models + both_failing_models))
+                    for model_name in sorted(all_failing):
                         btn = gr.Button(
                             model_name,
                             variant="secondary",
                             size="sm",
                             elem_classes=["model-button", "model-button-failed"]
                         )
-                        failing_buttons.append(btn)
+                        both_buttons.append(btn)
 
             # CI job links at bottom of sidebar
             ci_links_display = gr.Markdown("🔗 **CI Jobs:** *Loading...*", elem_classes=["sidebar-links"])
@@ -317,20 +385,59 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css(), js=js_func)
                         elem_classes=["plot-container"]
                     )
 
-    # Failing models toggle functionality
-    def toggle_failing_models_filter(show_failing_only):
-        """Toggle between showing all models and only failing models."""
-        if show_failing_only:
-            # Show only failing models container
-            return gr.update(visible=False), gr.update(visible=True)
-        else:
+    # Failing models filter functionality
+    def filter_failing_models(show_amd, show_nvidia):
+        """Filter models based on AMD and/or NVIDIA failures.
+        
+        Logic:
+        - Neither checked: show all models
+        - AMD only: show models with AMD failures (including those with both)
+        - NVIDIA only: show models with NVIDIA failures (including those with both)
+        - Both checked: show all models with any failures
+        """
+        if not show_amd and not show_nvidia:
             # Show all models container
-            return gr.update(visible=True), gr.update(visible=False)
+            return (
+                gr.update(visible=True),   # all_models_container
+                gr.update(visible=False),  # amd_failures_container
+                gr.update(visible=False),  # nvidia_failures_container
+                gr.update(visible=False),  # both_failures_container
+            )
+        elif show_amd and not show_nvidia:
+            # Show AMD failures only
+            return (
+                gr.update(visible=False),  # all_models_container
+                gr.update(visible=True),   # amd_failures_container
+                gr.update(visible=False),  # nvidia_failures_container
+                gr.update(visible=False),  # both_failures_container
+            )
+        elif not show_amd and show_nvidia:
+            # Show NVIDIA failures only
+            return (
+                gr.update(visible=False),  # all_models_container
+                gr.update(visible=False),  # amd_failures_container
+                gr.update(visible=True),   # nvidia_failures_container
+                gr.update(visible=False),  # both_failures_container
+            )
+        else:  # both checked
+            # Show all failures
+            return (
+                gr.update(visible=False),  # all_models_container
+                gr.update(visible=False),  # amd_failures_container
+                gr.update(visible=False),  # nvidia_failures_container
+                gr.update(visible=True),   # both_failures_container
+            )
     
-    show_only_failing.change(
-        fn=toggle_failing_models_filter,
-        inputs=[show_only_failing],
-        outputs=[all_models_container, failing_models_container]
+    # Connect both checkboxes to the filter function
+    show_amd_failures.change(
+        fn=filter_failing_models,
+        inputs=[show_amd_failures, show_nvidia_failures],
+        outputs=[all_models_container, amd_failures_container, nvidia_failures_container, both_failures_container]
+    )
+    show_nvidia_failures.change(
+        fn=filter_failing_models,
+        inputs=[show_amd_failures, show_nvidia_failures],
+        outputs=[all_models_container, amd_failures_container, nvidia_failures_container, both_failures_container]
     )
 
     # Model toggle functionality
@@ -668,9 +775,62 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css(), js=js_func)
             ],
         )
     
-    # Wire up failing model buttons (same functionality)
-    for i, btn in enumerate(failing_buttons):
-        model_name = failing_models[i]
+    # Wire up AMD failing model buttons
+    amd_models_to_show = amd_failing_models + both_failing_models
+    for i, btn in enumerate(amd_buttons):
+        model_name = sorted(amd_models_to_show)[i]
+        btn.click(
+            fn=lambda history_mode, m=model_name: handle_model_click(m, history_mode),
+            inputs=[history_view_button],
+            outputs=[
+                plot_output,
+                amd_failed_tests_output,
+                nvidia_failed_tests_output,
+                current_view,
+                historical_view,
+                summary_display,
+                detail_view,
+                time_series_failure_rates,
+                time_series_amd_tests,
+                time_series_nvidia_tests,
+                time_series_amd_model_plot,
+                time_series_nvidia_model_plot,
+                time_series_detail_view,
+                selected_model_state,
+                in_model_view_state,
+            ],
+        )
+    
+    # Wire up NVIDIA failing model buttons
+    nvidia_models_to_show = nvidia_failing_models + both_failing_models
+    for i, btn in enumerate(nvidia_buttons):
+        model_name = sorted(nvidia_models_to_show)[i]
+        btn.click(
+            fn=lambda history_mode, m=model_name: handle_model_click(m, history_mode),
+            inputs=[history_view_button],
+            outputs=[
+                plot_output,
+                amd_failed_tests_output,
+                nvidia_failed_tests_output,
+                current_view,
+                historical_view,
+                summary_display,
+                detail_view,
+                time_series_failure_rates,
+                time_series_amd_tests,
+                time_series_nvidia_tests,
+                time_series_amd_model_plot,
+                time_series_nvidia_model_plot,
+                time_series_detail_view,
+                selected_model_state,
+                in_model_view_state,
+            ],
+        )
+    
+    # Wire up both failures model buttons
+    all_failing = list(set(amd_failing_models + nvidia_failing_models + both_failing_models))
+    for i, btn in enumerate(both_buttons):
+        model_name = sorted(all_failing)[i]
         btn.click(
             fn=lambda history_mode, m=model_name: handle_model_click(m, history_mode),
             inputs=[history_view_button],

styles.css

@@ -194,45 +194,73 @@ div[data-testid="column"]:has(.sidebar) {
     transition: all 0.3s ease !important;
 }
 
-/* Failing models toggle styling */
-.failing-models-toggle {
+/* Failing models filter row */
+.failing-models-filter-row {
     background: linear-gradient(145deg, #1a1a1a, #0f0f0f) !important;
     border: 1px solid #333 !important;
     border-radius: 6px !important;
-    padding: 10px 12px !important;
-    margin: 8px 0px 12px 0px !important;
-    transition: all 0.3s ease !important;
+    padding: 8px 8px !important;
+    margin: 0px 0px 12px 0px !important;
+    gap: 8px !important;
+}
+
+/* Failing models toggle styling */
+.failing-models-toggle {
+    background: transparent !important;
+    border: none !important;
+    padding: 4px 6px !important;
+    margin: 0 !important;
+    flex: 1 !important;
 }
 
 .failing-models-toggle:hover {
-    background: linear-gradient(145deg, #252525, #1a1a1a) !important;
-    border-color: #444 !important;
+    background: rgba(255, 255, 255, 0.05) !important;
+    border-radius: 4px !important;
 }
 
 .failing-models-toggle label {
-    color: #E53E3E !important;
     font-family: monospace !important;
-    font-size: 13px !important;
+    font-size: 11px !important;
     font-weight: 600 !important;
     text-transform: uppercase !important;
     letter-spacing: 0.5px !important;
     cursor: pointer !important;
     display: flex !important;
     align-items: center !important;
+    white-space: nowrap !important;
+}
+
+.amd-toggle label {
+    color: #FF6B6B !important;
+}
+
+.nvidia-toggle label {
+    color: #76B900 !important;
 }
 
 .failing-models-toggle input[type="checkbox"] {
-    accent-color: #E53E3E !important;
     cursor: pointer !important;
-    width: 18px !important;
-    height: 18px !important;
-    margin-right: 8px !important;
+    width: 16px !important;
+    height: 16px !important;
+    margin-right: 6px !important;
 }
 
-.failing-models-toggle input[type="checkbox"]:checked {
+.amd-toggle input[type="checkbox"] {
     accent-color: #FF6B6B !important;
 }
 
+.nvidia-toggle input[type="checkbox"] {
+    accent-color: #76B900 !important;
+}
+
+.amd-toggle input[type="checkbox"]:checked {
+    accent-color: #FF8888 !important;
+}
+
+.nvidia-toggle input[type="checkbox"]:checked {
+    accent-color: #8BD918 !important;
+}
+
 
 /* Model button styling */
 .model-button {