radnn 0.0.7.2__py3-none-any.whl → 0.0.8__py3-none-any.whl

radnn/__init__.py

@@ -1,8 +1,10 @@
-# Version 0.0.3  [2025-01-25]
-# Version 0.0.5  [2025-01-26]
-# Version 0.0.6  [2025-02-04]
-# Version 0.0.7  [2025-02-17]
-__version__ = "0.0.7"
+# Version 0.0.3    [2025-01-25]
+# Version 0.0.5    [2025-01-26]
+# Version 0.0.6    [2025-02-04]
+# Version 0.0.7.2  [2025-02-17]
+# Version 0.0.7.3  [2025-02-21]
+# Version 0.0.8    [2025-02-xx]
+__version__ = "0.0.8"
 
 from .system import FileStore, FileSystem
 from .ml_system import MLSystem

radnn/core.py

@@ -1,27 +1,37 @@
+# ======================================================================================
+#
+#     Rapid Deep Neural Networks
+#
+#     Licensed under the MIT License
+# ______________________________________________________________________________________
+# ......................................................................................
+
+# Copyright (c) 2018-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 sys
 import socket
 import platform
 import subprocess
 from datetime import datetime
-import importlib.util
-
-
-# ----------------------------------------------------------------------------------------------------------------------
-def is_opencv_installed():
-    return importlib.util.find_spec("cv2") is not None
-# ----------------------------------------------------------------------------------------------------------------------
-def is_tensorflow_installed():
-    bIsInstalled = importlib.util.find_spec("tensorflow") is not None
-    if not is_tensorflow_installed:
-      bIsInstalled = importlib.util.find_spec("tensorflow-gpu") is not None
-    return bIsInstalled
-# ----------------------------------------------------------------------------------------------------------------------
-def is_torch_installed():
-    return importlib.util.find_spec("torch") is not None
-# ----------------------------------------------------------------------------------------------------------------------
-
-
-
 
 # ----------------------------------------------------------------------------------------------------------------------
 def system_name() -> str:
@@ -45,24 +55,27 @@ def shell_command_output(command_string):
 
 
 
-
-#TODO: macOS support
-
+# ======================================================================================================================
 class MLInfrastructure(object):
-  # ----------------------------------------------------------------------------------------------------------------------
+  # --------------------------------------------------------------------------------------------------------------------
   @classmethod
   def is_linux(cls):
-    return not (cls.is_windows or cls.is_colab)
-  # ----------------------------------------------------------------------------------------------------------------------
+    return not (cls.is_windows or cls.is_colab or cls.is_macos())
+  # --------------------------------------------------------------------------------------------------------------------
   @classmethod
   def is_windows(cls):
     sPlatform = platform.system()
     return (sPlatform == "Windows")
-  # ----------------------------------------------------------------------------------------------------------------------
+  # --------------------------------------------------------------------------------------------------------------------
   @classmethod
   def is_colab(cls):
     return "google.colab" in sys.modules
-  # ----------------------------------------------------------------------------------------------------------------------
+  # --------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def is_macos(cls):
+    sPlatform = platform.system()
+    return (sPlatform == "Darwin")
+  # --------------------------------------------------------------------------------------------------------------------
   @classmethod
   def host_name(cls, is_using_ip_address=True) -> str:
     sPlatform = platform.system()
@@ -77,7 +90,10 @@ class MLInfrastructure(object):
     else:
       if sPlatform == "Windows":
         sResult = "(windows)-" + sHostName
+      elif sPlatform == "Darwin":
+        sResult = "(macos)-" + sHostName
       else:
         sResult = "(linux)-" + sHostName
     return sResult
-  # ----------------------------------------------------------------------------------------------------------------------
+  # --------------------------------------------------------------------------------------------------------------------
+# ======================================================================================================================

radnn/data/__init__.py

@@ -1,4 +1,12 @@
 from .dataset_base import DataSetBase
 from .image_dataset import ImageDataSet
 from .sample_set import SampleSet
+from .data_feed import DataFeed
+from .subset_type import SubsetType
+from .sample_set import SampleSet
+from radnn import mlsys
+if mlsys.is_tensorflow_installed:
+  from .tf_classification_data_feed import TFClassificationDataFeed
+
+from .image_dataset_files import ImageDataSetFiles
 

radnn/data/data_feed.py

@@ -0,0 +1,147 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2019-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.
+
+# ......................................................................................
+from .dataset_base import DataSetBase
+from .subset_type import SubsetType
+from radnn.data.preprocess import Normalizer, Standardizer
+
+class DataFeed(object):
+  def __init__(self, dataset: DataSetBase, subset_type):
+    self.subset_type: SubsetType = None
+    if isinstance(subset_type, SubsetType):
+      self.subset_type = subset_type
+    elif isinstance(subset_type, str):
+      self.subset_type = SubsetType(subset_type)
+    else:
+      self.subset_type = None
+
+    self.dataset = dataset
+    self.feed = None
+    self.pipeline_objects = []
+    self.method_actions = []
+    self.augmentations = []
+
+    self.value_preprocessor = None
+    self.padding_offset = None
+    self.padding_target = None
+
+    self.input_shape = self.dataset.sample_shape
+    self.sample_count_to_shuffle = None
+    if self.subset_type.is_training_set:
+      self.sample_count_to_shuffle = self.dataset.ts_sample_count
+    elif self.subset_type.is_validation_set:
+      self.sample_count_to_shuffle = self.dataset.vs_sample_count
+    elif self.subset_type.is_unknown_test_set:
+      self.sample_count_to_shuffle = self.dataset.ut_sample_count
+    self.batch_size  = None
+
+    self._has_mapped_preprocessing_method = False
+    self._is_multiclass = False
+
+    self.feed = self.build_iterator()
+    self.pipeline_objects.append(self.feed)
+  # --------------------------------------------------------------------------------------------------------------------
+  def multiclass(self):
+    self._is_multiclass = True
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def normalize(self):
+    self.value_preprocessor = Normalizer(self.dataset.name, self.dataset.filestore)
+    if self.value_preprocessor.min is None:
+      self.value_preprocessor.fit(self.dataset.ts_samples)
+    self.method_actions.append("normalize")
+    if not self._has_mapped_preprocessing_method:
+      self.feed = self.build_preprocessor(self.feed)
+      self.pipeline_objects.append(self.feed)
+      self._has_mapped_preprocessing_method = True
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def map_preprocessing(self):
+    if not self._has_mapped_preprocessing_method:
+      self.feed = self.build_preprocessor(self.feed)
+      self.pipeline_objects.append(self.feed)
+      self._has_mapped_preprocessing_method = True
+  # --------------------------------------------------------------------------------------------------------------------
+  def standardize(self, axis_for_stats=None):
+    self.value_preprocessor = Standardizer(self.dataset.name, self.dataset.filestore)
+    if self.value_preprocessor.mean is None:
+      self.value_preprocessor.fit(self.dataset.ts_samples, axis_for_stats=axis_for_stats)
+    self.method_actions.append("standardize")
+    self.map_preprocessing()
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def random_shuffle(self):
+    self.feed = self.build_random_shuffler(self.feed)
+    self.pipeline_objects.append(self.feed)
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def batch(self, batch_size):
+    self.batch_size = batch_size
+    self.feed = self.build_minibatch_maker(self.feed)
+    self.pipeline_objects.append(self.feed)
+    return self
+# --------------------------------------------------------------------------------------------------------------------
+  def augment_crop(self, padding_offset):
+    self.padding_offset = padding_offset
+    assert self.dataset.sample_shape is not None, "You should define the images input shape on the dataset"
+    self.padding_target = self.dataset.sample_shape[0] + self.padding_offset
+    self.map_preprocessing()
+    self.feed = self.build_augmentation(self.feed, "random_crop")
+    self.pipeline_objects.append(self.feed)
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def augment_flip_left_right(self):
+    self.map_preprocessing()
+    self.feed = self.build_augmentation(self.feed, "random_flip_left_right")
+    self.pipeline_objects.append(self.feed)
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def augment_cutout(self):
+    self.map_preprocessing()
+    self.feed = self.build_augmentation(self.feed, "random_cutout")
+    self.pipeline_objects.append(self.feed)
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+
+  #// To be overrided \\
+  # --------------------------------------------------------------------------------------------------------------------
+  def build_iterator(self):
+    return None
+  # --------------------------------------------------------------------------------------------------------------------
+  def build_preprocessor(self, feed):
+    return feed
+  # --------------------------------------------------------------------------------------------------------------------
+  def add_augmentation(self, augmentation_kind):
+    self.method_actions.add(augmentation_kind)
+  # --------------------------------------------------------------------------------------------------------------------
+  def build_random_shuffler(self, feed):
+    return feed
+# --------------------------------------------------------------------------------------------------------------------
+  def build_minibatch_maker(self, feed):
+    return feed
+  # --------------------------------------------------------------------------------------------------------------------
+
+
+
+

radnn/data/dataset_base.py

@@ -22,8 +22,6 @@
 # SOFTWARE.
 
 # ......................................................................................
-
-
 import numpy as np
 import pandas as pd
 from sklearn.model_selection import train_test_split
@@ -56,7 +54,7 @@ class DataSetBase(object):
       elif isinstance(self.fs, FileStore):
         self.filestore = self.fs
       elif isinstance(self.fs, str):
-        self.filestore = FileSystem(self.fs)
+        self.filestore = FileStore(self.fs)
       else:
         raise Exception("The parameter fs could be a path, a filestore or a filesystem")
     else:
@@ -88,6 +86,8 @@ class DataSetBase(object):
     self.ut_labels           = None
     self.ut_sample_count     = None
 
+    self.sample_shape = None
+
     self.card = dict()
     self.card["name"] = name
     # ................................................................
@@ -319,8 +319,6 @@ class DataSetBase(object):
         self.card["class_count"] = self.class_count
       self.card["class_names"] = self.class_names
 
-
-    print(self.card)
     filestore.json.save(self.card, f"{self.name}_card.json", is_sorted_keys=False)
   # --------------------------------------------------------------------------------------------------------------------
 

radnn/data/dataset_folder.py

@@ -0,0 +1,55 @@
+from .subset_type import SubsetType
+
+class DataSetFolder(object):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, folder_name, filestore):
+    self.folder_name = folder_name
+    self.filestore = filestore
+    self.filestore_ts = None
+    self.filestore_vs = None
+    self.filestore_ut = None
+    self.split_filestores = []
+
+    self.subfolders = self.filestore.list_folders(is_full_path=False)
+    self.is_split, sTSFolder, sVSFolder, sUTFolder = self.get_split_subfolders(self.subfolders)
+    if self.is_split:
+      if sTSFolder is not None:
+        self.filestore_ts = self.filestore.subfs(sTSFolder, must_exist=True)
+        self.split_filestores.append(self.filestore_ts)
+      if sVSFolder is not None:
+        self.filestore_vs = self.filestore.subfs(sVSFolder, must_exist=True)
+        self.split_filestores.append(self.filestore_vs)
+      if sUTFolder is not None:
+        self.filestore_ut = self.filestore.subfs(sUTFolder, must_exist=True)
+        self.split_filestores.append(self.filestore_ut)
+  # --------------------------------------------------------------------------------------------------------------------
+  def get_split_subfolders(self, folders):
+    sTSFolder = None
+    sVSFolder = None
+    sUTFolder = None
+    bIsSplit = False
+    for sFolder in folders:
+      oFolderSubsetType = SubsetType(sFolder)
+      if oFolderSubsetType.is_training_set:
+        sTSFolder = sFolder
+        bIsSplit = True
+      elif oFolderSubsetType.is_validation_set:
+        sVSFolder = sFolder
+        bIsSplit = True
+      elif oFolderSubsetType.is_unknown_test_set:
+        sUTFolder = sFolder
+        bIsSplit = True
+
+    #  When confusing terminology is uses and 'test' means 'validation'
+    if (sUTFolder is not None) and (sVSFolder is None):
+      sVSFolder = sUTFolder
+      sUTFolder = None
+
+    return bIsSplit, sTSFolder, sVSFolder, sUTFolder
+  # --------------------------------------------------------------------------------------------------------------------
+  def __str__(self):
+    return "./" + self.folder_name
+  # --------------------------------------------------------------------------------------------------------------------
+  def __repr__(self):
+    return self.__str__()
+  # --------------------------------------------------------------------------------------------------------------------

radnn/data/image_dataset.py

@@ -22,8 +22,6 @@
 # SOFTWARE.
 
 # ......................................................................................
-
-
 import numpy as np
 from radnn import FileStore
 from .dataset_base import DataSetBase

radnn/data/image_dataset_files.py

@@ -0,0 +1,175 @@
+from radnn import FileStore
+from radnn.utils import camel_case
+from radnn.system.files import FileList
+from .dataset_folder import DataSetFolder
+import sys
+from tqdm import tqdm
+from datetime import datetime
+
+class ImageDataSetFiles(object):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, images_fs, name="files", is_progress_indicator=True):
+    self.images_fs :FileStore = images_fs
+    self.name = name
+    self.is_progress_indicator = is_progress_indicator
+    self.class_names :dict = dict()
+    self.class_folders :list = []
+    self.files :FileList = dict()
+    self.files_ts :FileList = dict()
+    self.files_vs :FileList = dict()
+    self.files_ut :FileList = dict()
+    self.total_file_count = 0
+    self.is_split_on_main_folder = False
+    self.is_split_in_class_folders = False
+    self.run_date_time = None
+
+    self.detect_class_names_from_folders()
+  # --------------------------------------------------------------------------------------------------------------------
+  def load(self, extensions="*.jpg;  *.png"):
+    if not self.load_file_lists():
+      self.detect_files(extensions)
+  # --------------------------------------------------------------------------------------------------------------------
+  def load_file_lists(self):
+    bResult = False
+    oDict = self.images_fs.obj.load(f"{self.name}-file-info.pkl")
+    if oDict is not None:
+      self.run_date_time = oDict["RunDateTime"]
+      self.class_names = oDict["ClassNames"]
+      self.class_folders = oDict["ClassFolders"]
+      self.files = oDict["ClassFiles.All"]
+      self.files_ts = oDict["ClassFiles.TrainingSet"]
+      self.files_vs = oDict["ClassFiles.ValidationSet"]
+      self.files_ut = oDict["ClassFiles.UnknownTestSet"]
+      self.total_file_count = oDict["TotalFileCount"]
+      self.is_split_on_main_folder = oDict["IsSplitOnMainFolder"]
+      self.is_split_in_class_folders = oDict["IsSplitInClassFolders"]
+      bResult = True
+
+    return bResult
+  # --------------------------------------------------------------------------------------------------------------------
+  def save_file_lists(self):
+    oDict = dict()
+    oDict["RunDateTime"] = self.run_date_time
+    oDict["ClassNames"] = self.class_names
+    oDict["ClassFolders"] = self.class_folders
+    oDict["ClassFiles.All"] = self.files
+    oDict["ClassFiles.TrainingSet"] = self.files_ts
+    oDict["ClassFiles.ValidationSet"] = self.files_vs
+    oDict["ClassFiles.UnknownTestSet"] = self.files_ut
+    oDict["TotalFileCount"] = self.total_file_count
+    oDict["IsSplitOnMainFolder"] = self.is_split_on_main_folder
+    oDict["IsSplitInClassFolders"] = self.is_split_in_class_folders
+    self.images_fs.obj.save(oDict, f"{self.name}-file-info.pkl")
+  # --------------------------------------------------------------------------------------------------------------------
+  def detect_class_names_from_folders(self):
+    oClassNamesFS = self.images_fs
+    oMainFolder = DataSetFolder("/", self.images_fs)
+    oFolders = oMainFolder.subfolders
+
+    self.is_split_on_main_folder = oMainFolder.is_split
+    if self.is_split_on_main_folder:
+      # Detect the class names under the training set subfolder
+      oClassNamesFS = oMainFolder.filestore_ts
+      oFolders = oClassNamesFS.list_folders(is_full_path=False)
+
+    for nIndex, sFolder in enumerate(oFolders):
+      sClassName = camel_case(sFolder)
+      self.class_names[nIndex] = sClassName
+      oClassFS = oClassNamesFS.subfs(sFolder, must_exist=True)
+      oClassFolder = DataSetFolder(sFolder, oClassFS)
+      if not self.is_split_on_main_folder:
+        if oClassFolder.is_split:
+          self.is_split_in_class_folders = True
+      self.class_folders.append(oClassFolder)
+
+    return self.class_folders
+
+  # --------------------------------------------------------------------------------------------------------------------
+  def traverse_sub_folders(self, extensions, progress):
+    for nClassIndex, oClassFolder in enumerate(self.class_folders):
+      if progress is not None:
+        progress.set_description(f"Finding files for class {self.class_names[nClassIndex]}")
+        progress.refresh()
+      self.files[nClassIndex] = oClassFolder.filestore.filelist(extensions)
+      self.total_file_count += len(self.files[nClassIndex])
+      if progress is not None:
+        progress.update(1)
+  # --------------------------------------------------------------------------------------------------------------------
+  def traverse_sub_folders_with_split(self, extensions, progress):
+    self.total_file_count = 0
+    for nClassIndex, oClassFolder in enumerate(self.class_folders):
+      if progress is not None:
+        progress.set_description(f"Finding files for class {self.class_names[nClassIndex]}")
+        progress.refresh()
+      if oClassFolder.is_split:
+        oClassAllFiles = FileList()
+        for nIndex, oSplitFileStore in enumerate(oClassFolder.split_filestores):
+          if oSplitFileStore is not None:
+            oFileList = oSplitFileStore.filelist(extensions)
+            for oFile in oFileList.full_paths:
+              dSplit = None
+              if oSplitFileStore == oClassFolder.filestore_ts:
+                dSplit = self.files_ts
+              elif oSplitFileStore == oClassFolder.filestore_vs:
+                dSplit = self.files_vs
+              elif oSplitFileStore == oClassFolder.filestore_ut:
+                dSplit = self.files_ut
+
+              if dSplit is not None:
+                if nClassIndex not in dSplit:
+                  dSplit[nClassIndex] = []
+                dSplit[nClassIndex].append(oFile)
+
+              oClassAllFiles.append(oFile)
+      else:
+        raise Exception(f"No split subfolders for class {nIndex} '{self.class_names[nIndex]}',\n"
+                        + f"that is stored in {oClassFolder.filestore}\n"
+                        + f"All of the classes should have the same split.")
+      self.files[nClassIndex] = oClassAllFiles
+      self.total_file_count += len(self.files[nClassIndex])
+      if progress is not None:
+        progress.update(1)
+
+
+    if progress is not None:
+      progress.set_description("Finished")
+      progress.refresh()
+  # --------------------------------------------------------------------------------------------------------------------
+  def detect_files(self, extensions="*.jpg;  *.png"):
+    oProgress = None
+    if len(self.class_folders) > 0:
+      if (not self.is_split_on_main_folder) and (not self.is_split_in_class_folders):
+        if self.is_progress_indicator:
+          oProgress = tqdm(total=len(self.class_folders), ncols=80)
+        try:
+          self.traverse_sub_folders(extensions, oProgress)
+        finally:
+          if self.is_progress_indicator:
+            oProgress.close()
+
+      elif (not self.is_split_on_main_folder) and self.is_split_in_class_folders:
+        if self.is_progress_indicator:
+          oProgress = tqdm(total=len(self.class_folders), ncols=80)
+        try:
+          self.traverse_sub_folders_with_split(extensions, oProgress)
+        finally:
+          if self.is_progress_indicator:
+            oProgress.close()
+
+      self.save_file_lists()
+  # --------------------------------------------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

