1. fix vispoints bug in cylinder2d_unsteady_Re100; 2. remove dot at end of print info

Author: HydrogenSulfate

examples/cylinder/2d_unsteady/cylinder2d_unsteady_Re100.py

@@ -13,16 +13,14 @@
 # limitations under the License.
 
 import numpy as np
-from paddle import fluid
 
 import ppsci
 from ppsci.utils import config
 from ppsci.utils import logger
 from ppsci.utils import reader
 
 if __name__ == "__main__":
-    fluid.core.set_prim_eager_enabled(True)
-
+    # fluid.core.set_prim_eager_enabled(True)
     args = config.parse_args()
     # set random seed for reproducibility
     ppsci.utils.misc.set_random_seed(42)
@@ -89,7 +87,7 @@
     ITERS_PER_EPOCH = 1
 
     # pde/bc/sup constraint use t1~tn, initial constraint use t0
-    NPOINT_PDE, ntime_pde = 9420, len(train_timestamps)
+    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"}
@@ -101,7 +99,7 @@
         geom["time_rect"],
         {
             "dataset": "IterableNamedArrayDataset",
-            "batch_size": NPOINT_PDE * ntime_pde,
+            "batch_size": NPOINT_PDE * NTIME_PDE,
             "iters_per_epoch": ITERS_PER_EPOCH,
         },
         ppsci.loss.MSELoss("mean"),
@@ -202,14 +200,15 @@
 
     # 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,
