radnn 0.0.9__tar.gz → 0.1.1__tar.gz

{radnn-0.0.9 → radnn-0.1.1}/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2025 Pantelis I. Kaplanoglou
+Copyright (c) 2017-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

{radnn-0.0.9/src/radnn.egg-info → radnn-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: radnn
-Version: 0.0.9
+Version: 0.1.1
 Summary: Rapid Deep Neural Networks
 Author-email: "Pantelis I. Kaplanoglou" <pikaplanoglou@ihu.gr>
 License-Expression: MIT
@@ -18,20 +18,14 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.7
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy>=1.26.4
 Requires-Dist: matplotlib>=3.8.4
 Requires-Dist: pandas>=2.2.1
 Requires-Dist: scikit-learn>=1.4.2
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: psutil>=5.9.5
 Dynamic: license-file
-
-# radnn - Rapid Deep Neural Networks
-
-A library that brings the Rapid Application Development (RAD) approach into the lifecycle of Deep Learning models. Adapts objects from other frameworks and hides their implementation details to put emphasis on:
-
-- Experiments: Data, Models, Training, Reproducibility
-- Management: Process, Storage, Deployment
-- Evaluation: Metrics, Plots, Visualizations
-- Integration: IPC, Web API

{radnn-0.0.9 → radnn-0.1.1}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "radnn"
-version = "0.0.9"
+version = "0.1.1"
 description = "Rapid Deep Neural Networks"
 readme = "README.md"
 authors = [
     {name = "Pantelis I. Kaplanoglou", email = "pikaplanoglou@ihu.gr"}
 ]
-requires-python = ">=3.7"
+requires-python = ">=3.10"
 license = "MIT"
 license-files = ["LICENSE.txt"]
 classifiers=[
@@ -22,12 +22,15 @@ classifiers=[
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12"
 ]
 dependencies = [
-"numpy >= 1.26.4",
-"matplotlib >= 3.8.4",
-"pandas >= 2.2.1",
-"scikit-learn >= 1.4.2"
+    "numpy >= 1.26.4",
+    "matplotlib >= 3.8.4",
+    "pandas >= 2.2.1",
+    "scikit-learn >= 1.4.2",
+	"tqdm >= 4.67.1",
+	"psutil >= 5.9.5"
 ]
 
 [project.urls]

{radnn-0.0.9 → radnn-0.1.1}/setup.cfg

@@ -1,6 +1,6 @@
 [options]
 packages = find:
-python_requires = > 3.7
+python_requires = > 3.10
 include_package_data = True
 
 [aliases]

{radnn-0.0.9 → radnn-0.1.1}/src/radnn/__init__.py

@@ -4,14 +4,13 @@
 # Version 0.0.7.2  [2025-02-17]
 # Version 0.0.7.3  [2025-02-21]
 # Version 0.0.8    [2025-02-25]
-# Version 0.0.9    [2025-03-xx]
-__version__ = "0.0.9"
+# Version 0.0.9    [2025-04-15]
+# Version 0.1.0    [2026-01-07]
+# Version 0.1.1    [2025-01-08]
+__version__ = "0.1.1"
 
 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-0.1.1/src/radnn/benchmark/__init__.py

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

radnn-0.1.1/src/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-0.1.1/src/radnn/core.py

@@ -0,0 +1,243 @@
+# ======================================================================================
+#
+#     Rapid Deep Neural Networks
+#
+#     Licensed under the MIT License
+# ______________________________________________________________________________________
+# ......................................................................................
+
+# 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
+# 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 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:
+  return MLInfrastructure.host_name(False)
+# ----------------------------------------------------------------------------------------------------------------------
+def now_iso():
+  return datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+# ----------------------------------------------------------------------------------------------------------------------
+def shell_command_output(command_string):
+  oOutput = subprocess.check_output(command_string, shell=True)
+  oOutputLines = oOutput.decode().splitlines()
+
+  oResult = []
+  for sLine in oOutputLines:
+      oResult.append(sLine)
+
+  return oResult
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+
+
+
+# ======================================================================================================================
+class MLInfrastructure(object):
+  # --------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def is_linux(cls):
+    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()
+    sHostName = socket.gethostname()
+    sIPAddress = socket.gethostbyname(sHostName)
+
+    bIsColab = "google.colab" in sys.modules
+    if bIsColab:
+      sResult = "(colab)"
+      if is_using_ip_address:
+        sResult += "-" + sIPAddress
+    else:
+      if sPlatform == "Windows":
+        sResult = "(windows)-" + sHostName
+      elif sPlatform == "Darwin":
+        sResult = "(macos)-" + sHostName
+      else:
+        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-0.1.1/src/radnn/data/__init__.py

@@ -0,0 +1,7 @@
+from .dataset_base import DataSetBase, DataSetCallbacks
+from .dataset_base_legacy import CDataSetBase
+from .sequence_dataset import SequenceDataSet
+from .sample_set import SampleSet
+from .sample_set_kind import SampleSetKind
+from .sample_preprocessor import SamplePreprocessor
+

radnn-0.1.1/src/radnn/data/dataset_base.py

@@ -0,0 +1,165 @@
+# ......................................................................................
+# 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.
+
+# ......................................................................................
+import os
+import numpy as np
+import pandas as pd
+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(ABC):
+  # --------------------------------------------------------------------------------------------------------------------
+  # Constructor
+  def __init__(self, name: str, variant: str|None=None, file_store=None, random_seed: int | None=None, callbacks: DataSetCallbacks | None = None):
+    # ..................// Instance Fields \\.........................
+    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):
+      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)
+
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def filesystem_folder(self):
+      return self.fs.absolute_path
+  # --------------------------------------------------------------------------------------------------------------------
+  @abstractmethod
+  def do_read_hyperparams(self):
+    pass # must implement concrete method
+  # --------------------------------------------------------------------------------------------------------------------
+  @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 prepare(self, hyperparams: dict|None = None):
+    self.hparams = hyperparams
+    if self.hparams is not None:
+      self.do_read_hyperparams()
+
+    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()
+
+    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_columns: range):
+    if isinstance(data, tuple):
+      self.samples, self.labels = data
+    elif isinstance(data, np.ndarray):
+      self.samples = data
+    elif isinstance(data, dict):
+      if ("samples" in dict) and ("labels" in dict):
+        self.samples = data["samples"]
+        self.labels = data["labels"]
+      else:
+        pass # Support other formats
+    elif isinstance(data, pd.DataFrame):
+      if isinstance(data.columns, pd.Index):
+        nData = data.iloc[1:].to_numpy()
+      else:
+        nData = data.to_numpy()
+
+      if label_columns is None:
+        self.samples = nData
+      else:
+        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_columns.start:label_columns.stop + 1]
+            self.samples = nData[:, label_columns.stop + 1:]
+        else:
+          self.samples = nData[:, :label_columns.start]
+          self.labels  = nData[:, label_columns.start:]
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def print_info(self):
+    if self.variant is not None:
+      print(f"Dataset [{self.name}] {self.variant}")
+    else:
+      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()
+  # --------------------------------------------------------------------------------------------------------------------