radnn/data/preprocess/normalizer.py

@@ -22,7 +22,6 @@
 # SOFTWARE.
 
 # ......................................................................................
-
 import numpy as np
 
 '''
@@ -90,6 +89,7 @@ class Normalizer(object):
       if is_verbose:
         print("  Normalization: min/max shape:%s" % str(self.min.shape))
       self.save()
+    return self
   # --------------------------------------------------------------------------------------------------------------------
   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)
@@ -109,3 +109,9 @@ class Normalizer(object):
     nDenormalizedData = (data * (self.max - self.min)) + self.min
     return nDenormalizedData.astype(data.dtype)
   # --------------------------------------------------------------------------------------------------------------------
+  def __str__(self):
+    return f"Normalizer: min={self.min} max={self.max}"
+  # --------------------------------------------------------------------------------------------------------------------
+  def __repr__(self):
+    return self.__str__()
+  # --------------------------------------------------------------------------------------------------------------------

radnn/data/preprocess/standardizer.py

@@ -22,7 +22,6 @@
 # SOFTWARE.
 
 # ......................................................................................
-
 import numpy as np
 
 '''
@@ -52,7 +51,7 @@ class Standardizer(object):
       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):
+  def fit(self, data, axis_for_stats=None, 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:
@@ -79,6 +78,8 @@ class Standardizer(object):
       if is_verbose:
         print("  Standardization: mean/std shape:%s" % str(self.mean.shape))
       self.save()
+
+    return self
   # --------------------------------------------------------------------------------------------------------------------
   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)
@@ -98,3 +99,9 @@ class Standardizer(object):
     nNonStandardizedData = (data * self.std) + self.mean
     return nNonStandardizedData.astype(data.dtype)
   # --------------------------------------------------------------------------------------------------------------------
+  def __str__(self):
+    return f"Standardizer: mean={self.mean} std={self.std}"
+  # --------------------------------------------------------------------------------------------------------------------
+  def __repr__(self):
+    return self.__str__()
+  # --------------------------------------------------------------------------------------------------------------------