neural-monkey 0.2.0__tar.gz

neural_monkey-0.2.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: neural-monkey
+Version: 0.2.0
+Summary: A neural network library for beginners.
+Home-page: https://github.com/19919rohit/Neural-Monkey
+Author: Neunix Studios
+Author-email: neunixstudios@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Monkey – Simple Neural Networks for Beginners
+
+Monkey is a lightweight Python library for building and training simple neural networks.  
+It is designed for beginners to learn concepts like layers, activations, forward propagation, backpropagation, and simple attention mechanisms in a fun and interactive way.
+
+---
+
+## Features
+
+- Create fully connected neural networks (Dense layers)  
+- Choose activation functions: **ReLU**, **Sigmoid**, **Tanh**  
+- Train networks using gradient descent with adjustable learning rate and epochs  
+- Make predictions on new inputs  
+- Optional lightweight **AttentionBlock** for sequence inputs  
+- Beginner-friendly API with minimal setup  
+- Fully Python-based, no external dependencies  
+
+---
+
+## Installation
+
+```bash
+pip install monkey
+```
+
+---
+
+## Quick Start Examples
+
+### 1. Predict the sum of two numbers
+
+```python
+from monkey.nn import NeuralNet
+
+# Training data
+x_train = [[2, 8], [9, 3], [7, 4], [1, 1]]
+y_train = [[sum(pair)] for pair in x_train]
+
+# Create network
+nn = NeuralNet(input_size=2)
+nn.add_layer(neurons=5, activation='relu')
+nn.add_layer(neurons=1, activation='relu', layer='output')
+
+# Train the network
+nn.train(x_train, y_train, epochs=500, lr=0.1)
+
+# Predict
+print("Prediction for [3,5]:", nn.predict([3,5])[0])
+```
+
+### 2. Predict using Sigmoid activation
+
+```python
+nn = NeuralNet(input_size=2)
+nn.add_layer(neurons=4, activation='sigmoid')
+nn.add_layer(neurons=1, activation='sigmoid', layer='output')
+
+nn.train(x_train, y_train, epochs=1000, lr=0.05)
+print("Prediction for [2,2]:", nn.predict([2,2])[0])
+```
+
+### 3. Using AttentionBlock for sequences
+
+```python
+from monkey.attention import AttentionBlock
+
+seq_input = [[0.8, 0.2, 0.1], [0.5, 0.1, 0.3], [0.2, 0.7, 0.6]]
+attn = AttentionBlock(input_size=3, output_size=3)
+seq_output = attn.forward(seq_input)
+
+print("Attention output:", seq_output)
+```
+
+---
+
+## API Reference
+
+| Class / Function      | Description                                                                 |
+|-----------------------|-----------------------------------------------------------------------------|
+| `NeuralNet`           | Core class for creating and training fully connected networks              |
+| `NeuralNet.add_layer` | Add a layer to the network; choose neurons, activation, layer type          |
+| `NeuralNet.predict`   | Make predictions for a given input                                         |
+| `NeuralNet.train`     | Train the network on input/output data                                      |
+| `AttentionBlock`      | Simple attention mechanism for sequences                                    |
+| `relu(x)`             | Rectified Linear Unit activation function                                    |
+| `sigmoid(x)`          | Sigmoid activation function                                                 |
+| `tanh(x)`             | Tanh activation function                                                    |
+
+**Layer Parameters in `add_layer`:**
+
+- `neurons`: Number of neurons in the layer  
+- `activation`: One of `'relu'`, `'sigmoid'`, `'tanh'`  
+- `layer`: `'hidden'` (default) or `'output'`  
+- `input_size`: Optional, only needed for first layer  
+
+---
+
+## Testing Monkey
+
+You can run the provided test script:
+
+```bash
+python tests/test.py
+```
+
+Sample test scenarios include:
+
+- Predicting sums of two numbers  
+- Predicting multiplication or XOR patterns  
+- Testing different activation functions  
+- Testing AttentionBlock on sequence data  
+
+---
+
+## Learning Tips for Beginners
+
+- Start with a single hidden layer and few neurons  
+- Use small datasets (like sum of two numbers) for testing  
+- Adjust `learning_rate` and `epochs` to see effect on convergence  
+- Observe how activation functions change the output and training speed  
+- Experiment with the AttentionBlock for sequence-based learning  
+
+---
+
+## Contributing
+
+Monkey is beginner-friendly and open to contributions!  
+
+- Experiment with new activation functions  
+- Add utilities or visualization helpers  
+- Improve training efficiency  
+
+Github Repo available at : https://github.com/19919rohit/Neural-Monkey
+
+---
+
+## License
+
+MIT License

