neuralplex 0.0.1__tar.gz → 0.0.2__tar.gz

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

@@ -158,3 +158,5 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+*.ipynb

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: neuralplex
-Version: 0.0.1
+Version: 0.0.2
 Summary: A Neuralplex.
 Project-URL: Homepage, https://github.com/faranalytics/neuralplex
 Project-URL: Issues, https://github.com/faranalytics/neuralplex/issues
@@ -9,7 +9,9 @@ License-File: LICENSE
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
-# neuralplex
+# Neural-pleX
+
+An object oriented neural network implementation.

neuralplex-0.0.2/README.md

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

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

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "neuralplex"
-version = "0.0.1"
+version = "0.0.2"
 authors = [
   { name="FAR Analytics & Research", email="adam@farar.net" },
 ]
 description = "A Neuralplex."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",

neuralplex-0.0.2/src/neuralplex/layer.py

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

neuralplex-0.0.2/src/neuralplex/network.py

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,73 @@
+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)

neuralplex-0.0.1/README.md

@@ -1 +0,0 @@
-# neuralplex

neuralplex-0.0.1/src/neuralplex/layer.py

@@ -1,14 +0,0 @@
-class Layer:
-
-    def __init__(self, perceptrons, deg):
-        self.perceptrons = perceptrons
-        self.deg = deg
-
-        if self.deg:
-            for perceptron in self.perceptrons:
-                perceptron.deg = self.deg
-
-    def connect(self, layer):
-        for p1 in self.perceptrons:
-            for p2 in layer.perceptrons:
-                p1.connect(p2)

neuralplex-0.0.1/src/neuralplex/network.py

@@ -1,36 +0,0 @@
-class Network:
-
-    def __init__(self, layers):
-        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 epoch(self, inputs, outputs):
-        if len(self.input.perceptrons) != len(inputs):
-            raise Exception(f'The length of the training values, {len(inputs)}, is not equal to the number 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 number 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):
-
-        if len(self.input.perceptrons) != len(inputs):
-            raise Exception(f'The length of the training values, ${len(inputs)}, is not equal to the number 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.1/src/neuralplex/perceptron.py

@@ -1,35 +0,0 @@
-class Perceptron:
-
-    def __init__(self, coef, deg=1):
-        self.coef = coef
-        self.deg = deg
-        self.perceptronsRHS = []
-        self.perceptronsLHS = []
-        self.activations = []
-        self.propagations = []
-        self.q = 0
-
-    def connect(self, perceptron):
-        self.perceptronsRHS.append(perceptron);
-        perceptron.perceptronsLHS.append(self);
-
-    def activate(self, t):
-        self.activations.append(self.coef * t**self.deg)
-        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):
-        self.propagations.append(t)
-        if len(self.perceptronsRHS) == 0 or len(self.propagations) == len(self.perceptronsRHS):
-            d = sum(self.propagations)
-            if d > 0:
-                self.coef = self.coef - 1e-5
-            else: 
-                self.coef = self.coef + 1e-5
-            
-            for perceptron in self.perceptronsLHS:
-                perceptron.propagate(d)
-            self.propagations = []

neuralplex-0.0.1/tests/main.ipynb

@@ -1,83 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import random\n",
-    "import json\n",
-    "from neuralplex import Network, Layer, Perceptron"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "l1 = Layer(perceptrons=[\n",
-    "    Perceptron(coef=random.randint(0,1)),\n",
-    "    Perceptron(coef=random.randint(0,1)),\n",
-    "    Perceptron(coef=random.randint(0,1)),\n",
-    "    Perceptron(coef=random.randint(0,1))\n",
-    "], deg=1)\n",
-    "\n",
-    "l2 = Layer(perceptrons=[Perceptron(coef=random.randint(0,1)) for i in range(0, 1000)], deg=2)\n",
-    "\n",
-    "l3 = Layer(perceptrons=[\n",
-    "    Perceptron(coef=random.randint(0,1))\n",
-    "], deg=1)\n",
-    "\n",
-    "n1 = Network([l1, l2, l3])\n",
-    "\n",
-    "for i in range(0, int(1e5*3)):\n",
-    "\n",
-    "    n = random.randint(1,15)\n",
-    "    \n",
-    "    binary = [int(i) for i in list('{0:0b}'.format(n))]\n",
-    "    \n",
-    "    while len(binary) < 4:\n",
-    "        binary = [0] + binary\n",
-    "\n",
-    "    print(binary, n)\n",
-    "\n",
-    "    n1.epoch(binary, [n])\n",
-    "\n",
-    "    prediction = n1.predict(binary)\n",
-    "\n",
-    "    if \n",
-    "        print(f'{i} input: {json.dumps(binary)}, truth: {n} prediction: {json.dumps(prediction)}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py39",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.16"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

neuralplex-0.0.1/tests/main.py

@@ -1,40 +0,0 @@
-import random
-import json
-from neuralplex import Network, Layer, Perceptron
-
-l1 = Layer(
-    perceptrons=[
-        Perceptron(coef=random.randint(0, 10)),
-        Perceptron(coef=random.randint(0, 10)),
-        Perceptron(coef=random.randint(0, 10)),
-        Perceptron(coef=random.randint(0, 10)),
-    ],
-    deg=1,
-)
-
-l2 = Layer(
-    perceptrons=[Perceptron(coef=random.randint(0, 1)) for i in range(0, 1000)], deg=2
-)
-
-l3 = Layer(perceptrons=[Perceptron(coef=random.randint(0, 1))], deg=1)
-
-n1 = Network([l1, l2, l3])
-
-for i in range(0, int(1e5 * 3)):
-
-    n = random.randint(1, 15)
-
-    binary = [int(i) for i in list("{0:0b}".format(n))]
-
-    while len(binary) < 4:
-        binary = [0] + binary
-
-    print(binary, n)
-
-    n1.epoch(binary, [n])
-
-    prediction = n1.predict(binary)
-
-    print(
-        f"{i} input: {json.dumps(binary)}, truth: {n} prediction: {json.dumps(prediction)}"
-    )