class_docstr: Decision tree classifier.
  
  :param criterion: the type of criterion to be used for subtree splitting.
  :type criterion: str, {'gini', 'information_gain'}, default='gini'
  
  :param min_subset_size: the minimum number of vectors corresponding to a node subtree.
  :type min_subset_size: int, default=1
  
  :param min_subset_part: the minimum weight of the vectors in a subtree relative to the parent node weight.
  :type min_subset_part: float, [0..1], default=0.0
  
  :param min_split_size: the minimum number of vectors in a node subtree when it may be divided further.
  :type min_split_size: int, default=1
  
  :param max_tree_depth: the maximum depth of the tree.
  :type max_tree_depth: int, default=32
  
  :param max_node_count: the maximum number of nodes in the tree.
  :type max_node_count: int, default=4096
  
  :param const_threshold: if the ratio of same class elements in the subset is greater than this value,
      a constant node will be created.
  :type const_threshold: float, [0..1], default=0.99
  
  :param random_selected_feature_count: no more than this number of randomly selected features will be used for each node.
      -1 means use all features every time.
  :type random_selected_feature_count: int, default=-1
  
  :param available_memory: the memory limit for the algorithm (default is 1 Gigabyte)
  :type available_memory: int, default=1024*1024*1024
  
  :param multiclass_mode: determines how to handle multi-class classification
  :type multiclass_mode: str, ['single_tree', 'one_vs_all', 'one_vs_one'], default='single_tree'
code: def __init__(
      self,
      criterion="gini",
      min_subset_size=1,
      min_subset_part=0.0,
      min_split_size=1,
      max_tree_depth=32,
      max_node_count=4096,
      const_threshold=0.99,
      random_selected_feature_count=-1,
      available_memory=1024 * 1024 * 1024,
      multiclass_mode="single_tree",
  ):
      if criterion != "gini" and criterion != "information_gain":
          raise ValueError(
              "The `criterion` must be one of: `gini`, `information_gain`."
          )
      if min_subset_size < 1:
          raise ValueError("The `min_subset_size` must be > 0.")
      if min_subset_part > 1 or min_subset_part < 0:
          raise ValueError("The `min_subset_part` must be in [0, 1].")
      if min_split_size < 1:
          raise ValueError("The `min_split_size` must be > 0.")
      if max_tree_depth <= 0:
          raise ValueError("The `max_tree_depth` must be > 0.")
      if max_node_count <= 1:
          raise ValueError("The `max_node_count` must be > 1.")
      if const_threshold > 1 or const_threshold < 0:
          raise ValueError("The `const_threshold` must be in [0, 1].")
      if (
          random_selected_feature_count <= 0
          and random_selected_feature_count != -1
      ):
          raise ValueError(
              "The `random_selected_feature_count` must be > 0 or -1."
          )
      if available_memory < 0:
          raise ValueError(
              "The `available_memory` must be non-negative."
          )
      if (
          multiclass_mode != "single_tree"
          and multiclass_mode != "one_vs_all"
          and multiclass_mode != "one_vs_one"
      ):
          raise ValueError(
              "The `multiclass_mode` must be one of: `single_tree`, `one_vs_all`, `one_vs_one`."
          )
  
      super().__init__(
          int(min_subset_size),
          float(min_subset_part),
          int(min_split_size),
          int(max_tree_depth),
          int(max_node_count),
          criterion,
          float(const_threshold),
          int(random_selected_feature_count),
          int(available_memory),
          multiclass_mode,
      )
  
file_path: neoml/NeoML/Python/neoml/DecisionTree.py
imports: import numpy
  from .Utils import convert_data, get_data
  from scipy.sparse import csr_matrix, issparse
  import neoml.PythonWrapper
label_desc: Use image node_id 1 to create a new DecisionTreeClassifier object from inherited base classes: PythonWrapper with example: obj = DecisionTreeClassifier(criterion, min_subset_size, min_subset_part, min_split_size, max_tree_depth, max_node_count, const_threshold, random_selected_feature_count, available_memory, multiclass_mode)