Added Truth Python Files

lgga/FeynmanProblem.py

@@ -0,0 +1,62 @@
+import numpy as np
+import pandas as pd
+import tempfile, os, pdb, csv, traceback,random, time
+
+
+class FeynmanProblem:
+    def __init__(self, row, gen=False):
+        self.eq_id      = row['Filename']
+        self.form       = row['Formula']
+        self.n_vars     = int(row['# variables'])
+        self.var_names  = [row[f'v{i+1}_name']  for i in range(self.n_vars)]
+        self.low        = [float(row[f'v{i+1}_low'])   for i in range(self.n_vars)]
+        self.high       = [float(row[f'v{i+1}_high'])  for i in range(self.n_vars)]
+        self.dp         = 500#int(row[f'datapoints'])
+        self.X = None
+        self.Y = None
+        if gen:
+            self.X = np.random.uniform(0.01, 25, size=(self.dp, self.n_vars))
+            d = {}
+            for var in range(len(self.var_names)):
+                d[self.var_names[var]] = self.X[:, var]
+            d['exp'] = np.exp
+            d['sqrt'] = np.sqrt
+            d['pi'] = np.pi
+            d['cos'] = np.cos
+            d['sin'] = np.sin
+            d['tan'] = np.tan
+            d['tanh'] = np.tanh
+            d['ln']   = np.log
+            d['arcsin'] = np.arcsin
+            self.Y = eval(self.form,d)
+        return
+
+    def __str__(self):
+        return f"Feynman Equation: {self.eq_id}|Form: {self.form}"
+
+    def __repr__(self):
+        return str(self)
+
+    def mk_problems(first=100, gen=False, data_dir="datasets/FeynmanEquations.csv"):
+        ret = []
+        with open(data_dir) as csvfile:
+            ind = 0
+            reader = csv.DictReader(csvfile)
+            for i, row in enumerate(reader):
+                if ind > first:
+                    break
+                if row['Filename'] == '': continue
+                try:
+                    p = FeynmanProblem(row, gen=gen)
+                    ret.append(p)
+                except Exception as e:
+                    #traceback.print_exc()
+                    #print(row)
+                    print(f"FAILED ON ROW {i}")
+                ind += 1
+        return ret
+
+
+if __name__ == "__main__":
+    ret = FeynmanProblem.mk_problems(first=100, gen=True)
+    print(ret)

lgga/Oracle.py

@@ -0,0 +1,97 @@
+import numpy as np
+
+
+class Oracle:
+    oracle_d = {'exp': np.exp, 'sqrt': np.sqrt, 'pi': np.pi, 'cos': np.cos, 'sin': np.sin, 'tan': np.tan,
+                'tanh': np.tanh, 'ln': np.log, 'arcsin': np.arcsin}
+
+    def __init__(self, nvariables, f=None, form=None, variable_names=None, range_restriction={}, id=None):
+        """
+        nvariables: is the number of variables the function takes in
+        f: takes in an X of shape (n, nvariables) and returns f(X) of shape (n,)
+        form: String Def of the function
+        variable_names: variable names used in form
+        Range_restrictions: Dictionary of form {variable_index: (low, high)}
+        """
+        self.nvariables = nvariables
+        if f is None and form is None:
+            raise ValueError("f and form are both none in Oracle initialization. Specify at least one")
+        if f is not None and form is not None:
+            raise ValueError("f and form are both not none, pick only one")
+        if form is not None and variable_names is None:
+            raise ValueError("If form is provided then variable_names must also be provided")
+        if form is not None:
+            self.form = form
+            self.variable_names = variable_names
+            self.use_func = False
+            self.d = Oracle.oracle_d.copy()
+            for var_name in variable_names:
+                self.d[var_name] = None
+        else:
+            # f is not None
+            self.func = f
+            self.use_func = True
+
+        self.ranges = []
+        for i in range(nvariables):
+            if i in range_restriction:
+                self.ranges.append(range_restriction[i])
+            else:
+                self.ranges.append(None)
+
+        if id is not None:
+            self.id = id
+        return
+
+    def f(self, X):
+        """
+        X is of shape (n, nvariables)
+        """
+        if self.invalid_input(X):
+            raise ValueError("Invalid input to Oracle")
+        if self.use_func:
+            return self.func(X)
+        else:
+            return self.form_f(X)
+
+    def form_f(self, X):
+        """
+        Returns the function output using form
+        """
+        for i, var in enumerate(self.variable_names):
+            self.d[var] = X[:, i]
+        return eval(self.form, self.d)
+
+    def invalid_input(self, X):
+        """
+        Returns true if any of the following are true
+            X has more or less variables than nvariables
+            X has a value in a restricted range variable outside said range
+        """
+        if X.shape[1] != self.nvariables:
+            return True
+        for i, r in enumerate(self.ranges):
+            if r is None:
+                continue
+            else:
+                low = r[0]
+                high = r[1]
+                low_check = all(low <= X[:, i])
+                high_check = all(X[:, i] <= high)
+                if not low_check or not high_check:
+                    return True
+
+    def __str__(self):
+        if self.id:
+            return str(self.id)
+        elif self.form:
+            return str(self.form)
+        else:
+            return "<Un named Oracle>"
+
+    def from_problem(problem):
+        """
+        Static function to return an oracle when given an instance of class problem.
+        """
+        return Oracle(nvariables=problem.n_vars, f=None, form=problem.form, variable_names=problem.var_names,
+                      id=problem.eq_id)

