geoai-py 0.15.0__py2.py3-none-any.whl → 0.16.0__py2.py3-none-any.whl

geoai/utils.py

@@ -383,6 +383,394 @@ def calc_stats(dataset, divide_by: float = 1.0) -> Tuple[np.ndarray, np.ndarray]
     return accum_mean / len(files), accum_std / len(files)
 
 
+def calc_iou(
+    ground_truth: Union[str, np.ndarray, torch.Tensor],
+    prediction: Union[str, np.ndarray, torch.Tensor],
+    num_classes: Optional[int] = None,
+    ignore_index: Optional[int] = None,
+    smooth: float = 1e-6,
+    band: int = 1,
+) -> Union[float, np.ndarray]:
+    """
+    Calculate Intersection over Union (IoU) between ground truth and prediction masks.
+
+    This function computes the IoU metric for segmentation tasks. It supports both
+    binary and multi-class segmentation, and can handle numpy arrays, PyTorch tensors,
+    or file paths to raster files.
+
+    Args:
+        ground_truth (Union[str, np.ndarray, torch.Tensor]): Ground truth segmentation mask.
+            Can be a file path (str) to a raster file, numpy array, or PyTorch tensor.
+            For binary segmentation: shape (H, W) with values {0, 1}.
+            For multi-class segmentation: shape (H, W) with class indices.
+        prediction (Union[str, np.ndarray, torch.Tensor]): Predicted segmentation mask.
+            Can be a file path (str) to a raster file, numpy array, or PyTorch tensor.
+            Should have the same shape and format as ground_truth.
+        num_classes (Optional[int], optional): Number of classes for multi-class segmentation.
+            If None, assumes binary segmentation. Defaults to None.
+        ignore_index (Optional[int], optional): Class index to ignore in computation.
+            Useful for ignoring background or unlabeled pixels. Defaults to None.
+        smooth (float, optional): Smoothing factor to avoid division by zero.
+            Defaults to 1e-6.
+        band (int, optional): Band index to read from raster file (1-based indexing).
+            Only used when input is a file path. Defaults to 1.
+
+    Returns:
+        Union[float, np.ndarray]: For binary segmentation, returns a single float IoU score.
+            For multi-class segmentation, returns an array of IoU scores for each class.
+
+    Examples:
+        >>> # Binary segmentation with arrays
+        >>> gt = np.array([[0, 0, 1, 1], [0, 1, 1, 1]])
+        >>> pred = np.array([[0, 0, 1, 1], [0, 0, 1, 1]])
+        >>> iou = calc_iou(gt, pred)
+        >>> print(f"IoU: {iou:.4f}")
+        IoU: 0.8333
+
+        >>> # Multi-class segmentation
+        >>> gt = np.array([[0, 0, 1, 1], [0, 2, 2, 1]])
+        >>> pred = np.array([[0, 0, 1, 1], [0, 0, 2, 2]])
+        >>> iou = calc_iou(gt, pred, num_classes=3)
+        >>> print(f"IoU per class: {iou}")
+        IoU per class: [0.8333 0.5000 0.5000]
+
+        >>> # Using PyTorch tensors
+        >>> gt_tensor = torch.tensor([[0, 0, 1, 1], [0, 1, 1, 1]])
+        >>> pred_tensor = torch.tensor([[0, 0, 1, 1], [0, 0, 1, 1]])
+        >>> iou = calc_iou(gt_tensor, pred_tensor)
+        >>> print(f"IoU: {iou:.4f}")
+        IoU: 0.8333
+
+        >>> # Using raster file paths
+        >>> iou = calc_iou("ground_truth.tif", "prediction.tif", num_classes=3)
+        >>> print(f"Mean IoU: {np.nanmean(iou):.4f}")
+        Mean IoU: 0.7500
+    """
+    # Load from file if string path is provided
+    if isinstance(ground_truth, str):
+        with rasterio.open(ground_truth) as src:
+            ground_truth = src.read(band)
+    if isinstance(prediction, str):
+        with rasterio.open(prediction) as src:
+            prediction = src.read(band)
+
+    # Convert to numpy if torch tensor
+    if isinstance(ground_truth, torch.Tensor):
+        ground_truth = ground_truth.cpu().numpy()
+    if isinstance(prediction, torch.Tensor):
+        prediction = prediction.cpu().numpy()
+
+    # Ensure inputs have the same shape
+    if ground_truth.shape != prediction.shape:
+        raise ValueError(
+            f"Shape mismatch: ground_truth {ground_truth.shape} vs prediction {prediction.shape}"
+        )
+
+    # Binary segmentation
+    if num_classes is None:
+        ground_truth = ground_truth.astype(bool)
+        prediction = prediction.astype(bool)
+
+        intersection = np.logical_and(ground_truth, prediction).sum()
+        union = np.logical_or(ground_truth, prediction).sum()
+
+        if union == 0:
+            return 1.0 if intersection == 0 else 0.0
+
+        iou = (intersection + smooth) / (union + smooth)
+        return float(iou)
+
+    # Multi-class segmentation
+    else:
+        iou_per_class = []
+
+        for class_idx in range(num_classes):
+            # Handle ignored class by appending np.nan
+            if ignore_index is not None and class_idx == ignore_index:
+                iou_per_class.append(np.nan)
+                continue
+
+            # Create binary masks for current class
+            gt_class = (ground_truth == class_idx).astype(bool)
+            pred_class = (prediction == class_idx).astype(bool)
+
+            intersection = np.logical_and(gt_class, pred_class).sum()
+            union = np.logical_or(gt_class, pred_class).sum()
+
+            if union == 0:
+                # If class is not present in both gt and pred
+                iou_per_class.append(np.nan)
+            else:
+                iou_per_class.append((intersection + smooth) / (union + smooth))
+
+        return np.array(iou_per_class)
+
+
+def calc_f1_score(
+    ground_truth: Union[str, np.ndarray, torch.Tensor],
+    prediction: Union[str, np.ndarray, torch.Tensor],
+    num_classes: Optional[int] = None,
+    ignore_index: Optional[int] = None,
+    smooth: float = 1e-6,
+    band: int = 1,
+) -> Union[float, np.ndarray]:
+    """
+    Calculate F1 score between ground truth and prediction masks.
+
+    The F1 score is the harmonic mean of precision and recall, computed as:
+    F1 = 2 * (precision * recall) / (precision + recall)
+    where precision = TP / (TP + FP) and recall = TP / (TP + FN).
+
+    This function supports both binary and multi-class segmentation, and can handle
+    numpy arrays, PyTorch tensors, or file paths to raster files.
+
+    Args:
+        ground_truth (Union[str, np.ndarray, torch.Tensor]): Ground truth segmentation mask.
+            Can be a file path (str) to a raster file, numpy array, or PyTorch tensor.
+            For binary segmentation: shape (H, W) with values {0, 1}.
+            For multi-class segmentation: shape (H, W) with class indices.
+        prediction (Union[str, np.ndarray, torch.Tensor]): Predicted segmentation mask.
+            Can be a file path (str) to a raster file, numpy array, or PyTorch tensor.
+            Should have the same shape and format as ground_truth.
+        num_classes (Optional[int], optional): Number of classes for multi-class segmentation.
+            If None, assumes binary segmentation. Defaults to None.
+        ignore_index (Optional[int], optional): Class index to ignore in computation.
+            Useful for ignoring background or unlabeled pixels. Defaults to None.
+        smooth (float, optional): Smoothing factor to avoid division by zero.
+            Defaults to 1e-6.
+        band (int, optional): Band index to read from raster file (1-based indexing).
+            Only used when input is a file path. Defaults to 1.
+
+    Returns:
+        Union[float, np.ndarray]: For binary segmentation, returns a single float F1 score.
+            For multi-class segmentation, returns an array of F1 scores for each class.
+
+    Examples:
+        >>> # Binary segmentation with arrays
+        >>> gt = np.array([[0, 0, 1, 1], [0, 1, 1, 1]])
+        >>> pred = np.array([[0, 0, 1, 1], [0, 0, 1, 1]])
+        >>> f1 = calc_f1_score(gt, pred)
+        >>> print(f"F1 Score: {f1:.4f}")
+        F1 Score: 0.8571
+
+        >>> # Multi-class segmentation
+        >>> gt = np.array([[0, 0, 1, 1], [0, 2, 2, 1]])
+        >>> pred = np.array([[0, 0, 1, 1], [0, 0, 2, 2]])
+        >>> f1 = calc_f1_score(gt, pred, num_classes=3)
+        >>> print(f"F1 Score per class: {f1}")
+        F1 Score per class: [0.8571 0.6667 0.6667]
+
+        >>> # Using PyTorch tensors
+        >>> gt_tensor = torch.tensor([[0, 0, 1, 1], [0, 1, 1, 1]])
+        >>> pred_tensor = torch.tensor([[0, 0, 1, 1], [0, 0, 1, 1]])
+        >>> f1 = calc_f1_score(gt_tensor, pred_tensor)
+        >>> print(f"F1 Score: {f1:.4f}")
+        F1 Score: 0.8571
+
+        >>> # Using raster file paths
+        >>> f1 = calc_f1_score("ground_truth.tif", "prediction.tif", num_classes=3)
+        >>> print(f"Mean F1: {np.nanmean(f1):.4f}")
+        Mean F1: 0.7302
+    """
+    # Load from file if string path is provided
+    if isinstance(ground_truth, str):
+        with rasterio.open(ground_truth) as src:
+            ground_truth = src.read(band)
+    if isinstance(prediction, str):
+        with rasterio.open(prediction) as src:
+            prediction = src.read(band)
+
+    # Convert to numpy if torch tensor
+    if isinstance(ground_truth, torch.Tensor):
+        ground_truth = ground_truth.cpu().numpy()
+    if isinstance(prediction, torch.Tensor):
+        prediction = prediction.cpu().numpy()
+
+    # Ensure inputs have the same shape
+    if ground_truth.shape != prediction.shape:
+        raise ValueError(
+            f"Shape mismatch: ground_truth {ground_truth.shape} vs prediction {prediction.shape}"
+        )
+
+    # Binary segmentation
+    if num_classes is None:
+        ground_truth = ground_truth.astype(bool)
+        prediction = prediction.astype(bool)
+
+        # Calculate True Positives, False Positives, False Negatives
+        tp = np.logical_and(ground_truth, prediction).sum()
+        fp = np.logical_and(~ground_truth, prediction).sum()
+        fn = np.logical_and(ground_truth, ~prediction).sum()
+
+        # Calculate precision and recall
+        precision = (tp + smooth) / (tp + fp + smooth)
+        recall = (tp + smooth) / (tp + fn + smooth)
+
+        # Calculate F1 score
+        f1 = 2 * (precision * recall) / (precision + recall + smooth)
+        return float(f1)
+
+    # Multi-class segmentation
+    else:
+        f1_per_class = []
+
+        for class_idx in range(num_classes):
+            # Mark ignored class with np.nan
+            if ignore_index is not None and class_idx == ignore_index:
+                f1_per_class.append(np.nan)
+                continue
+
+            # Create binary masks for current class
+            gt_class = (ground_truth == class_idx).astype(bool)
+            pred_class = (prediction == class_idx).astype(bool)
+
+            # Calculate True Positives, False Positives, False Negatives
+            tp = np.logical_and(gt_class, pred_class).sum()
+            fp = np.logical_and(~gt_class, pred_class).sum()
+            fn = np.logical_and(gt_class, ~pred_class).sum()
+
+            # Calculate precision and recall
+            precision = (tp + smooth) / (tp + fp + smooth)
+            recall = (tp + smooth) / (tp + fn + smooth)
+
+            # Calculate F1 score
+            if tp + fp + fn == 0:
+                # If class is not present in both gt and pred
+                f1_per_class.append(np.nan)
+            else:
+                f1 = 2 * (precision * recall) / (precision + recall + smooth)
+                f1_per_class.append(f1)
+
+        return np.array(f1_per_class)
+
+
+def calc_segmentation_metrics(
+    ground_truth: Union[str, np.ndarray, torch.Tensor],
+    prediction: Union[str, np.ndarray, torch.Tensor],
+    num_classes: Optional[int] = None,
+    ignore_index: Optional[int] = None,
+    smooth: float = 1e-6,
+    metrics: List[str] = ["iou", "f1"],
+    band: int = 1,
+) -> Dict[str, Union[float, np.ndarray]]:
+    """
+    Calculate multiple segmentation metrics between ground truth and prediction masks.
+
+    This is a convenient wrapper function that computes multiple metrics at once,
+    including IoU (Intersection over Union) and F1 score. It supports both binary
+    and multi-class segmentation, and can handle numpy arrays, PyTorch tensors,
+    or file paths to raster files.
+
+    Args:
+        ground_truth (Union[str, np.ndarray, torch.Tensor]): Ground truth segmentation mask.
+            Can be a file path (str) to a raster file, numpy array, or PyTorch tensor.
+            For binary segmentation: shape (H, W) with values {0, 1}.
+            For multi-class segmentation: shape (H, W) with class indices.
+        prediction (Union[str, np.ndarray, torch.Tensor]): Predicted segmentation mask.
+            Can be a file path (str) to a raster file, numpy array, or PyTorch tensor.
+            Should have the same shape and format as ground_truth.
+        num_classes (Optional[int], optional): Number of classes for multi-class segmentation.
+            If None, assumes binary segmentation. Defaults to None.
+        ignore_index (Optional[int], optional): Class index to ignore in computation.
+            Useful for ignoring background or unlabeled pixels. Defaults to None.
+        smooth (float, optional): Smoothing factor to avoid division by zero.
+            Defaults to 1e-6.
+        metrics (List[str], optional): List of metrics to calculate.
+            Options: "iou", "f1". Defaults to ["iou", "f1"].
+        band (int, optional): Band index to read from raster file (1-based indexing).
+            Only used when input is a file path. Defaults to 1.
+
+    Returns:
+        Dict[str, Union[float, np.ndarray]]: Dictionary containing the computed metrics.
+            Keys are metric names ("iou", "f1"), values are the metric scores.
+            For binary segmentation, values are floats.
+            For multi-class segmentation, values are numpy arrays with per-class scores.
+            Also includes "mean_iou" and "mean_f1" for multi-class segmentation
+            (mean computed over valid classes, ignoring NaN values).
+
+    Examples:
+        >>> # Binary segmentation with arrays
+        >>> gt = np.array([[0, 0, 1, 1], [0, 1, 1, 1]])
+        >>> pred = np.array([[0, 0, 1, 1], [0, 0, 1, 1]])
+        >>> metrics = calc_segmentation_metrics(gt, pred)
+        >>> print(f"IoU: {metrics['iou']:.4f}, F1: {metrics['f1']:.4f}")
+        IoU: 0.8333, F1: 0.8571
+
+        >>> # Multi-class segmentation
+        >>> gt = np.array([[0, 0, 1, 1], [0, 2, 2, 1]])
+        >>> pred = np.array([[0, 0, 1, 1], [0, 0, 2, 2]])
+        >>> metrics = calc_segmentation_metrics(gt, pred, num_classes=3)
+        >>> print(f"Mean IoU: {metrics['mean_iou']:.4f}")
+        >>> print(f"Mean F1: {metrics['mean_f1']:.4f}")
+        >>> print(f"Per-class IoU: {metrics['iou']}")
+        Mean IoU: 0.6111
+        Mean F1: 0.7302
+        Per-class IoU: [0.8333 0.5000 0.5000]
+
+        >>> # Calculate only IoU
+        >>> metrics = calc_segmentation_metrics(gt, pred, num_classes=3, metrics=["iou"])
+        >>> print(f"Mean IoU: {metrics['mean_iou']:.4f}")
+        Mean IoU: 0.6111
+
+        >>> # Using PyTorch tensors
+        >>> gt_tensor = torch.tensor([[0, 0, 1, 1], [0, 1, 1, 1]])
+        >>> pred_tensor = torch.tensor([[0, 0, 1, 1], [0, 0, 1, 1]])
+        >>> metrics = calc_segmentation_metrics(gt_tensor, pred_tensor)
+        >>> print(f"IoU: {metrics['iou']:.4f}, F1: {metrics['f1']:.4f}")
+        IoU: 0.8333, F1: 0.8571
+
+        >>> # Using raster file paths
+        >>> metrics = calc_segmentation_metrics("ground_truth.tif", "prediction.tif", num_classes=3)
+        >>> print(f"Mean IoU: {metrics['mean_iou']:.4f}")
+        >>> print(f"Mean F1: {metrics['mean_f1']:.4f}")
+        Mean IoU: 0.6111
+        Mean F1: 0.7302
+    """
+    results = {}
+
+    # Calculate IoU if requested
+    if "iou" in metrics:
+        iou = calc_iou(
+            ground_truth,
+            prediction,
+            num_classes=num_classes,
+            ignore_index=ignore_index,
+            smooth=smooth,
+            band=band,
+        )
+        results["iou"] = iou
+
+        # Add mean IoU for multi-class
+        if num_classes is not None and isinstance(iou, np.ndarray):
+            # Calculate mean ignoring NaN values
+            valid_ious = iou[~np.isnan(iou)]
+            results["mean_iou"] = (
+                float(np.mean(valid_ious)) if len(valid_ious) > 0 else 0.0
+            )
+
+    # Calculate F1 score if requested
+    if "f1" in metrics:
+        f1 = calc_f1_score(
+            ground_truth,
+            prediction,
+            num_classes=num_classes,
+            ignore_index=ignore_index,
+            smooth=smooth,
+            band=band,
+        )
+        results["f1"] = f1
+
+        # Add mean F1 for multi-class
+        if num_classes is not None and isinstance(f1, np.ndarray):
+            # Calculate mean ignoring NaN values
+            valid_f1s = f1[~np.isnan(f1)]
+            results["mean_f1"] = (
+                float(np.mean(valid_f1s)) if len(valid_f1s) > 0 else 0.0
+            )
+
+    return results
+
+
 def dict_to_rioxarray(data_dict: Dict) -> xr.DataArray:
     """Convert a dictionary to a xarray DataArray. The dictionary should contain the
     following keys: "crs", "bounds", and "image". It can be generated from a TorchGeo
@@ -2605,7 +2993,7 @@ def batch_vector_to_raster(
 def export_geotiff_tiles(
     in_raster,
     out_folder,
-    in_class_data,
+    in_class_data=None,
     tile_size=256,
     stride=128,
     class_value_field="class",
@@ -2623,7 +3011,8 @@ def export_geotiff_tiles(
     Args:
         in_raster (str): Path to input raster image
         out_folder (str): Path to output folder
-        in_class_data (str): Path to classification data - can be vector file or raster
+        in_class_data (str, optional): Path to classification data - can be vector file or raster.
+            If None, only image tiles will be exported without labels. Defaults to None.
         tile_size (int): Size of tiles in pixels (square)
         stride (int): Step size between tiles
         class_value_field (str): Field containing class values (for vector data)
@@ -2644,36 +3033,42 @@ def export_geotiff_tiles(
     os.makedirs(out_folder, exist_ok=True)
     image_dir = os.path.join(out_folder, "images")
     os.makedirs(image_dir, exist_ok=True)
-    label_dir = os.path.join(out_folder, "labels")
-    os.makedirs(label_dir, exist_ok=True)
 
-    # Create annotation directory based on metadata format
-    if metadata_format in ["PASCAL_VOC", "COCO"]:
-        ann_dir = os.path.join(out_folder, "annotations")
-        os.makedirs(ann_dir, exist_ok=True)
+    # Only create label and annotation directories if class data is provided
+    if in_class_data is not None:
+        label_dir = os.path.join(out_folder, "labels")
+        os.makedirs(label_dir, exist_ok=True)
 
-    # Initialize COCO annotations dictionary
-    if metadata_format == "COCO":
-        coco_annotations = {"images": [], "annotations": [], "categories": []}
-        ann_id = 0
+        # Create annotation directory based on metadata format
+        if metadata_format in ["PASCAL_VOC", "COCO"]:
+            ann_dir = os.path.join(out_folder, "annotations")
+            os.makedirs(ann_dir, exist_ok=True)
 
-    # Determine if class data is raster or vector
+        # Initialize COCO annotations dictionary
+        if metadata_format == "COCO":
+            coco_annotations = {"images": [], "annotations": [], "categories": []}
+            ann_id = 0
+
+    # Determine if class data is raster or vector (only if class data provided)
     is_class_data_raster = False
-    if isinstance(in_class_data, str):
-        file_ext = Path(in_class_data).suffix.lower()
-        # Common raster extensions
-        if file_ext in [".tif", ".tiff", ".img", ".jp2", ".png", ".bmp", ".gif"]:
-            try:
-                with rasterio.open(in_class_data) as src:
-                    is_class_data_raster = True
+    if in_class_data is not None:
+        if isinstance(in_class_data, str):
+            file_ext = Path(in_class_data).suffix.lower()
+            # Common raster extensions
+            if file_ext in [".tif", ".tiff", ".img", ".jp2", ".png", ".bmp", ".gif"]:
+                try:
+                    with rasterio.open(in_class_data) as src:
+                        is_class_data_raster = True
+                        if not quiet:
+                            print(f"Detected in_class_data as raster: {in_class_data}")
+                            print(f"Raster CRS: {src.crs}")
+                            print(f"Raster dimensions: {src.width} x {src.height}")
+                except Exception:
+                    is_class_data_raster = False
                     if not quiet:
-                        print(f"Detected in_class_data as raster: {in_class_data}")
-                        print(f"Raster CRS: {src.crs}")
-                        print(f"Raster dimensions: {src.width} x {src.height}")
-            except Exception:
-                is_class_data_raster = False
-                if not quiet:
-                    print(f"Unable to open {in_class_data} as raster, trying as vector")
+                        print(
+                            f"Unable to open {in_class_data} as raster, trying as vector"
+                        )
 
     # Open the input raster
     with rasterio.open(in_raster) as src:
@@ -2693,10 +3088,10 @@ def export_geotiff_tiles(
         if max_tiles is None:
             max_tiles = total_tiles
 
-        # Process classification data
+        # Process classification data (only if class data provided)
         class_to_id = {}
 
-        if is_class_data_raster:
+        if in_class_data is not None and is_class_data_raster:
             # Load raster class data
             with rasterio.open(in_class_data) as class_src:
                 # Check if raster CRS matches
@@ -2740,7 +3135,7 @@ def export_geotiff_tiles(
                                 "supercategory": "object",
                             }
                         )
-        else:
+        elif in_class_data is not None:
             # Load vector class data
             try:
                 gdf = gpd.read_file(in_class_data)
@@ -2862,8 +3257,8 @@ def export_geotiff_tiles(
                 label_mask = np.zeros((tile_size, tile_size), dtype=np.uint8)
                 has_features = False
 
-                # Process classification data to create labels
-                if is_class_data_raster:
+                # Process classification data to create labels (only if class data provided)
+                if in_class_data is not None and is_class_data_raster:
                     # For raster class data
                     with rasterio.open(in_class_data) as class_src:
                         # Calculate window in class raster
@@ -2913,7 +3308,7 @@ def export_geotiff_tiles(
                             except Exception as e:
                                 pbar.write(f"Error reading class raster window: {e}")
                                 stats["errors"] += 1
-                else:
+                elif in_class_data is not None:
                     # For vector class data
                     # Find features that intersect with window
                     window_features = gdf[gdf.intersects(window_bounds)]
@@ -2956,8 +3351,8 @@ def export_geotiff_tiles(
                                     pbar.write(f"Error rasterizing feature {idx}: {e}")
                                     stats["errors"] += 1
 
-                # Skip tile if no features and skip_empty_tiles is True
-                if skip_empty_tiles and not has_features:
+                # Skip tile if no features and skip_empty_tiles is True (only when class data provided)
+                if in_class_data is not None and skip_empty_tiles and not has_features:
                     pbar.update(1)
                     tile_index += 1
                     continue
@@ -2988,33 +3383,35 @@ def export_geotiff_tiles(
                     pbar.write(f"ERROR saving image GeoTIFF: {e}")
                     stats["errors"] += 1
 
-                # Create profile for label GeoTIFF
-                label_profile = {
-                    "driver": "GTiff",
-                    "height": tile_size,
-                    "width": tile_size,
-                    "count": 1,
-                    "dtype": "uint8",
-                    "crs": src.crs,
-                    "transform": window_transform,
-                }
+                # Export label as GeoTIFF (only if class data provided)
+                if in_class_data is not None:
+                    # Create profile for label GeoTIFF
+                    label_profile = {
+                        "driver": "GTiff",
+                        "height": tile_size,
+                        "width": tile_size,
+                        "count": 1,
+                        "dtype": "uint8",
+                        "crs": src.crs,
+                        "transform": window_transform,
+                    }
 
-                # Export label as GeoTIFF
-                label_path = os.path.join(label_dir, f"tile_{tile_index:06d}.tif")
-                try:
-                    with rasterio.open(label_path, "w", **label_profile) as dst:
-                        dst.write(label_mask.astype(np.uint8), 1)
+                    label_path = os.path.join(label_dir, f"tile_{tile_index:06d}.tif")
+                    try:
+                        with rasterio.open(label_path, "w", **label_profile) as dst:
+                            dst.write(label_mask.astype(np.uint8), 1)
 
-                    if has_features:
-                        stats["tiles_with_features"] += 1
-                        stats["feature_pixels"] += np.count_nonzero(label_mask)
-                except Exception as e:
-                    pbar.write(f"ERROR saving label GeoTIFF: {e}")
-                    stats["errors"] += 1
+                        if has_features:
+                            stats["tiles_with_features"] += 1
+                            stats["feature_pixels"] += np.count_nonzero(label_mask)
+                    except Exception as e:
+                        pbar.write(f"ERROR saving label GeoTIFF: {e}")
+                        stats["errors"] += 1
 
                 # Create annotations for object detection if using vector class data
                 if (
-                    not is_class_data_raster
+                    in_class_data is not None
+                    and not is_class_data_raster
                     and "gdf" in locals()
                     and len(window_features) > 0
                 ):
@@ -3209,8 +3606,8 @@ def export_geotiff_tiles(
         # Close progress bar
         pbar.close()
 
-        # Save COCO annotations if applicable
-        if metadata_format == "COCO":
+        # Save COCO annotations if applicable (only if class data provided)
+        if in_class_data is not None and metadata_format == "COCO":
             try:
                 with open(os.path.join(ann_dir, "instances.json"), "w") as f:
                     json.dump(coco_annotations, f, indent=2)
@@ -3225,8 +3622,8 @@ def export_geotiff_tiles(
                     print(f"ERROR saving COCO annotations: {e}")
                 stats["errors"] += 1
 
-        # Save YOLO classes file if applicable
-        if metadata_format == "YOLO":
+        # Save YOLO classes file if applicable (only if class data provided)
+        if in_class_data is not None and metadata_format == "YOLO":
             try:
                 # Create classes.txt with class names
                 classes_path = os.path.join(out_folder, "classes.txt")
@@ -3259,13 +3656,14 @@ def export_geotiff_tiles(
         if not quiet:
             print("\n------- Export Summary -------")
             print(f"Total tiles exported: {stats['total_tiles']}")
-            print(
-                f"Tiles with features: {stats['tiles_with_features']} ({stats['tiles_with_features']/max(1, stats['total_tiles'])*100:.1f}%)"
-            )
-            if stats["tiles_with_features"] > 0:
+            if in_class_data is not None:
                 print(
-                    f"Average feature pixels per tile: {stats['feature_pixels']/stats['tiles_with_features']:.1f}"
+                    f"Tiles with features: {stats['tiles_with_features']} ({stats['tiles_with_features']/max(1, stats['total_tiles'])*100:.1f}%)"
                 )
+                if stats["tiles_with_features"] > 0:
+                    print(
+                        f"Average feature pixels per tile: {stats['feature_pixels']/stats['tiles_with_features']:.1f}"
+                    )
             if stats["errors"] > 0:
                 print(f"Errors encountered: {stats['errors']}")
             print(f"Output saved to: {out_folder}")
@@ -3274,7 +3672,6 @@ def export_geotiff_tiles(
             if stats["total_tiles"] > 0:
                 print("\n------- Georeference Verification -------")
                 sample_image = os.path.join(image_dir, f"tile_0.tif")
-                sample_label = os.path.join(label_dir, f"tile_0.tif")
 
                 if os.path.exists(sample_image):
                     try:
@@ -3290,19 +3687,22 @@ def export_geotiff_tiles(
                     except Exception as e:
                         print(f"Error verifying image georeference: {e}")
 
-                if os.path.exists(sample_label):
-                    try:
-                        with rasterio.open(sample_label) as lbl:
-                            print(f"Label CRS: {lbl.crs}")
-                            print(f"Label transform: {lbl.transform}")
-                            print(
-                                f"Label has georeference: {lbl.crs is not None and lbl.transform is not None}"
-                            )
-                            print(
-                                f"Label dimensions: {lbl.width}x{lbl.height}, {lbl.count} bands, {lbl.dtypes[0]} type"
-                            )
-                    except Exception as e:
-                        print(f"Error verifying label georeference: {e}")
+                # Only verify label if class data was provided
+                if in_class_data is not None:
+                    sample_label = os.path.join(label_dir, f"tile_0.tif")
+                    if os.path.exists(sample_label):
+                        try:
+                            with rasterio.open(sample_label) as lbl:
+                                print(f"Label CRS: {lbl.crs}")
+                                print(f"Label transform: {lbl.transform}")
+                                print(
+                                    f"Label has georeference: {lbl.crs is not None and lbl.transform is not None}"
+                                )
+                                print(
+                                    f"Label dimensions: {lbl.width}x{lbl.height}, {lbl.count} bands, {lbl.dtypes[0]} type"
+                                )
+                        except Exception as e:
+                            print(f"Error verifying label georeference: {e}")
 
         # Return statistics dictionary for further processing if needed
         return stats
@@ -3323,33 +3723,38 @@ def export_geotiff_tiles_batch(
     skip_empty_tiles=False,
     image_extensions=None,
     mask_extensions=None,
-    match_by_name=True,
+    match_by_name=False,
     metadata_format="PASCAL_VOC",
 ) -> Dict[str, Any]:
     """
