pynet-ai 1.3.1__tar.gz

pynet_ai-1.3.1/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: pynet-ai
+Version: 1.3.1
+Summary: A Python neural network library for simple networks and educational use.
+Author-email: Andru Cupala <andru@cupala.com>
+License-Expression: LicenseRef-PolyForm-Noncommercial-1.0.0
+Keywords: neural-network,machine-learning,deep-learning,education,python
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# PyNet
+
+A simple educational neural network library built from scratch in Python.
+
+PyNet focuses on understanding how neural networks work internally, including layers, activations, loss functions, backpropagation, optimizers, weight initialization, and model serialization.
+
+## Features
+
+### Layers
+
+- Dense (fully connected) layers
+
+### Activations
+
+- ReLU
+- LeakyReLU
+- Sigmoid
+- Tanh
+- Softmax
+- ELU
+- Swish
+- GELU
+
+### Loss Functions
+
+- MSELoss
+- CrossEntropyLoss
+- MAELoss
+- HuberLoss
+- BinaryCrossEntropyLoss
+
+### Optimizers
+
+- SGD
+- Momentum
+- Adam
+
+### Weight Initialization
+
+- He
+- Xavier
+- RandomNormal
+- Zeros
+
+### Utilities
+
+- Metrics
+- Model saving/loading
+
+## Examples
+
+PyNet includes examples demonstrating:
+
+- Multiplication Prediction
+- Regression
+- XOR Classification
+
+## Installation
+
+Copy PyNet files into project directory. PyNet will be on PyPi soon.

pynet_ai-1.3.1/README.md

@@ -0,0 +1,60 @@
+# PyNet
+
+A simple educational neural network library built from scratch in Python.
+
+PyNet focuses on understanding how neural networks work internally, including layers, activations, loss functions, backpropagation, optimizers, weight initialization, and model serialization.
+
+## Features
+
+### Layers
+
+- Dense (fully connected) layers
+
+### Activations
+
+- ReLU
+- LeakyReLU
+- Sigmoid
+- Tanh
+- Softmax
+- ELU
+- Swish
+- GELU
+
+### Loss Functions
+
+- MSELoss
+- CrossEntropyLoss
+- MAELoss
+- HuberLoss
+- BinaryCrossEntropyLoss
+
+### Optimizers
+
+- SGD
+- Momentum
+- Adam
+
+### Weight Initialization
+
+- He
+- Xavier
+- RandomNormal
+- Zeros
+
+### Utilities
+
+- Metrics
+- Model saving/loading
+
+## Examples
+
+PyNet includes examples demonstrating:
+
+- Multiplication Prediction
+- Regression
+- XOR Classification
+
+## Installation
+
+Copy PyNet files into project directory. PyNet will be on PyPi soon.

pynet_ai-1.3.1/pynet/__init__.py

@@ -0,0 +1,10 @@
+from .network import Network
+from .layer import Layer, Dense
+from .initialization import Initializer, RandomNormal, Zeros, Xavier, He
+from .activation import Activation, ReLU, LeakyReLU, Sigmoid, Softmax, Tanh, ELU, Swish, GELU
+from .loss import Loss, MSELoss, CrossEntropyLoss, MAELoss, HuberLoss, BinaryCrossEntropyLoss
+from .optimizer import Optimizer, SGD, Momentum, Adam
+from .metrics import accuracy, mean_squared_error, mean_absolute_error
+from .serialization import save, load
+
+__version__ = "1.3.1"

pynet_ai-1.3.1/pynet/activation.py

