[Add] logging & logs directory

Author: drawcodeboy

logs/.gitignore

@@ -0,0 +1 @@
+*.log

test.py

@@ -1,7 +1,7 @@
 import torch
 
 import argparse
-import time, sys, os, yaml
+import time, sys, os, yaml, logging
 
 from utils import evaluate
 from models import load_model
@@ -13,16 +13,36 @@ def add_args_parser():
 
     return parser
 
+def get_logger(expr_name):
+    logger = logging.getLogger('test')
+    logger.setLevel(logging.INFO)
+    
+    formatter = logging.Formatter(
+        "%(asctime)s | %(levelname)s | %(message)s"
+    )
+
+    file_h = logging.FileHandler(f"logs/{expr_name}.log", mode='w')
+    file_h.setLevel(logging.INFO)
+    file_h.setFormatter(formatter)
+    logger.addHandler(file_h)
+
+    console_h = logging.StreamHandler()
+    console_h.setLevel(logging.INFO)
+    logger.addHandler(console_h)
+
+    return logger
+
 def main(cfg):
-    print(f"=====================[{cfg['expr']}]=====================")
+    logger = get_logger(cfg['expr'])
+    logger.info(f"=====================[{cfg['expr']}]=====================")
 
     # Device Setting
     device = None
     if cfg['device'] != 'cpu' and torch.cuda.is_available():
         device = cfg['device']
     else: 
         device = 'cpu'
-    print(f"device: {device}")
+    logger.info(f"device: {device}")
 
     # Hyperparameter Settings
     hp_cfg = cfg['hyperparameters']
@@ -32,7 +52,7 @@ def main(cfg):
     test_ds = load_dataset(data_cfg)
     test_dl = torch.utils.data.DataLoader(test_ds,
                                           batch_size=hp_cfg['batch_size'])
-    print(f"Load Dataset {data_cfg['dataset']}")
+    logger.info(f"Load Dataset {data_cfg['dataset']}")
 
     # Load Model
     save_cfg = cfg['save']
@@ -45,10 +65,10 @@ def main(cfg):
     start_time = int(time.time())
     result = evaluate(model, test_dl, device)
     test_time = int(time.time() - start_time)
-    print(f"Test Time: {test_time//60:02d}m {test_time%60:02d}s")
+    logger.info(f"Test Time: {test_time//60:02d}m {test_time%60:02d}s")
 
     for key, value in result.items():
-        print(f"{key}: {value:.4f}")
+        logger.info(f"{key}: {value:.4f}")
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser('Test', parents=[add_args_parser()])

train.py

@@ -6,24 +6,44 @@
 import torch
 from torch import nn, optim
 from torch.utils.data import DataLoader
-import argparse, time, os, sys, yaml
+import argparse, time, os, sys, yaml, logging
 
 def add_args_parser():
     parser = argparse.ArgumentParser(add_help=False)
     parser.add_argument('--config', type=str)
 
     return parser
+
+def get_logger(expr_name):
+    logger = logging.getLogger('train')
+    logger.setLevel(logging.INFO)
+    
+    formatter = logging.Formatter(
+        "%(asctime)s | %(levelname)s | %(message)s"
+    )
+
+    file_h = logging.FileHandler(f"logs/{expr_name}.log", mode='w')
+    file_h.setLevel(logging.INFO)
+    file_h.setFormatter(formatter)
+    logger.addHandler(file_h)
+
+    console_h = logging.StreamHandler()
+    console_h.setLevel(logging.INFO)
+    logger.addHandler(console_h)
+
+    return logger
 
 def main(cfg):
-    print(f"=====================[{cfg['expr']}]=====================")
+    logger = get_logger(cfg['expr'])
+    logger.info(f"=====================[{cfg['expr']}]=====================")
 
     # Device Setting
     device = None
     if cfg['device'] != 'cpu' and torch.cuda.is_available():
         device = cfg['device']
     else: 
         device = 'cpu'
-    print(f"device: {device}")
+    logger.info(f"device: {device}")
 
     # Hyperparameter Settings
     hp_cfg = cfg['hyperparameters']
@@ -35,11 +55,11 @@ def main(cfg):
                                            shuffle=True,
                                            batch_size=hp_cfg['batch_size'],
                                            drop_last=True)
-    print(f"Load Dataset {data_cfg['dataset']}")
+    logger.info(f"Load Dataset {data_cfg['dataset']}")
 
     # Load Model
     model_cfg = cfg['model']
-    print(model_cfg['name'])
+    logger.info(model_cfg['name'])
     model = load_model(model_cfg).to(device)
     if cfg['parallel'] == True:
         model = nn.DataParallel(model)
