neuralplex 0.0.2__tar.gz → 0.0.4__tar.gz

{neuralplex-0.0.2 → neuralplex-0.0.4}/.gitignore

@@ -159,4 +159,5 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 
-*.ipynb
+*.ipynb
+*.pkl

{neuralplex-0.0.2 → neuralplex-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: neuralplex
-Version: 0.0.2
+Version: 0.0.4
 Summary: A Neuralplex.
 Project-URL: Homepage, https://github.com/faranalytics/neuralplex
 Project-URL: Issues, https://github.com/faranalytics/neuralplex/issues
@@ -14,4 +14,25 @@ Description-Content-Type: text/markdown
 
 # Neural-pleX
 
-An object oriented neural network implementation.
+An object oriented neural network implementation.
+
+## Installation
+```bash
+pip install neuralplex
+```
+## Run the Test
+
+Install the package using the [Installation](#installation) instructions.
+
+### Clone the repository.
+```bash
+git clone https://github.com/faranalytics/neuralplex.git
+```
+### Change directory into the repository.
+```bash
+cd neuralplex
+```
+### Run the tests.
+```bash
+python -m unittest -v
+```

neuralplex-0.0.4/README.md

@@ -0,0 +1,24 @@
+# Neural-pleX
+
+An object oriented neural network implementation.
+
+## Installation
+```bash
+pip install neuralplex
+```
+## Run the Test
+
+Install the package using the [Installation](#installation) instructions.
+
+### Clone the repository.
+```bash
+git clone https://github.com/faranalytics/neuralplex.git
+```
+### Change directory into the repository.
+```bash
+cd neuralplex
+```
+### Run the tests.
+```bash
+python -m unittest -v
+```

{neuralplex-0.0.2 → neuralplex-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "neuralplex"
-version = "0.0.2"
+version = "0.0.4"
 authors = [
   { name="FAR Analytics & Research", email="adam@farar.net" },
 ]

{neuralplex-0.0.2 → neuralplex-0.0.4}/src/neuralplex/layer.py

@@ -5,16 +5,16 @@ from neuralplex.perceptron import Perceptron
 
 class Layer:
 
-    def __init__(self, perceptrons: List[Perceptron], deg: float = None):
+    def __init__(self, perceptrons: List[Perceptron], step: float = None):
         self.perceptrons = perceptrons
-        self.deg = deg
+        self.step = step
 
-        if not self.deg is None:
+        if not self.step is None:
             for perceptron in self.perceptrons:
-                if perceptron.deg is None:
-                    perceptron.deg = self.deg
+                if perceptron.step is None:
+                    perceptron.step = self.step
 
-    def connect(self, layer: Self):
+    def connect(self, layer: Self) -> None:
         for p1 in self.perceptrons:
             for p2 in layer.perceptrons:
                 p1.connectRHS(p2)

neuralplex-0.0.4/src/neuralplex/network.py

@@ -0,0 +1,46 @@
+from typing import List
+from neuralplex import Layer
+
+
+class Network:
+
+    def __init__(self, layers: List[Layer]):
+        self.layers = layers
+        self.input_layer = layers[0]
+        self.output_layer = layers[len(layers) - 1]
+
+        for i in range(0, len(layers) - 1):
+            l1 = layers[i]
+            l2 = layers[i + 1]
+            l1.connect(l2)
+
+    def train(self, X_train: List[float], y_train: List[float]) -> None:
+        if len(self.input_layer.perceptrons) != len(X_train):
+            raise Exception(
+                f"The length of the training values, {len(X_train)}, is not equal to the length of input perceptrons: {len(self.input_layer.perceptrons)}"
+            )
+
+        if len(self.output_layer.perceptrons) != len(y_train):
+            raise Exception(
+                f"The length of the training values, {len(y_train)}, is not equal to the length of output perceptrons: {len(self.output_layer.perceptrons)}"
+            )
+
+        for i in range(0, len(X_train)):
+            self.input_layer.perceptrons[i].activate(X_train[i])
+
+        for i in range(0, len(y_train)):
+            y_train = y_train[i]
+            perceptron = self.output_layer.perceptrons[i]
+            perceptron.propagate(perceptron.value - y_train, None)
+
+    def predict(self, inputs: List[float]) -> List[float]:
+
+        if len(self.input_layer.perceptrons) != len(inputs):
+            raise Exception(
+                f"The length of the training values, {len(inputs)}, is not equal to the length of input perceptrons: {len(self.input.perceptrons)}"
+            )
+
+        for i in range(0, len(inputs)):
+            self.input_layer.perceptrons[i].activate(inputs[i])
+
+        return [perceptron.value for perceptron in self.output_layer.perceptrons]

neuralplex-0.0.4/src/neuralplex/perceptron.py

@@ -0,0 +1,93 @@
+import math
+import statistics
+from typing import Dict, List, Self
+from scipy.stats import linregress
+
+
+class Perceptron:
+
+    def __init__(self, m: float, b: float = 0, step: float = None, name=None):
+
+        self.m = m
+        self.b = b
+        self.name = name
+        self.step = step
+
+        self.value = 0
+        self.activation_count = 0
+
+        self.perceptronsRHS: List[Self] = []
+        self.perceptronsLHS: List[Self] = []
+
+        self.activation: Dict[Self, float] = {}
+        self.propagation: Dict[Self, float] = {}
+
+    def connectRHS(self, perceptronRHS: Self) -> None:
+        if perceptronRHS not in self.perceptronsRHS:
+            self.perceptronsRHS.append(perceptronRHS)
+
+        if self not in perceptronRHS.perceptronsLHS:
+            perceptronRHS.connectLHS(self)
+
+    def connectLHS(self, perceptronLHS: Self) -> None:
+        if perceptronLHS not in self.perceptronsLHS:
+            self.perceptronsLHS.append(perceptronLHS)
+
+        if self not in perceptronLHS.perceptronsRHS:
+            perceptronLHS.connectRHS(self)
+
+    def disconnectRHS(self, perceptronRHS: Self) -> None:
+        if perceptronRHS in self.perceptronsRHS:
+            self.perceptronsRHS.remove(perceptronRHS)
+
+        if self in perceptronRHS.perceptronsLHS:
+            perceptronRHS.disconnectLHS(self)
+
+        if len(self.perceptronsRHS) == 0:
+            for perceptron in self.perceptronsLHS:
+                perceptron.disconnectRHS(self)
+
+    def disconnectLHS(self, perceptronLHS: Self) -> None:
+        if perceptronLHS in self.perceptronsLHS:
+            self.perceptronsLHS.remove(perceptronLHS)
+
+        if self in perceptronLHS.perceptronsRHS:
+            perceptronLHS.disconnectRHS(self)
+
+        if len(self.perceptronsLHS) == 0:
+            for perceptron in self.perceptronsRHS:
+                perceptron.disconnectLHS(self)
+
+    def activate(self, t: float, p: Self = None) -> None:
+
+        if self.activation_count == 0:
+            self.activation = {}
+
+        self.activation.update({p: self.m * t})
+        self.activation_count = self.activation_count + 1
+
+        if len(self.perceptronsLHS) == 0 or self.activation_count == len(self.perceptronsLHS):
+            self.value = sum(self.activation.values())
+            for perceptron in self.perceptronsRHS:
+                perceptron.activate(self.value, self)
+            self.activation_count = 0
+
+    def propagate(self, error: float, p: Self = None) -> None:
+
+        self.propagation.update({p: error})
+
+        if len(self.perceptronsRHS) == 0 or len(self.propagation) == len(self.perceptronsRHS):
+
+            error_total = sum(self.propagation.values())
+            for error in self.propagation.values():
+                self.m = self.m - (error * self.step)
+
+            for p in self.perceptronsLHS:
+                p_activation_value = self.activation[p]
+
+                if p_activation_value > 0 and error_total > 0 or p_activation_value < 0 and error_total < 0:
+                    p.propagate(error_total, self)
+                else:
+                    p.propagate(math.copysign(1, error_total), self)
+
+            self.propagation = {}

neuralplex-0.0.4/tests/test.py

@@ -0,0 +1,65 @@
+import unittest
+import json
+from random import random, randint
+from sklearn.metrics import r2_score
+from neuralplex import Network, Layer, Perceptron
+
+class Test(unittest.TestCase):
+
+    def test_nibbles(self):
+
+        ITERATION = int(1e5 / 2)
+        STEP = 1e-4
+
+        l1 = Layer(perceptrons=[Perceptron(m=random()) for i in range(0, 4)], step=STEP)
+
+        l2 = Layer(perceptrons=[Perceptron(m=random()) for i in range(0, 8)], step=STEP)
+
+        l3 = Layer(perceptrons=[Perceptron(m=random(), name="out-0")], step=STEP)
+
+        n1 = Network(
+            [
+                l1,
+                l2,
+                l3,
+            ]
+        )
+
+        print("Training the model.")
+        for i in range(0, ITERATION):
+
+            if i % 100000 == 0:
+                print(f"Training iteration: {i}")
+
+            rn = randint(1, 15)
+
+            b = [int(n) for n in bin(rn)[2:]]
+
+            while len(b) < 4:
+                b = [0] + b
+
+            n1.train(b, [rn])
+
+
+        ys = []
+        ys_p = []
+        for i in range(1, 16):
+
+            b = [int(n) for n in bin(i)[2:]]
+
+            while len(b) < 4:
+                b = [0] + b
+
+            pn = n1.predict(b)
+
+            ys.append(i)
+            ys_p.append(pn[0])
+
+            print(f"{i} input: {json.dumps(b)}, truth: {i} prediction: {json.dumps(pn)}")
+
+        R2 = r2_score(ys, ys_p)
+
+        print(f"R2: {R2}")
+
+if __name__ == '__main__':
+    unittest.main()

neuralplex-0.0.2/README.md

@@ -1,3 +0,0 @@
-# Neural-pleX
-
-An object oriented neural network implementation.

neuralplex-0.0.2/src/neuralplex/network.py

@@ -1,43 +0,0 @@
-from typing import List
-from neuralplex import Layer
-
-
-class Network:
-
-    def __init__(self, layers: List[Layer]):
-        self.layers = layers
-        self.input = layers[0]
-        self.output = layers[len(layers) - 1]
-
-        for i in range(0, len(layers) - 1):
-            l1 = layers[i]
-            l2 = layers[i + 1]
-            l1.connect(l2)
-
-    def train(self, inputs: List[float], outputs: List[float]):
-        if len(self.input.perceptrons) != len(inputs):
-            raise Exception(
-                f'The length of the training values, {len(inputs)}, is not equal to the length of input perceptrons: {len(self.input.perceptrons)}')
-
-        if len(self.output.perceptrons) != len(outputs):
-            raise Exception(
-                f'The length of the training values, {len(outputs)}, is not equal to the length of output perceptrons: {len(self.output.perceptrons)}')
-
-        for i in range(0, len(inputs)):
-            self.input.perceptrons[i].activate(inputs[i])
-
-        for i in range(0, len(outputs)):
-            o = outputs[i]
-            p = self.output.perceptrons[i]
-            p.propagate(p.q-o)
-
-    def predict(self, inputs: List[float]):
-
-        if len(self.input.perceptrons) != len(inputs):
-            raise Exception(
-                f'The length of the training values, {len(inputs)}, is not equal to the length of input perceptrons: {len(self.input.perceptrons)}')
-
-        for i in range(0, len(inputs)):
-            self.input.perceptrons[i].activate(inputs[i])
-
-        return [perceptron.q for perceptron in self.output.perceptrons]

neuralplex-0.0.2/src/neuralplex/perceptron.py

@@ -1,77 +0,0 @@
-from typing import Dict, List, Self
-
-
-class Perceptron:
-
-    def __init__(self, coef: float, deg: float = None, name=None):
-        self.coef = coef
-        self.deg = deg
-        self.name = name
-        self.perceptronsRHS: List[Self] = []
-        self.perceptronsLHS: List[Self] = []
-        self.activations: List[float] = []
-        self.propagation: Dict[float] = {}
-        self.q = 0
-
-    def connectRHS(self, perceptronRHS: Self):
-        if perceptronRHS not in self.perceptronsRHS:
-            self.perceptronsRHS.append(perceptronRHS)
-
-        if self not in perceptronRHS.perceptronsLHS:
-            perceptronRHS.connectLHS(self)
-
-    def connectLHS(self, perceptronLHS: Self):
-        if perceptronLHS not in self.perceptronsLHS:
-            self.perceptronsLHS.append(perceptronLHS)
-
-        if self not in perceptronLHS.perceptronsRHS:
-            perceptronLHS.connectRHS(self)
-
-    def disconnectRHS(self, perceptronRHS: Self):
-        if perceptronRHS in self.perceptronsRHS:
-            self.perceptronsRHS.remove(perceptronRHS)
-
-        if self in perceptronRHS.perceptronsLHS:
-            perceptronRHS.disconnectLHS(self)
-
-        if len(self.perceptronsRHS) == 0:
-            for perceptron in self.perceptronsLHS:
-                perceptron.disconnectRHS(self)
-
-    def disconnectLHS(self, perceptronLHS: Self):
-        if perceptronLHS in self.perceptronsLHS:
-            self.perceptronsLHS.remove(perceptronLHS)
-
-        if self in perceptronLHS.perceptronsRHS:
-            perceptronLHS.disconnectRHS(self)
-
-        if len(self.perceptronsLHS) == 0:
-            for perceptron in self.perceptronsRHS:
-                perceptron.disconnectLHS(self)
-
-    def activate(self, t: float):
-        self.activations.append(self.coef * t**self.deg)
-        # print(self.name, len(self.activations))
-        if len(self.perceptronsLHS) == 0 or len(self.activations) == len(self.perceptronsLHS):
-            self.q = sum(self.activations)
-            for perceptron in self.perceptronsRHS:
-                perceptron.activate(self.q)
-            self.activations = []
-
-    def propagate(self, t: float, p: Self = None):
-        self.propagation.update({p: t})
-        if len(self.perceptronsRHS) == 0 or len(self.propagation) == len(self.perceptronsRHS):
-            if len(self.perceptronsRHS) > 5:
-                perceptronRHS_max: Perceptron = max(
-                    self.propagation, key=lambda x: abs(self.propagation.get(x)))
-                self.disconnectRHS(perceptronRHS_max)
-                print(self.name, self.propagation[perceptronRHS_max], len(
-                    self.perceptronsRHS))
-            d = sum(self.propagation.values())
-            if d > 0:
-                self.coef = self.coef - 1e-4
-            else:
-                self.coef = self.coef + 1e-4
-            for perceptron in self.perceptronsLHS:
-                perceptron.propagate(d, self)
-            self.propagation = {}

neuralplex-0.0.2/tests/main.py

@@ -1,73 +0,0 @@
-import time
-from random import random, randint
-import json
-import pickle
-import numbers
-import math
-from sklearn.metrics import r2_score
-from neuralplex import Network, Layer, Perceptron
-
-EPOCHS = int(1e6)
-
-l1 = Layer(
-    perceptrons=[
-        Perceptron(coef=random(), name='in-a'),
-        Perceptron(coef=random(), name='in-b'),
-        Perceptron(coef=random(), name='in-c'),
-        Perceptron(coef=random(), name='in-d'),
-    ],
-    deg=1,
-)
-
-# l2a = Layer(
-#     perceptrons=[Perceptron(coef=random()*1e2) for i in range(0, 10)], deg=2
-# )
-
-l2b = Layer(
-    perceptrons=[Perceptron(coef=random()*1e2) for i in range(0, 10)], deg=2
-)
-
-l3 = Layer(perceptrons=[Perceptron(coef=random(), name='out')], deg=1)
-
-n1 = Network([l1, l2b, l3])
-
-for i in range(0, EPOCHS):
-    
-    rn = randint(1, 15)
-
-    b = [int(n) for n in bin(rn)[2:]]
-
-    while len(b) < 4:
-        b = [0] + b
-
-    n1.train(b, [rn])
-
-    pn = n1.predict(b)
-
-    print(f"{i} input: {json.dumps(b)}, truth: {rn} prediction: {json.dumps(pn)}")
-
-    # time.sleep(1)
-
-y_true = []
-y_pred = []
-for i in range(1, 16):
-
-    b = [int(n) for n in bin(i)[2:]]
-
-    while len(b) < 4:
-        b = [0] + b
-
-    pn = n1.predict(b)
-
-    y_true.append(i)
-    y_pred.append(pn[0])
-
-    print(f"{i} input: {json.dumps(b)}, truth: {i} prediction: {json.dumps(pn)}")
-
-R2 = r2_score(y_true, y_pred)
-
-print(R2)
-
-if R2 >= .7:
-    with open("model.pkl", "wb") as f:
-        pickle.dump(n1, f)