vanillanets 1.0.0__py3-none-any.whl

vanillanets/__init__.py

@@ -0,0 +1,112 @@
+"""
+VanillaNets v1.0.0 - A transparent, NumPy-only neural network library.
+
+A from-scratch implementation of core neural network components using only Python and NumPy.
+Every component is written explicitly with clarity prioritized over convenience.
+
+Main Classes:
+    - Model: Sequential model for building neural networks
+    - DenseLayer: Fully connected layers
+    - Activation functions: Linear, ReLU, LeakyReLU, Tanh, Sigmoid, Softmax
+    - Loss functions: BinaryCrossEntropy, CategoricalCrossEntropy, SparseCategoricalCrossEntropy, MeanSquaredError
+    - Optimizers: Optimizer_SGD, Optimizer_Adam
+    - Metrics: Accuracy, Precision, Recall, F1Score, ConfusionMatrix, R2Score, MAE, RMSE
+
+Example Usage:
+    >>> from vanillanets import Model, DenseLayer
+    >>> from vanillanets.activations import ReLU, Sigmoid
+    >>> from vanillanets.losses import BinaryCrossEntropy
+    >>> from vanillanets.optimizers import Optimizer_Adam
+    >>> from vanillanets.metrics import Accuracy
+    >>>
+    >>> model = Model()
+    >>> model.add(DenseLayer(30, 64))
+    >>> model.add(ReLU())
+    >>> model.add(DenseLayer(64, 1))
+    >>> model.add(Sigmoid())
+    >>>
+    >>> model.set(
+    ...     loss=BinaryCrossEntropy(),
+    ...     optimizer=Optimizer_Adam(learning_rate=0.01),
+    ...     metrics={'accuracy': Accuracy()}
+    ... )
+    >>> model.finalize()
+    >>>
+    >>> model.fit(X_train, y_train, epochs=100, validation_data=(X_val, y_val))
+    >>> predictions = model.predict(X_test)
+"""
+
+__version__ = "1.0.0"
+__author__ = "Umar Balak"
+__license__ = "MIT"
+
+# Core model and layer
+from .model import Model
+from .layers import DenseLayer
+
+# Activation functions
+from .activations import (
+    Linear,
+    ReLU,
+    LeakyReLU,
+    Sigmoid,
+    Tanh,
+    Softmax,
+)
+
+# Loss functions
+from .losses import (
+    BinaryCrossEntropy,
+    CategoricalCrossEntropy,
+    SparseCategoricalCrossEntropy,
+    MeanSquaredError,
+)
+
+# Optimizers
+from .optimizers import Optimizer_SGD, Optimizer_Adam
+
+# Metrics
+from .metrics import (
+    Accuracy,
+    Precision,
+    Recall,
+    F1Score,
+    ConfusionMatrix,
+    R2Score,
+    MAE,
+    RMSE,
+)
+
+# Legacy accuracy
+from .accuracy import Accuracy as Accuracy_Legacy
+
+__all__ = [
+    # Core
+    "Model",
+    "DenseLayer",
+    # Activations
+    "Linear",
+    "ReLU",
+    "LeakyReLU",
+    "Sigmoid",
+    "Tanh",
+    "Softmax",
+    # Losses
+    "BinaryCrossEntropy",
+    "CategoricalCrossEntropy",
+    "SparseCategoricalCrossEntropy",
+    "MeanSquaredError",
+    # Optimizers
+    "Optimizer_SGD",
+    "Optimizer_Adam",
+    # Metrics
+    "Accuracy",
+    "Precision",
+    "Recall",
+    "F1Score",
+    "ConfusionMatrix",
+    "R2Score",
+    "MAE",
+    "RMSE",
+    "Accuracy_Legacy",
+]

vanillanets/accuracy.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+class Accuracy:
+    # Calculates accuracy based on predictions and ground truth
+    def calculate(self, predictions, y):
+        # Handle binary classification (single output)
+        if predictions.shape[1] == 1:
+            # Binary case: threshold at 0.5
+            predictions = (predictions > 0.5) * 1
+            predictions = predictions.flatten()
+
+            # y for binary is shape (n, 1), NOT one-hot -> just flatten
+            if len(y.shape) == 2:
+                y = y.flatten()
+        else:
+            # Multiclass case: use argmax
+            predictions = np.argmax(predictions, axis=1)
+
+            # Handle one-hot encoded y
+            if len(y.shape) == 2:
+                y = np.argmax(y, axis=1)
+
+        return np.mean(predictions == y)

vanillanets/activations.py