neural_monkey-0.2.0/README.md

@@ -0,0 +1,139 @@
+# Monkey – Simple Neural Networks for Beginners
+
+Monkey is a lightweight Python library for building and training simple neural networks.  
+It is designed for beginners to learn concepts like layers, activations, forward propagation, backpropagation, and simple attention mechanisms in a fun and interactive way.
+
+---
+
+## Features
+
+- Create fully connected neural networks (Dense layers)  
+- Choose activation functions: **ReLU**, **Sigmoid**, **Tanh**  
+- Train networks using gradient descent with adjustable learning rate and epochs  
+- Make predictions on new inputs  
+- Optional lightweight **AttentionBlock** for sequence inputs  
+- Beginner-friendly API with minimal setup  
+- Fully Python-based, no external dependencies  
+
+---
+
+## Installation
+
+```bash
+pip install monkey
+```
+
+---
+
+## Quick Start Examples
+
+### 1. Predict the sum of two numbers
+
+```python
+from monkey.nn import NeuralNet
+
+# Training data
+x_train = [[2, 8], [9, 3], [7, 4], [1, 1]]
+y_train = [[sum(pair)] for pair in x_train]
+
+# Create network
+nn = NeuralNet(input_size=2)
+nn.add_layer(neurons=5, activation='relu')
+nn.add_layer(neurons=1, activation='relu', layer='output')
+
+# Train the network
+nn.train(x_train, y_train, epochs=500, lr=0.1)
+
+# Predict
+print("Prediction for [3,5]:", nn.predict([3,5])[0])
+```
+
+### 2. Predict using Sigmoid activation
+
+```python
+nn = NeuralNet(input_size=2)
+nn.add_layer(neurons=4, activation='sigmoid')
+nn.add_layer(neurons=1, activation='sigmoid', layer='output')
+
+nn.train(x_train, y_train, epochs=1000, lr=0.05)
+print("Prediction for [2,2]:", nn.predict([2,2])[0])
+```
+
+### 3. Using AttentionBlock for sequences
+
+```python
+from monkey.attention import AttentionBlock
+
+seq_input = [[0.8, 0.2, 0.1], [0.5, 0.1, 0.3], [0.2, 0.7, 0.6]]
+attn = AttentionBlock(input_size=3, output_size=3)
+seq_output = attn.forward(seq_input)
+
+print("Attention output:", seq_output)
+```
+
+---
+
+## API Reference
+
+| Class / Function      | Description                                                                 |
+|-----------------------|-----------------------------------------------------------------------------|
+| `NeuralNet`           | Core class for creating and training fully connected networks              |
+| `NeuralNet.add_layer` | Add a layer to the network; choose neurons, activation, layer type          |
+| `NeuralNet.predict`   | Make predictions for a given input                                         |
+| `NeuralNet.train`     | Train the network on input/output data                                      |
+| `AttentionBlock`      | Simple attention mechanism for sequences                                    |
+| `relu(x)`             | Rectified Linear Unit activation function                                    |
+| `sigmoid(x)`          | Sigmoid activation function                                                 |
+| `tanh(x)`             | Tanh activation function                                                    |
+
+**Layer Parameters in `add_layer`:**
+
+- `neurons`: Number of neurons in the layer  
+- `activation`: One of `'relu'`, `'sigmoid'`, `'tanh'`  
+- `layer`: `'hidden'` (default) or `'output'`  
+- `input_size`: Optional, only needed for first layer  
+
+---
+
+## Testing Monkey
+
+You can run the provided test script:
+
+```bash
+python tests/test.py
+```
+
+Sample test scenarios include:
+
+- Predicting sums of two numbers  
+- Predicting multiplication or XOR patterns  
+- Testing different activation functions  
+- Testing AttentionBlock on sequence data  
+
+---
+
+## Learning Tips for Beginners
+
+- Start with a single hidden layer and few neurons  
+- Use small datasets (like sum of two numbers) for testing  
+- Adjust `learning_rate` and `epochs` to see effect on convergence  
+- Observe how activation functions change the output and training speed  
+- Experiment with the AttentionBlock for sequence-based learning  
+
+---
+
+## Contributing
+
+Monkey is beginner-friendly and open to contributions!  
+
+- Experiment with new activation functions  
+- Add utilities or visualization helpers  
+- Improve training efficiency  
+
+Github Repo available at : https://github.com/19919rohit/Neural-Monkey
+
+---
+
+## License
+
+MIT License

