flexibot 0.0.0__py3-none-any.whl

flexibot/__init__.py

@@ -0,0 +1,109 @@
+import numpy as np
+import random as rad
+
+class network():
+    def __init__(self, isizes,  wsizes, bsizes):
+
+        # ~ initiate inputs ~ #
+        self.i1 = np.random.uniform(-0.1, 0.1, size=isizes.__getitem__(0))
+        self.i2 = np.random.uniform(-0.1, 0.1, size=isizes.__getitem__(1))
+        self.i3 = np.random.uniform(-0.1, 0.1, size=isizes.__getitem__(2))
+        self.i4 = np.random.uniform(-0.1, 0.1, size=isizes.__getitem__(3))
+
+        # ~ initiate parameters ~ #
+        self.w1 = np.random.uniform(-0.1, 0.1, size=wsizes.__getitem__(0))
+        self.w2 = np.random.uniform(-0.1, 0.1, size=wsizes.__getitem__(1))
+        self.w3 = np.random.uniform(-0.1, 0.1, size=wsizes.__getitem__(2))
+        self.w4 = np.random.uniform(-0.1, 0.1, size=wsizes.__getitem__(3))
+
+        self.b1 = np.random.uniform(-0.1, 0.1, size=bsizes.__getitem__(0))
+        self.b2 = np.random.uniform(-0.1, 0.1, size=bsizes.__getitem__(1))
+        self.b3 = np.random.uniform(-0.1, 0.1, size=bsizes.__getitem__(2))
+        self.b4 = np.random.uniform(-0.1, 0.1, size=bsizes.__getitem__(3))
+
+    def ReLU(self, activate):
+        if activate == True:
+            self.enable = True
+        else:
+            self.enable = False
+
+    def MatrixMultiplication(self, inchange):
+        """
+        input: numpy array 
+        """
+        
+        self.p1 = self.i1 @ self.w1 + self.b1
+        if self.enable == True:
+            self.p1 = np.maximum(0, self.p1)
+        self.i2 += inchange ** 2 / rad.uniform(1, 2)
+        self.p1 = np.resize(self.p1, self.i2.shape)
+        self.i2 += self.p1
+        self.i2 = np.clip(self.i2, -1.0, 1.0)
+
+
+
+        self.p2 = self.i2 @ self.w2 + self.b2
+        if self.enable == True:
+            self.p2 = np.maximum(0, self.p2)
+        self.i3 += inchange ** 2 / rad.uniform(1, 2)
+        self.p2 = np.resize(self.p2, self.i3.shape)
+        self.i3 += self.p2
+        self.i3 = np.clip(self.i3, -1.0, 1.0)
+
+
+
+        self.p3 = self.i3 @ self.w3 + self.b3
+        if self.enable == True:
+            self.p3 = np.maximum(0, self.p3)
+        self.i4 += inchange ** 2 / rad.uniform(1, 2)
+        self.p3 = np.resize(self.p3, self.i4.shape)
+        self.i4 += self.p3
+        self.i4 = np.clip(self.i4, -1.0, 1.0)
+
+
+
+        self.p4 = self.i4 @ self.w4 + self.b4
+        if self.enable == True:
+            self.p4 = np.maximum(0, self.p4)
+        self.i1 += inchange ** 2 / rad.uniform(1, 2)
+        self.p4 = np.resize(self.p4, self.i1.shape)
+        self.i1 += self.p4
+        self.i1 = np.clip(self.i1, -1.0, 1.0)
+
+
+        return self.p1, self.p2, self.p3, self.p4, self.i1, self.i2, self.i3, self.i4
+    def Smoothen(self, _inchange_):
+        self.MatrixMultiplication(_inchange_)
+
+        return np.ravel(self.p4)
+    def MSE(self, ref):
+
+        self.error = self.p4 - ref
+
+        MSE = np.power(self.error, 2)
+
+
+        self.MSE_loss = np.mean(MSE)
+
+        return self.MSE_loss, self.error
+    
+    def Optim(self, lr):
+        grad4 = self.i4.T @ self.error
+        grad3 = self.i3.T @ self.error
+        grad2 = self.i2.T @ self.error
+        grad1 = self.i1.T @ self.error
+
+        # 2. MAGIC FIX: Force the gradients to match the exact shape 
+        # of their respective weights before subtracting!
+        self.w4 -= lr * np.resize(grad4, self.w4.shape)
+        self.w3 -= lr * np.resize(grad3, self.w3.shape)
+        self.w2 -= lr * np.resize(grad2, self.w2.shape)
+        self.w1 -= lr * np.resize(grad1, self.w1.shape)
+
+        # 3. Clean bias updates (using resize so they always match the bias shape!)
+        self.b4 -= lr * np.resize(np.mean(self.error), self.b4.shape)
+        self.b3 -= lr * np.mean(self.error) # If these are always flat, they are fine
+        self.b2 -= lr * np.mean(self.error)
+        self.b1 -= lr * np.mean(self.error)
+
+        return self.w1, self.w2, self.w3, self.w4, self.b1, self.b2, self.b3, self.b4

flexibot-0.0.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: flexibot
+Version: 0.0.0
+License-File: LICENSE
+Dynamic: license-file

flexibot-0.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+flexibot/__init__.py,sha256=VVERMJwg3w0HxcAl0zHhhSBWjDlO2SpcNJFWFpI9sSc,3982
+flexibot-0.0.0.dist-info/licenses/LICENSE,sha256=xQS0sSLen-sCoy9R70cLPVJwh7lgyDb4EY3Ao3tFkyc,1093
+flexibot-0.0.0.dist-info/METADATA,sha256=kmdDrDQXF-acm_V2NKujiQFM11LFgaPXk_5cA1HEPnk,101
+flexibot-0.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+flexibot-0.0.0.dist-info/top_level.txt,sha256=s6CZ0wEqrCeuh-Jia4TAeHtThzFtcn5N-JL5trl1t28,9
+flexibot-0.0.0.dist-info/RECORD,,

flexibot-0.0.0.dist-info/WHEEL

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

flexibot-0.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+Copyright (c) 2026 Luke William Warren
+
+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.

flexibot-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flexibot