Merge pull request #299 from zhiminzhang0830/upper

change name of constant parameter to upper case

Author: HydrogenSulfate

examples/cylinder/2d_unsteady/cylinder2d_unsteady_Re100.py

@@ -23,11 +23,11 @@
     # set random seed for reproducibility
     ppsci.utils.misc.set_random_seed(42)
     # set output directory
-    output_dir = (
+    OUTPUT_DIR = (
         "./output_cylinder2d_unsteady" if not args.output_dir else args.output_dir
     )
     # initialize logger
-    logger.init_logger("ppsci", f"{output_dir}/train.log", "info")
+    logger.init_logger("ppsci", f"{OUTPUT_DIR}/train.log", "info")
 
     # set model
     model = ppsci.arch.MLP(
@@ -37,19 +37,19 @@
     equation = {"NavierStokes": ppsci.equation.NavierStokes(0.02, 1.0, 2, True)}
 
     # set timestamps
-    time_start, time_end = 1, 50
-    num_timestamps = 50
-    train_num_timestamps = 30
+    TIME_START, TIME_END = 1, 50
+    NUM_TIMESTAMPS = 50
+    TRAIN_NUM_TIMESTAMPS = 30
 
     train_timestamps = np.linspace(
-        time_start, time_end, num_timestamps, endpoint=True
+        TIME_START, TIME_END, NUM_TIMESTAMPS, endpoint=True
     ).astype("float32")
-    train_timestamps = np.random.choice(train_timestamps, train_num_timestamps)
+    train_timestamps = np.random.choice(train_timestamps, TRAIN_NUM_TIMESTAMPS)
     train_timestamps.sort()
-    t0 = np.array([time_start], dtype="float32")
+    t0 = np.array([TIME_START], dtype="float32")
 
     val_timestamps = np.linspace(
-        time_start, time_end, num_timestamps, endpoint=True
+        TIME_START, TIME_END, NUM_TIMESTAMPS, endpoint=True
     ).astype("float32")
 
     logger.info(f"train_timestamps: {train_timestamps.tolist()}")
@@ -59,8 +59,8 @@
     geom = {
         "time_rect": ppsci.geometry.TimeXGeometry(
             ppsci.geometry.TimeDomain(
-                time_start,
-                time_end,
+                TIME_START,
+                TIME_END,
                 timestamps=np.concatenate((t0, train_timestamps), axis=0),
             ),
             ppsci.geometry.PointCloud(
@@ -77,13 +77,13 @@
     }
 
     # set dataloader config
-    iters_per_epoch = 1
+    ITERS_PER_EPOCH = 1
 
     # pde/bc/sup constraint use t1~tn, initial constraint use t0
-    npoint_pde, ntime_pde = 9420, len(train_timestamps)
-    npoint_inlet_cylinder = 161
-    npoint_outlet = 81
-    alias_dict = {"x": "Points:0", "y": "Points:1", "u": "U:0", "v": "U:1"}
+    NPOINT_PDE, ntime_pde = 9420, len(train_timestamps)
+    NPOINT_INLET_CYLINDER = 161
+    NPOINT_OUTLET = 81
+    ALIAS_DICT = {"x": "Points:0", "y": "Points:1", "u": "U:0", "v": "U:1"}
 
     # set constraint
     pde_constraint = ppsci.constraint.InteriorConstraint(
@@ -92,8 +92,8 @@
         geom["time_rect"],
         {
             "dataset": "IterableNamedArrayDataset",
-            "batch_size": npoint_pde * ntime_pde,
-            "iters_per_epoch": iters_per_epoch,
+            "batch_size": NPOINT_PDE * ntime_pde,
+            "iters_per_epoch": ITERS_PER_EPOCH,
         },
         ppsci.loss.MSELoss("mean"),
         name="EQ",
@@ -105,7 +105,7 @@
                 "file_path": "./datasets/domain_inlet_cylinder.csv",
                 "input_keys": ["x", "y"],
                 "label_keys": ["u", "v"],
-                "alias_dict": alias_dict,
+                "alias_dict": ALIAS_DICT,
                 "weight_dict": {"u": 10, "v": 10},
                 "timestamps": train_timestamps,
             },
@@ -120,7 +120,7 @@
                 "file_path": "./datasets/domain_outlet.csv",
                 "input_keys": ["x", "y"],
                 "label_keys": ["p"],
-                "alias_dict": alias_dict,
+                "alias_dict": ALIAS_DICT,
                 "timestamps": train_timestamps,
             },
         },
@@ -134,7 +134,7 @@
                 "file_path": "./datasets/initial/ic0.1.csv",
                 "input_keys": ["x", "y"],
                 "label_keys": ["u", "v", "p"],
-                "alias_dict": alias_dict,
+                "alias_dict": ALIAS_DICT,
                 "weight_dict": {"u": 10, "v": 10, "p": 10},
                 "timestamps": t0,
             },
@@ -149,7 +149,7 @@
                 "file_path": "./datasets/probe/probe1_50.csv",
                 "input_keys": ["t", "x", "y"],
                 "label_keys": ["u", "v"],
-                "alias_dict": alias_dict,
+                "alias_dict": ALIAS_DICT,
                 "weight_dict": {"u": 10, "v": 10},
                 "timestamps": train_timestamps,
             },