@@ -0,0 +1,99 @@
+import numpy as np
+
+class Linear:
+
+    def forward(self, inputs):
+        self.inputs = inputs
+        self.output = inputs
+
+    def backward(self, dvalues):
+        # The derivative is 1, so 1 * dvalues = dvalues
+        self.dinputs = dvalues.copy()
+
+class Sigmoid:
+
+    def forward(self, inputs):
+        self.inputs = inputs
+        self.output = 1 / (1 + np.exp(-inputs))
+        
+    def backward(self, dvalues):
+        # Derivative of Sigmoid is: output * (1 - output)
+        self.dinputs = dvalues * (1 - self.output) * self.output
+        
+class ReLU:
+
+    def forward(self, inputs):
+        # Remember inputs for backward pass
+        self.inputs = inputs
+        self.output = np.maximum(0, inputs)
+
+    def backward(self, dvalues):
+        # Since we need to modify the original variable, we make a copy first
+        self.dinputs = dvalues.copy()
+        
+        # Zero gradient where input values were negative
+        self.dinputs[self.inputs <= 0] = 0
+
+
+class LeakyReLU:
+
+    def forward(self, inputs):
+        # Remember inputs for backward pass
+        self.inputs = inputs
+        self.output = np.where(inputs > 0, inputs, 0.1 * inputs)
+
+    def backward(self, dvalues):
+        # Make a copy of values first
+        self.dinputs = dvalues.copy()
+        
+        # Multiply gradient by 0.1 where input values were negative or zero
+        self.dinputs[self.inputs <= 0] *= 0.1
+
+class Tanh:
+    """
+    NumPy provides direct, built-in function for Tanh 
+    because it is a standard mathematical function (hyperbolic tangent), 
+    just like sine or cosine.
+    """
+
+    def forward(self, inputs):
+        """
+        # self.output = (np.exp(inputs) - np.exp(-inputs)) / (np.exp(inputs) + np.exp(-inputs))
+
+        # Manual formula for tanh works mathematically for small/typical inputs 
+        # but produces nan for large values because np.exp(inputs) overflows (is too large for float storage), 
+        # and the denominator also overflows, leading to division by infinity or undefined math.
+        """
+        
+        # The objective is to utilize NumPy for implementing the neural network, rather than hardcoding operations using pure Python.
+        self.inputs = inputs
+        self.output = np.tanh(inputs)
+
+    def backward(self, dvalues):
+            # Derivative of Tanh is: 1 - (output)^2
+            self.dinputs = dvalues * (1 - self.output ** 2)
+
+class Softmax:
+
+    def forward(self, inputs):
+        self.inputs = inputs
+        # Get unnormalized probabilities
+        exp_values = np.exp(inputs - np.max(inputs, axis=1, keepdims=True))
+        # Normalize them for each sample
+        probabilities = exp_values / np.sum(exp_values, axis=1, keepdims=True)
+        self.output = probabilities
+
+    def backward(self, dvalues):
+        # Create uninitialized array to hold the gradients
+        self.dinputs = np.empty_like(dvalues)
+
+        # Enumerate outputs and gradients
+        for index, (single_output, single_dvalues) in enumerate(zip(self.output, dvalues)):
+            # Flatten output array
+            single_output = single_output.reshape(-1, 1)
+            
+            # Calculate Jacobian matrix of the output
+            jacobian_matrix = np.diagflat(single_output) - np.dot(single_output, single_output.T)
+            
+            # Calculate sample-wise gradient and add it to the array of sample gradients
+            self.dinputs[index] = np.dot(jacobian_matrix, single_dvalues)

vanillanets/layers.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+
+class DenseLayer:
+    def __init__(self, n_inputs, n_neurons, *, activation='relu', init='auto',
+                 distribution='normal', bias_init='zeros', seed=None):
+        """
+        n_inputs: fan-in
+        n_neurons: fan-out
+        activation: 'relu', 'leaky_relu', 'tanh', 'sigmoid', 'softmax', 'linear'
+        init: 'auto' | 'he' | 'xavier'
+        distribution: 'normal' or 'uniform'
+        bias_init: 'zeros' or float (small constant)
+        seed: optional int for reproducibility
+        """
+        if seed is not None:
+            rng = np.random.default_rng(seed)
+        else:
+            rng = np.random.default_rng()
+
+        fan_in, fan_out = n_inputs, n_neurons
+
+        # choose initializer
+        if init == 'auto':
+            if activation in ('relu', 'leaky_relu'):
+                init = 'he'
+            else:
+                init = 'xavier'
+
+        if init == 'he':
+            # std = sqrt(2 / fan_in)
+            if distribution == 'normal':
+                std = np.sqrt(2.0 / fan_in)
+                self.weights = rng.normal(0.0, std, size=(fan_in, fan_out))
+            else:
+                # limit = sqrt(6 / fan_in)
+                limit = np.sqrt(6.0 / fan_in)
+                self.weights = rng.uniform(-limit, limit, size=(fan_in, fan_out))
+
+        elif init == 'xavier':
+            # normal: std = sqrt(2 / (fan_in + fan_out))
+            # uniform: limit = sqrt(6 / (fan_in + fan_out))
+            denom = (fan_in + fan_out)
+            if distribution == 'normal':
+                std = np.sqrt(2.0 / denom)
+                self.weights = rng.normal(0.0, std, size=(fan_in, fan_out))
+            else:
+                limit = np.sqrt(6.0 / denom)
+                self.weights = rng.uniform(-limit, limit, size=(fan_in, fan_out))
+
+        else:
+            raise ValueError("init must be 'auto', 'he', or 'xavier'")
+
+        # biases: prefer zeros; optionally small positive for ReLU to reduce dead units
+        if bias_init == 'zeros':
+            self.biases = np.zeros((1, fan_out))
+        elif isinstance(bias_init, (int, float)):
+            self.biases = np.full((1, fan_out), float(bias_init))
+        else:
+            raise ValueError("bias_init must be 'zeros' or a numeric constant")
+
+        self.output = None
+
+    def forward(self, inputs):
+        # Remember inputs for backward pass
+        self.inputs = inputs
+        self.output = np.dot(inputs, self.weights) + self.biases
+
+    def backward(self, dvalues):
+        # Gradients on parameters
+        # self.inputs.T is the transposed inputs from the forward pass
+        self.dweights = np.dot(self.inputs.T, dvalues)
+
+        # np.sum with axis=0 calculates the sum of gradients for each bias
+        # keepdims=True ensures the output shape matches self.biases (1, n_neurons)
+        self.dbiases = np.sum(dvalues, axis=0, keepdims=True)
+
+        # Gradient on values to pass to the previous layer
+        self.dinputs = np.dot(dvalues, self.weights.T)

vanillanets/losses.py