-    Export georeferenced GeoTIFF tiles from images and masks.
+    Export georeferenced GeoTIFF tiles from images and optionally masks.
+
+    This function supports four modes:
+    1. Images only (no masks) - when neither masks_file nor masks_folder is provided
+    2. Single vector file covering all images (masks_file parameter)
+    3. Multiple vector files, one per image (masks_folder parameter)
+    4. Multiple raster mask files (masks_folder parameter)
 
-    This function supports three mask input modes:
-    1. Single vector file covering all images (masks_file parameter)
-    2. Multiple vector files, one per image (masks_folder parameter)
-    3. Multiple raster mask files (masks_folder parameter)
+    For mode 1 (images only), only image tiles will be exported without labels.
 
-    For mode 1 (single vector file), specify masks_file path. The function will
+    For mode 2 (single vector file), specify masks_file path. The function will
     use spatial intersection to determine which features apply to each image.
 
-    For mode 2/3 (multiple mask files), specify masks_folder path. Images and masks
+    For mode 3/4 (multiple mask files), specify masks_folder path. Images and masks
     are paired either by matching filenames (match_by_name=True) or by sorted order
     (match_by_name=False).
 
-    All image tiles are saved to a single 'images' folder and all mask tiles to a
-    single 'masks' folder within the output directory.
+    All image tiles are saved to a single 'images' folder and all mask tiles (if provided)
+    to a single 'masks' folder within the output directory.
 
     Args:
         images_folder (str): Path to folder containing raster images
         masks_folder (str, optional): Path to folder containing classification masks/vectors.
