1_python/3a_evaluate_CNN.py

# -*- coding: utf-8 -*-
# Document info
__author__ = 'Andreas Sjölander, Gemini'
__version__ = ['1.0']
__version_date__ = '2025-11-25'
__maintainer__ = 'Andreas Sjölander'
__email__ = 'asjola@kth.se'

"""
3_evaluate_CNN.py
This script loads a pre-trained model and evaluate its performance on a list 
of datasets. The output is a .txt file with metrics. Naming of the file is based on
the SESSION_NAME and metrics for each eavluation is added in the txt file in
sequence, i.e. the metrics for all evaluation using the same model is stored in
the same file.
"""

import os
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from tqdm import tqdm
from PIL import Image
from fastai.vision.all import *
from fastai.losses import CrossEntropyLossFlat
from datetime import datetime  

# --- CONFIGURATION ---
SESSION_NAME = "TA+TC" 
TEST_CSVS  = ['TB_train.csv', 'TB_val.csv'] 

BASE_DIR = os.getcwd()
DATA_ROOT_DIR = os.path.abspath(os.path.join(BASE_DIR, '../')) 
CSV_SOURCE_DIR = os.path.join(DATA_ROOT_DIR, '2_model_input/') 
ORIGINAL_MASK_DIR = os.path.join(DATA_ROOT_DIR, '3_mask')
SANITIZED_MASK_DIR = os.path.join(DATA_ROOT_DIR, '3_masks_sanitized')

OUTPUT_ROOT = os.path.join(DATA_ROOT_DIR, '5_model_output')
SESSION_DIR = os.path.join(OUTPUT_ROOT, SESSION_NAME)
TRAIN_MODEL_DIR = os.path.join(SESSION_DIR, 'Training', 'Models')
MODEL_WEIGHTS_PATH = os.path.join(TRAIN_MODEL_DIR, 'best_model.pth')

TEST_DIR = os.path.join(OUTPUT_ROOT, 'Testing')


# --- MODEL SETTINGS ---
ORIGINAL_CLASS_PIXEL_VALUE = 40 
SANITIZED_VALUE = 1               
MODEL_ARCH = resnet34
BATCH_SIZE = 8
CRACK_CLASS_WEIGHT = 20.0 

# --- DEFINITIONS (REQUIRED FOR LOADING) ---
def get_expected_mask_basename(image_basename):
    parts = image_basename.rsplit('_', 1)
    if len(parts) == 2:
        base_name, tile_id = parts
        return f"{base_name}_fuse_{tile_id}_1band"
    return image_basename

def _get_stats(inp, targ, class_idx=1, smooth=1e-6):
    pred = inp.argmax(dim=1)
    targ = targ.squeeze(1)
    tp = ((pred == class_idx) & (targ == class_idx)).sum().float()
    fp = ((pred == class_idx) & (targ != class_idx)).sum().float()
    fn = ((pred != class_idx) & (targ == class_idx)).sum().float()
    tn = ((pred != class_idx) & (targ != class_idx)).sum().float()
    return tp, fp, fn, tn, smooth

def iou_crack(inp, targ):
    tp, fp, fn, _, smooth = _get_stats(inp, targ)
    return (tp + smooth) / (tp + fp + fn + smooth)

def dice_score_crack(inp, targ):
    tp, fp, fn, _, smooth = _get_stats(inp, targ)
    return (2 * tp + smooth) / (2 * tp + fp + fn + smooth)

def recall_crack(inp, targ):
    tp, _, fn, _, smooth = _get_stats(inp, targ)
    return (tp + smooth) / (tp + fn + smooth)

def precision_crack(inp, targ):
    tp, fp, _, _, smooth = _get_stats(inp, targ)
    return (tp + smooth) / (tp + fp + smooth)

def f1_score_crack(inp, targ):
    tp, fp, fn, _, smooth = _get_stats(inp, targ)
    precision = (tp + smooth) / (tp + fp + smooth)
    recall = (tp + smooth) / (tp + fn + smooth)
    return 2 * (precision * recall) / (precision + recall + smooth)

class WeightedCombinedLoss(nn.Module):
    def __init__(self, crack_weight=CRACK_CLASS_WEIGHT, dice_weight=0.5, ce_weight=0.5):
        super().__init__()
        self.dice_weight, self.ce_weight = dice_weight, ce_weight
        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        class_weights = torch.tensor([1.0, crack_weight]).to(device)
        self.ce = CrossEntropyLossFlat(axis=1, weight=class_weights)
        self.dice = DiceLoss(axis=1) 
    def forward(self, inp, targ):
        ce_loss = self.ce(inp, targ.long())
        dice_loss = self.dice(inp, targ) 
        return (self.ce_weight * ce_loss) + (self.dice_weight * dice_loss)

