radnn 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

radnn/data/preprocess/standardizer.py

@@ -0,0 +1,100 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2023-2025 Pantelis I. Kaplanoglou
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# ......................................................................................
+
+import numpy as np
+
+'''
+    Standardization for rank 3 and above tensors using numpy
+'''
+class Standardizer(object):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, name=None, filestore=None):
+    # ................................................................
+    # // Fields \\
+    self.mean = None
+    self.std = None
+    self.name = name
+    self.filestore = filestore
+    # ................................................................
+    self.load()
+  # --------------------------------------------------------------------------------------------------------------------
+  def load(self):
+    if (self.name is not None) and (self.filestore is not None):
+      dStats = self.filestore.obj.load("%s-meanstd.pkl" % self.name)
+      if dStats is not None:
+        self.mean = dStats["mean"]
+        self.std = dStats["std"]
+  # --------------------------------------------------------------------------------------------------------------------
+  def save(self):
+    if (self.name is not None) and (self.filestore is not None):
+      dStats = {"mean": self.mean, "std": self.std}
+      self.filestore.obj.save(dStats, "%s-meanstd.pkl" % self.name, is_overwriting=True)
+  # --------------------------------------------------------------------------------------------------------------------
+  def fit(self, data, axis_for_stats=-1, is_recalculating=False, is_verbose=False):
+    bIsCached = False
+    if (self.name is not None) and (self.filestore is not None):
+      if self.mean is not None:
+        bIsCached = True
+
+    if (not bIsCached) or is_recalculating:
+      # Collect statistics with maximum precision
+      data = data.astype(np.float64)
+      nAxes = list(range(len(data.shape)))
+      if axis_for_stats is None:
+        nAxes = tuple(nAxes)
+      else:
+        if axis_for_stats == -1:
+          axis_for_stats = nAxes[-1]
+
+        nAxes.remove(axis_for_stats)
+        if len(nAxes) == 1:
+          nAxes = nAxes[0]
+        else:
+          nAxes = tuple(nAxes)
+
+      self.mean = np.mean(data, axis=nAxes)
+      self.std = np.std(data, axis=nAxes)
+      if is_verbose:
+        print("  Standardization: mean/std shape:%s" % str(self.mean.shape))
+      self.save()
+  # --------------------------------------------------------------------------------------------------------------------
+  def fit_transform(self, data, axis_for_stats=-1, is_recalculating=False, is_verbose=False):
+    self.fit(data, axis_for_stats, is_recalculating, is_verbose)
+    return self.transform(data)
+  # --------------------------------------------------------------------------------------------------------------------
+  def standardize(self, data):
+    return (data - self.mean) / self.std
+  # --------------------------------------------------------------------------------------------------------------------
+  def destandardize(self, data):
+    return (data * self.std) + self.mean
+  # --------------------------------------------------------------------------------------------------------------------
+  def transform(self, data):
+    nStandardizedData = (data - self.mean) / self.std
+    return nStandardizedData.astype(data.dtype)
+  # --------------------------------------------------------------------------------------------------------------------
+  def inverse_transform(self, data):
+    nNonStandardizedData = (data * self.std) + self.mean
+    return nNonStandardizedData.astype(data.dtype)
+  # --------------------------------------------------------------------------------------------------------------------

radnn/data/sample_set.py