neural_monkey-0.2.0/monkey/__init__.py

@@ -0,0 +1,49 @@
+# monkey/__init__.py
+
+"""
+Monkey Library
+--------------
+A simple neural network library with dense layers, activations, and attention blocks.
+
+Author: NEUNIX STUDIOS
+"""
+
+# Core Neural Network
+from .nn import NeuralNet, Dense
+
+# Activations
+from .activations import (
+    activation_map,
+    relu,
+    relu_derivative,
+    sigmoid,
+    sigmoid_derivative,
+    tanh,
+    tanh_derivative,
+    linear,
+    linear_derivative
+)
+
+# Attention
+from .attention import AttentionBlock
+
+# Public API
+__all__ = [
+    # Neural network components
+    "NeuralNet",
+    "Dense",
+
+    # Activations
+    "activation_map",
+    "relu",
+    "relu_derivative",
+    "sigmoid",
+    "sigmoid_derivative",
+    "tanh",
+    "tanh_derivative",
+    "linear",
+    "linear_derivative",
+
+    # Attention
+    "AttentionBlock"
+]

neural_monkey-0.2.0/monkey/activations.py

@@ -0,0 +1,38 @@
+import math
+
+# Sigmoid activation and derivative
+def sigmoid(x):
+    return 1 / (1 + math.exp(-x))
+
+def sigmoid_derivative(x):
+    s = sigmoid(x)
+    return s * (1 - s)
+
+# ReLU activation and derivative
+def relu(x):
+    return max(0, x)
+
+def relu_derivative(x):
+    return 1 if x > 0 else 0
+
+# Tanh activation and derivative
+def tanh(x):
+    return math.tanh(x)
+
+def tanh_derivative(x):
+    return 1 - math.tanh(x)**2
+
+# Linear activation and derivative
+def linear(x):
+    return x
+
+def linear_derivative(x):
+    return 1
+
+# Mapping of activation names to their functions and derivatives
+activation_map = {
+    'relu': (relu, relu_derivative),
+    'sigmoid': (sigmoid, sigmoid_derivative),
+    'tanh': (tanh, tanh_derivative),
+    'linear': (linear, linear_derivative)
+}

neural_monkey-0.2.0/monkey/attention.py