@@ -0,0 +1,134 @@
+import math
+
+
+class Activation:
+
+    def forward(self, x):
+        raise NotImplementedError
+
+    def backward(self, gradient):
+        raise NotImplementedError
+
+
+class ReLU(Activation):
+
+    def __init__(self):
+        self.input = None
+
+    def forward(self, x):
+        self.input = x
+        return [max(0, value) for value in x]
+
+    def backward(self, gradient):
+        return [g if value > 0 else 0 for g, value in zip(gradient, self.input)]
+
+
+class LeakyReLU(Activation):
+
+    def __init__(self, alpha=0.01):
+        self.alpha = alpha
+        self.input = None
+
+    def forward(self, x):
+        self.input = x
+        return [value if value > 0 else self.alpha * value for value in x]
+
+    def backward(self, gradient):
+        return [g if value > 0 else g * self.alpha for g, value in zip(gradient, self.input)]
+
+
+class Sigmoid(Activation):
+
+    def __init__(self):
+        self.output = None
+
+    def forward(self, x):
+        self.output = []
+        for value in x:
+            value = max(min(value, 50), -50)
+            self.output.append(1 / (1 + math.exp(-value)))
+        return self.output
+
+    def backward(self, gradient):
+        return [g * value * (1 - value) for g, value in zip(gradient, self.output)]
+
+
+class Softmax(Activation):
+
+    def __init__(self):
+        self.output = None
+
+    def forward(self, x):
+        maximum = max(x)
+        exp_values = [math.exp(value - maximum) for value in x]
+        total = sum(exp_values)
+        self.output = [value / total for value in exp_values]
+        return self.output
+
+    def backward(self, gradient):
+        return gradient
+
+
+class Tanh(Activation):
+
+    def __init__(self):
+        self.output = None
+
+    def forward(self, x):
+        self.output = [math.tanh(value) for value in x]
+        return self.output
+
+    def backward(self, gradient):
+        return [g * (1 - value**2) for g, value in zip(gradient, self.output)]
+
+
+class ELU(Activation):
+
+    def __init__(self, alpha=1.0):
+        self.alpha = alpha
+        self.input = None
+
+    def forward(self, x):
+        self.input = x
+        return [value if value > 0 else self.alpha * (math.exp(value) - 1) for value in x]
+
+    def backward(self, gradient):
+        return [g if value > 0 else g * self.alpha * math.exp(value) for g, value in zip(gradient, self.input)]
+
+
+class Swish(Activation):
+
+    def __init__(self):
+        self.input = None
+        self.output = None
+
+    def forward(self, x):
+        self.input = x
+        self.output = [value / (1 + math.exp(-value)) for value in x]
+        return self.output
+
+    def backward(self, gradient):
+        result = []
+        for g, value in zip(gradient, self.input):
+            sigmoid = 1 / (1 + math.exp(-value))
+            derivative = sigmoid + value * sigmoid * (1 - sigmoid)
+            result.append(g * derivative)
+        return result
+
+
+class GELU(Activation):
+
+    def __init__(self):
+        self.input = None
+
+    def forward(self, x):
+        self.input = x
+        return [0.5 * value * (1 + math.tanh(math.sqrt(2 / math.pi) * (value + 0.044715 * value**3))) for value in x]
+
+    def backward(self, gradient):
+        result = []
+        for g, value in zip(gradient, self.input):
+            tanh_value = math.tanh(math.sqrt(2 / math.pi) * (value + 0.044715 * value**3))
+            derivative = 0.5 * (1 + tanh_value) + 0.5 * value * (1 - tanh_value**2) * math.sqrt(2 / math.pi) * (1 + 3 * 0.044715 * value**2)
+            result.append(g * derivative)
+        return result

pynet_ai-1.3.1/pynet/initialization.py

@@ -0,0 +1,38 @@
+import math
+import random
+
+
+class Initializer:
+
+    def initialize(self, inputs, outputs):
+        raise NotImplementedError
+
+
+class RandomNormal(Initializer):
+
+    def __init__(self, mean=0.0, std=1.0):
+        self.mean = mean
+        self.std = std
+
+    def initialize(self, inputs, outputs):
+        return [[random.gauss(self.mean, self.std) for _ in range(inputs)] for _ in range(outputs)]
+
+
+class Zeros(Initializer):
+
+    def initialize(self, inputs, outputs):
+        return [[0.0 for _ in range(inputs)] for _ in range(outputs)]
+
+
+class Xavier(Initializer):
+
+    def initialize(self, inputs, outputs):
+        scale = math.sqrt(1 / inputs)
+        return [[random.gauss(0, scale) for _ in range(inputs)] for _ in range(outputs)]
+
+
+class He(Initializer):
+
+    def initialize(self, inputs, outputs):
+        scale = math.sqrt(2 / inputs)
+        return [[random.gauss(0, scale) for _ in range(inputs)] for _ in range(outputs)]

