[breaking] Remove deprecated parameters in the skl interface. (#9986)

tests/python/test_callback.py

@@ -16,13 +16,14 @@ class TestCallbacks:
     @classmethod
     def setup_class(cls):
         from sklearn.datasets import load_breast_cancer
+
         X, y = load_breast_cancer(return_X_y=True)
         cls.X = X
         cls.y = y
 
-        split = int(X.shape[0]*0.8)
-        cls.X_train = X[: split, ...]
-        cls.y_train = y[: split, ...]
+        split = int(X.shape[0] * 0.8)
+        cls.X_train = X[:split, ...]
+        cls.y_train = y[:split, ...]
         cls.X_valid = X[split:, ...]
         cls.y_valid = y[split:, ...]
 
@@ -31,31 +32,32 @@ class TestCallbacks:
         D_train: xgb.DMatrix,
         D_valid: xgb.DMatrix,
         rounds: int,
-        verbose_eval: Union[bool, int]
+        verbose_eval: Union[bool, int],
     ):
         def check_output(output: str) -> None:
             if int(verbose_eval) == 1:
                 # Should print each iteration info
-                assert len(output.split('\n')) == rounds
+                assert len(output.split("\n")) == rounds
             elif int(verbose_eval) > rounds:
                 # Should print first and latest iteration info
-                assert len(output.split('\n')) == 2
+                assert len(output.split("\n")) == 2
             else:
                 # Should print info by each period additionaly to first and latest
                 # iteration
                 num_periods = rounds // int(verbose_eval)
                 # Extra information is required for latest iteration
                 is_extra_info_required = num_periods * int(verbose_eval) < (rounds - 1)
