Upload 8 files

1_python/0_environment.yml

@@ -0,0 +1,13 @@
+name: TTD
+channels:
+  - defaults
+  - pytorch
+dependencies:
+  - python=3.11
+  - torchvision
+  - pip
+  - pip:
+      - opencv-python
+      - matplotlib
+      - pandas
+      - fastai

1_python/0_read_me.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""
+This file contains a list of python script and their purpuse and status
+"""
+"""
+0_environment.yml
+This file includes a setup of the python environment requried to run the scripts.
+Please note that installation of GPU resources are not added. The model wil 
+automatically try to run the script on the GPU (if installed) and will otherwise
+use the CPU.
+
+"""
+
+"""
+1a_dataset_statistics.py
+This is used to compute statistics of the dataset. 
+1. Calculates Total Pixel Area (Resolution * Image Count).
+2. Calculates "No Defect" (Background) pixel counts.
+3. Calculates Pixel Percentages for all categories.
+4. Maintains the TA, TB, TC split.
+"""
+
+"""
+1b_histogram_plot.py
+This script reads the segmented masks and plots histograms of the defect size 
+distribution. It generates:
+1. Individual plots for all datasets and individual plots for the tunnels 
+TA, TB, TC.
+2. A combined subplot figure comparing TA, TB, and TC.
+
+The user chose which defect that should be plotted.
+"""
+
+
+"""
+1c_create_classification.py
+this scripts reads the csv files that contain information about images with and
+withou cracks. Based on this, three classification datasets are created in the
+folder "3_classification", i.e. TA, TB and TC. Each folder contains the 
+subfolder "crack" and "no_crack"
+"""
+
+"""
+2_train_CNN.py
+
+This script trains a UNet segmentaiton model for a single detection class. 
+The user defines the "Session_Name" which is the output folder for the saved 
+model, plots and metrics. 
+The user use the Global Configuration to adjust parameters. This includdes: 
+ - A weight factor is included for imbalanced datasets.
+- Data used for Traning, Evaluation and Testing is based on csv files.
+ - The script creates masks used for the fastai packaage which use 1 for defect
+ and 0 for background. The user defines the pixel value for the class they want 
+to train the model for. 
+ - Model training parameters are easily adjusted.
+ - Output includes plots of top 5 best and worst predictions of cracks and 
+ txt files with a summary of the metrics
+"""
+
+"""
+2b_plot_training.py
+This script reads the csv output from training and creates a plot of training 
+and validation loss in one plot and IoU and F1-score in a second plot. 
+User only needs to change "TRAINING_DATA" to correct training set.
+"""
+
+"""
+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.
+"""

1_python/1a_dataset_statistics.py

@@ -0,0 +1,244 @@
+# -*- coding: utf-8 -*-
+# Document info
+__author__ = 'Andreas Sjölander, Gemini'
+__version__ = ['1.0']
+__version_date__ = '2025-11-25'
+__maintainer__ = 'Andreas Sjölander'
+__email__ = '[email protected]'
+
+"""
+1a_dataset_statistics.py
+This is used to compute statistics of the dataset. 
+1. Calculates Total Pixel Area (Resolution * Image Count).
+2. Calculates "No Defect" (Background) pixel counts.
+3. Calculates Pixel Percentages for all categories.
+4. Maintains the TA, TB, TC split.
+"""
+
+import os
+import numpy as np
+from PIL import Image
+import csv
+from datetime import datetime
+from tqdm import tqdm
+
+# --- CONFIGURATION ---
+CLASS_MAP = {
+    'Crack': 40,
+    'Water': 160,
+    'Leaching': 200
+}
+
+SUB_DATASETS = ['TA', 'TB', 'TC']
+
+def init_stats_structure():
+    return {
+        'img_count': 0, 
+        'total_pixel_area': 0, # NEW: Tracks total surface area (H*W)
+        'class_counts': {k: 0 for k in CLASS_MAP.keys()},
+        'no_defect_img_count': 0,
+        'pixel_counts': {k: 0 for k in CLASS_MAP.keys()}
+    }
+
+def calculate_dataset_statistics_complete():
+    # --- 1. Setup Paths ---
+    script_location = os.path.dirname(os.path.abspath(__file__))
+    root_dir = os.path.dirname(script_location)
+    
+    mask_folder = os.path.join(root_dir, '3_mask')
+    stats_folder = os.path.join(root_dir, '2_statistics')
+
+    os.makedirs(stats_folder, exist_ok=True)
+
+    if not os.path.exists(mask_folder):
+        print(f"CRITICAL ERROR: Mask folder not found at: {mask_folder}")
+        return
+
+    valid_exts = ('.png', '.jpg', '.jpeg', '.bmp', '.tif', '.tiff')
+    mask_files = [f for f in os.listdir(mask_folder) if f.lower().endswith(valid_exts)]
+    
+    if not mask_files:
+        print("No mask images found.")
+        return
+
+    print(f"Found {len(mask_files)} masks. Calculating Pixel Distributions...")
+    print("-" * 30)
+
+    # --- 2. Initialize Data Structure ---
+    all_stats = {'Total': init_stats_structure()}
+    for ds in SUB_DATASETS:
+        all_stats[ds] = init_stats_structure()
+
+    errors = 0
+
+    # --- 3. Process Images ---
+    try:
+        iterator = tqdm(mask_files, desc="Processing", unit="img")
+    except ImportError:
+        iterator = mask_files
+        print("Processing... (install 'tqdm' for a progress bar)")
+
+    for filename in iterator:
+        file_path = os.path.join(mask_folder, filename)
+        
+        # Identify Sub-Dataset
+        current_sub_ds = None
+        for prefix in SUB_DATASETS:
+            if filename.startswith(prefix):
+                current_sub_ds = prefix
+                break
+        
+        try:
+            with Image.open(file_path) as img:
+                # Ensure grayscale
+                mask_arr = np.array(img.convert('L'))
+
+            # Get image stats
+            img_area = mask_arr.size # Total pixels in this image (H*W)
+            unique_vals, counts = np.unique(mask_arr, return_counts=True)
+            img_pixel_data = dict(zip(unique_vals, counts))
+
+            # --- UPDATE STATISTICS ---
+            targets = ['Total']
+            if current_sub_ds:
+                targets.append(current_sub_ds)
+
+            for target in targets:
+                stats = all_stats[target]
+                stats['img_count'] += 1
+                stats['total_pixel_area'] += img_area # Add this image's area to total
+
+                has_defect = False
+                
+                for class_name, pixel_val in CLASS_MAP.items():
+                    if pixel_val in img_pixel_data:
+                        # Image Count
+                        stats['class_counts'][class_name] += 1
+                        # Pixel Count
+                        stats['pixel_counts'][class_name] += img_pixel_data[pixel_val]
+                        has_defect = True
+                
+                if not has_defect:
+                    stats['no_defect_img_count'] += 1
+
+        except Exception as e:
+            errors += 1
+            # print(f"Error: {e}") 
+
+    # --- 4. Generate Report Paths ---
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    txt_path = os.path.join(stats_folder, f'Dataset_Statistics_Full_{timestamp}.txt')
+    csv_path = os.path.join(stats_folder, f'Dataset_Statistics_Full_{timestamp}.csv')
+
+    # --- 5. Write TXT Report ---
+    with open(txt_path, 'w', encoding='utf-8') as f:
+        f.write("==================================================\n")
+        f.write(f"DATASET STATISTICS REPORT (FULL)\n")
+        f.write(f"Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+        f.write("==================================================\n\n")
+
+        report_order = ['Total'] + sorted(SUB_DATASETS)
+
+        for ds_name in report_order:
+            data = all_stats[ds_name]
+            total_imgs = data['img_count']
+            total_pixels = data['total_pixel_area']
+
+            f.write(f"--- DATASET: {ds_name} ---\n")
+            f.write(f"Total Images: {total_imgs}\n")
+            f.write(f"Total Pixels: {total_pixels:,}\n")
+            
+            if total_imgs > 0:
+                # A. IMAGE DISTRIBUTION
+                f.write(f"  [Image Distribution]\n")
+                pct_no = (data['no_defect_img_count'] / total_imgs) * 100
+                f.write(f"    No Defect Images: {data['no_defect_img_count']} ({pct_no:.2f}%)\n")
+                
+                for c_name in CLASS_MAP.keys():
+                    count = data['class_counts'][c_name]
+                    pct = (count / total_imgs) * 100
+                    f.write(f"    {c_name:<16}: {count} ({pct:.2f}%)\n")
+                
+                # B. PIXEL DISTRIBUTION
+                # Calculate Defect Pixels sum
+                total_defect_pixels = sum(data['pixel_counts'].values())
+                # Calculate No Defect (Background) Pixels
+                no_defect_pixels = total_pixels - total_defect_pixels
+                
+                f.write(f"  [Pixel Distribution]\n")
+                
+                # Write No Defect Pixels
+                nd_pct = (no_defect_pixels / total_pixels) * 100
+                f.write(f"    No Defect/Bg    : {no_defect_pixels:,} px ({nd_pct:.4f}%)\n")
+
+                for c_name in CLASS_MAP.keys():
+                    px = data['pixel_counts'][c_name]
+                    px_pct = (px / total_pixels) * 100
+                    f.write(f"    {c_name:<16}: {px:,} px ({px_pct:.4f}%)\n")
+            else:
+                f.write("  (No images found)\n")
+            
+            f.write("\n")
+
+        if errors > 0:
+            f.write(f"NOTE: {errors} files skipped due to errors.\n")
+
+    # --- 6. Write CSV Report ---
+    with open(csv_path, 'w', newline='', encoding='utf-8') as csvfile:
+        writer = csv.writer(csvfile)
+        
+        # Header
+        writer.writerow(['Dataset', 'Metric Type', 'Class', 'Count', 'Percentage'])
+        
+        for ds_name in report_order:
+            data = all_stats[ds_name]
+            total_imgs = data['img_count']
+            total_pixels = data['total_pixel_area']
+            
+            if total_imgs == 0:
+                continue
+
+            # 1. Image Stats
+            # No Defect
+            pct = (data['no_defect_img_count'] / total_imgs) * 100
+            writer.writerow([ds_name, 'Image Count', 'No Defect', data['no_defect_img_count'], f"{pct:.2f}%"])
+            
+            # Defects
+            for c_name in CLASS_MAP.keys():
+                count = data['class_counts'][c_name]
+                pct = (count / total_imgs) * 100
+                writer.writerow([ds_name, 'Image Count', c_name, count, f"{pct:.2f}%"])
+
+            # 2. Pixel Stats
+            # Calculate No Defect Pixels
+            total_defect_pixels = sum(data['pixel_counts'].values())
+            no_defect_pixels = total_pixels - total_defect_pixels
+            
+            # Write No Defect
+            nd_pct = (no_defect_pixels / total_pixels) * 100
+            writer.writerow([ds_name, 'Pixel Count', 'No Defect / Background', no_defect_pixels, f"{nd_pct:.5f}%"])
+
+            # Write Defects
+            for c_name in CLASS_MAP.keys():
+                px = data['pixel_counts'][c_name]
+                px_pct = (px / total_pixels) * 100
+                writer.writerow([ds_name, 'Pixel Count', c_name, px, f"{px_pct:.5f}%"])
+            
+            writer.writerow([]) # Spacer
+
+    # --- 7. Final Console Output ---
+    print("\n" + "="*30)
+    print("CALCULATION COMPLETE")
+    print(f"Total Images: {all_stats['Total']['img_count']}")
+    print(f"Total Pixels: {all_stats['Total']['total_pixel_area']:,}")
+    print("-" * 30)
+    print(f"Reports saved to: {stats_folder}")
+
+if __name__ == "__main__":
+    try:
+        import PIL
+    except ImportError:
+        print("Please install Pillow: pip install Pillow")
+        exit()
+        
+    calculate_dataset_statistics_complete()

1_python/1b_histogram_plot.py

@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+# Document info
+__author__ = 'Andreas Sjölander, Gemini'
+__version__ = ['1.0'] 
+__version_date__ = '2025-12-01'
+__maintainer__ = 'Andreas Sjölander'
+__email__ = '[email protected]'
+
+"""
+1b_histogram_plot.py
+This script reads the segmented masks and plots histograms of the defect size 
+distribution. It generates:
+1. Individual plots for all datasets and individual plots for the tunnels 
+TA, TB, TC.
+2. A combined subplot figure comparing TA, TB, and TC.
+
+The user chose which defect that should be plotted.
+"""
+
+import os
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from glob import glob
+from tqdm import tqdm
+
+# ==========================================
+#               CONFIGURATION
+# ==========================================
+
+# 1. SELECT DEFECT TO PLOT
+# Options: 'Crack', 'Water', 'Leaching'
+DEFECT_TO_PLOT = 'Crack' 
+
+# 2. CLASS DEFINITIONS (Pixel Values)
+CLASS_MAP = {
+    'Crack': 40,
+    'Water': 160,
+    'Leaching': 200
+}
+
+# ------------------------------------------
+# 3. FONT CONFIGURATION (Global)
+# ------------------------------------------
+FONT_PARAMS = {
+    'suptitle': 18,  # Main title for the combined subplot figure
+    'title':    16,  # Title of individual plots
+    'label':    14,  # X and Y axis labels (e.g. "Frequency")
+    'ticks':    14,  # Numbers on the axes
+    'legend':   14,  # Legend text size
+}
+
+# ------------------------------------------
+# 4. SETTINGS: INDIVIDUAL PLOTS (One file per tunnel)
+# ------------------------------------------
+INDIV_X_AXIS_MAX = 15000   # Max pixel area on X-axis
+INDIV_Y_AXIS_MAX = 50      # Max frequency on Y-axis
+INDIV_BIN_SIZE = 250       # Bin width for single plots
+
+# ------------------------------------------
+# 5. SETTINGS: SUBPLOT FIGURE (TA, TB, TC combined)
+# ------------------------------------------
+SUBPLOT_X_AXIS_MAX = 15000 # Max pixel area on X-axis
+SUBPLOT_Y_AXIS_MAX = 70    # Max frequency on Y-axis
+SUBPLOT_BIN_SIZE = 400     # Bin width for the comparison plot
+
+# ==========================================
+#               MAIN SCRIPT
+# ==========================================
+
+def run_histogram_analysis():
+    # --- 1. Setup Paths ---
+    script_location = os.path.dirname(os.path.abspath(__file__))
+    root_dir = os.path.dirname(script_location)
+    
+    mask_folder = os.path.join(root_dir, '3_mask')
+    output_dir = os.path.join(root_dir, '2_statistics')
+    
+    # Create output sub-folder for plots to keep it tidy
+    plot_output_dir = os.path.join(output_dir, 'Plots')
+    os.makedirs(plot_output_dir, exist_ok=True)
+
+    # Get target pixel value
+    if DEFECT_TO_PLOT not in CLASS_MAP:
+        print(f"Error: {DEFECT_TO_PLOT} is not in CLASS_MAP. Choose: {list(CLASS_MAP.keys())}")
+        return
+    
+    target_value = CLASS_MAP[DEFECT_TO_PLOT]
+    print(f"--- Configuration ---")
+    print(f"Target Defect: {DEFECT_TO_PLOT} (Pixel Value: {target_value})")
+    print(f"Source:        {mask_folder}")
+    print(f"Output:        {plot_output_dir}")
+    print("-" * 30)
+
+    # --- 2. Data Collection ---
+    data_buckets = {
+        'Total': [],
+        'TA': [],
+        'TB': [],
+        'TC': []
+    }
+
+    # Get files
+    valid_exts = ['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tiff']
+    files = []
+    for ext in valid_exts:
+        files.extend(glob(os.path.join(mask_folder, ext)))
+    
+    if not files:
+        print("No mask files found.")
+        return
+
+    print("Reading masks and extracting defect sizes...")
+    
+    for filepath in tqdm(files, unit="mask"):
+        # Read image using OpenCV (Grayscale)
+        mask = cv2.imread(filepath, cv2.IMREAD_GRAYSCALE)
+        
+        if mask is None:
+            continue
+
+        # Count pixels matching the target value
+        defect_pixels = np.sum(mask == target_value)
+
+        if defect_pixels > 0:
+            filename = os.path.basename(filepath)
+            
+            # Add to Total
+            data_buckets['Total'].append(defect_pixels)
+            
+            # Add to Sub-dataset buckets
+            if filename.startswith('TA'):
+                data_buckets['TA'].append(defect_pixels)
+            elif filename.startswith('TB'):
+                data_buckets['TB'].append(defect_pixels)
+            elif filename.startswith('TC'):
+                data_buckets['TC'].append(defect_pixels)
+
+    print("-" * 30)
+    
+    # --- 3. Plotting Loop (Individual) ---
+    print("Generating Individual Plots...")
+    for dataset_name, values in data_buckets.items():
+        if not values:
+            print(f"Skipping {dataset_name}: No defects found.")
+            continue
+            
+        plot_single_histogram(
+            data_values=values,
+            dataset_name=dataset_name,
+            defect_type=DEFECT_TO_PLOT,
+            output_dir=plot_output_dir,
+            x_max=INDIV_X_AXIS_MAX,
+            y_max=INDIV_Y_AXIS_MAX,
+            bin_size=INDIV_BIN_SIZE
+        )
+
+    # --- 4. Plotting Subplots (Combined) ---
+    print("Generating Comparison Subplots...")
+    plot_comparison_figure(
+        data_buckets=data_buckets,
+        defect_type=DEFECT_TO_PLOT,
+        output_dir=plot_output_dir,
+        x_max=SUBPLOT_X_AXIS_MAX,
+        y_max=SUBPLOT_Y_AXIS_MAX,
+        bin_size=SUBPLOT_BIN_SIZE
+    )
+
+    print("\nProcessing Complete.")
+
+def plot_single_histogram(data_values, dataset_name, defect_type, output_dir, x_max, y_max, bin_size):
+    """
+    Generates and saves a single histogram.
+    """
+    # Statistics
+    mean_val = np.mean(data_values)
+    median_val = np.median(data_values)
+    max_val = np.max(data_values)
+    
+    plt.figure(figsize=(8, 6))
+
+    # --- Bin Calculation ---
+    upper_limit = x_max if x_max else max_val
+    bins = np.arange(0, upper_limit + bin_size, bin_size)
+
+    # --- Plotting ---
+    plt.hist(data_values, bins=bins, color='#1f77b4', edgecolor='black', alpha=0.7)
+
+    # Lines for Mean/Median
+    plt.axvline(mean_val, color='red', linestyle='--', linewidth=2, label=f'Mean: {mean_val:.0f}')
+    plt.axvline(median_val, color='orange', linestyle='-', linewidth=2, label=f'Median: {median_val:.0f}')
+
+    # Labels & Fonts
+    plt.title(f'{defect_type} Size Distribution: {dataset_name}', 
+              fontsize=FONT_PARAMS['title'], fontweight='bold')
+    plt.xlabel(f'Defect Area (Pixels)', fontsize=FONT_PARAMS['label'])
+    plt.ylabel('Frequency (Count)', fontsize=FONT_PARAMS['label'])
+    
+    plt.xticks(fontsize=FONT_PARAMS['ticks'])
+    plt.yticks(fontsize=FONT_PARAMS['ticks'])
+    plt.grid(axis='y', alpha=0.5, linestyle='--')
+    plt.legend(fontsize=FONT_PARAMS['legend'])
+
+    # Axis Limits
+    if x_max:
+        plt.xlim(0, x_max)
+    if y_max:
+        plt.ylim(0, y_max)
+
+    plt.tight_layout()
+
+    # --- Save ---
+    filename = f"Hist_{defect_type}_{dataset_name}.png"
+    save_path = os.path.join(output_dir, filename)
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close() 
+
+    # Save Stats Text
+    txt_filename = f"Stats_{defect_type}_{dataset_name}.txt"
+    with open(os.path.join(output_dir, txt_filename), 'w') as f:
+        f.write(f"Dataset: {dataset_name}\nDefect: {defect_type}\nMean: {mean_val:.2f}\nMedian: {median_val:.2f}\nMax: {max_val}\n")
+
+def plot_comparison_figure(data_buckets, defect_type, output_dir, x_max, y_max, bin_size):
+    """
+    Generates a 1x3 subplot figure comparing TA, TB, and TC.
+    """
+    tunnels = ['TA', 'TB', 'TC']
+    
+    # Setup Figure (1 row, 3 columns)
+    fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharey=True)
+    
+    # Use 'suptitle' from FONT_PARAMS
+    fig.suptitle(f'{defect_type} Distribution Comparison (Bin Size: {bin_size}px)', 
+                 fontsize=FONT_PARAMS['suptitle'], fontweight='bold')
+
+    for ax, tunnel in zip(axes, tunnels):
+        data = data_buckets.get(tunnel, [])
+        
+        # Handle empty data
+        if not data:
+            ax.text(0.5, 0.5, 'No Data', ha='center', va='center', transform=ax.transAxes, 
+                    fontsize=FONT_PARAMS['label'])
+            ax.set_title(f"Tunnel {tunnel}", fontsize=FONT_PARAMS['title'])
+            continue
+
+        # Stats
+        mean_val = np.mean(data)
+        median_val = np.median(data)
+        max_val_local = np.max(data)
+
+        # Bins
+        upper_limit = x_max if x_max else max_val_local
+        bins = np.arange(0, upper_limit + bin_size, bin_size)
+
+        # Plot
+        ax.hist(data, bins=bins, color='Steelblue', edgecolor='black', alpha=0.7)
+        
+        # Lines
+        ax.axvline(mean_val, color='red', linestyle='--', linewidth=2, label=f'Mean: {mean_val:.0f}')
+        ax.axvline(median_val, color='orange', linestyle='-', linewidth=2, label=f'Median: {median_val:.0f}')
+
+        # Formatting with Fonts
+        ax.set_title(f"Tunnel {tunnel} (n={len(data)})", fontsize=FONT_PARAMS['title'])
+        ax.set_xlabel('Defect Area (Pixels)', fontsize=FONT_PARAMS['label'])
+        
+        # Adjust Ticks
+        ax.tick_params(axis='both', which='major', labelsize=FONT_PARAMS['ticks'])
+        
+        ax.grid(axis='y', alpha=0.5, linestyle='--')
+        ax.legend(fontsize=FONT_PARAMS['legend'], loc='upper right')
+
+        # Axis Limits
+        if x_max:
+            ax.set_xlim(0, x_max)
+        if y_max:
+            ax.set_ylim(0, y_max)
+
+    # Set Y-label only on the first plot
+    axes[0].set_ylabel('Frequency (Count)', fontsize=FONT_PARAMS['label'])
+
+    plt.tight_layout(rect=[0, 0.03, 1, 0.95]) # Make space for suptitle
+    
+    # Save
+    filename = f"Hist_Comparison_{defect_type}_TA_TB_TC.png"
+    save_path = os.path.join(output_dir, filename)
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"Comparison plot saved: {filename}")
+
+if __name__ == "__main__":
+    run_histogram_analysis()

1_python/1c_create_classification.py

@@ -0,0 +1,121 @@
+# Document info
+__author__ = 'Andreas Sjolander, Gemini'
+__version__ = ['1.0'] 
+__version_date__ = '2025-11-25' 
+__maintainer__ = 'Andreas Sjolander'
+__github__ = 'andreassjolander'
+__email__ = '[email protected]'
+
+"""
+1c_create_classification.py
+this scripts reads the csv files that contain information about images with and
+withou cracks. Based on this, three classification datasets are created in the
+folder "3_classification", i.e. TA, TB and TC. Each folder contains the 
+subfolder "crack" and "no_crack"
+"""
+
+##################################
+# IMPORT PACKAGES
+##################################
+import os
+import shutil
+import pandas as pd
+import sys
+
+##################################
+# SPECIFY WORKING PATHS
+##################################
+# 1. Get the root directory (assuming script is running from the root)
+project_root = os.getcwd()
+
+# 2. Define Input folders
+# The folder where your CSV files are located
+input_csv_folder = os.path.join(project_root, "../2_model_input")
+# The folder where your images are currently stored
+source_img_folder = os.path.join(project_root, "../3_img")
+# 3. Define Output folder
+output_base_folder = os.path.join(project_root, "../3_classification")
+
+##################################
+# MAIN EXECUTION
+##################################
+
+def sort_classification_data():
+    print(f"--- Starting Classification Sorting ---")
+    print(f"Root Directory: {project_root}")
+    print(f"Source Images : {source_img_folder}")
+    print(f"Input CSVs    : {input_csv_folder}")
+    
+    # Datasets to process
+    datasets = ["TA", "TB", "TC"]
+
+    for dataset in datasets:
+        print(f"\nProcessing Dataset: {dataset}...")
+        
+        # Construct CSV path
+        csv_file = f"{dataset}_dataset_labels.csv"
+        csv_path = os.path.join(input_csv_folder, csv_file)
+
+        # Check if CSV exists
+        if not os.path.exists(csv_path):
+            print(f"  [WARNING] CSV not found: {csv_path}. Skipping.")
+            continue
+
+        # Read the CSV
+        try:
+            df = pd.read_csv(csv_path)
+        except Exception as e:
+            print(f"  [Error] Could not read CSV: {e}")
+            continue
+
+        # Counters for feedback
+        count_crack = 0
+        count_no_crack = 0
+        count_missing = 0
+
+        # Iterate through each row in the CSV
+        for index, row in df.iterrows():
+            # 1. Extract the filename
+            # The CSV contains "../3 img/filename.png". We only want "filename.png".
+            raw_path = str(row['filename'])
+            filename = os.path.basename(raw_path) 
+            
+            # 2. Get the label
+            label = str(row['label']).strip().lower() # e.g., "crack" or "no_crack"
+
+            # 3. Define Source Path
+            # We look for the file in the local "3 img" folder
+            src_path = os.path.join(source_img_folder, filename)
+
+            # 4. Define Destination Path
+            # Structure: 3 Classification / TA / crack / filename.png
+            dest_dir = os.path.join(output_base_folder, dataset, label)
+            dest_path = os.path.join(dest_dir, filename)
+
+            # 5. Copy the file
+            if os.path.exists(src_path):
+                # Create destination folder if it doesn't exist
+                os.makedirs(dest_dir, exist_ok=True)
+                
+                shutil.copy2(src_path, dest_path)
+                
+                if "no_crack" in label:
+                    count_no_crack += 1
+                else:
+                    count_crack += 1
+            else:
+                # If file is missing, print a warning (limit to first 5 to avoid spamming console)
+                if count_missing < 5:
+                    print(f"  [Missing] Could not find image: {src_path}")
+                count_missing += 1
+
+        print(f"  Summary for {dataset}:")
+        print(f"    - Cracks copied   : {count_crack}")
+        print(f"    - No Cracks copied: {count_no_crack}")
+        if count_missing > 0:
+            print(f"    - Missing images  : {count_missing} (Check filenames or source folder)")
+
+    print("\n--- Processing Complete ---")
+
+if __name__ == "__main__":
+    sort_classification_data()

1_python/2a_train_CNN.py

@@ -0,0 +1,555 @@
+# -*- coding: utf-8 -*-
+"""
+2_train_CNN.py
+
+This script trains a UNet segmentaiton model for a single detection class. 
+The user defines the "Session_Name" which is the output folder for the saved 
+model, plots and metrics. 
+The user use the Global Configuration to adjust parameters. This includdes: 
+ - A weight factor is included for imbalanced datasets.
+- Data used for Traning, Evaluation and Testing is based on csv files.
+ - The script creates masks used for the fastai packaage which use 1 for defect
+ and 0 for background. The user defines the pixel value for the class they want 
+to train the model for. 
+ - Model training parameters are easily adjusted.
+ - Output includes plots of top 5 best and worst predictions of cracks and 
+ txt files with a summary of the metrics
+"""
+
+import os
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+from PIL import Image
+from fastai.vision.all import *
+from fastai.callback.tracker import SaveModelCallback, CSVLogger
+from fastai.losses import CrossEntropyLossFlat
+
+##################################
+# 1. GLOBAL CONFIGURATION
+##################################
+
+# --- 🏷️ SESSION SETTINGS ---
+SESSION_NAME = "TA+TB+TC_TEST" 
+
+# --- ⚖️ CLASS IMBALANCE SETTINGS ---
+CRACK_CLASS_WEIGHT = 20.0 
+
+# --- 📁 CSV LOCATION & SELECTION ---
+TRAIN_CSVS = ['TA_train.csv','TB_train.csv','TC_train.csv']
+VAL_CSVS   = ['TA_val.csv','TB_val.csv','TC_val.csv']
+TEST_CSVS  = ['TA_test.csv','TB_test.csv','TC_test.csv'] 
+
+# --- Directory Settings ---
+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_DIR = os.path.join(SESSION_DIR, 'Training')
+TRAIN_MODEL_DIR = os.path.join(TRAIN_DIR, 'Models')
+TRAIN_PLOT_DIR = os.path.join(TRAIN_DIR, 'Plots')
+
+TEST_DIR = os.path.join(SESSION_DIR, 'Testing')
+TEST_PLOT_DIR = os.path.join(TEST_DIR, 'Plots')
+
+# --- Sanitization Settings ---
+ORIGINAL_CLASS_PIXEL_VALUE = 40 
+SANITIZED_VALUE = 1               
+
+# --- Model Training Settings ---
+MODEL_ARCH = resnet34
+IMG_SIZE = 512
+BATCH_SIZE = 8
+NUM_EPOCHS = 2
+LEARNING_RATE = 4e-4
+WD = 1e-2
+
+##################################
+# 2. HELPER & METRIC FUNCTIONS
+##################################
+
+def check_system_resources():
+    print("\n--- 🖥️ System Resource Check ---")
+    if torch.cuda.is_available():
+        device_name = torch.cuda.get_device_name(0)
+        print(f"✅ GPU Detected: {device_name}")
+    else:
+        print("❌ GPU NOT Detected. Training will be slow.")
+        
+def enforce_dedicated_vram(fraction=0.95):
+    """
+    Configures PyTorch to strictly use only a specific fraction of Dedicated VRAM.
+    If the model attempts to exceed this, it will throw an OOM error immediately
+    rather than spilling into slow system RAM (Shared Memory).
+    """
+    if torch.cuda.is_available():
+        # Empty cache to start fresh
+        torch.cuda.empty_cache()
+        
+        # Enforce the limit. 
+        # We use 0.95 (95%) to leave a tiny bit of room for the OS display overhead 
+        # so the driver doesn't panic and swap to RAM.
+        try:
+            torch.cuda.set_per_process_memory_fraction(fraction, 0)
+            print(f"🔒 STRICT MODE: GPU memory capped at {fraction*100}%.")
+            print("   -> Script will CRASH if this limit is exceeded (preventing slow shared memory usage).")
+        except RuntimeError as e:
+            print(f"⚠️ Could not set memory fraction: {e}")
+    else:
+        print("⚠️ GPU not available. Running on CPU (slow).")
+
+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
+
+# --- Metrics ---
+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)
+
+# --- Weighted Loss ---
+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)
+
+##################################
+# 3. DATA PROCESSING FUNCTIONS
+##################################
+
+def sanitize_dataframe(df, desc="Sanitizing"):
+    os.makedirs(SANITIZED_MASK_DIR, exist_ok=True)
+    new_mask_paths = []
+    image_abs_paths = []
+    valid_indices = []
+    
+    found_count = 0
+    missing_count = 0
+
+    for idx, row in tqdm(df.iterrows(), total=len(df), desc=desc):
+        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)
+                found_count += 1
+                continue
+
+            if not os.path.exists(raw_mask_path):
+                if missing_count < 3:
+                    print(f"⚠️ Raw mask not found for: {os.path.basename(abs_img_path)}")
+                missing_count += 1
+                continue
+                
+            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:
+                blank_mask = np.zeros_like(mask_arr, dtype=np.uint8)
+                Image.fromarray(blank_mask).save(clean_mask_path)
+            
+            image_abs_paths.append(abs_img_path)
+            new_mask_paths.append(clean_mask_path)
+            valid_indices.append(idx)
+            found_count += 1
+            
+        except Exception as e:
+            print(f"Error on {os.path.basename(abs_img_path)}: {e}")
+
+    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, is_valid_flag=False):
+    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))
+        else:
+            print(f"❌ Warning: CSV file not found: {path}")
+    if not dfs: return pd.DataFrame()
+    combined = pd.concat(dfs, ignore_index=True)
+    combined['is_valid'] = is_valid_flag
+    return combined
+
+##################################
+# 4. REPORTING & VISUALIZATION
+##################################
+
+def visualize_sanity_check(df, save_dir, n_samples=5):
+    os.makedirs(save_dir, exist_ok=True)
+    crack_df = df[df['target'] == 1]
+    if len(crack_df) == 0: return
+
+    n = min(n_samples, len(crack_df))
+    samples = crack_df.sample(n=n)
+    
+    fig, axs = plt.subplots(n, 3, figsize=(15, 5*n))
+    if n == 1: axs = np.expand_dims(axs, 0)
+    
+    row_idx = 0
+    for _, row in samples.iterrows():
+        img = Image.open(row['image_abs_path'])
+        mask = np.array(Image.open(row['mask_path_sanitized']))
+        masked_overlay = np.ma.masked_where(mask == 0, mask)
+
+        axs[row_idx, 0].imshow(img, cmap='gray')
+        axs[row_idx, 0].set_title("Image")
+        axs[row_idx, 0].axis('off')
+        
+        axs[row_idx, 1].imshow(mask, cmap='gray')
+        axs[row_idx, 1].set_title("Sanitized Mask")
+        axs[row_idx, 1].axis('off')
+        
+        axs[row_idx, 2].imshow(img, cmap='gray')
+        axs[row_idx, 2].imshow(masked_overlay, cmap='autumn', alpha=0.6)
+        axs[row_idx, 2].set_title("Overlay")
+        axs[row_idx, 2].axis('off')
+        row_idx += 1
+        
+    plt.tight_layout()
+    plt.savefig(os.path.join(save_dir, 'sanity_check_preview.png'))
+    plt.close()
+
+# --- NEW: Generate Comprehensive Training Report ---
+def generate_training_report(log_path, output_dir):
+    """
+    Reads the CSV log, finds best epoch, writes a summary TXT file.
+    Returns: Dictionary of the best validation metrics found.
+    """
+    if not os.path.exists(log_path):
+        print("⚠️ No training log found to generate report.")
+        return {}
+
+    df = pd.read_csv(log_path)
+    
+    # Identify the best epoch based on IoU
+    # (FastAI columns: epoch, train_loss, valid_loss, [metrics...])
+    # We assume 'iou_crack' is in the columns
+    
+    if 'iou_crack' in df.columns:
+        best_row = df.loc[df['iou_crack'].idxmax()]
+        best_epoch = int(best_row['epoch'])
+    else:
+        # Fallback if iou_crack missing, use last epoch
+        best_row = df.iloc[-1]
+        best_epoch = int(best_row['epoch'])
+
+    # Prepare stats for return
+    best_metrics = best_row.to_dict()
+
+    txt_path = os.path.join(output_dir, 'training_report.txt')
+    
+    with open(txt_path, 'w') as f:
+        f.write("TRAINING SESSION SUMMARY\n")
+        f.write("========================\n")
+        f.write(f"Total Epochs Run: {len(df)}\n")
+        f.write(f"Best Model Saved at Epoch: {best_epoch}\n")
+        f.write("Note: 'valid_loss' and metrics below are evaluated on the VALIDATION dataset.\n\n")
+        
+        f.write(f"BEST VALIDATION METRICS (Epoch {best_epoch}):\n")
+        f.write("-----------------------------------\n")
+        for k, v in best_metrics.items():
+            # Format numbers nicely
+            val_str = f"{v:.6f}" if isinstance(v, (int, float)) else str(v)
+            f.write(f"{k:<20}: {val_str}\n")
+            
+        f.write("\n\nFULL TRAINING HISTORY\n")
+        f.write("=====================\n")
+        # Write the full dataframe table
+        f.write(df.to_string(index=False))
+    
+    print(f"✅ Training report with Best Epoch Summary saved to {txt_path}")
+    return best_metrics
+
+# --- Generate Comparison Testing Report ---
+def generate_testing_report(test_metrics, val_metrics, output_dir):
+    """
+    Writes test metrics AND compares them to the best validation metrics.
+    """
+    txt_path = os.path.join(output_dir, 'testing_report.txt')
+    
+    with open(txt_path, 'w') as f:
+        f.write("TESTING & COMPARISON REPORT\n")
+        f.write("===========================\n\n")
+        
+        # Header for Table
+        # Columns: Metric Name | Best Validation (Train Phase) | Testing Result
+        f.write(f"{'METRIC':<25} | {'BEST VALIDATION':<18} | {'TESTING RESULT':<18}\n")
+        f.write("-" * 65 + "\n")
+        
+        for k, test_val in test_metrics.items():
+            # Try to find matching key in validation stats
+            # Note: FastAI training log might call it 'iou_crack' 
+            # while validate() output might call it 'iou_crack' (should match)
+            
+            val_val = val_metrics.get(k, "N/A")
+            
+            # Formatting
+            if isinstance(test_val, float): test_str = f"{test_val:.6f}"
+            else: test_str = str(test_val)
+            
+            if isinstance(val_val, float): val_str = f"{val_val:.6f}"
+            else: val_str = str(val_val)
+            
+            f.write(f"{k:<25} | {val_str:<18} | {test_str:<18}\n")
+            
+    print(f"✅ Testing report (with Training comparison) saved to {txt_path}")
+
+def save_best_worst_predictions(learn, dl, save_dir, k=5):
+    print(f"\n--- 📸 Generating Best/Worst {k} Predictions (CRACKS ONLY) ---")
+    os.makedirs(save_dir, exist_ok=True)
+    
+    preds, targs = learn.get_preds(dl=dl)
+    pred_masks = preds.argmax(dim=1)
+    
+    results = []
+    for i in range(len(pred_masks)):
+        p = pred_masks[i]
+        t = targs[i]
+        inter = ((p==1) & (t==1)).sum().item()
+        union = ((p==1) | (t==1)).sum().item()
+        if union == 0: iou_val = 1.0 
+        else: iou_val = inter / (union + 1e-6)
+        has_crack_in_gt = (t == 1).sum().item() > 0
+        results.append({'idx': i, 'iou': iou_val, 'has_crack': has_crack_in_gt})
+        
+    res_df = pd.DataFrame(results)
+    crack_candidates = res_df[res_df['has_crack'] == True].copy()
+    
+    if len(crack_candidates) == 0:
+        print("⚠️ No images with cracks found. Skipping plots.")
+        return
+
+    print(f"    -> Found {len(crack_candidates)} images with cracks.")
+    sorted_df = crack_candidates.sort_values(by='iou', ascending=True)
+    worst_df = sorted_df.head(k)
+    best_df = sorted_df.tail(k).iloc[::-1] 
+
+    def plot_batch(df_rows, label_type):
+        for rank, (_, row_data) in enumerate(df_rows.iterrows()):
+            idx = int(row_data['idx'])
+            row_item = dl.dataset.items.iloc[idx]
+            img = Image.open(row_item['image_abs_path'])
+            gt_mask = targs[idx]
+            pred_mask = pred_masks[idx]
+            iou_val = row_data['iou']
+            
+            fig, ax = plt.subplots(1, 3, figsize=(12, 4))
+            ax[0].imshow(img, cmap='gray'); ax[0].set_title(f"Input Image"); ax[0].axis('off')
+            ax[1].imshow(gt_mask.cpu(), cmap='gray'); ax[1].set_title("Ground Truth"); ax[1].axis('off')
+            ax[2].imshow(pred_mask.cpu(), cmap='gray'); ax[2].set_title(f"Pred (IoU: {iou_val:.4f})"); ax[2].axis('off')
+            
+            filename = os.path.basename(row_item['image_abs_path'])
+            plt.suptitle(f"{label_type} #{rank+1} - {filename}")
+            plt.tight_layout()
+            plt.savefig(os.path.join(save_dir, f"{label_type}_{rank+1}_iou_{iou_val:.2f}.png"))
+            plt.close()
+
+    plot_batch(best_df, "BEST_CRACK")
+    plot_batch(worst_df, "WORST_CRACK")
+    print(f"✅ Plots saved to {save_dir}")
+
+##################################
+# 5. MAIN PIPELINE
+##################################
+
+def get_metric_name(metric):
+    if hasattr(metric, '__name__'): return metric.__name__
+    if hasattr(metric, 'func'): return metric.func.__name__
+    return str(metric)
+
+def run_pipeline():
+    check_system_resources()
+    
+    for d in [TRAIN_DIR, TRAIN_MODEL_DIR, TRAIN_PLOT_DIR, TEST_DIR, TEST_PLOT_DIR]:
+        os.makedirs(d, exist_ok=True)
+    
+    print(f"--- Session: {SESSION_NAME} ---")
+
+    # ==========================
+    # PHASE 1: PREPARE TRAINING DATA
+    # ==========================
+    print("\n--- 🔄 Loading Training Data ---")
+    df_train = combine_csvs(TRAIN_CSVS, is_valid_flag=False)
+    df_val = combine_csvs(VAL_CSVS, is_valid_flag=True)
+    
+    if len(df_train) == 0: raise ValueError("No training data found.")
+    full_df = pd.concat([df_train, df_val], ignore_index=True)
+    
+    df_ready = sanitize_dataframe(full_df, desc="Sanitizing Train/Val")
+    visualize_sanity_check(df_ready, TRAIN_PLOT_DIR)
+
+    codes = np.array(['background', 'crack'])
+    dblock = DataBlock(
+        blocks=(ImageBlock, MaskBlock(codes)),
+        get_x=ColReader('image_abs_path'),
+        get_y=ColReader('mask_path_sanitized'),
+        splitter=ColSplitter('is_valid'),
+        batch_tfms=[
+            *aug_transforms(flip_vert=True, max_rotate=15.0, max_zoom=1.1, max_lighting=0.2),
+            Normalize.from_stats(*imagenet_stats)
+        ]
+    )
+    dls = dblock.dataloaders(
+        df_ready, 
+        bs=BATCH_SIZE, 
+        num_workers=0,      
+        pin_memory=True     
+                             
+                             )
+
+    # ==========================
+    # PHASE 2: TRAINING
+    # ==========================
+    print(f"\n--- 🏋️ Starting Training ({NUM_EPOCHS} epochs) ---")
+    history_log_path = os.path.join(TRAIN_DIR, 'training_log.csv')
+    
+    learn = unet_learner(
+        dls, MODEL_ARCH, 
+        loss_func=WeightedCombinedLoss(crack_weight=CRACK_CLASS_WEIGHT),
+        metrics=[dice_score_crack, iou_crack, recall_crack, precision_crack, f1_score_crack],
+        wd=WD,
+        model_dir=TRAIN_MODEL_DIR
+    ).to_fp16()
+    
+    callbacks = [
+        SaveModelCallback(monitor='iou_crack', comp=np.greater, fname='best_model'),
+        CSVLogger(fname=history_log_path) 
+    ]
+    
+    learn.fit_one_cycle(NUM_EPOCHS, slice(LEARNING_RATE), cbs=callbacks)
+    
+    # --- UPDATED: Generate Enhanced Training Report ---
+    # This now captures the best metrics to pass to Phase 3
+    best_val_metrics = generate_training_report(history_log_path, TRAIN_DIR)
+    
+    print("\n--- 🔍 Evaluating Validation Set ---")
+    save_best_worst_predictions(learn, dls.valid, TRAIN_PLOT_DIR, k=5)
+
+    # ==========================
+    # PHASE 3: TESTING
+    # ==========================
+    print("\n--- 🧪 Starting Testing Phase ---")
+    
+    df_test_raw = combine_csvs(TEST_CSVS)
+    if len(df_test_raw) > 0:
+        df_test_ready = sanitize_dataframe(df_test_raw, desc="Sanitizing Test Set")
+        
+        if len(df_test_ready) > 0:
+            test_dl = learn.dls.test_dl(df_test_ready, with_labels=True)
+            
+            print("Loading best model for testing...")
+            learn.load('best_model')
+            
+            results = learn.validate(dl=test_dl)
+            metric_names = ['valid_loss'] + [get_metric_name(m) for m in learn.metrics]
+            # FastAI calls validation loss 'valid_loss' in validate(), but we can just label it Loss
+            
+            test_metrics_dict = dict(zip(metric_names, results))
+            
+            print("\nTest Results:")
+            for k, v in test_metrics_dict.items():
+                print(f"  {k}: {v:.6f}")
+            
+            # --- UPDATED: Generate Comparison Report ---
+            generate_testing_report(test_metrics_dict, best_val_metrics, TEST_DIR)
+            
+            save_best_worst_predictions(learn, test_dl, TEST_PLOT_DIR, k=5)
+            
+        else:
+            print("⚠️ Test dataframe empty after sanitization.")
+    else:
+        print("⚠️ No test CSVs found or they are empty.")
+
+    print(f"\n✅ Pipeline Complete. Output saved to: {SESSION_DIR}")
+
+if __name__ == "__main__":
+    # 1. Enforce the Lock
+    enforce_dedicated_vram(fraction=0.90) # Set to 90% to be safe, or 0.95 to push limits
+    
+    # 2. Run Pipeline with Error Catching
+    try:
+        run_pipeline()
+        
+    except torch.cuda.OutOfMemoryError:
+        # This is the specific error we want to catch
+        print("\n" + "="*60)
+        print("🛑 CRITICAL ERROR: OUT OF DEDICATED GPU MEMORY")
+        print("="*60)
+        print("The script was stopped because it filled up the Dedicated VRAM.")
+        print("We prevented it from using Shared Memory (RAM) to maintain performance.")
+        print("SUGGESTIONS:")
+        print("1. Decrease BATCH_SIZE (currently set to {})".format(BATCH_SIZE))
+        print("2. Decrease IMG_SIZE (currently set to {})".format(IMG_SIZE))
+        print("3. Use a smaller model architecture (e.g., resnet18)")
+        sys.exit(1)
+        
+    except Exception as e:
+        # Catch other standard errors
+        print(f"\n❌ An unexpected error occurred: {e}")
+        # print(traceback.format_exc()) # Uncomment if you want full traceback

1_python/2b_plot_training.py

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+# Document info
+__author__ = 'Andreas Sjölander, Gemini'
+__version__ = ['1.0']
+__version_date__ = '2025-11-25'
+__maintainer__ = 'Andreas Sjölander'
+__email__ = '[email protected]'
+
+"""
+2b_plot_training.py
+This script reads the csv output from training and creates a plot of training 
+and validation loss in one plot and IoU and F1-score in a second plot. 
+User only needs to change "TRAINING_DATA" to correct training set.
+"""
+
+import pandas as pd
+import matplotlib.pyplot as plt
+import os
+
+# ==========================================
+# 🎨 CONFIGURATION & AESTHETICS SECTION
+# ==========================================
+# Change these variables to customize the look of your plots
+
+# --- File Settings ---
+TRAINING_DATA = 'TA' # Options: 'TA', 'TB', 'TC', etc.
+
+# Dynamic path setup
+script_location = os.path.dirname(os.path.abspath(__file__))
+# Assuming the script is inside a subfolder, go up one level to root
+root_dir = os.path.dirname(script_location) 
+
+# Input Folder
+file_folder = os.path.join(root_dir, '5_model_output', TRAINING_DATA, 'Training')
+FILE_PATH = os.path.join(file_folder, 'training_log.csv')
+
+# Output Folder for Plots
+PLOT_OUTPUT_DIR = os.path.join(root_dir, '5_model_output', 'Plots')
+
+# --- General Plot Settings ---
+FIG_SIZE = (6, 6)      # Width, Height in inches
+DPI = 100               # Resolution
+USE_GRID = True         # Show grid lines?
+GRID_STYLE = '--'       # Grid line style
+GRID_ALPHA = 0.5        # Grid transparency
+
+# --- Font Sizes ---
+FONT_TITLE = 16
+FONT_AXIS_LABEL = 14
+FONT_LEGEND = 12
+FONT_TICKS = 12
+
+# --- Colors & Line Styles ---
+# You can use color names ('red', 'blue') or Hex codes ('#FF5733')
+LINE_WIDTH = 2.5
+
+# Plot 1: Loss Configuration
+COLOR_TRAIN_LOSS = '#1f77b4'  
+COLOR_VALID_LOSS = '#ff7f0e'  
+TITLE_LOSS = f"Training vs Validation Loss ({TRAINING_DATA})"
+Y_LABEL_LOSS = "Loss Value"
+
+# Plot 2: Metrics Configuration
+COLOR_IOU = '#2ca02c'         
+COLOR_F1 = '#d62728'          
+TITLE_METRICS = f"IoU and F1 Score over Epochs ({TRAINING_DATA})"
+Y_LABEL_METRICS = "Score"
+
+# ==========================================
+# 🚀 MAIN SCRIPT LOGIC
+# ==========================================
+
+def plot_training_results():
+    # 1. Check if input file exists
+    if not os.path.exists(FILE_PATH):
+        print(f"Error: The file '{FILE_PATH}' was not found.")
+        print(f"Constructed path: {FILE_PATH}")
+        print("Please check the 'TRAINING_DATA' variable or folder structure.")
+        return
+
+    # 2. Create Output Directory if it doesn't exist
+    if not os.path.exists(PLOT_OUTPUT_DIR):
+        try:
+            os.makedirs(PLOT_OUTPUT_DIR)
+            print(f"Created output directory: {PLOT_OUTPUT_DIR}")
+        except OSError as e:
+            print(f"Error creating directory {PLOT_OUTPUT_DIR}: {e}")
+            return
+
+    # 3. Read the CSV file
+    try:
+        df = pd.read_csv(FILE_PATH)
+        print(f"Successfully loaded data for {TRAINING_DATA}. Found {len(df)} epochs.")
+    except Exception as e:
+        print(f"Error reading CSV: {e}")
+        return
+
+    # Apply global font sizes using rcParams
+    plt.rcParams.update({
+        'font.size': FONT_TICKS,
+        'axes.titlesize': FONT_TITLE,
+        'axes.labelsize': FONT_AXIS_LABEL,
+        'legend.fontsize': FONT_LEGEND,
+        'xtick.labelsize': FONT_TICKS,
+        'ytick.labelsize': FONT_TICKS
+    })
+
+    # -------------------------------------------------------
+    # PLOT 1: Training and Validation Loss
+    # -------------------------------------------------------
+    plt.figure(figsize=FIG_SIZE, dpi=DPI)
+    
+    plt.plot(df['epoch'], df['train_loss'], 
+             label='Training Loss', 
+             color=COLOR_TRAIN_LOSS, 
+             linewidth=LINE_WIDTH)
+    
+    plt.plot(df['epoch'], df['valid_loss'], 
+             label='Validation Loss', 
+             color=COLOR_VALID_LOSS, 
+             linewidth=LINE_WIDTH, 
+             linestyle='--') 
+
+    plt.title(TITLE_LOSS, fontweight='bold')
+    plt.xlabel("Epochs")
+    plt.ylabel(Y_LABEL_LOSS)
+    plt.legend()
+    
+    if USE_GRID:
+        plt.grid(True, linestyle=GRID_STYLE, alpha=GRID_ALPHA)
+    
+    plt.tight_layout()
+    
+    # Save Plot 1
+    save_name_loss = f"{TRAINING_DATA}_loss_plot.png"
+    save_path_loss = os.path.join(PLOT_OUTPUT_DIR, save_name_loss)
+    plt.savefig(save_path_loss)
+    print(f"Saved Loss plot to: {save_path_loss}")
+
+    # -------------------------------------------------------
+    # PLOT 2: IoU and F1 Score
+    # -------------------------------------------------------
+    plt.figure(figsize=FIG_SIZE, dpi=DPI)
+
+    plt.plot(df['epoch'], df['iou_crack'], 
+             label='IoU (Crack)', 
+             color=COLOR_IOU, 
+             linewidth=LINE_WIDTH)
+    
+    plt.plot(df['epoch'], df['f1_score_crack'], 
+             label='F1 Score (Crack)', 
+             color=COLOR_F1, 
+             linewidth=LINE_WIDTH)
+
+    plt.title(TITLE_METRICS, fontweight='bold')
+    plt.xlabel("Epochs")
+    plt.ylabel(Y_LABEL_METRICS)
+    plt.legend()
+
+    if USE_GRID:
+        plt.grid(True, linestyle=GRID_STYLE, alpha=GRID_ALPHA)
+
+    plt.tight_layout()
+
+    # Save Plot 2
+    save_name_metrics = f"{TRAINING_DATA}_metrics_plot.png"
+    save_path_metrics = os.path.join(PLOT_OUTPUT_DIR, save_name_metrics)
+    plt.savefig(save_path_metrics)
+    print(f"Saved Metrics plot to: {save_path_metrics}")
+
+    # Show the plots
+    print("Displaying plots...")
+    plt.show()
+
+if __name__ == "__main__":
+    plot_training_results()

1_python/3a_evaluate_CNN.py

@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+# Document info
+__author__ = 'Andreas Sjölander, Gemini'
+__version__ = ['1.0']
+__version_date__ = '2025-11-25'
+__maintainer__ = 'Andreas Sjölander'
+__email__ = '[email protected]'
+
+"""
+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()