@@ -0,0 +1,43 @@
+import random
+
+class AttentionBlock:
+    """
+    Simplified attention block for sequence inputs.
+    - Transforms a sequence of vectors using query, key, value matrices
+    - Produces an output sequence where each vector attends to the others
+    """
+
+    class Layer:
+        def __init__(self, input_size, output_size):
+            self.weights = [[random.uniform(-0.5, 0.5) for _ in range(output_size)] for _ in range(input_size)]
+            self.biases = [0] * output_size
+
+        def forward(self, x):
+            return [sum(x[i] * self.weights[i][j] for i in range(len(x))) + self.biases[j]
+                    for j in range(len(self.weights[0]))]
+
+    def __init__(self, input_size, output_size):
+        self.Wq = self.Layer(input_size, output_size)
+        self.Wk = self.Layer(input_size, output_size)
+        self.Wv = self.Layer(input_size, output_size)
+
+    def forward(self, X):
+        Q = [self.Wq.forward(x) for x in X]
+        K = [self.Wk.forward(x) for x in X]
+        V = [self.Wv.forward(x) for x in X]
+
+        # Compute attention scores
+        attn_scores = [[sum(qi * kj for qi, kj in zip(q, k)) for k in K] for q in Q]
+
+        # Normalize scores to get attention weights
+        attn_weights = [[s / sum(row) if sum(row) != 0 else 1 / len(row) for s in row] for row in attn_scores]
+
+        # Compute weighted output
+        output = []
+        for w_row in attn_weights:
+            out_vec = [0] * len(V[0])
+            for i, w in enumerate(w_row):
+                for j, v_val in enumerate(V[i]):
+                    out_vec[j] += w * v_val
+            output.append(out_vec)
+        return output

neural_monkey-0.2.0/monkey/nn.py

@@ -0,0 +1,120 @@
+import random
+from .activations import activation_map
+
+# --- Dense layer ---
+class Dense:
+    def __init__(self, input_size, output_size, activation, activation_deriv):
+        # Initialize weights randomly and biases to zero
+        self.weights = [[random.uniform(-0.5, 0.5) for _ in range(output_size)] for _ in range(input_size)]
+        self.biases = [0] * output_size
+        self.activation = activation
+        self.activation_deriv = activation_deriv
+        self.last_input = None
+        self.last_output = None
+        self.is_output = False
+
+    def forward(self, x):
+        self.last_input = x
+        # Linear combination + bias
+        z = [sum(x[i] * self.weights[i][j] for i in range(len(x))) + self.biases[j]
+             for j in range(len(self.weights[0]))]
+        # Activation
+        self.last_output = [self.activation(v) for v in z]
+        return self.last_output
+
+    def backward(self, grad_output, lr):
+        grad_input = [0] * len(self.last_input)
+        for i in range(len(self.last_input)):
+            for j in range(len(self.weights[0])):
+                grad = grad_output[j] * self.activation_deriv(self.last_output[j])
+                grad_input[i] += grad * self.weights[i][j]
+                # Update weights and biases
+                self.weights[i][j] -= lr * grad * self.last_input[i]
+                self.biases[j] -= lr * grad
+        return grad_input
+
+
+# --- Neural Network ---
+class NeuralNet:
+    def __init__(self, input_size=None, lr=0.1):
+        self.layers = []
+        self.input_size = input_size
+        self.learning_rate = lr
+
+    def add_layer(self, neurons, activation='relu', layer='hidden', input_size=None):
+        """
+        Add a layer to the network.
+        - neurons: number of neurons in the layer
+        - activation: activation function name
+        - layer: 'hidden' or 'output'
+        """
+        # Determine input size
+        if not self.layers:
+            input_size = input_size or self.input_size
+            if input_size is None:
+                raise ValueError("Input size must be specified")
+        else:
+            input_size = len(self.layers[-1].biases)
+
+        # Fetch activation functions
+        act, act_deriv = activation_map.get(activation, (lambda x: x, lambda x: 1))
+
+        # Create layer
+        new_layer = Dense(input_size, neurons, act, act_deriv)
+
+        # Handle output layer replacement
+        if layer.lower() == 'output':
+            if self.layers and getattr(self.layers[-1], 'is_output', False):
+                self.layers[-1].is_output = False
+            new_layer.is_output = True
+        else:
+            new_layer.is_output = False
+
+        self.layers.append(new_layer)
+
+    def predict(self, x):
+        for layer in self.layers:
+            x = layer.forward(x)
+        return x
+
+    def train(self, x_train, y_train=None, epochs=1000, shuffle=True, verbose=100, lr=None, next_step=False):
+        """
+        Flexible training:
+        - Supports supervised learning if y_train is provided.
+        - Supports self-supervised / reconstruction if y_train is None.
+        - Supports next-step prediction for sequences if next_step=True.
+        """
+        learning_rate = lr if lr is not None else self.learning_rate
+
+        for epoch in range(epochs):
+            total_loss = 0
+            data = x_train
+            targets = y_train
+
+            # For sequence next-step learning
+            if next_step:
+                data = [x_train[i:i+2] for i in range(len(x_train)-2)]
+                targets = [x_train[i+2] for i in range(len(x_train)-2)]
+
+            # If no targets, use self-supervised (auto-reconstruction)
+            combined = list(zip(data, targets)) if targets is not None else [(x, x) for x in data]
+            if shuffle:
+                random.shuffle(combined)
+
+            for x, y in combined:
+                # Ensure x and y are lists
+                x_list = x if isinstance(x, list) else [x]
+                y_list = y if isinstance(y, list) else [y]
+
+                output = self.predict(x_list)
+
+                # Compute gradient
+                grad = [2*(o-t) for o, t in zip(output, y_list)]
+                total_loss += sum((o-t)**2 for o, t in zip(output, y_list))
+
+                # Backpropagate through layers
+                for layer in reversed(self.layers):
+                    grad = layer.backward(grad, learning_rate)
+
+            if verbose and epoch % verbose == 0:
+                print(f"Epoch {epoch}, Loss: {total_loss:.6f}")

