Removed LGGA from the recover branch entirely

lgga/FeynmanProblem.py

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

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

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

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

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