pynet_ai-1.3.1/pynet/layer.py

@@ -0,0 +1,73 @@
+import random
+from .initialization import He
+
+
+class Layer:
+
+    def forward(self, x):
+        raise NotImplementedError
+
+    def backward(self, gradient):
+        raise NotImplementedError
+
+    def zero_grad(self):
+        pass
+
+    def get_config(self):
+        return {}
+
+    def get_parameters(self):
+        return {}
+
+    def set_parameters(self, parameters):
+        pass
+
+
+class Dense(Layer):
+
+    def __init__(self, inputs, outputs, initializer=None):
+        self.inputs = inputs
+        self.outputs = outputs
+        if initializer is None:
+            initializer = He()
+        self.initializer = initializer
+        self.weights = initializer.initialize(inputs, outputs)
+        self.biases = [random.uniform(-0.01, 0.01) for _ in range(outputs)]
+        self.input = None
+        self.weight_gradients = [[0.0 for _ in range(inputs)] for _ in range(outputs)]
+        self.bias_gradients = [0.0 for _ in range(outputs)]
+
+    def forward(self, x):
+        self.input = x
+        output = []
+        for neuron_weights, bias in zip(self.weights, self.biases):
+            total = bias
+            for weight, value in zip(neuron_weights, x):
+                total += weight * value
+            output.append(total)
+        return output
+
+    def backward(self, gradient):
+        input_gradient = [0.0 for _ in range(self.inputs)]
+        for neuron in range(self.outputs):
+            self.bias_gradients[neuron] += gradient[neuron]
+            for previous in range(self.inputs):
+                self.weight_gradients[neuron][previous] += gradient[neuron] * self.input[previous]
+                input_gradient[previous] += self.weights[neuron][previous] * gradient[neuron]
+        return input_gradient
+
+    def zero_grad(self):
+        for neuron in range(self.outputs):
+            self.bias_gradients[neuron] = 0.0
+            for previous in range(self.inputs):
+                self.weight_gradients[neuron][previous] = 0.0
+
+    def get_config(self):
+        return {"inputs": self.inputs, "outputs": self.outputs, "initializer": self.initializer.__class__.__name__}
+
+    def get_parameters(self):
+        return {"weights": self.weights, "biases": self.biases}
+
+    def set_parameters(self, parameters):
+        self.weights = parameters["weights"]
+        self.biases = parameters["biases"]

pynet_ai-1.3.1/pynet/loss.py