-            Use this for multiple mask files (one per image or raster masks).
+            Use this for multiple mask files (one per image or raster masks). If not provided
+            and masks_file is also not provided, only image tiles will be exported.
         masks_file (str, optional): Path to a single vector file covering all images.
-            Use this for a single GeoJSON/Shapefile that covers multiple images.
+            Use this for a single GeoJSON/Shapefile that covers multiple images. If not provided
+            and masks_folder is also not provided, only image tiles will be exported.
         output_folder (str, optional): Path to output folder. If None, creates 'tiles'
             subfolder in images_folder.
         tile_size (int): Size of tiles in pixels (square)
@@ -3373,10 +3778,15 @@ def export_geotiff_tiles_batch(
 
     Raises:
         ValueError: If no images found, or if masks_folder and masks_file are both specified,
-            or if neither is specified, or if counts don't match when using masks_folder with
-            match_by_name=False.
+            or if counts don't match when using masks_folder with match_by_name=False.
 
     Examples:
+        # Images only (no masks)
+        >>> stats = export_geotiff_tiles_batch(
+        ...     images_folder='data/images',
+        ...     output_folder='output/tiles'
+        ... )
+
         # Single vector file covering all images
         >>> stats = export_geotiff_tiles_batch(
         ...     images_folder='data/images',
@@ -3411,11 +3821,6 @@ def export_geotiff_tiles_batch(
             "Cannot specify both masks_folder and masks_file. Please use only one."
         )
 
-    if masks_folder is None and masks_file is None:
-        raise ValueError(
-            "Must specify either masks_folder or masks_file for mask data source."
-        )
-
     # Default output folder if not specified
     if output_folder is None:
         output_folder = os.path.join(images_folder, "tiles")
@@ -3446,22 +3851,37 @@ def export_geotiff_tiles_batch(
     # Create output folder structure
     os.makedirs(output_folder, exist_ok=True)
     output_images_dir = os.path.join(output_folder, "images")
-    output_masks_dir = os.path.join(output_folder, "masks")
     os.makedirs(output_images_dir, exist_ok=True)
-    os.makedirs(output_masks_dir, exist_ok=True)
 
-    # Create annotation directory based on metadata format
-    if metadata_format in ["PASCAL_VOC", "COCO"]:
+    # Only create masks directory if masks are provided
+    output_masks_dir = None
+    if masks_folder is not None or masks_file is not None:
+        output_masks_dir = os.path.join(output_folder, "masks")
+        os.makedirs(output_masks_dir, exist_ok=True)
+
+    # Create annotation directory based on metadata format (only if masks are provided)
+    ann_dir = None
+    if (masks_folder is not None or masks_file is not None) and metadata_format in [
+        "PASCAL_VOC",
+        "COCO",
+    ]:
         ann_dir = os.path.join(output_folder, "annotations")
         os.makedirs(ann_dir, exist_ok=True)
 
-    # Initialize COCO annotations dictionary
+    # Initialize COCO annotations dictionary (only if masks are provided)
     coco_annotations = None
-    if metadata_format == "COCO":
+    if (
+        masks_folder is not None or masks_file is not None
+    ) and metadata_format == "COCO":
         coco_annotations = {"images": [], "annotations": [], "categories": []}
 
-    # Initialize YOLO class set
-    yolo_classes = set() if metadata_format == "YOLO" else None
+    # Initialize YOLO class set (only if masks are provided)
+    yolo_classes = (
+        set()
+        if (masks_folder is not None or masks_file is not None)
+        and metadata_format == "YOLO"
+        else None
+    )
 
     # Get list of image files
     image_files = []
@@ -3479,10 +3899,16 @@ def export_geotiff_tiles_batch(
 
     # Handle different mask input modes
     use_single_mask_file = masks_file is not None
+    has_masks = masks_file is not None or masks_folder is not None
     mask_files = []
     image_mask_pairs = []
 
-    if use_single_mask_file:
+    if not has_masks:
+        # Mode 0: No masks - create pairs with None for mask
+        for image_file in image_files:
+            image_mask_pairs.append((image_file, None, None))
+
+    elif use_single_mask_file:
         # Mode 1: Single vector file covering all images
         if not os.path.exists(masks_file):
             raise ValueError(f"Mask file not found: {masks_file}")
@@ -3534,10 +3960,21 @@ def export_geotiff_tiles_batch(
                         print(f"Warning: No mask found for image {img_base}")
 
             if not image_mask_pairs:
-                raise ValueError(
+                # Provide detailed error message with found files
+                image_bases = list(image_dict.keys())
+                mask_bases = list(mask_dict.keys())
+                error_msg = (
                     "No matching image-mask pairs found when matching by filename. "
-                    "Check that image and mask files have matching base names."
+                    "Check that image and mask files have matching base names.\n"
+                    f"Found {len(image_bases)} image(s): "
+                    f"{', '.join(image_bases[:5]) if image_bases else 'None found'}"
+                    f"{'...' if len(image_bases) > 5 else ''}\n"
+                    f"Found {len(mask_bases)} mask(s): "
+                    f"{', '.join(mask_bases[:5]) if mask_bases else 'None found'}"
+                    f"{'...' if len(mask_bases) > 5 else ''}\n"
+                    "Tip: Set match_by_name=False to match by sorted order, or ensure filenames match."
                 )
+                raise ValueError(error_msg)
 
         else:
             # Match by sorted order
@@ -3564,7 +4001,11 @@ def export_geotiff_tiles_batch(
     }
 
     if not quiet:
-        if use_single_mask_file:
+        if not has_masks:
+            print(
+                f"Found {len(image_files)} image files to process (images only, no masks)"
+            )
+        elif use_single_mask_file:
             print(f"Found {len(image_files)} image files to process")
             print(f"Using single mask file: {masks_file}")
         else:
@@ -3593,10 +4034,15 @@ def export_geotiff_tiles_batch(
             if not quiet:
                 print(f"\nProcessing: {base_name}")
                 print(f"  Image: {os.path.basename(image_file)}")
-                if use_single_mask_file:
-                    print(f"  Mask: {os.path.basename(mask_file)} (spatially filtered)")
+                if mask_file is not None:
+                    if use_single_mask_file:
+                        print(
+                            f"  Mask: {os.path.basename(mask_file)} (spatially filtered)"
+                        )
+                    else:
+                        print(f"  Mask: {os.path.basename(mask_file)}")
                 else:
-                    print(f"  Mask: {os.path.basename(mask_file)}")
+                    print(f"  Mask: None (images only)")
 
             # Process the image-mask pair
             tiles_generated = _process_image_mask_pair(
@@ -3718,11 +4164,12 @@ def export_geotiff_tiles_batch(
 
         print(f"Output saved to: {output_folder}")
         print(f"  Images: {output_images_dir}")
-        print(f"  Masks: {output_masks_dir}")
-        if metadata_format in ["PASCAL_VOC", "COCO"]:
-            print(f"  Annotations: {ann_dir}")
-        elif metadata_format == "YOLO":
-            print(f"  Labels: {os.path.join(output_folder, 'labels')}")
+        if output_masks_dir is not None:
+            print(f"  Masks: {output_masks_dir}")
+            if metadata_format in ["PASCAL_VOC", "COCO"] and ann_dir is not None:
+                print(f"  Annotations: {ann_dir}")
+            elif metadata_format == "YOLO":
+                print(f"  Labels: {os.path.join(output_folder, 'labels')}")
 
         # List failed files if any
         if batch_stats["failed_files"]:
@@ -3765,9 +4212,9 @@ def _process_image_mask_pair(
     """
     import warnings
 
-    # Determine if mask data is raster or vector
+    # Determine if mask data is raster or vector (only if mask_file is provided)
     is_class_data_raster = False
-    if isinstance(mask_file, str):
+    if mask_file is not None and isinstance(mask_file, str):
         file_ext = Path(mask_file).suffix.lower()
         # Common raster extensions
         if file_ext in [".tif", ".tiff", ".img", ".jp2", ".png", ".bmp", ".gif"]:
@@ -3801,10 +4248,10 @@ def _process_image_mask_pair(
         if max_tiles is None:
             max_tiles = total_tiles
 
-        # Process classification data
+        # Process classification data (only if mask_file is provided)
         class_to_id = {}
 
-        if is_class_data_raster:
+        if mask_file is not None and is_class_data_raster:
             # Load raster class data
             with rasterio.open(mask_file) as class_src:
                 # Check if raster CRS matches
@@ -3831,7 +4278,7 @@ def _process_image_mask_pair(
 
                 # Create class mapping
                 class_to_id = {int(cls): i + 1 for i, cls in enumerate(unique_classes)}
-        else:
+        elif mask_file is not None:
             # Load vector class data
             try:
                 if use_single_mask_file and mask_gdf is not None:
@@ -3907,12 +4354,12 @@ def _process_image_mask_pair(
 
                 window_bounds = box(minx, miny, maxx, maxy)
 
-                # Create label mask
+                # Create label mask (only if mask_file is provided)
                 label_mask = np.zeros((tile_size, tile_size), dtype=np.uint8)
                 has_features = False
 
-                # Process classification data to create labels
-                if is_class_data_raster:
+                # Process classification data to create labels (only if mask_file is provided)
+                if mask_file is not None and is_class_data_raster:
                     # For raster class data
                     with rasterio.open(mask_file) as class_src:
                         # Get corresponding window in class raster
@@ -3945,7 +4392,7 @@ def _process_image_mask_pair(
                             if not quiet:
                                 print(f"Error reading class raster window: {e}")
                             stats["errors"] += 1
-                else:
+                elif mask_file is not None:
                     # For vector class data
                     # Find features that intersect with window
                     window_features = gdf[gdf.intersects(window_bounds)]
@@ -3983,8 +4430,8 @@ def _process_image_mask_pair(
                                         print(f"Error rasterizing feature {idx}: {e}")
                                     stats["errors"] += 1
 
-                # Skip tile if no features and skip_empty_tiles is True
-                if skip_empty_tiles and not has_features:
+                # Skip tile if no features and skip_empty_tiles is True (only applies when masks are provided)
+                if mask_file is not None and skip_empty_tiles and not has_features:
                     continue
 
                 # Check if we've reached max_tiles before saving
@@ -4021,32 +4468,37 @@ def _process_image_mask_pair(
                         print(f"ERROR saving image GeoTIFF: {e}")
                     stats["errors"] += 1
 
-                # Create profile for label GeoTIFF
-                label_profile = {
-                    "driver": "GTiff",
-                    "height": tile_size,
-                    "width": tile_size,
-                    "count": 1,
-                    "dtype": "uint8",
-                    "crs": src.crs,
-                    "transform": window_transform,
-                }
+                # Export label as GeoTIFF (only if mask_file and output_masks_dir are provided)
+                if mask_file is not None and output_masks_dir is not None:
+                    # Create profile for label GeoTIFF
+                    label_profile = {
+                        "driver": "GTiff",
+                        "height": tile_size,
+                        "width": tile_size,
+                        "count": 1,
+                        "dtype": "uint8",
+                        "crs": src.crs,
+                        "transform": window_transform,
+                    }
 
-                # Export label as GeoTIFF
-                label_path = os.path.join(output_masks_dir, f"{tile_name}.tif")
-                try:
-                    with rasterio.open(label_path, "w", **label_profile) as dst:
-                        dst.write(label_mask.astype(np.uint8), 1)
+                    label_path = os.path.join(output_masks_dir, f"{tile_name}.tif")
+                    try:
+                        with rasterio.open(label_path, "w", **label_profile) as dst:
+                            dst.write(label_mask.astype(np.uint8), 1)
 
-                    if has_features:
-                        stats["tiles_with_features"] += 1
-                except Exception as e:
-                    if not quiet:
-                        print(f"ERROR saving label GeoTIFF: {e}")
-                    stats["errors"] += 1
+                        if has_features:
+                            stats["tiles_with_features"] += 1
+                    except Exception as e:
+                        if not quiet:
+                            print(f"ERROR saving label GeoTIFF: {e}")
+                        stats["errors"] += 1
 
-                # Generate annotation metadata based on format
-                if metadata_format == "PASCAL_VOC" and ann_dir:
+                # Generate annotation metadata based on format (only if mask_file is provided)
+                if (
+                    mask_file is not None
+                    and metadata_format == "PASCAL_VOC"
+                    and ann_dir
+                ):
                     # Create PASCAL VOC XML annotation
                     from lxml import etree as ET
 
@@ -4108,7 +4560,7 @@ def _process_image_mask_pair(
                     tree = ET.ElementTree(annotation)
                     tree.write(xml_path, pretty_print=True, encoding="utf-8")
 
-                elif metadata_format == "COCO":
+                elif mask_file is not None and metadata_format == "COCO":
                     # Add COCO image entry
                     image_id = int(global_tile_counter + tile_index)
                     stats["coco_data"]["images"].append(
@@ -4188,7 +4640,7 @@ def _process_image_mask_pair(
                                 )
                                 coco_ann_id += 1
 
-                elif metadata_format == "YOLO":
+                elif mask_file is not None and metadata_format == "YOLO":
                     # Create YOLO labels directory if needed
                     labels_dir = os.path.join(
                         os.path.dirname(output_images_dir), "labels"
@@ -8313,17 +8765,39 @@ def write_colormap(
 
 def plot_performance_metrics(
     history_path: str,
-    figsize: Tuple[int, int] = (15, 5),
+    figsize: Optional[Tuple[int, int]] = None,
     verbose: bool = True,
     save_path: Optional[str] = None,
+    csv_path: Optional[str] = None,
     kwargs: Optional[Dict] = None,
-) -> None:
-    """Plot performance metrics from a history object.
+) -> pd.DataFrame:
+    """Plot performance metrics from a training history object and return as DataFrame.
+
+    This function loads training history, plots available metrics (loss, IoU, F1,
+    precision, recall), optionally exports to CSV, and returns all metrics as a
+    pandas DataFrame for further analysis.
 
     Args:
-        history_path: The history object to plot.
-        figsize: The figure size.
-        verbose: Whether to print the best and final metrics.
+        history_path (str): Path to the saved training history (.pth file).
+        figsize (Optional[Tuple[int, int]]): Figure size in inches. If None,
+            automatically determined based on number of metrics.
+        verbose (bool): Whether to print best and final metric values. Defaults to True.
+        save_path (Optional[str]): Path to save the plot image. If None, plot is not saved.
+        csv_path (Optional[str]): Path to export metrics as CSV. If None, CSV is not exported.
+        kwargs (Optional[Dict]): Additional keyword arguments for plt.savefig().
+
+    Returns:
+        pd.DataFrame: DataFrame containing all metrics with columns for epoch and each metric.
+            Columns include: 'epoch', 'train_loss', 'val_loss', 'val_iou', 'val_f1',
+            'val_precision', 'val_recall' (depending on availability in history).
+
+    Example:
+        >>> df = plot_performance_metrics(
+        ...     'training_history.pth',
+        ...     save_path='metrics_plot.png',
+        ...     csv_path='metrics.csv'
+        ... )
+        >>> print(df.head())
     """
     if kwargs is None:
         kwargs = {}
@@ -8333,65 +8807,135 @@ def plot_performance_metrics(
     train_loss_key = "train_losses" if "train_losses" in history else "train_loss"
     val_loss_key = "val_losses" if "val_losses" in history else "val_loss"
     val_iou_key = "val_ious" if "val_ious" in history else "val_iou"
-    val_dice_key = "val_dices" if "val_dices" in history else "val_dice"
+    # Support both new (f1) and old (dice) key formats for backward compatibility
+    val_f1_key = (
+        "val_f1s"
+        if "val_f1s" in history
+        else ("val_dices" if "val_dices" in history else "val_dice")
+    )
+    # Add support for precision and recall
+    val_precision_key = (
+        "val_precisions" if "val_precisions" in history else "val_precision"
+    )
+    val_recall_key = "val_recalls" if "val_recalls" in history else "val_recall"
+
+    # Collect available metrics for plotting
+    available_metrics = []
+    metric_info = {
+        "Loss": (train_loss_key, val_loss_key, ["Train Loss", "Val Loss"]),
+        "IoU": (val_iou_key, None, ["Val IoU"]),
+        "F1": (val_f1_key, None, ["Val F1"]),
+        "Precision": (val_precision_key, None, ["Val Precision"]),
+        "Recall": (val_recall_key, None, ["Val Recall"]),
+    }
+
+    for metric_name, (key1, key2, labels) in metric_info.items():
+        if key1 in history or (key2 and key2 in history):
+            available_metrics.append((metric_name, key1, key2, labels))
 
-    # Determine number of subplots based on available metrics
-    has_dice = val_dice_key in history
-    n_plots = 3 if has_dice else 2
-    figsize = (15, 5) if has_dice else (10, 5)
+    # Determine number of subplots and figure size
+    n_plots = len(available_metrics)
+    if figsize is None:
+        figsize = (5 * n_plots, 5)
 
-    plt.figure(figsize=figsize)
+    # Create DataFrame for all metrics
+    n_epochs = 0
+    df_data = {}
 
-    # Plot loss
-    plt.subplot(1, n_plots, 1)
+    # Add epochs
+    if "epochs" in history:
+        df_data["epoch"] = history["epochs"]
+        n_epochs = len(history["epochs"])
+    elif train_loss_key in history:
+        n_epochs = len(history[train_loss_key])
+        df_data["epoch"] = list(range(1, n_epochs + 1))
+
+    # Add all available metrics to DataFrame
     if train_loss_key in history:
-        plt.plot(history[train_loss_key], label="Train Loss")
+        df_data["train_loss"] = history[train_loss_key]
     if val_loss_key in history:
-        plt.plot(history[val_loss_key], label="Val Loss")
-    plt.title("Loss")
-    plt.xlabel("Epoch")
-    plt.ylabel("Loss")
-    plt.legend()
-    plt.grid(True)
-
-    # Plot IoU
-    plt.subplot(1, n_plots, 2)
+        df_data["val_loss"] = history[val_loss_key]
     if val_iou_key in history:
-        plt.plot(history[val_iou_key], label="Val IoU")
-    plt.title("IoU Score")
-    plt.xlabel("Epoch")
-    plt.ylabel("IoU")
-    plt.legend()
-    plt.grid(True)
-
-    # Plot Dice if available
-    if has_dice:
-        plt.subplot(1, n_plots, 3)
-        plt.plot(history[val_dice_key], label="Val Dice")
-        plt.title("Dice Score")
-        plt.xlabel("Epoch")
-        plt.ylabel("Dice")
-        plt.legend()
-        plt.grid(True)
+        df_data["val_iou"] = history[val_iou_key]
+    if val_f1_key in history:
+        df_data["val_f1"] = history[val_f1_key]
+    if val_precision_key in history:
+        df_data["val_precision"] = history[val_precision_key]
+    if val_recall_key in history:
+        df_data["val_recall"] = history[val_recall_key]
+
+    # Create DataFrame
+    df = pd.DataFrame(df_data)
+
+    # Export to CSV if requested
+    if csv_path:
+        df.to_csv(csv_path, index=False)
+        if verbose:
+            print(f"Metrics exported to: {csv_path}")
+
+    # Create plots
+    if n_plots > 0:
+        fig, axes = plt.subplots(1, n_plots, figsize=figsize)
+        if n_plots == 1:
+            axes = [axes]
+
+        for idx, (metric_name, key1, key2, labels) in enumerate(available_metrics):
+            ax = axes[idx]
+
+            if metric_name == "Loss":
+                # Special handling for loss (has both train and val)
+                if key1 in history:
+                    ax.plot(history[key1], label=labels[0])
+                if key2 and key2 in history:
+                    ax.plot(history[key2], label=labels[1])
+            else:
+                # Single metric plots
+                if key1 in history:
+                    ax.plot(history[key1], label=labels[0])
 
-    plt.tight_layout()
+            ax.set_title(metric_name)
+            ax.set_xlabel("Epoch")
+            ax.set_ylabel(metric_name)
+            ax.legend()
+            ax.grid(True)
 
-    if save_path:
-        if "dpi" not in kwargs:
-            kwargs["dpi"] = 150
-        if "bbox_inches" not in kwargs:
-            kwargs["bbox_inches"] = "tight"
-        plt.savefig(save_path, **kwargs)
+        plt.tight_layout()
 
-    plt.show()
+        if save_path:
+            if "dpi" not in kwargs:
+                kwargs["dpi"] = 150
+            if "bbox_inches" not in kwargs:
+                kwargs["bbox_inches"] = "tight"
+            plt.savefig(save_path, **kwargs)
 
+        plt.show()
+
+    # Print summary statistics
     if verbose:
+        print("\n=== Performance Metrics Summary ===")
         if val_iou_key in history:
-            print(f"Best IoU: {max(history[val_iou_key]):.4f}")
-            print(f"Final IoU: {history[val_iou_key][-1]:.4f}")
-        if val_dice_key in history:
-            print(f"Best Dice: {max(history[val_dice_key]):.4f}")
-            print(f"Final Dice: {history[val_dice_key][-1]:.4f}")
+            print(
+                f"IoU     - Best: {max(history[val_iou_key]):.4f} | Final: {history[val_iou_key][-1]:.4f}"
+            )
+        if val_f1_key in history:
+            print(
+                f"F1      - Best: {max(history[val_f1_key]):.4f} | Final: {history[val_f1_key][-1]:.4f}"
+            )
+        if val_precision_key in history:
+            print(
+                f"Precision - Best: {max(history[val_precision_key]):.4f} | Final: {history[val_precision_key][-1]:.4f}"
+            )
+        if val_recall_key in history:
+            print(
+                f"Recall  - Best: {max(history[val_recall_key]):.4f} | Final: {history[val_recall_key][-1]:.4f}"
+            )
+        if val_loss_key in history:
+            print(
+                f"Val Loss - Best: {min(history[val_loss_key]):.4f} | Final: {history[val_loss_key][-1]:.4f}"
+            )
+        print("===================================\n")
+
+    return df
 
 
 def get_device() -> torch.device: