♻️ [Refactor] os.path -> pathlib Path, more safely

yolo/config/task/inference.yaml

@@ -1,6 +1,6 @@
 task: inference
 
-fast_inference:  # onnx, trt or Empty
+fast_inference:  # onnx, trt, deploy or Empty
 data:
   source: demo/images/inference/image.png
   image_size: ${image_size}

yolo/model/yolo.py

@@ -1,5 +1,5 @@
-import os
-from typing import Dict, List, Optional, Union
+from pathlib import Path
+from typing import Dict, List, Union
 
 import torch
 from loguru import logger
@@ -116,7 +116,7 @@ class YOLO(nn.Module):
             raise ValueError(f"Unsupported layer type: {layer_type}")
 
 
-def create_model(model_cfg: ModelConfig, weight_path: Union[bool, str] = True, class_num: int = 80) -> YOLO:
+def create_model(model_cfg: ModelConfig, weight_path: Union[bool, Path] = True, class_num: int = 80) -> YOLO:
     """Constructs and returns a model from a Dictionary configuration file.
 
     Args:
@@ -129,11 +129,11 @@ def create_model(model_cfg: ModelConfig, weight_path: Union[bool, str] = True, c
     model = YOLO(model_cfg, class_num)
     if weight_path:
         if weight_path == True:
-            weight_path = os.path.join("weights", f"{model_cfg.name}.pt")
-        if not os.path.exists(weight_path):
+            weight_path = Path("weights") / f"{model_cfg.name}.pt"
+        if not weight_path.exists():
             logger.info(f"🌐 Weight {weight_path} not found, try downloading")
             prepare_weight(weight_path=weight_path)
-        if os.path.exists(weight_path):
+        if weight_path.exists():
             model.model.load_state_dict(torch.load(weight_path, map_location=torch.device("cpu")), strict=False)
             logger.info("✅ Success load model & weight")
     else:

yolo/tools/data_conversion.py

@@ -1,5 +1,5 @@
 import json
-import os
+from pathlib import Path
 from typing import Dict, List, Optional
 
 from tqdm import tqdm
@@ -17,14 +17,14 @@ def discretize_categories(categories: List[Dict[str, int]]) -> Dict[int, int]:
 def process_annotations(
     image_annotations: Dict[int, List[Dict]],
     image_info_dict: Dict[int, tuple],
-    output_dir: str,
+    output_dir: Path,
     id_to_idx: Optional[Dict[int, int]] = None,
 ) -> None:
     """
     Process and save annotations to files, with option to remap category IDs.
     """
     for image_id, annotations in tqdm(image_annotations.items(), desc="Processing annotations"):
-        file_path = os.path.join(output_dir, f"{image_id:0>12}.txt")
+        file_path = output_dir / "{image_id:0>12}.txt"
         if not annotations:
             continue
         with open(file_path, "w") as file:
@@ -73,7 +73,7 @@ def convert_annotations(json_file: str, output_dir: str) -> None:
     with open(json_file) as file:
         data = json.load(file)
 
-    os.makedirs(output_dir, exist_ok=True)
+    Path(output_dir).mkdir(exist_ok=True)
 
     image_info_dict = {img["id"]: (img["width"], img["height"]) for img in data.get("images", [])}
     id_to_idx = discretize_categories(data.get("categories", [])) if "categories" in data else None

yolo/tools/data_loader.py

@@ -1,5 +1,4 @@
-import os
-from os import path
+from pathlib import Path
 from queue import Empty, Queue
 from threading import Event, Thread
 from typing import Generator, List, Tuple, Union
@@ -39,22 +38,22 @@ class YoloDataset(Dataset):
         transforms = [eval(aug)(prob) for aug, prob in augment_cfg.items()]
         self.transform = AugmentationComposer(transforms, self.image_size)
         self.transform.get_more_data = self.get_more_data
-        self.data = self.load_data(dataset_cfg.path, phase_name)
+        self.data = self.load_data(Path(dataset_cfg.path), phase_name)
 
-    def load_data(self, dataset_path, phase_name):
+    def load_data(self, dataset_path: Path, phase_name: str):
         """
         Loads data from a cache or generates a new cache for a specific dataset phase.
 
         Parameters:
