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

radnn/__init__.py

@@ -3,14 +3,14 @@
 # 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"
+# Version 0.0.8    [2025-02-25]
+# Version 0.0.9    [2025-04-15]
+# Version 0.1.0    [2026-01-06]
+# Version 0.1.1    [2025-01-xx]
+__version__ = "0.1.0"
 
 from .system import FileStore, FileSystem
 from .ml_system import MLSystem
 from .ml_system import mlsys
 from .utils import print_tensor
 from .errors import Errors
-
-
-

radnn/benchmark/__init__.py

@@ -0,0 +1 @@
+from .latency import timed_method, mlbench

radnn/benchmark/latency.py

@@ -0,0 +1,55 @@
+import numpy as np
+import time
+import functools
+
+
+class LatencyBenchmark(dict):
+  def __init__(self):
+    self.enabled = False
+  
+  def stats(self, key):
+    nSeries = np.asarray(self.get(key, [0.0]), np.float32)
+    nMean = np.mean(nSeries)
+    nStd = np.std(nSeries)
+    nMax = np.max(nSeries)
+    nMin = np.min(nSeries)
+    return nMin, nMax, nMean, nStd
+
+    
+
+mlbench = LatencyBenchmark()
+
+
+def timed_method(name: str | None = None):
+  """
+  Decorator to measure elapsed time using a high-resolution timer.
+
+  Usage:
+      @timeit()
+      def f(...):
+
+      @timeit("custom_name")
+      def g(...):
+  """
+  
+  def decorator(func):
+    label = name or func.__qualname__
+    
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+      if not mlbench.enabled:
+        return func(*args, **kwargs)
+      else:
+        start = time.perf_counter()
+        try:
+          return func(*args, **kwargs)
+        finally:
+          end = time.perf_counter()
+          elapsed = end - start
+          if not label in mlbench:
+            mlbench[label] = []
+          mlbench[label].append(elapsed * 1e3)
+    
+    return wrapper
+  
+  return decorator

radnn/core.py

@@ -6,7 +6,7 @@
 # ______________________________________________________________________________________
 # ......................................................................................
 
-# Copyright (c) 2018-2025 Pantelis I. Kaplanoglou
+# Copyright (c) 2018-2026 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
@@ -30,8 +30,23 @@
 import sys
 import socket
 import platform
+import psutil
 import subprocess
 from datetime import datetime
+import importlib
+import importlib.util
+
+
+class RequiredLibs(object):
+  def __init__(self):
+    self.is_tensorflow_installed = importlib.util.find_spec("tensorflow") is not None
+    if not self.is_tensorflow_installed:
+      self.is_tensorflow_installed = importlib.util.find_spec("tensorflow-gpu") is not None
+    self.is_torch_installed = importlib.util.find_spec("torch") is not None
+    self.is_opencv_installed = importlib.util.find_spec("cv2") is not None
+
+
+
 
 # ----------------------------------------------------------------------------------------------------------------------
 def system_name() -> str:
@@ -96,4 +111,133 @@ class MLInfrastructure(object):
         sResult = "(linux)-" + sHostName
     return sResult
   # --------------------------------------------------------------------------------------------------------------------
