style: format code and comments for consistency across lr_scheduler files

Author: kinorw

infini_train/include/lr_scheduler.h

@@ -67,7 +67,7 @@ class LRScheduler {
     virtual StateDict State() const;
     virtual void LoadState(const StateDict &state);
 
-    bool SharesOptimizerWith(const std::shared_ptr<Optimizer> &opt) const ;
+    bool SharesOptimizerWith(const std::shared_ptr<Optimizer> &opt) const;
 
 protected:
     virtual float GetClosedFormLR() const = 0;
@@ -157,7 +157,9 @@ class SequentialLR : public LRScheduler {
     void LoadState(const StateDict &state) override;
 
 protected:
-    float GetClosedFormLR() const override { return base_lr_; } // FIXME: SequentialLR should not have a closed-form LR, but we need to implement this pure virtual function.
+    float GetClosedFormLR() const override {
+        return base_lr_;
+    } // FIXME: SequentialLR should not have a closed-form LR, but we need to implement this pure virtual function.
     void UndoChildInitialSteps();
 
 private:
@@ -178,7 +180,9 @@ class ChainedScheduler : public LRScheduler {
     void LoadState(const StateDict &state) override;
 
 protected:
-    float GetClosedFormLR() const override { return base_lr_; } // FIXME: ChainedScheduler should not have a closed-form LR, but we need to implement this pure virtual function.
+    float GetClosedFormLR() const override {
+        return base_lr_;
+    } // FIXME: ChainedScheduler should not have a closed-form LR, but we need to implement this pure virtual function.
 
 private:
     std::vector<std::shared_ptr<LRScheduler>> schedulers_;

infini_train/src/lr_scheduler.cc

@@ -90,9 +90,7 @@ void LRScheduler::InitialStep() {
     is_initial_ = false;
 }
 
-void LRScheduler::ApplyLR(float lr) {
-    optimizer_->SetLearningRate(lr);
-}
+void LRScheduler::ApplyLR(float lr) { optimizer_->SetLearningRate(lr); }
 
 float LRScheduler::GetChainedFormLR() const { return GetClosedFormLR(); }
 
@@ -129,9 +127,9 @@ namespace lr_schedulers {
 
 ConstantLR::ConstantLR(std::shared_ptr<Optimizer> optimizer, float factor, int total_iters, int64_t last_step)
     : LRScheduler(std::move(optimizer), last_step), factor_(factor), total_iters_(total_iters) {
-        CHECK_GE(factor_, 0.0f) << "ConstantLR: factor must be >= 0.";
-        CHECK_LE(factor_, 1.0f) << "ConstantLR: factor must be <= 1.";
-    }
+    CHECK_GE(factor_, 0.0f) << "ConstantLR: factor must be >= 0.";
+    CHECK_LE(factor_, 1.0f) << "ConstantLR: factor must be <= 1.";
+}
 
 float ConstantLR::GetClosedFormLR() const { return last_step_ < total_iters_ ? base_lr_ * factor_ : base_lr_; }
 
@@ -171,12 +169,12 @@ LinearLR::LinearLR(std::shared_ptr<Optimizer> optimizer, float start_factor, flo
                    int64_t last_step)
     : LRScheduler(std::move(optimizer), last_step), start_factor_(start_factor), end_factor_(end_factor),
       total_iters_(total_iters) {
-        CHECK_GT(start_factor_, 0.0f) << "LinearLR: start_factor must be > 0.";
-        CHECK_LE(start_factor_, 1.0f) << "LinearLR: start_factor must be <= 1.";
-        CHECK_GE(end_factor_, 0.0f) << "LinearLR: end_factor must be >= 0.";
-        CHECK_LE(end_factor_, 1.0f) << "LinearLR: end_factor must be <= 1.";
-                CHECK_GT(total_iters_, 0) << "LinearLR: total_iters must be > 0.";
-      }
+    CHECK_GT(start_factor_, 0.0f) << "LinearLR: start_factor must be > 0.";
+    CHECK_LE(start_factor_, 1.0f) << "LinearLR: start_factor must be <= 1.";
+    CHECK_GE(end_factor_, 0.0f) << "LinearLR: end_factor must be >= 0.";
+    CHECK_LE(end_factor_, 1.0f) << "LinearLR: end_factor must be <= 1.";
+    CHECK_GT(total_iters_, 0) << "LinearLR: total_iters must be > 0.";
+}
 
 float LinearLR::GetClosedFormLR() const {
     if (last_step_ >= total_iters_) {
@@ -210,8 +208,8 @@ float LinearLR::GetChainedFormLR() const {
 
 LambdaLR::LambdaLR(std::shared_ptr<Optimizer> optimizer, std::function<float(int64_t)> lr_lambda, int64_t last_step)
     : LRScheduler(std::move(optimizer), last_step), lr_lambda_(std::move(lr_lambda)) {
-        CHECK(lr_lambda_) << "LambdaLR: lr_lambda must not be null.";
-    }
+    CHECK(lr_lambda_) << "LambdaLR: lr_lambda must not be null.";
+}
 
 float LambdaLR::GetClosedFormLR() const { return base_lr_ * lr_lambda_(last_step_); }
 
@@ -233,7 +231,6 @@ SequentialLR::SequentialLR(std::shared_ptr<Optimizer> optimizer, std::vector<std
     for (size_t i = 1; i < milestones_.size(); ++i) {
         CHECK_GT(milestones_[i], milestones_[i - 1]) << "Milestones must be strictly increasing.";
     }
-
 }
 
 void SequentialLR::InitialStep() {
@@ -266,7 +263,6 @@ void SequentialLR::Step() {
     } else {
         scheduler->Step();
     }
-
 }
 
 StateDict SequentialLR::State() const {
@@ -313,8 +309,7 @@ ChainedScheduler::ChainedScheduler(std::shared_ptr<Optimizer> optimizer,
     }
 }
 
-void ChainedScheduler::InitialStep() {
-}
+void ChainedScheduler::InitialStep() {}
 
 void ChainedScheduler::Step() {
     ++last_step_;

test/lr_scheduler/test_chained_lr.cc

@@ -7,7 +7,7 @@ using namespace infini_train::lr_schedulers;
 namespace {
 constexpr float kBaseLR = 0.1f;
 }
-// TC1: 单子调度器退化
+
 void TestSingleScheduler() {
     std::cout << "[TC1] TestSingleScheduler" << std::endl;
     auto opt = MakeDummyOptimizer(kBaseLR);
@@ -23,7 +23,7 @@ void TestSingleScheduler() {
     ASSERT_FLOAT_NEAR(sched->GetLR(), 0.1f, kEps);
 }
 
-// TC2: StepLR + LambdaLR 乘法叠加
+// TC2: StepLR + LambdaLR
 void TestMultiplicativeChain() {
     std::cout << "[TC2] TestMultiplicativeChain" << std::endl;
     auto opt = MakeDummyOptimizer(kBaseLR);
@@ -53,7 +53,7 @@ void TestMultiplicativeChain() {
     ASSERT_FLOAT_NEAR(sched->GetLR(), 0.07f, kEps);
 }
 
-// TC3: ConstantLR + StepLR 叠加 (无穿插声明)
+// TC3: ConstantLR + StepLR
 void TestConstantPlusStep() {
     std::cout << "[TC3] TestConstantPlusStep" << std::endl;
     auto opt = MakeDummyOptimizer(kBaseLR);
@@ -86,7 +86,7 @@ void TestConstantPlusStep() {
     ASSERT_FLOAT_NEAR(sched->GetLR(), 0.01f, kEps);
 }
 
-// TC4: ConstantLR + StepLR 叠加（有穿插声明）
+// TC4: ConstantLR + StepLR (with extra unused scheduler）
 void TestConstantPlusStepDLC() {
     std::cout << "[TC4] TestConstantPlusStepDLC" << std::endl;
     auto opt = MakeDummyOptimizer(kBaseLR);
@@ -129,7 +129,7 @@ void TestConstantPlusStepDLC() {
     ASSERT_FLOAT_NEAR(sched->GetLR(), 0.02f, kEps);
 }
 
-// TC5: State/LoadState 往返
+// TC5: State/LoadState
 void TestStateRoundTrip() {
     std::cout << "[TC5] TestStateRoundTrip" << std::endl;
     auto opt = MakeDummyOptimizer(kBaseLR);
@@ -199,4 +199,4 @@ int main(int argc, char *argv[]) {
         std::cout << g_fail_count << " test(s) FAILED" << std::endl;
     }
     return g_fail_count > 0 ? 1 : 0;
-}
+}

test/lr_scheduler/test_constant_lr.cc

@@ -181,4 +181,4 @@ int main(int argc, char *argv[]) {
         std::cout << g_fail_count << " test(s) FAILED" << std::endl;
     }
     return g_fail_count > 0 ? 1 : 0;
-}
+}

test/lr_scheduler/test_helpers.h

@@ -32,4 +32,4 @@ void Check(bool cond, const char *expr, int line) {
 #define ASSERT_FLOAT_EQ(a, b) Check(FloatNear((a), (b)), #a " == " #b, __LINE__)
 #define ASSERT_FLOAT_NEAR(a, b, eps) Check(FloatNear((a), (b), (eps)), #a " ≈ " #b, __LINE__)
 
-} // namespace
+} // namespace

test/lr_scheduler/test_lambda_lr.cc

@@ -14,7 +14,7 @@ void TestIdentityLambda() {
                                             .type = "lambda",
                                             .lambda_fn = [](int64_t) { return 1.0f; },
                                         });
-    // 构造器内 Step() → last_step_=0, lr = 0.1 * 1.0 = 0.1
+    // Step() → last_step_=0, lr = 0.1 * 1.0 = 0.1
     ASSERT_TRUE(sched->LastStep() == 0);
     ASSERT_FLOAT_NEAR(sched->GetLR(), kBaseLR, kEps);
     ASSERT_FLOAT_NEAR(opt->GetLearningRate(), kBaseLR, kEps);
@@ -124,4 +124,4 @@ int main(int argc, char *argv[]) {
         std::cout << g_fail_count << " test(s) FAILED" << std::endl;
     }
     return g_fail_count > 0 ? 1 : 0;
-}
+}

test/lr_scheduler/test_linear_lr.cc

@@ -137,4 +137,4 @@ int main(int argc, char *argv[]) {
         std::cout << g_fail_count << " test(s) FAILED" << std::endl;
     }
     return g_fail_count > 0 ? 1 : 0;
-}
+}

test/lr_scheduler/test_lr_scheduler.cc

@@ -103,7 +103,7 @@ void TestLinearDecay() {
     ASSERT_FLOAT_EQ(opt->GetLearningRate(), 0.05f);
 }
 
-// T4: State → LoadState 
+// T4: State → LoadState
 void TestStateRoundTrip() {
     std::cout << "[T4] TestStateRoundTrip" << std::endl;
     constexpr int64_t kTotalSteps = 20;

test/lr_scheduler/test_lr_scheduler_validation.cc

@@ -84,8 +84,8 @@ void TestSequentialLRRejectsMismatchedOptimizer() {
                                               .step_gamma = 0.5f,
                                           });
 
-        auto sched = LRScheduler::Create<SequentialLR>(
-            opt1, std::vector<std::shared_ptr<LRScheduler>>{s1, s2}, std::vector<int64_t>{1});
+        auto sched = LRScheduler::Create<SequentialLR>(opt1, std::vector<std::shared_ptr<LRScheduler>>{s1, s2},
+                                                       std::vector<int64_t>{1});
         (void)sched;
     }));
 }

test/lr_scheduler/test_sequential_lr.cc

@@ -219,4 +219,4 @@ int main(int argc, char *argv[]) {
         std::cout << g_fail_count << " test(s) FAILED" << std::endl;
     }
     return g_fail_count > 0 ? 1 : 0;
-}
+}