-                assert len(output.split('\n')) == (
+                assert len(output.split("\n")) == (
                     1 + num_periods + int(is_extra_info_required)
                 )
 
         evals_result: xgb.callback.TrainingCallback.EvalsLog = {}
-        params = {'objective': 'binary:logistic', 'eval_metric': 'error'}
+        params = {"objective": "binary:logistic", "eval_metric": "error"}
         with tm.captured_output() as (out, err):
             xgb.train(
-                params, D_train,
-                evals=[(D_train, 'Train'), (D_valid, 'Valid')],
+                params,
+                D_train,
+                evals=[(D_train, "Train"), (D_valid, "Valid")],
                 num_boost_round=rounds,
                 evals_result=evals_result,
                 verbose_eval=verbose_eval,
@@ -73,14 +75,16 @@ class TestCallbacks:
         D_valid = xgb.DMatrix(self.X_valid, self.y_valid)
         evals_result = {}
         rounds = 10
-        xgb.train({'objective': 'binary:logistic',
-                   'eval_metric': 'error'}, D_train,
-                  evals=[(D_train, 'Train'), (D_valid, 'Valid')],
-                  num_boost_round=rounds,
-                  evals_result=evals_result,
-                  verbose_eval=True)
-        assert len(evals_result['Train']['error']) == rounds
-        assert len(evals_result['Valid']['error']) == rounds
+        xgb.train(
+            {"objective": "binary:logistic", "eval_metric": "error"},
+            D_train,
+            evals=[(D_train, "Train"), (D_valid, "Valid")],
+            num_boost_round=rounds,
+            evals_result=evals_result,
+            verbose_eval=True,
+        )
+        assert len(evals_result["Train"]["error"]) == rounds
+        assert len(evals_result["Valid"]["error"]) == rounds
 
         self.run_evaluation_monitor(D_train, D_valid, rounds, True)
         self.run_evaluation_monitor(D_train, D_valid, rounds, 2)
@@ -93,72 +97,83 @@ class TestCallbacks:
         evals_result = {}
         rounds = 30
         early_stopping_rounds = 5
-        booster = xgb.train({'objective': 'binary:logistic',
-                             'eval_metric': 'error'}, D_train,
-                            evals=[(D_train, 'Train'), (D_valid, 'Valid')],
-                            num_boost_round=rounds,
-                            evals_result=evals_result,
-                            verbose_eval=True,
-                            early_stopping_rounds=early_stopping_rounds)
-        dump = booster.get_dump(dump_format='json')
+        booster = xgb.train(
+            {"objective": "binary:logistic", "eval_metric": "error"},
+            D_train,
+            evals=[(D_train, "Train"), (D_valid, "Valid")],
+            num_boost_round=rounds,
+            evals_result=evals_result,
+            verbose_eval=True,
+            early_stopping_rounds=early_stopping_rounds,
+        )
+        dump = booster.get_dump(dump_format="json")
         assert len(dump) - booster.best_iteration == early_stopping_rounds + 1
 
     def test_early_stopping_custom_eval(self):
         D_train = xgb.DMatrix(self.X_train, self.y_train)
         D_valid = xgb.DMatrix(self.X_valid, self.y_valid)
         early_stopping_rounds = 5
-        booster = xgb.train({'objective': 'binary:logistic',
-                             'eval_metric': 'error',
-                             'tree_method': 'hist'}, D_train,
-                            evals=[(D_train, 'Train'), (D_valid, 'Valid')],
-                            feval=tm.eval_error_metric,
-                            num_boost_round=1000,
-                            early_stopping_rounds=early_stopping_rounds,
-                            verbose_eval=False)
-        dump = booster.get_dump(dump_format='json')
+        booster = xgb.train(
+            {
+                "objective": "binary:logistic",
+                "eval_metric": "error",
+                "tree_method": "hist",
+            },
+            D_train,
+            evals=[(D_train, "Train"), (D_valid, "Valid")],
+            feval=tm.eval_error_metric,
+            num_boost_round=1000,
+            early_stopping_rounds=early_stopping_rounds,
+            verbose_eval=False,
+        )
+        dump = booster.get_dump(dump_format="json")
         assert len(dump) - booster.best_iteration == early_stopping_rounds + 1
 
     def test_early_stopping_customize(self):
         D_train = xgb.DMatrix(self.X_train, self.y_train)
         D_valid = xgb.DMatrix(self.X_valid, self.y_valid)
         early_stopping_rounds = 5
-        early_stop = xgb.callback.EarlyStopping(rounds=early_stopping_rounds,
-                                                metric_name='CustomErr',
-                                                data_name='Train')
+        early_stop = xgb.callback.EarlyStopping(
+            rounds=early_stopping_rounds, metric_name="CustomErr", data_name="Train"
+        )
         # Specify which dataset and which metric should be used for early stopping.
         booster = xgb.train(
-            {'objective': 'binary:logistic',
-             'eval_metric': ['error', 'rmse'],
-             'tree_method': 'hist'}, D_train,
-            evals=[(D_train, 'Train'), (D_valid, 'Valid')],
+            {
+                "objective": "binary:logistic",
+                "eval_metric": ["error", "rmse"],
+                "tree_method": "hist",
+            },
+            D_train,
+            evals=[(D_train, "Train"), (D_valid, "Valid")],
             feval=tm.eval_error_metric,
             num_boost_round=1000,
             callbacks=[early_stop],
-            verbose_eval=False)
-        dump = booster.get_dump(dump_format='json')
+            verbose_eval=False,
+        )
+        dump = booster.get_dump(dump_format="json")
         assert len(dump) - booster.best_iteration == early_stopping_rounds + 1
-        assert len(early_stop.stopping_history['Train']['CustomErr']) == len(dump)
+        assert len(early_stop.stopping_history["Train"]["CustomErr"]) == len(dump)
 
         rounds = 100
         early_stop = xgb.callback.EarlyStopping(
             rounds=early_stopping_rounds,
-            metric_name='CustomErr',
-            data_name='Train',
+            metric_name="CustomErr",
+            data_name="Train",
             min_delta=100,
             save_best=True,
         )
         booster = xgb.train(
             {
-                'objective': 'binary:logistic',
-                'eval_metric': ['error', 'rmse'],
-                'tree_method': 'hist'
+                "objective": "binary:logistic",
+                "eval_metric": ["error", "rmse"],
+                "tree_method": "hist",
             },
             D_train,
-            evals=[(D_train, 'Train'), (D_valid, 'Valid')],
+            evals=[(D_train, "Train"), (D_valid, "Valid")],
             feval=tm.eval_error_metric,
             num_boost_round=rounds,
             callbacks=[early_stop],
-            verbose_eval=False
+            verbose_eval=False,
         )
         # No iteration can be made with min_delta == 100
         assert booster.best_iteration == 0
@@ -166,18 +181,20 @@ class TestCallbacks:
 
     def test_early_stopping_skl(self):
         from sklearn.datasets import load_breast_cancer
+
         X, y = load_breast_cancer(return_X_y=True)
         early_stopping_rounds = 5
         cls = xgb.XGBClassifier(
-            early_stopping_rounds=early_stopping_rounds, eval_metric='error'
+            early_stopping_rounds=early_stopping_rounds, eval_metric="error"
         )
         cls.fit(X, y, eval_set=[(X, y)])
         booster = cls.get_booster()
-        dump = booster.get_dump(dump_format='json')
+        dump = booster.get_dump(dump_format="json")
         assert len(dump) - booster.best_iteration == early_stopping_rounds + 1
 
     def test_early_stopping_custom_eval_skl(self):
         from sklearn.datasets import load_breast_cancer
+
         X, y = load_breast_cancer(return_X_y=True)
         early_stopping_rounds = 5
         early_stop = xgb.callback.EarlyStopping(rounds=early_stopping_rounds)
@@ -186,11 +203,12 @@ class TestCallbacks:
         )
         cls.fit(X, y, eval_set=[(X, y)])
         booster = cls.get_booster()
-        dump = booster.get_dump(dump_format='json')
+        dump = booster.get_dump(dump_format="json")
         assert len(dump) - booster.best_iteration == early_stopping_rounds + 1
 
     def test_early_stopping_save_best_model(self):
         from sklearn.datasets import load_breast_cancer
+
         X, y = load_breast_cancer(return_X_y=True)
         n_estimators = 100
         early_stopping_rounds = 5
