[c++] Preserve feature sampling on unrelated parameter updates

CMakeLists.txt

@@ -699,6 +699,7 @@ if(BUILD_CPP_TEST)
       tests/cpp_tests/test_arrow_deprecated.cpp
       tests/cpp_tests/test_byte_buffer.cpp
       tests/cpp_tests/test_chunked_array.cpp
+      tests/cpp_tests/test_col_sampler.cpp
       tests/cpp_tests/test_common.cpp
       tests/cpp_tests/test_main.cpp
       tests/cpp_tests/test_serialize.cpp

src/treelearner/col_sampler.hpp

@@ -53,8 +53,11 @@ class ColSampler {
   }
 
   void SetConfig(const Config* config) {
-    fraction_bytree_ = config->feature_fraction;
     fraction_bynode_ = config->feature_fraction_bynode;
+    if (fraction_bytree_ == config->feature_fraction && seed_ == config->feature_fraction_seed) {
+      return;
+    }
+    fraction_bytree_ = config->feature_fraction;
     is_feature_used_.resize(train_data_->num_features(), 1);
     // seed is changed
     if (seed_ != config->feature_fraction_seed) {

tests/cpp_tests/test_col_sampler.cpp

@@ -0,0 +1,72 @@
+/*!
+ * Copyright (c) 2026 The LightGBM developers. All rights reserved.
+ * Licensed under the MIT License. See LICENSE file in the project root for license information.
+ */
+
+#include <gtest/gtest.h>
+
+#include <LightGBM/c_api.h>
+#include <LightGBM/tree.h>
+
+#include <algorithm>
+#include <memory>
+
+#include "../../src/treelearner/col_sampler.hpp"
+
+namespace {
+
+class ColSamplerTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    double features[20 * 8];
+    for (int row = 0; row < 20; ++row) {
+      for (int col = 0; col < 8; ++col) {
+        features[row * 8 + col] = row * (col + 1);
+      }
+    }
+    DatasetHandle handle;
+    ASSERT_EQ(0, LGBM_DatasetCreateFromMat(features, C_API_DTYPE_FLOAT64, 20, 8, 1,
+        "min_data_in_bin=1 min_data_in_leaf=1 num_threads=1", nullptr, &handle));
+    data_.reset(static_cast<LightGBM::Dataset*>(handle));
+    config_.feature_fraction = 0.5;
+    config_.feature_fraction_seed = 123;
+  }
+
+  LightGBM::Config config_;
+  std::unique_ptr<LightGBM::Dataset> data_;
+};
+
+TEST_F(ColSamplerTest, UnrelatedConfigPreservesSampling) {
+  LightGBM::ColSampler control(&config_);
+  LightGBM::ColSampler updated(&config_);
+  control.SetTrainingData(data_.get());
+  updated.SetTrainingData(data_.get());
+  config_.learning_rate = 0.2;
+  updated.SetConfig(&config_);
+  EXPECT_EQ(control.is_feature_used_bytree(), updated.is_feature_used_bytree());
+  control.ResetByTree();
+  updated.ResetByTree();
+  EXPECT_EQ(control.is_feature_used_bytree(), updated.is_feature_used_bytree());
+}
+
+TEST_F(ColSamplerTest, SamplingConfigStillUpdates) {
+  LightGBM::ColSampler sampler(&config_);
+  sampler.SetTrainingData(data_.get());
+  config_.feature_fraction = 0.25;
+  sampler.SetConfig(&config_);
+  const auto& mask = sampler.is_feature_used_bytree();
+  EXPECT_EQ(2, std::count(mask.begin(), mask.end(), 1));
+
+  config_.feature_fraction_bynode = 0.5;
+  sampler.SetConfig(&config_);
+  const auto node_mask = sampler.GetByNode(nullptr, 0);
+  EXPECT_EQ(1, std::count(node_mask.begin(), node_mask.end(), 1));
+
+  config_.feature_fraction_seed = 456;
+  sampler.SetConfig(&config_);
+  LightGBM::ColSampler fresh(&config_);
+  fresh.SetTrainingData(data_.get());
+  EXPECT_EQ(fresh.is_feature_used_bytree(), sampler.is_feature_used_bytree());
+}
+
+}  // namespace

tests/python_package_test/test_engine.py

@@ -3147,6 +3147,47 @@ def test_default_objective_and_metric():
     assert len(evals_result["valid_0"]["l2"]) == 5
 
 
+@pytest.mark.parametrize("seed", [123, None], ids=["fixed_seed", "randomized"])
+@pytest.mark.parametrize("update", ["custom_objective", "reset_parameter"])
+def test_feature_sampling_is_unchanged_by_unrelated_updates(seed, update):
+    if seed is None:
+        seed = int(np.random.default_rng().integers(0, 1000000))
+    rng = np.random.RandomState(1)
+    X, y = rng.randn(300, 300), rng.randn(300)
+    params = {
+        "objective": "regression",
+        "max_depth": 1,
+        "learning_rate": 0.001,
+        "feature_fraction": 0.5,
+        "seed": seed,
+        "deterministic": True,
+        "force_row_wise": True,
+        "num_threads": 1,
+        "verbosity": -1,
+    }
+    dataset = lgb.Dataset(X, label=y, init_score=np.zeros_like(y))
+    expected = lgb.train(params, dataset, num_boost_round=3)
+
+    def custom_l2(pred, data):
+        return pred - data.get_label(), np.ones_like(pred)
+
+    def reset_same_learning_rate(env):
+        if env.iteration == 0:
+            env.model.reset_parameter({"learning_rate": params["learning_rate"]})
+
+    reset_same_learning_rate.before_iteration = True
+    if update == "custom_objective":
+        params["objective"] = custom_l2
+        callbacks = None
+    else:
+        callbacks = [reset_same_learning_rate]
+    actual = lgb.train(params, dataset, num_boost_round=3, callbacks=callbacks)
+    expected_features = [tree["tree_structure"]["split_feature"] for tree in expected.dump_model()["tree_info"]]
+    actual_features = [tree["tree_structure"]["split_feature"] for tree in actual.dump_model()["tree_info"]]
+    assert actual_features == expected_features, f"seed={seed}"
+    np.testing.assert_allclose(actual.predict(X), expected.predict(X), err_msg=f"seed={seed}")
+
+
 @pytest.mark.parametrize("use_weight", [True, False])
 def test_multiclass_custom_objective(use_weight):
     def custom_obj(y_pred, ds):