+        evenly=True,
     )
     visualizer = {
-        "visulzie_u": ppsci.visualize.VisualizerVtu(
+        "visulzie_u_v_p": ppsci.visualize.VisualizerVtu(
             vis_points,
             {"u": lambda d: d["u"], "v": lambda d: d["v"], "p": lambda d: d["p"]},
             num_timestamps=NUM_TIMESTAMPS,
-            prefix="result_u",
+            prefix="result_u_v_p",
         )
     }
 

ppsci/solver/solver.py

@@ -439,7 +439,7 @@ def visualize(self, epoch_id: int = 0):
         self.visu_func = ppsci.solver.visu.visualize_func
 
         self.visu_func(self, epoch_id)
-        logger.info(f"[Visualize][Epoch {epoch_id}] Finished visualization.")
+        logger.info(f"[Visualize][Epoch {epoch_id}] Finished visualization")
 
         if train_state:
             self.model.train()
@@ -516,7 +516,7 @@ def export(self):
         export_dir = self.cfg["Global"]["save_inference_dir"]
         save_path = os.path.join(export_dir, "inference")
         paddle.jit.save(static_model, save_path)
-        logger.info(f"The inference model has been exported to {export_dir}.")
+        logger.info(f"The inference model has been exported to {export_dir}")
 
     def autocast_context_manager(self) -> contextlib.AbstractContextManager:
         """Autocast context manager for Auto Mix Precision.

ppsci/utils/download.py

@@ -132,9 +132,7 @@ def _download(url, path, md5sum=None):
             req = requests.get(url, stream=True)
         except Exception as e:  # requests.exceptions.ConnectionError
             logger.info(
-                "Downloading {} from {} failed {} times with exception {}".format(
-                    fname, url, retry_cnt + 1, str(e)
-                )
+                f"Downloading {fname} from {url} failed {retry_cnt + 1} times with exception {str(e)}"
             )
             time.sleep(1)
             continue

ppsci/utils/save_load.py

@@ -34,11 +34,11 @@ def _mkdir_if_not_exist(path):
     if not os.path.exists(path):
         try:
             os.makedirs(path)
-        except OSError as e:
-            if e.errno == errno.EEXIST and os.path.isdir(path):
-                logger.warning(f"{path} already created")
+        except OSError as os_err:
+            if os_err.errno == errno.EEXIST and os.path.isdir(path):
+                logger.warning(f"{path} already created.")
             else:
-                raise OSError(f"Failed to mkdir {path}")
+                raise OSError(f"Failed to mkdir {path}.")
 
 
 def _load_pretrain_from_path(model, path, equation=None):
@@ -49,17 +49,20 @@ def _load_pretrain_from_path(model, path, equation=None):
         path (str, optional): Pretrained model path.
         equation (Optional[Dict[str, ppsci.equation.PDE]]): Equations. Defaults to None.
     """
-    if not (os.path.isdir(path) or os.path.exists(path + ".pdparams")):
+    if not (os.path.isdir(path) or os.path.exists(f"{path}.pdparams")):
         raise FileNotFoundError(
             f"Pretrained model path {path}.pdparams does not exists."
         )
 
-    param_state_dict = paddle.load(path + ".pdparams")
+    param_state_dict = paddle.load(f"{path}.pdparams")
     model.set_dict(param_state_dict)
     if equation is not None:
-        equation_dict = paddle.load(path + ".pdeqn")
-        for name, _equation in equation.items():
-            _equation.set_state_dict(equation_dict[name])
+        if not os.path.exists(f"{path}.pdeqn"):
+            logger.warning(f"{path}.pdeqn not found.")
+        else:
+            equation_dict = paddle.load(f"{path}.pdeqn")
+            for name, _equation in equation.items():
+                _equation.set_state_dict(equation_dict[name])
 
     logger.info(f"Finish loading pretrained model from {path}")
 
@@ -92,28 +95,32 @@ def load_checkpoint(
     Returns:
         Dict[str, Any]: Loaded metric information.
     """
-    if not os.path.exists(path + ".pdparams"):
+    if not os.path.exists(f"{path}.pdparams"):
         raise FileNotFoundError(f"{path}.pdparams not exist.")
-    if not os.path.exists(path + ".pdopt"):
+    if not os.path.exists(f"{path}.pdopt"):
         raise FileNotFoundError(f"{path}.pdopt not exist.")
-    if grad_scaler is not None and not os.path.exists(path + ".pdscaler"):
+    if grad_scaler is not None and not os.path.exists(f"{path}.pdscaler"):
         raise FileNotFoundError(f"{path}.scaler not exist.")
 
     # load state dict
-    param_dict = paddle.load(path + ".pdparams")
-    optim_dict = paddle.load(path + ".pdopt")
-    metric_dict = paddle.load(path + ".pdstates")
+    param_dict = paddle.load(f"{path}.pdparams")
+    optim_dict = paddle.load(f"{path}.pdopt")
+    metric_dict = paddle.load(f"{path}.pdstates")
     if grad_scaler is not None:
-        scaler_dict = paddle.load(path + ".pdscaler")
+        scaler_dict = paddle.load(f"{path}.pdscaler")
     if equation is not None:
-        equation_dict = paddle.load(path + ".pdeqn")
+        if not os.path.exists(f"{path}.pdeqn"):
+            logger.warning(f"{path}.pdeqn not found.")
+            equation_dict = None
+        else:
+            equation_dict = paddle.load(f"{path}.pdeqn")
 
     # set state dict
     model.set_state_dict(param_dict)
     optimizer.set_state_dict(optim_dict)
     if grad_scaler is not None:
         grad_scaler.load_state_dict(scaler_dict)
-    if equation is not None:
+    if equation is not None and equation_dict is not None:
         for name, _equation in equation.items():
             _equation.set_state_dict(equation_dict[name])
 
@@ -141,15 +148,15 @@ def save_checkpoint(
     _mkdir_if_not_exist(model_dir)
     model_path = os.path.join(model_dir, prefix)
 
-    paddle.save(model.state_dict(), model_path + ".pdparams")
-    paddle.save(optimizer.state_dict(), model_path + ".pdopt")
-    paddle.save(metric, model_path + ".pdstates")
+    paddle.save(model.state_dict(), f"{model_path}.pdparams")
+    paddle.save(optimizer.state_dict(), f"{model_path}.pdopt")
+    paddle.save(metric, f"{model_path}.pdstates")
     if grad_scaler is not None:
-        paddle.save(grad_scaler.state_dict(), model_path + ".pdscaler")
+        paddle.save(grad_scaler.state_dict(), f"{model_path}.pdscaler")
     if equation is not None:
         paddle.save(
             {key: eq.state_dict() for key, eq in equation.items()},
-            model_path + ".pdeqn",
+            f"{model_path}.pdeqn",
         )
 
     logger.info(f"Finish saving checkpoint to {model_path}")