import copy

import pickle

from itertools import product, chain

import struct

import io

import copyreg

import pytest

import numpy as np

from numpy.testing import assert_allclose

from scipy.sparse import csc_matrix

from scipy.sparse import csr_matrix

from scipy.sparse import coo_matrix

import joblib

from joblib.numpy_pickle import NumpyPickler

from sklearn.random_projection import _sparse_random_matrix

from sklearn.dummy import DummyRegressor

from sklearn.metrics import accuracy_score

from sklearn.metrics import mean_squared_error

from sklearn.metrics import mean_poisson_deviance

from sklearn.model_selection import train_test_split

from sklearn.utils._testing import assert_array_equal

from sklearn.utils._testing import assert_array_almost_equal

from sklearn.utils._testing import assert_almost_equal

from sklearn.utils._testing import create_memmap_backed_data

from sklearn.utils._testing import ignore_warnings

from sklearn.utils._testing import skip_if_32bit

from sklearn.utils.estimator_checks import check_sample_weights_invariance

from sklearn.utils.validation import check_random_state

from sklearn.utils import _IS_32BIT

from sklearn.exceptions import NotFittedError

from sklearn.tree import DecisionTreeClassifier

from sklearn.tree import DecisionTreeRegressor

from sklearn.tree import ExtraTreeClassifier

from sklearn.tree import ExtraTreeRegressor

from sklearn import tree

from sklearn.tree._tree import TREE_LEAF, TREE_UNDEFINED

from sklearn.tree._tree import Tree as CythonTree

from sklearn.tree._tree import _check_n_classes

from sklearn.tree._tree import _check_value_ndarray

from sklearn.tree._tree import _check_node_ndarray

from sklearn.tree._tree import NODE_DTYPE

from sklearn.tree._classes import CRITERIA_CLF

from sklearn.tree._classes import CRITERIA_REG

from sklearn import datasets

from sklearn.utils import compute_sample_weight

from sklearn.tree._classes import DENSE_SPLITTERS, SPARSE_SPLITTERS

CLF_CRITERIONS = ("gini", "log_loss")

REG_CRITERIONS = ("squared_error", "absolute_error", "friedman_mse", "poisson")

CLF_TREES = {

"DecisionTreeClassifier": DecisionTreeClassifier,

"ExtraTreeClassifier": ExtraTreeClassifier,

}

REG_TREES = {

"DecisionTreeRegressor": DecisionTreeRegressor,

"ExtraTreeRegressor": ExtraTreeRegressor,

}

ALL_TREES: dict = dict()

ALL_TREES.update(CLF_TREES)

ALL_TREES.update(REG_TREES)

SPARSE_TREES = [

]

X_small = np.array(

)

y_small = [1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]

y_small_reg = [

]

X = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1]]

y = [-1, -1, -1, 1, 1, 1]

T = [[-1, -1], [2, 2], [3, 2]]

true_result = [-1, 1, 1]

iris = datasets.load_iris()

rng = np.random.RandomState(1)

perm = rng.permutation(iris.target.size)

iris.data = iris.data[perm]

iris.target = iris.target[perm]

diabetes = datasets.load_diabetes()

perm = rng.permutation(diabetes.target.size)

diabetes.data = diabetes.data[perm]

diabetes.target = diabetes.target[perm]

digits = datasets.load_digits()

perm = rng.permutation(digits.target.size)

digits.data = digits.data[perm]

digits.target = digits.target[perm]

random_state = check_random_state(0)

X_multilabel, y_multilabel = datasets.make_multilabel_classification(

random_state=0, n_samples=30, n_features=10

)

X_sparse_pos = random_state.uniform(size=(20, 5))

X_sparse_pos[X_sparse_pos <= 0.8] = 0.0

y_random = random_state.randint(0, 4, size=(20,))

X_sparse_mix = _sparse_random_matrix(20, 10, density=0.25, random_state=0).toarray()

DATASETS = {

}

for name in DATASETS:

DATASETS[name]["X_sparse"] = csc_matrix(DATASETS[name]["X"])

def assert_tree_equal(d, s, message):

)

def test_classification_toy():

assert_array_equal(clf.predict(T), true_result, "Failed with {0}".format(name))

def test_weighted_classification_toy():

assert_array_equal(clf.predict(T), true_result, "Failed with {0}".format(name))

def test_regression_toy(Tree, criterion):

assert_allclose(reg.predict(T), y_test)

def test_xor():

assert clf.score(X, y) == 1.0, "Failed with {0}".format(name)

def test_iris():

)

def test_diabetes_overfit(name, Tree, criterion):

), f"Failed with {name}, criterion = {criterion} and score = {score}"

def test_diabetes_underfit(name, Tree, criterion, max_depth, metric, max_loss):

assert 0 < loss < max_loss

def test_probability():

)

def test_arrayrepr():

reg.fit(X, y)

def test_pure_set():

assert_almost_equal(reg.predict(X), y, err_msg="Failed with {0}".format(name))

def test_numerical_stability():

reg.fit(-X, -y)

def test_importances():

assert_array_equal(clf.feature_importances_, clf2.feature_importances_)

def test_importances_raises():

getattr(clf, "feature_importances_")

def test_importances_gini_equal_squared_error():

assert_array_equal(clf.tree_.n_node_samples, reg.tree_.n_node_samples)

def test_max_features():

assert est.max_features_ == iris.data.shape[1]

def test_error():

est.fit([[0, 1, 2]], [5, -0.1, 2])

def test_min_samples_split():

assert np.min(node_samples) > 9, "Failed with {0}".format(name)

def test_min_samples_leaf():

assert np.min(leaf_count) > 4, "Failed with {0}".format(name)

def check_min_weight_fraction_leaf(name, datasets, sparse=False):

)

def test_min_weight_fraction_leaf_on_dense_input(name):

check_min_weight_fraction_leaf(name, "iris")

def test_min_weight_fraction_leaf_on_sparse_input(name):

check_min_weight_fraction_leaf(name, "multilabel", True)

def check_min_weight_fraction_leaf_with_min_samples_leaf(name, datasets, sparse=False):

)

def test_min_weight_fraction_leaf_with_min_samples_leaf_on_dense_input(name):

check_min_weight_fraction_leaf_with_min_samples_leaf(name, "iris")

def test_min_weight_fraction_leaf_with_min_samples_leaf_on_sparse_input(name):

check_min_weight_fraction_leaf_with_min_samples_leaf(name, "multilabel", True)

def test_min_impurity_decrease():

)

def test_pickle():

)

def test_multioutput():