workbench 0.8.177__py3-none-any.whl → 0.8.227__py3-none-any.whl

workbench/web_interface/components/plugins/model_details.py

@@ -8,9 +8,14 @@ from dash import html, callback, dcc, Input, Output, State
 # Workbench Imports
 from workbench.api import ModelType, ParameterStore
 from workbench.cached.cached_model import CachedModel
-from workbench.utils.markdown_utils import health_tag_markdown
+from workbench.utils.markdown_utils import (
+    health_tag_markdown,
+    tags_to_markdown,
+    dict_to_markdown,
+    dict_to_collapsible_html,
+    df_to_html_table,
+)
 from workbench.web_interface.components.plugin_interface import PluginInterface, PluginPage, PluginInputType
-from workbench.utils.markdown_utils import tags_to_markdown, dict_to_markdown, dict_to_collapsible_html
 
 
 class ModelDetails(PluginInterface):
@@ -41,12 +46,10 @@ class ModelDetails(PluginInterface):
             id=self.component_id,
             children=[
                 html.H4(id=f"{self.component_id}-header", children="Model: Loading..."),
-                dcc.Markdown(id=f"{self.component_id}-summary"),
+                dcc.Markdown(id=f"{self.component_id}-summary", dangerously_allow_html=True),
                 html.H5(children="Inference Metrics", style={"marginTop": "20px"}),
                 dcc.Dropdown(id=f"{self.component_id}-dropdown", className="dropdown"),
-                dcc.Markdown(id=f"{self.component_id}-metrics"),
-                html.H5(children="Cross Fold Metrics", style={"marginTop": "20px"}),
-                dcc.Markdown(id=f"{self.component_id}-cross-metrics", dangerously_allow_html=True),
+                dcc.Markdown(id=f"{self.component_id}-metrics", dangerously_allow_html=True),
             ],
         )
 
@@ -57,7 +60,6 @@ class ModelDetails(PluginInterface):
             (f"{self.component_id}-dropdown", "options"),
             (f"{self.component_id}-dropdown", "value"),
             (f"{self.component_id}-metrics", "children"),
-            (f"{self.component_id}-cross-metrics", "children"),
         ]
         self.signals = [(f"{self.component_id}-dropdown", "value")]
 
@@ -84,10 +86,9 @@ class ModelDetails(PluginInterface):
         # Populate the inference runs dropdown
         inference_runs, default_run = self.get_inference_runs()
         metrics = self.inference_metrics(default_run)
-        cross_metrics = self.cross_metrics()
 
         # Return the updated property values for the plugin