@@ -0,0 +1,145 @@
+import numpy as np
+
+# Common loss class
+class Loss:
+
+    """
+    Calculate mean loss between actual value and predicted value
+    """
+
+    # Calculate the data and regularization losses given model output and ground truth values
+    def calculate(self, output, y):
+        # Calculate sample losses
+        sample_losses = self.forward(output, y)
+
+        # Calculate mean loss
+        data_loss = np.mean(sample_losses)
+
+        return data_loss
+    
+class BinaryCrossEntropy(Loss):
+
+    def forward(self, y_pred, y_true):
+        """
+        Returns shape (n_samples,) when y_pred and y_true are both shape (n_samples,)
+
+        """
+
+        # Clip data to prevent division by 0
+        # Clip both sides to not drag mean towards any value
+        y_pred_clipped = np.clip(y_pred, 1e-7, 1 - 1e-7)
+
+        # Binary cross-entropy formula
+        sample_losses = -(y_true * np.log(y_pred_clipped) + (1 - y_true) * np.log(1 - y_pred_clipped))
+
+        return sample_losses
+    
+    def backward(self, dvalues, y_true):
+        # Number of samples
+        samples = len(dvalues)
+        
+        # Number of outputs in every sample
+        outputs = len(dvalues[0])
+
+        # Clip data to prevent division by 0
+        # Clip both sides to not drag mean towards any value
+        clipped_dvalues = np.clip(dvalues, 1e-7, 1 - 1e-7)
+
+        # Calculate gradient
+        self.dinputs = -(y_true / clipped_dvalues - (1 - y_true) / (1 - clipped_dvalues)) / outputs
+
+        # Normalize gradient across the batch
+        self.dinputs = self.dinputs / samples
+    
+# Cross-entropy loss
+class CategoricalCrossEntropy(Loss):
+
+    def forward(self, y_pred, y_true):
+        """
+        Returns shape (n_samples,) after extracting correct_confidences
+
+        """
+        
+        # Number of samples in a batch
+        samples = len(y_pred)
+
+        # Clip data to prevent division by 0
+        # Clip both sides to not drag mean towards any value
+        y_pred_clipped = np.clip(y_pred, 1e-7, 1 - 1e-7)
+
+        # Probabilities for target values
+        # Only if categorical labels
+        if len(y_true.shape) == 1:
+            correct_confidences = np.array([y_pred_clipped[i, y_true[i]] for i in range(samples)])
+        
+        # Mask values - only for one-hot encoded labels
+        elif len(y_true.shape) == 2:
+            correct_confidences = np.sum(
+                y_pred_clipped * y_true,
+                axis=1
+            )
+
+        # Losses
+        negative_log_likelihood = -np.log(correct_confidences)
+
+        return negative_log_likelihood
+    
+    def backward(self, dvalues, y_true):
+        samples = len(dvalues)
+        labels = len(dvalues[0])
+
+        if len(y_true.shape) == 1:
+            y_true = np.eye(labels)[y_true]
+
+        # Clip data to prevent division by 0
+        clipped_dvalues = np.clip(dvalues, 1e-7, 1 - 1e-7)
+
+        # Calculate gradient using the clipped values
+        self.dinputs = -y_true / clipped_dvalues
+
+        # Normalize gradient across the batch
+        self.dinputs = self.dinputs / samples
+    
+# Cross-entropy loss
+class SparseCategoricalCrossEntropy(Loss):
+
+    def forward(self, y_pred, y_true):
+        """
+        Returns shape (n_samples,) after extracting correct_confidences
+
+        """
+
+        # Number of samples in a batch
+        samples = len(y_pred)
+
+        # Clip data to prevent division by 0
+        # Clip both sides to not drag mean towards any value
+        y_pred_clipped = np.clip(y_pred, 1e-7, 1 - 1e-7)
+
+        correct_confidences = np.array([y_pred_clipped[i, y_true[i]] for i in range(samples)])
+
+        # Losses
+        negative_log_likelihood = -np.log(correct_confidences)
+        
+        return negative_log_likelihood
+    
+
+class MeanSquaredError(Loss):
+
+    def forward(self, y_pred, y_true):
+        # Calculate loss
+        sample_losses = np.mean((y_true - y_pred)**2, axis=-1)
+        return sample_losses
+
+    def backward(self, dvalues, y_true):
+        # Number of samples
+        samples = len(dvalues)
+        
+        # Number of outputs in every sample
+        outputs = len(dvalues[0])
+
+        # Gradient on values
+        self.dinputs = -2 * (y_true - dvalues) / outputs
+
+        # Normalize gradient across the batch
+        self.dinputs = self.dinputs / samples

vanillanets/metrics.py

