SHAP Benchmark
\n"
- # out += "\n"
- #out += ""
-
- out += "\n" # box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2), 0 6px 20px 0 rgba(0, 0, 0, 0.19);
- out += "\n"
- for ind,model in enumerate(model_names):
- row_keys, col_keys, data = make_grid(scores, dataset, model)
-# print(data)
-# print(colors.red_blue_solid(0.))
-# print(colors.red_blue_solid(1.))
-# return
- for metric in col_keys:
- save_plot = False
- if metric.startswith("human_"):
- plot_human(dataset, model, metric)
- save_plot = True
- elif metric not in ["local_accuracy", "runtime", "consistency_guarantees"]:
- plot_curve(dataset, model, metric)
- save_plot = True
-
- if save_plot:
- buf = io.BytesIO()
- pl.gcf().set_size_inches(1200.0/175,1000.0/175)
- pl.savefig(buf, format='png', dpi=175)
- if out_dir is not None:
- pl.savefig(f"{out_dir}/plot_{dataset}_{model}_{metric}.pdf", format='pdf')
- pl.close()
- buf.seek(0)
- data_uri = base64.b64encode(buf.read()).decode('utf-8').replace('\n', '')
- plot_id = "plot__"+dataset+"__"+model+"__"+metric
- prefix += f""
-
- model_title = getattr(models, dataset+"__"+model).__doc__.split("\n")[0].strip()
-
- if ind == 0:
- out += "
\n"
- out += "| " - for j in range(data.shape[1]): - metric_title = getattr(metrics, col_keys[j]).__doc__.split("\n")[0].strip() - out += " | " + metric_title + " | "
- out += "
" % data_uri
- prefix += "| %s | ||
%s | " % (data.shape[0], model_name)
- method_title = getattr(methods, row_keys[i]).__doc__.split("\n")[0].strip()
- out += "" + method_title + " | \n" - for j in range(data.shape[1]): - plot_id = "plot__"+dataset+"__"+model+"__"+col_keys[j] - out += "" % plot_id - #out += "" - out += "" - #out += "" - out += " | \n" - out += "
\n"
- out += "
\n"
-
- # output the legend
- out += "SHAP Benchmark v"+__version__+"
\n"
-# select {
-# margin: 50px;
-# width: 150px;
-# padding: 5px 35px 5px 5px;
-# font-size: 16px;
-# border: 1px solid #ccc;
-# height: 34px;
-# -webkit-appearance: none;
-# -moz-appearance: none;
-# appearance: none;
-# background: url(http://www.stackoverflow.com/favicon.ico) 96% / 15% no-repeat #eee;
-# }
- #out += "Dataset:
\n"
-
- out += "\n"
- #out += ""
- #out += "CRIC
\n"
- out += "| Higher score |
| " - val = (legend_size-i-1) / (legend_size-1) - out += "" - out += " | " - out += "
| Lower score |
- Visualization omitted, Javascript library not loaded!
- Have you run `initjs()` in this notebook? If this notebook was from another - user you must also trust this notebook (File -> Trust notebook). If you are viewing - this notebook on github the Javascript has been stripped for security. If you are using - JupyterLab this error is because a JupyterLab extension has not yet been written. -
"""
-
-
-def getjs():
- bundle_path = os.path.join(os.path.split(__file__)[0], "resources", "bundle.js")
- with open(bundle_path, encoding="utf-8") as f:
- bundle_data = f.read()
- return f""
-
-
-def initjs():
- """Initialize the necessary javascript libraries for interactive force plots.
-
- Run this only in a notebook environment with IPython installed.
- """
- assert have_ipython, "IPython must be installed to use initjs()! Run `pip install ipython` and then restart shap."
-
- logo_path = os.path.join(os.path.split(__file__)[0], "resources", "logoSmallGray.png")
- with open(logo_path, "rb") as f:
- logo_data = f.read()
- logo_data = base64.b64encode(logo_data).decode("utf-8")
- display(HTML(
- f"- Have you run `initjs()` in this notebook? If this notebook was from another - user you must also trust this notebook (File -> Trust notebook). If you are viewing - this notebook on github the Javascript has been stripped for security. If you are using - JupyterLab this error is because a JupyterLab extension has not yet been written. -
{err_msg}
- """
-
- def _repr_html_(self):
- return self.html()
-
-
-class AdditiveForceVisualizer(BaseVisualizer):
- """Visualizer for a single Additive Force plot."""
-
- def __init__(self, e, plot_cmap="RdBu"):
- """
-
- Parameters
- ----------
- e : AdditiveExplanation
- Contains the data necessary for additive force plots.
-
- plot_cmap : str or list[str]
- Color map to use. It can be a string (defaults to ``RdBu``) or a list of hex color strings.
- """
- if not isinstance(e, AdditiveExplanation):
- emsg = "AdditiveForceVisualizer can only visualize AdditiveExplanation objects!"
- raise TypeError(emsg)
-
- # build the json data
- features = {}
- for i in filter(lambda j: e.effects[j] != 0, range(len(e.data.group_names))):
- features[i] = {
- "effect": ensure_not_numpy(e.effects[i]),
- "value": ensure_not_numpy(e.instance.group_display_values[i])
- }
- self.data = {
- "outNames": e.model.out_names,
- "baseValue": ensure_not_numpy(e.base_value),
- "outValue": ensure_not_numpy(e.out_value),
- "link": str(e.link),
- "featureNames": e.data.group_names,
- "features": features,
- "plot_cmap": plot_cmap,
- }
-
- def html(self, label_margin=20):
- # assert have_ipython, "IPython must be installed to use this visualizer! Run `pip install ipython` and then restart shap."
- self.data["labelMargin"] = label_margin
- generated_id = id_generator()
- return f"""
-{err_msg}
- """
-
- def matplotlib(self, figsize, show, text_rotation, min_perc=0.05):
- fig = draw_additive_plot(self.data,
- figsize=figsize,
- show=show,
- text_rotation=text_rotation,
- min_perc=min_perc)
-
- return fig
-
- def _repr_html_(self):
- return self.html()
-
-
-class AdditiveForceArrayVisualizer(BaseVisualizer):
- """Visualizer for a sequence of AdditiveExplanation, as a stacked force plot."""
-
- def __init__(self, arr, plot_cmap="RdBu", ordering_keys=None, ordering_keys_time_format=None):
- if not isinstance(arr[0], AdditiveExplanation):
- emsg = (
- "AdditiveForceArrayVisualizer can only visualize arrays of "
- "AdditiveExplanation objects!"
- )
- raise TypeError(emsg)
-
- # order the samples by their position in a hierarchical clustering
- if all(e.model.f == arr[1].model.f for e in arr):
- clustOrder = hclust_ordering(np.vstack([e.effects for e in arr]))
- else:
- emsg = "Tried to visualize an array of explanations from different models!"
- raise ValueError(emsg)
-
- # make sure that we put the higher predictions first...just for consistency
- if sum(arr[clustOrder[0]].effects) < sum(arr[clustOrder[-1]].effects):
- np.flipud(clustOrder) # reverse
-
- # build the json data
- clustOrder = np.argsort(clustOrder) # inverse permutation
- self.data = {
- "outNames": arr[0].model.out_names,
- "baseValue": ensure_not_numpy(arr[0].base_value),
- "link": arr[0].link.__str__(),
- "featureNames": arr[0].data.group_names,
- "explanations": [],
- "plot_cmap": plot_cmap,
- "ordering_keys": list(ordering_keys) if hasattr(ordering_keys, '__iter__') else None,
- "ordering_keys_time_format": ordering_keys_time_format,
- }
- for ind, e in enumerate(arr):
- self.data["explanations"].append({
- "outValue": ensure_not_numpy(e.out_value),
- "simIndex": ensure_not_numpy(clustOrder[ind])+1,
- "features": {}
- })
- for i in filter(lambda j: e.effects[j] != 0 or e.instance.x[0,j] != 0, range(len(e.data.group_names))):
- self.data["explanations"][-1]["features"][i] = {
- "effect": ensure_not_numpy(e.effects[i]),
- "value": ensure_not_numpy(e.instance.group_display_values[i])
- }
-
- def html(self):
- # assert have_ipython, "IPython must be installed to use this visualizer! Run `pip install ipython` and then restart shap."
- return """
-{err_msg}
- """.format(err_msg=err_msg, data=json.dumps(self.data), id=id_generator())
-
- def _repr_html_(self):
- return self.html()
diff --git a/lib/shap/plots/_force_matplotlib.py b/lib/shap/plots/_force_matplotlib.py
deleted file mode 100644
index e07f4dc3d7c7d5e3b22946689a2a62a96555d1fd..0000000000000000000000000000000000000000
--- a/lib/shap/plots/_force_matplotlib.py
+++ /dev/null
@@ -1,408 +0,0 @@
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib import lines
-from matplotlib.font_manager import FontProperties
-from matplotlib.patches import PathPatch
-from matplotlib.path import Path
-
-
-def draw_bars(out_value, features, feature_type, width_separators, width_bar):
- """Draw the bars and separators."""
- rectangle_list = []
- separator_list = []
-
- pre_val = out_value
- for index, features in zip(range(len(features)), features):
- if feature_type == 'positive':
- left_bound = float(features[0])
- right_bound = pre_val
- pre_val = left_bound
-
- separator_indent = np.abs(width_separators)
- separator_pos = left_bound
- colors = ['#FF0D57', '#FFC3D5']
- else:
- left_bound = pre_val
- right_bound = float(features[0])
- pre_val = right_bound
-
- separator_indent = - np.abs(width_separators)
- separator_pos = right_bound
- colors = ['#1E88E5', '#D1E6FA']
-
- # Create rectangle
- if index == 0:
- if feature_type == 'positive':
- points_rectangle = [[left_bound, 0],
- [right_bound, 0],
- [right_bound, width_bar],
- [left_bound, width_bar],
- [left_bound + separator_indent, (width_bar / 2)]
- ]
- else:
- points_rectangle = [[right_bound, 0],
- [left_bound, 0],
- [left_bound, width_bar],
- [right_bound, width_bar],
- [right_bound + separator_indent, (width_bar / 2)]
- ]
-
- else:
- points_rectangle = [[left_bound, 0],
- [right_bound, 0],
- [right_bound + separator_indent * 0.90, (width_bar / 2)],
- [right_bound, width_bar],
- [left_bound, width_bar],
- [left_bound + separator_indent * 0.90, (width_bar / 2)]]
-
- line = plt.Polygon(points_rectangle, closed=True, fill=True,
- facecolor=colors[0], linewidth=0)
- rectangle_list += [line]
-
- # Create separator
- points_separator = [[separator_pos, 0],
- [separator_pos + separator_indent, (width_bar / 2)],
- [separator_pos, width_bar]]
-
- line = plt.Polygon(points_separator, closed=None, fill=None,
- edgecolor=colors[1], lw=3)
- separator_list += [line]
-
- return rectangle_list, separator_list
-
-
-def draw_labels(fig, ax, out_value, features, feature_type, offset_text, total_effect=0, min_perc=0.05, text_rotation=0):
- start_text = out_value
- pre_val = out_value
-
- # Define variables specific to positive and negative effect features
- if feature_type == 'positive':
- colors = ['#FF0D57', '#FFC3D5']
- alignment = 'right'
- sign = 1
- else:
- colors = ['#1E88E5', '#D1E6FA']
- alignment = 'left'
- sign = -1
-
- # Draw initial line
- if feature_type == 'positive':
- x, y = np.array([[pre_val, pre_val], [0, -0.18]])
- line = lines.Line2D(x, y, lw=1., alpha=0.5, color=colors[0])
- line.set_clip_on(False)
- ax.add_line(line)
- start_text = pre_val
-
- box_end = out_value
- val = out_value
- for feature in features:
- # Exclude all labels that do not contribute at least 10% to the total
- feature_contribution = np.abs(float(feature[0]) - pre_val) / np.abs(total_effect)
- if feature_contribution < min_perc:
- break
-
- # Compute value for current feature
- val = float(feature[0])
-
- # Draw labels.
- if feature[1] == "":
- text = feature[2]
- else:
- text = feature[2] + ' = ' + feature[1]
-
- if text_rotation != 0:
- va_alignment = 'top'
- else:
- va_alignment = 'baseline'
-
- text_out_val = plt.text(start_text - sign * offset_text,
- -0.15, text,
- fontsize=12, color=colors[0],
- horizontalalignment=alignment,
- va=va_alignment,
- rotation=text_rotation)
- text_out_val.set_bbox(dict(facecolor='none', edgecolor='none'))
-
- # We need to draw the plot to be able to get the size of the
- # text box
- fig.canvas.draw()
- box_size = text_out_val.get_bbox_patch().get_extents()\
- .transformed(ax.transData.inverted())
- if feature_type == 'positive':
- box_end_ = box_size.get_points()[0][0]
- else:
- box_end_ = box_size.get_points()[1][0]
-
- # If the feature goes over the side of the plot, we remove that label
- # and stop drawing labels
- if box_end_ > ax.get_xlim()[1]:
- text_out_val.remove()
- break
-
- # Create end line
- if (sign * box_end_) > (sign * val):
- x, y = np.array([[val, val], [0, -0.18]])
- line = lines.Line2D(x, y, lw=1., alpha=0.5, color=colors[0])
- line.set_clip_on(False)
- ax.add_line(line)
- start_text = val
- box_end = val
-
- else:
- box_end = box_end_ - sign * offset_text
- x, y = np.array([[val, box_end, box_end],
- [0, -0.08, -0.18]])
- line = lines.Line2D(x, y, lw=1., alpha=0.5, color=colors[0])
- line.set_clip_on(False)
- ax.add_line(line)
- start_text = box_end
-
- # Update previous value
- pre_val = float(feature[0])
-
-
- # Create line for labels
- extent_shading = [out_value, box_end, 0, -0.31]
- path = [[out_value, 0], [pre_val, 0], [box_end, -0.08],
- [box_end, -0.2], [out_value, -0.2],
- [out_value, 0]]
-
- path = Path(path)
- patch = PathPatch(path, facecolor='none', edgecolor='none')
- ax.add_patch(patch)
-
- # Extend axis if needed
- lower_lim, upper_lim = ax.get_xlim()
- if (box_end < lower_lim):
- ax.set_xlim(box_end, upper_lim)
-
- if (box_end > upper_lim):
- ax.set_xlim(lower_lim, box_end)
-
- # Create shading
- if feature_type == 'positive':
- colors = np.array([(255, 13, 87), (255, 255, 255)]) / 255.
- else:
- colors = np.array([(30, 136, 229), (255, 255, 255)]) / 255.
-
- cm = matplotlib.colors.LinearSegmentedColormap.from_list('cm', colors)
-
- _, Z2 = np.meshgrid(np.linspace(0, 10), np.linspace(-10, 10))
- im = plt.imshow(Z2, interpolation='quadric', cmap=cm,
- vmax=0.01, alpha=0.3,
- origin='lower', extent=extent_shading,
- clip_path=patch, clip_on=True, aspect='auto')
- im.set_clip_path(patch)
-
- return fig, ax
-
-
-def format_data(data):
- """Format data."""
- # Format negative features
- neg_features = np.array([[data['features'][x]['effect'],
- data['features'][x]['value'],
- data['featureNames'][x]]
- for x in data['features'].keys() if data['features'][x]['effect'] < 0])
-
- neg_features = np.array(sorted(neg_features, key=lambda x: float(x[0]), reverse=False))
-
- # Format positive features
- pos_features = np.array([[data['features'][x]['effect'],
- data['features'][x]['value'],
- data['featureNames'][x]]
- for x in data['features'].keys() if data['features'][x]['effect'] >= 0])
- pos_features = np.array(sorted(pos_features, key=lambda x: float(x[0]), reverse=True))
-
- # Define link function
- if data['link'] == 'identity':
- def convert_func(x):
- return x
- elif data['link'] == 'logit':
- def convert_func(x):
- return 1 / (1 + np.exp(-x))
- else:
- emsg = f"ERROR: Unrecognized link function: {data['link']}"
- raise ValueError(emsg)
-
- # Convert negative feature values to plot values
- neg_val = data['outValue']
- for i in neg_features:
- val = float(i[0])
- neg_val = neg_val + np.abs(val)
- i[0] = convert_func(neg_val)
- if len(neg_features) > 0:
- total_neg = np.max(neg_features[:, 0].astype(float)) - \
- np.min(neg_features[:, 0].astype(float))
- else:
- total_neg = 0
-
- # Convert positive feature values to plot values
- pos_val = data['outValue']
- for i in pos_features:
- val = float(i[0])
- pos_val = pos_val - np.abs(val)
- i[0] = convert_func(pos_val)
-
- if len(pos_features) > 0:
- total_pos = np.max(pos_features[:, 0].astype(float)) - \
- np.min(pos_features[:, 0].astype(float))
- else:
- total_pos = 0
-
- # Convert output value and base value
- data['outValue'] = convert_func(data['outValue'])
- data['baseValue'] = convert_func(data['baseValue'])
-
- return neg_features, total_neg, pos_features, total_pos
-
-
-def draw_output_element(out_name, out_value, ax):
- # Add output value
- x, y = np.array([[out_value, out_value], [0, 0.24]])
- line = lines.Line2D(x, y, lw=2., color='#F2F2F2')
- line.set_clip_on(False)
- ax.add_line(line)
-
- font0 = FontProperties()
- font = font0.copy()
- font.set_weight('bold')
- text_out_val = plt.text(out_value, 0.25, f'{out_value:.2f}',
- fontproperties=font,
- fontsize=14,
- horizontalalignment='center')
- text_out_val.set_bbox(dict(facecolor='white', edgecolor='white'))
-
- text_out_val = plt.text(out_value, 0.33, out_name,
- fontsize=12, alpha=0.5,
- horizontalalignment='center')
- text_out_val.set_bbox(dict(facecolor='white', edgecolor='white'))
-
-
-def draw_base_element(base_value, ax):
- x, y = np.array([[base_value, base_value], [0.13, 0.25]])
- line = lines.Line2D(x, y, lw=2., color='#F2F2F2')
- line.set_clip_on(False)
- ax.add_line(line)
-
- text_out_val = plt.text(base_value, 0.33, 'base value',
- fontsize=12, alpha=0.5,
- horizontalalignment='center')
- text_out_val.set_bbox(dict(facecolor='white', edgecolor='white'))
-
-
-def draw_higher_lower_element(out_value, offset_text):
- plt.text(out_value - offset_text, 0.405, 'higher',
- fontsize=13, color='#FF0D57',
- horizontalalignment='right')
-
- plt.text(out_value + offset_text, 0.405, 'lower',
- fontsize=13, color='#1E88E5',
- horizontalalignment='left')
-
- plt.text(out_value, 0.4, r'$\leftarrow$',
- fontsize=13, color='#1E88E5',
- horizontalalignment='center')
-
- plt.text(out_value, 0.425, r'$\rightarrow$',
- fontsize=13, color='#FF0D57',
- horizontalalignment='center')
-
-
-def update_axis_limits(ax, total_pos, pos_features, total_neg,
- neg_features, base_value, out_value):
- ax.set_ylim(-0.5, 0.15)
- padding = np.max([np.abs(total_pos) * 0.2,
- np.abs(total_neg) * 0.2])
-
- if len(pos_features) > 0:
- min_x = min(np.min(pos_features[:, 0].astype(float)), base_value) - padding
- else:
- min_x = out_value - padding
- if len(neg_features) > 0:
- max_x = max(np.max(neg_features[:, 0].astype(float)), base_value) + padding
- else:
- max_x = out_value + padding
- ax.set_xlim(min_x, max_x)
-
- plt.tick_params(top=True, bottom=False, left=False, right=False, labelleft=False,
- labeltop=True, labelbottom=False)
- plt.locator_params(axis='x', nbins=12)
-
- for key, spine in zip(plt.gca().spines.keys(), plt.gca().spines.values()):
- if key != 'top':
- spine.set_visible(False)
-
-
-def draw_additive_plot(data, figsize, show, text_rotation=0, min_perc=0.05):
- """Draw additive plot."""
- # Turn off interactive plot
- if show is False:
- plt.ioff()
-
- # Format data
- neg_features, total_neg, pos_features, total_pos = format_data(data)
-
- # Compute overall metrics
- base_value = data['baseValue']
- out_value = data['outValue']
- offset_text = (np.abs(total_neg) + np.abs(total_pos)) * 0.04
-
- # Define plots
- fig, ax = plt.subplots(figsize=figsize)
-
- # Compute axis limit
- update_axis_limits(ax, total_pos, pos_features, total_neg,
- neg_features, base_value, out_value)
-
- # Define width of bar
- width_bar = 0.1
- width_separators = (ax.get_xlim()[1] - ax.get_xlim()[0]) / 200
-
- # Create bar for negative shap values
- rectangle_list, separator_list = draw_bars(out_value, neg_features, 'negative',
- width_separators, width_bar)
- for i in rectangle_list:
- ax.add_patch(i)
-
- for i in separator_list:
- ax.add_patch(i)
-
- # Create bar for positive shap values
- rectangle_list, separator_list = draw_bars(out_value, pos_features, 'positive',
- width_separators, width_bar)
- for i in rectangle_list:
- ax.add_patch(i)
-
- for i in separator_list:
- ax.add_patch(i)
-
- # Add labels
- total_effect = np.abs(total_neg) + total_pos
- fig, ax = draw_labels(fig, ax, out_value, neg_features, 'negative',
- offset_text, total_effect, min_perc=min_perc, text_rotation=text_rotation)
-
- fig, ax = draw_labels(fig, ax, out_value, pos_features, 'positive',
- offset_text, total_effect, min_perc=min_perc, text_rotation=text_rotation)
-
- # higher lower legend
- draw_higher_lower_element(out_value, offset_text)
-
- # Add label for base value
- draw_base_element(base_value, ax)
-
- # Add output label
- out_names = data['outNames'][0]
- draw_output_element(out_names, out_value, ax)
-
- # Scale axis
- if data['link'] == 'logit':
- plt.xscale('logit')
- ax.xaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())
- ax.ticklabel_format(style='plain')
-
- if show:
- plt.show()
- else:
- return plt.gcf()
diff --git a/lib/shap/plots/_group_difference.py b/lib/shap/plots/_group_difference.py
deleted file mode 100644
index b983dc74d3e8eece271655a114ea0f9100b89aa1..0000000000000000000000000000000000000000
--- a/lib/shap/plots/_group_difference.py
+++ /dev/null
@@ -1,85 +0,0 @@
-import matplotlib.pyplot as pl
-import numpy as np
-
-from . import colors
-
-
-def group_difference(shap_values, group_mask, feature_names=None, xlabel=None, xmin=None, xmax=None,
- max_display=None, sort=True, show=True, ax=None):
- """ This plots the difference in mean SHAP values between two groups.
-
- It is useful to decompose many group level metrics about the model output among the
- input features. Quantitative fairness metrics for machine learning models are
- a common example of such group level metrics.
-
- Parameters
- ----------
- shap_values : numpy.array
- Matrix of SHAP values (# samples x # features) or a vector of model outputs (# samples).
-
- group_mask : numpy.array
- A boolean mask where True represents the first group of samples and False the second.
-
- feature_names : list
- A list of feature names.
- """
-
- # Compute confidence bounds for the group difference value
- vs = []
- gmean = group_mask.mean()
- for i in range(200):
- r = np.random.rand(shap_values.shape[0]) > gmean
- vs.append(shap_values[r].mean(0) - shap_values[~r].mean(0))
- vs = np.array(vs)
- xerr = np.vstack([np.percentile(vs, 95, axis=0), np.percentile(vs, 5, axis=0)])
-
- # See if we were passed a single model output vector and not a matrix of SHAP values
- if len(shap_values.shape) == 1:
- shap_values = shap_values.reshape(1, -1).T
- if feature_names is None:
- feature_names = [""]
-
- # Fill in any missing feature names
- if feature_names is None:
- feature_names = ["Feature %d" % i for i in range(shap_values.shape[1])]
-
- diff = shap_values[group_mask].mean(0) - shap_values[~group_mask].mean(0)
-
- if sort is True:
- inds = np.argsort(-np.abs(diff)).astype(int)
- else:
- inds = np.arange(len(diff))
-
- if max_display is not None:
- inds = inds[:max_display]
- if ax:
- # Disable plotting out if an ax has been provided
- show = False
- else:
- # Draw the figure if no ax has been provided
- figsize = (6.4, 0.2 + 0.9 * len(inds))
- _, ax = pl.subplots(figsize=figsize)
- ticks = range(len(inds)-1, -1, -1)
- ax.axvline(0, color="#999999", linewidth=0.5)
- ax.barh(
- ticks, diff[inds], color=colors.blue_rgb,
- capsize=3, xerr=np.abs(xerr[:,inds])
- )
-
- for i in range(len(inds)):
- ax.axhline(y=i, color="#cccccc", lw=0.5, dashes=(1, 5), zorder=-1)
-
- ax.xaxis.set_ticks_position('bottom')
- ax.yaxis.set_ticks_position('none')
- ax.set_yticks(ticks)
- ax.set_yticklabels([feature_names[i] for i in inds], fontsize=13)
- ax.spines['right'].set_visible(False)
- ax.spines['top'].set_visible(False)
- ax.spines['left'].set_visible(False)
- ax.tick_params(labelsize=11)
- if xlabel is None:
- xlabel = "Group SHAP value difference"
- ax.set_xlabel(xlabel, fontsize=13)
- ax.set_xlim(xmin, xmax)
- if show:
- pl.show()
diff --git a/lib/shap/plots/_heatmap.py b/lib/shap/plots/_heatmap.py
deleted file mode 100644
index 7a42b34f69b7b5ca4c94bda498918d1ab777ff55..0000000000000000000000000000000000000000
--- a/lib/shap/plots/_heatmap.py
+++ /dev/null
@@ -1,182 +0,0 @@
-import matplotlib.pyplot as pl
-import numpy as np
-
-from .. import Explanation
-from ..utils import OpChain
-from . import colors
-from ._labels import labels
-from ._utils import convert_ordering
-
-
-def heatmap(shap_values, instance_order=Explanation.hclust(), feature_values=Explanation.abs.mean(0),
- feature_order=None, max_display=10, cmap=colors.red_white_blue, show=True,
- plot_width=8):
- """Create a heatmap plot of a set of SHAP values.
-
- This plot is designed to show the population substructure of a dataset using supervised
- clustering and a heatmap.
- Supervised clustering involves clustering data points not by their original
- feature values but by their explanations.
- By default, we cluster using :func:`shap.utils.hclust_ordering`,
- but any clustering can be used to order the samples.
-
- Parameters
- ----------
- shap_values : shap.Explanation
- A multi-row :class:`.Explanation` object that we want to visualize in a
- cluster ordering.
-
- instance_order : OpChain or numpy.ndarray
- A function that returns a sort ordering given a matrix of SHAP values and an axis, or
- a direct sample ordering given as an ``numpy.ndarray``.
-
- feature_values : OpChain or numpy.ndarray
- A function that returns a global summary value for each input feature, or an array of such values.
-
- feature_order : None, OpChain, or numpy.ndarray
- A function that returns a sort ordering given a matrix of SHAP values and an axis, or
- a direct input feature ordering given as an ``numpy.ndarray``.
- If ``None``, then we use ``feature_values.argsort``.
-
- max_display : int
- The maximum number of features to display (default is 10).
-
- show : bool
- Whether ``matplotlib.pyplot.show()`` is called before returning.
- Setting this to ``False`` allows the plot
- to be customized further after it has been created.
-
- plot_width: int, default 8
- The width of the heatmap plot.
-
- Examples
- --------
-
- See `heatmap plot examples {ordinal_str(i)} instance:
")) - image_to_text(shap_values[i]) - - return - - uuid = ''.join(random.choices(string.ascii_lowercase, k=20)) - - # creating input html tokens - - model_output = shap_values.output_names - - output_text_html = '' - - for i in range(model_output.shape[0]): - output_text_html += "
" \
- + f"
"
-
- # computing gray scale images
- image_data = shap_values.data
- image_height = image_data.shape[0]
- image_width = image_data.shape[1]
-
- # computing gray scale image
- image_data_gray_scale = np.ones((image_height, image_width, 4)) * 255 * 0.5
- image_data_gray_scale[:, :, 0] = np.mean(image_data, axis=2).astype(int)
- image_data_gray_scale[:, :, 1] = image_data_gray_scale[:, :, 0]
- image_data_gray_scale[:, :, 2] = image_data_gray_scale[:, :, 0]
-
- # computing shap color values for every pixel and for every output token
-
- shap_values_color_maps = shap_values.values[:, :, 0, :]
- max_val = np.nanpercentile(np.abs(shap_values.values), 99.9)
-
- shap_values_color_dict = {}
-
- for index in range(model_output.shape[0]):
- shap_values_color_dict[f'{uuid}_output_flat_token_{index}'] = (colors.red_transparent_blue(
- 0.5 + 0.5 * shap_values_color_maps[:, :, index] / max_val) * 255).astype(int).tolist()
-
- # converting to json to be read in javascript
-
- image_data_json = json.dumps(shap_values.data.astype(int).tolist())
- shap_values_color_dict_json = json.dumps(shap_values_color_dict)
- image_data_gray_scale_json = json.dumps(image_data_gray_scale.astype(int).tolist())
-
- image_viz_html = f"""
-
- " \
- + "
" \
- + f"" \
- + model_output[i].replace("<", "<").replace(">", ">").replace(' ##', '').replace('▁',
- '').replace(
- 'Ġ', '') \
- + "
" \
- + "
-
-
- """
-
- image_viz_script = f"""
-
- """
-
- display(HTML(image_viz_html + image_viz_script))
diff --git a/lib/shap/plots/_labels.py b/lib/shap/plots/_labels.py
deleted file mode 100644
index 836050801aaabf99677f0d368e0ae88c6d1fabe1..0000000000000000000000000000000000000000
--- a/lib/shap/plots/_labels.py
+++ /dev/null
@@ -1,15 +0,0 @@
-labels = {
- 'MAIN_EFFECT': "SHAP main effect value for\n%s",
- 'INTERACTION_VALUE': "SHAP interaction value",
- 'INTERACTION_EFFECT': "SHAP interaction value for\n%s and %s",
- 'VALUE': "SHAP value (impact on model output)",
- 'GLOBAL_VALUE': "mean(|SHAP value|) (average impact on model output magnitude)",
- 'VALUE_FOR': "SHAP value for\n%s",
- 'PLOT_FOR': "SHAP plot for %s",
- 'FEATURE': "Feature %s",
- 'FEATURE_VALUE': "Feature value",
- 'FEATURE_VALUE_LOW': "Low",
- 'FEATURE_VALUE_HIGH': "High",
- 'JOINT_VALUE': "Joint SHAP value",
- 'MODEL_OUTPUT': "Model output value"
-}
diff --git a/lib/shap/plots/_monitoring.py b/lib/shap/plots/_monitoring.py
deleted file mode 100644
index 5a7f8d05e3804a722b5a4fd8a219fd3267dc7ec4..0000000000000000000000000000000000000000
--- a/lib/shap/plots/_monitoring.py
+++ /dev/null
@@ -1,80 +0,0 @@
-import matplotlib.pyplot as pl
-import numpy as np
-import pandas as pd
-import scipy.stats
-
-from . import colors
-from ._labels import labels
-
-
-def truncate_text(text, max_len):
- if len(text) > max_len:
- return text[:int(max_len/2)-2] + "..." + text[-int(max_len/2)+1:]
- else:
- return text
-
-def monitoring(ind, shap_values, features, feature_names=None, show=True):
- """ Create a SHAP monitoring plot.
-
- (Note this function is preliminary and subject to change!!)
- A SHAP monitoring plot is meant to display the behavior of a model
- over time. Often the shap_values given to this plot explain the loss
- of a model, so changes in a feature's impact on the model's loss over
- time can help in monitoring the model's performance.
-
- Parameters
- ----------
- ind : int
- Index of the feature to plot.
-
- shap_values : numpy.array
- Matrix of SHAP values (# samples x # features)
-
- features : numpy.array or pandas.DataFrame
- Matrix of feature values (# samples x # features)
-
- feature_names : list
- Names of the features (length # features)
- """
-
- if isinstance(features, pd.DataFrame):
- if feature_names is None:
- feature_names = features.columns
- features = features.values
-
- num_features = shap_values.shape[1]
-
- if feature_names is None:
- feature_names = np.array([labels['FEATURE'] % str(i) for i in range(num_features)])
-
- pl.figure(figsize=(10,3))
- ys = shap_values[:,ind]
- xs = np.arange(len(ys))#np.linspace(0, 12*2, len(ys))
-
- pvals = []
- inc = 50
- for i in range(inc, len(ys)-inc, inc):
- #stat, pval = scipy.stats.mannwhitneyu(v[:i], v[i:], alternative="two-sided")
- _, pval = scipy.stats.ttest_ind(ys[:i], ys[i:])
- pvals.append(pval)
- min_pval = np.min(pvals)
- min_pval_ind = np.argmin(pvals)*inc + inc
-
- if min_pval < 0.05 / shap_values.shape[1]:
- pl.axvline(min_pval_ind, linestyle="dashed", color="#666666", alpha=0.2)
-
- pl.scatter(xs, ys, s=10, c=features[:,ind], cmap=colors.red_blue)
-
- pl.xlabel("Sample index")
- pl.ylabel(truncate_text(feature_names[ind], 30) + "\nSHAP value", size=13)
- pl.gca().xaxis.set_ticks_position('bottom')
- pl.gca().yaxis.set_ticks_position('left')
- pl.gca().spines['right'].set_visible(False)
- pl.gca().spines['top'].set_visible(False)
- cb = pl.colorbar()
- cb.outline.set_visible(False)
- bbox = cb.ax.get_window_extent().transformed(pl.gcf().dpi_scale_trans.inverted())
- cb.ax.set_aspect((bbox.height - 0.7) * 20)
- cb.set_label(truncate_text(feature_names[ind], 30), size=13)
- if show:
- pl.show()
diff --git a/lib/shap/plots/_partial_dependence.py b/lib/shap/plots/_partial_dependence.py
deleted file mode 100644
index 4935079a679b4a84878dad3d5ee1f8939d40c51a..0000000000000000000000000000000000000000
--- a/lib/shap/plots/_partial_dependence.py
+++ /dev/null
@@ -1,246 +0,0 @@
-import matplotlib.pyplot as pl
-import numpy as np
-import pandas as pd
-
-from .. import Explanation
-from ..plots.colors import blue_rgb, light_blue_rgb, red_blue_transparent, red_rgb
-from ..utils import convert_name
-
-
-def compute_bounds(xmin, xmax, xv):
- """ Handles any setting of xmax and xmin.
-
- Note that we handle None, float, or "percentile(float)" formats.
- """
-
- if xmin is not None or xmax is not None:
- if isinstance(xmin, str) and xmin.startswith("percentile"):
- xmin = np.nanpercentile(xv, float(xmin[11:-1]))
- if isinstance(xmax, str) and xmax.startswith("percentile"):
- xmax = np.nanpercentile(xv, float(xmax[11:-1]))
-
- if xmin is None or xmin == np.nanmin(xv):
- xmin = np.nanmin(xv) - (xmax - np.nanmin(xv))/20
- if xmax is None or xmax == np.nanmax(xv):
- xmax = np.nanmax(xv) + (np.nanmax(xv) - xmin)/20
-
- return (xmin, xmax)
-
-def partial_dependence(ind, model, data, xmin="percentile(0)", xmax="percentile(100)",
- npoints=None, feature_names=None, hist=True, model_expected_value=False,
- feature_expected_value=False, shap_values=None,
- ylabel=None, ice=True, ace_opacity=1, pd_opacity=1, pd_linewidth=2,
- ace_linewidth='auto', ax=None, show=True):
- """ A basic partial dependence plot function.
- """
-
- if isinstance(data, Explanation):
- features = data.data
- shap_values = data
- else:
- features = data
-
- # convert from DataFrames if we got any
- use_dataframe = False
- if isinstance(features, pd.DataFrame):
- if feature_names is None:
- feature_names = features.columns
- features = features.values
- use_dataframe = True
-
- if feature_names is None:
- feature_names = ["Feature %d" % i for i in range(features.shape[1])]
-
- # this is for a 1D partial dependence plot
- if type(ind) is not tuple:
- ind = convert_name(ind, None, feature_names)
- xv = features[:,ind]
- xmin, xmax = compute_bounds(xmin, xmax, xv)
- npoints = 100 if npoints is None else npoints
- xs = np.linspace(xmin, xmax, npoints)
-
-
- if ice:
- features_tmp = features.copy()
- ice_vals = np.zeros((npoints, features.shape[0]))
- for i in range(npoints):
- features_tmp[:,ind] = xs[i]
- if use_dataframe:
- ice_vals[i,:] = model(pd.DataFrame(features_tmp, columns=feature_names))
- else:
- ice_vals[i,:] = model(features_tmp)
- # if linewidth is None:
- # linewidth = 1
- # if opacity is None:
- # opacity = 0.5
-
- features_tmp = features.copy()
- vals = np.zeros(npoints)
- for i in range(npoints):
- features_tmp[:,ind] = xs[i]
- if use_dataframe:
- vals[i] = model(pd.DataFrame(features_tmp, columns=feature_names)).mean()
- else:
- vals[i] = model(features_tmp).mean()
-
-
-
-
- if ax is None:
- fig = pl.figure()
- ax1 = pl.gca()
- else:
- fig = pl.gcf()
- ax1 = pl.gca()
-
- #fig, ax1 = pl.subplots(figsize)
- ax2 = ax1.twinx()
-
- # the histogram of the data
- if hist:
- #n, bins, patches =
- ax2.hist(xv, 50, density=False, facecolor='black', alpha=0.1, range=(xmin, xmax))
-
-
-
- # ice line plot
- if ice:
- if ace_linewidth == "auto":
- ace_linewidth = min(1, 50/ice_vals.shape[1])
- ax1.plot(xs, ice_vals, color=light_blue_rgb, linewidth=ace_linewidth, alpha=ace_opacity)
-
- # the line plot
- ax1.plot(xs, vals, color=blue_rgb, linewidth=pd_linewidth, alpha=pd_opacity)
-
- ax2.set_ylim(0,features.shape[0])#ax2.get_ylim()[0], ax2.get_ylim()[1] * 4)
- ax1.set_xlabel(feature_names[ind], fontsize=13)
- if ylabel is None:
- if not ice:
- ylabel = "E[f(x) | "+ str(feature_names[ind]) + "]"
- else:
- ylabel = "f(x) | "+ str(feature_names[ind])
- ax1.set_ylabel(ylabel, fontsize=13)
- ax1.xaxis.set_ticks_position('bottom')
- ax1.yaxis.set_ticks_position('left')
- ax1.spines['right'].set_visible(False)
- ax1.spines['top'].set_visible(False)
- ax1.tick_params(labelsize=11)
-
- ax2.xaxis.set_ticks_position('bottom')
- ax2.yaxis.set_ticks_position('left')
- ax2.yaxis.set_ticks([])
- ax2.spines['right'].set_visible(False)
- ax2.spines['top'].set_visible(False)
- ax2.spines['left'].set_visible(False)
- ax2.spines['bottom'].set_visible(False)
-
-
- if feature_expected_value is not False:
- ax3=ax2.twiny()
- ax3.set_xlim(xmin,xmax)
- mval = xv.mean()
- ax3.set_xticks([mval])
- ax3.set_xticklabels(["E["+str(feature_names[ind])+"]"])
- ax3.spines['right'].set_visible(False)
- ax3.spines['top'].set_visible(False)
- ax3.tick_params(length=0, labelsize=11)
- ax1.axvline(mval, color="#999999", zorder=-1, linestyle="--", linewidth=1)
-
- if model_expected_value is not False or shap_values is not None:
- if model_expected_value is True:
- if use_dataframe:
- model_expected_value = model(pd.DataFrame(features, columns=feature_names)).mean()
- else:
- model_expected_value = model(features).mean()
- else:
- model_expected_value = shap_values.base_values
- ymin,ymax = ax1.get_ylim()
- ax4=ax2.twinx()
- ax4.set_ylim(ymin,ymax)
- ax4.set_yticks([model_expected_value])
- ax4.set_yticklabels(["E[f(x)]"])
- ax4.spines['right'].set_visible(False)
- ax4.spines['top'].set_visible(False)
- ax4.tick_params(length=0, labelsize=11)
- ax1.axhline(model_expected_value, color="#999999", zorder=-1, linestyle="--", linewidth=1)
-
- if shap_values is not None:
- # vals = shap_values.values[:, ind]
- # if shap_value_features is None:
- # shap_value_features = features
- # assert shap_values.shape == features.shape
- # #sample_ind = 18
- # vals = shap_values[:, ind]
- # if type(model_expected_value) is bool:
- # if use_dataframe:
- # model_expected_value = model(pd.DataFrame(features, columns=feature_names)).mean()
- # else:
- # model_expected_value = model(features).mean()
- # if isinstance(shap_value_features, pd.DataFrame):
- # shap_value_features = shap_value_features.values
- markerline, stemlines, _ = ax1.stem(
- shap_values.data[:,ind], shap_values.base_values + shap_values.values[:, ind],
- bottom=shap_values.base_values,
- markerfmt="o", basefmt=" ",
- )
- stemlines.set_edgecolors([red_rgb if v > 0 else blue_rgb for v in vals])
- pl.setp(stemlines, 'zorder', -1)
- pl.setp(stemlines, 'linewidth', 2)
- pl.setp(markerline, 'color', "black")
- pl.setp(markerline, 'markersize', 4)
-
- if show:
- pl.show()
- else:
- return fig,ax1
-
-
- # this is for a 2D partial dependence plot
- else:
- ind0 = convert_name(ind[0], None, feature_names)
- ind1 = convert_name(ind[1], None, feature_names)
- xv0 = features[:,ind0]
- xv1 = features[:,ind1]
-
- xmin0 = xmin[0] if type(xmin) is tuple else xmin
- xmin1 = xmin[1] if type(xmin) is tuple else xmin
- xmax0 = xmax[0] if type(xmax) is tuple else xmax
- xmax1 = xmax[1] if type(xmax) is tuple else xmax
-
- xmin0, xmax0 = compute_bounds(xmin0, xmax0, xv0)
- xmin1, xmax1 = compute_bounds(xmin1, xmax1, xv1)
- npoints = 20 if npoints is None else npoints
- xs0 = np.linspace(xmin0, xmax0, npoints)
- xs1 = np.linspace(xmin1, xmax1, npoints)
-
- features_tmp = features.copy()
- x0 = np.zeros((npoints, npoints))
- x1 = np.zeros((npoints, npoints))
- vals = np.zeros((npoints, npoints))
- for i in range(npoints):
- for j in range(npoints):
- features_tmp[:,ind0] = xs0[i]
- features_tmp[:,ind1] = xs1[j]
- x0[i, j] = xs0[i]
- x1[i, j] = xs1[j]
- vals[i, j] = model(features_tmp).mean()
-
- fig = pl.figure()
- ax = fig.add_subplot(111, projection='3d')
-
-
-# x = y = np.arange(-3.0, 3.0, 0.05)
-# X, Y = np.meshgrid(x, y)
-# zs = np.array(fun(np.ravel(X), np.ravel(Y)))
-# Z = zs.reshape(X.shape)
-
- ax.plot_surface(x0, x1, vals, cmap=red_blue_transparent)
-
- ax.set_xlabel(feature_names[ind0], fontsize=13)
- ax.set_ylabel(feature_names[ind1], fontsize=13)
- ax.set_zlabel("E[f(x) | "+ str(feature_names[ind0]) + ", "+ str(feature_names[ind1]) + "]", fontsize=13)
-
- if show:
- pl.show()
- else:
- return fig, ax
diff --git a/lib/shap/plots/_scatter.py b/lib/shap/plots/_scatter.py
deleted file mode 100644
index 5b23dc4e54d68e4f8960c8e09eddc8b57f162755..0000000000000000000000000000000000000000
--- a/lib/shap/plots/_scatter.py
+++ /dev/null
@@ -1,780 +0,0 @@
-import warnings
-
-import matplotlib
-import matplotlib.pyplot as pl
-import numpy as np
-import pandas as pd
-
-from .._explanation import Explanation
-from ..utils import approximate_interactions, convert_name
-from ..utils._general import encode_array_if_needed
-from . import colors
-from ._labels import labels
-
-
-# TODO: Make the color bar a one-sided beeswarm plot so we can see the density along the color axis
-def scatter(shap_values, color="#1E88E5", hist=True, axis_color="#333333", cmap=colors.red_blue,
- dot_size=16, x_jitter="auto", alpha=1, title=None, xmin=None, xmax=None, ymin=None, ymax=None,
- overlay=None, ax=None, ylabel="SHAP value", show=True):
- """Create a SHAP dependence scatter plot, colored by an interaction feature.
-
- Plots the value of the feature on the x-axis and the SHAP value of the same feature
- on the y-axis. This shows how the model depends on the given feature, and is like a
- richer extension of classical partial dependence plots. Vertical dispersion of the
- data points represents interaction effects. Grey ticks along the y-axis are data
- points where the feature's value was NaN.
-
- Note that if you want to change the data being displayed, you can update the
- ``shap_values.display_features`` attribute and it will then be used for plotting instead of
- ``shap_values.data``.
-
- Parameters
- ----------
- shap_values : shap.Explanation
- A single column of an :class:`.Explanation` object (i.e.
- ``shap_values[:,"Feature A"]``).
-
- color : string or shap.Explanation
- How to color the scatter plot points. This can be a fixed color string, or an
- :class:`.Explanation` object. If it is an :class:`.Explanation` object, then the
- scatter plot points are colored by the feature that seems to have the strongest
- interaction effect with the feature given by the ``shap_values`` argument. This
- is calculated using :func:`shap.utils.approximate_interactions`. If only a
- single column of an :class:`.Explanation` object is passed, then that
- feature column will be used to color the data points.
-
- hist : bool
- Whether to show a light histogram along the x-axis to show the density of the
- data. Note that the histogram is normalized such that if all the points were in
- a single bin, then that bin would span the full height of the plot. Defaults to
- ``True``.
-
- x_jitter : 'auto' or float
- Adds random jitter to feature values by specifying a float between 0 to 1. May
- increase plot readability when a feature is discrete. By default, ``x_jitter``
- is chosen based on auto-detection of categorical features.
-
- alpha : float
- The transparency of the data points (between 0 and 1). This can be useful to
- show the density of the data points when using a large dataset.
-
- xmin : float or string
- Represents the lower bound of the plot's x-axis. It can be a string of the format
- "percentile(float)" to denote that percentile of the feature's value used on the x-axis.
-
- xmax : float or string
- Represents the upper bound of the plot's x-axis. It can be a string of the format
- "percentile(float)" to denote that percentile of the feature's value used on the x-axis.
-
- ax : matplotlib Axes object
- Optionally specify an existing matplotlib ``Axes`` object, into which the plot will be placed.
- In this case, we do not create a ``Figure``, otherwise we do.
-
- show : bool
- Whether ``matplotlib.pyplot.show()`` is called before returning.
- Setting this to ``False`` allows the plot
- to be customized further after it has been created.
-
- Examples
- --------
-
- See `scatter plot examples
-
-
- Input/Output - Heatmap
-
-
-
-
-
-
- Input Image
-
-
-
-
-
-
- -
-
-
- -
-
- Zoom
-
-
-
-
- - -
-
-
- Output Text
-
-
- {output_text_html}
-
- -
-
[{i}]
-
-
-
" - for i,name in enumerate(shap_values.output_names): - out += f"
"
- if display:
- _ipython_display_html(out)
- return
- else:
- return out
- #text_to_text(shap_values)
- #return
-
- if len(shap_values.shape) == 3:
- xmin_computed = None
- xmax_computed = None
- cmax_computed = None
-
- for i in range(shap_values.shape[-1]):
- for j in range(shap_values.shape[0]):
- values, clustering = unpack_shap_explanation_contents(shap_values[j,:,i])
- tokens, values, group_sizes = process_shap_values(shap_values[j,:,i].data, values, grouping_threshold, separator, clustering)
-
- xmin_i, xmax_i, cmax_i = values_min_max(values, shap_values[j,:,i].base_values)
- if xmin_computed is None or xmin_i < xmin_computed:
- xmin_computed = xmin_i
- if xmax_computed is None or xmax_i > xmax_computed:
- xmax_computed = xmax_i
- if cmax_computed is None or cmax_i > cmax_computed:
- cmax_computed = cmax_i
-
- if xmin is None:
- xmin = xmin_computed
- if xmax is None:
- xmax = xmax_computed
- if cmax is None:
- cmax = cmax_computed
-
- out = ""
- for i, v in enumerate(shap_values):
- out += f"""
-outputs
"""
- output_values = shap_values.values.sum(0) + shap_values.base_values
- output_max = np.max(np.abs(output_values))
- for i,name in enumerate(shap_values.output_names):
- scaled_value = 0.5 + 0.5 * output_values[i] / (output_max + 1e-8)
- color = colors.red_transparent_blue(scaled_value)
- color = (color[0]*255, color[1]*255, color[2]*255, color[3])
- # '#dddddd' if i == 0 else '#ffffff' border-bottom: {'3px solid #000000' if i == 0 else 'none'};
- out += f"""
-{name}
"""
- out += "" - for i,name in enumerate(shap_values.output_names): - out += f"
"
- out += text(
- shap_values[:, i], num_starting_labels=num_starting_labels, grouping_threshold=grouping_threshold,
- separator=separator, xmin=xmin, xmax=xmax, cmax=cmax, display=False
- )
- out += "
"
- out += f""
- out += "-
-
[{i}]
-inputs
"
- for i, token in enumerate(tokens):
- scaled_value = 0.5 + 0.5 * values[i] / (cmax + 1e-8)
- color = colors.red_transparent_blue(scaled_value)
- color = (color[0]*255, color[1]*255, color[2]*255, color[3])
-
- # display the labels for the most important words
- label_display = "none"
- wrapper_display = "inline"
- if i in top_inds:
- label_display = "block"
- wrapper_display = "inline-block"
-
- # create the value_label string
- value_label = ""
- if group_sizes[i] == 1:
- value_label = str(values[i].round(3))
- else:
- value_label = str(values[i].round(3)) + " / " + str(group_sizes[i])
-
- # the HTML for this token
- out += f"""{value_label}
{token.replace("<", "<").replace(">", ">").replace(' ##', '')}