@@ -0,0 +1,97 @@
+import math
+
+
+class Loss:
+
+    def forward(self, prediction, target):
+        raise NotImplementedError
+
+    def backward(self, prediction, target):
+        raise NotImplementedError
+
+
+class MSELoss(Loss):
+
+    def forward(self, prediction, target):
+        total = 0.0
+        for p, t in zip(prediction, target):
+            total += (p - t) ** 2
+        return total / len(target)
+
+    def backward(self, prediction, target):
+        return [2 * (p - t) / len(target) for p, t in zip(prediction, target)]
+
+
+class CrossEntropyLoss(Loss):
+
+    def forward(self, prediction, target):
+        total = 0.0
+        for p, t in zip(prediction, target):
+            total -= t * math.log(max(p, 1e-08))
+        return total
+
+    def backward(self, prediction, target):
+        return [p - t for p, t in zip(prediction, target)]
+
+
+class MAELoss(Loss):
+
+    def forward(self, prediction, target):
+        total = 0.0
+        for p, t in zip(prediction, target):
+            total += abs(p - t)
+        return total / len(target)
+
+    def backward(self, prediction, target):
+        gradients = []
+        for p, t in zip(prediction, target):
+            if p > t:
+                gradients.append(1 / len(target))
+            elif p < t:
+                gradients.append(-1 / len(target))
+            else:
+                gradients.append(0)
+        return gradients
+
+
+class HuberLoss(Loss):
+
+    def __init__(self, delta=1.0):
+        self.delta = delta
+
+    def forward(self, prediction, target):
+        total = 0.0
+        for p, t in zip(prediction, target):
+            error = abs(p - t)
+            if error <= self.delta:
+                total += 0.5 * error**2
+            else:
+                total += self.delta * (error - 0.5 * self.delta)
+        return total / len(target)
+
+    def backward(self, prediction, target):
+        gradients = []
+        for p, t in zip(prediction, target):
+            error = p - t
+            if abs(error) <= self.delta:
+                gradients.append(error / len(target))
+            else:
+                gradients.append(self.delta * (1 if error > 0 else -1) / len(target))
+        return gradients
+
+
+class BinaryCrossEntropyLoss(Loss):
+
+    def forward(self, prediction, target):
+        total = 0.0
+        for p, t in zip(prediction, target):
+            p = max(min(p, 1 - 1e-08), 1e-08)
+            total += -t * math.log(p) - (1 - t) * math.log(1 - p)
+        return total / len(target)
+
+    def backward(self, prediction, target):
+        gradients = []
+        for p, t in zip(prediction, target):
+            p = max(min(p, 1 - 1e-08), 1e-08)
+            gradients.append((p - t) / (p * (1 - p) * len(target)))
+        return gradients

pynet_ai-1.3.1/pynet/metrics.py

@@ -0,0 +1,30 @@
+def accuracy(predictions, targets):
+    if len(targets) == 0:
+        raise ValueError("targets cannot be empty")
+    correct = 0
+    for prediction, target in zip(predictions, targets):
+        if isinstance(prediction, list):
+            prediction = prediction.index(max(prediction))
+        if isinstance(target, list):
+            target = target.index(max(target))
+        if prediction == target:
+            correct += 1
+    return correct / len(targets)
+
+
+def mean_squared_error(predictions, targets):
+    if len(targets) == 0:
+        raise ValueError("targets cannot be empty")
+    total = 0.0
+    for prediction, target in zip(predictions, targets):
+        total += (prediction - target) ** 2
+    return total / len(targets)
+
+
+def mean_absolute_error(predictions, targets):
+    if len(targets) == 0:
+        raise ValueError("targets cannot be empty")
+    total = 0.0
+    for prediction, target in zip(predictions, targets):
+        total += abs(prediction - target)
+    return total / len(targets)

pynet_ai-1.3.1/pynet/network.py

@@ -0,0 +1,66 @@
+class Network:
+
+    def __init__(self, *modules):
+        self.modules = list(modules)
+        self.training = True
+
+    def forward(self, x):
+        for module in self.modules:
+            x = module.forward(x)
+        return x
+
+    def backward(self, gradient):
+        for module in reversed(self.modules):
+            gradient = module.backward(gradient)
+        return gradient
+
+    def train(self, inputs, targets, loss, optimizer, epochs=1):
+        for _ in range(epochs):
+            for x, y in zip(inputs, targets):
+                prediction = self.forward(x)
+                gradient = loss.backward(prediction, y)
+                self.backward(gradient)
+                optimizer.step(self.modules)
+
+    def train_batch(self, inputs, targets, loss, optimizer):
+        self.zero_grad()
+        batch_size = len(inputs)
+        for x, y in zip(inputs, targets):
+            prediction = self.forward(x)
+            gradient = loss.backward(prediction, y)
+            self.backward(gradient)
+        for module in self.modules:
+            if hasattr(module, "weight_gradients"):
+                for neuron in range(len(module.weight_gradients)):
+                    module.bias_gradients[neuron] /= batch_size
+                    for previous in range(len(module.weight_gradients[neuron])):
+                        module.weight_gradients[neuron][previous] /= batch_size
+        optimizer.step(self.modules)
+
+    def zero_grad(self):
+        for module in self.modules:
+            if hasattr(module, "zero_grad"):
+                module.zero_grad()
+
+    def predict(self, x):
+        return self.forward(x)
+
+    def train_mode(self):
+        self.training = True
+
+    def eval_mode(self):
+        self.training = False
+
+    def get_config(self):
+        return {"modules": [{"type": module.__class__.__name__, "config": module.get_config(), "parameters": module.get_parameters()} for module in self.modules]}
+
+    def save(self, path):
+        from .serialization import save
+
+        save(self, path)
+
+    @staticmethod
+    def load(path):
+        from .serialization import load
+
+        return load(path)