@@ -0,0 +1,131 @@
+import numpy as np
+
+
+def _to_labels(predictions, y):
+    """
+    Convert raw model outputs and ground truth into 1D label arrays
+    suitable for classification metrics.
+
+    - predictions: (n, 1) -> threshold at 0.5 -> (n,)
+                    (n, C) -> argmax over classes -> (n,)
+    - y:           (n, 1) -> flatten -> (n,)        [binary, NOT one-hot]
+                    (n, C) -> argmax over classes -> (n,) [one-hot, multiclass]
+                    (n,)   -> unchanged
+    """
+    if predictions.shape[1] == 1:
+        predictions = (predictions > 0.5).astype(int).flatten()
+        if len(y.shape) == 2:
+            y = y.flatten()
+    else:
+        predictions = np.argmax(predictions, axis=1)
+        if len(y.shape) == 2:
+            y = np.argmax(y, axis=1)
+
+    return predictions, y.astype(int)
+
+
+class Accuracy:
+    """Fraction of correct predictions. Works for binary and multiclass."""
+
+    def calculate(self, predictions, y):
+        predictions, y = _to_labels(predictions, y)
+        return np.mean(predictions == y)
+
+
+class Precision:
+    """
+    Binary precision: TP / (TP + FP).
+    For multiclass, computes macro-averaged precision (mean over classes).
+    """
+
+    def calculate(self, predictions, y):
+        predictions, y = _to_labels(predictions, y)
+        classes = np.unique(np.concatenate([predictions, y]))
+
+        if len(classes) <= 2:
+            tp = np.sum((predictions == 1) & (y == 1))
+            fp = np.sum((predictions == 1) & (y == 0))
+            return tp / (tp + fp + 1e-7)
+
+        # macro-average over classes
+        scores = []
+        for c in classes:
+            tp = np.sum((predictions == c) & (y == c))
+            fp = np.sum((predictions == c) & (y != c))
+            scores.append(tp / (tp + fp + 1e-7))
+        return np.mean(scores)
+
+
+class Recall:
+    """
+    Binary recall: TP / (TP + FN).
+    For multiclass, computes macro-averaged recall (mean over classes).
+    """
+
+    def calculate(self, predictions, y):
+        predictions, y = _to_labels(predictions, y)
+        classes = np.unique(np.concatenate([predictions, y]))
+
+        if len(classes) <= 2:
+            tp = np.sum((predictions == 1) & (y == 1))
+            fn = np.sum((predictions == 0) & (y == 1))
+            return tp / (tp + fn + 1e-7)
+
+        scores = []
+        for c in classes:
+            tp = np.sum((predictions == c) & (y == c))
+            fn = np.sum((predictions != c) & (y == c))
+            scores.append(tp / (tp + fn + 1e-7))
+        return np.mean(scores)
+
+
+class F1Score:
+    """Harmonic mean of precision and recall."""
+
+    def calculate(self, predictions, y):
+        p = Precision().calculate(predictions, y)
+        r = Recall().calculate(predictions, y)
+        return 2 * p * r / (p + r + 1e-7)
+
+
+class ConfusionMatrix:
+    """
+    Returns an (n_classes, n_classes) integer matrix where
+    rows = true labels, columns = predicted labels.
+
+    num_classes can be passed explicitly (recommended), otherwise
+    it is inferred from the data (max label + 1), which may miss
+    classes absent from a given batch.
+    """
+
+    def calculate(self, predictions, y, num_classes=None):
+        predictions, y = _to_labels(predictions, y)
+        n = num_classes if num_classes is not None else int(max(predictions.max(), y.max())) + 1
+
+        cm = np.zeros((n, n), dtype=int)
+        for true_label, pred_label in zip(y, predictions):
+            cm[true_label, pred_label] += 1
+        return cm
+
+
+class R2Score:
+    """Coefficient of determination for regression. 1.0 is a perfect fit."""
+
+    def calculate(self, y_pred, y_true):
+        ss_res = np.sum((y_true - y_pred) ** 2)
+        ss_tot = np.sum((y_true - np.mean(y_true)) ** 2)
+        return 1 - ss_res / (ss_tot + 1e-7)
+
+
+class MAE:
+    """Mean Absolute Error for regression."""
+
+    def calculate(self, y_pred, y_true):
+        return np.mean(np.abs(y_true - y_pred))
+
+
+class RMSE:
+    """Root Mean Squared Error for regression."""
+
+    def calculate(self, y_pred, y_true):
+        return np.sqrt(np.mean((y_true - y_pred) ** 2))

vanillanets/model.py

@@ -0,0 +1,172 @@
+import numpy as np
+from vanillanets.activations import Softmax
+from vanillanets.losses import CategoricalCrossEntropy
+from vanillanets.softmax_loss import Activation_Softmax_Loss_CategoricalCrossentropy
+
+
+class Model:
+
+    def __init__(self):
+        # Create a list of network objects
+        self.layers = []
+        # Catch-all object for the fast Softmax+CrossEntropy backward pass
+        self.softmax_classifier_output = None
+        self.metrics = {}
+
+    # Add objects to the model
+    def add(self, layer):
+        self.layers.append(layer)
+
+    # Set loss, optimizer and metrics
+    def set(self, *, loss, optimizer, accuracy=None, metrics=None):
+        """
+        loss: a loss instance (CategoricalCrossEntropy, BinaryCrossEntropy, MeanSquaredError)
+        optimizer: an optimizer instance
+        accuracy: (legacy) single metric object with a .calculate(predictions, y) method.
+                  Kept for backward compatibility - automatically folded into `metrics`.
+        metrics: dict of {name: metric_object} or list of metric objects.
+                 Each metric object must implement .calculate(predictions, y).
+                 Examples: Accuracy(), Precision(), Recall(), F1Score(),
+                           R2Score(), MAE(), RMSE()
+        """
+        self.loss = loss
+        self.optimizer = optimizer
+
+        self.metrics = {}
+
+        # Backward-compatible single 'accuracy' metric
+        if accuracy is not None:
+            self.metrics['accuracy'] = accuracy
+
+        # New flexible metrics interface
+        if metrics is not None:
+            if isinstance(metrics, dict):
+                self.metrics.update(metrics)
+            else:
+                # list/tuple of metric objects -> derive names from class names
+                for m in metrics:
+                    name = type(m).__name__.lower()
+                    self.metrics[name] = m
+
+    # Finalize the model setup
+    def finalize(self):
+        # If the last layer is Softmax and the loss is Categorical Cross-Entropy,
+        # we create the combined object for a much faster backward pass
+        if self.loss is not None and isinstance(self.layers[-1], Softmax) and \
+           isinstance(self.loss, CategoricalCrossEntropy):
+            self.softmax_classifier_output = Activation_Softmax_Loss_CategoricalCrossentropy()
+
+    # Run a forward pass through all layers and return final output
+    def predict(self, X):
+        layer_input = X
+        for layer in self.layers:
+            layer.forward(layer_input)
+            layer_input = layer.output
+        return layer_input
+
+    # Compute loss and all configured metrics for a given dataset
+    # without performing any backward pass / parameter updates
+    def evaluate(self, X, y):
+        predictions = self.predict(X)
+        loss_value = self.loss.calculate(predictions, y)
+
+        results = {}
+        for name, metric in self.metrics.items():
+            results[name] = metric.calculate(predictions, y)
+
+        return loss_value, results
+
+    # Train the model
+    def fit(self, X, y, *, epochs=1, print_every=100, validation_data=None):
+        """
+        validation_data: optional (X_val, y_val) tuple. If provided, validation
+        loss and metrics are computed (without affecting training) and printed
+        alongside training stats.
+        """
+
+        # Main training loop
+        for epoch in range(1, epochs + 1):
+
+            # --- FORWARD PASS ---
+            # The initial input is our training data
+            layer_input = X
+
+            # Forward pass through all layers in the list
+            for layer in self.layers:
+                layer.forward(layer_input)
+                # The output of this layer becomes the input of the next layer
+                layer_input = layer.output
+
+            # Calculate loss from the output of the final layer
+            data_loss = self.loss.calculate(layer_input, y)
+
+            # --- METRICS ---
+            metric_results = {}
+            for name, metric in self.metrics.items():
+                metric_results[name] = metric.calculate(layer_input, y)
+
+            # --- BACKWARD PASS ---
+
+            # Check if we are using the fast Softmax+CCE combination
+            if self.softmax_classifier_output is not None:
+                # Do the fast backward pass
+                self.softmax_classifier_output.backward(layer_input, y)
+                # The gradient to pass back comes from this fused object
+                dinputs = self.softmax_classifier_output.dinputs
+
+                # We safely ignore the standalone Softmax layer for the backward loop
+                layers_to_backprop = self.layers[:-1]
+
+            else:
+                # ONLY if we aren't using the shortcut, calculate standalone loss gradient
+                self.loss.backward(layer_input, y)
+                dinputs = self.loss.dinputs
+
+                # Backpropagate through all layers normally
+                layers_to_backprop = self.layers
+
+            # Loop backward through the remaining layers
+            for layer in reversed(layers_to_backprop):
+                layer.backward(dinputs)
+                dinputs = layer.dinputs
+
+            # --- OPTIMIZATION ---
+            self.optimizer.pre_update_lr()
+
+            # We only update parameters for layers that actually have weights (DenseLayers)
+            for layer in self.layers:
+                if hasattr(layer, 'weights'):
+                    self.optimizer.update_params(layer)
+
+            # Increment iteration counter
+            self.optimizer.post_update_params()
+
+            # --- VALIDATION (optional) ---
+            # Run after backward/update so this forward pass doesn't
+            # clobber the cached layer state used during backprop.
+            val_loss = None
+            val_metric_results = {}
+            if validation_data is not None:
+                X_val, y_val = validation_data
+                val_loss, val_metric_results = self.evaluate(X_val, y_val)
+
+            # Print status updates
+            if not epoch % print_every:
+                metric_str = ', '.join(
+                    f'{name}: {value:.3f}' for name, value in metric_results.items()
+                )
+                line = f'epoch: {epoch}'
+                if metric_str:
+                    line += f', {metric_str}'
+                line += f', loss: {data_loss:.3f}'
+                line += f', lr: {self.optimizer.current_learning_rate:.6f}'
+
+                if validation_data is not None:
+                    val_metric_str = ', '.join(
+                        f'val_{name}: {value:.3f}' for name, value in val_metric_results.items()
+                    )
+                    line += f', val_loss: {val_loss:.3f}'
+                    if val_metric_str:
+                        line += f', {val_metric_str}'
+
+                print(line)

