radnn 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

radnn/data/sample_set.py

@@ -29,6 +29,7 @@ from sklearn.utils.class_weight import compute_class_weight
 from .sample_set_kind import SampleSetKindInfo
 
 from radnn.core import RequiredLibs
+
 oReqs = RequiredLibs()
 if oReqs.is_torch_installed:
   # [TODO] Additional coupling to torch (+)->MANOLO
@@ -36,9 +37,10 @@ if oReqs.is_torch_installed:
   import torch
   from torch.utils.data import DataLoader
 
+
 class SampleSet(object):
   LOADER_NUM_WORKERS = 8
-
+  
   # --------------------------------------------------------------------------------------------------------------------
   def __init__(self, parent_dataset, subset_kind: str, **kwargs):
     '''
@@ -60,43 +62,43 @@ class SampleSet(object):
     self.info.is_classification = kwargs.get("is_classification", False)
     self.batch_size = kwargs.get("batch_size", None)
     self.transform_augment = kwargs.get("sample_transform_augment", None)
-    self._sample_count                      = 0
-
-    self.ids : list | np.ndarray | None = kwargs.get('ids', None)
-    self.samples: list | np.ndarray | None      = kwargs.get("samples", None)
+    self._sample_count = 0
+    
+    self.ids: list | np.ndarray | None = kwargs.get('ids', None)
+    self.samples: list | np.ndarray | None = kwargs.get("samples", None)
     if (self.samples is not None):
       if isinstance(self.samples, list):
         self.samples = np.array(self.samples, np.float32)
       self._sample_count = self.samples.shape[0]
-    self.labels: list | np.ndarray | None       = kwargs.get("labels", None)
-
-    self.files                              = None
-    self._sample_directory: pd.DataFrame | None  = kwargs.get("sample_file_records", None)
+    self.labels: list | np.ndarray | None = kwargs.get("labels", None)
+    
+    self.files = None
+    self._sample_directory: pd.DataFrame | None = kwargs.get("sample_file_records", None)
     if self._sample_directory is not None:
       self.files = self._sample_directory.iloc[:, 0].to_list()
       self._sample_count = len(self.files)
-      self.labels       = self._sample_directory.iloc[:, 1].to_list()
-
-    assert self._sample_count > 0, ERR_SUBSET_MUST_HAVE_SAMPLES
+      self.labels = self._sample_directory.iloc[:, 1].to_list()
+    
+    assert self._sample_count > 0, ERR_DS_SUBSET_MUST_HAVE_SAMPLES
     self._step = 1
     self._iter_start_pos = 0
     self._iter_counter = 0
     self._are_samples_in_memory = self.samples is not None
-
+    
     self.has_sample_ids = self.ids is not None
-
+    
     self.minibatch_count = self._sample_count
     if self.batch_size is not None:
       bMustSuffle = kwargs.get("must_shuffle", self.info.must_shuffle)
       if SampleSet.LOADER_NUM_WORKERS > 0:
         self.loader = DataLoader(self, batch_size=self.batch_size, shuffle=bMustSuffle,
-                                  num_workers=SampleSet.LOADER_NUM_WORKERS,
-                                  pin_memory=True,persistent_workers=True, prefetch_factor=SampleSet.LOADER_NUM_WORKERS
+                                 num_workers=SampleSet.LOADER_NUM_WORKERS,
+                                 pin_memory=True, persistent_workers=True, prefetch_factor=SampleSet.LOADER_NUM_WORKERS
                                  )
       else:
         self.loader = DataLoader(self, batch_size=self.batch_size, shuffle=bMustSuffle,
-                                  num_workers=SampleSet.LOADER_NUM_WORKERS,
-                                  pin_memory=True
+                                 num_workers=SampleSet.LOADER_NUM_WORKERS,
+                                 pin_memory=True
                                  )
       
       self.minibatch_count = len(self.loader)
@@ -104,19 +106,23 @@ class SampleSet(object):
       self.loader = DataLoader(self, shuffle=self.info.must_shuffle, num_workers=SampleSet.LOADER_NUM_WORKERS,
                                pin_memory=True, persistent_workers=True
                                )
-
+    
     if self.info.is_classification:
       self.info.class_indices = np.sort(np.unique(self.labels))
-      self.info.class_weights = compute_class_weight(class_weight='balanced', classes=self.info.class_indices, y=np.array(self.labels))
+      self.info.class_weights = compute_class_weight(class_weight='balanced', classes=self.info.class_indices,
+                                                     y=np.array(self.labels))
       self.info.class_count = len(self.info.class_indices)
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def sample_count(self):
     return self._sample_count
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def has_labels(self):
     return self.labels is not None
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def data_tuple(self):
@@ -137,9 +143,11 @@ class SampleSet(object):
           return (self.ids, self.samples, self.labels)
     else:
       return None
+  
   # --------------------------------------------------------------------------------------------------------------------
   def __len__(self):
     return self._sample_count
+  
   # --------------------------------------------------------------------------------------------------------------------
   def __getitem__(self, index):
     nID = None
@@ -147,11 +155,10 @@ class SampleSet(object):
       tSample = self.do_load_sample(index)
     else:
       tSample, nID = self.do_load_sample_from_file(index)
-      
-      
+    
     if self.transform_augment is not None:
       tSample = self.transform_augment(tSample)
-
+    
     if self.ids is not None:
       nID = self.ids[index]
     
@@ -160,15 +167,16 @@ class SampleSet(object):
     if self.labels is not None:
       # Supervised
       oResult.append(self.do_load_target(index))
-      
+    
     if nID is not None:
       oResult.append(nID)
     
     return tuple(oResult)
+  
   # --------------------------------------------------------------------------------------------------------------------
   def __iter__(self):
     self._iter_counter = 0
-
+    
     if self._are_samples_in_memory:
       if self.ids is not None:
         if self.labels is not None:
@@ -185,6 +193,7 @@ class SampleSet(object):
         yield from self._file_generator_for_supervised()
       else:
         yield from self._file_generator_for_unsupervised()
+  
   # --------------------------------------------------------------------------------------------------------------------
   def do_load_sample_from_file(self, index):
     '''
