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

radnn/data_beta/sample_set.py

@@ -0,0 +1,166 @@
+# ......................................................................................
+# 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
+
+
+
+class SampleSet(object):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, subset_type="custom", has_ids=False):
+    self.subset_type: SubsetType = SubsetType(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 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.subset_type.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.subset_type.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.subset_type.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_beta/sequence_dataset.py

@@ -0,0 +1,134 @@
+# ......................................................................................
+# 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/data_beta/structures/__init__.py

@@ -0,0 +1,2 @@
+from .dictionary import Dictionary
+

radnn/data_beta/structures/dictionary.py

@@ -0,0 +1,41 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2013 Andy Hayden
+
+# 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.
+
+# ......................................................................................
+# Based on the blog post:  https://andyhayden.com/2013/dotable-dictionaries
+class Dictionary(dict):
+  __getattr__ = dict.__getitem__
+
+  def __init__(self, d):
+    super().__init__()
+    self.update(**dict((k, self.parse(v))
+                       for k, v in d.iteritems()))
+
+  @classmethod
+  def parse(cls, v):
+    if isinstance(v, dict):
+      return cls(v)
+    elif isinstance(v, list):
+      return [cls.parse(i) for i in v]
+    else:
+      return v

radnn/{data → data_beta}/tf_classification_data_feed.py

@@ -28,9 +28,12 @@
 
 # ......................................................................................
 
-import tensorflow as tf
+from radnn.core import RequiredLibs
+oReqs = RequiredLibs()
+if oReqs.is_tensorflow_installed:
+  import tensorflow as tf
 from radnn import mlsys
-from radnn.data.preprocess import Normalizer, Standardizer
+from radnn.data_beta.preprocess import Normalizer, Standardizer
 from .data_feed import DataFeed
 
 class TFClassificationDataFeed(DataFeed):

radnn/errors.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
@@ -28,4 +28,12 @@
 
 # .......................................................................................
 class Errors:
-  MLSYS_NO_FILESYS = "No file system defined for the machine learning system. Create the object and assign the mlsys.filesys property."
+  MLSYS_NO_FILESYS = "No file system defined for the machine learning system. Create the object and assign the mlsys.filesys property."
+  
+  
+HPARAMS_DATA_INPUT_DIMS = "Invalid data hyperparameters: The sample rank dimensions for the model's input tensor have not been defined."
+
+FILESTORE_DATAFILE_KIND_NOT_SUPPORTED = "Data file kind {%s} is not supported."
+TRAINER_LR_SCHEDULER_INVALID_SETUP = "The learning rate scheduler step list is missing or invalid."
+TRAINER_LR_SCHEDULER_INVALID_MILESTONE_SETUP = "The learning rate change milestone list is missing or invalid."
+TRAINER_LR_SCHEDULER_UNSUPPORTED = "The learning rate scheduler is not supported."

radnn/experiment/__init__.py

@@ -1,4 +1,6 @@
 from .ml_experiment_config import get_experiment_code, get_experiment_code_ex, experiment_number_and_variation, experiment_code_and_timestamp
 from .ml_experiment_config import MLExperimentConfig
 from .ml_experiment_env import MLExperimentEnv
+from .ml_experiment_log import MLExperimentLog
+from .identification import experiment_fold_number, experiment_name_with_fold
 

radnn/experiment/identification.py

@@ -0,0 +1,7 @@
+def experiment_fold_number(hyperparams: dict):
+  return hyperparams.get("Experiment.FoldNumber", hyperparams.get("Dataset.FoldNumber", 0))
+  
+def experiment_name_with_fold(hyperparams: dict):
+  nFoldNumber = hyperparams.get("Experiment.FoldNumber", hyperparams.get("Dataset.FoldNumber", 0))
+  sExperimentName = hyperparams.get("Experiment.Name", "noname")
+  return f"{sExperimentName}.{nFoldNumber}"

radnn/experiment/ml_experiment.py

@@ -30,10 +30,15 @@
 import os
 import numpy as np
 from datetime import datetime
-from tensorflow import keras
+
+from radnn.core import RequiredLibs
+oReqs = RequiredLibs()
+if oReqs.is_tensorflow_installed:
+  from tensorflow import keras
+  
 from radnn import MLSystem, FileSystem, FileStore, Errors
 from radnn.data import DataSetBase
-from radnn.learn import LearningAlgorithm
+from radnn.learn.keras import KLearningAlgorithm
 
 from radnn.plots import PlotLearningCurve
 from radnn.evaluation import EvaluateClassification

radnn/experiment/ml_experiment_log.py

@@ -0,0 +1,47 @@
+from radnn.system.filesystem import FileStore
+class MLExperimentLog:
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, filename: str, experiment_info: dict | None = None):
+    self.filename = filename
+    if experiment_info is None:
+      experiment_info = {}
+    self.experiment_info = experiment_info
+    self.logs = { "experiment": experiment_info,
+                  "epoch": [],
+                  "epoch_time": [],
+                  "train_step_loss": [],
+                  "train_step_accuracy": [],
+                  "train_loss": [],
+                  "train_accuracy": [],
+                  "val_loss": [],
+                  "val_accuracy": [],
+            }
+  # --------------------------------------------------------------------------------------------------------------------
+  def assign_series(self, is_autoinit=False, **kwargs):
+    if is_autoinit:
+      for key, value in kwargs.items():
+        if key not in self.logs:
+          self.logs[key] = []
+      
+    for key, value in kwargs.items():
+      self.logs[key] = value
+  # --------------------------------------------------------------------------------------------------------------------
+  def append(self, is_autoinit=False, **kwargs):
+    if is_autoinit:
+      for key, value in kwargs.items():
+        if key not in self.logs:
+          self.logs[key] = []
+
+    for key, value in kwargs.items():
+      self.logs[key].append(value)
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def load(self, experiment_fs: FileStore):
+    self.logs = experiment_fs.json.load(self.filename)
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def save(self, experiment_fs: FileStore):
+    experiment_fs.json.save(self.logs, self.filename)
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+    