vanillanets/optimizers.py

@@ -0,0 +1,109 @@
+import numpy as np
+
+class Optimizer_SGD:
+
+    # Initialize optimizer - set learning rate, decay, and momentum
+    def __init__(self, learning_rate=1.0, decay=0., momentum=0.):
+        self.learning_rate = learning_rate
+        self.current_learning_rate = learning_rate
+        self.decay = decay
+        self.iterations = 0
+        self.momentum = momentum
+
+    # Call once before any parameter updates
+    def pre_update_lr(self):
+        # If we have a decay rate, calculate the decayed learning rate
+        if self.decay:
+            self.current_learning_rate = self.learning_rate * (1. / (1. + self.decay * self.iterations))
+
+    # Update parameters
+    def update_params(self, layer):
+        
+        # If we use momentum
+        if self.momentum:
+            
+            # If layer does not contain momentum arrays, create them filled with zeros
+            if not hasattr(layer, 'weight_momentums'):
+                layer.weight_momentums = np.zeros_like(layer.weights)
+                layer.bias_momentums = np.zeros_like(layer.biases)
+
+            # Build weight updates with momentum - take previous updates multiplied by retain factor and update with current gradients
+            weight_updates = \
+                self.momentum * layer.weight_momentums - \
+                self.current_learning_rate * layer.dweights
+            
+            # Save the updates for the next iteration
+            layer.weight_momentums = weight_updates
+
+            # Build bias updates with momentum
+            bias_updates = \
+                self.momentum * layer.bias_momentums - \
+                self.current_learning_rate * layer.dbiases
+            
+            layer.bias_momentums = bias_updates
+
+        # Vanilla SGD updates if momentum is 0
+        else:
+            weight_updates = -self.current_learning_rate * layer.dweights
+            bias_updates = -self.current_learning_rate * layer.dbiases
+
+        # Update weights and biases using either vanilla or momentum updates
+        layer.weights += weight_updates
+        layer.biases += bias_updates
+
+    # Call once after any parameter updates
+    def post_update_params(self):
+        self.iterations += 1
+
+
+class Optimizer_Adam:
+
+    # Initialize optimizer - set parameters to Adam's standard defaults
+    def __init__(self, learning_rate=0.001, decay=0., epsilon=1e-7, beta_1=0.9, beta_2=0.999):
+        self.learning_rate = learning_rate
+        self.current_learning_rate = learning_rate
+        self.decay = decay
+        self.iterations = 0
+        self.epsilon = epsilon
+        self.beta_1 = beta_1
+        self.beta_2 = beta_2
+
+    # Call once before any parameter updates
+    def pre_update_lr(self):
+        if self.decay:
+            self.current_learning_rate = self.learning_rate * (1. / (1. + self.decay * self.iterations))
+
+    # Update parameters
+    def update_params(self, layer):
+
+        # If layer does not contain cache arrays, create them filled with zeros
+        if not hasattr(layer, 'weight_cache'):
+            layer.weight_momentums = np.zeros_like(layer.weights)
+            layer.weight_cache = np.zeros_like(layer.weights)
+            layer.bias_momentums = np.zeros_like(layer.biases)
+            layer.bias_cache = np.zeros_like(layer.biases)
+
+        # --- Update momentum  with current gradients ---
+        layer.weight_momentums = self.beta_1 * layer.weight_momentums + (1 - self.beta_1) * layer.dweights
+        layer.bias_momentums = self.beta_1 * layer.bias_momentums + (1 - self.beta_1) * layer.dbiases
+        
+        # Get corrected momentum (to account for the zero initialization bias at the start of training)
+        # self.iteration is 0 at first pass, so we add 1
+        weight_momentums_corrected = layer.weight_momentums / (1 - self.beta_1 ** (self.iterations + 1))
+        bias_momentums_corrected = layer.bias_momentums / (1 - self.beta_1 ** (self.iterations + 1))
+        
+        # --- Update cache with squared current gradients ---
+        layer.weight_cache = self.beta_2 * layer.weight_cache + (1 - self.beta_2) * layer.dweights**2
+        layer.bias_cache = self.beta_2 * layer.bias_cache + (1 - self.beta_2) * layer.dbiases**2
+        
+        # Get corrected cache
+        weight_cache_corrected = layer.weight_cache / (1 - self.beta_2 ** (self.iterations + 1))
+        bias_cache_corrected = layer.bias_cache / (1 - self.beta_2 ** (self.iterations + 1))
+
+        # --- Perform the actual parameter updates ---
+        layer.weights += -self.current_learning_rate * weight_momentums_corrected / (np.sqrt(weight_cache_corrected) + self.epsilon)
+        layer.biases += -self.current_learning_rate * bias_momentums_corrected / (np.sqrt(bias_cache_corrected) + self.epsilon)
+
+    # Call once after any parameter updates
+    def post_update_params(self):
+        self.iterations += 1