-# ======================================================================================================================
+# ======================================================================================================================
+
+
+
+# ======================================================================================================================
+class HardwareDevice(object):
+  def __init__(self, name):
+    self.name = name
+
+  def __str__(self):
+    return self.name
+  
+  def __repr__(self):
+    return self.__str__()
+    
+    
+# ======================================================================================================================
+class CPU(HardwareDevice):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, name):
+    super(CPU, self).__init__(name)
+    self._cpuid()
+  # --------------------------------------------------------------------------------------------------------------------
+  def _cpuid(self):
+    '''
+    CPU Identification for both Windows and Linux
+    '''
+    sPlatform = platform.system()
+    
+    if sPlatform == "Windows":
+      oCPUs = subprocess.check_output(
+        ["powershell", "-Command",
+         "(Get-CimInstance Win32_Processor | Select-Object -ExpandProperty Name) -join \"\n\""],
+        text=True
+      ).strip().splitlines()
+      
+      self.name = ""
+      for sCPU in oCPUs:
+        self.name += f', {sCPU}'
+      
+    elif sPlatform == "Darwin":
+      pass #MacOS
+    else:
+      self.name = ""
+      with open("/proc/cpuinfo") as f:
+        for line in f:
+          line = line.strip()
+          if line.startswith("model name"):
+            self.name += f', {line.split(":", 1)[1].strip()}'
+    if self.name.startswith(", "):
+      self.name = self.name[2:]
+  # --------------------------------------------------------------------------------------------------------------------
+
+
+# ======================================================================================================================
+class NeuralProcessingUnit(HardwareDevice):
+  def __init__(self, name):
+    super(NeuralProcessingUnit, self).__init__(name)
+    self.compute_capability = None
+    self.vram_in_gb = None
+    
+    
+# ======================================================================================================================
+class AIGridInfo(HardwareDevice):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, name=None):
+    self.name = name
+    if self.name is None:
+      self.name = socket.gethostname()
+    self.cpu = CPU(platform.processor())
+    
+    mem = psutil.virtual_memory()
+    total_bytes = mem.total
+    self.ram_in_gb = round(total_bytes / (1024 ** 3))
+    
+    self.devices = []
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def device(self):
+    if len(self.devices) > 0:
+      return self.devices[0]
+    else:
+      return self.cpu
+  # --------------------------------------------------------------------------------------------------------------------
+  def discover_devices(self, framework_type: str = "torch"):
+    '''
+    Detects the AI accelerators using the framework libraries
+    :param framework_type: The framework that is used "torch" or "tensorflow"
+    :return:
+    '''
+    self.cpu = CPU(platform.processor())
+    
+    if framework_type == "torch":
+      import torch
+      device_count = torch.cuda.device_count()
+      for i in range(device_count):
+        oUnit = NeuralProcessingUnit(torch.cuda.get_device_name(i))
+        oUnit.compute_capability = torch.cuda.get_device_capability(i)
+        oUnit.vram_in_gb = round(torch.cuda.get_device_properties(i).total_memory / (1024 ** 3))
+        self.devices.append(oUnit)
+    elif framework_type == "tensorflow":
+      import tensorflow as tf
+      gpus = tf.config.list_physical_devices("GPU")
+      for gpu in gpus:
+        details = tf.config.experimental.get_device_details(gpu)
+        oUnit = NeuralProcessingUnit(details["device_name"])
+        oUnit.compute_capability = details["compute_capability"]
+        print(details)
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def __str__(self):
+    sResult  = f'{"|"*24}\n'
+    sResult += f"|| [{self.name[:16]:^16}] ||\n"
+    sResult  = f'{"|"*24}\n'
+    sResult += f" |__ CPU: {self.cpu}\n"
+    sResult += f" |__ RAM: {self.ram_in_gb}  GB\n"
+    sResult += f" |__ NPUs\n"
+    for oDevice in self.devices:
+      if isinstance(oDevice, NeuralProcessingUnit):
+        sResult += f'{" "*5} |__ {oDevice.name} {oDevice.vram_in_gb} GB\n'
+      else:
+        sResult += f'{" "*5} |__ {oDevice} \n'
+    return sResult
+  # --------------------------------------------------------------------------------------------------------------------
+  def __repr__(self):
+    return self.__str__()
+  # --------------------------------------------------------------------------------------------------------------------
+    
+# ======================================================================================================================
+

radnn/data/__init__.py

@@ -1,12 +1,7 @@
-from .dataset_base import DataSetBase
-from .image_dataset import ImageDataSet
+from .dataset_base import DataSetBase, DataSetCallbacks
+from .dataset_base_legacy import CDataSetBase
+from .sequence_dataset import SequenceDataSet
 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
+from .sample_set_kind import SampleSetKind
+from .sample_preprocessor import SamplePreprocessor
 

radnn/data/dataset_base.py

@@ -22,112 +22,105 @@
 # SOFTWARE.
 
 # ......................................................................................
+import os
 import numpy as np
 import pandas as pd
-from sklearn.model_selection import train_test_split
-from radnn import FileSystem, FileStore, MLSystem, Errors
+from abc import ABC, abstractmethod
+from .sample_set import SampleSet
+from .sample_set_kind import SampleSetKind
+from .sample_preprocessor import SamplePreprocessor, VoidPreprocessor
+from .errors import *
+from radnn import FileStore
 