lgga/Transformation.py

@@ -0,0 +1,77 @@
+class Transformation:
+    def __init__(self, index, name="Identity Transformation"):
+        self.name = name
+        self.index = index
+
+    def transform(self, X):
+        """
+        Takes in a data point of shape (n, d) and returns an augmented data point based on the constraint
+        """
+        return X
+
+    def __str__(self):
+        return str(self.name)
+
+    def __repr__(self):
+        return str(self)
+
+    def get_params(self):
+        raise NotImplementedError
+
+
+class SymTransformation(Transformation):
+    def __init__(self, x1=0, x2=1):
+        """
+        x1, x2 = indices of the variables which are symmetric
+        """
+        super().__init__(1, name=f"Symmetry Between Variable {x1} and {x2}")
+        self.x1 = x1
+        self.x2 = x2
+
+    def transform(self, X):
+        """
+        """
+        temp = X.copy()
+        temp[:, self.x2] = X[:, self.x1].copy()
+        temp[:, self.x1] = X[:, self.x2].copy()
+        return temp
+
+    def get_params(self):
+        return [self.x1, self.x2]
+
+
+class ZeroTransformation(Transformation):
+    def __init__(self, inds=[0]):
+        """
+        inds is a list of indices to set to 0
+        """
+        super().__init__(2, name=f"Zero Constraint for Variables {inds}")
+        self.inds = inds
+
+    def transform(self, X):
+        temp = X.copy()
+        for ind in self.inds:
+            temp[:, ind] = 0
+        return temp
+
+    def get_params(self):
+        return list(self.inds)
+
+
+class ValueTransformation(Transformation):
+    def __init__(self, inds=[0]):
+        """
+        inds is list of indices to set to the same value as the first element in that list
+        """
+        super().__init__(3, name=f"Value Constraint for Variables {inds}")
+        self.inds = inds
+
+    def transform(self, X):
+        temp = X.copy()
+        val = temp[:, self.inds[0]]
+        for ind in self.inds[1:]:
+            temp[:, ind] = val
+        return temp
+
+    def get_params(self):
+        return list(self.inds)

lgga/Truth.py

@@ -0,0 +1,39 @@
+import numpy as np
+
+
+class Truth:
+    def __init__(self, transformation, model):
+        self.transformation = transformation
+        self.weights = list(model.coef_) + [model.intercept_]
+
+    def predict(self, X, y):
+        transformed = self.transformation.transform(X)
+        res = np.zeros(shape=y.shape)
+        for w in range(len(self.weights)):
+            if w < X.shape[1]:
+                res = res + (X[:, w] * self.weights[w])
+            elif w == X.shape[1]:
+                res = res + (y * self.weights[w])
+            else:
+                assert w == X.shape[1] + 1
+                res = res + self.weights[w]
+        return res
+
+    def transform(self, X):
+        return self.transformation.transform(X)
+
+    def __str__(self):
+        return f"Auxiliary Truth: {self.transformation} with linear coefficients for X, y, 1 {self.weights}"
+
+    def __repr__(self):
+        return str(self)
+
+    def julia_string(self):
+        """
+        Return an expression that sorta creates a julia instances of Truth with these parameters
+        Specifically Truth(type, params, weights)
+        Julia indexing starts at 1 not 0 so we need to add 1 to all parameter indices
+        """
+        index = self.transformation.index
+        params = self.transformation.get_params()
+        return f"Truth({index}, {[param + 1 for param in params]}, {self.weights})"

lgga/constraint_discovery.py