pynet_ai-1.3.1/pynet/optimizer.py

@@ -0,0 +1,87 @@
+import math
+
+
+class Optimizer:
+
+    def step(self, modules):
+        raise NotImplementedError
+
+
+class SGD(Optimizer):
+
+    def __init__(self, learning_rate=0.01):
+        self.learning_rate = learning_rate
+
+    def step(self, modules):
+        for module in modules:
+            if hasattr(module, "weights"):
+                for neuron in range(len(module.weights)):
+                    for previous in range(len(module.weights[neuron])):
+                        module.weights[neuron][previous] -= self.learning_rate * module.weight_gradients[neuron][previous]
+            if hasattr(module, "biases"):
+                for neuron in range(len(module.biases)):
+                    module.biases[neuron] -= self.learning_rate * module.bias_gradients[neuron]
+            if hasattr(module, "zero_grad"):
+                module.zero_grad()
+
+
+class Momentum(Optimizer):
+
+    def __init__(self, learning_rate=0.01, momentum=0.9):
+        self.learning_rate = learning_rate
+        self.momentum = momentum
+        self.velocities = {}
+
+    def step(self, modules):
+        for module in modules:
+            if not hasattr(module, "weights"):
+                continue
+            module_id = id(module)
+            if module_id not in self.velocities:
+                self.velocities[module_id] = {"weights": [[0.0 for _ in row] for row in module.weights], "biases": [0.0 for _ in module.biases]}
+            velocity = self.velocities[module_id]
+            for neuron in range(len(module.weights)):
+                for previous in range(len(module.weights[neuron])):
+                    velocity["weights"][neuron][previous] = self.momentum * velocity["weights"][neuron][previous] + module.weight_gradients[neuron][previous]
+                    module.weights[neuron][previous] -= self.learning_rate * velocity["weights"][neuron][previous]
+            for neuron in range(len(module.biases)):
+                velocity["biases"][neuron] = self.momentum * velocity["biases"][neuron] + module.bias_gradients[neuron]
+                module.biases[neuron] -= self.learning_rate * velocity["biases"][neuron]
+            module.zero_grad()
+
+
+class Adam(Optimizer):
+
+    def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08):
+        self.learning_rate = learning_rate
+        self.beta1 = beta1
+        self.beta2 = beta2
+        self.epsilon = epsilon
+        self.steps = 0
+        self.moments = {}
+
+    def step(self, modules):
+        self.steps += 1
+        for module in modules:
+            if not hasattr(module, "weights"):
+                continue
+            module_id = id(module)
+            if module_id not in self.moments:
+                self.moments[module_id] = {"m_weights": [[0.0 for _ in row] for row in module.weights], "v_weights": [[0.0 for _ in row] for row in module.weights], "m_biases": [0.0 for _ in module.biases], "v_biases": [0.0 for _ in module.biases]}
+            state = self.moments[module_id]
+            for neuron in range(len(module.weights)):
+                for previous in range(len(module.weights[neuron])):
+                    gradient = module.weight_gradients[neuron][previous]
+                    state["m_weights"][neuron][previous] = self.beta1 * state["m_weights"][neuron][previous] + (1 - self.beta1) * gradient
+                    state["v_weights"][neuron][previous] = self.beta2 * state["v_weights"][neuron][previous] + (1 - self.beta2) * gradient**2
+                    m_hat = state["m_weights"][neuron][previous] / (1 - self.beta1**self.steps)
+                    v_hat = state["v_weights"][neuron][previous] / (1 - self.beta2**self.steps)
+                    module.weights[neuron][previous] -= self.learning_rate * m_hat / (math.sqrt(v_hat) + self.epsilon)
+            for neuron in range(len(module.biases)):
+                gradient = module.bias_gradients[neuron]
+                state["m_biases"][neuron] = self.beta1 * state["m_biases"][neuron] + (1 - self.beta1) * gradient
+                state["v_biases"][neuron] = self.beta2 * state["v_biases"][neuron] + (1 - self.beta2) * gradient**2
+                m_hat = state["m_biases"][neuron] / (1 - self.beta1**self.steps)
+                v_hat = state["v_biases"][neuron] / (1 - self.beta2**self.steps)
+                module.biases[neuron] -= self.learning_rate * m_hat / (math.sqrt(v_hat) + self.epsilon)
+            module.zero_grad()