+# ======================================================================================================================
+class DataSetCallbacks(object):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, lazy_loader=None, random_seeder=None):
+    self.lazy_loader = lazy_loader
+    self.random_seeder = random_seeder
+  # --------------------------------------------------------------------------------------------------------------------
+  def lazy_load(self):
+    self.lazy_loader()
+  # --------------------------------------------------------------------------------------------------------------------
+  def initialize_random_seed(self, seed: int):
+    self.random_seeder(seed)
+  # --------------------------------------------------------------------------------------------------------------------
 
-class DataSetBase(object):
+
+# ======================================================================================================================
+class DataSetBase(ABC):
   # --------------------------------------------------------------------------------------------------------------------
   # Constructor
-  def __init__(self, fs=None, name=None, variant=None, random_seed=None, is_classification=False):
+  def __init__(self, name: str, variant: str|None=None, file_store=None, random_seed: int | None=None, callbacks: DataSetCallbacks | None = None):
     # ..................// Instance Fields \\.........................
-    self.name                = name
-    self.fs                  = fs
-    self.variant             = variant
-    self.ts = None
-    self.vs = None
-    self.ut = None
-
-    if self.fs is None:
-      if MLSystem.Instance().filesys is not None:
-        self.fs = MLSystem.Instance().filesys
-      else:
-        raise Exception(Errors.MLSYS_NO_FILESYS)
-
-    if self.fs is not None:
-      if isinstance(self.fs, FileSystem):
-        if variant is not None:
-          name = name + "_" + variant
-        self.filestore = self.fs.datasets.subfs(name.upper())
-      elif isinstance(self.fs, FileStore):
-        self.filestore = self.fs
-      elif isinstance(self.fs, str):
-        self.filestore = FileStore(self.fs)
-      else:
-        raise Exception("The parameter fs could be a path, a filestore or a filesystem")
-    else:
-      raise Exception("Could not determine the filestore for the dataset")
-
-    self.random_seed         = random_seed
-    self.is_classification   = is_classification
-    
-    self.feature_count       = None
-    self.class_count         = None
-    self.class_names         = None
-    self.sample_count        = None
-    
-    self.samples             = None
-    self.labels              = None
-    
-    self.ts_sample_ids       = None
-    self.ts_samples          = None
-    self.ts_labels           = None
-    self.ts_sample_count     = 0
-    
-    self.vs_sample_ids       = None
-    self.vs_samples          = None
-    self.vs_labels           = None
-    self.vs_sample_count     = 0
-    
-    self.ut_sample_ids       = None
-    self.ut_samples          = None
-    self.ut_labels           = None
-    self.ut_sample_count     = None
-
-    self.sample_shape = None
-
-    self.card = dict()
-    self.card["name"] = name
+    self.fs: FileStore|None = file_store
+    if (file_store is not None) and isinstance(file_store, str):
+      if not os.path.exists(file_store):
+        raise Exception(ERR_DATASET_FOLDER_NOT_FOUND % file_store)
+      self.fs = FileStore(file_store)
+    assert self.fs is not None, ERR_DATASET_MUST_PROVIDE_LOCAL_FILESTORE
+
+    self.name                 = name
+    self.variant              = variant
+    self.random_seed          = random_seed
+    self.callbacks: DataSetCallbacks = callbacks
+
+    self.hparams :dict|None = None
+    self.ts: SampleSet|None = None
+    self.vs: SampleSet|None = None
+    self.ut: SampleSet|None = None
+    self.preprocessor: SamplePreprocessor = VoidPreprocessor(self)
     # ................................................................
-    if self.random_seed is not None:
-      MLSystem.Instance().random_seed_all(self.random_seed)
+    if (self.random_seed is not None):
+      assert self.callbacks is not None, ERR_NO_CALLBACKS
+      assert self.callbacks.random_seeder is not None, ERR_NO_RANDOM_SEED_INITIALIZER_CALLBACK
+      self.callbacks.initialize_random_seed(self.random_seed)
 
   # --------------------------------------------------------------------------------------------------------------------