@@ -192,6 +201,7 @@ class SampleSet(object):
     :param index: The index of the sample in the sample file list
     '''
     pass
+  
   # --------------------------------------------------------------------------------------------------------------------
   def do_load_sample(self, index):
     '''
@@ -200,6 +210,7 @@ class SampleSet(object):
     :return:
     '''
     return torch.tensor(self.samples[index, ...], dtype=torch.float32)
+  
   # --------------------------------------------------------------------------------------------------------------------
   def do_load_target(self, index):
     '''
@@ -207,6 +218,7 @@ class SampleSet(object):
     :param index: The index of the sample in the sample subset
     '''
     return torch.tensor(self.labels[index, ...], dtype=torch.long)
+  
   # --------------------------------------------------------------------------------------------------------------------
   def _file_generator_for_supervised(self):
     nIndex = self._iter_start_pos
@@ -216,6 +228,7 @@ class SampleSet(object):
         tSample = self.transform_augment(tSample)
       yield (tSample, self.do_load_target(nIndex))
       nIndex += self._step
+  
   # --------------------------------------------------------------------------------------------------------------------
   def _file_generator_for_unsupervised(self):
     nIndex = self._iter_start_pos
@@ -225,6 +238,7 @@ class SampleSet(object):
         tSample = self.transform_augment(tSample)
       yield (tSample)
       nIndex += self._step
+  
   # --------------------------------------------------------------------------------------------------------------------
   def _numpy_generator_for_supervised(self):
     nIndex = self._iter_start_pos
@@ -234,6 +248,7 @@ class SampleSet(object):
         tSample = self.transform_augment(tSample)
       yield (tSample, self.do_load_target(nIndex))
       nIndex += self._step
+  
   # --------------------------------------------------------------------------------------------------------------------
   def _numpy_generator_for_supervised_with_ids(self):
     nIndex = self._iter_start_pos
@@ -243,6 +258,7 @@ class SampleSet(object):
         tSample = self.transform_augment(tSample)
       yield (self.ids[nIndex], tSample, self.do_load_target(nIndex))
       nIndex += self._step
+  
   # --------------------------------------------------------------------------------------------------------------------
   def _numpy_generator_for_unsupervised(self):
     nIndex = self._iter_start_pos
@@ -252,6 +268,7 @@ class SampleSet(object):
         tSample = self.transform_augment(tSample)
       yield tSample
       nIndex += self._step
+  
   # --------------------------------------------------------------------------------------------------------------------
   def _numpy_generator_for_unsupervised_with_ids(self):
     nIndex = self._iter_start_pos
@@ -261,6 +278,7 @@ class SampleSet(object):
         tSample = self.transform_augment(tSample)
       yield (self.ids[nIndex], tSample)
       nIndex += self._step
+  
   # --------------------------------------------------------------------------------------------------------------------
   def print_info(self):
     sDescription = self.info.kind_description
@@ -269,18 +287,19 @@ class SampleSet(object):
     if self.minibatch_count is not None:
       sMinibatches = f" minbatches: {self.minibatch_count}"
     if (self.samples is not None) and isinstance(self.samples, np.ndarray):
-      print(f"  |__ {sDescription} set samples: {self.sample_count}   shape: {self.samples.shape}{sMinibatches}")
-      print(f"          |__ {sDescription} set labels: {self.sample_count}   shape: {self.labels.shape}")
+      print(f"  |__ {sDescription} samples: {self.sample_count}   shape: {self.samples.shape}{sMinibatches}")
     else:
-      print(f"  |__ {sDescription} set samples: {self.sample_count} {sMinibatches}")
-
+      print(f"  |__ {sDescription} samples: {self.sample_count} {sMinibatches}")
+    
     if (self.labels is not None) and isinstance(self.labels, np.ndarray):
-        print(f"      |__ Labels: {self.sample_count}   shape:{self.labels.shape}")
+      print(f"      |__ {sDescription} labels: {self.sample_count}   shape:{self.labels.shape}")
     else:
-      print(f"      |__ Labels: {self.sample_count}")
+      print(f"      |__ {sDescription} labels: {self.sample_count}")
+  
   # --------------------------------------------------------------------------------------------------------------------
   def __str__(self):
     return f"{self.info.kind_description} samples:{self.sample_count} minibatches:{self.minibatch_count}"
+  
   # --------------------------------------------------------------------------------------------------------------------
   def __repr__(self):
     return self.__str__()

radnn/data/sample_set_kind.py

@@ -31,21 +31,24 @@ class SampleSetKind(Enum):
   TRAINING_SET = 0
   VALIDATION_SET = 1
   UNKNOWN_TEST_SET = 2
+  
+
+# ======================================================================================================================
 
 
 # ======================================================================================================================
 class SampleSetKindInfo(dict):
   # --------------------------------------------------------------------------------------------------------------------
-  def __init__(self, kind_str: str|None=None, kind: int | None=None, **kwargs):
+  def __init__(self, kind_str: str | None = None, kind: int | None = None, **kwargs):
     super().__init__(**kwargs)
     self._kind: int | None = kind
     self._kind_str: str | None = None
     if kind_str is not None:
       self._kind_str = kind_str.lower()
-
+    
     # Invoke the property getters
-    self["kind"]      = self.kind
-    self["kind_str"]  = self.kind_description
+    self["kind"] = self.kind
+    self["kind_str"] = self.kind_description
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def kind_description(self):
@@ -58,11 +61,12 @@ class SampleSetKindInfo(dict):
       elif nKind == SampleSetKind.value:
         self._kind_str = "training"
     return self._kind_str
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def kind(self):
     if (self._kind is None):
-      nKind = -1 # Unknown
+      nKind = -1  # Unknown
       if self.is_training_set:
         nKind = SampleSetKind.TRAINING_SET.value
       elif self.is_validation_set:
@@ -71,26 +75,32 @@ class SampleSetKindInfo(dict):
         nKind = SampleSetKind.UNKNOWN_TEST_SET.value
       self._kind = nKind
     return self._kind
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def must_shuffle(self):
     return self.kind == SampleSetKind.TRAINING_SET.value
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def is_training_set(self):
     return (self._kind_str == "training") or (self._kind_str == "train") or (self._kind_str == "ts")
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def is_validation_set(self):
     return (self._kind_str == "validation") or (self._kind_str == "val") or (self._kind_str == "vs")
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def is_unknown_test_set(self):
     return (self._kind_str == "testing") or (self._kind_str == "test") or (self._kind_str == "ut")
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def is_classification(self):
     return self["Task"] == "classification"
+  
   # --------------------------------------------------------------------------------------------------------------------
   @is_classification.setter
   def is_classification(self, value):
@@ -99,26 +109,32 @@ class SampleSetKindInfo(dict):
       self["Classes.Count"] = None
       self["Classes.Indices"] = None
       self["Classes.Weights"] = None
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def class_count(self):
     return self["Classes.Count"]
+  
   # --------------------------------------------------------------------------------------------------------------------
   @class_count.setter
   def class_count(self, value):
     self["Classes.Count"] = value
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def class_indices(self):
     return self["Classes.Indices"]
+  
   # --------------------------------------------------------------------------------------------------------------------
   @class_indices.setter
   def class_indices(self, value):
     self["Classes.Indices"] = value
+  
   # --------------------------------------------------------------------------------------------------------------------
   @property
   def class_weights(self):
     return self["Classes.Weights"]
+  
   # --------------------------------------------------------------------------------------------------------------------
   @class_weights.setter
   def class_weights(self, value):

radnn/data/sample_set_simple.py

@@ -1,13 +1,29 @@
+import numpy as np
+from radnn.data.sample_set_kind import SampleSetKind
+
 class SampleSet(object):
   # --------------------------------------------------------------------------------------------------------------------
-  def __init__(self, parent_dataset, samples=None, labels=None):
+  def __init__(self, parent_dataset, samples=None, labels=None, ids=None, kind: SampleSetKind | str = None):
     self.parent_dataset = parent_dataset
     self.samples = samples
     self.labels = labels
+    self.ids = ids
+    if self.ids is None:
+      self.ids = np.arange(len(self.samples)) + 1
+    self.kind: SampleSetKind = kind
+    
     self.loader = None
     self._sample_count = None
     self._minibatch_count = None
   # --------------------------------------------------------------------------------------------------------------------
+  def assign(self, samples, labels=None, ids=None):
+    self.samples = samples
+    self.labels = labels
+    self.ids = ids
+    if self.ids is None:
+      self.ids = np.arange(len(self.samples)) + 1
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
   @property
   def sample_count(self):
     if self._sample_count is None:
@@ -26,7 +42,49 @@ class SampleSet(object):
   def __getitem__(self, index):
     return (self.samples[index], self.labels[index])
   # --------------------------------------------------------------------------------------------------------------------
+  def __str__(self):
+    sDescr = f"{self.kind:<17} samples: {self.sample_count:7d}  mini-batches: {self.minibatch_count}"
+    return sDescr
+  # --------------------------------------------------------------------------------------------------------------------
+  def __repr__(self):
+    return self.__str__()
   
+  # --------------------------------------------------------------------------------------------------------------------
+  def _iter_unsupervised(self):
+    for nIndex, nSample in enumerate(self.samples):
+      nLabel = self.labels[nIndex]
+      nId = self.ids[nIndex]
+      yield nSample, int(nId)
+  # --------------------------------------------------------------------------------------------------------------------
+  def _iter_supervised(self):
+    for nIndex, nSample in enumerate(self.samples):
+      nLabel = self.labels[nIndex]
+      nId = self.ids[nIndex]
+      yield nSample, nLabel, int(nId)
+  # --------------------------------------------------------------------------------------------------------------------
+  def __iter__(self):
+    if self.labels is None:
+      return self._iter_unsupervised()
+    else:
+      return self._iter_supervised()
+  # --------------------------------------------------------------------------------------------------------------------
+  def print_info(self):
+    sDescription = self.kind.name.lower().replace("_", " ")
+    sDescription = sDescription[0].upper() + sDescription[1:]
+    sMinibatches = ""
+    if self.minibatch_count is not None:
+      sMinibatches = f" minbatches: {self.minibatch_count}"
+    if (self.samples is not None) and isinstance(self.samples, np.ndarray):
+      print(f"  |__ {sDescription} samples: {self.sample_count}   shape: {self.samples.shape}{sMinibatches}")
+    else:
+      print(f"  |__ {sDescription} samples: {self.sample_count} {sMinibatches}")
+    
+    if (self.labels is not None) and isinstance(self.labels, np.ndarray):
+      print(f"      |__ {sDescription} labels: {self.sample_count}   shape:{self.labels.shape}")
+    else:
+      print(f"      |__ {sDescription} labels: {self.sample_count}")
+  # --------------------------------------------------------------------------------------------------------------------
+# ======================================================================================================================
   
   
   

radnn/data/sequence_dataset.py

@@ -68,10 +68,10 @@ class SequenceDataSet(DataSetBase):
     self.clip_stride: int|None = None
     self.is_padding_zeros: bool|None = None
   # --------------------------------------------------------------------------------------------------------------------
-  def do_read_hyperparams(self):
-    self.clip_window_size = self.hparams.get("Data.Clip.WindowSize", None)
-    self.clip_stride = self.hparams.get("Data.Clip.Stride", None)
-    self.is_padding_zeros = self.hparams.get("Data.Clip.IsPaddingZeroes", None)
+  def read_hyperparams(self):
+    self.clip_window_size = self.hprm.get("Data.Clip.WindowSize", None)
+    self.clip_stride = self.hprm.get("Data.Clip.Stride", None)
+    self.is_padding_zeros = self.hprm.get("Data.Clip.IsPaddingZeroes", None)
   # --------------------------------------------------------------------------------------------------------------------
   def generate_clips(self, subset: SampleSet):
     return generate_sequence_clips(self, subset.samples, subset.labels,

radnn/learn/constants.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+class MLTask(Enum):
+  BINARY_CLASSIFICATION = 0
+  MULTICLASS_CLASSIFICATION = 1
+  REGRESSION = 2
+  MULTIVARIATE_REGRESSION = 3
+  CLUSTERING = 4
+  INPUT_RECONSTRUCTION = 5
+  RANKING = 6
+
+
+def get_task_from_hyperparams(hyperparams: dict) -> MLTask:
+  sTask = None
+  if "Experiment.Task" in hyperparams:
+    sTask = hyperparams["Experiment.Task"]
+    
+  oTask = None
+  if sTask is not None:
+    sTask = sTask.upper().replace(" ", "_")
+    if sTask in MLTask.__members__:
+      oTask = MLTask[sTask]
+      
+  return oTask

radnn/learn/torch/ml_model_freezer.py

@@ -162,7 +162,7 @@ class MLModelFreezer(object):
   def convnext_frozen(self):
     """
     torchvision.convnext_tiny has:
-      model.features: Sequential of 8 modules:
+      model.features: Sequential of 8 nnmodules:
         0 stem
         1 stage1
         2 downsample1

radnn/plots/__init__.py

@@ -5,5 +5,6 @@ from .plot_voronoi_2d import PlotVoronoi2D
 from .plot_multi_scatter import MultiScatterPlot
 from .plot_auto_multi_image import AutoMultiImagePlot
 from .plot_function import PlotFunction
-from .plot_histogram_of_classes import PlotHistogramOfClasses, CPlot
-from .plot_visualize_dataset2d import PlotVisualizeDataset2D
+from .plot_histogram_of_classes import PlotHistogramOfClasses
+from .plot_visualize_dataset2d import PlotVisualizeDataset2D
+from .plot_legacy import CPlot, PlotDataset

radnn/plots/plot_histogram_of_classes.py

@@ -28,101 +28,23 @@ import numpy as np
 import matplotlib.pyplot as plt  # use the subpackage (a.k.a. namespace) with the alias "plt"
 from matplotlib import colors
 
-
-# ====================================================================================================
-class CPlot(object):  # class CPlot: object
-  # --------------------------------------------------------------------------------------
-  # Constructor
-  def __init__(self, p_sTitle, p_oSamples, p_oLabels
-               , p_sLabelDescriptions=["orange tree", "olive tree"]
-               , p_sColors=["darkorange", "darkseagreen"]
-               # https://matplotlib.org/3.1.0/gallery/color/named_colors.html
-               , p_sXLabel="Feature 1"
-               , p_sYLabel="Feature 2"
-               ):
-    # ................................................................
-    # // Fields \\
-    self.Title = p_sTitle
-    self.Samples = p_oSamples
-    self.Labels = p_oLabels
-    self.LabelDescriptions = p_sLabelDescriptions
-    self.Colors = p_sColors
-    self.XLabel = p_sXLabel
-    self.YLabel = p_sYLabel
-    # ................................................................
-  
-  # --------------------------------------------------------------------------------------
-  def Show(self, p_bIsMinMaxScaled=False, p_nLineSlope=None, p_nLineIntercept=None, p_nLimitsX=[-4, 4],
-           p_nLimitsY=[-4, 4]):
-    
-    # Two dimensional dataset for the scatter plot
-    nXValues = self.Samples[:, 0]
-    nYValues = self.Samples[:, 1]
-    nLabels = self.Labels
-    
-    oColorMap = colors.ListedColormap(self.Colors)
-    
-    fig, ax = plt.subplots(figsize=(8, 8))
-    plt.scatter(nXValues, nYValues, c=nLabels, cmap=oColorMap)
-    
-    plt.title(self.Title)
-    cb = plt.colorbar()
-    nLoc = np.arange(0, max(nLabels), max(nLabels) / float(len(self.Colors)))
-    cb.set_ticks(nLoc)
-    cb.set_ticklabels(self.LabelDescriptions)
-    
-    if (p_nLineSlope is not None):
-      x1 = np.min(nXValues)
-      y1 = p_nLineSlope * x1 + p_nLineIntercept;
-      x2 = np.max(nXValues)
-      y2 = p_nLineSlope * x2 + p_nLineIntercept;
-      oPlot1 = ax.plot([x1, x2], [y1, y2], 'r--', label="Decision line")
-      oLegend = plt.legend(loc="upper left", shadow=True, fontsize='x-large')
-      oLegend.get_frame().set_facecolor("lightyellow")
-    
-    if p_bIsMinMaxScaled:
-      ax.set_xlim((-0.05, 1.05))
-      ax.set_ylim((-0.05, 1.05))
-    else:
-      ax.set_xlim(p_nLimitsX[0], p_nLimitsX[1])
-      ax.set_ylim(p_nLimitsY[0], p_nLimitsY[1])
-    
-    ax.set_xlabel(self.XLabel)
-    ax.set_ylabel(self.YLabel)
-    
-    # plt.scatter(oDataset.Samples[:,0], oDataset.Samples[:,1])
-    # , t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
-    
-    plt.show()
-  # --------------------------------------------------------------------------------------
-
-
-# ====================================================================================================
-
-
-
-
-
-
-
-
 # =========================================================================================================================
 class PlotHistogramOfClasses(object):  # class CPlot: object
   # --------------------------------------------------------------------------------------
-  def __init__(self, p_nData, p_nClasses, p_bIsProbabilities=False):
-    self.Data = p_nData
-    self.Classes = p_nClasses
-    self.IsProbabilities = p_bIsProbabilities
+  def __init__(self, data, classes, is_probabilities=False):
+    self.data = data
+    self.classes = classes
+    self.is_probabilities = is_probabilities
   
   # --------------------------------------------------------------------------------------
   def prepare(self):
     
     fig, ax = plt.subplots(figsize=(7, 7))
     
-    ax.hist(self.Data, density=self.IsProbabilities, bins=self.Classes, ec="k")
+    ax.hist(self.data, density=self.is_probabilities, bins=self.classes, ec="k")
     ax.locator_params(axis='x', integer=True)
     
-    if self.IsProbabilities:
+    if self.is_probabilities:
       plt.ylabel('Probabilities')
     else:
       plt.ylabel('Counts')