-            dataset_path (str): The root path to the dataset directory.
+            dataset_path (Path): The root path to the dataset directory.
             phase_name (str): The specific phase of the dataset (e.g., 'train', 'test') to load or generate data for.
 
         Returns:
             dict: The loaded data from the cache for the specified phase.
         """
-        cache_path = path.join(dataset_path, f"{phase_name}.cache")
+        cache_path = dataset_path / f"{phase_name}.cache"
 
-        if not path.isfile(cache_path):
+        if not cache_path.exists():
             logger.info("🏭 Generating {} cache", phase_name)
             data = self.filter_data(dataset_path, phase_name)
             torch.save(data, cache_path)
@@ -63,20 +62,20 @@ class YoloDataset(Dataset):
             logger.info("📦 Loaded {} cache", phase_name)
         return data
 
-    def filter_data(self, dataset_path: str, phase_name: str) -> list:
+    def filter_data(self, dataset_path: Path, phase_name: str) -> list:
         """
         Filters and collects dataset information by pairing images with their corresponding labels.
 
         Parameters:
-            images_path (str): Path to the directory containing image files.
+            images_path (Path): Path to the directory containing image files.
             labels_path (str): Path to the directory containing label files.
 
         Returns:
             list: A list of tuples, each containing the path to an image file and its associated segmentation as a tensor.
         """
-        images_path = path.join(dataset_path, "images", phase_name)
+        images_path = dataset_path / "images" / phase_name
         labels_path, data_type = locate_label_paths(dataset_path, phase_name)
-        images_list = sorted(os.listdir(images_path))
+        images_list = sorted([p.name for p in Path(images_path).iterdir() if p.is_file()])
         if data_type == "json":
             annotations_index, image_info_dict = create_image_metadata(labels_path)
 
@@ -85,7 +84,7 @@ class YoloDataset(Dataset):
         for image_name in track(images_list, description="Filtering data"):
             if not image_name.lower().endswith((".jpg", ".jpeg", ".png")):
                 continue
-            image_id, _ = path.splitext(image_name)
+            image_id = Path(image_name).stem
 
             if data_type == "json":
                 image_info = image_info_dict.get(image_id, None)
@@ -97,8 +96,8 @@ class YoloDataset(Dataset):
                     continue
 
             elif data_type == "txt":
-                label_path = path.join(labels_path, f"{image_id}.txt")
-                if not path.isfile(label_path):
+                label_path = labels_path / f"{image_id}.txt"
+                if not label_path.is_file():
                     continue
                 with open(label_path, "r") as file:
                     image_seg_annotations = [list(map(float, line.strip().split())) for line in file]
@@ -107,13 +106,13 @@ class YoloDataset(Dataset):
 
             labels = self.load_valid_labels(image_id, image_seg_annotations)
 
-            img_path = path.join(images_path, image_name)
+            img_path = images_path / image_name
             data.append((img_path, labels))
             valid_inputs += 1
         logger.info("Recorded {}/{} valid inputs", valid_inputs, len(images_list))
         return data
 
-    def load_valid_labels(self, label_path, seg_data_one_img) -> Union[torch.Tensor, None]:
+    def load_valid_labels(self, label_path: str, seg_data_one_img: list) -> Union[torch.Tensor, None]:
         """
         Loads and validates bounding box data is [0, 1] from a label file.
 
