flexibot 0.0.0__tar.gz

flexibot-0.0.0/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/PKG-INFO

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

flexibot-0.0.0/README.md

@@ -0,0 +1,39 @@
+# Flexibot
+
+This is an efficient Python library made for the intended use of reinforcement learning in robotics.
+
+!!WARNING THIS LIBRARY IS NOT FOR THE USE OF LLMS or Agents (e.g. ChatGPT, Gemini)!!
+
+## Installation
+
+```bash
+pip install flexibot
+```
+## Example of how Flexibot is used
+
+```python
+import flexibot as fl
+
+isizess = [(1, 10), (1, 5), (1, 4), (1, 8)]
+wsizess = [(10, 5), (5, 4), (4, 8), (8, 2)]  # Inner numbers match input columns!
+bsizess = [(1, 5),  (1, 4), (1, 8), (1, 2)]
+
+model = fl.network(isizes=isizess, wsizes=wsizess, bsizes=bsizess)
+
+model.ReLU(activate=True)
+
+while True:
+    g = model.MatrixMultiplication(2)
+
+    l, err = model.MSE(10)
+
+    if l < 0.001:
+        print(f"Success final answer {g}")
+        break
+    else:
+        model.Optim(0.01)
+```
+
+## License
+
+MIT License

flexibot-0.0.0/setup.cfg

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

flexibot-0.0.0/src/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/src/flexibot.egg-info/PKG-INFO

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

flexibot-0.0.0/src/flexibot.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+LICENSE
+README.md
+pyproject.toml
+src/flexibot/__init__.py
+src/flexibot.egg-info/PKG-INFO
+src/flexibot.egg-info/SOURCES.txt
+src/flexibot.egg-info/dependency_links.txt
+src/flexibot.egg-info/top_level.txt

flexibot-0.0.0/src/flexibot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flexibot-0.0.0/src/flexibot.egg-info/top_level.txt

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