vanillanets/softmax_loss.py

@@ -0,0 +1,41 @@
+import numpy as np
+from vanillanets.activations import Softmax
+from vanillanets.losses import CategoricalCrossEntropy
+
+class Activation_Softmax_Loss_CategoricalCrossentropy:
+    """
+    Combined Softmax activation and cross-entropy loss for faster backward step
+    """
+    def __init__(self):
+        self.activation = Softmax()
+        self.loss = CategoricalCrossEntropy()
+
+    # Forward pass
+    def forward(self, inputs, y_true):
+        # Output layer's activation function
+        self.activation.forward(inputs)
+        # Set the output
+        self.output = self.activation.output
+        # Calculate and return loss value
+        return self.loss.calculate(self.output, y_true)
+
+    # Backward pass
+    def backward(self, dvalues, y_true):
+        # Number of samples
+        samples = len(dvalues)
+
+        # If labels are one-hot encoded, turn them into discrete values
+        if len(y_true.shape) == 2:
+            y_true = np.argmax(y_true, axis=1)
+
+        # Copy so we can safely modify
+        self.dinputs = dvalues.copy()
+        
+        # Calculate gradient (predicted probability - true label)
+        # We subtract 1 from the predicted probability at the index of the true label
+        self.dinputs[range(samples), y_true] -= 1
+        
+        # Normalize gradient
+        # If we don't normalize, larger batch sizes will result in larger gradients, 
+        # making training unstable.
+        self.dinputs = self.dinputs / samples

vanillanets-1.0.0.dist-info/METADATA