@@ -215,9 +214,9 @@ def create_dataloader(data_cfg: DataConfig, dataset_cfg: DatasetConfig, task: st
 
 class StreamDataLoader:
     def __init__(self, data_cfg: DataConfig):
-        self.source = data_cfg.source
+        self.source = Path(data_cfg.source)
         self.running = True
-        self.is_stream = isinstance(self.source, int) or self.source.lower().startswith("rtmp://")
+        self.is_stream = isinstance(self.source, int) or str(self.source).lower().startswith("rtmp://")
 
         self.transform = AugmentationComposer([], data_cfg.image_size)
         self.stop_event = Event()
@@ -230,20 +229,20 @@ class StreamDataLoader:
             self.thread.start()
 
     def load_source(self):
-        if os.path.isdir(self.source):  # image folder
+        if self.source.is_dir():  # image folder
             self.load_image_folder(self.source)
-        elif any(self.source.lower().endswith(ext) for ext in [".mp4", ".avi", ".mkv"]):  # Video file
+        elif any(self.source.suffix.lower().endswith(ext) for ext in [".mp4", ".avi", ".mkv"]):  # Video file
             self.load_video_file(self.source)
         else:  # Single image
             self.process_image(self.source)
 
     def load_image_folder(self, folder):
-        for root, _, files in os.walk(folder):
-            for file in files:
-                if self.stop_event.is_set():
-                    break
-                if any(file.lower().endswith(ext) for ext in [".jpg", ".jpeg", ".png", ".bmp"]):
-                    self.process_image(os.path.join(root, file))
+        folder_path = Path(folder)
+        for file_path in folder_path.rglob("*"):
+            if self.stop_event.is_set():
+                break
+            if file_path.suffix.lower() in [".jpg", ".jpeg", ".png", ".bmp"]:
+                self.process_image(file_path)
 
     def process_image(self, image_path):
         image = Image.open(image_path).convert("RGB")

yolo/tools/dataset_preparation.py

@@ -1,5 +1,5 @@
-import os
 import zipfile
+from pathlib import Path
 from typing import Optional
 
 import requests
@@ -9,7 +9,7 @@ from rich.progress import BarColumn, Progress, TextColumn, TimeRemainingColumn
 from yolo.config.config import DatasetConfig
 
 
-def download_file(url, destination):
+def download_file(url, destination: Path):
     """
     Downloads a file from the specified URL to the destination path with progress logging.
     """
@@ -25,7 +25,7 @@ def download_file(url, destination):
             "•",
             TimeRemainingColumn(),
         ) as progress:
-            task = progress.add_task(f"📥 Downloading {os.path.basename(destination)}...", total=total_size)
+            task = progress.add_task(f"📥 Downloading {destination.name }...", total=total_size)
             with open(destination, "wb") as file:
                 for data in response.iter_content(chunk_size=1024 * 1024):  # 1 MB chunks
                     file.write(data)
@@ -33,14 +33,14 @@ def download_file(url, destination):
     logger.info("✅ Download completed.")
 
 
-def unzip_file(source, destination):
+def unzip_file(source: Path, destination: Path):
     """
     Extracts a ZIP file to the specified directory and removes the ZIP file after extraction.
     """
-    logger.info(f"Unzipping {os.path.basename(source)}...")
+    logger.info(f"Unzipping {source.name}...")
     with zipfile.ZipFile(source, "r") as zip_ref:
         zip_ref.extractall(destination)
-    os.remove(source)
+    source.unlink()
     logger.info(f"Removed {source}.")
 
 
@@ -48,7 +48,7 @@ def check_files(directory, expected_count=None):
     """
     Returns True if the number of files in the directory matches expected_count, False otherwise.
     """
-    files = [f for f in os.listdir(directory) if os.path.isfile(os.path.join(directory, f))]
+    files = [f.name for f in Path(directory).iterdir() if f.is_file()]
     return len(files) == expected_count if expected_count is not None else bool(files)
 
 