@@ -0,0 +1,153 @@
+from .dataset_base import DataSetBase
+
+
+
+
+class SampleSet(object):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, subset_type="custom", has_ids=False):
+    self.subset_type = subset_type
+    self.parent_dataset = None
+
+    self.has_ids = has_ids
+
+    self.ids    = None
+    self.samples = None
+    self.sample_count = None
+    self.labels = None
+
+    self._step = 1
+    self._iter_start_pos = 0
+    self._iter_counter = 0
+
+    self.feed = None
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def is_training_set(self):
+    return (self.subset_type == "training") or (self.subset_type == "train") or (self.subset_type == "ts")
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def is_validation_set(self):
+    return (self.subset_type == "validation") or (self.subset_type == "val") or (self.subset_type == "vs")
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def is_unknown_test_set(self):
+    return (self.subset_type == "testing") or (self.subset_type == "test") or (self.subset_type == "ut")
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def has_labels(self):
+    return self.labels is not None
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def data_tuple(self):
+    if self.has_ids:
+      if self.labels is None:
+        return (self.ids, self.samples)
+      else:
+        return (self.ids, self.samples, self.labels)
+    else:
+      if self.labels is None:
+        return self.samples
+      else:
+        return (self.ids, self.samples, self.labels)
+  # --------------------------------------------------------------------------------------------------------------------
+  def subset_of(self, parent_dataset: DataSetBase):
+    self.parent_dataset = parent_dataset
+    if self.parent_dataset is not None:
+      if self.is_training_set:
+        if self.parent_dataset.ts_samples is not None:
+          self.parent_dataset.ts = self
+          self.ids = self.parent_dataset.ts_sample_ids
+          self.samples = self.parent_dataset.ts_samples
+          self.sample_count = self.parent_dataset.ts_sample_count
+          self.labels = self.parent_dataset.ts_labels
+      elif self.is_validation_set:
+        if self.parent_dataset.vs_samples is not None:
+          self.parent_dataset.vs = self
+          self.ids = self.parent_dataset.vs_sample_ids
+          self.samples = self.parent_dataset.vs_samples
+          self.sample_count = self.parent_dataset.vs_sample_count
+          self.labels = self.parent_dataset.vs_labels
+      elif self.is_unknown_test_set:
+        if self.parent_dataset.ut_samples is not None:
+          self.parent_dataset.ut = self
+          self.ids = self.parent_dataset.ut_sample_ids
+          self.samples = self.parent_dataset.ut_samples
+          self.sample_count = self.parent_dataset.ut_sample_count
+          self.labels = self.parent_dataset.ut_labels
+
+      self.has_ids = self.ids is not None
+  # --------------------------------------------------------------------------------------------------------------------
+  '''
+  def create_feed(self, has_ids=False):
+    self.has_ids = has_ids
+    if is_tensorflow_installed:
+      import tensorflow as tf
+
+      if has_ids:
+        self.feed = tf.data.Dataset.from_tensor_slices((self.ids, self.samples, self.labels))
+      else:
+        self.feed = tf.data.Dataset.from_tensor_slices((self.samples, self.labels))
+
+      self.feed = self.feed.map(preprocess_tf, num_parallel_calls=8)
+
+      if (self.subset_type == "training") or (self.subset_type == "train") or (self.subset_type == "ts"):
+  # -----------------------------------------------------------------------------------
+  def preprocess_tf(self, sample_pack):
+
+    import tensorflow as tf
+
+    if self.has_ids:
+      nId, nSample, nLabel = sample_pack
+    else:
+      nSample, nLabel = sample_pack
+
+    tImage = tf.cast(p_tImageInVS, tf.float32)  # //[BF] overflow of standardization
+    tNormalizedImage = self.normalizeImage(tImage)
+
+    tTargetOneHot = tf.one_hot(p_tLabelInVS, self.ClassCount)
+
+    return tNormalizedImage, tTargetOneHot
+  '''
+
+  # --------------------------------------------------------------------------------------------------------------------
+  def __iter__(self):
+    self._iter_counter = 0
+    if self.ids is not None:
+      if self.labels is not None:
+        yield from self._generator_for_supervised_with_ids()
+      else:
+        yield from self._generator_for_unsupervised_with_ids()
+    else:
+      if self.labels is not None:
+        yield from self._generator_for_supervised()
+      else:
+        yield from self._generator_for_unsupervised()
+  # --------------------------------------------------------------------------------------------------------------------
+  def _generator_for_supervised(self):
+    nIndex = self._iter_start_pos
+    while self._iter_counter < self.sample_count:
+      yield (self.samples[nIndex, ...], self.labels[nIndex, ...])
+      nIndex += self._step
+  # --------------------------------------------------------------------------------------------------------------------
+  def _generator_for_unsupervised(self):
+    nIndex = self._iter_start_pos
+    while self._iter_counter < self.sample_count:
+      yield self.samples[nIndex, ...]
+      nIndex += self._step
+  # --------------------------------------------------------------------------------------------------------------------
+  def _generator_for_supervised_with_ids(self):
+    nIndex = self._iter_start_pos
+    while self._iter_counter < self.sample_count:
+      yield (self.ids[nIndex], self.samples[nIndex, ...], self.labels[nIndex, ...])
+      nIndex += self._step
+  # --------------------------------------------------------------------------------------------------------------------
+  def _generator_for_unsupervised_with_ids(self):
+    nIndex = self._iter_start_pos
+    while self._iter_counter < self.sample_count:
+      yield (self.ids[nIndex], self.samples[nIndex, ...])
+      nIndex += self._step
+  # --------------------------------------------------------------------------------------------------------------------
+
+
+

radnn/data/sequence_dataset.py

