dragon-ml-toolbox 19.14.0__py3-none-any.whl → 20.0.0__py3-none-any.whl

ml_tools/{_core/_ML_vision_datasetmaster.py → ML_datasetmaster/_vision_datasetmaster.py}

@@ -2,7 +2,7 @@ import torch
 from torch.utils.data import Dataset, Subset
 import numpy
 from sklearn.model_selection import train_test_split
-from typing import Union, Tuple, List, Optional, Callable, Dict, Any
+from typing import Union, Optional, Callable, Any
 from PIL import Image
 from torchvision.datasets import ImageFolder
 from torchvision import transforms
@@ -12,15 +12,15 @@ import random
 import json
 import inspect
 
-from ._ML_vision_transformers import TRANSFORM_REGISTRY, _save_recipe
-from ._path_manager import make_fullpath
-from ._logger import get_logger
-from ._script_info import _script_info
-from ._keys import VisionTransformRecipeKeys, ObjectDetectionKeys
-from ._IO_tools import custom_logger
+from ..ML_vision_transformers._core_transforms import TRANSFORM_REGISTRY, _save_recipe
+from ..IO_tools import save_json
 
+from ..path_manager import make_fullpath
+from .._core import get_logger
+from ..keys._keys import VisionTransformRecipeKeys, ObjectDetectionKeys
 
-_LOGGER = get_logger("DragonDataset")
+
+_LOGGER = get_logger("DragonVisionDataset")
 
 
 __all__ = [
@@ -50,7 +50,7 @@ class DragonDatasetVision:
         self._test_dataset = None
         self._val_dataset = None
         self._full_dataset: Optional[ImageFolder] = None
-        self.labels: Optional[List[int]] = None
+        self.labels: Optional[list[int]] = None
         self.class_map: dict[str,int] = dict()
         
         self._is_split = False
@@ -255,10 +255,10 @@ class DragonDatasetVision:
     def configure_transforms(self, 
                              resize_size: int = 256, 
                              crop_size: Optional[int] = 224, 
-                             mean: Optional[List[float]] = [0.485, 0.456, 0.406], 
-                             std: Optional[List[float]] = [0.229, 0.224, 0.225],
-                             pre_transforms: Optional[List[Callable]] = None,
-                             extra_train_transforms: Optional[List[Callable]] = None) -> 'DragonDatasetVision':
+                             mean: Optional[list[float]] = [0.485, 0.456, 0.406], 
+                             std: Optional[list[float]] = [0.229, 0.224, 0.225],
+                             pre_transforms: Optional[list[Callable]] = None,
+                             extra_train_transforms: Optional[list[Callable]] = None) -> 'DragonDatasetVision':
         """
         Configures and applies the image transformations and augmentations.
         
@@ -368,7 +368,7 @@ class DragonDatasetVision:
         _LOGGER.info("Image transforms configured and applied.")
         return self
 
-    def get_datasets(self) -> Tuple[Dataset, ...]:
+    def get_datasets(self) -> tuple[Dataset, ...]:
         """
         Returns the final train, validation, and optional test datasets.
         
@@ -407,7 +407,7 @@ class DragonDatasetVision:
             _LOGGER.error("Transforms are not configured. Call .configure_transforms() first.")
             raise RuntimeError()
 