@@ -200,11 +218,11 @@ class TestCallbacks:
         cls = xgb.XGBClassifier(
             n_estimators=n_estimators,
             eval_metric=tm.eval_error_metric_skl,
-            callbacks=[early_stop]
+            callbacks=[early_stop],
         )
         cls.fit(X, y, eval_set=[(X, y)])
         booster = cls.get_booster()
-        dump = booster.get_dump(dump_format='json')
+        dump = booster.get_dump(dump_format="json")
         assert len(dump) == booster.best_iteration + 1
 
         early_stop = xgb.callback.EarlyStopping(
@@ -220,8 +238,9 @@ class TestCallbacks:
             cls.fit(X, y, eval_set=[(X, y)])
 
         # No error
-        early_stop = xgb.callback.EarlyStopping(rounds=early_stopping_rounds,
-                                                save_best=False)
+        early_stop = xgb.callback.EarlyStopping(
+            rounds=early_stopping_rounds, save_best=False
+        )
         xgb.XGBClassifier(
             booster="gblinear",
             n_estimators=10,
@@ -231,14 +250,17 @@ class TestCallbacks:
 
     def test_early_stopping_continuation(self):
         from sklearn.datasets import load_breast_cancer
+
         X, y = load_breast_cancer(return_X_y=True)
-        cls = xgb.XGBClassifier(eval_metric=tm.eval_error_metric_skl)
+
         early_stopping_rounds = 5
         early_stop = xgb.callback.EarlyStopping(
             rounds=early_stopping_rounds, save_best=True
         )
-        with pytest.warns(UserWarning):
-            cls.fit(X, y, eval_set=[(X, y)], callbacks=[early_stop])
+        cls = xgb.XGBClassifier(
+            eval_metric=tm.eval_error_metric_skl, callbacks=[early_stop]
+        )
+        cls.fit(X, y, eval_set=[(X, y)])
 
         booster = cls.get_booster()
         assert booster.num_boosted_rounds() == booster.best_iteration + 1
@@ -256,21 +278,10 @@ class TestCallbacks:
             )
             cls.fit(X, y, eval_set=[(X, y)])
             booster = cls.get_booster()
-            assert booster.num_boosted_rounds() == \
-                booster.best_iteration + early_stopping_rounds + 1
-
-    def test_deprecated(self):
-        from sklearn.datasets import load_breast_cancer
-        X, y = load_breast_cancer(return_X_y=True)
-        early_stopping_rounds = 5
-        early_stop = xgb.callback.EarlyStopping(
-            rounds=early_stopping_rounds, save_best=True
-        )
-        clf = xgb.XGBClassifier(
-            eval_metric=tm.eval_error_metric_skl, callbacks=[early_stop]
-        )
-        with pytest.raises(ValueError, match=r".*set_params.*"):
-            clf.fit(X, y, eval_set=[(X, y)], callbacks=[early_stop])
+            assert (
+                booster.num_boosted_rounds()
+                == booster.best_iteration + early_stopping_rounds + 1
+            )
 
     def run_eta_decay(self, tree_method):
         """Test learning rate scheduler, used by both CPU and GPU tests."""
@@ -343,7 +354,7 @@ class TestCallbacks:
             callbacks=[scheduler([0, 0, 0, 0])],
             evals_result=evals_result,
         )
-        eval_errors_2 = list(map(float, evals_result['eval']['error']))
+        eval_errors_2 = list(map(float, evals_result["eval"]["error"]))
         assert isinstance(bst, xgb.core.Booster)
         # validation error should not decrease, if eta/learning_rate = 0
         assert eval_errors_2[0] == eval_errors_2[-1]
@@ -361,7 +372,7 @@ class TestCallbacks:
             callbacks=[scheduler(eta_decay)],
             evals_result=evals_result,
         )
-        eval_errors_3 = list(map(float, evals_result['eval']['error']))
+        eval_errors_3 = list(map(float, evals_result["eval"]["error"]))
 
         assert isinstance(bst, xgb.core.Booster)
 

tests/python/test_early_stopping.py

@@ -15,23 +15,23 @@ class TestEarlyStopping:
         from sklearn.model_selection import train_test_split
 
         digits = load_digits(n_class=2)
-        X = digits['data']
-        y = digits['target']
+        X = digits["data"]
+        y = digits["target"]
         X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
-        clf1 = xgb.XGBClassifier(learning_rate=0.1)
-        clf1.fit(X_train, y_train, early_stopping_rounds=5, eval_metric="auc",
-                 eval_set=[(X_test, y_test)])
-        clf2 = xgb.XGBClassifier(learning_rate=0.1)
-        clf2.fit(X_train, y_train, early_stopping_rounds=4, eval_metric="auc",
-                 eval_set=[(X_test, y_test)])
+        clf1 = xgb.XGBClassifier(
+            learning_rate=0.1, early_stopping_rounds=5, eval_metric="auc"
+        )
+        clf1.fit(X_train, y_train, eval_set=[(X_test, y_test)])
+        clf2 = xgb.XGBClassifier(
+            learning_rate=0.1, early_stopping_rounds=4, eval_metric="auc"
+        )
+        clf2.fit(X_train, y_train, eval_set=[(X_test, y_test)])
         # should be the same
         assert clf1.best_score == clf2.best_score
         assert clf1.best_score != 1
         # check overfit
         clf3 = xgb.XGBClassifier(
-            learning_rate=0.1,
-            eval_metric="auc",
-            early_stopping_rounds=10
+            learning_rate=0.1, eval_metric="auc", early_stopping_rounds=10
         )
         clf3.fit(X_train, y_train, eval_set=[(X_test, y_test)])
         base_score = get_basescore(clf3)