@@ -0,0 +1,136 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2022-2025 Pantelis I. Kaplanoglou
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# ......................................................................................
+
+
+import numpy as np
+from .dataset_base import DataSetBase
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+def generate_sequence_clips(samples, labels, window_size, stride, is_padding_zeros=False):
+  nSequenceIndex = 0
+  while nSequenceIndex < samples.shape[0]:
+    nLabel = labels[nSequenceIndex]
+    nPosition = 0
+    nSpanPoints = window_size
+    if is_padding_zeros:
+      nSpanPoints = window_size - 3 * stride
+
+    nDataPointCount = samples.shape[1]
+    while (nPosition + nSpanPoints) <= nDataPointCount:
+      if is_padding_zeros and ((nPosition + window_size) >= nDataPointCount):
+        nSeqSample = np.zeros((window_size, samples.shape[2]), np.float32)
+        nSeqSample[nPosition + window_size - nDataPointCount:, :] = samples[nSequenceIndex, nPosition:, :]
+      else:
+        nSeqSample = samples[nSequenceIndex, nPosition:nPosition + window_size, :]
+
+      yield (nSeqSample, nLabel)
+
+      nPosition += stride
+    nSequenceIndex += 1
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+
+
+
+class SequenceDataset(DataSetBase):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, name,  fs, clip_window_size=None, clip_stride=None, is_padding_zeros=False, random_seed=None, is_classification=True):
+    super(SequenceDataset, self).__init__(name, fs, random_seed, is_classification)
+    self.clip_window_size = clip_window_size
+    self.clip_stride = clip_stride
+    self.is_padding_zeros = is_padding_zeros
+    self.card["clips.window_size"] = self.clip_window_size
+    self.card["clips.stride"] = self.clip_stride
+    self.card["clips.is_padding_zeros"] = self.is_padding_zeros
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def ts_sequence_clips(self):
+    return generate_sequence_clips(self.ts_samples, self.ts_labels, self.clip_window_size, self.clip_stride,
+                                   self.is_padding_zeros)
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def vs_sequence_clips(self):
+    if self.vs_samples is not None:
+      return generate_sequence_clips(self.vs_samples, self.vs_labels, self.clip_window_size, self.clip_stride,
+                                     self.is_padding_zeros)
+    else:
+      return None
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def ut_sequence_clips(self):
+    if self.ut_samples is not None:
+      return generate_sequence_clips(self.ut_samples, self.ut_labels, self.clip_window_size, self.clip_stride,
+                                     self.is_padding_zeros)
+    else:
+      return None
+  # --------------------------------------------------------------------------------------------------------------------
+  def convert_samples_to_clips(self, clip_window_size=None, clip_stride=None, is_padding_zeros=False):
+    if clip_window_size is not None:
+      self.clip_window_size = clip_window_size
+    if clip_stride is not None:
+      self.clip_stride = clip_stride
+    if is_padding_zeros and (not self.is_padding_zeros):
+      self.is_padding_zeros = is_padding_zeros
+
+    self.card["clips.window_size"] = self.clip_window_size
+    self.card["clips.stride"] = self.clip_stride
+    self.card["clips.is_padding_zeros"] = self.is_padding_zeros
+
+    # Create training set clips
+    nClips = []
+    nClipLabels = []
+    for (nClip, nClipLabel) in self.ts_sequence_clips:
+      nClips.append(nClip)
+      nClipLabels.append(nClipLabel)
+    nClips = np.asarray(nClips)
+    nClipLabels = np.asarray(nClipLabels)
+    self.assign_training_set(nClips, nClipLabels)
+
+    # Create validation set clips
+    if self.vs_samples is not None:
+      nClips = []
+      nClipLabels = []
+      for (nClip, nClipLabel) in self.vs_sequence_clips:
+        nClips.append(nClip)
+        nClipLabels.append(nClipLabel)
+      nClips = np.asarray(nClips)
+      nClipLabels = np.asarray(nClipLabels)
+      self.assign_validation_set(nClips, nClipLabels)
+
+    # Create unknown test set clips
+    if self.ut_samples is not None:
+      nClips = []
+      nClipLabels = []
+      for (nClip, nClipLabel) in self.ut_sequence_clips:
+        nClips.append(nClip)
+        nClipLabels.append(nClipLabel)
+      nClips = np.asarray(nClips)
+      nClipLabels = np.asarray(nClipLabels)
+      self.assign_unknown_test_set(nClips, nClipLabels)
+
+    return self
+  # --------------------------------------------------------------------------------------

radnn/errors.py

@@ -0,0 +1,2 @@
+class Errors:
+  MLSYS_NO_FILESYS = "No file system defined for the machine learning system. Create the object and assign the mlsys.filesys property."

radnn/evaluation/evaluate_classification.py

@@ -94,10 +94,10 @@ class EvaluateClassification(object):
     print("-" * nRepeat)
   # --------------------------------------------------------------------------------------------------------------
   def print_overall(self):
-    print(f"Weighted Average Recall %   :{self.average_recall*100.0:.3f}")
-    print(f"Weighted Average Precision %:{self.average_precision*100.0:.3f}")
     print(f"Accuracy %                  :{self.accuracy*100.0       :.3f}")
     print(f"Average F1 Score %          :{self.average_f1score*100.0:.3f}")
+    print(f"Weighted Average Recall %   :{self.average_recall*100.0:.3f}")
+    print(f"Weighted Average Precision %:{self.average_precision*100.0:.3f}")
     if (self.class_count == 2) and (self.auc is not None):
       print(f"Area Under the Curve (AUC):{self.auc:.4f}")
     print()