pynet_ai-1.3.1/pynet/serialization.py

@@ -0,0 +1,20 @@
+import json
+
+
+def save(network, path):
+    data = {"modules": []}
+    for module in network.modules:
+        item = {"type": module.__class__.__name__, "config": {}, "parameters": {}}
+        if hasattr(module, "get_config"):
+            item["config"] = module.get_config()
+        if hasattr(module, "get_parameters"):
+            item["parameters"] = module.get_parameters()
+        data["modules"].append(item)
+    with open(path, "w") as file:
+        json.dump(data, file, indent=4)
+
+
+def load(path):
+    with open(path) as file:
+        data = json.load(file)
+    return data

pynet_ai-1.3.1/pynet_ai.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: pynet-ai
+Version: 1.3.1
+Summary: A Python neural network library for simple networks and educational use.
+Author-email: Andru Cupala <andru@cupala.com>
+License-Expression: LicenseRef-PolyForm-Noncommercial-1.0.0
+Keywords: neural-network,machine-learning,deep-learning,education,python
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# PyNet
+
+A simple educational neural network library built from scratch in Python.
+
+PyNet focuses on understanding how neural networks work internally, including layers, activations, loss functions, backpropagation, optimizers, weight initialization, and model serialization.
+
+## Features
+
+### Layers
+
+- Dense (fully connected) layers
+
+### Activations
+
+- ReLU
+- LeakyReLU
+- Sigmoid
+- Tanh
+- Softmax
+- ELU
+- Swish
+- GELU
+
+### Loss Functions
+
+- MSELoss
+- CrossEntropyLoss
+- MAELoss
+- HuberLoss
+- BinaryCrossEntropyLoss
+
+### Optimizers
+
+- SGD
+- Momentum
+- Adam
+
+### Weight Initialization
+
+- He
+- Xavier
+- RandomNormal
+- Zeros
+
+### Utilities
+
+- Metrics
+- Model saving/loading
+
+## Examples
+
+PyNet includes examples demonstrating:
+
+- Multiplication Prediction
+- Regression
+- XOR Classification
+
+## Installation
+
+Copy PyNet files into project directory. PyNet will be on PyPi soon.

pynet_ai-1.3.1/pynet_ai.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+pynet/__init__.py
+pynet/activation.py
+pynet/initialization.py
+pynet/layer.py
+pynet/loss.py
+pynet/metrics.py
+pynet/network.py
+pynet/optimizer.py
+pynet/serialization.py
+pynet_ai.egg-info/PKG-INFO
+pynet_ai.egg-info/SOURCES.txt
+pynet_ai.egg-info/dependency_links.txt
+pynet_ai.egg-info/top_level.txt
+tests/test.py

pynet_ai-1.3.1/pynet_ai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pynet_ai-1.3.1/pynet_ai.egg-info/top_level.txt

@@ -0,0 +1 @@
+pynet