@@ -39,9 +39,9 @@ class TestEarlyStopping:
 
         clf3 = xgb.XGBClassifier(
             learning_rate=0.1,
-            base_score=.5,
+            base_score=0.5,
             eval_metric="auc",
-            early_stopping_rounds=10
+            early_stopping_rounds=10,
         )
         clf3.fit(X_train, y_train, eval_set=[(X_test, y_test)])
 

tests/python/test_eval_metrics.py

@@ -9,37 +9,41 @@ rng = np.random.RandomState(1337)
 
 
 class TestEvalMetrics:
-    xgb_params_01 = {'nthread': 1, 'eval_metric': 'error'}
+    xgb_params_01 = {"nthread": 1, "eval_metric": "error"}
 
-    xgb_params_02 = {'nthread': 1, 'eval_metric': ['error']}
+    xgb_params_02 = {"nthread": 1, "eval_metric": ["error"]}
 
-    xgb_params_03 = {'nthread': 1, 'eval_metric': ['rmse', 'error']}
+    xgb_params_03 = {"nthread": 1, "eval_metric": ["rmse", "error"]}
 
-    xgb_params_04 = {'nthread': 1, 'eval_metric': ['error', 'rmse']}
+    xgb_params_04 = {"nthread": 1, "eval_metric": ["error", "rmse"]}
 
     def evalerror_01(self, preds, dtrain):
         labels = dtrain.get_label()
-        return 'error', float(sum(labels != (preds > 0.0))) / len(labels)
+        return "error", float(sum(labels != (preds > 0.0))) / len(labels)
 
     def evalerror_02(self, preds, dtrain):
         labels = dtrain.get_label()
-        return [('error', float(sum(labels != (preds > 0.0))) / len(labels))]
+        return [("error", float(sum(labels != (preds > 0.0))) / len(labels))]
 
     @pytest.mark.skipif(**tm.no_sklearn())
     def evalerror_03(self, preds, dtrain):
         from sklearn.metrics import mean_squared_error
 
         labels = dtrain.get_label()
-        return [('rmse', mean_squared_error(labels, preds)),
-                ('error', float(sum(labels != (preds > 0.0))) / len(labels))]
+        return [
+            ("rmse", mean_squared_error(labels, preds)),
+            ("error", float(sum(labels != (preds > 0.0))) / len(labels)),
+        ]
 
     @pytest.mark.skipif(**tm.no_sklearn())
     def evalerror_04(self, preds, dtrain):
         from sklearn.metrics import mean_squared_error
 
         labels = dtrain.get_label()
-        return [('error', float(sum(labels != (preds > 0.0))) / len(labels)),
-                ('rmse', mean_squared_error(labels, preds))]
+        return [
+            ("error", float(sum(labels != (preds > 0.0))) / len(labels)),
+            ("rmse", mean_squared_error(labels, preds)),
+        ]
 
     @pytest.mark.skipif(**tm.no_sklearn())
     def test_eval_metrics(self):
@@ -50,15 +54,15 @@ class TestEvalMetrics:
         from sklearn.datasets import load_digits
 
         digits = load_digits(n_class=2)
-        X = digits['data']
-        y = digits['target']
+        X = digits["data"]
+        y = digits["target"]
 
         Xt, Xv, yt, yv = train_test_split(X, y, test_size=0.2, random_state=0)
 
         dtrain = xgb.DMatrix(Xt, label=yt)
         dvalid = xgb.DMatrix(Xv, label=yv)
 
-        watchlist = [(dtrain, 'train'), (dvalid, 'val')]
+        watchlist = [(dtrain, "train"), (dvalid, "val")]
 
         gbdt_01 = xgb.train(self.xgb_params_01, dtrain, num_boost_round=10)
         gbdt_02 = xgb.train(self.xgb_params_02, dtrain, num_boost_round=10)
@@ -66,26 +70,54 @@ class TestEvalMetrics:
         assert gbdt_01.predict(dvalid)[0] == gbdt_02.predict(dvalid)[0]
         assert gbdt_01.predict(dvalid)[0] == gbdt_03.predict(dvalid)[0]
 