@@ -167,14 +167,14 @@
     }
 
     # set training hyper-parameters
-    epochs = 40000 if not args.epochs else args.epochs
-    eval_freq = 400
+    EPOCHS = 40000 if not args.epochs else args.epochs
+    EVAL_FREQ = 400
 
     # set optimizer
     optimizer = ppsci.optimizer.Adam(0.001)((model,))
 
     # set validator
-    npoints_eval = (npoint_pde + npoint_inlet_cylinder + npoint_outlet) * num_timestamps
+    npoints_eval = (NPOINT_PDE + NPOINT_INLET_CYLINDER + NPOINT_OUTLET) * NUM_TIMESTAMPS
     residual_validator = ppsci.validate.GeometryValidator(
         equation["NavierStokes"].equations,
         {"continuity": 0, "momentum_x": 0, "momentum_y": 0},
@@ -193,13 +193,13 @@
 
     # set visualizer(optional)
     vis_points = geom["time_rect_eval"].sample_interior(
-        (npoint_pde + npoint_inlet_cylinder + npoint_outlet) * num_timestamps
+        (NPOINT_PDE + NPOINT_INLET_CYLINDER + NPOINT_OUTLET) * NUM_TIMESTAMPS
     )
     visualizer = {
         "visulzie_u": ppsci.visualize.VisualizerVtu(
             vis_points,
             {"u": lambda d: d["u"], "v": lambda d: d["v"], "p": lambda d: d["p"]},
-            num_timestamps=num_timestamps,
+            num_timestamps=NUM_TIMESTAMPS,
             prefix="result_u",
         )
     }
@@ -208,13 +208,13 @@
     solver = ppsci.solver.Solver(
         model,
         constraint,
-        output_dir,
+        OUTPUT_DIR,
         optimizer,
         None,
-        epochs,
-        iters_per_epoch,
+        EPOCHS,
+        ITERS_PER_EPOCH,
         eval_during_train=True,
-        eval_freq=eval_freq,
+        eval_freq=EVAL_FREQ,
         equation=equation,
         geom=geom,
         validator=validator,
@@ -228,16 +228,16 @@
     solver.visualize()
 
     # directly evaluate model from pretrained_model_path(optional)
-    logger.init_logger("ppsci", f"{output_dir}/eval.log", "info")
+    logger.init_logger("ppsci", f"{OUTPUT_DIR}/eval.log", "info")
     solver = ppsci.solver.Solver(
         model,
         constraint,
-        output_dir,
+        OUTPUT_DIR,
         equation=equation,
         geom=geom,
         validator=validator,
         visualizer=visualizer,
-        pretrained_model_path=f"{output_dir}/checkpoints/latest",
+        pretrained_model_path=f"{OUTPUT_DIR}/checkpoints/latest",
     )
     solver.eval()
     # visualize prediction from pretrained_model_path(optional)

examples/cylinder/2d_unsteady/transformer_physx/train_enn_v2.py

@@ -48,29 +48,29 @@ def get_mean_std(data: np.ndarray, visc: np.ndarray):
 if __name__ == "__main__":
     ppsci.utils.set_random_seed(42)
 
-    epochs = 300
-    train_block_size = 4
-    valid_block_size = 32
+    EPOCHS = 300
+    TRAIN_BLOCK_SIZE = 4
+    VALID_BLOCK_SIZE = 32
 
     input_keys = ("states", "visc")
     output_keys = ("pred_states", "recover_states")
-    weights = (10.0 * (train_block_size - 1), 10.0 * train_block_size)
+    weights = (10.0 * (TRAIN_BLOCK_SIZE - 1), 10.0 * TRAIN_BLOCK_SIZE)
     regularization_key = "k_matrix"
 
-    output_dir = "./output/cylinder_enn"
-    train_file_path = "./datasets/cylinder_training.hdf5"
-    valid_file_path = "./datasets/cylinder_valid.hdf5"
+    OUTPUT_DIR = "./output/cylinder_enn"
+    TRAIN_FILE_PATH = "./datasets/cylinder_training.hdf5"
+    VALID_FILE_PATH = "./datasets/cylinder_valid.hdf5"
     # initialize logger
-    logger.init_logger("ppsci", f"{output_dir}/train.log", "info")
+    logger.init_logger("ppsci", f"{OUTPUT_DIR}/train.log", "info")
 
     # maunally build constraint(s)
     train_dataloader_cfg = {
         "dataset": {
             "name": "CylinderDataset",
-            "file_path": train_file_path,
+            "file_path": TRAIN_FILE_PATH,
             "input_keys": input_keys,
             "label_keys": output_keys,
-            "block_size": train_block_size,
+            "block_size": TRAIN_BLOCK_SIZE,
             "stride": 16,
             "weight_dict": {key: value for key, value in zip(output_keys, weights)},
         },
@@ -86,15 +86,15 @@ def get_mean_std(data: np.ndarray, visc: np.ndarray):
     sup_constraint = ppsci.constraint.SupervisedConstraint(
         train_dataloader_cfg,
         ppsci.loss.MSELossWithL2Decay(
-            regularization_dict={regularization_key: 1.0e-2 * (train_block_size - 1)}
+            regularization_dict={regularization_key: 1.0e-2 * (TRAIN_BLOCK_SIZE - 1)}
         ),
         {key: lambda out, k=key: out[k] for key in output_keys + (regularization_key,)},
         name="Sup",
     )
     constraint = {sup_constraint.name: sup_constraint}
 
     # set iters_per_epoch by dataloader length
-    iters_per_epoch = len(sup_constraint.data_loader)
+    ITERS_PER_EPOCH = len(sup_constraint.data_loader)
 
     # manually init model
     data_mean, data_std = get_mean_std(
@@ -107,11 +107,11 @@ def get_mean_std(data: np.ndarray, visc: np.ndarray):
     # init optimizer and lr scheduler
     clip = paddle.nn.ClipGradByGlobalNorm(clip_norm=0.1)
     lr_scheduler = ppsci.optimizer.lr_scheduler.ExponentialDecay(
-        epochs,
-        iters_per_epoch,
+        EPOCHS,
+        ITERS_PER_EPOCH,
         0.001,
         gamma=0.995,
-        decay_steps=iters_per_epoch,
+        decay_steps=ITERS_PER_EPOCH,
         by_epoch=True,
     )()
     optimizer = ppsci.optimizer.Adam(
@@ -121,14 +121,14 @@ def get_mean_std(data: np.ndarray, visc: np.ndarray):
     )([model])
 
     # maunally build validator
-    weights = (10.0 * (valid_block_size - 1), 10.0 * valid_block_size)
+    weights = (10.0 * (VALID_BLOCK_SIZE - 1), 10.0 * VALID_BLOCK_SIZE)
     eval_dataloader_cfg = {
         "dataset": {
             "name": "CylinderDataset",
-            "file_path": valid_file_path,
+            "file_path": VALID_FILE_PATH,
             "input_keys": input_keys,
             "label_keys": output_keys,
-            "block_size": valid_block_size,
+            "block_size": VALID_BLOCK_SIZE,
             "stride": 32,
             "weight_dict": {key: value for key, value in zip(output_keys, weights)},
         },
@@ -153,11 +153,11 @@ def get_mean_std(data: np.ndarray, visc: np.ndarray):
     solver = ppsci.solver.Solver(
         model,
         constraint,
-        output_dir,
+        OUTPUT_DIR,
         optimizer,
         lr_scheduler,
-        epochs,
-        iters_per_epoch,
+        EPOCHS,
+        ITERS_PER_EPOCH,
         eval_during_train=True,
         eval_freq=50,
         validator=validator,
@@ -168,11 +168,11 @@ def get_mean_std(data: np.ndarray, visc: np.ndarray):
     solver.eval()
 
     # directly evaluate pretrained model(optional)
-    logger.init_logger("ppsci", f"{output_dir}/eval.log", "info")
+    logger.init_logger("ppsci", f"{OUTPUT_DIR}/eval.log", "info")
     solver = ppsci.solver.Solver(
         model,
-        output_dir=output_dir,
+        output_dir=OUTPUT_DIR,
         validator=validator,
-        pretrained_model_path=f"{output_dir}/checkpoints/latest",
+        pretrained_model_path=f"{OUTPUT_DIR}/checkpoints/latest",
     )
     solver.eval()