text: from typing import Tuple
  import numpy as np
  import pandas as pd
  
  import matplotlib.patches as patches
  import matplotlib.pyplot as plt
  from matplotlib.collections import PatchCollection
  from colour import Color
  from PIL import ImageColor
  
  from dtreeviz.colors import adjust_colors, GREY
  from dtreeviz.trees import add_classifier_legend
  from dtreeviz import utils
  
  
  def clfviz(model, X: np.ndarray, y: np.ndarray,
             ntiles=50, tile_fraction=.9,
             binary_threshold=0.5,
             show=['instances', 'boundaries', 'probabilities', 'misclassified', 'legend'],
             feature_names=None, target_name=None, class_names=None,
             markers=None,
             boundary_marker='o', boundary_markersize=.8,
             fontsize=9, fontname="Arial",
             dot_w=25,
             yshift=.08,
             sigma=.013,
             colors: dict = None,
             ranges: Tuple = None,
             ax=None) -> None:
      """
      Two-variable case:
      Draw a tiled grid over a 2D classifier feature space where each tile is colored by
      the coordinate probabilities or coordinate predicted class. The X,y instances
      are drawn on top of the tiling. The decision boundaries are indicated
      by dots in between the classes. You can specify a threshold for the binary
      classification case. Misclassified instances are highlighted.
  
      One-variable case:
      Draw a strip plot over a 1D feature space, one strip per class. A narrow rectangle
      along the bottom indicates a color combined probabilities from all classes. The
      color associated with the most likely class will dominate the probabilities rectangle.
      Misclassified instances are highlighted. Decision boundaries, where the predicted
      class shifts from one to another, are indicated by vertical dashed lines.
  
      TODO: assumes classes are contiguous and 0..k-1
  
      :param model: an sklearn classifier model or any other model that can answer
                    method predict_proba(X)
      :param X: A 1- or 2-column dataframe or numpy array with the one or two features to plot
      :param y: The target column with integers indicating the true instance classes;
                currently these must be contiguous 0..k-1 for k classes.
      :param ntiles: How many tiles to draw across the x1, x2 feature space
      :param tile_fraction: A value between 0..1 indicating how much of a tile
                            should be colored; e.g., .9 indicates the tile should leave
                            10% whitespace around the colored portion.
      :param boundary_marker: The marker symbol from matplotlib to use for the boundary;
                              default is a circle 'o'.
      :param boundary_markersize: The boundary marker size; default is .8
      :param feature_names: A list of strings indicating the one or two X variable names.
                            If None, no axes labels are showing
      :param target_name: If showing legend, this is the title of the legend box.
      :param class_names: If showing legend, these are the class names in the legend box
      :param show: Which elements to show, includes elements from
                   ['instances','boundaries','probabilities','misclassified','legend']
      :param markers: By default, just small circles are shown for each X instance, but
                      if not None, this is a list of matplotlib marker strings like ['X','s'].
      :param fontsize: Font size for tick labels and axis labels
      :param fontname: The font name for  tick labels and axis labels
      :param colors: A dictionary with adjustments to the colors
      :param dot_w: How wide should the circles be when drawing the instances
      :param yshift: For univariate case. If you'd like to play around with the strip plot,
                     this variable shifts the class clusters; a shifted zero puts them on
                     top of each other.
      :param sigma:  For univariate case. The standard deviation of the noise added to make
                     the strip plot.
      :param ranges: Tuple for ranges of plot. One range per input dimension also specified as tuple, 
                     e.g. ((10, 100), (500, 600)).
                     Ranges of plot are determined by min, max of X vector if not specified. 
      :param ax: An optional matplotlib "axes" upon which this method should draw. If you
                 send in your own figure, it should be wide but not tall like shape 4,1
      """
      if isinstance(X, pd.DataFrame):
          X = X.values
      if isinstance(y, pd.Series):
          y = y.values
  
      if len(X.shape) == 1 or (len(X.shape)==2 and X.shape[1] == 1):
          clfviz_univar(model=model, x=X, y=y,
                        ntiles=ntiles,
                        binary_threshold=binary_threshold,
                        show=show,
                        feature_name=feature_names[0] if feature_names is not None else None,
                        target_name=target_name,
                        class_names=class_names,
                        markers=markers,
                        fontsize=fontsize, fontname=fontname,
                        dot_w=dot_w,
                        sigma=sigma,
                        yshift=yshift,
                        colors=colors,
                        ax=ax)
      elif len(X.shape) == 2 and X.shape[1] == 2:
          clfviz_bivar(model=model, X=X, y=y,
                       ntiles=ntiles, tile_fraction=tile_fraction,
                       binary_threshold=binary_threshold,
                       show=show,
                       feature_names=feature_names, target_name=target_name,
                       class_names=class_names,
                       markers=markers,
                       boundary_marker=boundary_marker,
                       boundary_markersize=boundary_markersize,
                       fontsize=fontsize, fontname=fontname,
                       dot_w=dot_w, colors=colors,
                       ranges=ranges,
                       ax=ax)
      else:
          raise ValueError(f"Expecting 2D data not {X.shape}")
  
  
  def clfviz_bivar(model, X:np.ndarray, y:np.ndarray,
                   ntiles=50, tile_fraction=.9,
                   binary_threshold=0.5,
                   show=['instances','boundaries','probabilities','misclassified','legend'],
                   feature_names=None, target_name=None, class_names=None,
                   markers=None,
                   boundary_marker='o', boundary_markersize=.8,
                   fontsize=9, fontname="Arial",
                   dot_w=25, colors:dict=None,
                   ranges=None,
                   ax=None) -> None:
      """
      See comment and parameter descriptions for clfviz() above.
      """
      if isinstance(X, pd.DataFrame):
          X = X.values
      if isinstance(y, pd.Series):
          y = y.values
  
      if len(X.shape)==1 or (len(X.shape)==2 and X.shape[1]!=2) or len(X.shape)>2:
          raise ValueError(f"Expecting 2D data not {X.shape}")
  
      if ax is None:
          fig, ax = plt.subplots(1, 1, figsize=(5, 3.5))
  
      # Created grid over the range of x1 and x2 variables, get probabilities, predictions
      grid_points, grid_proba, grid_pred_as_matrix, w, x_, class_X, class_values = \
          _compute_tiling(model, X, y, binary_threshold, ntiles, tile_fraction, ranges=ranges)
  
      x_proba = _predict_proba(model, X)
      if len(np.unique(y)) == 2:  # is k=2 binary?
          X_pred = np.where(x_proba[:, 1] >= binary_threshold, 1, 0)
      else:
          X_pred = np.argmax(x_proba, axis=1)  # TODO: assumes classes are 0..k-1
      class_X_pred = [X_pred[y == cl] for cl in class_values]
  
      if markers is None:
          markers = ['o']*len(class_X)
  
      colors = adjust_colors(colors)
  
      class_values = np.unique(y) # returns sorted
  
      # Get class to color map for probabilities and predictions
      color_map, grid_pred_colors, grid_proba_colors = \
          _get_grid_colors(grid_proba, grid_pred_as_matrix, class_values, colors)
  
      # Draw probabilities or class prediction grid
      facecolors = grid_proba_colors if 'probabilities' in show else grid_pred_colors
      _draw_tiles(ax, grid_points, facecolors, colors['tile_alpha'], x_, w)
  
      # Get grid with class predictions with coordinates (x,y)
      # e.g., y_pred[0,0] is lower left pixel and y_pred[5,5] is top-right pixel
      # for npoints=5
      grid_pred_as_matrix = grid_pred_as_matrix.reshape(ntiles, ntiles)
  
      if 'boundaries' in show:
          _draw_boundary_edges(ax, grid_points, grid_pred_as_matrix,
                               boundary_marker, boundary_markersize,
                               colors, w, x_)
  
      # Draw the X instances circles
      if 'instances' in show:
          for i, x_ in enumerate(class_X):
              if 'misclassified' in show:
                  # Show correctly classified markers
                  good_x = x_[class_X_pred[i] == class_values[i],:]
                  ax.scatter(good_x[:, 0], good_x[:, 1],
                             s=dot_w, c=color_map[i],
                             marker=markers[i],
                             alpha=colors['scatter_marker_alpha'],
                             edgecolors=colors['scatter_edge'],
                             lw=.5)
                  # Show misclassified markers (can't have alpha per marker so do in 2 calls)
                  bad_x = x_[class_X_pred[i] != class_values[i],:]
                  ax.scatter(bad_x[:, 0], bad_x[:, 1],
                             s=dot_w, c=color_map[i],
                             marker=markers[i],
                             alpha=1.0,
                             edgecolors=colors['warning'],
                             lw=.5)
              else:
                  ax.scatter(x_[:, 0], x_[:, 1],
                             s=dot_w, c=color_map[i],
                             marker=markers[i],
                             alpha=colors['scatter_marker_alpha'],
                             edgecolors=colors['scatter_edge'],
                             lw=.5)
  
      if feature_names is not None:
          ax.set_xlabel(f"{feature_names[0]}", fontsize=fontsize, fontname=fontname, color=colors['axis_label'])
          ax.set_ylabel(f"{feature_names[1]}", fontsize=fontsize, fontname=fontname, color=colors['axis_label'])
  
      if 'legend' in show:
          class_names = utils._normalize_class_names(class_names, nclasses=len(class_values))
          add_classifier_legend(ax, class_names, class_values, color_map, target_name, colors,
                                fontsize=fontsize, fontname=fontname)
  
      ax.tick_params(axis='both', which='major', width=.3, labelcolor=colors['tick_label'],
                     labelsize=fontsize)
      for tick in ax.get_xticklabels():
          tick.set_fontname(fontname)
      for tick in ax.get_yticklabels():
          tick.set_fontname(fontname)
      ax.spines['top'].set_visible(False)  # turns off the top "spine" completely
      ax.spines['right'].set_visible(False)
      ax.spines['left'].set_linewidth(.5)
      ax.spines['bottom'].set_linewidth(.5)
  
  
  def _compute_tiling(model, X:np.ndarray, y:np.ndarray, binary_threshold,
                      ntiles, tile_fraction, ranges):
      """
      Create grid over the range of x1 and x2 variables; use the model to
      compute the probabilities with model.predict_proba(), which will work with sklearn
      and, I think, XGBoost. Later we will have to figure out how to get probabilities
      out of the other models we support.
  
      The predictions are computed simply by picking the argmax of probabilities, which
      assumes classes are 0..k-1. TODO: update to allow disjoint integer class values
  
      For k=2 binary classifications, there is no way to set the threshold and so
      a threshold of 0.5 is implicitly chosen by argmax.
  
      This returns all of the details needed to plot the tiles. The coordinates of
      the grid are a linear space from min to max of each variable, inclusively.
      So if the range is 1..5 and we want 5 tiles, then the width of each tile is 1.
      We get a tile at each position. When we are drawing, the position is taken as
      the center of the tile. In this case, the grid points would be centered over
      1,2,3,4, and 5.
      """
      if isinstance(X, pd.DataFrame):
          X = X.values
      if isinstance(y, pd.Series):
          y = y.values
  
      X1 = X[:, 0]
      X2 = X[:, 1]
  
      if ranges is not None:
          x1range, x2range = ranges
          min_x1, max_x1 = x1range
          min_x2, max_x2 = x2range
      else:
          min_x1, max_x1 = min(X1), max(X1) 
          min_x2, max_x2 = min(X2), max(X2)
          
      x1r = max_x1 - min_x1
      x2r = max_x2 - min_x2
      border1 = x1r*0.05 # make a 5% border
      border2 = x2r*0.05
      x1range = (min_x1-border1, max_x1+border1)
      x2range = (min_x2-border2, max_x2+border2)
      w = (x1r+2*border1) / (ntiles-1)
      h = (x2r+2*border2) / (ntiles-1)
      w *= tile_fraction
      h *= tile_fraction
  
      grid_points = []  # a list of coordinate pairs for the grid
      # Iterate through v1 (x-axis) most quickly then v2 (y-axis)
      for iv2, v2 in enumerate(np.linspace(*x2range, num=ntiles, endpoint=True)):
          for iv1, v1 in enumerate(np.linspace(*x1range, num=ntiles, endpoint=True)):
              grid_points.append([v1, v2])
      grid_points = np.array(grid_points)
  
      class_values = np.unique(y)
      class_X = [X[y == cl] for cl in class_values]
  
      grid_proba = _predict_proba(model, grid_points)
  
      if len(np.unique(y))==2: # is k=2 binary?
          grid_pred = np.where(grid_proba[:,1]>=binary_threshold,1,0)
      else:
          grid_pred = np.argmax(grid_proba, axis=1) # TODO: assumes classes are 0..k-1
  
      return grid_points, grid_proba, grid_pred, w, h, class_X, class_values
  
  
  def _get_grid_colors(grid_proba, grid_pred, class_values, colors):
      """
      For the grid locations, return a list of colors, one per location
      indicating the class color.  To compute the probability color,
      we want to simulate overlaying regions from multiple trees onto
      the two-dimensional feature space using alpha to shade the colors.
      Instead, compute the color for each tile by combining the class colors
      according to their probabilities. If class 1 has probability .3 and class 2
      has probability .7, multiply the color ((R,G,B) color vector) associated
      with class 1 by .3 and the color vector associated with class 2 by .7 then
      add together. This gives a weighted color vector for each tile associated with
      the class probabilities. This gives the exact same effect as alpha channels,
      but transparent colors screwed up plotting the instance circles on top; they
      got washed out. This gives us more control and we can use alpha=1.
      """
      nclasses = len(class_values)
      class_colors = np.array(colors['classes'][nclasses])
  
      grid_pred_colors = class_colors[grid_pred] # color for each prediction in grid
  
      color_map = {v: class_colors[i] for i, v in enumerate(class_values)}
      # multiply each probability vector times rgb color for each class then add
      # together to get weighted color
      rgb = np.array([ImageColor.getcolor(c, mode="RGB") for c in class_colors])
      grid_proba_colors = grid_proba @ rgb
      grid_proba_colors /= 255  # get in [0..1]
      grid_proba_colors = [Color(rgb=c).hex for c in grid_proba_colors]
      return color_map, grid_pred_colors, grid_proba_colors
  
  
  def _draw_tiles(ax, grid_points, facecolors, tile_alpha, h, w):
      boxes = []
      for i, (v1, v2) in enumerate(grid_points):
          # center a box over (v1,v2) grid location
          rect = patches.Rectangle((v1 - w / 2, v2 - h / 2), w, h, angle=0.0, linewidth=0,
                                   facecolor=facecolors[i], alpha=tile_alpha)
          boxes.append(rect)
      # Adding collection is MUCH faster than repeated add_patch()
      ax.add_collection(PatchCollection(boxes, match_original=True))
  
  
  def _draw_boundary_edges(ax, grid_points, grid_pred_as_matrix, boundary_marker, boundary_markersize,
                           colors, w, h):
      ntiles = grid_pred_as_matrix.shape[0]
  
      # find transitions from one class to the other moving horizontally
      dx = np.diff(grid_pred_as_matrix, axis=1)
      dx = np.abs(dx)
      # put a zero col vector on the left to restore size
      dx = np.hstack([np.zeros((ntiles, 1)), dx])
  
      # find transitions moving vertically, bottom to top (grid matrix is flipped vertically btw)
      dy = np.diff(grid_pred_as_matrix, axis=0)
      dy = np.abs(dy)
      # put a zero row vector on the top to restore size
      dy = np.vstack([np.zeros((1, ntiles)), dy])
  
      dx_edge_idx = np.where(dx.reshape(-1)) # what are the indexes of dx class transitions?
      dy_edge_idx = np.where(dy.reshape(-1)) # what are the indexes of dy class transitions?
      dx_edges = grid_points[dx_edge_idx]    # get v1,v2 coordinates of left-to-right transitions
      dy_edges = grid_points[dy_edge_idx]    # get v1,v2 coordinates of bottom-to-top transitions
  
      # Plot the boundary markers in between tiles; e.g., shift dx stuff to the left half a tile
      ax.plot(dx_edges[:, 0] - w / 2, dx_edges[:, 1], boundary_marker,
              markersize=boundary_markersize, c=colors['class_boundary'], alpha=1.0)
      ax.plot(dy_edges[:, 0], dy_edges[:, 1] - h / 2, boundary_marker,
              markersize=boundary_markersize, c=colors['class_boundary'], alpha=1.0)
  
  
  def clfviz_univar(model, x: np.ndarray, y: np.ndarray,
                    ntiles=100,
                    binary_threshold=0.5,
                    show=['instances', 'boundaries', 'probabilities', 'misclassified', 'legend'],
                    feature_name=None, target_name=None, class_names=None,
                    markers=None,
                    fontsize=9, fontname="Arial",
                    dot_w=25,
                    yshift=.09,
                    sigma=.09,
                    colors: dict = None,
                    ax=None) -> None:
      """
      See comment and parameter descriptions for clfviz() above.
      """
      if ax is None:
          fig, ax = plt.subplots(1, 1, figsize=(5, 1.2))
  
      if isinstance(x, pd.Series):
          x = x.values
      if isinstance(y, pd.Series):
          y = y.values
  
      if (len(x.shape)==2 and x.shape[1]!=1) or len(x.shape)>2:
          raise ValueError(f"Expecting 1D data not {x.shape}")
  
      colors = adjust_colors(colors)
  
      mu = 0.08
      class_values = np.unique(y)
      nclasses = len(class_values)
      class_colors = np.array(colors['classes'][nclasses])
      color_map = {v: class_colors[i] for i, v in enumerate(class_values)}
  
      x1r = np.max(x) - np.min(x)
      x1range = (np.min(x), np.max(x))
      grid_points, w = np.linspace(*x1range, num=ntiles, endpoint=True, retstep=True)
      grid_proba = _predict_proba(model, grid_points)
      if len(np.unique(y)) == 2:  # is k=2 binary?
          grid_pred = np.where(grid_proba[:, 1] >= binary_threshold, 1, 0)
      else:
          grid_pred = np.argmax(grid_proba, axis=1)  # TODO: assumes classes are 0..k-1
      ymax = ax.get_ylim()[1]
  
      # compute the stripes on the bottom showing probabilities
      if 'probabilities' in show:
          class_values = np.unique(y)
          color_map, grid_pred_colors, grid_proba_colors = \
              _get_grid_colors(grid_proba, grid_pred, class_values, colors=adjust_colors(None))
  
          pred_box_height = .08 * ymax
          boxes = []
          for i, gx in enumerate(grid_points):
              rect = patches.Rectangle((gx, 0), w, pred_box_height,
                                       edgecolor='none', facecolor=grid_proba_colors[i],
                                       alpha=colors['tile_alpha'])
              boxes.append(rect)
          # drop box around the gradation
          ax.add_collection(PatchCollection(boxes, match_original=True))
          rect = patches.Rectangle((grid_points[0], 0), x1r + w, pred_box_height, linewidth=.3,
                                   edgecolor=colors['rect_edge'], facecolor='none')
          ax.add_patch(rect)
  
      if 'boundaries' in show:
          dx = np.abs(np.diff(grid_pred))
          dx = np.hstack([0, dx])
          dx_edge_idx = np.where(dx)  # indexes of dx class transitions?
          for lx in grid_points[dx_edge_idx]:
              ax.plot([lx, lx], [*ax.get_ylim()], '--', lw=.3,
                      c=colors['split_line'], alpha=1.0)
  
      if 'instances' in show:
          # user should pass in short and wide fig
          x_proba = _predict_proba(model, x)
          if len(np.unique(y)) == 2:  # is k=2 binary?
              x_pred = np.where(x_proba[:, 1] >= binary_threshold, 1, 0)
          else:
              x_pred = np.argmax(x_proba, axis=1)  # TODO: assumes classes are 0..k-1
          class_x = [x[y == cl] for cl in class_values]
          class_x_pred = [x_pred[y == cl] for cl in class_values]
  
          if markers is None:
              markers = ['o'] * len(class_x)
          for i, x_, in enumerate(class_x):
              if 'misclassified' in show:
                  # Show correctly classified markers
                  good_x = x_[class_x_pred[i] == class_values[i]]
                  noise = np.random.normal(mu, sigma, size=len(good_x))
                  ax.scatter(good_x, [mu + i * yshift] * len(good_x) + noise,
                             s=dot_w, c=color_map[i],
                             marker=markers[i],
                             alpha=colors['scatter_marker_alpha'],
                             edgecolors=colors['scatter_edge'],
                             lw=.5)
                  # Show misclassified markers (can't have alpha per marker so do in 2 calls)
                  bad_x = x_[class_x_pred[i] != class_values[i]]
                  noise = np.random.normal(mu, sigma, size=len(bad_x))
                  ax.scatter(bad_x, [mu + i * yshift] * len(bad_x) + noise,
                             s=dot_w, c=color_map[i],
                             marker=markers[i],
                             alpha=1.0,
                             edgecolors=colors['warning'],
                             lw=.5)
              else:
                  noise = np.random.normal(mu, sigma, size=len(x_))
                  ax.scatter(x_, [mu + i * yshift] * len(x_) + noise,
                             s=dot_w, c=color_map[i],
                             marker=markers[i],
                             alpha=colors['scatter_marker_alpha'],
                             edgecolors=colors['scatter_edge'],
                             lw=.5)
  
      ax.spines['top'].set_visible(False)
      ax.spines['left'].set_visible(False)
      ax.spines['right'].set_visible(False)
      ax.spines['bottom'].set_linewidth(0.1)
      ax.set_yticks([])
      ax.tick_params(axis='both', which='major', width=.3, labelcolor=colors['tick_label'],
                     labelsize=fontsize)
      for tick in ax.get_xticklabels():
          tick.set_fontname(fontname)
      for tick in ax.get_yticklabels():
          tick.set_fontname(fontname)
      ax.set_ylim(0, mu + nclasses * yshift + 6*sigma)
  
      if feature_name is not None:
          ax.set_xlabel(f"{feature_name}", fontsize=fontsize, fontname=fontname,
                        color=colors['axis_label'])
  
      if 'legend' in show:
          class_names = utils._normalize_class_names(class_names, nclasses)
          add_classifier_legend(ax, class_names, class_values, color_map, target_name, colors,
                                fontsize=fontsize, fontname=fontname)
  
  
  def _predict_proba(model, X):
      """
      This is where we figure out how to get a matrix of k probabilities for a k-class
      classification problem.  It works with any model that answers predict_proba()
      but we can add special cases such as Keras, that has deprecated that method.
      """
      if len(X.shape)==1:
          X = X.reshape(-1,1)
      # Keras wants predict not predict_proba and still gives probabilities
      if model.__class__.__module__.startswith('tensorflow.python.keras') or \
              model.__class__.__module__.startswith('keras'):
          proba = model.predict(X)
          if proba.shape[1]==1:
              proba = np.hstack([1-proba,proba]) # get prob y=0, y=1 nx2 matrix like sklearn
          return proba
  
      # sklearn etc...
      return model.predict_proba(X)
  