ruff unsafe fixes

Author: paulbkoch

python/interpret-api/interpret/newapi/explanation.py

@@ -24,9 +24,8 @@ def __init__(self, **kwargs):
     # TODO: Needs further discussion at design-level.
     def append(self, component):
         if not isinstance(component, Component):
-            raise Exception(
-                f"Can't append object of type {type(component)} to this object."
-            )
+            msg = f"Can't append object of type {type(component)} to this object."
+            raise Exception(msg)
 
         self.components[type(component)] = component
         for field_name, field_value in component.fields.items():
@@ -44,8 +43,8 @@ def __repr__(self):
         shape_str = f"shape: {self.shape}"
         fields.append(shape_str)
         fields.append("-" * len(shape_str))
-        for record_key, record_val in record.items():
-            for field_name, field_val in record_val.fields.items():
+        for record_val in record.values():
+            for field_name in record_val.fields:
                 field_value = str(self.__getattr__(field_name))
 
                 if field_name in self._dims:
@@ -68,17 +67,14 @@ def __repr__(self):
                 if len(field_value_str) > 60:
                     field_value_str = field_value_str[:57] + "..."
                 fields.append(field_value_str)
-        fields = "\n".join(fields)
-
-        return fields
+        return "\n".join(fields)
 
     @classmethod
     def from_json(cls, json_str):
         from interpret.newapi.serialization import ExplanationJSONDecoder
 
         d = json.loads(json_str, cls=ExplanationJSONDecoder)
-        instance = d["content"]
-        return instance
+        return d["content"]
 
     @classmethod
     def from_components(cls, components):

python/interpret-core/interpret/api/templates.py

@@ -126,15 +126,20 @@ def visualize(self, key=None, title=None):
                         perf=perf[key],
                     )
                 # pragma: no cover
-                raise RuntimeError(f"Visual provider {provider} not supported")
+                msg = f"Visual provider {provider} not supported"
+                raise RuntimeError(msg)
             is_multiclass = is_multiclass_local_data_dict(data_dict)
             if is_multiclass:
                 # Sort by predicted class' abs feature values
                 pred_idx = data_dict["perf"]["predicted"]
-                sort_fn = lambda x: -abs(x[pred_idx])
+
+                def sort_fn(x):
+                    return -abs(x[pred_idx])
             else:
                 # Sort by abs feature values
-                sort_fn = lambda x: -abs(x)
+                def sort_fn(x):
+                    return -abs(x)
+
             data_dict = sort_take(
                 data_dict, sort_fn=sort_fn, top_n=15, reverse_results=True
             )
@@ -146,7 +151,7 @@ def visualize(self, key=None, title=None):
             title = self.feature_names[key]
         if feature_type == "continuous":
             return plot_line(data_dict, title=title)
-        if feature_type == "nominal" or feature_type == "ordinal":
+        if feature_type in ("nominal", "ordinal"):
             return plot_bar(data_dict, title=title)
         if feature_type == "interaction":
             # TODO: Generalize this out.
@@ -157,6 +162,7 @@ def visualize(self, key=None, title=None):
             )
 
         # Handle everything else as invalid
+        msg = f"Not supported configuration: {self.explanation_type}, {feature_type}"
         raise Exception(  # pragma: no cover
-            f"Not supported configuration: {self.explanation_type}, {feature_type}"
+            msg
         )

python/interpret-core/interpret/blackbox/_lime.py

@@ -76,7 +76,8 @@ def explain_local(self, X, y=None, name=None, **kwargs):
         if y is not None:
             y = clean_dimensions(y, "y")
             if y.ndim != 1:
-                raise ValueError("y must be 1 dimensional")
+                msg = "y must be 1 dimensional"
+                raise ValueError(msg)
             n_samples = len(y)
 
         X, n_samples = preclean_X(
@@ -85,7 +86,8 @@ def explain_local(self, X, y=None, name=None, **kwargs):
 
         predict_fn, n_classes, classes = determine_classes(self.model, X, n_samples)
         if n_classes >= 3:
-            raise Exception("multiclass LIME not supported")
+            msg = "multiclass LIME not supported"
+            raise Exception(msg)
         predict_fn = unify_predict_fn(predict_fn, X, 1 if n_classes == 2 else -1)
 
         X, _, _ = unify_data(

python/interpret-core/interpret/blackbox/_partialdependence.py

@@ -18,8 +18,7 @@ def _unique_grid_points(values):
 
 def _percentile_grid_points(values, num_points=10):
     percentiles = np.linspace(0, 100, num=num_points)
-    grid_points = np.percentile(values, percentiles)
-    return grid_points
+    return np.percentile(values, percentiles)
 
 
 # def _equal_spaced_grid_points(values, num_points=10):
@@ -37,11 +36,7 @@ def _gen_pdp(
     num_ice_samples=10,
 ):
     num_uniq_vals = len(np.unique(X[:, col_idx]))
-    if (
-        feature_type == "nominal"
-        or feature_type == "ordinal"
-        or num_uniq_vals <= num_points
-    ):
+    if feature_type in ("nominal", "ordinal") or num_uniq_vals <= num_points:
         grid_points = _unique_grid_points(X[:, col_idx])
         values, counts = np.unique(X[:, col_idx], return_counts=True)
     else:
@@ -109,7 +104,8 @@ def __init__(
 
         predict_fn, n_classes, _ = determine_classes(model, data, n_samples)
         if n_classes >= 3:
-            raise Exception("multiclass PDP not supported")
+            msg = "multiclass PDP not supported"
+            raise Exception(msg)
         predict_fn = unify_predict_fn(predict_fn, data, 1 if n_classes == 2 else -1)
 
         data, self.feature_names_in_, self.feature_types_in_ = unify_data(
@@ -121,7 +117,7 @@ def __init__(
 
         pdps = []
         unique_val_counts = np.zeros(len(self.feature_names_in_), dtype=np.int64)
-        for col_idx, feature in enumerate(self.feature_names_in_):
+        for col_idx, _feature in enumerate(self.feature_names_in_):
             feature_type = self.feature_types_in_[col_idx]
             pdp = _gen_pdp(
                 data,
@@ -156,7 +152,7 @@ def explain_global(self, name=None):
         data_dicts = []
         feature_list = []
         density_list = []
-        for col_idx, feature in enumerate(self.feature_names_in_):
+        for col_idx, _feature in enumerate(self.feature_names_in_):
             pdp = self.pdps_[col_idx]
             feature_dict = {
                 "feature_values": pdp["values"],
@@ -259,10 +255,11 @@ def visualize(self, key=None):
         feature_name = self.feature_names[key]
         if feature_type == "continuous":
             figure = plot_line(data_dict, title=feature_name)
-        elif feature_type == "nominal" or feature_type == "ordinal":
+        elif feature_type in ("nominal", "ordinal"):
             figure = plot_bar(data_dict, title=feature_name)
         else:
-            raise Exception(f"Feature type {feature_type} is not supported.")
+            msg = f"Feature type {feature_type} is not supported."
+            raise Exception(msg)
 
         figure["layout"]["yaxis1"].update(title="Average Response")
         return figure

python/interpret-core/interpret/blackbox/_sensitivity.py

@@ -78,7 +78,8 @@ def __init__(
 
         predict_fn, n_classes, _ = determine_classes(model, data, n_samples)
         if n_classes >= 3:
-            raise Exception("multiclass MorrisSensitivity not supported")
+            msg = "multiclass MorrisSensitivity not supported"
+            raise Exception(msg)
         predict_fn = unify_predict_fn(predict_fn, data, 1 if n_classes == 2 else -1)
 
         data, self.feature_names_in_, self.feature_types_in_ = unify_data(
@@ -112,7 +113,7 @@ def __init__(
         )
 
         unique_val_counts = np.zeros(len(self.feature_names_in_), dtype=np.int64)
-        for col_idx, feature in enumerate(self.feature_names_in_):
+        for col_idx, _feature in enumerate(self.feature_names_in_):
             X_col = data[:, col_idx]
             unique_val_counts[col_idx] = len(np.unique(X_col))
 
@@ -138,7 +139,7 @@ def explain_global(self, name=None):
         }
 
         specific_data_dicts = []
-        for feat_idx, feature_name in enumerate(self.feature_names_in_):
+        for feat_idx, _feature_name in enumerate(self.feature_names_in_):
             specific_data_dict = {
                 "type": "morris",
                 "mu": self.mu_[feat_idx],
@@ -193,7 +194,7 @@ def __init__(
             selector: A dataframe whose indices correspond to explanation entries.
         """
 
-        super(MorrisExplanation, self).__init__(
+        super().__init__(
             explanation_type,
             internal_obj,
             feature_names=feature_names,
@@ -223,11 +224,10 @@ def visualize(self, key=None):
             data_dict = sort_take(
                 data_dict, sort_fn=lambda x: -abs(x), top_n=15, reverse_results=True
             )
-            title = "Morris Sensitivity<br>Convergence Index: {0:.3f}".format(
+            title = "Morris Sensitivity<br>Convergence Index: {:.3f}".format(
                 data_dict["convergence_index"]
             )
-            figure = plot_horizontal_bar(data_dict, start_zero=True, title=title)
-            return figure
+            return plot_horizontal_bar(data_dict, start_zero=True, title=title)
 
         if self.explanation_type == "global" and key is not None:
             multi_html_template = r"""
@@ -282,10 +282,9 @@ def visualize(self, key=None):
                 mu_star_conf=data_dict["mu_star_conf"],
             )
 
-            html_str = multi_html_template.format(
+            return multi_html_template.format(
                 feature_name=self.feature_names[key], analyses=analysis
             )
-            return html_str
 
         return super().visualize(key)
 
@@ -312,9 +311,8 @@ def _soft_min_max(values, soft_add=1, soft_bounds=1):
 
 def _gen_problem_from_data(data, feature_names):
     bounds = [_soft_min_max(data[:, i]) for i, _ in enumerate(feature_names)]
-    problem = {
+    return {
         "num_vars": len(feature_names),
         "names": feature_names,
         "bounds": bounds,
     }
-    return problem

python/interpret-core/interpret/blackbox/_shap.py

@@ -38,7 +38,8 @@ def __init__(self, model, data, feature_names=None, feature_types=None, **kwargs
 
         predict_fn, n_classes, _ = determine_classes(model, data, n_samples)
         if n_classes >= 3:
-            raise Exception("multiclass SHAP not supported")
+            msg = "multiclass SHAP not supported"
+            raise Exception(msg)
         predict_fn = unify_predict_fn(predict_fn, data, 1 if n_classes == 2 else -1)
 
         data, self.feature_names_in_, self.feature_types_in_ = unify_data(