-        return [header, details, inference_runs, default_run, metrics, cross_metrics]
+        return [header, details, inference_runs, default_run, metrics]
 
     def register_internal_callbacks(self):
         @callback(
@@ -110,63 +111,37 @@ class ModelDetails(PluginInterface):
         Returns:
             str: A markdown string
         """
-
-        # Get these fields from the model
-        show_fields = [
-            "health_tags",
-            "input",
-            "workbench_registered_endpoints",
-            "workbench_model_type",
-            "workbench_model_target",
-            "workbench_model_features",
-            "param_meta",
-            "workbench_tags",
-        ]
-
-        # Construct the markdown string
         summary = self.current_model.summary()
         markdown = ""
-        for key in show_fields:
-
-            # Special case for the health tags
-            if key == "health_tags":
-                markdown += health_tag_markdown(summary.get(key, []))
-                continue
-
-            # Special case for the features
-            if key == "workbench_model_features":
-                value = summary.get(key, [])
-                key = "features"
-                value = f"({len(value)}) {', '.join(value)[:100]}..."
-                markdown += f"**{key}:** {value}  \n"
-                continue
-
-            # Special case for Parameter Store Metadata
-            if key == "param_meta":
-                model_name = summary["name"]
-                meta_data = self.params.get(f"/workbench/models/{model_name}/meta", warn=False)
-                if meta_data:
-                    markdown += dict_to_markdown(meta_data, title="Additional Metadata")
-                continue
-
-            # Special case for tags
-            if key == "workbench_tags":
-                tags = summary.get(key, "")
-                markdown += tags_to_markdown(tags)
-                continue
-
-            # Get the value
-            value = summary.get(key, "-")
-
-            # If the value is a list, convert it to a comma-separated string
-            if isinstance(value, list):
-                value = ", ".join(value)
-
-            # Chop off the "workbench_" prefix
-            key = key.replace("workbench_", "")
-
-            # Add to markdown string
-            markdown += f"**{key}:** {value}  \n"
+
+        # Health tags
+        markdown += health_tag_markdown(summary.get("health_tags", []))
+
+        # Simple fields
+        markdown += f"**input:** {summary.get('input', '-')}  \n"
+        endpoints = ", ".join(summary.get("workbench_registered_endpoints", []))
+        markdown += f"**registered_endpoints:** {endpoints or '-'}  \n"
+        markdown += f"**model_type:** {summary.get('workbench_model_type', '-')}  \n"
+        markdown += f"**model_target:** {summary.get('workbench_model_target', '-')}  \n"
+
+        # Features (truncated)
+        features = summary.get("workbench_model_features", [])
+        features_str = f"({len(features)}) {', '.join(features)[:100]}..."
+        markdown += f"**features:** {features_str}  \n"
+
+        # Parameter Store metadata
+        model_name = summary["name"]
+        meta_data = self.params.get(f"/workbench/models/{model_name}/meta", warn=False)
+        if meta_data:
+            markdown += dict_to_markdown(meta_data, title="Additional Metadata")
+
+        # Tags
+        markdown += tags_to_markdown(summary.get("workbench_tags", "")) + "  \n"
+
+        # Hyperparameters
+        hyperparams = summary.get("hyperparameters")
+        if hyperparams and isinstance(hyperparams, dict):
+            markdown += dict_to_collapsible_html(hyperparams, title="Hyperparameters", collapse_all=True)
 
         return markdown
 
@@ -205,15 +180,14 @@ class ModelDetails(PluginInterface):
             markdown += "  \nNo Data  \n"
         else:
             markdown += "  \n"
-            metrics = metrics.round(3)
 
             # If the model is a classification model, have the index sorting match the class labels
             if self.current_model.model_type == ModelType.CLASSIFIER:
-                # Sort the metrics by the class labels (if they match)
                 class_labels = self.current_model.class_labels()
                 if set(metrics.index) == set(class_labels):
                     metrics = metrics.reindex(class_labels)
-            markdown += metrics.to_markdown()
+
+            markdown += df_to_html_table(metrics)
 
         # Get additional inference metrics if they exist
         model_name = self.current_model.name
@@ -223,17 +197,6 @@ class ModelDetails(PluginInterface):
             markdown += dict_to_markdown(inference_data, title="Additional Inference Metrics")
         return markdown
 
-    def cross_metrics(self) -> str:
-        # Get cross fold metrics if they exist
-        model_name = self.current_model.name
-        cross_fold_data = self.params.get(f"/workbench/models/{model_name}/inference/cross_fold", warn=False)
-        if not cross_fold_data:
-            return "**No Cross Fold Data**"
-
-        # Convert the cross fold data to a markdown string
-        html = dict_to_collapsible_html(cross_fold_data)
-        return html
-
     def get_inference_runs(self):
         """Get the inference runs for the model
 
@@ -249,8 +212,13 @@ class ModelDetails(PluginInterface):
         if not inference_runs:
             return [], None
 
-        # Set "auto_inference" as the default, if that doesn't exist, set the first
-        default_inference_run = "auto_inference" if "auto_inference" in inference_runs else inference_runs[0]
+        # Default inference run (full_cross_fold if it exists, then auto_inference, then first)
+        if "full_cross_fold" in inference_runs:
+            default_inference_run = "full_cross_fold"
+        elif "auto_inference" in inference_runs:
+            default_inference_run = "auto_inference"
+        else:
+            default_inference_run = inference_runs[0]
 
         # Return the options for the dropdown and the selected value
         return inference_runs, default_inference_run