NeuralEngine 0.2.4__tar.gz → 0.2.7__tar.gz

{neuralengine-0.2.4 → neuralengine-0.2.7/NeuralEngine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NeuralEngine
-Version: 0.2.4
+Version: 0.2.7
 Summary: A framework/library for building and training neural networks.
 Home-page: https://github.com/Prajjwal2404/NeuralEngine
 Author: Prajjwal Pratap Shah
@@ -123,9 +123,12 @@ ne.set_device(ne.Device.CUDA)
 # Load your dataset (example: MNIST)
 x_train, y_train, x_test, y_test = load_mnist_data()
 
-y_train = ne.one_hot(y_train)
+y_train = ne.one_hot(y_train) # Preprocess if needed
 y_test = ne.one_hot(y_test)
 
+train_data = ne.DataLoader(x_train, y_train, batch_size=10000)
+test_data = ne.DataLoader(x_test, y_test, batch_size=10000, shuffle=False)
+
 # Build your model
 model = ne.Model(
     input_size=(28, 28),
@@ -140,8 +143,8 @@ model(
 )
 
 # Train and evaluate
-model.train(x_train, y_train, epochs=30, batch_size=10000)
-result = model.eval(x_test, y_test)
+model.train(train_data, epochs=30)
+result = model.eval(test_data)
 ```
 
 ## Project Structure
@@ -153,6 +156,7 @@ neuralengine/
     utils.py
     nn/
         __init__.py
+        dataload.py
         layers.py
         loss.py
         metrics.py
@@ -220,7 +224,7 @@ NeuralEngine offers the following core capabilities:
 - `ne.Huber(delta=1.0)`: Huber loss, robust to outliers.
 - `ne.GaussianNLL(eps=1e-7)`: Gaussian Negative Log Likelihood loss for probabilistic regression.
 - `ne.KLDivergence(eps=1e-7)`: Kullback-Leibler Divergence loss for measuring distribution differences.
-- All loss functions inherit from a common base and support autograd.
+- All loss functions inherit from a common base, support autograd and loss accumulation.
 
 ### Optimizers
 - `ne.Adam(lr=1e-3, betas=(0.9, 0.99), eps=1e-7, reg=0)`: Adam optimizer (switches to RMSProp if only one beta is provided).
@@ -228,21 +232,28 @@ NeuralEngine offers the following core capabilities:
 - All optimizers support L2 regularization and gradient reset.
 
 ### Metrics
-- `ne.ClassificationMetrics(num_classes=None, acc=True, prec=False, rec=False, f1=False, cm=False)`: Computes accuracy, precision, recall, F1 score, and confusion matrix for classification tasks.
+- `ne.ClassificationMetrics(num_classes=None, acc=True, prec=False, rec=False, f1=False)`: Computes accuracy, precision, recall and F1 score for classification tasks.
 - `ne.RMSE()`: Root Mean Squared Error for regression.
 - `ne.R2()`: R2 Score for regression.
-- All metrics return results as dictionaries and support batch evaluation.
+- `ne.Perplexity()`: Perplexity metric for generative models.
+- All metrics store results as dictionaries, support batch evaluation and metric accumulation.
 
 ### Model API
 - `ne.Model(input_size, optimizer, loss, metrics)`: Create a model specifying input size, optimizer, loss function, and metrics.
 - Add layers by calling the model instance: `model(layer1, layer2, ...)` or using `model.build(layer1, layer2, ...)`.
-- `model.train(x, y, epochs=10, batch_size=64, seed=None, ckpt_interval=None)`: Train the model on data, with support for batching, shuffling, and metric/loss reporting and checkpointing per epoch.
-- `model.eval(x, y)`: Evaluate the model on data, disables gradient tracking using `with ne.NoGrad():`, prints loss and metrics, and returns output tensor. Also prints confusion matrix if enabled in metrics.
+- `model.train(dataloader, epochs=10, ckpt_interval=None)`: Train the model on dataset, with support for  metric/loss reporting and checkpointing per epoch.
+- `model.eval(dataloader)`: Evaluate the model on dataset, disables gradient tracking using `with ne.NoGrad():`, prints loss and metrics, and returns output tensor.
 - Layers are set to training or evaluation mode automatically during `train` and `eval`.
 - `model.save(filename, weights_only=False)`: Save the model architecture or model parameters to a file.
 - `model.load_params(filepath)`: Load model parameters from a saved file.
 - `ne.Model.load_model(filepath)`: Load a model from a saved file.
 
+### DataLoader
+- `ne.DataLoader(x, y, dtype=None, batch_size=32, shuffle=True, seed=None, bar=30)`: Create a data loader for batching and shuffling datasets during training and evaluation.
+- Supports lists, tuples, numpy arrays, pandas dataframes and tensors as input data.
+- Provides batching, shuffling, and progress bar display during iteration.
+- Extensible for custom data loading strategies.
+
 ### Utilities
 - Tensor creation: `tensor(data, requires_grad=False)`, `zeros(shape)`, `ones(shape)`, `rand(shape)`, `randn(shape, xavier=False)`, `randint(low, high, shape)` and their `_like` variants for matching shapes.
 - Tensor operations: `sum`, `max`, `min`, `mean`, `var`, `log`, `sqrt`, `exp`, `abs`, `concat`, `stack`, `where`, `clip`, `array(data, dtype=...)` for elementwise, reduction, and conversion operations.
@@ -253,8 +264,9 @@ NeuralEngine is designed for easy extension and customization:
 - **Custom Layers**: Create new layers by inheriting from the `Layer` base class and implementing the `forward(self, x)` method. You can add parameters, initialization logic, and custom computations as needed. All built-in layers follow this pattern, making it simple to add your own.
 - **Custom Losses**: Define new loss functions by inheriting from the `Loss` base class and implementing the `compute(self, z, y)` method. This allows you to integrate any custom loss logic with autograd support.
 - **Custom Optimizers**: Implement new optimization algorithms by inheriting from the `Optimizer` base class and providing your own `step(self)` method. You can manage optimizer state and parameter updates as required.
-- **Custom Metrics**: Add new metrics by inheriting from the `Metric` base class and implementing the `compute(self, z, y)` method. Alternatively, you can pass a function of the form `func(x, y) -> dict[str, float | np.ndarray]` directly to the model's metrics argument for flexible evaluation.
-- All core components are modular and can be replaced or extended for research, experimentation, or production use.
+- **Custom Metrics**: Add new metrics by inheriting from the `Metric` base class and implementing the `compute(self, z, y)` method. This allows you to track any performance measure with metric accumulation.
+- **Custom DataLoaders**: Extend the `DataLoader` class to create specialized data loading strategies. Override the `__getitem__` method to define how batches are constructed.
+- All core components are modular and can be replaced or extended for research or production use.
 
 ## Contribution Guide
 

{neuralengine-0.2.4 → neuralengine-0.2.7}/NeuralEngine.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ neuralengine/config.py
 neuralengine/tensor.py
 neuralengine/utils.py
 neuralengine/nn/__init__.py
+neuralengine/nn/dataload.py
 neuralengine/nn/layers.py
 neuralengine/nn/loss.py
 neuralengine/nn/metrics.py

{neuralengine-0.2.4/NeuralEngine.egg-info → neuralengine-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NeuralEngine
-Version: 0.2.4
+Version: 0.2.7
 Summary: A framework/library for building and training neural networks.
 Home-page: https://github.com/Prajjwal2404/NeuralEngine
 Author: Prajjwal Pratap Shah
@@ -123,9 +123,12 @@ ne.set_device(ne.Device.CUDA)
 # Load your dataset (example: MNIST)
 x_train, y_train, x_test, y_test = load_mnist_data()
 
-y_train = ne.one_hot(y_train)
+y_train = ne.one_hot(y_train) # Preprocess if needed
 y_test = ne.one_hot(y_test)
 
+train_data = ne.DataLoader(x_train, y_train, batch_size=10000)
+test_data = ne.DataLoader(x_test, y_test, batch_size=10000, shuffle=False)
+
 # Build your model
 model = ne.Model(
     input_size=(28, 28),
@@ -140,8 +143,8 @@ model(
 )
 
 # Train and evaluate
-model.train(x_train, y_train, epochs=30, batch_size=10000)
-result = model.eval(x_test, y_test)
+model.train(train_data, epochs=30)
+result = model.eval(test_data)
 ```
 
 ## Project Structure
@@ -153,6 +156,7 @@ neuralengine/
     utils.py
     nn/
         __init__.py
+        dataload.py
         layers.py
         loss.py
         metrics.py
@@ -220,7 +224,7 @@ NeuralEngine offers the following core capabilities:
 - `ne.Huber(delta=1.0)`: Huber loss, robust to outliers.
 - `ne.GaussianNLL(eps=1e-7)`: Gaussian Negative Log Likelihood loss for probabilistic regression.
 - `ne.KLDivergence(eps=1e-7)`: Kullback-Leibler Divergence loss for measuring distribution differences.
-- All loss functions inherit from a common base and support autograd.
+- All loss functions inherit from a common base, support autograd and loss accumulation.
 
 ### Optimizers
 - `ne.Adam(lr=1e-3, betas=(0.9, 0.99), eps=1e-7, reg=0)`: Adam optimizer (switches to RMSProp if only one beta is provided).
@@ -228,21 +232,28 @@ NeuralEngine offers the following core capabilities:
 - All optimizers support L2 regularization and gradient reset.
 
 ### Metrics
-- `ne.ClassificationMetrics(num_classes=None, acc=True, prec=False, rec=False, f1=False, cm=False)`: Computes accuracy, precision, recall, F1 score, and confusion matrix for classification tasks.
+- `ne.ClassificationMetrics(num_classes=None, acc=True, prec=False, rec=False, f1=False)`: Computes accuracy, precision, recall and F1 score for classification tasks.
 - `ne.RMSE()`: Root Mean Squared Error for regression.
 - `ne.R2()`: R2 Score for regression.
-- All metrics return results as dictionaries and support batch evaluation.
+- `ne.Perplexity()`: Perplexity metric for generative models.
+- All metrics store results as dictionaries, support batch evaluation and metric accumulation.
 
 ### Model API
 - `ne.Model(input_size, optimizer, loss, metrics)`: Create a model specifying input size, optimizer, loss function, and metrics.
 - Add layers by calling the model instance: `model(layer1, layer2, ...)` or using `model.build(layer1, layer2, ...)`.
-- `model.train(x, y, epochs=10, batch_size=64, seed=None, ckpt_interval=None)`: Train the model on data, with support for batching, shuffling, and metric/loss reporting and checkpointing per epoch.
-- `model.eval(x, y)`: Evaluate the model on data, disables gradient tracking using `with ne.NoGrad():`, prints loss and metrics, and returns output tensor. Also prints confusion matrix if enabled in metrics.
+- `model.train(dataloader, epochs=10, ckpt_interval=None)`: Train the model on dataset, with support for  metric/loss reporting and checkpointing per epoch.
+- `model.eval(dataloader)`: Evaluate the model on dataset, disables gradient tracking using `with ne.NoGrad():`, prints loss and metrics, and returns output tensor.
 - Layers are set to training or evaluation mode automatically during `train` and `eval`.
 - `model.save(filename, weights_only=False)`: Save the model architecture or model parameters to a file.
 - `model.load_params(filepath)`: Load model parameters from a saved file.
 - `ne.Model.load_model(filepath)`: Load a model from a saved file.
 
+### DataLoader
+- `ne.DataLoader(x, y, dtype=None, batch_size=32, shuffle=True, seed=None, bar=30)`: Create a data loader for batching and shuffling datasets during training and evaluation.
+- Supports lists, tuples, numpy arrays, pandas dataframes and tensors as input data.
+- Provides batching, shuffling, and progress bar display during iteration.
+- Extensible for custom data loading strategies.
+
 ### Utilities
 - Tensor creation: `tensor(data, requires_grad=False)`, `zeros(shape)`, `ones(shape)`, `rand(shape)`, `randn(shape, xavier=False)`, `randint(low, high, shape)` and their `_like` variants for matching shapes.
 - Tensor operations: `sum`, `max`, `min`, `mean`, `var`, `log`, `sqrt`, `exp`, `abs`, `concat`, `stack`, `where`, `clip`, `array(data, dtype=...)` for elementwise, reduction, and conversion operations.
@@ -253,8 +264,9 @@ NeuralEngine is designed for easy extension and customization:
 - **Custom Layers**: Create new layers by inheriting from the `Layer` base class and implementing the `forward(self, x)` method. You can add parameters, initialization logic, and custom computations as needed. All built-in layers follow this pattern, making it simple to add your own.
 - **Custom Losses**: Define new loss functions by inheriting from the `Loss` base class and implementing the `compute(self, z, y)` method. This allows you to integrate any custom loss logic with autograd support.
 - **Custom Optimizers**: Implement new optimization algorithms by inheriting from the `Optimizer` base class and providing your own `step(self)` method. You can manage optimizer state and parameter updates as required.
-- **Custom Metrics**: Add new metrics by inheriting from the `Metric` base class and implementing the `compute(self, z, y)` method. Alternatively, you can pass a function of the form `func(x, y) -> dict[str, float | np.ndarray]` directly to the model's metrics argument for flexible evaluation.
-- All core components are modular and can be replaced or extended for research, experimentation, or production use.
+- **Custom Metrics**: Add new metrics by inheriting from the `Metric` base class and implementing the `compute(self, z, y)` method. This allows you to track any performance measure with metric accumulation.
+- **Custom DataLoaders**: Extend the `DataLoader` class to create specialized data loading strategies. Override the `__getitem__` method to define how batches are constructed.
+- All core components are modular and can be replaced or extended for research or production use.
 
 ## Contribution Guide
 

{neuralengine-0.2.4 → neuralengine-0.2.7}/README.md

@@ -75,9 +75,12 @@ ne.set_device(ne.Device.CUDA)
 # Load your dataset (example: MNIST)
 x_train, y_train, x_test, y_test = load_mnist_data()
 
-y_train = ne.one_hot(y_train)
+y_train = ne.one_hot(y_train) # Preprocess if needed
 y_test = ne.one_hot(y_test)
 
+train_data = ne.DataLoader(x_train, y_train, batch_size=10000)
+test_data = ne.DataLoader(x_test, y_test, batch_size=10000, shuffle=False)
+
 # Build your model
 model = ne.Model(
     input_size=(28, 28),
@@ -92,8 +95,8 @@ model(
 )
 
 # Train and evaluate
-model.train(x_train, y_train, epochs=30, batch_size=10000)
-result = model.eval(x_test, y_test)
+model.train(train_data, epochs=30)
+result = model.eval(test_data)
 ```
 
 ## Project Structure
@@ -105,6 +108,7 @@ neuralengine/
     utils.py
     nn/
         __init__.py
+        dataload.py
         layers.py
         loss.py
         metrics.py
@@ -172,7 +176,7 @@ NeuralEngine offers the following core capabilities:
 - `ne.Huber(delta=1.0)`: Huber loss, robust to outliers.
 - `ne.GaussianNLL(eps=1e-7)`: Gaussian Negative Log Likelihood loss for probabilistic regression.
 - `ne.KLDivergence(eps=1e-7)`: Kullback-Leibler Divergence loss for measuring distribution differences.
-- All loss functions inherit from a common base and support autograd.
+- All loss functions inherit from a common base, support autograd and loss accumulation.
 
 ### Optimizers
 - `ne.Adam(lr=1e-3, betas=(0.9, 0.99), eps=1e-7, reg=0)`: Adam optimizer (switches to RMSProp if only one beta is provided).
@@ -180,21 +184,28 @@ NeuralEngine offers the following core capabilities:
 - All optimizers support L2 regularization and gradient reset.
 
 ### Metrics
-- `ne.ClassificationMetrics(num_classes=None, acc=True, prec=False, rec=False, f1=False, cm=False)`: Computes accuracy, precision, recall, F1 score, and confusion matrix for classification tasks.
+- `ne.ClassificationMetrics(num_classes=None, acc=True, prec=False, rec=False, f1=False)`: Computes accuracy, precision, recall and F1 score for classification tasks.
 - `ne.RMSE()`: Root Mean Squared Error for regression.
 - `ne.R2()`: R2 Score for regression.
-- All metrics return results as dictionaries and support batch evaluation.
+- `ne.Perplexity()`: Perplexity metric for generative models.
+- All metrics store results as dictionaries, support batch evaluation and metric accumulation.
 
 ### Model API
 - `ne.Model(input_size, optimizer, loss, metrics)`: Create a model specifying input size, optimizer, loss function, and metrics.
 - Add layers by calling the model instance: `model(layer1, layer2, ...)` or using `model.build(layer1, layer2, ...)`.
-- `model.train(x, y, epochs=10, batch_size=64, seed=None, ckpt_interval=None)`: Train the model on data, with support for batching, shuffling, and metric/loss reporting and checkpointing per epoch.
-- `model.eval(x, y)`: Evaluate the model on data, disables gradient tracking using `with ne.NoGrad():`, prints loss and metrics, and returns output tensor. Also prints confusion matrix if enabled in metrics.
+- `model.train(dataloader, epochs=10, ckpt_interval=None)`: Train the model on dataset, with support for  metric/loss reporting and checkpointing per epoch.
+- `model.eval(dataloader)`: Evaluate the model on dataset, disables gradient tracking using `with ne.NoGrad():`, prints loss and metrics, and returns output tensor.
 - Layers are set to training or evaluation mode automatically during `train` and `eval`.
 - `model.save(filename, weights_only=False)`: Save the model architecture or model parameters to a file.
 - `model.load_params(filepath)`: Load model parameters from a saved file.
 - `ne.Model.load_model(filepath)`: Load a model from a saved file.
 
+### DataLoader
+- `ne.DataLoader(x, y, dtype=None, batch_size=32, shuffle=True, seed=None, bar=30)`: Create a data loader for batching and shuffling datasets during training and evaluation.
+- Supports lists, tuples, numpy arrays, pandas dataframes and tensors as input data.
+- Provides batching, shuffling, and progress bar display during iteration.
+- Extensible for custom data loading strategies.
+
 ### Utilities
 - Tensor creation: `tensor(data, requires_grad=False)`, `zeros(shape)`, `ones(shape)`, `rand(shape)`, `randn(shape, xavier=False)`, `randint(low, high, shape)` and their `_like` variants for matching shapes.
 - Tensor operations: `sum`, `max`, `min`, `mean`, `var`, `log`, `sqrt`, `exp`, `abs`, `concat`, `stack`, `where`, `clip`, `array(data, dtype=...)` for elementwise, reduction, and conversion operations.
@@ -205,8 +216,9 @@ NeuralEngine is designed for easy extension and customization:
 - **Custom Layers**: Create new layers by inheriting from the `Layer` base class and implementing the `forward(self, x)` method. You can add parameters, initialization logic, and custom computations as needed. All built-in layers follow this pattern, making it simple to add your own.
 - **Custom Losses**: Define new loss functions by inheriting from the `Loss` base class and implementing the `compute(self, z, y)` method. This allows you to integrate any custom loss logic with autograd support.
 - **Custom Optimizers**: Implement new optimization algorithms by inheriting from the `Optimizer` base class and providing your own `step(self)` method. You can manage optimizer state and parameter updates as required.
-- **Custom Metrics**: Add new metrics by inheriting from the `Metric` base class and implementing the `compute(self, z, y)` method. Alternatively, you can pass a function of the form `func(x, y) -> dict[str, float | np.ndarray]` directly to the model's metrics argument for flexible evaluation.
-- All core components are modular and can be replaced or extended for research, experimentation, or production use.
+- **Custom Metrics**: Add new metrics by inheriting from the `Metric` base class and implementing the `compute(self, z, y)` method. This allows you to track any performance measure with metric accumulation.
+- **Custom DataLoaders**: Extend the `DataLoader` class to create specialized data loading strategies. Override the `__getitem__` method to define how batches are constructed.
+- All core components are modular and can be replaced or extended for research or production use.
 
 ## Contribution Guide
 

{neuralengine-0.2.4 → neuralengine-0.2.7}/neuralengine/config.py

@@ -24,7 +24,6 @@ def set_device(device: Device) -> None:
     Sets the current device for tensor operations.
     @param device: The device to set, either Device.CPU or Device.CUDA
     """
-
     global nu, _current_device
     if device == Device.CPU:
         nu = np

{neuralengine-0.2.4 → neuralengine-0.2.7}/neuralengine/nn/__init__.py

@@ -2,4 +2,5 @@ from .layers import *
 from .optim import *
 from .loss import *
 from .metrics import *
-from .model import *
+from .model import *
+from .dataload import *

neuralengine-0.2.7/neuralengine/nn/dataload.py

@@ -0,0 +1,60 @@
+import neuralengine.config as cf
+from ..tensor import Tensor
+
+
+class DataLoader:
+    """Data loader class for batching and shuffling data."""
+    def __init__(self, x, y, dtype=None, batch_size: int = 32, shuffle: bool = True, seed: int = None, bar: int = 30):
+        """
+        @param x: Input data (array-like).
+        @param y: Target data (array-like).
+        @param dtype: Data type for the dataset.
+        @param batch_size: Number of samples per batch.
+        @param shuffle: Whether to shuffle the data at the start of each epoch.
+        @param seed: Seed for random number generator to ensure reproducibility.
+        @param bar: Length of the progress bar.
+        """
+        self.x = Tensor(x, dtype=dtype)
+        self.y = Tensor(y, dtype=dtype)
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+        self.current_batch = 0
+        self.num_samples = self.x.shape[0]
+        self.num_batches = (self.num_samples + batch_size - 1) // batch_size
+        self.indices = cf.nu.arange(self.num_samples)
+        self.rng = cf.nu.random.RandomState(seed)
+        self.bar = bar
+
+    def __len__(self) -> int:
+        """Returns the number of batches."""
+        return self.num_batches
+    
+    def __getitem__(self, index: int | slice) -> tuple[Tensor, Tensor]:
+        """Gets a batch of data by index. Override for custom behavior."""
+        return self.x[index], self.y[index]
+
+    def __iter__(self) -> 'DataLoader':
+        """Returns an iterator over the batches."""
+        self.current_batch = 0
+        if self.shuffle:
+            self.rng.shuffle(self.indices)
+        return self
+
+    def __next__(self) -> tuple[Tensor, Tensor]:
+        """Returns the next batch of data."""
+        if self.current_batch < self.num_batches:
+            start_idx = self.current_batch * self.batch_size
+            end_idx = min(start_idx + self.batch_size, self.num_samples)
+            batch_indices = self.indices[start_idx:end_idx]
+            batch_data = self[batch_indices]
+            self.current_batch += 1
+            return batch_data
+        else:
+            raise StopIteration
+        
+    def __repr__(self) -> str:
+        """String representation showing progress bar."""
+        percent = (self.current_batch / self.num_batches) * 100
+        filled = int(self.bar * self.current_batch // self.num_batches)
+        progress = '█' * filled + '-' * (self.bar - filled)
+        return f"\r|{progress}| {percent:.0f}%"

{neuralengine-0.2.4 → neuralengine-0.2.7}/neuralengine/nn/loss.py

@@ -5,7 +5,8 @@ from ..utils import *
 class Loss:
     """Base class for all loss functions."""
     def __init__(self):
-        self.loss_val = None
+        self.loss_val = 0
+        self.count = 0
 
     def __call__(self, z, y, *args, **kwargs):
         """ Calls the loss compute method with the provided predictions and targets.
@@ -16,17 +17,23 @@ class Loss:
         y = y if isinstance(y, Tensor) else Tensor(y)
         loss = self.compute(z, y, *args, **kwargs)
 
-        self.loss_val = loss.data.mean() if isinstance(loss, Tensor) else loss
+        self.loss_val += loss.data.mean() if isinstance(loss, Tensor) else loss
+        self.count += 1
         return loss
 
     def __repr__(self) -> str:
         """ Returns a string representation of the loss with its value if computed. """
-        if self.loss_val is not None:
-            return f"{self.__class__.__name__}: {self.loss_val:.4f}"
+        if self.count > 0:
+            return f"{self.__class__.__name__}: {(self.loss_val / self.count):.4f}"
         else:
             return "No loss computed yet."
         
-    def compute(self, z, y, *args, **kwargs):
+    def reset(self) -> None:
+        """ Resets the accumulated loss value and count. """
+        self.loss_val = 0
+        self.count = 0
+        
+    def compute(self, z, y, *args, **kwargs) -> Tensor:
         """ Computes the loss given predictions and targets. To be implemented by subclasses. """
         raise NotImplementedError("compute() must be implemented in subclasses")
 
@@ -64,9 +71,8 @@ class Huber(Loss):
 
     def compute(self, z, y):
         # Huber: if |z - y| <= δ: 1/2 (z - y)² else: δ(|z - y| - 1/2 δ)
-        diff = z - y
-        abs_diff = abs(diff)
-        loss = where(abs_diff <= self.delta, 0.5 * diff ** 2, self.delta * (abs_diff - 0.5 * self.delta))
+        diff = abs(z - y)
+        loss = where(diff <= self.delta, 0.5 * diff ** 2, self.delta * (diff - 0.5 * self.delta))
         return mean(loss, axis=-1, keepdims=False)
     
 

{neuralengine-0.2.4 → neuralengine-0.2.7}/neuralengine/nn/metrics.py

@@ -5,7 +5,8 @@ from ..tensor import array
 class Metric:
     """Base class for all metrics."""
     def __init__(self):
-        self.metric_val = None
+        self.metric_val = {}
+        self.count = 0
 
     def __call__(self, z, y, *args, **kwargs):
         """ Calls the metric compute method with the provided predictions and targets.
@@ -14,28 +15,40 @@ class Metric:
         """
         z = z if isinstance(z, cf.nu.ndarray) else array(z)
         y = y if isinstance(y, cf.nu.ndarray) else array(y)
-        metric_val = self.compute(z, y, *args, **kwargs)
+        metric = self.compute(z, y, *args, **kwargs)
 
-        if not isinstance(metric_val, dict):
+        if not isinstance(metric, dict):
             raise ValueError("Metric compute method must return a dictionary.")
         
-        self.metric_val = metric_val
-        return self.metric_val
+        self.metric_val = {key: self.metric_val.get(key, 0) + value for key, value in metric.items()}
+        self.count += 1
+        return self
+    
+    def __getitem__(self, key: str):
+        """ Allows access to individual metric values by key. """
+        return self.metric_val.get(key, None)
 
     def __repr__(self) -> str:
         """ Returns a string representation of the metric with its value if computed. """
-        if self.metric_val is not None:
-
+        if self.count > 0:
             metric_str = ""
             for key, value in self.metric_val.items():
-                if value is None: continue
                 if isinstance(value, (cf.nu.ndarray)) and value.ndim == 1:
                     value = value.mean(keepdims=False)
-                metric_str += f"{key}: {value:.4f}, "
-            return metric_str[:-2]
+                metric_str += f"{key}: {(value / self.count):.4f}, "
+            return metric_str[:-2]  # Remove trailing comma and space
         
         else:
             return "No metric computed yet."
+        
+    def reset(self) -> None:
+        """ Resets the accumulated metric values and count. """
+        self.metric_val = {}
+        self.count = 0
+        
+    def compute(self, z, y, *args, **kwargs) -> dict[str, float | cf.np.ndarray]:
+        """ Computes the metric given predictions and targets. To be implemented by subclasses. """
+        raise NotImplementedError("compute() must be implemented in subclasses")
 
 
 class RMSE(Metric):
@@ -68,14 +81,13 @@ class R2(Metric):
 
 class ClassificationMetrics(Metric):
     """Classification metrics: Accuracy, Precision, Recall, F1 Score, Confusion Matrix."""
-    def __init__(self, num_classes: int = None, acc: bool = True, prec: bool = False, rec: bool = False, f1: bool = False, cm: bool = False):
+    def __init__(self, num_classes: int = None, acc: bool = True, prec: bool = False, rec: bool = False, f1: bool = False):
         """
         @param num_classes: Number of classes for classification tasks.
         @param acc: Whether to compute accuracy.
         @param prec: Whether to compute precision.
         @param rec: Whether to compute recall.
         @param f1: Whether to compute F1 score.
-        @param cm: Whether to compute confusion matrix. Only for evaluation mode.
         """
         super().__init__()
         self.num_classes = num_classes
@@ -83,7 +95,6 @@ class ClassificationMetrics(Metric):
         self.prec = prec
         self.rec = rec
         self.f1 = f1
-        self.cm = cm
 
     def compute(self, z, y):
         if self.num_classes is None:
@@ -100,28 +111,41 @@ class ClassificationMetrics(Metric):
         FP = cf.nu.sum(cm, axis=0) - TP
         FN = cf.nu.sum(cm, axis=1) - TP
 
-        acc, prec, rec, f1 = None, None, None, None
+        acc, prec, rec, f1, metrics = None, None, None, None, {}
         if self.acc:
             # Accuracy = trace(cm) / sum(cm)
             acc = cf.nu.trace(cm) / cf.nu.sum(cm) if cf.nu.sum(cm) > 0 else 0
+            metrics["Accuracy"] = acc
         if self.prec:
             # Precision = TP / (TP + FP)
             prec = cf.nu.zeros_like(TP, dtype=cf.nu.float32)
             cf.nu.divide(TP, TP + FP, out=prec, where=(TP + FP) != 0)
+            metrics["Precision"] = prec
         if self.rec:
             # Recall = TP / (TP + FN)
             rec = cf.nu.zeros_like(TP, dtype=cf.nu.float32)
             cf.nu.divide(TP, TP + FN, out=rec, where=(TP + FN) != 0)
+            metrics["Recall"] = rec
         if self.f1:
             # F1 = 2 * Precision * Recall / (Precision + Recall)
             f1 = cf.nu.zeros_like(TP, dtype=cf.nu.float32)
             cf.nu.divide(2 * prec * rec, prec + rec, out=f1, where=(prec + rec) != 0)
-        if self.cm is not False:
-            self.cm = cm
-
-        return {
-            "Accuracy": acc,
-            "Precision": prec,
-            "Recall": rec,
-            "F1 Score": f1
-        }
+            metrics["F1 Score"] = f1
+        return metrics
+
+
+class Perplexity(Metric):
+    """Perplexity metric for generative models."""
+    def __init__(self, eps: float = 1e-7):
+        """
+        @param eps: Small value for numerical stability
+        """
+        super().__init__()
+        self.eps = eps
+
+    def compute(self, z, y):
+        # Perplexity = exp(-1/N Σ log(p(y|x)))
+        z = cf.nu.clip(z, self.eps, 1 - self.eps)
+        log_likelihood = -cf.nu.sum(y * cf.nu.log(z), axis=-1)
+        perplexity = cf.nu.exp(cf.nu.mean(log_likelihood))
+        return {"Perplexity": perplexity}

{neuralengine-0.2.4 → neuralengine-0.2.7}/neuralengine/nn/model.py

@@ -2,10 +2,12 @@ import os
 import pickle as pkl
 import neuralengine.config as cf
 from itertools import chain
-from ..tensor import Tensor, NoGrad, array
+from ..tensor import Tensor, NoGrad
+from ..utils import concat
 from .layers import Layer, Mode, Flatten, LSTM
 from .optim import Optimizer
 from .loss import Loss
+from .dataload import DataLoader
 
 
 class Model:
@@ -13,15 +15,13 @@ class Model:
     Allows for defining the model architecture, optimizer, loss function, and metrics.
     The model can be trained and evaluated.
     """
-
     def __init__(self, input_size: tuple | int, optimizer: Optimizer = None, loss: Loss = None, metrics=()):
         """
         @param input_size: Tuple or int, shape of input data samples (int if 1D).
         @param optimizer: Optimizer instance.
         @param loss: Loss instance.
-        @param metrics: List/tuple of Metric or Loss instances or func(x, y) → dict[str, float | np.ndarray].
+        @param metrics: List/tuple of Metric or Loss instances.
         """
-
         self.input_size = input_size
 
         if not isinstance(optimizer, Optimizer):
@@ -48,7 +48,6 @@ class Model:
         Builds the model by adding layers.
         @param layers: Variable number of Layer instances to add to the model.
         """
-
         self.parameters, prevLayer = {}, None
         for i, layer in enumerate(layers):
 
@@ -73,12 +72,12 @@ class Model:
                 layer.in_size = self.input_size
             self.input_size = layer.out_size if hasattr(layer, 'out_size') else self.input_size
             if isinstance(layer, Flatten):
-                self.input_size = int(cf.nu.prod(array(self.input_size)))
+                self.input_size = int(cf.np.prod(self.input_size))
 
             self.parameters[f"layer_{i}"] = list(layer.parameters()) # Collect parameters from the layer
             
         self.layers = layers
-        self.optimizer.parameters = list(chain.from_iterable(self.parameters.values()))
+        self.optimizer.parameters = list(chain(*self.parameters.values()))
 
 
     @classmethod
@@ -141,110 +140,87 @@ class Model:
             else: pkl.dump(self, file)
 
 
-    def train(self, x, y, epochs: int = 10, batch_size: int = 64, seed: int = None, ckpt_interval: int = None):
+    def train(self, dataloader: DataLoader, epochs: int = 10, ckpt_interval: int = None) -> None:
         """
         Trains the model on data.
-        @param x: Input data, shape (N, features)
-        @param y: Target data, shape (N, target_features)
-        @param epochs: Number of epochs
-        @param batch_size: Batch size (None for full batch)
-        @param seed: Seed for random shuffling
+        @param dataloader: DataLoader instance providing training data.
+        @param epochs: Number of epochs to train
         @param ckpt_interval: Interval (in epochs) to save checkpoints
         """
+        if not isinstance(dataloader, DataLoader):
+            raise ValueError("dataloader must be an instance of DataLoader class")
 
         for layer in self.layers:
             layer.mode = Mode.TRAIN
 
-        x, y = array(x), array(y)
-
-        if batch_size is None:
-            batch_size = x.shape[0]
-        if batch_size <= 0 or batch_size > x.shape[0]:
-            raise ValueError("batch_size must be a positive integer ≤ number of samples")
-
         for i in range(epochs):
 
-            loss_val, metric_vals = 0, {}
-            cf.nu.random.seed(seed)
-            shuffle_indices = cf.nu.random.permutation(x.shape[0])
-            x, y = x[shuffle_indices], y[shuffle_indices] # Shuffle data
-
-            for j in range(0, x.shape[0], batch_size):
-                x_batch = x[j:j + batch_size]
-                y_batch = y[j:j + batch_size]
+            for batch in dataloader:
+                x, y = batch
 
                 # Forward pass
                 for layer in self.layers:
-                    x_batch = layer(x_batch)
+                    x = layer(x)
                     # For stacked LSTM, pass outputs accordingly
-                    if isinstance(layer, LSTM): x_batch = x_batch[layer.use_output[0]]
+                    if isinstance(layer, LSTM): x = x[layer.use_output[0]]
                     
-                # Compute loss
-                loss = self.loss(x_batch, y_batch)
-                loss_val += self.loss.loss_val
-
+                loss = self.loss(x, y) # Compute loss
                 loss.backward() # Backward pass
 
                 # Compute metrics
                 for metric in self.metrics:
-                    metric_val = metric(x_batch, y_batch)
-                    if isinstance(metric, Loss):
-                        key = metric.__class__.__name__
-                        metric_vals[key] = metric_vals.get(key, 0.0) + metric.loss_val
-                        continue
-                    for key, value in metric_val.items():
-                        if value is None: continue
-                        metric_vals[key] = metric_vals.get(key, 0.0) + value
+                    metric(x, y)
 
                 # Update parameters
                 self.optimizer.step()
                 self.optimizer.reset_grad() # Reset gradients
 
-            loss_val /= (x.shape[0] / batch_size) # Average loss over batches
-            output_strs = [f"Epoch {i + 1}/{epochs}", f"Loss: {loss_val:.4f}"]
+                print(dataloader, f'Epoch {i + 1}/{epochs}', sep=', ', end='', flush=True) # Show progress bar
 
-            for key, value in metric_vals.items():
-                value /= (x.shape[0] / batch_size) # Average metric over batches
-                if isinstance(value, (cf.nu.ndarray)) and value.ndim == 1:
-                    value = value.mean(keepdims=False)
-                output_strs.append(f"{key}: {value:.4f}")
+            output_strs = [f": (Loss) {self.loss}", *self.metrics]
 
             # Save checkpoint
             if ckpt_interval and (i + 1) % ckpt_interval == 0:
                 self.save(f"checkpoints/model_epoch_{i + 1}.pkl", weights_only=True)
                 output_strs.append("Checkpoint saved")
+            print(*output_strs, sep=', ', flush=True)
 
-            print(*output_strs, sep=", ")
+            # Reset loss and metrics for next epoch
+            self.loss.reset()
+            for metric in self.metrics: metric.reset()
 
 
-    def eval(self, x, y) -> Tensor:
+    def eval(self, dataloader: DataLoader) -> Tensor:
         """
         Evaluates the model on data.
-        @param x: Input data, shape (N, features)
-        @param y: Target data, shape (N, target_features)
+        @param dataloader: DataLoader instance providing evaluation data.
         @return: Output tensor after evaluation
         """
+        if not isinstance(dataloader, DataLoader):
+            raise ValueError("dataloader must be an instance of DataLoader class")
 
         for layer in self.layers:
             layer.mode = Mode.EVAL
 
-        # Forward pass
-        with NoGrad():
-            z = x
-            for layer in self.layers:
-                z = layer(z)
-                # For stacked LSTM, pass outputs accordingly
-                if isinstance(layer, LSTM): z = z[layer.use_output[0]]
-
-            self.loss(z, y) # Compute loss
-
-        # Compute metrics
-        cm = False
-        for metric in self.metrics:
-            metric(z, y)
-            cm = metric.cm if hasattr(metric, 'cm') else cm
-
-        print(f"Evaluation: (Loss) {self.loss}", *self.metrics, sep=", ")
-        if cm is not False:
-            print(f"Confusion Matrix:\n{cm}")
-        return z
+        z = []
+        for batch in dataloader:
+            x, y = batch
+
+            # Forward pass
+            with NoGrad():
+                for layer in self.layers:
+                    x = layer(x)
+                    # For stacked LSTM, pass outputs accordingly
+                    if isinstance(layer, LSTM): x = x[layer.use_output[0]]
+
+                z.append(x) # Accumulate outputs
+                self.loss(x, y) # Compute loss
+
+            # Compute metrics
+            for metric in self.metrics:
+                metric(x, y)
+
+            print(dataloader, 'Evaluation', sep=', ', end='', flush=True) # Show progress bar
+
+        print(f": (Loss) {self.loss}", *self.metrics, sep=', ', flush=True)
+        return concat(*z, axis=0)

{neuralengine-0.2.4 → neuralengine-0.2.7}/neuralengine/nn/optim.py

@@ -43,7 +43,6 @@ class SGD(Optimizer):
         @param momentum: Momentum factor
         @param nesterov: Use Nesterov momentum
         """
-
         super().__init__()
         self.lr = lr
         self.reg = reg
@@ -83,7 +82,6 @@ class Adam(Optimizer):
         @param eps: Numerical stability
         @param reg: L2 regularization
         """
-
         super().__init__()
         self.lr = lr
         betas = betas if isinstance(betas, (list, tuple)) else (betas,)
@@ -105,7 +103,6 @@ class Adam(Optimizer):
         Updates the parameters using Adam optimization algorithm.
         RMSProp algorithm is used if only one beta is provided.
         """
-
         self.t += 1
         for param in self._params:
             # grad = ∂L/∂w + λw (L2 regularization)

{neuralengine-0.2.4 → neuralengine-0.2.7}/neuralengine/tensor.py

@@ -758,6 +758,8 @@ def array(data, dtype=cf.nu.float32):
     @param dtype: Desired data type of the output array.
     """
     if isinstance(data, Tensor):
+        if dtype is None:
+            return data.data.copy()
         return data.data.astype(dtype)
     return cf.nu.asarray(data, dtype=dtype)
 

{neuralengine-0.2.4 → neuralengine-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "NeuralEngine"
-version = "0.2.4"
+version = "0.2.7"
 description = "A framework/library for building and training neural networks."
 authors = [
     { name = "Prajjwal Pratap Shah", email = "prajjwalpratapshah@outlook.com" }

{neuralengine-0.2.4 → neuralengine-0.2.7}/setup.py

@@ -11,7 +11,7 @@ def read_requirements():
 
 setup(
     name="NeuralEngine",
-    version="0.2.4",
+    version="0.2.7",
     author="Prajjwal Pratap Shah",
     author_email="prajjwalpratapshah@outlook.com",
     maintainer="Prajjwal Pratap Shah",