-        gbdt_01 = xgb.train(self.xgb_params_01, dtrain, 10, watchlist,
-                            early_stopping_rounds=2)
-        gbdt_02 = xgb.train(self.xgb_params_02, dtrain, 10, watchlist,
-                            early_stopping_rounds=2)
-        gbdt_03 = xgb.train(self.xgb_params_03, dtrain, 10, watchlist,
-                            early_stopping_rounds=2)
-        gbdt_04 = xgb.train(self.xgb_params_04, dtrain, 10, watchlist,
-                            early_stopping_rounds=2)
+        gbdt_01 = xgb.train(
+            self.xgb_params_01, dtrain, 10, watchlist, early_stopping_rounds=2
+        )
+        gbdt_02 = xgb.train(
+            self.xgb_params_02, dtrain, 10, watchlist, early_stopping_rounds=2
+        )
+        gbdt_03 = xgb.train(
+            self.xgb_params_03, dtrain, 10, watchlist, early_stopping_rounds=2
+        )
+        gbdt_04 = xgb.train(
+            self.xgb_params_04, dtrain, 10, watchlist, early_stopping_rounds=2
+        )
         assert gbdt_01.predict(dvalid)[0] == gbdt_02.predict(dvalid)[0]
         assert gbdt_01.predict(dvalid)[0] == gbdt_03.predict(dvalid)[0]
         assert gbdt_03.predict(dvalid)[0] != gbdt_04.predict(dvalid)[0]
 
-        gbdt_01 = xgb.train(self.xgb_params_01, dtrain, 10, watchlist,
-                            early_stopping_rounds=2, feval=self.evalerror_01)
-        gbdt_02 = xgb.train(self.xgb_params_02, dtrain, 10, watchlist,
-                            early_stopping_rounds=2, feval=self.evalerror_02)
-        gbdt_03 = xgb.train(self.xgb_params_03, dtrain, 10, watchlist,
-                            early_stopping_rounds=2, feval=self.evalerror_03)
-        gbdt_04 = xgb.train(self.xgb_params_04, dtrain, 10, watchlist,
-                            early_stopping_rounds=2, feval=self.evalerror_04)
+        gbdt_01 = xgb.train(
+            self.xgb_params_01,
+            dtrain,
+            10,
+            watchlist,
+            early_stopping_rounds=2,
+            feval=self.evalerror_01,
+        )
+        gbdt_02 = xgb.train(
+            self.xgb_params_02,
+            dtrain,
+            10,
+            watchlist,
+            early_stopping_rounds=2,
+            feval=self.evalerror_02,
+        )
+        gbdt_03 = xgb.train(
+            self.xgb_params_03,
+            dtrain,
+            10,
+            watchlist,
+            early_stopping_rounds=2,
+            feval=self.evalerror_03,
+        )
+        gbdt_04 = xgb.train(
+            self.xgb_params_04,
+            dtrain,
+            10,
+            watchlist,
+            early_stopping_rounds=2,
+            feval=self.evalerror_04,
+        )
         assert gbdt_01.predict(dvalid)[0] == gbdt_02.predict(dvalid)[0]
         assert gbdt_01.predict(dvalid)[0] == gbdt_03.predict(dvalid)[0]
         assert gbdt_03.predict(dvalid)[0] != gbdt_04.predict(dvalid)[0]
@@ -93,6 +125,7 @@ class TestEvalMetrics:
     @pytest.mark.skipif(**tm.no_sklearn())
     def test_gamma_deviance(self):
         from sklearn.metrics import mean_gamma_deviance
+
         rng = np.random.RandomState(1994)
         n_samples = 100
         n_features = 30
@@ -101,8 +134,13 @@ class TestEvalMetrics:
         y = rng.randn(n_samples)
         y = y - y.min() * 100
 
-        reg = xgb.XGBRegressor(tree_method="hist", objective="reg:gamma", n_estimators=10)
-        reg.fit(X, y, eval_metric="gamma-deviance")
+        reg = xgb.XGBRegressor(
+            tree_method="hist",
+            objective="reg:gamma",
+            n_estimators=10,
+            eval_metric="gamma-deviance",
+        )
+        reg.fit(X, y)
 
         booster = reg.get_booster()
         score = reg.predict(X)
@@ -113,16 +151,26 @@ class TestEvalMetrics:
     @pytest.mark.skipif(**tm.no_sklearn())
     def test_gamma_lik(self) -> None:
         import scipy.stats as stats
+
         rng = np.random.default_rng(1994)
         n_samples = 32
         n_features = 10
 
-        X = rng.normal(0, 1, size=n_samples * n_features).reshape((n_samples, n_features))
+        X = rng.normal(0, 1, size=n_samples * n_features).reshape(
+            (n_samples, n_features)
+        )
 
         alpha, loc, beta = 5.0, 11.1, 22
-        y = stats.gamma.rvs(alpha, loc=loc, scale=beta, size=n_samples, random_state=rng)
-        reg = xgb.XGBRegressor(tree_method="hist", objective="reg:gamma", n_estimators=64)
-        reg.fit(X, y, eval_metric="gamma-nloglik", eval_set=[(X, y)])
+        y = stats.gamma.rvs(
+            alpha, loc=loc, scale=beta, size=n_samples, random_state=rng
+        )
+        reg = xgb.XGBRegressor(
+            tree_method="hist",
+            objective="reg:gamma",
+            n_estimators=64,
+            eval_metric="gamma-nloglik",
+        )
+        reg.fit(X, y, eval_set=[(X, y)])
 
         score = reg.predict(X)
 
@@ -134,7 +182,7 @@ class TestEvalMetrics:
         # XGBoost uses the canonical link function of gamma in evaluation function.
         # so \theta = - (1.0 / y)
         # dispersion is hardcoded as 1.0, so shape (a in scipy parameter) is also 1.0