neural_monkey-0.2.0/neural_monkey.egg-info/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: neural-monkey
+Version: 0.2.0
+Summary: A neural network library for beginners.
+Home-page: https://github.com/19919rohit/Neural-Monkey
+Author: Neunix Studios
+Author-email: neunixstudios@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Monkey – Simple Neural Networks for Beginners
+
+Monkey is a lightweight Python library for building and training simple neural networks.  
+It is designed for beginners to learn concepts like layers, activations, forward propagation, backpropagation, and simple attention mechanisms in a fun and interactive way.
+
+---
+
+## Features
+
+- Create fully connected neural networks (Dense layers)  
+- Choose activation functions: **ReLU**, **Sigmoid**, **Tanh**  
+- Train networks using gradient descent with adjustable learning rate and epochs  
+- Make predictions on new inputs  
+- Optional lightweight **AttentionBlock** for sequence inputs  
+- Beginner-friendly API with minimal setup  
+- Fully Python-based, no external dependencies  
+
+---
+
+## Installation
+
+```bash
+pip install monkey
+```
+
+---
+
+## Quick Start Examples
+
+### 1. Predict the sum of two numbers
+
+```python
+from monkey.nn import NeuralNet
+
+# Training data
+x_train = [[2, 8], [9, 3], [7, 4], [1, 1]]
+y_train = [[sum(pair)] for pair in x_train]
+
+# Create network
+nn = NeuralNet(input_size=2)
+nn.add_layer(neurons=5, activation='relu')
+nn.add_layer(neurons=1, activation='relu', layer='output')
+
+# Train the network
+nn.train(x_train, y_train, epochs=500, lr=0.1)
+
+# Predict
+print("Prediction for [3,5]:", nn.predict([3,5])[0])
+```
+
+### 2. Predict using Sigmoid activation
+
+```python
+nn = NeuralNet(input_size=2)
+nn.add_layer(neurons=4, activation='sigmoid')
+nn.add_layer(neurons=1, activation='sigmoid', layer='output')
+
+nn.train(x_train, y_train, epochs=1000, lr=0.05)
+print("Prediction for [2,2]:", nn.predict([2,2])[0])
+```
+
+### 3. Using AttentionBlock for sequences
+
+```python
+from monkey.attention import AttentionBlock
+
+seq_input = [[0.8, 0.2, 0.1], [0.5, 0.1, 0.3], [0.2, 0.7, 0.6]]
+attn = AttentionBlock(input_size=3, output_size=3)
+seq_output = attn.forward(seq_input)
+
+print("Attention output:", seq_output)
+```
+
+---
+
+## API Reference
+
+| Class / Function      | Description                                                                 |
+|-----------------------|-----------------------------------------------------------------------------|
+| `NeuralNet`           | Core class for creating and training fully connected networks              |
+| `NeuralNet.add_layer` | Add a layer to the network; choose neurons, activation, layer type          |
+| `NeuralNet.predict`   | Make predictions for a given input                                         |
+| `NeuralNet.train`     | Train the network on input/output data                                      |
+| `AttentionBlock`      | Simple attention mechanism for sequences                                    |
+| `relu(x)`             | Rectified Linear Unit activation function                                    |
+| `sigmoid(x)`          | Sigmoid activation function                                                 |
+| `tanh(x)`             | Tanh activation function                                                    |
+
+**Layer Parameters in `add_layer`:**
+
+- `neurons`: Number of neurons in the layer  
+- `activation`: One of `'relu'`, `'sigmoid'`, `'tanh'`  
+- `layer`: `'hidden'` (default) or `'output'`  
+- `input_size`: Optional, only needed for first layer  
+
+---
+
+## Testing Monkey
+
+You can run the provided test script:
+
+```bash
+python tests/test.py
+```
+
+Sample test scenarios include:
+
+- Predicting sums of two numbers  
+- Predicting multiplication or XOR patterns  
+- Testing different activation functions  
+- Testing AttentionBlock on sequence data  
+
+---
+
+## Learning Tips for Beginners
+
+- Start with a single hidden layer and few neurons  
+- Use small datasets (like sum of two numbers) for testing  
+- Adjust `learning_rate` and `epochs` to see effect on convergence  
+- Observe how activation functions change the output and training speed  
+- Experiment with the AttentionBlock for sequence-based learning  
+
+---
+
+## Contributing
+
+Monkey is beginner-friendly and open to contributions!  
+
+- Experiment with new activation functions  
+- Add utilities or visualization helpers  
+- Improve training efficiency  
+
+Github Repo available at : https://github.com/19919rohit/Neural-Monkey
+
+---
+
+## License
+
+MIT License

