feat(log): save the evaluation log and add inlineTee for output file.

* for easy sharing score afterward etc.
* update docs about upcoming works also.

Author: Kin-Zhang

README.md

@@ -11,6 +11,11 @@
 OpenSceneFlow is a codebase for point cloud scene flow estimation. 
 It is also an official implementation of the following papers (sorted by the time of publication):
 
+<!-- - **TeFlow: An Efficient Multi-frame Scene Flow Estimation Method**   
+*Qingwen Zhang, Chenhan Jiang, Xiaomeng Zhu, Yunqi Miao, Yushan Zhang, Olov Andersson, Patric Jensfelt*  
+Under Review   
+[ Strategy ] [ Self-Supervised ] - [ [OpenReview](https://openreview.net/forum?id=h70FLgnIAw) ] [ [Project](https://github.com/Kin-Zhang/TeFlow) ]&rarr; [here](#teflow) -->
+
 - **DeltaFlow: An Efficient Multi-frame Scene Flow Estimation Method**   
 *Qingwen Zhang, Xiaomeng Zhu, Yushan Zhang, Yixi Cai, Olov Andersson, Patric Jensfelt*  
 Conference on Neural Information Processing Systems (**NeurIPS**) 2025 - Spotlight   
@@ -338,6 +343,7 @@ https://github.com/user-attachments/assets/07e8d430-a867-42b7-900a-11755949de21
 ## Cite Us
 
 [*OpenSceneFlow*](https://github.com/KTH-RPL/OpenSceneFlow) is originally designed by [Qingwen Zhang](https://kin-zhang.github.io/) from DeFlow and SeFlow. 
+It is actively maintained and developed by the community (ref. below works).
 If you find it useful, please cite our works:
 
 ```bibtex
@@ -375,6 +381,12 @@ If you find it useful, please cite our works:
   year={2025},
   url={https://openreview.net/forum?id=T9qNDtvAJX}
 }
+@misc{zhang2025teflow,
+  title={{TeFlow}: Enabling Multi-frame Supervision for Feed-forward Scene Flow Estimation},
+  author={Zhang, Qingwen and Jiang, Chenhan and Zhu, Xiaomeng and Miao, Yunqi and Zhang, Yushan and Andersson, Olov and Jensfelt, Patric},
+  year={2025},
+  url={https://openreview.net/forum?id=h70FLgnIAw}
+}
 ```
 
 And our excellent collaborators works contributed to this codebase also:

conf/eval.yaml

@@ -1,6 +1,6 @@
 
 dataset_path: /home/kin/data/av2/h5py/sensor
-checkpoint: /home/kin/model_zoo/deflow.ckpt
+checkpoint: /home/kin/data/model_zoo/deltaflow_public/deltaflow-av2.ckpt
 data_mode: val # [val, test]
 save_res: False # [True, False]
 
@@ -15,7 +15,7 @@ output: ${model.name}-${slurm_id}
 gpus: 1
 seed: 42069
 eval_only: True
-wandb_mode: offline # [offline, disabled, online]
+wandb_mode: disabled # [offline, disabled, online]
 defaults:
   - hydra: default
   - model: deflow

eval.py

@@ -13,12 +13,13 @@
 import torch
 from torch.utils.data import DataLoader
 import lightning.pytorch as pl
-from lightning.pytorch.loggers import WandbLogger
+from lightning.pytorch.loggers import TensorBoardLogger, WandbLogger
 from omegaconf import DictConfig
 import hydra, wandb, os, sys
 from hydra.core.hydra_config import HydraConfig
 from src.dataset import HDF5Dataset
 from src.trainer import ModelWrapper
+from src.utils import InlineTee
 
 def precheck_cfg_valid(cfg):
     if os.path.exists(cfg.dataset_path + f"/{cfg.data_mode}") is False:
@@ -36,8 +37,8 @@ def main(cfg):
 
     if 'iter_only' in cfg.model and cfg.model.iter_only:
         from src.runner import launch_runner
-        print(f"---LOG[eval]: Run optmization-based method: {cfg.model.name}")
-        launch_runner(cfg, cfg.data_mode)
+        launch_runner(cfg, cfg.data_mode, output_dir)
+        print(f"---LOG[eval]: Finished optimization-based evaluation. Logging saved to {output_dir}/output.log")
         return
 
     if not os.path.exists(cfg.checkpoint):
@@ -47,27 +48,39 @@ def main(cfg):
     torch_load_ckpt = torch.load(cfg.checkpoint)
     checkpoint_params = DictConfig(torch_load_ckpt["hyper_parameters"])
     cfg.output = checkpoint_params.cfg.output + f"-e{torch_load_ckpt['epoch']}-{cfg.data_mode}-v{cfg.leaderboard_version}"
+    # replace output_dir ${old_output_dir} with ${output_dir}
+    output_dir = output_dir.replace(HydraConfig.get().runtime.output_dir.split('/')[-2], checkpoint_params.cfg.output.split('/')[-1])
     cfg.model.update(checkpoint_params.cfg.model)
     cfg.num_frames = cfg.model.target.get('num_frames', checkpoint_params.cfg.get('num_frames', cfg.get('num_frames', 2)))
 
     mymodel = ModelWrapper.load_from_checkpoint(cfg.checkpoint, cfg=cfg, eval=True)
-    print(f"\n---LOG[eval]: Loaded model from {cfg.checkpoint}. The backbone network is {checkpoint_params.cfg.model.name}.\n")
+    os.makedirs(output_dir, exist_ok=True)
+    sys.stdout = InlineTee(f"{output_dir}/output.log")
+    print(f"---LOG[eval]: Loaded model from {cfg.checkpoint}. The backbone network is {checkpoint_params.cfg.model.name}.")
+    print(f"---LOG[eval]: Evaluation data: {cfg.dataset_path}/{cfg.data_mode} set.\n")
 
-    wandb_logger = WandbLogger(save_dir=output_dir,
-                               entity="kth-rpl",
-                               project=f"deflow-eval", 
-                               name=f"{cfg.output}",
-                               offline=(cfg.wandb_mode == "offline"))
+    if cfg.wandb_mode != "disabled":
+        logger = WandbLogger(save_dir=output_dir,
+                            entity="kth-rpl",
+                            project=f"opensf-eval", 
+                            name=f"{cfg.output}",
+                            offline=(cfg.wandb_mode == "offline"))
+        logger.watch(mymodel, log_graph=False)
+    else:
+        # check local tensorboard logging: tensorboard --logdir logs/jobs/{log folder}
+        logger = TensorBoardLogger(save_dir=output_dir, name="logs")
 
-    trainer = pl.Trainer(logger=wandb_logger, devices=1)
+    trainer = pl.Trainer(logger=logger, devices=1)
     # NOTE(Qingwen): search & check: def eval_only_step_(self, batch, res_dict)
     trainer.validate(model = mymodel, \
                      dataloaders = DataLoader( \
                                             HDF5Dataset(cfg.dataset_path + f"/{cfg.data_mode}", \
                                                         n_frames=cfg.num_frames, \
                                                         eval=True, leaderboard_version=cfg.leaderboard_version), \
                                             batch_size=1, shuffle=False))
-    wandb.finish()
+    if cfg.wandb_mode != "disabled":
+        wandb.finish()
+    print(f"---LOG[eval]: Finished feed-forward evaluation. Logging saved to {output_dir}/output.log")
 
 if __name__ == "__main__":
     main()

src/runner.py

@@ -15,7 +15,7 @@
 # 
 """
 
-import os
+import os, sys
 import torch
 import torch.distributed as dist
 import torch.multiprocessing as mp
@@ -34,7 +34,7 @@
 from .utils.eval_metric import OfficialMetrics, evaluate_leaderboard, evaluate_leaderboard_v2, evaluate_ssf
 from .utils.av2_eval import write_output_file
 from .utils.mics import zip_res
-
+from .utils import InlineTee
 class SceneDistributedSampler(Sampler):
     """
     A DistributedSampler that distributes data based on scene IDs, not individual indices.
@@ -300,15 +300,20 @@ def _run_process(cfg, mode):
 
     runner.cleanup()
 
-def _spawn_wrapper(rank, world_size, cfg, mode):
+def _spawn_wrapper(rank, world_size, cfg, mode, output_dir):
+    log_filepath = f"{output_dir}/output.log" if output_dir else None
+    if log_filepath and rank==0:
+        sys.stdout = InlineTee(log_filepath, append=True)
+    if rank == 0:
+        print(f"---LOG[eval]: Run optimization-based method: {cfg.model.name} on {cfg.dataset_path}/{cfg.data_mode} set.\n")
     torch.cuda.set_device(rank)
     os.environ['RANK'] = str(rank)
     os.environ['WORLD_SIZE'] = str(world_size)
     os.environ['MASTER_ADDR'] = 'localhost'
     os.environ['MASTER_PORT'] = str(cfg.get('master_port', 12355))
     _run_process(cfg, mode)
 
-def launch_runner(cfg, mode):
+def launch_runner(cfg, mode, output_dir):
     is_slurm_job = 'SLURM_PROCID' in os.environ
 
     if not is_slurm_job and not dist.is_initialized():
@@ -320,7 +325,7 @@ def launch_runner(cfg, mode):
             cfg.save_res_path = Path(cfg.dataset_path).parent / "results" / cfg.output
 
         mp.spawn(_spawn_wrapper,
-                 args=(world_size, cfg, mode),
+                 args=(world_size, cfg, mode, output_dir),
                  nprocs=world_size,
                  join=True)
 

src/utils/__init__.py

@@ -29,4 +29,48 @@ def npcal_pose0to1(pose0, pose1):
     pose1_inv[:3,:3] = pose1[:3,:3].T
     pose1_inv[:3,3] = (pose1[:3,:3].T * -pose1[:3,3]).sum(axis=1)
     pose_0to1 = pose1_inv @ pose0.astype(np.float64)
-    return pose_0to1.astype(np.float32)
+    return pose_0to1.astype(np.float32)
+
+
+# a quick inline tee class to log stdout to file
+import sys
+import re
+from datetime import datetime
+class InlineTee:
+    def __init__(self, filepath, append=False, timestamp_per_line=False):
+        mode = "a" if append else "w"
+        self.file = open(filepath, mode)
+        self.stdout = sys.stdout
+        self.newline = True
+        self.timestamp_per_line = timestamp_per_line
+        self.first_write = True
+        self.ansi_pattern = re.compile(r'\x1b\[[0-9;]*m')
+        
+        # write header timestamp
+        if not self.timestamp_per_line:
+            self.file.write(f"=== Log started at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} ===\n\n")
+
+    def write(self, data):
+        self.stdout.write(data)
+        
+        clean_data = self.ansi_pattern.sub('', data)
+        
+        if self.timestamp_per_line and clean_data.strip():
+            lines = clean_data.split('\n')
+            for i, line in enumerate(lines):
+                if line and self.newline:
+                    timestamp = datetime.now().strftime("[%Y-%m-%d %H:%M:%S] ")
+                    self.file.write(timestamp + line)
+                else:
+                    self.file.write(line)
+                if i < len(lines) - 1:
+                    self.file.write('\n')
+                    self.newline = True
+                else:
+                    self.newline = line == ''
+        else:
+            self.file.write(clean_data)
+
+    def flush(self):
+        self.file.flush()
+        self.stdout.flush()