-        beta = - (1.0 / (- (1.0 / y)))  # == y
+        beta = -(1.0 / (-(1.0 / y)))  # == y
         nloglik_stats = -stats.gamma.logpdf(score, a=1.0, scale=beta)
 
         np.testing.assert_allclose(nloglik, np.mean(nloglik_stats), rtol=1e-3)
@@ -153,7 +201,7 @@ class TestEvalMetrics:
             n_features,
             n_informative=n_features,
             n_redundant=0,
-            random_state=rng
+            random_state=rng,
         )
         Xy = xgb.DMatrix(X, y)
         booster = xgb.train(
@@ -197,7 +245,7 @@ class TestEvalMetrics:
             n_informative=n_features,
             n_redundant=0,
             n_classes=n_classes,
-            random_state=rng
+            random_state=rng,
         )
         if weighted:
             weights = rng.randn(n_samples)
@@ -242,20 +290,25 @@ class TestEvalMetrics:
     def run_pr_auc_binary(self, tree_method):
         from sklearn.datasets import make_classification
         from sklearn.metrics import auc, precision_recall_curve
+
         X, y = make_classification(128, 4, n_classes=2, random_state=1994)
-        clf = xgb.XGBClassifier(tree_method=tree_method, n_estimators=1)
-        clf.fit(X, y, eval_metric="aucpr", eval_set=[(X, y)])
+        clf = xgb.XGBClassifier(
+            tree_method=tree_method, n_estimators=1, eval_metric="aucpr"
+        )
+        clf.fit(X, y, eval_set=[(X, y)])
         evals_result = clf.evals_result()["validation_0"]["aucpr"][-1]
 
         y_score = clf.predict_proba(X)[:, 1]  # get the positive column
         precision, recall, _ = precision_recall_curve(y, y_score)
         prauc = auc(recall, precision)
-        # Interpolation results are slightly different from sklearn, but overall should be
-        # similar.
+        # Interpolation results are slightly different from sklearn, but overall should
+        # be similar.
         np.testing.assert_allclose(prauc, evals_result, rtol=1e-2)
 
-        clf = xgb.XGBClassifier(tree_method=tree_method, n_estimators=10)
-        clf.fit(X, y, eval_metric="aucpr", eval_set=[(X, y)])
+        clf = xgb.XGBClassifier(
+            tree_method=tree_method, n_estimators=10, eval_metric="aucpr"
+        )
+        clf.fit(X, y, eval_set=[(X, y)])
         evals_result = clf.evals_result()["validation_0"]["aucpr"][-1]
         np.testing.assert_allclose(0.99, evals_result, rtol=1e-2)
 
@@ -264,16 +317,21 @@ class TestEvalMetrics:
 
     def run_pr_auc_multi(self, tree_method):
         from sklearn.datasets import make_classification
+
         X, y = make_classification(
             64, 16, n_informative=8, n_classes=3, random_state=1994
         )
-        clf = xgb.XGBClassifier(tree_method=tree_method, n_estimators=1)
-        clf.fit(X, y, eval_metric="aucpr", eval_set=[(X, y)])
+        clf = xgb.XGBClassifier(
+            tree_method=tree_method, n_estimators=1, eval_metric="aucpr"
+        )
+        clf.fit(X, y, eval_set=[(X, y)])
         evals_result = clf.evals_result()["validation_0"]["aucpr"][-1]
-        # No available implementation for comparison, just check that XGBoost converges to
-        # 1.0
-        clf = xgb.XGBClassifier(tree_method=tree_method, n_estimators=10)
-        clf.fit(X, y, eval_metric="aucpr", eval_set=[(X, y)])
+        # No available implementation for comparison, just check that XGBoost converges
+        # to 1.0
+        clf = xgb.XGBClassifier(
+            tree_method=tree_method, n_estimators=10, eval_metric="aucpr"
+        )
+        clf.fit(X, y, eval_set=[(X, y)])
         evals_result = clf.evals_result()["validation_0"]["aucpr"][-1]
         np.testing.assert_allclose(1.0, evals_result, rtol=1e-2)
 
@@ -282,9 +340,13 @@ class TestEvalMetrics:
 
     def run_pr_auc_ltr(self, tree_method):
         from sklearn.datasets import make_classification
+
         X, y = make_classification(128, 4, n_classes=2, random_state=1994)
         ltr = xgb.XGBRanker(
-            tree_method=tree_method, n_estimators=16, objective="rank:pairwise"
+            tree_method=tree_method,
+            n_estimators=16,
+            objective="rank:pairwise",
+            eval_metric="aucpr",
         )
         groups = np.array([32, 32, 64])
         ltr.fit(
@@ -293,7 +355,6 @@ class TestEvalMetrics:
             group=groups,
             eval_set=[(X, y)],
             eval_group=[groups],
-            eval_metric="aucpr",
         )
         results = ltr.evals_result()["validation_0"]["aucpr"]
         assert results[-1] >= 0.99

tests/python/test_training_continuation.py

