docs: def _pruning(self, X, y_true, cost_mat):
          """ Private function that prune the decision tree.
  
          Parameters
          ----------
  
          X : array-like of shape = [n_samples, n_features]
              The input samples.
  
          y_true : array indicator matrix
              Ground truth (correct) labels.
  
          cost_mat : array-like of shape = [n_samples, 4]
              Cost matrix of the classification problem
              Where the columns represents the costs of: false positives, false negatives,
              true positives and true negatives, for each example.
  
          """
          # Calculate gains
          nodes = self._nodes(self.tree_.tree_pruned)
          n_nodes = len(nodes)
          gains = np.zeros(n_nodes)
  
          y_pred = self._classify(X, self.tree_.tree_pruned)
          cost_base = cost_loss(y_true, y_pred, cost_mat)
  
          for m, node in enumerate(nodes):
  
              # Create temporal tree by eliminating node from tree_pruned
              temp_tree = self._delete_node(self.tree_.tree_pruned, node)
              y_pred = self._classify(X, temp_tree)
  
              nodes_pruned = self._nodes(temp_tree)
  
              # Calculate %gain
              gain = (cost_base - cost_loss(y_true, y_pred, cost_mat)) / cost_base
  
              # Calculate %gain_size
              gain_size = (len(nodes) - len(nodes_pruned)) * 1.0 / len(nodes)
  
              # Calculate weighted gain
              gains[m] = gain * gain_size
  
          best_gain = np.max(gains)
          best_node = nodes[int(np.argmax(gains))]
  
          if best_gain > self.min_gain:
              self.tree_.tree_pruned = self._delete_node(self.tree_.tree_pruned, best_node)
  
              # If best tree is not root node, then recursively pruning the tree
              if best_node != 0:
                  self._pruning(X, y_true, cost_mat)