pynet_ai-1.3.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# Required
+name = "pynet-ai"                # Must be unique on PyPI
+version = "1.3.1"
+description = "A Python neural network library for simple networks and educational use."
+readme = "README.md"
+requires-python = ">=3.10"
+
+# Licensing
+license = "LicenseRef-PolyForm-Noncommercial-1.0.0"
+license-files = ["LICENSE.md"]
+
+# Author information
+authors = [
+    { name = "Andru Cupala", email = "andru@cupala.com" }
+]
+
+# Keywords help with discoverability
+keywords = [
+    "neural-network",
+    "machine-learning",
+    "deep-learning",
+    "education",
+    "python",
+]
+
+# Runtime dependencies
+dependencies = []
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pynet*"]

pynet_ai-1.3.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pynet_ai-1.3.1/tests/test.py

@@ -0,0 +1,80 @@
+from pynet import Network, Dense, ReLU, LeakyReLU, Sigmoid, Tanh, ELU, Swish, GELU, Softmax, MSELoss, CrossEntropyLoss, MAELoss, HuberLoss, BinaryCrossEntropyLoss, SGD, Momentum, Adam, accuracy, mean_squared_error, mean_absolute_error
+from pynet.serialization import save, load
+
+
+def test_activations():
+    activations = [ReLU(), LeakyReLU(), Sigmoid(), Tanh(), ELU(), Swish(), GELU(), Softmax()]
+    values = [-2.0, -1.0, 0.0, 1.0, 2.0]
+    for activation in activations:
+        output = activation.forward(values)
+        gradient = activation.backward([1.0 for _ in output])
+        assert len(output) == len(values)
+        assert len(gradient) == len(values)
+        print(activation.__class__.__name__, "OK")
+
+
+def test_losses():
+    prediction = [0.2, 0.8]
+    target = [0, 1]
+    losses = [MSELoss(), CrossEntropyLoss(), MAELoss(), HuberLoss(), BinaryCrossEntropyLoss()]
+    for loss in losses:
+        value = loss.forward(prediction, target)
+        gradient = loss.backward(prediction, target)
+        assert isinstance(value, float)
+        assert len(gradient) == len(target)
+        print(loss.__class__.__name__, "OK")
+
+
+def create_network():
+    return Network(Dense(2, 8), ReLU(), Dense(8, 4), Tanh(), Dense(4, 1), Sigmoid())
+
+
+def test_training():
+    inputs = [[0, 0], [0, 1], [1, 0], [1, 1]]
+    targets = [[0], [1], [1], [0]]
+    optimizers = [SGD(0.1), Momentum(0.1), Adam(0.01)]
+    for optimizer in optimizers:
+        network = create_network()
+        network.train(inputs, targets, BinaryCrossEntropyLoss(), optimizer, epochs=100)
+        output = network.predict([0, 1])
+        assert len(output) == 1
+        print(optimizer.__class__.__name__, "OK")
+
+
+def test_metrics():
+    predictions = [[1, 0], [0, 1], [1, 0]]
+    targets = [[1, 0], [0, 1], [0, 1]]
+    acc = accuracy(predictions, targets)
+    assert 0 <= acc <= 1
+    mse = mean_squared_error([1, 2, 3], [1, 2, 4])
+    mae = mean_absolute_error([1, 2, 3], [1, 2, 4])
+    print("Accuracy:", acc)
+    print("MSE:", mse)
+    print("MAE:", mae)
+    print("Metrics OK")
+
+
+def test_saving():
+    network = create_network()
+    save(network, "test_model.json")
+    loaded = load("test_model.json")
+    assert loaded is not None
+    print("Saving/loading OK")
+
+
+def main():
+    print("\n--- Activations ---")
+    test_activations()
+    print("\n--- Losses ---")
+    test_losses()
+    print("\n--- Training ---")
+    test_training()
+    print("\n--- Metrics ---")
+    test_metrics()
+    print("\n--- Saving ---")
+    test_saving()
+    print("\nAll V1.1 tests passed")
+
+
+if __name__ == "__main__":
+    main()