radnn/images/image_processor.py

@@ -1,5 +1,8 @@
 import numpy as np
-import cv2
+from radnn.core import RequiredLibs
+oReqs = RequiredLibs()
+if oReqs.is_opencv_installed:
+  import cv2
 from PIL import Image, ImageChops, ImageFilter, ImageDraw
 from .colors import color
 

radnn/learn/__init__.py

@@ -1,7 +0,0 @@
-from radnn import mlsys
-
-if mlsys.is_tensorflow_installed:
-  from .keras_optimization_algorithm import KOptimizationAlgorithm
-  from .keras_learning_rate_scheduler import KLearningRateScheduler
-
-from .learning_algorithm import LearningAlgorithm

radnn/learn/keras/__init__.py

@@ -0,0 +1,4 @@
+from .keras_best_state_saver import KBestStateSaver
+from .keras_optimization_combo import KOptimizationCombo
+from .keras_learning_rate_scheduler import KLearningRateScheduler
+from .keras_learning_algorithm import KLearningAlgorithm

radnn/learn/{state → keras}/keras_best_state_saver.py

@@ -1,5 +1,9 @@
 import os
-import tensorflow.keras as ker
+
+from radnn.core import RequiredLibs
+oReqs = RequiredLibs()
+if oReqs.is_tensorflow_installed:
+  import tensorflow.keras as ker
 
 class KBestStateSaver(object):
   # -----------------------------------------------------------------------------------

radnn/learn/{learning_algorithm.py → keras/keras_learning_algorithm.py}

@@ -1,10 +1,6 @@
-from radnn import mlsys
+from radnn.learn.keras.keras_optimization_combo import KOptimizationCombo
 
-
-if mlsys.is_tensorflow_installed:
-  from .keras_optimization_algorithm import KOptimizationAlgorithm
-
-class LearningAlgorithm(object):
+class KLearningAlgorithm(object):
   # -----------------------------------------------------------------------------------
   def __init__(self, config, is_verbose=True):
     self.config = config
@@ -17,7 +13,7 @@ class LearningAlgorithm(object):
   def optimizer(self):
     oResult = None
     if self._implementation is not None:
-      if isinstance(self._implementation, KOptimizationAlgorithm):
+      if isinstance(self._implementation, KOptimizationCombo):
         oResult = self._implementation.optimizer
     return oResult
   # -----------------------------------------------------------------------------------
@@ -25,12 +21,12 @@ class LearningAlgorithm(object):
   def callbacks(self):
     oResult = None
     if self._implementation is not None:
-      if isinstance(self._implementation, KOptimizationAlgorithm):
+      if isinstance(self._implementation, KOptimizationCombo):
         oResult = self._implementation.callbacks
     return oResult
   # -----------------------------------------------------------------------------------
   def prepare(self):
     if mlsys.is_tensorflow_installed:
-      self._implementation = KOptimizationAlgorithm(self.config, self.is_verbose)
+      self._implementation = KOptimizationCombo(self.config, self.is_verbose)
     return self
   # -----------------------------------------------------------------------------------

radnn/learn/{keras_learning_rate_scheduler.py → keras/keras_learning_rate_scheduler.py}

@@ -1,4 +1,7 @@
-import tensorflow.keras as ker
+from radnn.core import RequiredLibs
+oReqs = RequiredLibs()
+if oReqs.is_tensorflow_installed:
+  import tensorflow.keras as ker
 
 class KLearningRateScheduler(ker.callbacks.LearningRateScheduler):
   # -----------------------------------------------------------------------------------

radnn/learn/{keras_optimization_algorithm.py → keras/keras_optimization_combo.py}

@@ -1,7 +1,11 @@
-import tensorflow.keras as ker
-from .keras_learning_rate_scheduler import KLearningRateScheduler
+from radnn.core import RequiredLibs
+oReqs = RequiredLibs()
+if oReqs.is_tensorflow_installed:
+  import tensorflow.keras as ker
 
-class KOptimizationAlgorithm(object):
+from radnn.learn.keras.keras_learning_rate_scheduler import KLearningRateScheduler
+
+class KOptimizationCombo(object):
   # -----------------------------------------------------------------------------------
   def __init__(self, config, is_verbose=True):
     self.config = config

radnn/learn/torch/__init__.py

@@ -0,0 +1,3 @@
+from .staircase_lr_scheduler import StairCaseLR
+from .ml_trainer import MLModelTrainer
+from .ml_model_freezer import MLModelFreezer