wheeeeegit add -Agit add -A!

Author: DylanDmitri

.idea/workspace.xml

@@ -0,0 +1,79 @@
+from bogo.RandomTree import RandomTree
+from sympy_descent.model import Model, NoThetaException, DivergentModelException
+import sympy as sp
+
+def match(data):
+
+    def log(*args):
+        return
+        print(*args)
+
+
+    best_error = float('inf')
+    best_func = None
+
+    features = [c for c in data.columns if c!='y']
+
+    for _ in range(300):
+        f = RandomTree(2, features=features)
+
+        log('\n\n----------------------')
+        print(f.to_sympy())
+
+        try:
+            solver = Model(
+                f.to_sympy(),
+                data,
+                'y'
+            )
+        except NoThetaException:
+            log('no thetas')
+            continue
+
+        try:
+            solver.descend('rand')
+        except DivergentModelException:
+            log('model diverged')
+            continue
+
+        log(solver.weighted_model)
+
+        error = solver.error()
+        print(error)
+        print()
+
+        if error < best_error:
+            best_error = error
+            best_func = solver.weighted_model
+
+
+    best_func = sp.simplify(best_func + sp.Symbol('y'))
+
+    print()
+    print('best:', best_func)
+    print('error:', best_error)
+
+
+
+import pandas as pd
+
+simple = pd.DataFrame({
+     'x1':(1,2,3,4,5,6),
+     'y': (3,4,5,6,7,8)
+    })
+
+lumpy = pd.DataFrame({
+    'n': (56, 56, 65, 65, 50, 25, 87, 44, 35),
+    'y': (87, 91, 85, 91, 75, 28, 122, 66, 58),
+})
+
+# match(lumpy)
+
+lumpy -= lumpy.min()
+lumpy /= lumpy.max()
+
+match(lumpy)
+
+
+
+

bogo/Guess.py

@@ -42,19 +42,15 @@ class Sum(Operation):
 class Product(Operation):
     func = sp.Mul
 
-class Min(Operation):
-    func = sp.Min
+# class Min(Operation):
+#     func = sp.Min
 
-class Max(Operation):
-    func = sp.Max
+# class Max(Operation):
+#     func = sp.Max
 
-class Power(Operation):
-    func = sp.Pow
-    slot_limit = 2
-
-class Log(Operation):
-    func = sp.log
-    slot_limit = 2
+# class Power(Operation):
+#     func = sp.Pow
+#     slot_limit = 2
 
 
 class RandomTree:
@@ -71,8 +67,6 @@ def __init__(self, operations=3,
         self.features = features
         self.fill(self.head)
 
-        print('done')
-
     def random_child(self, node):
         r = randint(0, len(node.args) + node.empty)
         if r >= len(node.args):
@@ -91,8 +85,8 @@ def fill(self, node):
         while len(node.args) < 2:
             node.add(self.random_symbol())
 
-        while node.empty and random()<.5:
-            node.add(self.random_symbol())
+        while node.empty and random()<.4:
+            node.add(sp.Symbol(choice(self.features)))
 
         for child in node.args:
             if isinstance(child, Operation):
@@ -102,3 +96,5 @@ def to_sympy(self):
         return sp.simplify(self.head.serialize())
 
 
+
+

bogo/RandomTree.py

@@ -0,0 +1,29 @@
+# -0.10544438075674*n**3 + n + 0.0927434048707628
+
+import pandas as pd
+import numpy as np
+
+lumpy = pd.DataFrame({
+    'n': (56, 56, 65, 65, 50, 25, 87, 44, 35),
+    'y': (87, 91, 85, 91, 75, 28, 122, 66, 58),
+})
+
+# match(lumpy)
+
+lumpy -= lumpy.min()
+lumpy /= lumpy.max()
+
+
+import matplotlib.pyplot as plt
+
+plt.scatter(lumpy.n, lumpy.y)
+
+xaxis = np.arange(0,1,.001)
+
+@np.vectorize
+def f(n):
+    return -.1054444380*n**3 + n + .0927434
+
+plt.plot(xaxis, f(xaxis))
+
+plt.show()

bogo/visualize.py

@@ -0,0 +1,5 @@
+{
+  "testEngine.py::TestGradientDescent::test_double_thetas": true,
+  "testEngine.py::TestGradientDescent::test_double_xs": true,
+  "testEngine.py::TestGradientDescent::test_simplest": true
+}

symengine_descent/.pytest_cache/v/cache/lastfailed

@@ -10,16 +10,3 @@
 run = lambda f: f()
 
 
-
-@run
-def w_engine():
-    x = symengine.var("x")
-
-    f = x**2 + x
-    f = f.subs(x, 5)
-
-    print(eval_double(f))
-
-
-
-

symengine_descent/speed_test.py

@@ -1,7 +1,9 @@
 import numpy as np
 import symengine as sym
 from symengine import Symbol
-from sympy_descent.data_loader import DataLoader
+from sympy_descent.data_loader import DataLoaderDict
+
+DataLoader = DataLoaderDict
 
 THETA_PREFIX = 't'
 def Theta(i:int):
@@ -82,7 +84,7 @@ def search(head):
         @np.vectorize
         def cost_partial(t):
             f = self.model * self.model.diff(t)
-            return np.sum(f.subs(row) for row in self.data) #.simplify()
+            return np.sum(f.subs(row) for row in self.data).simplify()
 
         self.grad = cost_partial(self.thetas)
 
@@ -123,7 +125,7 @@ def descend(self, initial_thetas,
     # =========================================================================
     @property
     def theta_dict(self):
-        return tuple(zip(self.thetas, self.theta_vals))
+        return dict(zip(self.thetas, self.theta_vals))
 
     def save_weighted_model(self):
         self.weighted_model = self.model.subs(self.theta_dict).simplify()

symengine_descent/symengine_model.py

@@ -0,0 +1,59 @@
+import unittest
+from symengine_descent.symengine_model import Model
+
+from symengine import Symbol
+import pandas as pd
+
+x1 = Symbol('x1')
+x2 = Symbol('x2')
+y  = Symbol('y')
+t1 = Symbol('t1')
+t2 = Symbol('t2')
+t3 = Symbol('t3')
+
+
+def disp(m):
+    print()
+    print('test1')
+    print(m.weighted_model)
+    print('error:', m.error())
+
+
+class TestGradientDescent(unittest.TestCase):
+
+    def test_simplest(self):
+
+        solver = Model(
+            t1 * x1,
+            pd.DataFrame({'x1':(1,2,3), 'y':(1.0,1.9,3.1)}),
+            target = 'y')
+
+        solver.descend('rand')
+
+        disp(solver)
+
+    def test_double_thetas(self):
+
+        solver = Model(
+            t1*x1*x1 + t2 - y,
+            pd.DataFrame({'x1':(0,1,2), 'y':(1,2,5)}),
+        )
+
+        solver.descend([0.0, 0.0], alpha=.05, momentum=.5, threshold=.01)
+        disp(solver)
+
+    def test_double_xs(self):
+
+        solver = Model(
+            t1*x1 + t2*x2 + t3,
+            pd.DataFrame({'x1':(0, 3, 6), 'x2':(0, 1, 2), 'y':(.1, .4, .8)}),
+            target = 'y'
+        )
+        solver.descend([0.0, 0.0, 0.0])
+        disp(solver)
+
+
+
+
+if __name__ == '__main__':
+    unittest.main()

symengine_descent/testEngine.py

@@ -12,4 +12,11 @@ def __init__(self, df:pd.DataFrame):
 
     def __iter__(self):
         for row in self.df.iterrows():
-            yield tuple(row[1].to_dict().items())
+            yield tuple(row[1].to_dict().items())
+
+
+class DataLoaderDict(DataLoader):
+
+    def __iter__(self):
+        for row in self.df.iterrows():
+            yield row[1].to_dict()

sympy_descent/data_loader.py

@@ -1,6 +1,14 @@
 from sympy_descent.helpers import *
 from sympy_descent.data_loader import DataLoader
 
+
+class NoThetaException(Exception):
+    """No thetas found. Should start with `t`."""
+
+class DivergentModelException(Exception):
+    """Whoops"""
+
+
 class Model:
 
     # =========================================================================
@@ -37,7 +45,7 @@ def search(head):
         search(self.model)
 
         if len(thetas) == 0:
-            raise Exception(f'No Thetas found. Should start with {THETA_PREFIX}')
+            raise NoThetaException
 
         self.thetas = sorted(tuple(thetas), key=str)
 
@@ -66,29 +74,34 @@ def cost_partial(t):
 
     # =========================================================================
     def descend(self, initial_thetas,
-                alpha=.05, momentum=0.5, threshold=.01):
+                alpha=.01, momentum=0.5, threshold=.01):
+
+        if initial_thetas == 'rand':
+            initial_thetas = list(np.random.rand(len(self.thetas)))
 
         assert len(initial_thetas) == len(self.thetas)
 
         self.theta_vals = initial_thetas
 
         deltas = np.zeros(len(self.thetas))
 
-        for i in range(999):
-
-            self.save_weighted_model()
+        for i in range(1,500):
 
-            # print(i, '\t', *(f'{float(s):.4f}'.ljust(8) for s in (*self.theta_vals, self.error())))
+            # if not i%50:
+            #     self.save_weighted_model()
+            #     print(i, '\t', *(f'{float(s):.4f}'.ljust(8) for s in (*self.theta_vals, self.error())))
 
             deltas = (momentum*deltas
                       + np.array([grad.subs(self.theta_dict) for grad in self.grad]))
 
-            if sum(abs(deltas)) < threshold: break
+            if sum(abs(deltas)) < threshold:
+                break
 
             self.theta_vals -= deltas * alpha
 
-        else:
-            raise Exception('maximum iterations exceeded. something is probably wrong')
+            if any(abs(self.theta_vals) > 9999):
+                raise DivergentModelException()
+
 
         self.save_weighted_model()
 
@@ -100,7 +113,6 @@ def theta_dict(self):
     def save_weighted_model(self):
         self.weighted_model = simplify(self.model.subs(self.theta_dict))
 
-
     def error(self):
         return np.sum(self.weighted_model.subs(row)**2 for row in self.data)
 

sympy_descent/model.py

@@ -0,0 +1 @@
+{}

tests/.pytest_cache/v/cache/lastfailed

@@ -1,10 +1,12 @@
 import unittest
-from bogo.BogoBoost import RandomTree
+from bogo.RandomTree import RandomTree, bag
 
 class MyTestCase(unittest.TestCase):
+
     def test_something(self):
-        t = RandomTree(3)
-        print(t.head.serialize)
+        t = RandomTree(1)
+        print(t.head.serialize())
+
 
 if __name__ == '__main__':
     unittest.main()