@@ -0,0 +1,193 @@
+from sklearn.linear_model import LinearRegression
+from Transformation import *
+from Truth import *
+import itertools
+import warnings
+import traceback
+
+
+def gen_valid_points(oracle, npoints=20, default_min=0.5, default_max=30):
+    """
+    Generates valid dataset (npoints, dim)
+    """
+    dim = oracle.nvariables
+    # print(f"Dim {dim}, {oracle.nvariables}")
+    # print(f"Oracle has {oracle} {oracle.variable_names}")
+    mins = []
+    maxes = []
+    for r in oracle.ranges:
+        if r is None:
+            mins.append(default_min)
+            maxes.append(default_max)
+        else:
+            mins.append(r[0])
+            maxes.append(r[1])
+    return np.random.uniform(low=mins, high=maxes, size=(npoints, dim))
+
+
+def discover(transformation, oracle, npoints=20, threshold=0.98, timeout=5):
+    """
+    Constraint is a class child of the Class parent Constraint
+
+    Oracle is a class which has a variable nvariables i.e number of inputs and a function f which performs f(X)
+        f(X) must be of shape (n, nvariables)
+
+    npoints: number of data points to train the weak model with
+
+    threshold: minimum accuracy of weak model to say that a constraint has been found
+
+    timeout: If the random generator cannot find a valid input in timeout seconds we quit
+    """
+    # Get random 10 points from some range
+    start = time()
+    sat = False
+    while not sat and time() - start < timeout:
+        try:
+            points = gen_valid_points(oracle, npoints)
+            y_original = oracle.f(points)
+            if any(np.isnan(y_original)) or any(np.isinf(y_original)):
+                print(points, points.shape, oracle)
+                print(y_original)
+                break
+                raise ValueError()
+            sat = True
+        except:
+            traceback.print_stack()
+    if not sat:
+        warnings.warn(f"Could not find an input that worked for oracle - ({oracle})")
+        return False, None
+    # print(points)
+    X = transformation.transform(points)
+    try:
+        y = oracle.f(X)
+        if any(np.isnan(y)) or any(np.isinf(y)):
+            raise ValueError()
+    except:
+        # If the oracle cannot evaluate this input because of an out of domain error
+        return False, None
+    model, score = weak_learner(X, y, y_original)
+    if score > threshold:
+        return True, Truth(transformation, model)
+    else:
+        return False, Truth(transformation, model)
+
+
+def weak_learner(X, y, y_original):
+    """
+    Takes in X, y and returns a weak learner that tries to fit the training data and its associated R^2 score as well as the model itself
+    """
+
+    y_original = np.reshape(y_original, newshape=(len(y_original), 1))
+    # print(X.shape, y_original.shape)
+    new_X = np.append(X, y_original, axis=1)
+
+    model = LinearRegression()
+    model.fit(new_X, y)
+    # Force the model to be simple by rounding coefficients to 2 decimal points
+    model.coef_ = np.round(model.coef_, 2)
+    model.intercept_ = np.round(model.intercept_, 2)
+
+    score = model.score(new_X, y)
+    return model, score
+
+
+def powerset(iterable):
+    "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
+    s = list(iterable)
+    return itertools.chain.from_iterable(itertools.combinations(s, r) for r in range(len(s) + 1))
+
+
+def multiprocess_task(transformation, oracle):
+    """
+    Takes in a constraint and oracle and returns (constraint, model) if the value from discover is true else returns None
+    """
+    value, truth = discover(transformation, oracle)
+    if value == True:
+        return truth
+    else:
+        return None
+
+
+def naive_procedure(oracle):
+    """
+    Takes in an oracle and gives out an exhaustive list of form [(constraint, model)] for all true constraints
+    """
+    nvariables = oracle.nvariables
+    var_list = range(nvariables)
+    pairs = itertools.combinations(var_list, r=2)
+    sets = [x for x in powerset(var_list) if len(x) > 0]
+    final = []
+    transformations = []
+    for pair in pairs:
+        transformations.append(SymTransformation(pair[0], pair[1]))
+        pass
+    for smallset in sets:
+        if len(smallset) > 1:
+            transformations.append(ValueTransformation(smallset))
+        transformations.append(ZeroTransformation(smallset))
+
+        pass
+    # with concurrent.futures.ProcessPoolExecutor() as executor:
+    #    args = [(constraint, oracle) for constraint in constraints]
+    #    results = executor.map(lambda x: multiprocess_task(*x), args)
+
+    temp = [multiprocess_task(transformation, oracle) for transformation in transformations]
+    for t in temp:
+        if t is not None:
+            final.append(t)
+    return final
+
+
+def process_from_problems(problems):
+    ids = []
+    forms = []
+    ns = []
+    for problem in problems:
+        nvariables = problem.n_vars
+        form = problem.form
+        variable_names = problem.var_names
+        id = problem.eq_id
+
+        oracle = Oracle(nvariables, form=form, variable_names=variable_names, id=id)
+        ids.append(oracle.id)
+        forms.append(oracle.form)
+        ns = len(naive_procedure(oracle))
+    d = {"id": ids, "form": forms, "Number of Constraints": ns}
+    return d
+
+
+def process_from_form_and_names(form, variable_names):
+    """
+    Returns a julia string which declares an array called TRUTHS
+    """
+    if form is None or variable_names is None:
+        return "TRUTHS = []"
+    nvars = len(variable_names)
+    oracle = Oracle(nvariables=nvars, form=form, variable_names=variable_names)
+    truths = naive_procedure(oracle)
+    print("Discovered the following Auxiliary Truths")
+    for truth in truths:
+        print(truth)
+    julia_string = "TRUTHS = ["
+    for truth in truths:
+        addition = truth.julia_string()
+        julia_string = julia_string + addition + ", "
+    julia_string = julia_string + "]"
+    return julia_string
+
+
+if __name__ == "__main__":
+    from Transformation import  SymTransformation
+    from Oracle import Oracle
+    from time import time
+
+    variable_names = ["alpha", "beta"]
+    form = "alpha * beta"
+    nvariables = len(variable_names)
+    # range_restriction={2: (1, 20)}
+    oracle = Oracle(nvariables, form=form, variable_names=variable_names)
+    now = time()
+    finals = naive_procedure(oracle)
+    end = time()
+    print(finals)
+    print(end - now)