dragon-ml-toolbox 14.3.1__py3-none-any.whl → 14.8.0__py3-none-any.whl

ml_tools/ML_vision_datasetmaster.py

@@ -273,8 +273,8 @@ class VisionDatasetMaker(_BaseMaker):
                                for validation/testing.
             crop_size (int): The target size (square) for the final
                              cropped image.
-            mean (List[float]): The mean values for normalization (e.g., ImageNet mean).
-            std (List[float]): The standard deviation values for normalization (e.g., ImageNet std).
+            mean (List[float] | None): The mean values for normalization (e.g., ImageNet mean).
+            std (List[float] | None): The standard deviation values for normalization (e.g., ImageNet std).
             extra_train_transforms (List[Callable] | None): A list of additional torchvision transforms to add to the end of the training transformations.
             pre_transforms (List[Callable] | None): An list of transforms to be applied at the very beginning of the transformations for all sets.
 
@@ -499,6 +499,39 @@ class VisionDatasetMaker(_BaseMaker):
         
         return self.class_map
     
+    def images_per_dataset(self) -> str:
+        """
+        Get the number of images per dataset as a string.
+        """
+        if self._is_split:
+            train_len = len(self._train_dataset) if self._train_dataset else 0
+            val_len = len(self._val_dataset) if self._val_dataset else 0
+            test_len = len(self._test_dataset) if self._test_dataset else 0
+            return f"Train | Validation | Test: {train_len} | {val_len} | {test_len} images\n"
+        elif self._full_dataset:
+            return f"Full Dataset: {len(self._full_dataset)} images\n"
+        else:
+            _LOGGER.warning("No datasets found.")
+            return "No datasets found\n"   
+    
+    def __repr__(self) -> str:
+        s = f"<{self.__class__.__name__}>:\n"
+        s += f"  Split: {self._is_split}\n"
+        s += f"  Transforms Configured: {self._are_transforms_configured}\n"
+        
+        if self.class_map:
+            s += f"  Classes: {len(self.class_map)}\n"
+
+        if self._is_split:
+            train_len = len(self._train_dataset) if self._train_dataset else 0
+            val_len = len(self._val_dataset) if self._val_dataset else 0
+            test_len = len(self._test_dataset) if self._test_dataset else 0
+            s += f"  Datasets (Train|Val|Test): {train_len} | {val_len} | {test_len}\n"
+        elif self._full_dataset:
+            s += f"  Full Dataset Size: {len(self._full_dataset)} images\n"
+            
+        return s
+    
 
 class _DatasetTransformer(Dataset):
     """
@@ -686,6 +719,7 @@ class SegmentationDatasetMaker(_BaseMaker):
         self._are_transforms_configured = False
         self.train_transform: Optional[Callable] = None
         self.val_transform: Optional[Callable] = None
+        self._has_mean_std: bool = False
 
     @classmethod
     def from_folders(cls, image_dir: Union[str, Path], mask_dir: Union[str, Path]) -> 'SegmentationDatasetMaker':
@@ -849,8 +883,8 @@ class SegmentationDatasetMaker(_BaseMaker):
     def configure_transforms(self, 
                              resize_size: int = 256, 
                              crop_size: int = 224, 
-                             mean: List[float] = [0.485, 0.456, 0.406], 
-                             std: List[float] = [0.229, 0.224, 0.225]) -> 'SegmentationDatasetMaker':
+                             mean: Optional[List[float]] = [0.485, 0.456, 0.406], 
+                             std: Optional[List[float]] = [0.229, 0.224, 0.225]) -> 'SegmentationDatasetMaker':
         """
         Configures and applies the image and mask transformations.
         
@@ -861,8 +895,8 @@ class SegmentationDatasetMaker(_BaseMaker):
                                for validation/testing.
             crop_size (int): The target size (square) for the final
                              cropped image.