@@ -0,0 +1,383 @@
+Metadata-Version: 2.4
+Name: vanillanets
+Version: 1.0.0
+Summary: A transparent, NumPy-only neural network library for learning and experimentation.
+Home-page: https://github.com/UmarBalak/vanillanets
+Author: Umar Balak
+Author-email: Umar Balak <umarbalak35@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/UmarBalak/vanillanets
+Project-URL: Documentation, https://github.com/UmarBalak/vanillanets#readme
+Project-URL: Repository, https://github.com/UmarBalak/vanillanets
+Project-URL: Bug Tracker, https://github.com/UmarBalak/vanillanets/issues
+Keywords: neural-network,deep-learning,machine-learning,numpy,education,from-scratch
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.3.3
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# VanillaNets v1.0.0
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8%2B-blue)](https://www.python.org/downloads/)
+[![NumPy](https://img.shields.io/badge/dependency-numpy%202.3.3%2B-green)](https://numpy.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Status: Production Ready ✓](https://img.shields.io/badge/status-production%20ready-success)]()
+
+**A transparent, NumPy-only neural network library designed for learning and experimentation.**
+
+VanillaNets is a from-scratch implementation of core neural network components using only Python and NumPy. Every component is written explicitly with clarity prioritized over convenience, making the entire system transparent, easy to inspect, and perfect for understanding how neural networks operate under the hood.
+
+Whether you're a student learning fundamentals, a researcher prototyping new ideas, or an educator building curriculum, VanillaNets provides a crystal-clear window into neural network mechanics without framework abstractions.
+
+---
+
+## Features
+
+### Core Architecture
+* **Dense Layers** - Fully connected layers with efficient forward and backward passes
+* **Advanced Weight Initialization** - He, Xavier (Glorot), normal and uniform distributions for optimized training
+* **Flexible Bias Initialization** - Zeros or small positive constants to reduce dead units
+
+### Activation Functions (with derivatives)
+* Linear, ReLU & LeakyReLU
+* Tanh & Sigmoid
+* Softmax (with fused Softmax+CrossEntropy backward pass optimization)
+
+### Loss Functions
+* Binary Cross-Entropy (for binary classification)
+* Categorical Cross-Entropy (for multiclass classification)
+* Sparse Categorical Cross-Entropy (for integer-encoded labels)
+* Mean Squared Error (for regression)
+
+### Optimizers
+* **SGD** - Stochastic Gradient Descent with momentum and learning rate decay
+* **Adam** - Adaptive Moment Estimation with adaptive learning rates per parameter
+
+### Metrics & Evaluation
+* **Classification:** Accuracy, Precision, Recall, F1 Score, Confusion Matrix
+* **Regression:** R² Score, Mean Absolute Error (MAE), Root Mean Squared Error (RMSE)
+
+### Model API
+* Sequential model building (`model.add()`)
+* Flexible metrics interface (single metric or multiple metrics as dict/list)
+* Training with `fit()` and optional validation data
+* Inference with `predict()`
+* Batch evaluation with `evaluate()`
+
+### Performance Optimizations
+* Fused Softmax + Categorical Cross-Entropy backward pass (faster training)
+* Efficient NumPy vectorization throughout
+* Memory-conscious layer implementations
+
+---
+
+## Installation
+
+### From PyPI (Recommended)
+
+Install directly from PyPI:
+
+```bash
+pip install vanillanets
+```
+
+### From Source
+
+Clone the repository and install in development mode:
+
+```bash
+git clone https://github.com/UmarBalak/vanillanets.git
+cd vanillanets
+pip install -e .
+```
+
+Or install with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+### Requirements
+
+- **Python:** 3.8 or higher
+- **NumPy:** 2.3.3+ (for efficient numerical computation)
+
+### Verify Installation
+
+```python
+import vanillanets
+print(f"VanillaNets {vanillanets.__version__} installed successfully!")
+
+# Import core components
+from vanillanets import Model, DenseLayer
+from vanillanets.activations import ReLU, Sigmoid
+from vanillanets.losses import BinaryCrossEntropy
+from vanillanets.optimizers import Optimizer_Adam
+from vanillanets.metrics import Accuracy
+
+print("✓ All modules imported successfully!")
+```
+
+---
+
+## Quick Start
+
+### Example 1: Binary Classification
+
+```python
+from vanillanets import Model, DenseLayer, Optimizer_Adam
+from vanillanets.activations import ReLU, Sigmoid
+from vanillanets.losses import BinaryCrossEntropy
+from vanillanets.metrics import Accuracy
+
+# Build model
+model = Model()
+model.add(DenseLayer(30, 64))
+model.add(ReLU())
+model.add(DenseLayer(64, 1))
+model.add(Sigmoid())
+
+# Compile with loss, optimizer, and metrics
+model.set(
+    loss=BinaryCrossEntropy(),
+    optimizer=Optimizer_Adam(learning_rate=0.01),
+    metrics={'accuracy': Accuracy()}
+)
+model.finalize()
+
+# Train the model
+model.fit(X_train, y_train, epochs=100, print_every=10, 
+          validation_data=(X_val, y_val))
+
+# Evaluate on test set
+loss, metrics = model.evaluate(X_test, y_test)
+print(f"Test Loss: {loss:.4f}, Accuracy: {metrics['accuracy']:.4f}")
+
+# Make predictions
+predictions = model.predict(X_new)
+```
+
+### Example 2: Multiclass Classification
+
+```python
+from vanillanets import Model, DenseLayer, Optimizer_Adam
+from vanillanets.activations import ReLU, Softmax
+from vanillanets.losses import CategoricalCrossEntropy
+from vanillanets.metrics import Accuracy
+
+# Build model
+model = Model()
+model.add(DenseLayer(784, 128))
+model.add(ReLU())
+model.add(DenseLayer(128, 64))
+model.add(ReLU())
+model.add(DenseLayer(64, 10))
+model.add(Softmax())
+
+# Compile
+model.set(
+    loss=CategoricalCrossEntropy(),
+    optimizer=Optimizer_Adam(learning_rate=0.05),
+    metrics={'accuracy': Accuracy()}
+)
+model.finalize()
+
+# Train
+model.fit(X_train, y_train, epochs=50, print_every=5)
+```
+
+### Example 3: Regression
+
+```python
+from vanillanets import Model, DenseLayer, Optimizer_Adam
+from vanillanets.activations import Linear, ReLU
+from vanillanets.losses import MeanSquaredError
+from vanillanets.metrics import RMSE, MAE
+
+# Build model
+model = Model()
+model.add(DenseLayer(8, 64))
+model.add(ReLU())
+model.add(DenseLayer(64, 1))
+model.add(Linear())
+
+# Compile with multiple metrics
+model.set(
+    loss=MeanSquaredError(),
+    optimizer=Optimizer_Adam(learning_rate=0.01),
+    metrics={'rmse': RMSE(), 'mae': MAE()}
+)
+model.finalize()
+
+# Train and evaluate
+model.fit(X_train, y_train, epochs=100, validation_data=(X_val, y_val))
+loss, metrics = model.evaluate(X_test, y_test)
+print(f"Test RMSE: {metrics['rmse']:.4f}, MAE: {metrics['mae']:.4f}")
+```
+
+---
+
+## Examples
+
+Full working examples included:
+* `binary_classification.py` - Breast cancer classification
+* `multiclass_classification.py` - Handwritten digit recognition
+* `regression.py` - California housing price prediction
+
+Run any example:
+```bash
+python binary_classification.py
+python multiclass_classification.py
+python regression.py
+```
+
+---
+
+## Testing
+
+Run the comprehensive test suite (requires pytest):
+
+```bash
+pip install pytest
+pytest tests/ -v
+```
+
+Or run tests with coverage:
+
+```bash
+pip install pytest pytest-cov
+pytest tests/ -v --cov=vanillanets
+```
+
+### Test Coverage
+
+Comprehensive unit and integration tests cover:
+- ✓ All activation functions (Linear, Sigmoid, ReLU, LeakyReLU, Tanh, Softmax) and their derivatives
+- ✓ All loss functions (BCE, CCE, SparseCCE, MSE) with gradient validation
+- ✓ Dense layer forward/backward passes
+- ✓ Optimizer updates (SGD momentum, Adam adaptive rates)
+- ✓ Fused Softmax+CrossEntropy optimization
+- ✓ All metrics (classification & regression)
+- ✓ Model training, evaluation, and prediction workflows
+- ✓ Edge cases and numerical stability
+
+---
+
+## Design Philosophy
+
+VanillaNets is built on the principle that **understanding requires transparency**:
+
+- **No magic** ✓ Every computation is explicit; no hidden state or black-box frameworks
+- **Learn by reading** ✓ Source code is the primary documentation
+- **Experimentation-friendly** ✓ Modify any component without framework constraints
+- **Pure NumPy** ✓ No external dependencies beyond NumPy for core functionality
+- **Production-ready** ✓ Full test coverage, efficient implementations, stable API
+
+## Use Cases
+
+- **Education:** Perfect for coursework on neural networks and deep learning
+- **Research Prototyping:** Experiment with new loss functions, activations, or optimization strategies
+- **Interview Prep:** Implement solutions from scratch during ML engineering interviews
+- **Curriculum Development:** Build course materials with fully transparent implementations
+- **Algorithmic Learning:** Understand backpropagation, gradient descent, and optimizer mechanics
+
+---
+
+## Project Status
+
+### v1.0.0 - Production Ready
+
+**Fully Implemented & Tested:**
+- ✓ Dense layer implementation with He, Xavier, normal, and uniform weight initialization
+- ✓ All activation functions with proper gradient computation (Linear, ReLU, LeakyReLU, Tanh, Sigmoid, Softmax)
+- ✓ All loss functions with backward passes (BCE, CCE, SparseCCE, MSE)
+- ✓ SGD optimizer with momentum and learning rate decay
+- ✓ Adam optimizer with adaptive learning rates
+- ✓ Comprehensive metrics suite (Accuracy, Precision, Recall, F1, Confusion Matrix, R², MAE, RMSE)
+- ✓ Full Model API (add, set, finalize, predict, evaluate, fit)
+- ✓ Fused Softmax+CrossEntropy optimization for faster training
+- ✓ Extensive test coverage (50+ test cases)
+- ✓ Complete example applications (binary classification, multiclass classification, regression)
+- ✓ Validation data support during training
+
+### Future Enhancements (Post-v1.0)
+- Convolutional (Conv2D) layers with pooling
+- Recurrent layers (LSTM, GRU)
+- Batch normalization and layer normalization
+- Dropout regularization
+- Custom layer support through base class
+- Learning rate scheduling
+- Distributed training utilities (multi-GPU)
+- Quantization and pruning support
+
+---
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for full details.
+
+You are free to use, modify, and distribute this software for any purpose (commercial or personal) with proper attribution.
+
+---
+
+## Acknowledgments
+
+VanillaNets was built with a singular mission: to demystify neural networks for learners everywhere. This library stands on the shoulders of foundational work in deep learning by pioneers like Yann LeCun, Geoffrey Hinton, Yoshua Bengio, and the broader machine learning community.
+
+Special thanks to:
+- The NumPy team for creating an incredible numerical computing foundation
+- All educators who emphasize understanding over black-box frameworks
+- Contributors and users who provide feedback and improvements
+
+## Citation
+
+If you use VanillaNets in your research or teaching, please cite:
+
+```bibtex
+@software{vanillanets2026,
+  title={VanillaNets: A Transparent Neural Network Library},
+  author={Umar Balak},
+  year={2026},
+  url={https://github.com/UmarBalak/vanillanets}
+}
+```
+
+---
+
+## Resources & References
+
+### Recommended Reading
+- **Neural Networks from Scratch in Python**, co-authored by Harrison Kinsley and Daniel Kukieła
+- **Deep Learning** by Goodfellow, I., Bengio, Y., & Courville, A.
+- **Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 3rd Edition** by Aurélien Géron
+
+
+### Related Projects
+- [NumPy](https://numpy.org/) - Our computational foundation
+- [3blue1brown Neural Network Series](https://www.youtube.com/watch?v=aircAruvnKk) - Visual learning guide
+
+---
+
+**Built with ❤️ for learners by learners.**

vanillanets-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+vanillanets/__init__.py,sha256=ywI6UnQa1AVEyGSxv2OKjmP1Obx54Fskh8XWKEU8jCk,2814
+vanillanets/accuracy.py,sha256=x5Qb7XvTaojrY4Vd1OEz992ecup6LNMDCPXW7JH7DXM,806
+vanillanets/activations.py,sha256=X028DOX9tKw3tMDHBOd0vtDfVyeXje1wu4LXY5YSR_M,3544
+vanillanets/layers.py,sha256=kJ72oq2B_8cACxog6WAzRM2F7svgF9IwkgL_XyNVrPs,3074
+vanillanets/losses.py,sha256=7GQ4L1sG_YUESPpLMgs5YIUqmrW3jOKAvhEgccBj6a0,4413
+vanillanets/metrics.py,sha256=nAJ28aYXDGNr3HZTwAPwrQc-h69Zep63iX2lPycsQnc,4180
+vanillanets/model.py,sha256=m_uRH3IxSY3iE6BSRQscwbR5mFAxPjBJ2MOrchfkQv4,7007
+vanillanets/optimizers.py,sha256=dowIBxR0di44yF9DWTar9XKVA4AeO3X-OhnTV7UV7RA,4925
+vanillanets/softmax_loss.py,sha256=MHctKr2e95f9FURuMihbXnZb0LiuunuF6_YaIjlcc5U,1498
+vanillanets-1.0.0.dist-info/licenses/LICENSE,sha256=Pkze_eXRJG35hZ53fp3bvOwIEJdIZUUY7FHJFT1YMtQ,1086
+vanillanets-1.0.0.dist-info/METADATA,sha256=9h6vbuR_uajR0BqDG84O6k6cy2Shx7YgglRxag39wJY,12836
+vanillanets-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+vanillanets-1.0.0.dist-info/top_level.txt,sha256=6S4aQN1FXxrD2H-PBo2DVAPLgRhXnpYpJ_6X9mNgSnw,12
+vanillanets-1.0.0.dist-info/RECORD,,

vanillanets-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vanillanets-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Umar Balak
+
+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.

vanillanets-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vanillanets