@@ -149,8 +149,8 @@ class TestTrainingContinuation:
         from sklearn.datasets import load_breast_cancer
 
         X, y = load_breast_cancer(return_X_y=True)
-        clf = xgb.XGBClassifier(n_estimators=2)
-        clf.fit(X, y, eval_set=[(X, y)], eval_metric="logloss")
+        clf = xgb.XGBClassifier(n_estimators=2, eval_metric="logloss")
+        clf.fit(X, y, eval_set=[(X, y)])
         assert tm.non_increasing(clf.evals_result()["validation_0"]["logloss"])
 
         with tempfile.TemporaryDirectory() as tmpdir:
@@ -160,5 +160,6 @@ class TestTrainingContinuation:
 
         clf = xgb.XGBClassifier(n_estimators=2)
         # change metric to error
-        clf.fit(X, y, eval_set=[(X, y)], eval_metric="error")
+        clf.set_params(eval_metric="error")
+        clf.fit(X, y, eval_set=[(X, y)], xgb_model=loaded)
         assert tm.non_increasing(clf.evals_result()["validation_0"]["error"])

tests/python/test_with_sklearn.py

@@ -30,8 +30,8 @@ def test_binary_classification():
     kf = KFold(n_splits=2, shuffle=True, random_state=rng)
     for cls in (xgb.XGBClassifier, xgb.XGBRFClassifier):
         for train_index, test_index in kf.split(X, y):
-            clf = cls(random_state=42)
-            xgb_model = clf.fit(X[train_index], y[train_index], eval_metric=['auc', 'logloss'])
+            clf = cls(random_state=42, eval_metric=['auc', 'logloss'])
+            xgb_model = clf.fit(X[train_index], y[train_index])
             preds = xgb_model.predict(X[test_index])
             labels = y[test_index]
             err = sum(1 for i in range(len(preds))
@@ -101,10 +101,11 @@ def test_best_iteration():
     def train(booster: str, forest: Optional[int]) -> None:
         rounds = 4
         cls = xgb.XGBClassifier(
-            n_estimators=rounds, num_parallel_tree=forest, booster=booster
-        ).fit(
-            X, y, eval_set=[(X, y)], early_stopping_rounds=3
-        )
+            n_estimators=rounds,
+            num_parallel_tree=forest,
+            booster=booster,
+            early_stopping_rounds=3,
+        ).fit(X, y, eval_set=[(X, y)])
         assert cls.best_iteration == rounds - 1
 
         # best_iteration is used by default, assert that under gblinear it's
@@ -112,9 +113,9 @@ def test_best_iteration():
         cls.predict(X)
 
     num_parallel_tree = 4
-    train('gbtree', num_parallel_tree)
-    train('dart', num_parallel_tree)
-    train('gblinear', None)
+    train("gbtree", num_parallel_tree)
+    train("dart", num_parallel_tree)
+    train("gblinear", None)
 
 
 def test_ranking():
@@ -258,6 +259,7 @@ def test_stacking_classification():
     X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
     clf.fit(X_train, y_train).score(X_test, y_test)
 
+
 @pytest.mark.skipif(**tm.no_pandas())
 def test_feature_importances_weight():
     from sklearn.datasets import load_digits
@@ -474,7 +476,8 @@ def run_housing_rf_regression(tree_method):
 
     rfreg = xgb.XGBRFRegressor()
     with pytest.raises(NotImplementedError):
-        rfreg.fit(X, y, early_stopping_rounds=10)
+        rfreg.set_params(early_stopping_rounds=10)
+        rfreg.fit(X, y)
 
 
 def test_rf_regression():
@@ -574,7 +577,7 @@ def test_classification_with_custom_objective():
         return logregobj(y, p)
 
     cls.set_params(objective=wrapped)
-    cls.predict(X)              # no throw
+    cls.predict(X)  # no throw
     cls.fit(X, y)
 
     assert is_called[0]
@@ -844,51 +847,65 @@ def run_validation_weights(model):
     y_train, y_test = y[:1600], y[1600:]
 
     # instantiate model
-    param_dist = {'objective': 'binary:logistic', 'n_estimators': 2,
-                  'random_state': 123}
+    param_dist = {
+        "objective": "binary:logistic",
+        "n_estimators": 2,
+        "random_state": 123,
+    }
     clf = model(**param_dist)
 
     # train it using instance weights only in the training set
     weights_train = np.random.choice([1, 2], len(X_train))
-    clf.fit(X_train, y_train,
-            sample_weight=weights_train,
-            eval_set=[(X_test, y_test)],
-            eval_metric='logloss',
-            verbose=False)
-
+    clf.set_params(eval_metric="logloss")
+    clf.fit(
+        X_train,
+        y_train,
+        sample_weight=weights_train,
+        eval_set=[(X_test, y_test)],
+        verbose=False,
+    )
     # evaluate logloss metric on test set *without* using weights
     evals_result_without_weights = clf.evals_result()
-    logloss_without_weights = evals_result_without_weights[
-        "validation_0"]["logloss"]
+    logloss_without_weights = evals_result_without_weights["validation_0"]["logloss"]
 
     # now use weights for the test set
     np.random.seed(0)
     weights_test = np.random.choice([1, 2], len(X_test))