-        recipe: Dict[str, Any] = {
+        recipe: dict[str, Any] = {
             VisionTransformRecipeKeys.TASK: "classification",
             VisionTransformRecipeKeys.PIPELINE: []
         }
@@ -500,11 +500,12 @@ class DragonDatasetVision:
             _LOGGER.error(f"Class to index mapping is empty.")
             raise ValueError()
         
-        custom_logger(data=self.class_map,
-                      save_directory=save_dir,
-                      log_name="Class_to_Index",
-                      add_timestamp=False,
-                      dict_as="json")
+        save_json(data=self.class_map,
+                  directory=save_dir,
+                  filename="Class_to_Index",
+                  verbose=False)
+        
+        _LOGGER.info(f"Class to index mapping saved to {save_dir}.")
         
         return self.class_map
     
@@ -606,13 +607,13 @@ class _SegmentationDataset(Dataset):
     
     Loads images as RGB and masks as 'L' (grayscale, 8-bit integer pixels).
     """
-    def __init__(self, image_paths: List[Path], mask_paths: List[Path], transform: Optional[Callable] = None):
+    def __init__(self, image_paths: list[Path], mask_paths: list[Path], transform: Optional[Callable] = None):
         self.image_paths = image_paths
         self.mask_paths = mask_paths
         self.transform = transform
         
         # --- Propagate 'classes' if they exist for trainer ---
-        self.classes: List[str] = []
+        self.classes: list[str] = []
 
     def __len__(self):
         return len(self.image_paths)
@@ -639,17 +640,17 @@ class _SegmentationDataset(Dataset):
 # Internal Paired Transform Helpers
 class _PairedCompose:
     """A 'Compose' for paired image/mask transforms."""
-    def __init__(self, transforms: List[Callable]):
+    def __init__(self, transforms: list[Callable]):
         self.transforms = transforms
 
-    def __call__(self, image: Any, mask: Any) -> Tuple[Any, Any]:
+    def __call__(self, image: Any, mask: Any) -> tuple[Any, Any]:
         for t in self.transforms:
             image, mask = t(image, mask)
         return image, mask
 
 class _PairedToTensor:
     """Converts a PIL Image pair (image, mask) to Tensors."""
-    def __call__(self, image: Image.Image, mask: Image.Image) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, image: Image.Image, mask: Image.Image) -> tuple[torch.Tensor, torch.Tensor]:
         # Use new variable names to satisfy the linter
         image_tensor = TF.to_tensor(image)
         # Convert mask to LongTensor, not float.
@@ -659,10 +660,10 @@ class _PairedToTensor:
 
 class _PairedNormalize:
     """Normalizes the image tensor and leaves the mask untouched."""
-    def __init__(self, mean: List[float], std: List[float]):
+    def __init__(self, mean: list[float], std: list[float]):
         self.normalize = transforms.Normalize(mean, std)
     
-    def __call__(self, image: torch.Tensor, mask: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    def __call__(self, image: torch.Tensor, mask: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         image = self.normalize(image)
         return image, mask
 
@@ -671,7 +672,7 @@ class _PairedResize:
     def __init__(self, size: int):
         self.size = [size, size]
     
-    def __call__(self, image: Image.Image, mask: Image.Image) -> Tuple[Image.Image, Image.Image]:
+    def __call__(self, image: Image.Image, mask: Image.Image) -> tuple[Image.Image, Image.Image]:
         # Use new variable names to avoid linter confusion
         resized_image = TF.resize(image, self.size, interpolation=TF.InterpolationMode.BILINEAR) # type: ignore
         # Use NEAREST for mask to avoid interpolating class IDs (e.g., 1.5)
@@ -683,7 +684,7 @@ class _PairedCenterCrop:
     def __init__(self, size: int):
         self.size = [size, size]
     
-    def __call__(self, image: Image.Image, mask: Image.Image) -> Tuple[Image.Image, Image.Image]:
+    def __call__(self, image: Image.Image, mask: Image.Image) -> tuple[Image.Image, Image.Image]:
         cropped_image = TF.center_crop(image, self.size) # type: ignore
         cropped_mask = TF.center_crop(mask, self.size) # type: ignore
         return cropped_image, cropped_mask # type: ignore
@@ -693,7 +694,7 @@ class _PairedRandomHorizontalFlip:
     def __init__(self, p: float = 0.5):
         self.p = p
     
-    def __call__(self, image: Image.Image, mask: Image.Image) -> Tuple[Image.Image, Image.Image]:
+    def __call__(self, image: Image.Image, mask: Image.Image) -> tuple[Image.Image, Image.Image]:
         if random.random() < self.p:
             flipped_image = TF.hflip(image) # type: ignore
             flipped_mask = TF.hflip(mask) # type: ignore
@@ -701,14 +702,14 @@ class _PairedRandomHorizontalFlip:
         
 class _PairedRandomResizedCrop:
     """Applies the same random resized crop to both image and mask."""
-    def __init__(self, size: int, scale: Tuple[float, float]=(0.08, 1.0), ratio: Tuple[float, float]=(3./4., 4./3.)):
+    def __init__(self, size: int, scale: tuple[float, float]=(0.08, 1.0), ratio: tuple[float, float]=(3./4., 4./3.)):
         self.size = [size, size]
         self.scale = scale
         self.ratio = ratio
         self.interpolation = TF.InterpolationMode.BILINEAR
         self.mask_interpolation = TF.InterpolationMode.NEAREST
 
-    def __call__(self, image: Image.Image, mask: Image.Image) -> Tuple[Image.Image, Image.Image]:
+    def __call__(self, image: Image.Image, mask: Image.Image) -> tuple[Image.Image, Image.Image]:
         # Get parameters for the random crop
         # Convert scale/ratio tuples to lists to satisfy the linter's type hint
         i, j, h, w = transforms.RandomResizedCrop.get_params(image, list(self.scale), list(self.ratio)) # type: ignore
@@ -744,9 +745,9 @@ class DragonDatasetSegmentation:
         self._train_dataset = None
         self._test_dataset = None
         self._val_dataset = None
-        self.image_paths: List[Path] = []
-        self.mask_paths: List[Path] = []
-        self.class_map: Dict[str, int] = {}
+        self.image_paths: list[Path] = []
+        self.mask_paths: list[Path] = []
+        self.class_map: dict[str, int] = {}
         
         self._is_split = False
         self._are_transforms_configured = False
@@ -830,12 +831,12 @@ class DragonDatasetSegmentation:
         """
         DragonDatasetVision.inspect_folder(path)
 
-    def set_class_map(self, class_map: Dict[str, int]) -> 'DragonDatasetSegmentation':
+    def set_class_map(self, class_map: dict[str, int]) -> 'DragonDatasetSegmentation':
         """
         Sets a map of class_name -> pixel value. This is used by the Trainer for clear evaluation reports.
 
         Args:
-            class_map (Dict[str, int]): A dictionary mapping the integer pixel
+            class_map (dict[str, int]): A dictionary mapping the integer pixel
                 value in a mask to its string name.
                 Example: {'background': 0, 'road': 1, 'car': 2}
         """
@@ -844,7 +845,7 @@ class DragonDatasetSegmentation:
         return self
     
     @property
-    def classes(self) -> List[str]:
+    def classes(self) -> list[str]:
         """Returns the list of class names, if set."""
         if self.class_map:
             return list(self.class_map.keys())
@@ -916,8 +917,8 @@ class DragonDatasetSegmentation:
     def configure_transforms(self, 
                              resize_size: int = 256, 
                              crop_size: int = 224, 
-                             mean: Optional[List[float]] = [0.485, 0.456, 0.406], 
-                             std: Optional[List[float]] = [0.229, 0.224, 0.225]) -> 'DragonDatasetSegmentation':
+                             mean: Optional[list[float]] = [0.485, 0.456, 0.406], 
+                             std: Optional[list[float]] = [0.229, 0.224, 0.225]) -> 'DragonDatasetSegmentation':
         """
         Configures and applies the image and mask transformations.
         
@@ -993,7 +994,7 @@ class DragonDatasetSegmentation:
         _LOGGER.info("Paired segmentation transforms configured and applied.")
         return self
 
-    def get_datasets(self) -> Tuple[Dataset, ...]:
+    def get_datasets(self) -> tuple[Dataset, ...]:
         """
         Returns the final train, validation, and optional test datasets.
         