-  def open(self):
-    pass
+  @property
+  def filesystem_folder(self):
+      return self.fs.absolute_path
   # --------------------------------------------------------------------------------------------------------------------
-  def close(self):
-    pass
+  @abstractmethod
+  def do_read_hyperparams(self):
+    pass # must implement concrete method
   # --------------------------------------------------------------------------------------------------------------------
-  def for_classification(self, class_count, class_names=None):
-    self.is_classification = True
-    self.class_count = class_count
-    if class_names is not None:
-      # We assume class_names is a dictionary, in other cases we turn it into a dictionary
-      if isinstance(class_names, set) or isinstance(class_names, list):
-        dClassNames = dict()
-        for nIndex, sClassName in enumerate(class_names):
-          dClassNames[nIndex] = sClassName
-        class_names = dClassNames
-      self.class_names = class_names
-    return self
+  @abstractmethod
+  def do_import_data(self):
+    pass # must implement concrete method
+  # --------------------------------------------------------------------------------------------------------------------
+  @abstractmethod
+  def do_prepare_data(self):
+    pass # could optionally override
+  # --------------------------------------------------------------------------------------------------------------------
+  @abstractmethod
+  def do_create_sample_sets(self):
+    pass # must implement concrete method
   # --------------------------------------------------------------------------------------------------------------------
-  def count_samples(self):
-    if self.ts_samples is not None:
-      self.ts_sample_count = int(self.ts_samples.shape[0])
-      self.sample_count = self.ts_sample_count + self.vs_sample_count
+  def prepare(self, hyperparams: dict|None = None):
+    self.hparams = hyperparams
+    if self.hparams is not None:
+      self.do_read_hyperparams()
 
-    if self.vs_samples is not None:
-      self.vs_sample_count = int(self.vs_samples.shape[0])
-      self.sample_count = self.ts_sample_count + self.vs_sample_count
+    if (self.callbacks is not None):
+      if self.callbacks.lazy_loader is not None:
+        self.callbacks.lazy_loader()
+    self.do_import_data()
+    self.do_prepare_data()
+
+    self.ts = None
+    self.vs = None
+    self.us = None
+    self.do_create_sample_sets()
 
-    # The test set samples are not included in the available sample count
-    if self.ut_samples is not None:
-      self.ut_sample_count = int(self.ut_samples.shape[0])
+    assert self.ts is not None, ERR_SUBSET_MUST_HAVE_TS
+    assert self.ts.info.kind == SampleSetKind.TRAINING_SET.value, ERR_SUBSET_INVALID_SETUP
+    if self.vs is not None:
+      assert self.ts.info.kind == SampleSetKind.TRAINING_SET.value, ERR_SUBSET_INVALID_SETUP
+    if self.us is not None:
+      assert self.ts.info.kind == SampleSetKind.TRAINING_SET.value, ERR_SUBSET_INVALID_SETUP
   # --------------------------------------------------------------------------------------------------------------------
-  def assign(self, data, label_start_column=None, label_end_column=None):
+  def assign(self, data, label_columns: range):
     if isinstance(data, tuple):
       self.samples, self.labels = data
     elif isinstance(data, np.ndarray):
@@ -144,182 +137,29 @@ class DataSetBase(object):
       else:
         nData = data.to_numpy()
 
-      if label_start_column is None:
+      if label_columns is None:
         self.samples = nData
       else:
-        if label_start_column >= 0:
-          if label_end_column is None:
-            self.labels = nData[:, label_start_column]
-            self.samples = nData[:, label_start_column + 1:]
+        if label_columns.start >= 0:
+          if label_columns.stop is None:
+            self.labels = nData[:, label_columns.start]
+            self.samples = nData[:, label_columns.start + 1:]
           else:
-            self.labels = nData[:, label_start_column:label_end_column + 1]
-            self.samples = nData[:, label_end_column + 1:]
+            self.labels = nData[:, label_columns.start:label_columns.stop + 1]
+            self.samples = nData[:, label_columns.stop + 1:]
         else:
-          self.samples = nData[:, :label_start_column]
-          self.labels  = nData[:, label_start_column:]
-    return self
-  # --------------------------------------------------------------------------------------------------------------------
-  def assign_training_set(self, samples, labels):
-    self.ts_samples = samples
-    self.ts_labels = labels
-    self.count_samples()
-    self.ts_sample_ids = np.arange(0, self.ts_sample_count)
-        
-    # Feature count is calculated on samples that are flattened as vectors
-    if self.feature_count is None:
-      self.feature_count = np.prod(self.ts_samples.shape[1:])
-      
-    if self.class_count is None:
-      if self.is_classification:
-        self.class_count = len(np.unique(self.ts_labels))
-      else:
-        self.class_count = 0
-    return self
-  # --------------------------------------------------------------------------------------------------------------------
-  def assign_validation_set(self, samples, labels):
-    self.vs_samples = samples
-    self.vs_labels = labels
-    self.count_samples()
-    self.vs_sample_ids = np.arange(0, self.vs_sample_count)
-
+          self.samples = nData[:, :label_columns.start]
+          self.labels  = nData[:, label_columns.start:]
     return self
   # --------------------------------------------------------------------------------------------------------------------
-  def assign_unknown_test_set(self, samples, labels):
-    self.ut_samples = samples
-    self.ut_labels = labels
-    self.count_samples()
-    self.ut_sample_ids = np.arange(0, self.ut_sample_count)
-
-    return self
-  # --------------------------------------------------------------------------------------------------------------------
-  def infox(self):
-    self.print_info()
-  # --------------------------------------------------------------------------------------------------------------------
   def print_info(self):