-            mean (List[float]): The mean values for image normalization.
-            std (List[float]): The std dev values for image normalization.
+            mean (List[float] | None): The mean values for image normalization.
+            std (List[float] | None): The std dev values for image normalization.
 
         Returns:
             SegmentationDatasetMaker: The same instance, with transforms applied.
@@ -871,29 +905,50 @@ class SegmentationDatasetMaker(_BaseMaker):
             _LOGGER.error("Transforms must be configured AFTER splitting data. Call .split_data() first.")
             raise RuntimeError()
         
+        if (mean is None and std is not None) or (mean is not None and std is None):
+            _LOGGER.error(f"'mean' and 'std' must be both None or both defined, but only one was provided.")
+            raise ValueError()
+        
         # --- Store components for validation recipe ---
-        self.val_recipe_components = {
+        self.val_recipe_components: dict[str,Any] = {
             VisionTransformRecipeKeys.RESIZE_SIZE: resize_size,
             VisionTransformRecipeKeys.CROP_SIZE: crop_size,
-            VisionTransformRecipeKeys.MEAN: mean,
-            VisionTransformRecipeKeys.STD: std
         }
+    
+        if mean is not None and std is not None:
+            self.val_recipe_components.update({
+                VisionTransformRecipeKeys.MEAN: mean,
+                VisionTransformRecipeKeys.STD: std
+            })
+            self._has_mean_std = True
 
         # --- Validation/Test Pipeline (Deterministic) ---
-        self.val_transform = _PairedCompose([
-            _PairedResize(resize_size),
-            _PairedCenterCrop(crop_size),
-            _PairedToTensor(),
-            _PairedNormalize(mean, std)
-        ])
-        
-        # --- Training Pipeline (Augmentation) ---
-        self.train_transform = _PairedCompose([
-            _PairedRandomResizedCrop(crop_size),
-            _PairedRandomHorizontalFlip(p=0.5),
-            _PairedToTensor(),
-            _PairedNormalize(mean, std)
-        ])
+        if self._has_mean_std:
+            self.val_transform = _PairedCompose([
+                _PairedResize(resize_size),
+                _PairedCenterCrop(crop_size),
+                _PairedToTensor(),
+                _PairedNormalize(mean, std) # type: ignore
+            ])
+            # --- Training Pipeline (Augmentation) ---
+            self.train_transform = _PairedCompose([
+                _PairedRandomResizedCrop(crop_size),
+                _PairedRandomHorizontalFlip(p=0.5),
+                _PairedToTensor(),
+                _PairedNormalize(mean, std) # type: ignore
+            ])
+        else:
+            self.val_transform = _PairedCompose([
+                _PairedResize(resize_size),
+                _PairedCenterCrop(crop_size),
+                _PairedToTensor()
+            ])
+            # --- Training Pipeline (Augmentation) ---
+            self.train_transform = _PairedCompose([
+                _PairedRandomResizedCrop(crop_size),
+                _PairedRandomHorizontalFlip(p=0.5),
+                _PairedToTensor()
+            ])
 
         # --- Apply Transforms to the Datasets ---
         self._train_dataset.transform = self.train_transform # type: ignore
@@ -946,23 +1001,57 @@ class SegmentationDatasetMaker(_BaseMaker):
         
         # validate path
         file_path = make_fullpath(filepath, make=True, enforce="file")
-
+        
         # Add standard transforms
         recipe: Dict[str, Any] = {
             VisionTransformRecipeKeys.TASK: "segmentation",
             VisionTransformRecipeKeys.PIPELINE: [
-                {VisionTransformRecipeKeys.NAME: "Resize", "kwargs": {"size": components["resize_size"]}},
-                {VisionTransformRecipeKeys.NAME: "CenterCrop", "kwargs": {"size": components["crop_size"]}},
-                {VisionTransformRecipeKeys.NAME: "ToTensor", "kwargs": {}},
-                {VisionTransformRecipeKeys.NAME: "Normalize", "kwargs": {
-                    "mean": components["mean"],
-                    "std": components["std"]
-                }}
+                {VisionTransformRecipeKeys.NAME: "Resize", "kwargs": {"size": components[VisionTransformRecipeKeys.RESIZE_SIZE]}},
+                {VisionTransformRecipeKeys.NAME: "CenterCrop", "kwargs": {"size": components[VisionTransformRecipeKeys.CROP_SIZE]}},
+                {VisionTransformRecipeKeys.NAME: "ToTensor", "kwargs": {}}
             ]
         }
         
+        if self._has_mean_std:
+            recipe[VisionTransformRecipeKeys.PIPELINE].append(
+                {VisionTransformRecipeKeys.NAME: "Normalize", "kwargs": {
+                    "mean": components[VisionTransformRecipeKeys.MEAN],
+                    "std": components[VisionTransformRecipeKeys.STD]
+                }}
+            )
+        
         # Save the file
         save_recipe(recipe, file_path)
+        
+    def images_per_dataset(self) -> str:
+        """
+        Get the number of images per dataset as a string.
+        """
+        if self._is_split:
+            train_len = len(self._train_dataset) if self._train_dataset else 0
+            val_len = len(self._val_dataset) if self._val_dataset else 0
+            test_len = len(self._test_dataset) if self._test_dataset else 0
+            return f"Train | Validation | Test: {train_len} | {val_len} | {test_len} images\n"
+        else:
+            _LOGGER.warning("No datasets found.")
+            return "No datasets found\n"   
+        
+    def __repr__(self) -> str:
+        s = f"<{self.__class__.__name__}>:\n"
+        s += f"  Total Image-Mask Pairs: {len(self.image_paths)}\n"
+        s += f"  Split: {self._is_split}\n"
+        s += f"  Transforms Configured: {self._are_transforms_configured}\n"
+        
+        if self.class_map:
+            s += f"  Classes: {list(self.class_map.keys())}\n"
+
+        if self._is_split:
+            train_len = len(self._train_dataset) if self._train_dataset else 0
+            val_len = len(self._val_dataset) if self._val_dataset else 0
+            test_len = len(self._test_dataset) if self._test_dataset else 0
+            s += f"  Datasets (Train|Val|Test): {train_len} | {val_len} | {test_len}\n"
+            
+        return s
 
 
 # Object detection
@@ -1114,6 +1203,7 @@ class ObjectDetectionDatasetMaker(_BaseMaker):
         self.train_transform: Optional[Callable] = None
         self.val_transform: Optional[Callable] = None
         self._val_recipe_components: Optional[Dict[str, Any]] = None
+        self._has_mean_std: bool = False
 
     @classmethod
     def from_folders(cls, image_dir: Union[str, Path], annotation_dir: Union[str, Path]) -> 'ObjectDetectionDatasetMaker':
@@ -1273,8 +1363,8 @@ class ObjectDetectionDatasetMaker(_BaseMaker):
         return self
 
     def configure_transforms(self, 
-                             mean: List[float] = [0.485, 0.456, 0.406], 
-                             std: List[float] = [0.229, 0.224, 0.225]) -> 'ObjectDetectionDatasetMaker':
+                             mean: Optional[List[float]] = [0.485, 0.456, 0.406], 
+                             std: Optional[List[float]] = [0.229, 0.224, 0.225]) -> 'ObjectDetectionDatasetMaker':
         """
         Configures and applies the image and target transformations.
         
@@ -1285,8 +1375,8 @@ class ObjectDetectionDatasetMaker(_BaseMaker):
         Transforms are limited to augmentation (flip), ToTensor, and Normalize.
 
         Args:
-            mean (List[float]): The mean values for image normalization.
-            std (List[float]): The std dev values for image normalization.
+            mean (List[float] | None): The mean values for image normalization.
+            std (List[float] | None): The std dev values for image normalization.
 
         Returns:
             ObjectDetectionDatasetMaker: The same instance, with transforms applied.
@@ -1295,24 +1385,42 @@ class ObjectDetectionDatasetMaker(_BaseMaker):
             _LOGGER.error("Transforms must be configured AFTER splitting data. Call .split_data() first.")
             raise RuntimeError()
         
-        # --- Store components for validation recipe ---
-        self._val_recipe_components = {
-            VisionTransformRecipeKeys.MEAN: mean,
-            VisionTransformRecipeKeys.STD: std
-        }
-
-        # --- Validation/Test Pipeline (Deterministic) ---
-        self.val_transform = _OD_PairedCompose([
-            _OD_PairedToTensor(),
-            _OD_PairedNormalize(mean, std)
-        ])
+        if (mean is None and std is not None) or (mean is not None and std is None):
+            _LOGGER.error(f"'mean' and 'std' must be both None or both defined, but only one was provided.")
+            raise ValueError()
         
-        # --- Training Pipeline (Augmentation) ---
-        self.train_transform = _OD_PairedCompose([
-            _OD_PairedRandomHorizontalFlip(p=0.5),
-            _OD_PairedToTensor(),
-            _OD_PairedNormalize(mean, std)
-        ])
+        if mean is not None and std is not None:
+            # --- Store components for validation recipe ---
+            self._val_recipe_components = {
+                VisionTransformRecipeKeys.MEAN: mean,
+                VisionTransformRecipeKeys.STD: std
+            }
+            self._has_mean_std = True
+            
+        if self._has_mean_std:
+            # --- Validation/Test Pipeline (Deterministic) ---
+            self.val_transform = _OD_PairedCompose([
+                _OD_PairedToTensor(),
+                _OD_PairedNormalize(mean, std) # type: ignore
+            ])
+            
+            # --- Training Pipeline (Augmentation) ---
+            self.train_transform = _OD_PairedCompose([
+                _OD_PairedRandomHorizontalFlip(p=0.5),
+                _OD_PairedToTensor(),
+                _OD_PairedNormalize(mean, std) # type: ignore
+            ])
+        else:
+            # --- Validation/Test Pipeline (Deterministic) ---
+            self.val_transform = _OD_PairedCompose([
+                _OD_PairedToTensor()
+            ])
+            
+            # --- Training Pipeline (Augmentation) ---
+            self.train_transform = _OD_PairedCompose([
+                _OD_PairedRandomHorizontalFlip(p=0.5),
+                _OD_PairedToTensor()
+            ])
 
         # --- Apply Transforms to the Datasets ---
         self._train_dataset.transform = self.train_transform # type: ignore
@@ -1368,10 +1476,6 @@ class ObjectDetectionDatasetMaker(_BaseMaker):
         
         components = self._val_recipe_components
         
-        if not components:
-            _LOGGER.error(f"Error getting the transformers recipe for validation set.")
-            raise ValueError()
-        
         # validate path
         file_path = make_fullpath(filepath, make=True, enforce="file")
 
@@ -1380,15 +1484,49 @@ class ObjectDetectionDatasetMaker(_BaseMaker):
             VisionTransformRecipeKeys.TASK: "object_detection",
             VisionTransformRecipeKeys.PIPELINE: [
                 {VisionTransformRecipeKeys.NAME: "ToTensor", "kwargs": {}},
-                {VisionTransformRecipeKeys.NAME: "Normalize", "kwargs": {
-                    "mean": components["mean"],
-                    "std": components["std"]
-                }}
             ]
         }
         
+        if self._has_mean_std and components:
+            recipe[VisionTransformRecipeKeys.PIPELINE].append(
+                {VisionTransformRecipeKeys.NAME: "Normalize", "kwargs": {
+                    "mean": components[VisionTransformRecipeKeys.MEAN],
+                    "std": components[VisionTransformRecipeKeys.STD]
+                }}
+            )
+        
         # Save the file
         save_recipe(recipe, file_path)
+    
+    def images_per_dataset(self) -> str:
+        """
+        Get the number of images per dataset as a string.
+        """
+        if self._is_split:
+            train_len = len(self._train_dataset) if self._train_dataset else 0
+            val_len = len(self._val_dataset) if self._val_dataset else 0
+            test_len = len(self._test_dataset) if self._test_dataset else 0
+            return f"Train | Validation | Test: {train_len} | {val_len} | {test_len} images\n"
+        else:
+            _LOGGER.warning("No datasets found.")
+            return "No datasets found\n"
+
+    def __repr__(self) -> str:
+        s = f"<{self.__class__.__name__}>:\n"
+        s += f"  Total Image-Annotation Pairs: {len(self.image_paths)}\n"
+        s += f"  Split: {self._is_split}\n"
+        s += f"  Transforms Configured: {self._are_transforms_configured}\n"
+        
+        if self.class_map:
+            s += f"  Classes ({len(self.class_map)}): {list(self.class_map.keys())}\n"
+
+        if self._is_split:
+            train_len = len(self._train_dataset) if self._train_dataset else 0
+            val_len = len(self._val_dataset) if self._val_dataset else 0
+            test_len = len(self._test_dataset) if self._test_dataset else 0
+            s += f"  Datasets (Train|Val|Test): {train_len} | {val_len} | {test_len}\n"
+            
+        return s
 
 
 def info():

ml_tools/ML_vision_models.py

@@ -47,12 +47,17 @@ class _BaseVisionWrapper(nn.Module, _ArchitectureHandlerMixin, ABC):
         self.num_classes = num_classes
         self.in_channels = in_channels
         self.model_name = model_name
+        self._pretrained_default_transforms = None
 
         # --- 2. Instantiate the base model ---
         if init_with_pretrained:
             weights_enum = getattr(vision_models, weights_enum_name, None) if weights_enum_name else None
             weights = weights_enum.IMAGENET1K_V1 if weights_enum else None
             
+            # Save transformations for pretrained models
+            if weights:
+                self._pretrained_default_transforms = weights.transforms()
+            
             if weights is None and init_with_pretrained:
                  _LOGGER.warning(f"Could not find modern weights for {model_name}. Using 'pretrained=True' legacy fallback.")
                  self.model = getattr(vision_models, model_name)(pretrained=True)
@@ -331,6 +336,7 @@ class _BaseSegmentationWrapper(nn.Module, _ArchitectureHandlerMixin, ABC):
         self.num_classes = num_classes
         self.in_channels = in_channels
         self.model_name = model_name
+        self._pretrained_default_transforms = None
 
         # --- 2. Instantiate the base model ---
         model_kwargs = {
@@ -343,6 +349,10 @@ class _BaseSegmentationWrapper(nn.Module, _ArchitectureHandlerMixin, ABC):
             weights_enum = getattr(vision_models.segmentation, weights_enum_name, None) if weights_enum_name else None
             weights = weights_enum.DEFAULT if weights_enum else None
             
+            # save pretrained model transformations
+            if weights:
+                self._pretrained_default_transforms = weights.transforms()
+            
             if weights is None:
                  _LOGGER.warning(f"Could not find modern weights for {model_name}. Using 'pretrained=True' legacy fallback.")
                  # Legacy models used 'pretrained=True' and num_classes was separate
@@ -520,7 +530,7 @@ class DragonFastRCNN(nn.Module, _ArchitectureHandlerMixin):
     This wrapper allows for customizing the model backbone, input channels,
     and the number of output classes for transfer learning.
 
-    NOTE: This model is NOT compatible with the MLTrainer class.
+    NOTE: This model is NOT compatible with the MLTrainer class. Use the ObjectDetectionTrainer instead.
     """
     def __init__(self,
                  num_classes: int,
@@ -550,6 +560,7 @@ class DragonFastRCNN(nn.Module, _ArchitectureHandlerMixin):
         self.num_classes = num_classes
         self.in_channels = in_channels
         self.model_name = model_name
+        self._pretrained_default_transforms = None
 
         # --- 2. Instantiate the base model ---
         model_constructor = getattr(detection_models, model_name)
@@ -560,6 +571,9 @@ class DragonFastRCNN(nn.Module, _ArchitectureHandlerMixin):
         
         weights_enum = getattr(detection_models, weights_enum_name, None) if weights_enum_name else None
         weights = weights_enum.DEFAULT if weights_enum and init_with_pretrained else None
+        
+        if weights:
+            self._pretrained_default_transforms = weights.transforms()
 
         self.model = model_constructor(weights=weights, weights_backbone=weights)
         

ml_tools/ML_vision_transformers.py

@@ -1,14 +1,18 @@
-from typing import Union, Dict, Type, Callable
+from typing import Union, Dict, Type, Callable, Optional, Any, List, Literal
 from PIL import ImageOps, Image
+from torchvision import transforms
+from pathlib import Path
 
 from ._logger import _LOGGER
 from ._script_info import _script_info
 from .keys import VisionTransformRecipeKeys
+from .path_manager import make_fullpath
 
 
 __all__ = [
     "TRANSFORM_REGISTRY",
-    "ResizeAspectFill"
+    "ResizeAspectFill",
+    "create_offline_augmentations"
 ]
 
 # --- Custom Vision Transform Class ---
@@ -23,9 +27,8 @@ class ResizeAspectFill:
     """
     def __init__(self, pad_color: Union[str, int] = "black") -> None:
         self.pad_color = pad_color
-        # Store kwargs to allow for recreation
+        # Store kwargs to allow for re-creation
         self.__setattr__(VisionTransformRecipeKeys.KWARGS, {"pad_color": pad_color})
-        # self._kwargs = {"pad_color": pad_color}
 
     def __call__(self, image: Image.Image) -> Image.Image:
         if not isinstance(image, Image.Image):
@@ -47,12 +50,154 @@ class ResizeAspectFill:
             padding = (left_padding, 0, right_padding, 0)
 
         return ImageOps.expand(image, padding, fill=self.pad_color)
-    
 
-#NOTE: Add custom transforms here.
+
+#NOTE: Add custom transforms.
 TRANSFORM_REGISTRY: Dict[str, Type[Callable]] = {
     "ResizeAspectFill": ResizeAspectFill,
 }
 
+
+def _build_transform_from_recipe(recipe: Dict[str, Any]) -> transforms.Compose:
+    """Internal helper to build a transform pipeline from a recipe dict."""
+    pipeline_steps: List[Callable] = []
+    
+    if VisionTransformRecipeKeys.PIPELINE not in recipe:
+        _LOGGER.error("Recipe dict is invalid: missing 'pipeline' key.")
+        raise ValueError("Invalid recipe format.")
+
+    for step in recipe[VisionTransformRecipeKeys.PIPELINE]:
+        t_name = step.get(VisionTransformRecipeKeys.NAME)
+        t_kwargs = step.get(VisionTransformRecipeKeys.KWARGS, {})
+        
+        if not t_name:
+            _LOGGER.error(f"Invalid transform step, missing 'name': {step}")
+            continue
+        
+        transform_class: Any = None
+
+        # 1. Check standard torchvision transforms
+        if hasattr(transforms, t_name):
+            transform_class = getattr(transforms, t_name)
+        # 2. Check custom transforms
+        elif t_name in TRANSFORM_REGISTRY:
+            transform_class = TRANSFORM_REGISTRY[t_name]
+        # 3. Not found
+        else:
+            _LOGGER.error(f"Unknown transform '{t_name}' in recipe. Not found in torchvision.transforms or TRANSFORM_REGISTRY.")
+            raise ValueError(f"Unknown transform name: {t_name}")
+            
+        # Instantiate the transform
+        try:
+            pipeline_steps.append(transform_class(**t_kwargs))
+        except Exception as e:
+            _LOGGER.error(f"Failed to instantiate transform '{t_name}' with kwargs {t_kwargs}: {e}")
+            raise
+            
+    return transforms.Compose(pipeline_steps)
+
+
+def create_offline_augmentations(
+    input_directory: Union[str, Path],
+    output_directory: Union[str, Path],
+    results_per_image: int,
+    recipe: Optional[Dict[str, Any]] = None,
+    save_format: Literal["WEBP", "JPEG", "PNG", "BMP", "TIF"] = "WEBP",
+    save_quality: int = 80
+) -> None:
+    """
+    Reads all valid images from an input directory, applies augmentations,
+    and saves the new images to an output directory (offline augmentation).
+
+    Skips subdirectories in the input path.
+
+    Args:
+        input_directory (Union[str, Path]): Path to the directory of source images.
+        output_directory (Union[str, Path]): Path to save the augmented images.
+        results_per_image (int): The number of augmented versions to create
+                                 for each source image.
+        recipe (Optional[Dict[str, Any]]): A transform recipe dictionary. If None,
+                                           a default set of strong, random
+                                           augmentations will be used.
+        save_format (str): The format to save images (e.g., "WEBP", "JPEG", "PNG").
+                           Defaults to "WEBP" for good compression.
+        save_quality (int): The quality for lossy formats (1-100). Defaults to 80.
+    """
+    VALID_IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.bmp', '.webp', '.tif', '.tiff')
+    
+    # --- 1. Validate Paths ---
+    in_path = make_fullpath(input_directory, enforce="directory")
+    out_path = make_fullpath(output_directory, make=True, enforce="directory")
+    
+    _LOGGER.info(f"Starting offline augmentation:\n\tInput: {in_path}\n\tOutput: {out_path}")
+
+    # --- 2. Find Images ---
+    image_files = [
+        f for f in in_path.iterdir()
+        if f.is_file() and f.suffix.lower() in VALID_IMG_EXTENSIONS
+    ]
+    
+    if not image_files:
+        _LOGGER.warning(f"No valid image files found in {in_path}.")
+        return
+
+    _LOGGER.info(f"Found {len(image_files)} images to process.")
+
+    # --- 3. Define Transform Pipeline ---
+    transform_pipeline: transforms.Compose
+    
+    if recipe:
+        _LOGGER.info("Building transformations from provided recipe.")
+        try:
+            transform_pipeline = _build_transform_from_recipe(recipe)
+        except Exception as e:
+            _LOGGER.error(f"Failed to build transform from recipe: {e}")
+            return
+    else:
+        _LOGGER.info("No recipe provided. Using default random augmentation pipeline.")
+        # Default "random" pipeline
+        transform_pipeline = transforms.Compose([
+            transforms.RandomResizedCrop(256, scale=(0.4, 1.0)),
+            transforms.RandomHorizontalFlip(p=0.5),
+            transforms.RandomRotation(degrees=90),
+            transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.15),
+            transforms.RandomPerspective(distortion_scale=0.2, p=0.4),
+            transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
+            transforms.RandomApply([
+                transforms.GaussianBlur(kernel_size=3)
+            ], p=0.3)
+        ])
+
+    # --- 4. Process Images ---
+    total_saved = 0
+    format_upper = save_format.upper()
+    
+    for img_path in image_files:
+        _LOGGER.debug(f"Processing {img_path.name}...")
+        try:
+            original_image = Image.open(img_path).convert("RGB")
+            
+            for i in range(results_per_image):
+                new_stem = f"{img_path.stem}_aug_{i+1:03d}"
+                output_path = out_path / f"{new_stem}.{format_upper.lower()}"
+                
+                # Apply transform
+                transformed_image = transform_pipeline(original_image)
+                
+                # Save
+                transformed_image.save(
+                    output_path, 
+                    format=format_upper, 
+                    quality=save_quality,
+                    optimize=True # Add optimize flag
+                )
+                total_saved += 1
+                
+        except Exception as e:
+            _LOGGER.warning(f"Failed to process or save augmentations for {img_path.name}: {e}")
+
+    _LOGGER.info(f"Offline augmentation complete. Saved {total_saved} new images.")
+
+
 def info():
     _script_info(__all__)