style: apply clang-format to all legacy files

Author: littleotherut

CMakeLists.txt

@@ -204,25 +204,23 @@ link_infini_train_exe(test_precision_check)
 add_executable(test_lora test/lora/test_lora.cc)
 link_infini_train_exe(test_lora)
 
-target_link_libraries(test_precision_check infini_train)
-
 add_executable(test_lr_scheduler test/lr_scheduler/test_lr_scheduler.cc)
-target_link_libraries(test_lr_scheduler infini_train)
+link_infini_train_exe(test_lr_scheduler)
 
 add_executable(test_constant_lr test/lr_scheduler/test_constant_lr.cc)
-target_link_libraries(test_constant_lr infini_train)
+link_infini_train_exe(test_constant_lr)
 
 add_executable(test_step_lr test/lr_scheduler/test_step_lr.cc)
-target_link_libraries(test_step_lr infini_train)
+link_infini_train_exe(test_step_lr)
 
 add_executable(test_linear_lr test/lr_scheduler/test_linear_lr.cc)
-target_link_libraries(test_linear_lr infini_train)
+link_infini_train_exe(test_linear_lr)
 
 add_executable(test_lambda_lr test/lr_scheduler/test_lambda_lr.cc)
-target_link_libraries(test_lambda_lr infini_train)
+link_infini_train_exe(test_lambda_lr)
 
 add_executable(test_sequential_lr test/lr_scheduler/test_sequential_lr.cc)
-target_link_libraries(test_sequential_lr infini_train)
+link_infini_train_exe(test_sequential_lr)
 
 add_executable(test_chained_lr test/lr_scheduler/test_chained_lr.cc)
-target_link_libraries(test_chained_lr infini_train)
+link_infini_train_exe(test_chained_lr)

example/gpt2/main.cc

@@ -58,8 +58,7 @@ DEFINE_uint32(text_length, 64, "the length of the generated text");
 DEFINE_double(learning_rate, 1e-4, "learning rate warmup iterations");
 DEFINE_bool(use_distributed_optimizer, false, "Whether to enable DistributedOptimizer(only take effects when DP>1)");
 // lr scheduler
-DEFINE_string(lr_scheduler, "none",
-              "Learning rate scheduler type: none|constant|step|linear");
+DEFINE_string(lr_scheduler, "none", "Learning rate scheduler type: none|constant|step|linear");
 DEFINE_int64(warmup_steps, 0, "Number of linear warmup steps (0 = no warmup)");
 DEFINE_double(warmup_start_factor, 0.333333, "Starting learning rate factor for linear warmup (multiplied by base LR)");
 DEFINE_double(warmup_end_factor, 1.0, "Ending learning rate factor for linear warmup (multiplied by base LR)");
@@ -331,10 +330,10 @@ void Train(const nn::parallel::Rank &rank) {
     sched_config.step_gamma = static_cast<float>(FLAGS_gamma);
     sched_config.linear_start_factor = static_cast<float>(FLAGS_start_factor);
     sched_config.linear_end_factor = static_cast<float>(FLAGS_end_factor);
-    sched_config.constant_factor = static_cast<float>(FLAGS_start_factor);  // 复用
+    sched_config.constant_factor = static_cast<float>(FLAGS_start_factor); // 复用
     sched_config.constant_total_iters = FLAGS_lr_total_iters;
     sched_config.linear_total_iters = FLAGS_lr_total_iters;
-    auto scheduler = CreateLRScheduler(optimizer,sched_config);
+    auto scheduler = CreateLRScheduler(optimizer, sched_config);
 
     auto train_iter = train_loader.begin();
     std::shared_ptr<nn::Module> loss_fn
@@ -455,8 +454,8 @@ void Train(const nn::parallel::Rank &rank) {
             std::tie(used_mb, reserved_mb) = impl->GetMemPoolPeakMB(device);
             LOG(ERROR) << std::format("step {:4d}/{} | train loss {:.6f} | lr {:.2e} | ({:.2f} ms | {:.0f} tok/s | "
                                       "peak used: {:5d} MB | peak reserved: {:5d} MB, DP={}, TP={}, SP={}, PP={})",
-                                      step + 1, FLAGS_num_iteration, lossf, current_lr, duration_us / 1e3f,
-                                      tps, used_mb, reserved_mb, ddp_world_size, tp_world_size, sp_world_size,
+                                      step + 1, FLAGS_num_iteration, lossf, current_lr, duration_us / 1e3f, tps,
+                                      used_mb, reserved_mb, ddp_world_size, tp_world_size, sp_world_size,
                                       pp_world_size);
 
             if ((step + 1) % FLAGS_freq_generate_txt == 0) {

example/llama3/main.cc

@@ -57,8 +57,7 @@ DEFINE_uint32(text_length, 64, "the length of the generated text");
 DEFINE_double(learning_rate, 1e-5, "learning rate warmup iterations");
 DEFINE_bool(use_distributed_optimizer, false, "Whether to enable DistributedOptimizer(only take effects when DP>1)");
 // lr scheduler
-DEFINE_string(lr_scheduler, "none",
-              "Learning rate scheduler type: none|constant|step|linear");
+DEFINE_string(lr_scheduler, "none", "Learning rate scheduler type: none|constant|step|linear");
 DEFINE_int64(warmup_steps, 0, "Number of linear warmup steps (0 = no warmup)");
 DEFINE_double(warmup_start_factor, 0.333333, "Starting learning rate factor for linear warmup (multiplied by base LR)");
 DEFINE_double(warmup_end_factor, 1.0, "Ending learning rate factor for linear warmup (multiplied by base LR)");
@@ -303,10 +302,10 @@ void Train(const nn::parallel::Rank &rank) {
     sched_config.step_gamma = static_cast<float>(FLAGS_gamma);
     sched_config.linear_start_factor = static_cast<float>(FLAGS_start_factor);
     sched_config.linear_end_factor = static_cast<float>(FLAGS_end_factor);
-    sched_config.constant_factor = static_cast<float>(FLAGS_start_factor);  // 复用
+    sched_config.constant_factor = static_cast<float>(FLAGS_start_factor); // 复用
     sched_config.constant_total_iters = FLAGS_lr_total_iters;
     sched_config.linear_total_iters = FLAGS_lr_total_iters;
-    auto scheduler = CreateLRScheduler(optimizer,sched_config);
+    auto scheduler = CreateLRScheduler(optimizer, sched_config);
 
     auto train_iter = train_loader.begin();
     std::shared_ptr<nn::Module> loss_fn
@@ -424,8 +423,8 @@ void Train(const nn::parallel::Rank &rank) {
             std::tie(used_mb, reserved_mb) = impl->GetMemPoolPeakMB(device);
             LOG(ERROR) << std::format("step {:4d}/{} | train loss {:.6f} | lr {:.2e} | ({:.2f} ms | {:.0f} tok/s | "
                                       "peak used: {:5d} MB | peak reserved: {:5d} MB, DP={}, TP={}, SP={}, PP={})",
-                                      step + 1, FLAGS_num_iteration, lossf, current_lr, duration_us / 1e3f,
-                                      tps, used_mb, reserved_mb, ddp_world_size, tp_world_size, sp_world_size,
+                                      step + 1, FLAGS_num_iteration, lossf, current_lr, duration_us / 1e3f, tps,
+                                      used_mb, reserved_mb, ddp_world_size, tp_world_size, sp_world_size,
                                       pp_world_size);
 
             if ((step + 1) % FLAGS_freq_generate_txt == 0) {

infini_train/include/lr_scheduler.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <cstdint>
 #include <cmath>
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
@@ -13,12 +13,11 @@ namespace infini_train {
 
 class Optimizer;
 
-using StateValue = std::variant<int64_t, float, double, std::string,
-                                std::vector<float>>;
+using StateValue = std::variant<int64_t, float, double, std::string, std::vector<float>>;
 using StateDict = std::unordered_map<std::string, StateValue>;
 
 struct LRSchedulerConfig {
-    std::string type  = "none";
+    std::string type = "none";
     // ConstantLR
     float constant_factor = 1.0f / 3.0f;
     int constant_total_iters = 5;
@@ -44,15 +43,13 @@ struct LRSchedulerConfig {
 
 class LRScheduler {
 public:
-    template<typename T, typename... Args>
-    static std::shared_ptr<T> Create(Args&&... args) {
+    template <typename T, typename... Args> static std::shared_ptr<T> Create(Args &&...args) {
         auto scheduler = std::make_shared<T>(std::forward<Args>(args)...);
         scheduler->InitialStep();
         return scheduler;
     }
 
-    explicit LRScheduler(std::shared_ptr<Optimizer> optimizer,
-                         int64_t last_step = -1);
+    explicit LRScheduler(std::shared_ptr<Optimizer> optimizer, int64_t last_step = -1);
     virtual ~LRScheduler() = default;
 
     LRScheduler(const LRScheduler &) = delete;
@@ -82,17 +79,13 @@ class LRScheduler {
     bool is_initial_ = false;
 };
 
-std::shared_ptr<LRScheduler> CreateLRScheduler(
-    std::shared_ptr<Optimizer> optimizer,
-    const LRSchedulerConfig& config);
+std::shared_ptr<LRScheduler> CreateLRScheduler(std::shared_ptr<Optimizer> optimizer, const LRSchedulerConfig &config);
 
 namespace lr_schedulers {
 
 class ConstantLR : public LRScheduler {
 public:
-    ConstantLR(std::shared_ptr<Optimizer> optimizer, 
-               float factor = 1.0f / 3.0f, 
-               int total_iters = 5, 
+    ConstantLR(std::shared_ptr<Optimizer> optimizer, float factor = 1.0f / 3.0f, int total_iters = 5,
                int64_t last_step = -1);
     ~ConstantLR() override = default;
 
@@ -107,10 +100,7 @@ class ConstantLR : public LRScheduler {
 
 class StepLR : public LRScheduler {
 public:
-    StepLR(std::shared_ptr<Optimizer> optimizer, 
-           int64_t step_size, 
-           float gamma = 0.1f, 
-           int64_t last_step = -1);
+    StepLR(std::shared_ptr<Optimizer> optimizer, int64_t step_size, float gamma = 0.1f, int64_t last_step = -1);
     ~StepLR() override = default;
 
 protected:
@@ -124,11 +114,8 @@ class StepLR : public LRScheduler {
 
 class LinearLR : public LRScheduler {
 public:
-    LinearLR(std::shared_ptr<Optimizer> optimizer,
-             float start_factor = 1.0f / 3.0f,
-             float end_factor = 1.0f,
-             int64_t total_iters = 5,
-             int64_t last_step = -1);
+    LinearLR(std::shared_ptr<Optimizer> optimizer, float start_factor = 1.0f / 3.0f, float end_factor = 1.0f,
+             int64_t total_iters = 5, int64_t last_step = -1);
     ~LinearLR() override = default;
 
 protected:
@@ -145,9 +132,7 @@ class LambdaLR : public LRScheduler {
 public:
     using LambdaFunc = std::function<float(int64_t)>;
 
-    LambdaLR(std::shared_ptr<Optimizer> optimizer, 
-                LambdaFunc lr_lambda, 
-                int64_t last_step = -1);
+    LambdaLR(std::shared_ptr<Optimizer> optimizer, LambdaFunc lr_lambda, int64_t last_step = -1);
     ~LambdaLR() override = default;
 
 protected:
@@ -157,13 +142,10 @@ class LambdaLR : public LRScheduler {
     const LambdaFunc lr_lambda_;
 };
 
-
 class SequentialLR : public LRScheduler {
 public:
-    SequentialLR(std::shared_ptr<Optimizer> optimizer, 
-                 std::vector<std::shared_ptr<LRScheduler>> schedulers,
-                 std::vector<int64_t> milestones, 
-                 int64_t last_step = -1);
+    SequentialLR(std::shared_ptr<Optimizer> optimizer, std::vector<std::shared_ptr<LRScheduler>> schedulers,
+                 std::vector<int64_t> milestones, int64_t last_step = -1);
     ~SequentialLR() override = default;
 
     void Step() override;
@@ -183,16 +165,15 @@ class SequentialLR : public LRScheduler {
 
 class ChainedScheduler : public LRScheduler {
 public:
-    ChainedScheduler(std::shared_ptr<Optimizer> optimizer,
-                     std::vector<std::shared_ptr<LRScheduler>> schedulers,
+    ChainedScheduler(std::shared_ptr<Optimizer> optimizer, std::vector<std::shared_ptr<LRScheduler>> schedulers,
                      int64_t last_step = -1);
     ~ChainedScheduler() override = default;
 
     void Step() override;
     void InitialStep() override;
 
     StateDict State() const override;
-    void LoadState(const StateDict& state) override;
+    void LoadState(const StateDict &state) override;
 
 protected:
     float GetClosedFormLR() const override { return current_lr_; }
@@ -201,6 +182,5 @@ class ChainedScheduler : public LRScheduler {
     std::vector<std::shared_ptr<LRScheduler>> schedulers_;
 };
 
-
-}  // namespace lr_schedulers
-}  // namespace infini_train
+} // namespace lr_schedulers
+} // namespace infini_train

infini_train/include/optimizer.h

@@ -26,7 +26,7 @@ class Optimizer {
     virtual float GetLearningRate() const;
 
     float GetInitialLearningRate() const;
-    
+
     void SetInitialLearningRate(float lr);
 
 protected:
@@ -48,7 +48,6 @@ class SGD : public Optimizer {
             return std::make_shared<SGD>(params, learning_rate);
         };
     }
-
 };
 
 class Adam : public Optimizer {