@@ -73,24 +93,24 @@ def main(cfg):
     min_loss = 1e4
 
     for current_epoch in range(1, hp_cfg['epochs']+1):
-        print("=======================================================")
-        print(f"Epoch: [{current_epoch:03d}/{hp_cfg['epochs']:03d}]\n")
+        logger.info("=======================================================")
+        logger.info(f"Epoch: [{current_epoch:03d}/{hp_cfg['epochs']:03d}]\n")
 
         # Training One Epoch
         start_time = int(time.time())
-        train_loss = train_one_epoch(model, train_dl, loss_fn, optimizer, scheduler, device)
+        train_loss = train_one_epoch(model, train_dl, loss_fn, optimizer, scheduler, device, logger)
         elapsed_time = int(time.time() - start_time)
-        print(f"Train Time: {elapsed_time//60:02d}m {elapsed_time%60:02d}s\n")
+        logger.info(f"Train Time: {elapsed_time//60:02d}m {elapsed_time%60:02d}s")
 
         if train_loss < min_loss:
             min_loss = train_loss
-            save_model_ckpt(model, save_cfg['name'], current_epoch, save_cfg['weights_path'])
+            save_model_ckpt(model, save_cfg['name'], current_epoch, save_cfg['weights_path'], logger)
 
         total_train_loss.append(train_loss)
-        save_loss_ckpt(save_cfg['name'], total_train_loss, save_cfg['loss_path'])
+        save_loss_ckpt(save_cfg['name'], total_train_loss, save_cfg['loss_path'], logger)
 
     total_elapsed_time = int(time.time()) - total_start_time
-    print(f"<Total Train Time: {total_elapsed_time//60:02d}m {total_elapsed_time%60:02d}s>")
+    logger.info(f"<Total Train Time: {total_elapsed_time//60:02d}m {total_elapsed_time%60:02d}s>")
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser('Training', parents=[add_args_parser()])

utils/engine.py

@@ -5,7 +5,7 @@
 
 from .metrics import get_metrics
 
-def train_one_epoch(model, dataloader, loss_fn, optimizer, scheduler, device):
+def train_one_epoch(model, dataloader, loss_fn, optimizer, scheduler, device, logger):
     model.train()
     total_loss = []
 
@@ -23,10 +23,12 @@ def train_one_epoch(model, dataloader, loss_fn, optimizer, scheduler, device):
         loss.backward()
         optimizer.step()
 
+        # Only stream (not log, because logging don't support the carriage return.)
         print(f"\rTraining: {100*batch_idx/len(dataloader):.2f}%, Loss: {sum(total_loss)/len(total_loss):.6f}, LR: {scheduler.get_last_lr()[0]:.6f}", end="")
     print()
 
     scheduler.step(sum(total_loss)/len(total_loss))
+    logger.info(f"Loss: {sum(total_loss)/len(total_loss):.6f}, LR: {scheduler.get_last_lr()[0]:.6f}")
 
     return sum(total_loss)/len(total_loss)
 
@@ -48,6 +50,7 @@ def evaluate(model, dataloader, device):
         total_outputs.extend(out.tolist())
         total_targets.extend(target.tolist())
 
+        # Only stream (not log, because logging don't support the carriage return.)
         print(f"\rEvaluate: {100*batch_idx/len(dataloader):.2f}%", end="")
     print()
 

utils/save_ckpt.py

@@ -2,7 +2,7 @@
 import numpy as np
 import os
 
-def save_model_ckpt(model, model_name, current_epoch, save_dir):
+def save_model_ckpt(model, model_name, current_epoch, save_dir, logger):
     ckpt = {}
     ckpt['model'] = model.state_dict()
     ckpt['epochs'] = current_epoch
@@ -11,13 +11,13 @@ def save_model_ckpt(model, model_name, current_epoch, save_dir):
 
     try:
         torch.save(ckpt, os.path.join(save_dir, save_name))
-        print(f"Save Model @epoch: {current_epoch}")
+        logger.info(f"Save Model @epoch: {current_epoch}")
     except:
-        print(f"Can\'t Save Model @epoch: {current_epoch}")
+        logger.info(f"Can\'t Save Model @epoch: {current_epoch}")
 
-def save_loss_ckpt(model_name, train_loss, save_dir):
+def save_loss_ckpt(model_name, train_loss, save_dir, logger):
     try:
         np.save(os.path.join(save_dir, f'train_loss_{model_name}.npy'), np.array(train_loss))
-        print('Save Train Loss')
+        logger.info('Save Train Loss')
     except:
-        print('Can\'t Save Train Loss') 
+        logger.info('Can\'t Save Train Loss')