# --- DATA HELPERS ---
def sanitize_dataframe(df):
    os.makedirs(SANITIZED_MASK_DIR, exist_ok=True)
    new_mask_paths = []
    image_abs_paths = []
    valid_indices = []
    for idx, row in tqdm(df.iterrows(), total=len(df), desc="Sanitizing"):
        try:
            rel_path = row['filename']
            abs_img_path = os.path.normpath(os.path.join(BASE_DIR, rel_path))
            img_basename = os.path.splitext(os.path.basename(abs_img_path))[0]
            mask_basename_no_ext = get_expected_mask_basename(img_basename)
            mask_filename = f"{mask_basename_no_ext}.png"
            raw_mask_path = os.path.join(ORIGINAL_MASK_DIR, mask_filename)
            clean_mask_path = os.path.join(SANITIZED_MASK_DIR, mask_filename)

            if os.path.exists(clean_mask_path):
                image_abs_paths.append(abs_img_path); new_mask_paths.append(clean_mask_path); valid_indices.append(idx)
                continue
            if os.path.exists(raw_mask_path):
                target_class = row.get('target', 0)
                mask_arr = np.array(Image.open(raw_mask_path))
                if target_class == 1:
                    new_mask = np.zeros_like(mask_arr, dtype=np.uint8)
                    new_mask[mask_arr == ORIGINAL_CLASS_PIXEL_VALUE] = SANITIZED_VALUE
                    Image.fromarray(new_mask).save(clean_mask_path)
                else:
                    Image.fromarray(np.zeros_like(mask_arr, dtype=np.uint8)).save(clean_mask_path)
                image_abs_paths.append(abs_img_path); new_mask_paths.append(clean_mask_path); valid_indices.append(idx)
        except: pass
    clean_df = df.iloc[valid_indices].copy()
    clean_df['image_abs_path'] = image_abs_paths
    clean_df['mask_path_sanitized'] = new_mask_paths
    return clean_df

def combine_csvs(csv_list):
    dfs = []
    for f in csv_list:
        path = os.path.join(CSV_SOURCE_DIR, f)
        if os.path.exists(path): dfs.append(pd.read_csv(path))
    return pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()

def get_metric_label(m):
    if hasattr(m, 'name'): return m.name
    if hasattr(m, 'func') and hasattr(m.func, '__name__'): return m.func.__name__
    return str(m)

# --- MAIN ---
def run():
    os.makedirs(TEST_DIR, exist_ok=True)
    print(f"--- 🧪 Evaluation Session: {SESSION_NAME} ---")

    # 1. Data
    df_test = sanitize_dataframe(combine_csvs(TEST_CSVS))
    if len(df_test) == 0: return print("❌ No test data found.")
    
    # 2. Setup Learner
    codes = np.array(['background', 'crack'])
    dblock = DataBlock(blocks=(ImageBlock, MaskBlock(codes)),
                       get_x=ColReader('image_abs_path'), get_y=ColReader('mask_path_sanitized'),
                       batch_tfms=[Normalize.from_stats(*imagenet_stats)])
    dls = dblock.dataloaders(df_test, bs=BATCH_SIZE, num_workers=0) # Windows Fix

    print("🔄 Reconstructing Model...")
    learn = unet_learner(dls, MODEL_ARCH, loss_func=WeightedCombinedLoss(),
                         metrics=[dice_score_crack, iou_crack, recall_crack, precision_crack, f1_score_crack],
                         model_dir=TRAIN_MODEL_DIR)
    
    # 3. Load & Eval
    print(f"📂 Loading: {MODEL_WEIGHTS_PATH}")
    learn.load('best_model')
    
    print("📉 Running Validation...")
    results = learn.validate(dl=dls.test_dl(df_test, with_labels=True))
    
    metric_labels = ['valid_loss'] + [get_metric_label(m) for m in learn.metrics]
    print("\n📊 RESULTS:")
    
    output_path = os.path.join(TEST_DIR, SESSION_NAME+'_testing_score.txt')
    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    with open(output_path, 'a') as f:
        # Header for this specific run
        f.write(f"\n{'='*40}\n")
        f.write(f"Date: {current_time}\n")
        f.write(f"Model Name: {SESSION_NAME}\n")
        f.write(f"Test CSVs: {', '.join(TEST_CSVS)}\n")
        f.write(f"{'-'*40}\n")
        
        for name, val in zip(metric_labels, results):
            print(f"{name:<25}: {val:.6f}")
            f.write(f"{name:<25}: {val:.6f}\n")
            
    print(f"📝 Results appended to: {output_path}")


if __name__ == "__main__":
    if torch.cuda.is_available(): torch.cuda.empty_cache()
    run()