-    clf.fit(X_train, y_train,
-            sample_weight=weights_train,
-            eval_set=[(X_test, y_test)],
-            sample_weight_eval_set=[weights_test],
-            eval_metric='logloss',
-            verbose=False)
+    clf.set_params(eval_metric="logloss")
+    clf.fit(
+        X_train,
+        y_train,
+        sample_weight=weights_train,
+        eval_set=[(X_test, y_test)],
+        sample_weight_eval_set=[weights_test],
+        verbose=False,
+    )
     evals_result_with_weights = clf.evals_result()
     logloss_with_weights = evals_result_with_weights["validation_0"]["logloss"]
 
     # check that the logloss in the test set is actually different when using
     # weights than when not using them
-    assert all((logloss_with_weights[i] != logloss_without_weights[i]
-                for i in [0, 1]))
+    assert all((logloss_with_weights[i] != logloss_without_weights[i] for i in [0, 1]))
 
     with pytest.raises(ValueError):
         # length of eval set and sample weight doesn't match.
-        clf.fit(X_train, y_train, sample_weight=weights_train,
-                eval_set=[(X_train, y_train), (X_test, y_test)],
-                sample_weight_eval_set=[weights_train])
+        clf.fit(
+            X_train,
+            y_train,
+            sample_weight=weights_train,
+            eval_set=[(X_train, y_train), (X_test, y_test)],
+            sample_weight_eval_set=[weights_train],
+        )
 
     with pytest.raises(ValueError):
         cls = xgb.XGBClassifier()
-        cls.fit(X_train, y_train, sample_weight=weights_train,
-                eval_set=[(X_train, y_train), (X_test, y_test)],
-                sample_weight_eval_set=[weights_train])
+        cls.fit(
+            X_train,
+            y_train,
+            sample_weight=weights_train,
+            eval_set=[(X_train, y_train), (X_test, y_test)],
+            sample_weight_eval_set=[weights_train],
+        )
 
 
 def test_validation_weights():
@@ -960,8 +977,7 @@ def test_XGBClassifier_resume():
 
         # file name of stored xgb model
         model1.save_model(model1_path)
-        model2 = xgb.XGBClassifier(
-            learning_rate=0.3, random_state=0, n_estimators=8)
+        model2 = xgb.XGBClassifier(learning_rate=0.3, random_state=0, n_estimators=8)
         model2.fit(X, Y, xgb_model=model1_path)
 
         pred2 = model2.predict(X)
@@ -972,8 +988,7 @@ def test_XGBClassifier_resume():
 
         # file name of 'Booster' instance Xgb model
         model1.get_booster().save_model(model1_booster_path)
-        model2 = xgb.XGBClassifier(
-            learning_rate=0.3, random_state=0, n_estimators=8)
+        model2 = xgb.XGBClassifier(learning_rate=0.3, random_state=0, n_estimators=8)
         model2.fit(X, Y, xgb_model=model1_booster_path)
 
         pred2 = model2.predict(X)
@@ -1279,12 +1294,16 @@ def test_estimator_reg(estimator, check):
         ):
             estimator.fit(X, y)
         return
-    if os.environ["PYTEST_CURRENT_TEST"].find("check_estimators_overwrite_params") != -1:
+    if (
+        os.environ["PYTEST_CURRENT_TEST"].find("check_estimators_overwrite_params")
+        != -1
+    ):
         # A hack to pass the scikit-learn parameter mutation tests.  XGBoost regressor
-        # returns actual internal default values for parameters in `get_params`, but those
-        # are set as `None` in sklearn interface to avoid duplication.  So we fit a dummy
-        # model and obtain the default parameters here for the mutation tests.
+        # returns actual internal default values for parameters in `get_params`, but
+        # those are set as `None` in sklearn interface to avoid duplication.  So we fit
+        # a dummy model and obtain the default parameters here for the mutation tests.
         from sklearn.datasets import make_regression
+
         X, y = make_regression(n_samples=2, n_features=1)
         estimator.set_params(**xgb.XGBRegressor().fit(X, y).get_params())
 
@@ -1325,6 +1344,7 @@ def test_categorical():
 def test_evaluation_metric():
     from sklearn.datasets import load_diabetes, load_digits
     from sklearn.metrics import mean_absolute_error
+
     X, y = load_diabetes(return_X_y=True)
     n_estimators = 16
 
@@ -1341,17 +1361,6 @@ def test_evaluation_metric():
     for line in lines:
         assert line.find("mean_absolute_error") != -1
 
-    def metric(predt: np.ndarray, Xy: xgb.DMatrix):
-        y = Xy.get_label()
-        return "m", np.abs(predt - y).sum()
-
-    with pytest.warns(UserWarning):
-        reg = xgb.XGBRegressor(
-            tree_method="hist",
-            n_estimators=1,
-        )
-        reg.fit(X, y, eval_set=[(X, y)], eval_metric=metric)
-
     def merror(y_true: np.ndarray, predt: np.ndarray):
         n_samples = y_true.shape[0]
         assert n_samples == predt.size