@@ -1036,7 +1037,7 @@ class DragonDatasetSegmentation:
         file_path = make_fullpath(filepath, make=True, enforce="file")
         
         # Add standard transforms
-        recipe: Dict[str, Any] = {
+        recipe: dict[str, Any] = {
             VisionTransformRecipeKeys.TASK: "segmentation",
             VisionTransformRecipeKeys.PIPELINE: [
                 {VisionTransformRecipeKeys.NAME: "Resize", "kwargs": {"size": components[VisionTransformRecipeKeys.RESIZE_SIZE]}},
@@ -1109,7 +1110,7 @@ class DragonDatasetSegmentation:
 
 
 # Object detection
-def _od_collate_fn(batch: List[Tuple[torch.Tensor, Dict[str, torch.Tensor]]]) -> Tuple[List[torch.Tensor], List[Dict[str, torch.Tensor]]]:
+def _od_collate_fn(batch: list[tuple[torch.Tensor, dict[str, torch.Tensor]]]) -> tuple[list[torch.Tensor], list[dict[str, torch.Tensor]]]:
     """
     Custom collate function for object detection.
     
@@ -1128,13 +1129,13 @@ class _ObjectDetectionDataset(Dataset):
     Loads an image as 'RGB' and parses its corresponding JSON annotation file
     to create the required target dictionary (boxes, labels).
     """
-    def __init__(self, image_paths: List[Path], annotation_paths: List[Path], transform: Optional[Callable] = None):
+    def __init__(self, image_paths: list[Path], annotation_paths: list[Path], transform: Optional[Callable] = None):
         self.image_paths = image_paths
         self.annotation_paths = annotation_paths
         self.transform = transform
         
         # --- Propagate 'classes' if they exist ---
-        self.classes: List[str] = []
+        self.classes: list[str] = []
 
     def __len__(self):
         return len(self.image_paths)
@@ -1156,7 +1157,7 @@ class _ObjectDetectionDataset(Dataset):
             labels = ann_data[ObjectDetectionKeys.LABELS] # Expected: [1, 2, 1, ...]
             
             # Convert to tensors
-            target: Dict[str, Any] = {}
+            target: dict[str, Any] = {}
             target[ObjectDetectionKeys.BOXES] = torch.as_tensor(boxes, dtype=torch.float32)
             target[ObjectDetectionKeys.LABELS] = torch.as_tensor(labels, dtype=torch.int64)
             
@@ -1173,25 +1174,25 @@ class _ObjectDetectionDataset(Dataset):
 # Internal Paired Transform Helpers for Object Detection
 class _OD_PairedCompose:
     """A 'Compose' for paired image/target_dict transforms."""
-    def __init__(self, transforms: List[Callable]):
+    def __init__(self, transforms: list[Callable]):
         self.transforms = transforms
 
-    def __call__(self, image: Any, target: Any) -> Tuple[Any, Any]:
+    def __call__(self, image: Any, target: Any) -> tuple[Any, Any]:
         for t in self.transforms:
             image, target = t(image, target)
         return image, target
 
 class _OD_PairedToTensor:
     """Converts a PIL Image to Tensor, passes targets dict through."""
-    def __call__(self, image: Image.Image, target: Dict[str, Any]) -> Tuple[torch.Tensor, Dict[str, Any]]:
+    def __call__(self, image: Image.Image, target: dict[str, Any]) -> tuple[torch.Tensor, dict[str, Any]]:
         return TF.to_tensor(image), target
 
 class _OD_PairedNormalize:
     """Normalizes the image tensor and leaves the target dict untouched."""
-    def __init__(self, mean: List[float], std: List[float]):
+    def __init__(self, mean: list[float], std: list[float]):
         self.normalize = transforms.Normalize(mean, std)
     
-    def __call__(self, image: torch.Tensor, target: Dict[str, Any]) -> Tuple[torch.Tensor, Dict[str, Any]]:
+    def __call__(self, image: torch.Tensor, target: dict[str, Any]) -> tuple[torch.Tensor, dict[str, Any]]:
         image_normalized = self.normalize(image)
         return image_normalized, target
 
@@ -1200,7 +1201,7 @@ class _OD_PairedRandomHorizontalFlip:
     def __init__(self, p: float = 0.5):
         self.p = p
     
-    def __call__(self, image: Image.Image, target: Dict[str, Any]) -> Tuple[Image.Image, Dict[str, Any]]:
+    def __call__(self, image: Image.Image, target: dict[str, Any]) -> tuple[Image.Image, dict[str, Any]]:
         if random.random() < self.p:
             w, h = image.size
             # Use new variable names to avoid linter confusion
@@ -1250,15 +1251,15 @@ class DragonDatasetObjectDetection:
         self._train_dataset = None
         self._test_dataset = None
         self._val_dataset = None
-        self.image_paths: List[Path] = []
-        self.annotation_paths: List[Path] = []
-        self.class_map: Dict[str, int] = {}
+        self.image_paths: list[Path] = []
+        self.annotation_paths: list[Path] = []
+        self.class_map: dict[str, int] = {}
         
         self._is_split = False
         self._are_transforms_configured = False
         self.train_transform: Optional[Callable] = None
         self.val_transform: Optional[Callable] = None
-        self._val_recipe_components: Optional[Dict[str, Any]] = None
+        self._val_recipe_components: Optional[dict[str, Any]] = None
         self._has_mean_std: bool = False
 
     @classmethod
@@ -1328,7 +1329,7 @@ class DragonDatasetObjectDetection:
         """
         DragonDatasetVision.inspect_folder(path)
 
-    def set_class_map(self, class_map: Dict[str, int]) -> 'DragonDatasetObjectDetection':
+    def set_class_map(self, class_map: dict[str, int]) -> 'DragonDatasetObjectDetection':
         """
         Sets a map of class_name -> pixel_value. This is used by the
         trainer for clear evaluation reports.
@@ -1349,7 +1350,7 @@ class DragonDatasetObjectDetection:
         return self
     
     @property
-    def classes(self) -> List[str]:
+    def classes(self) -> list[str]:
         """Returns the list of class names, if set."""
         if self.class_map:
             return list(self.class_map.keys())
@@ -1419,8 +1420,8 @@ class DragonDatasetObjectDetection:
         return self
 
     def configure_transforms(self, 
-                             mean: Optional[List[float]] = [0.485, 0.456, 0.406], 
-                             std: Optional[List[float]] = [0.229, 0.224, 0.225]) -> 'DragonDatasetObjectDetection':
+                             mean: Optional[list[float]] = [0.485, 0.456, 0.406], 
+                             std: Optional[list[float]] = [0.229, 0.224, 0.225]) -> 'DragonDatasetObjectDetection':
         """
         Configures and applies the image and target transformations.
         
@@ -1488,7 +1489,7 @@ class DragonDatasetObjectDetection:
         _LOGGER.info("Paired object detection transforms configured and applied.")
         return self
 
-    def get_datasets(self) -> Tuple[Dataset, ...]:
+    def get_datasets(self) -> tuple[Dataset, ...]:
         """
         Returns the final train, validation, and optional test datasets.
         
@@ -1536,7 +1537,7 @@ class DragonDatasetObjectDetection:
         file_path = make_fullpath(filepath, make=True, enforce="file")
 
         # Add standard transforms
-        recipe: Dict[str, Any] = {
+        recipe: dict[str, Any] = {
             VisionTransformRecipeKeys.TASK: "object_detection",
             VisionTransformRecipeKeys.PIPELINE: [
                 {VisionTransformRecipeKeys.NAME: "ToTensor", "kwargs": {}},
@@ -1605,6 +1606,3 @@ class DragonDatasetObjectDetection:
             
         return s
 
-
-def info():
-    _script_info(__all__)

ml_tools/ML_evaluation/__init__.py

@@ -0,0 +1,53 @@
+from ._regression import (
+    regression_metrics,
+    multi_target_regression_metrics
+)
+
+from ._classification import (
+    classification_metrics,
+    multi_label_classification_metrics
+)
+
+from ._loss import (
+    plot_losses,
+)
+
+from ._feature_importance import (
+    shap_summary_plot,
+    multi_target_shap_summary_plot,
+    plot_attention_importance
+)
+
+from ._sequence import (
+    sequence_to_value_metrics,
+    sequence_to_sequence_metrics
+)
+
+from ._vision import (
+    segmentation_metrics,
+    object_detection_metrics
+)
+
+from ._imprimir import info
+
+
+__all__ = [
+    # regression
+    "regression_metrics",
+    "multi_target_regression_metrics",
+    # classification
+    "classification_metrics",
+    "multi_label_classification_metrics",
+    # loss
+    "plot_losses",
+    # feature importance
+    "shap_summary_plot",
+    "multi_target_shap_summary_plot",
+    "plot_attention_importance",
+    # sequence
+    "sequence_to_value_metrics",
+    "sequence_to_sequence_metrics",
+    # vision
+    "segmentation_metrics",
+    "object_detection_metrics",
+]