@@ -57,7 +57,7 @@ def prepare_dataset(dataset_cfg: DatasetConfig, task: str):
     Prepares dataset by downloading and unzipping if necessary.
     """
     # TODO: do EDA of dataset
-    data_dir = dataset_cfg.path
+    data_dir = Path(dataset_cfg.path)
     for data_type, settings in dataset_cfg.auto_download.items():
         base_url = settings["base_url"]
         for dataset_type, dataset_args in settings.items():
@@ -65,16 +65,16 @@ def prepare_dataset(dataset_cfg: DatasetConfig, task: str):
                 continue
             file_name = f"{dataset_args.get('file_name', dataset_type)}.zip"
             url = f"{base_url}{file_name}"
-            local_zip_path = os.path.join(data_dir, file_name)
-            extract_to = os.path.join(data_dir, data_type) if data_type != "annotations" else data_dir
-            final_place = os.path.join(extract_to, dataset_type)
+            local_zip_path = data_dir / file_name
+            extract_to = data_dir / data_type if data_type != "annotations" else data_dir
+            final_place = extract_to / dataset_type
 
-            os.makedirs(final_place, exist_ok=True)
+            final_place.mkdir(exist_ok=True)
             if check_files(final_place, dataset_args.get("file_num")):
                 logger.info(f"✅ Dataset {dataset_type: <12} already verified.")
                 continue
 
-            if not os.path.exists(local_zip_path):
+            if not local_zip_path.exists():
                 download_file(url, local_zip_path)
             unzip_file(local_zip_path, extract_to)
 
@@ -82,16 +82,16 @@ def prepare_dataset(dataset_cfg: DatasetConfig, task: str):
                 logger.error(f"Error verifying the {dataset_type} dataset after extraction.")
 
 
-def prepare_weight(download_link: Optional[str] = None, weight_path: str = "v9-c.pt"):
-    weight_name = os.path.basename(weight_path)
+def prepare_weight(download_link: Optional[str] = None, weight_path: Path = "v9-c.pt"):
+    weight_name = weight_path.name
     if download_link is None:
         download_link = "https://github.com/WongKinYiu/yolov9mit/releases/download/v1.0-alpha/"
     weight_link = f"{download_link}{weight_name}"
 
-    if not os.path.isdir(os.path.dirname(weight_path)):
-        os.makedirs(os.path.dirname(weight_path))
+    if not weight_path.parent.is_dir():
+        weight_path.parent.mkdir(parents=True, exist_ok=True)
 
-    if os.path.exists(weight_path):
+    if weight_path.exists():
         logger.info(f"Weight file '{weight_path}' already exists.")
     try:
         download_file(weight_link, weight_path)

yolo/tools/drawer.py

@@ -1,4 +1,3 @@
-import os
 import random
 from typing import List, Optional, Union
 

yolo/tools/solver.py

@@ -1,6 +1,7 @@
+import contextlib
+import io
 import json
 import os
-import sys
 import time
 from collections import defaultdict
 from typing import Dict, Optional
@@ -46,7 +47,8 @@ class ModelTrainer:
         self.num_epochs = cfg.task.epoch
         self.mAPs_dict = defaultdict(list)
 
-        os.makedirs(os.path.join(self.progress.save_path, "weights"), exist_ok=True)
+        self.weights_dir = self.progress.save_path / "weights"
+        self.weights_dir.mkdir(exist_ok=True)
 
         if not progress.quite_mode:
             log_model_structure(model.model)
@@ -102,7 +104,7 @@ class ModelTrainer:
 
     def save_checkpoint(self, epoch_idx: int, file_name: Optional[str] = None):
         file_name = file_name or f"E{epoch_idx:03d}.pt"
-        file_path = os.path.join(self.progress.save_path, "weights", file_name)
+        file_path = self.weights_dir / file_name
 
         checkpoint = {
             "epoch": epoch_idx,
@@ -152,7 +154,7 @@ class ModelTester:
         self.progress = progress
 
         self.post_proccess = PostProccess(vec2box, cfg.task.nms)
-        self.save_path = os.path.join(progress.save_path, "images")
+        self.save_path = progress.save_path / "images"
         os.makedirs(self.save_path, exist_ok=True)
         self.save_predict = getattr(cfg.task, "save_predict", None)
         self.idx2label = cfg.class_list
@@ -187,7 +189,7 @@ class ModelTester:
                     if not self.save_predict:
                         continue
                 if self.save_predict != False:
-                    save_image_path = os.path.join(self.save_path, f"frame{idx:03d}.png")
+                    save_image_path = self.save_path / f"frame{idx:03d}.png"
                     img.save(save_image_path)
                     logger.info(f"💾 Saved visualize image at {save_image_path}")
 
@@ -215,12 +217,11 @@ class ModelValidator:
         self.progress = progress
 
         self.post_proccess = PostProccess(vec2box, validation_cfg.nms)
-        self.json_path = os.path.join(self.progress.save_path, f"predict.json")
+        self.json_path = self.progress.save_path / "predict.json"
 
-        sys.stdout = open(os.devnull, "w")
-        # TODO: load with config file
-        self.coco_gt = COCO("data/coco/annotations/instances_val2017.json")
-        sys.stdout = sys.__stdout__
+        with contextlib.redirect_stdout(io.StringIO()):
+            # TODO: load with config file
+            self.coco_gt = COCO("data/coco/annotations/instances_val2017.json")
 
     def solve(self, dataloader, epoch_idx=-1):
         # logger.info("🧪 Start Validation!")

yolo/utils/bounding_box_utils.py

@@ -1,5 +1,5 @@
 import math
-from typing import List, Tuple
+from typing import Dict, List, Tuple
 
 import torch
 import torch.nn.functional as F
@@ -333,7 +333,7 @@ def bbox_nms(cls_dist: Tensor, bbox: Tensor, nms_cfg: NMSConfig):
     return predicts_nms
 
 
-def calculate_map(predictions, ground_truths, iou_thresholds=arange(0.5, 1, 0.05)):
+def calculate_map(predictions, ground_truths, iou_thresholds=arange(0.5, 1, 0.05)) -> Dict[str, Tensor]:
     # TODO: Refactor this block, Flexible for calculate different mAP condition?
     device = predictions.device
     n_preds = predictions.size(0)
@@ -375,5 +375,8 @@ def calculate_map(predictions, ground_truths, iou_thresholds=arange(0.5, 1, 0.05
 
         aps.append(ap)
 
-    mean_ap = torch.mean(torch.stack(aps))
-    return mean_ap, aps[0]
+    mAP = {
+        "mAP.5": torch.mean(torch.stack(aps)),
+        "mAP.5:.95": aps[0],
+    }
+    return mAP

yolo/utils/dataset_utils.py

@@ -1,7 +1,7 @@
 import json
 import os
 from itertools import chain
-from os import path
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
@@ -10,25 +10,25 @@ from loguru import logger
 from yolo.tools.data_conversion import discretize_categories
 
 
-def locate_label_paths(dataset_path: str, phase_name: str):
+def locate_label_paths(dataset_path: Path, phase_name: Path) -> Tuple[Path, Path]:
     """
     Find the path to label files for a specified dataset and phase(e.g. training).
 
     Args:
-        dataset_path (str): The path to the root directory of the dataset.
-        phase_name (str): The name of the phase for which labels are being searched (e.g., "train", "val", "test").
+        dataset_path (Path): The path to the root directory of the dataset.
+        phase_name (Path): The name of the phase for which labels are being searched (e.g., "train", "val", "test").
 
     Returns:
-        Tuple[str, str]: A tuple containing the path to the labels file and the file format ("json" or "txt").
+        Tuple[Path, Path]: A tuple containing the path to the labels file and the file format ("json" or "txt").
     """
-    json_labels_path = path.join(dataset_path, "annotations", f"instances_{phase_name}.json")
+    json_labels_path = dataset_path / "annotations" / f"instances_{phase_name}.json"
 
-    txt_labels_path = path.join(dataset_path, "labels", phase_name)
+    txt_labels_path = dataset_path / "labels" / phase_name
 
-    if path.isfile(json_labels_path):
+    if json_labels_path.is_file():
         return json_labels_path, "json"
 
-    elif path.isdir(txt_labels_path):
+    elif txt_labels_path.is_dir():
         txt_files = [f for f in os.listdir(txt_labels_path) if f.endswith(".txt")]
         if txt_files:
             return txt_labels_path, "txt"
@@ -52,7 +52,7 @@ def create_image_metadata(labels_path: str) -> Tuple[Dict[str, List], Dict[str,
         labels_data = json.load(file)
         id_to_idx = discretize_categories(labels_data.get("categories", [])) if "categories" in labels_data else None
         annotations_index = organize_annotations_by_image(labels_data, id_to_idx)  # check lookup is a good name?
-        image_info_dict = {path.splitext(img["file_name"])[0]: img for img in labels_data["images"]}
+        image_info_dict = {Path(img["file_name"]).stem: img for img in labels_data["images"]}
         return annotations_index, image_info_dict
 
 

yolo/utils/deploy_utils.py

@@ -1,4 +1,4 @@
-import os
+from pathlib import Path
 
 import torch
 from loguru import logger
@@ -14,8 +14,8 @@ class FastModelLoader:
         self.compiler = cfg.task.fast_inference
         self._validate_compiler()
         if cfg.weight == True:
-            cfg.weight = os.path.join("weights", f"{cfg.model.name}.pt")
-        self.model_path = f"{os.path.splitext(cfg.weight)[0]}.{self.compiler}"
+            cfg.weight = Path("weights") / f"{cfg.model.name}.pt"
+        self.model_path = f"{Path(cfg.weight).stem}.{self.compiler}"
 
     def _validate_compiler(self):
         if self.compiler not in ["onnx", "trt", "deploy"]:

yolo/utils/logging_utils.py

@@ -14,8 +14,10 @@ Example:
 import os
 import sys
 from collections import deque
+from pathlib import Path
 from typing import Any, Dict, List
 
+import numpy as np
 import wandb
 import wandb.errors.term
 from loguru import logger
@@ -64,6 +66,7 @@ class ProgressLogger(Progress):
         self.ap_table = Table()
         # TODO: load maxlen by config files
         self.ap_past_list = deque(maxlen=5)
+        self.last_result = 0
         super().__init__(*args, *progress_bar, **kwargs)
 
         self.use_wandb = cfg.use_wandb
@@ -121,17 +124,20 @@ class ProgressLogger(Progress):
         self.batch_task = self.add_task("[green]Run pycocotools", total=1)
 
     def finish_pycocotools(self, result, epoch_idx=-1):
-        ap_table, ap_main = make_ap_table(result, self.ap_past_list, epoch_idx)
+        ap_table, ap_main = make_ap_table(result, self.ap_past_list, self.last_result, epoch_idx)
+        self.last_result = np.maximum(result, self.last_result)
         self.ap_past_list.append((epoch_idx, ap_main))
         self.ap_table = ap_table
 
         if self.use_wandb:
-            self.wandb.log({"PyCOCO/AP @ .5:.95": ap_main[1], "PyCOCO/AP @ .5": ap_main[3]})
+            self.wandb.log({"PyCOCO/AP @ .5:.95": ap_main[2], "PyCOCO/AP @ .5": ap_main[5]})
         self.update(self.batch_task, advance=1)
         self.refresh()
         self.remove_task(self.batch_task)
 
     def finish_train(self):
+        self.remove_task(self.task_epoch)
+        self.stop()
         self.wandb.finish()
 
 
@@ -167,23 +173,23 @@ def log_model_structure(model: List[YOLOLayer]):
     console.print(table)
 
 
-def validate_log_directory(cfg: Config, exp_name: str):
-    base_path = os.path.join(cfg.out_path, cfg.task.task)
-    save_path = os.path.join(base_path, exp_name)
+def validate_log_directory(cfg: Config, exp_name: str) -> Path:
+    base_path = Path(cfg.out_path, cfg.task.task)
+    save_path = base_path / exp_name
 
     if not cfg.exist_ok:
         index = 1
         old_exp_name = exp_name
-        while os.path.isdir(save_path):
+        while save_path.is_dir():
             exp_name = f"{old_exp_name}{index}"
-            save_path = os.path.join(base_path, exp_name)
+            save_path = base_path / exp_name
             index += 1
         if index > 1:
             logger.opt(colors=True).warning(
                 f"🔀 Experiment directory exists! Changed <red>{old_exp_name}</> to <green>{exp_name}</>"
             )
 
-    os.makedirs(save_path, exist_ok=True)
+    save_path.mkdir(exist_ok=True)
     logger.opt(colors=True).info(f"📄 Created log folder: <u><fg #808080>{save_path}</></>")
-    logger.add(os.path.join(save_path, "output.log"), mode="w", backtrace=True, diagnose=True)
+    logger.add(save_path / "output.log", mode="w", backtrace=True, diagnose=True)
     return save_path

yolo/utils/solver_utils.py

@@ -1,6 +1,7 @@
 import contextlib
 import io
 
+import numpy as np
 from pycocotools.coco import COCO
 from pycocotools.cocoeval import COCOeval
 from rich.table import Table
@@ -16,7 +17,7 @@ def calculate_ap(coco_gt: COCO, pd_path):
     return coco_eval.stats
 
 
-def make_ap_table(score, past_result=[], epoch=-1):
+def make_ap_table(score, past_result=[], last_score=None, epoch=-1):
     ap_table = Table()
     ap_table.add_column("Epoch", justify="center", style="white", width=5)
     ap_table.add_column("Avg. Precision", justify="left", style="cyan")
@@ -24,22 +25,24 @@ def make_ap_table(score, past_result=[], epoch=-1):
     ap_table.add_column("Avg. Recall", justify="left", style="cyan")
     ap_table.add_column("", justify="right", style="green", width=5)
 
-    for eps, (ap_name1, ap_value1, ap_name2, ap_value2) in past_result:
-        ap_table.add_row(f"{eps: 3d}", ap_name1, f"{ap_value1:.2f}", ap_name2, f"{ap_value2:.2f}")
+    for eps, (ap_name1, ap_color1, ap_value1, ap_name2, ap_color2, ap_value2) in past_result:
+        ap_table.add_row(f"{eps: 3d}", ap_name1, f"{ap_color1}{ap_value1:.2f}", ap_name2, f"{ap_color2}{ap_value2:.2f}")
     if past_result:
         ap_table.add_row()
 
-    this_ap = ("AP @ .5:.95", score[0], "AP @        .5", score[1])
+    color = np.where(last_score <= score, "[green]", "[red]")
+
+    this_ap = ("AP @ .5:.95", color[0], score[0], "AP @        .5", color[1], score[1])
     metrics = [
-        ("AP @ .5:.95", score[0], "AR maxDets   1", score[6]),
-        ("AP @     .5", score[1], "AR maxDets  10", score[7]),
-        ("AP @    .75", score[2], "AR maxDets 100", score[8]),
-        ("AP  (small)", score[3], "AR     (small)", score[9]),
-        ("AP (medium)", score[4], "AR    (medium)", score[10]),
-        ("AP  (large)", score[5], "AR     (large)", score[11]),
+        ("AP @ .5:.95", color[0], score[0], "AR maxDets   1", color[6], score[6]),
+        ("AP @     .5", color[1], score[1], "AR maxDets  10", color[7], score[7]),
+        ("AP @    .75", color[2], score[2], "AR maxDets 100", color[8], score[8]),
+        ("AP  (small)", color[3], score[3], "AR     (small)", color[9], score[9]),
+        ("AP (medium)", color[4], score[4], "AR    (medium)", color[10], score[10]),
+        ("AP  (large)", color[5], score[5], "AR     (large)", color[11], score[11]),
     ]
 
-    for ap_name, ap_value, ar_name, ar_value in metrics:
-        ap_table.add_row(f"{epoch: 3d}", ap_name, f"{ap_value:.2f}", ar_name, f"{ar_value:.2f}")
+    for ap_name, ap_color, ap_value, ar_name, ar_color, ar_value in metrics:
+        ap_table.add_row(f"{epoch: 3d}", ap_name, f"{ap_color}{ap_value:.2f}", ar_name, f"{ar_color}{ar_value:.2f}")
 
     return ap_table, this_ap