neural_monkey-0.2.0/neural_monkey.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+setup.cfg
+monkey/__init__.py
+monkey/activations.py
+monkey/attention.py
+monkey/nn.py
+neural_monkey.egg-info/PKG-INFO
+neural_monkey.egg-info/SOURCES.txt
+neural_monkey.egg-info/dependency_links.txt
+neural_monkey.egg-info/top_level.txt
+tests/test.py

neural_monkey-0.2.0/neural_monkey.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

neural_monkey-0.2.0/neural_monkey.egg-info/top_level.txt

@@ -0,0 +1 @@
+monkey

neural_monkey-0.2.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

neural_monkey-0.2.0/setup.cfg

@@ -0,0 +1,24 @@
+[metadata]
+name = neural-monkey
+version = 0.2.0
+author = Neunix Studios
+author_email = neunixstudios@gmail.com
+description = A neural network library for beginners.
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/19919rohit/Neural-Monkey
+classifiers = 
+	Programming Language :: Python :: 3
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+
+[options]
+packages = find:
+python_requires = >=3.7
+
+[options.packages.find]
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

neural_monkey-0.2.0/tests/test.py

@@ -0,0 +1,22 @@
+from monkey.nn import NeuralNet
+
+# Training data: simple sums
+x_train = [[0, 0], [0, 1], [1, 0], [1, 1], [2, 3], [3, 4], [5, 2], [6, 1]]
+y_train = [[sum(pair)] for pair in x_train]
+
+# Create the neural network
+nn = NeuralNet(input_size=2)
+
+# Add one hidden layer with 5 neurons, ReLU activation
+nn.add_layer(neurons=5, activation='relu')
+
+# Output layer with 1 neuron (the sum), ReLU works fine here
+nn.add_layer(neurons=1, activation='relu', layer='output')
+
+# Train the network
+nn.train(x_train, y_train, epochs=1000, lr=0.01)
+
+# Test predictions
+test_cases = [[1, 2], [3, 5], [4, 4], [6, 7]]
+for case in test_cases:
+    print(f"Prediction for {case}: {nn.predict(case)[0]}")