-    print("Dataset [%s]" % self.name)
-    print("  |__ FeatureCount:", self.feature_count)
-    if self.is_classification:
-      print("  |__ ClassCount:", self.class_count)
-      if self.class_names is not None:
-        print("        |__ Classes:", self.class_names)
-    
-    if self.ts_samples is not None:
-      print("  |__ Training set samples  : %d   shape:%s" % (self.ts_sample_count, self.ts_samples.shape))
-    if self.ts_labels is not None:
-      print("  |__ Training set targets  : %d   shape:%s" % (self.ts_sample_count, self.ts_labels.shape))
-      
-    if self.vs_samples is not None:
-      print("  |__ Validation set samples: %d   shape:%s" % (self.vs_sample_count, self.vs_samples.shape))
-    if self.vs_labels is not None:
-      print("  |__ Validation set targets: %d   shape:%s" % (self.vs_sample_count, self.vs_labels.shape))
-      
-    if self.ut_samples is not None:
-      print("  |__ MemoryTest set samples      : %d   shape:%s" % (self.ut_sample_count, self.ut_samples.shape))
-    if self.ut_labels is not None:
-      print("  |__ MemoryTest set targets      : %d   shape:%s" % (self.ut_sample_count, self.ut_labels.shape))
-  # --------------------------------------------------------------------------------------------------------------------
-  def split(self, training_samples_pc, random_seed=None):
-    if random_seed is None:
-      random_seed = self.random_seed
-
-    nTSSamples, nVSSamples, nTSTargets, nVSTargets = train_test_split(self.samples, self.labels
-                                                                      , test_size=1.0 - training_samples_pc
-                                                                      , random_state=random_seed
-                                                                      , shuffle=True
-                                                                      , stratify=self.labels
-                                                                      )
-    self.assign_training_set(nTSSamples, nTSTargets)
-    self.assign_validation_set(nVSSamples, nVSTargets)
-    self.count_samples()
-    return self
-  # --------------------------------------------------------------------------------------------------------------------
-  def has_cache(self, samples_file_prefix="Samples"):
-    return self.filestore.exists("%s.pkl" % samples_file_prefix) or self.filestore.exists("%s.TS.pkl" % samples_file_prefix)
-  # --------------------------------------------------------------------------------------------------------------------
-  def load_cache(self, filestore: FileStore = None, samples_file_prefix="Samples", targets_file_prefix="Labels", is_verbose=False):
-    if filestore is None:
-      filestore = self.filestore
-    if filestore is None:
-      raise Exception("To use load_cache() without providing a filestore, you should provide a filesystem or filestore during instantiation.")
-
-    bResult = filestore.exists("%s.pkl" % samples_file_prefix) or filestore.exists("%s.TS.pkl" % samples_file_prefix)
-    
-    if bResult:
-      if is_verbose:
-        print("Loading known data set ...")
-
-      dInfo = filestore.json.load(f"{self.name}_info.json")
-      if dInfo is not None:
-        if "class_names" in dInfo:    self.class_names = dInfo["class_names"]
-        if "feature_count" in dInfo:  self.feature_count = dInfo["feature_count"]
-        if "class_count" in dInfo:
-          self.is_classification = True
-          self.class_count = dInfo["class_count"]
-
-      self.samples   = filestore.obj.load("%s.pkl" % samples_file_prefix)
-      self.labels    = filestore.obj.load("%s.pkl" % targets_file_prefix)
-    
-      if is_verbose:
-        print("Loading training set ...")      
-      nTSSamples  = filestore.obj.load("%s.TS.pkl" % samples_file_prefix)
-      nTSTargets   = filestore.obj.load("%s.TS.pkl" % targets_file_prefix)
-      self.assign_training_set(nTSSamples, nTSTargets)
-      
-      if is_verbose:
-        print("Loading validation set ...")            
-      nVSSamples  = filestore.obj.load("%s.VS.pkl" % samples_file_prefix)
-      nVSTargets  = filestore.obj.load("%s.VS.pkl" % targets_file_prefix)
-      self.assign_validation_set(nVSSamples, nVSTargets)
-      
-      if is_verbose:
-        print("Loading unknown test data set ...")            
-      nUTSamples  = filestore.obj.load("%s.UT.pkl" % samples_file_prefix)
-      if nUTSamples is not None:
-        nUTTargets   = filestore.obj.load("%s.UT.pkl" % targets_file_prefix)
-        self.assign_unknown_test_set(nUTSamples, nUTTargets)
-
-
-    return bResult
-  # --------------------------------------------------------------------------------------------------------------------
-  def save_cache(self, filestore: FileStore = None, samples_file_prefix="Samples", targets_file_prefix="Labels"):
-    if filestore is None:
-      filestore = self.filestore
-    if filestore is None:
-      raise Exception("To use save_cache() without providing a filestore, you should provide a filesystem or filestore during instantiation.")
-
-    if self.samples is not None:
-      filestore.obj.save(self.samples, "%s.pkl" % samples_file_prefix, is_overwriting=True)
-      filestore.obj.save(self.labels, "%s.pkl" % targets_file_prefix, is_overwriting=True)
-
-    filestore.obj.save(self.ts_samples, "%s.TS.pkl" % samples_file_prefix, is_overwriting=True)
-    filestore.obj.save(self.ts_labels, "%s.TS.pkl" % targets_file_prefix, is_overwriting=True)
-
-    filestore.obj.save(self.vs_samples, "%s.VS.pkl" % samples_file_prefix, is_overwriting=True)
-    filestore.obj.save(self.vs_labels, "%s.VS.pkl" % targets_file_prefix, is_overwriting=True)
-
-    if self.ut_samples is not None:
-      filestore.obj.save(self.ut_samples, "%s.UT.pkl" % samples_file_prefix, is_overwriting=True)
-      filestore.obj.save(self.ut_labels, "%s.UT.pkl" % targets_file_prefix, is_overwriting=True)
-
-    self.card["name"] = self.name
-    if self.feature_count is not None:
-      self.card["feature_count"] = int(self.feature_count)
+    if self.variant is not None:
+      print(f"Dataset [{self.name}] {self.variant}")
     else:
-      self.card["feature_count"] = self.feature_count
-
-    if self.random_seed is not None:
-      self.card["random_seed"] = int(self.random_seed)
-    else:
-      self.card["random_seed"] = self.random_seed
-
-    if self.is_classification:
-      if self.class_count is not None:
-        self.card["class_count"] = int(self.class_count)
-      else:
-        self.card["class_count"] = self.class_count
-      self.card["class_names"] = self.class_names
-
-    filestore.json.save(self.card, f"{self.name}_card.json", is_sorted_keys=False)
+      print(f"Dataset [{self.name}]")
+    self.ts.print_info()
+    if self.vs is not None:
+      self.vs.print_info()
+    if self.ut is not None:
+      self.ut.print_info()
   # --------------------------------------------------------------------------------------------------------------------
-
-