optimal-omt 0.1.0__tar.gz

optimal_omt-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: optimal-omt
+Version: 0.1.0
+Summary: Optimal Model Trees using OR-Tools
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: binarytree
+Requires-Dist: ortools
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"

optimal_omt-0.1.0/omt/DatabaseParser.py

@@ -0,0 +1,128 @@
+import arff as rf
+from sklearn.preprocessing import StandardScaler
+import pandas as pd
+from TreeStructure import Multiplier
+from Binarizer import binarize_reduced, save_binarized_df
+
+def DataParser(name, ProbType, one_hot = True,toInt = False,StdScale=False):
+
+    try:
+        pd.set_option('future.no_silent_downcasting', True)
+    except:
+        pass
+
+    data = rf.load(open(f'{ProbType}Problems/{name}','rt'))
+
+    label_name = data['attributes'][-1][0]
+
+    df = pd.DataFrame(data['data'])
+    df.columns = [i[0] for i in data['attributes'] ]
+
+    eliminated_cols = []
+    # ELIMIATING A COLUMN FROM ALL DATASETS IF ALL THE VALUES IN IT ARE THE SAME IN THE TRAIN SET
+    for i in df.columns:
+        if df[i].nunique() <= 1:
+            df.drop(columns=[i], inplace=True)
+            eliminated_cols.append(i)
+
+    for i in [ i for i in data['attributes'] if i[0] not in eliminated_cols]:
+        # first with the features
+        if i[0] != label_name:
+            if type(i[1]) == str:
+                # replace NaN with mean for Numeric value features
+                mean_value = round(df[i[0]].mean(),3)
+                df[i[0]] = df[i[0]].fillna(value=mean_value).astype(float)
+                if toInt == True:
+                    # df[i[0]] = df[i[0]].round(3)  # todo comment off if you do not want to round
+                    df.loc[:, i[0]] *= Multiplier(df[i[0]])
+            else:
+                if one_hot == False:
+                    temp_feature_values = {i: ind for ind, i in enumerate(i[1])}
+                    df[i[0]] = df[i[0]].replace(temp_feature_values).astype(float)
+                else:
+                    if len(i[1]) == 2:
+                        df = pd.get_dummies(df,columns=[i[0]],drop_first=True,dtype=int)
+                    else:
+                        df = pd.get_dummies(df, columns=[i[0]],dtype=int)
+        elif i[0] == label_name and ProbType == 'Classification': # todo FOR CLASSIFICATION SCALE TARGET
+            if len(i[1]) == 2:
+                temp_label_values = {i[1][0]:-1,
+                                     i[1][1]:1}
+                df[i[0]] = df[i[0]].replace(temp_label_values).astype(float)
+            # else:
+            #     temp_label_values = {i: ind for ind, i in enumerate(i[1])}
+            #     df[i[0]] = df[i[0]].replace(temp_label_values).astype(int)
+    # df.dropna(inplace=True)
+
+    # ELIMIATING A COLUMN IF ALL THE VALUES IN IT ARE THE SAME
+    for i in df.columns:
+        if df[i].nunique() == 1:
+            df = df.drop(i, axis=1)
+
+    if StdScale == True:
+        ##### STANDARD SCALING #######
+        std_scaler = StandardScaler()
+        if ProbType == 'Classification':
+            features = list(df.columns.drop([label_name]))
+            df_scaled = df.drop(columns=label_name)
+        else:
+            features = list(df.columns)
+            df_scaled = df
+        df_scaled = std_scaler.fit_transform(df_scaled.to_numpy())
+        df_scaled = pd.DataFrame(df_scaled,columns=features)
+        if ProbType == 'Classification':
+            df_scaled.insert(len(features), label_name, df[label_name], True)
+        df = df_scaled
+
+    id_name = 'ID'
+    if id_name in df.columns:
+        df.drop(columns=[id_name],inplace=True)
+
+    return df
+
+if __name__ == "__main__":
+
+    #################### REGRESSION #####################
+    # collection = os.listdir('RegressionProblems')
+    #
+    # for i in collection:
+    #     df = regression_data_caller(i)
+    #     print(df)
+    #########################################
+
+    #################### CLASSIFICATION #####################
+    collection = [
+        ############ BINARY ############
+        'blogger.arff',
+        'boxing.arff',
+        'mux6.arff',
+        'corral.arff',
+        'biomed.arff',
+        'ionosphere.arff',
+        'jEdit.arff',
+        'schizo.arff',
+        'colic.arff',
+        'threeOf9.arff',
+        'R_data_frame.arff',
+        'australian.arff',
+        'doa_bwin_balanced.arff',
+        'blood-transf.arff',
+        'autoUniv.arff',
+        'parity.arff',
+        'banknote.arff',
+        'gametes_Epistasis.arff',
+        'kr-vs-kp.arff',
+        'banana.arff'
+    ]
+    for i in collection:
+        df = DataParser(i,
+                        'Classification',
+                        one_hot = False,
+                        toInt = False,
+                        StdScale=False)
+        print(i)
+        print(df)
+        df = binarize_reduced(df,max_thresholds=20)
+        print(df)
+        save_binarized_df(df,f'DL85_Problems/{i.split(".")[0]}.txt')
+    #########################################

optimal_omt-0.1.0/omt/Estimator.py

@@ -0,0 +1,138 @@
+from sklearn.base import BaseEstimator, ClassifierMixin
+from .ORToolsClassifier import optimal_OMT
+import pandas as pd
+import numpy as np
+
+class OptimalModelTreeClassifier(BaseEstimator, ClassifierMixin):
+
+    def __init__(
+        self,
+        splits=1,
+        C=1.0,
+        timeout=60,
+        split_type="Parallel",
+        model_tree=True,
+        random_seed=7,
+        super_sparse_integers=True,
+        meta=False,
+        ww=False,
+        sum_to_zero=False,
+        console_log=True,
+    ):
+        self.splits = splits
+        self.C = C
+        self.timeout = timeout
+        self.split_type = split_type
+        self.model_tree = model_tree
+        self.random_seed = random_seed
+        self.super_sparse_integers = super_sparse_integers
+        self.meta = meta
+        self.ww = ww
+        self.sum_to_zero = sum_to_zero
+        self.console_log = console_log
+
+    def fit(self, X, y):
+
+        if not isinstance(X, pd.DataFrame):
+            X = pd.DataFrame(X)
+
+        # FORCE y INTO 1D
+        y = np.asarray(y).ravel()
+        df = X.copy()
+        df["target"] = y
+
+        features = list(X.columns)
+        labels = ("target", np.unique(y))
+
+        config = {
+            "RandomSeed": self.random_seed,
+            "ProbType": "Classification",
+            "ModelTree": self.model_tree,
+            "SplitType": self.split_type,
+            "Timeout": self.timeout,
+            "Meta": self.meta,
+            "WW": self.ww,
+            "SuperSparseIntegers": self.super_sparse_integers,
+            "SumToZero": self.sum_to_zero,
+            "ConsoleLog": self.console_log,
+            "df_name": "sklearn",
+        }
+
+        self.tree_, self.runtime_ = optimal_OMT(
+            df=df,
+            features=features,
+            labels=labels,
+            Splits=self.splits,
+            C=self.C,
+            config=config,
+        )
+
+        self.classes_ = np.unique(y)
+        self.model_ = self.tree_
+        self.built_tree_ = self.tree_.build_tree(self.tree_.root.value)
+
+        return self
+
+    def predict(self, X):
+
+        if not isinstance(X, pd.DataFrame):
+            X = pd.DataFrame(X)
+
+        X_dict = X.to_dict("index")
+
+        preds = self.model_.predict_class(
+            X_dict,
+            self.built_tree_,
+            None,
+        )
+
+        return np.asarray(preds)
+
+# from sklearn.model_selection import train_test_split
+# from sklearn.model_selection import GridSearchCV, cross_val_score
+# from sklearn.metrics import accuracy_score
+# from sklearn.utils import shuffle
+# from DatabaseParser import DataParser
+
+# if __name__ == "__main__":
+#     clf = OptimalModelTreeClassifier(
+#         splits=1,
+#         C=1
+#     )
+#
+#     ProbType = 'Classification'
+#     file = 'blogger'
+#     df = DataParser(f'{file}.arff', ProbType, one_hot=True)
+#     df = shuffle(df,random_state=7)
+#
+#     X = df.loc[ : , df.columns != 'class']
+#     y = df['class']
+
+    # data = load_df(as_frame=True)
+    # X = data.data
+    # y = data.target
+
+    # X_train, X_test, y_train, y_test = train_test_split(
+    #     X,
+    #     y,
+    #     test_size=0.2,
+    #     stratify=y,
+    #     random_state=7
+    # )
+    #
+    # clf.fit(X_train,y_train)
+    # y_pred = clf.predict(X_test)
+    # acc = accuracy_score(y_test, y_pred)
+    # print("Test accuracy:", acc)
+
+    # cross_val_score(clf, X, y, cv=3)
+    # grid = GridSearchCV(
+    #     OptimalModelTreeClassifier(),
+    #     {"C": [0.1, 1, 10], "splits": [1, 2]},
+    #     cv=3
+    # )
+    # print('Grid Search')
+    # grid.fit(X, y)
+    # y_pred = clf.predict(X_test)
+    # acc = accuracy_score(y_test, y_pred)
+    # print("Test accuracy:", acc)

optimal_omt-0.1.0/omt/ORToolsClassifier.py

@@ -0,0 +1,577 @@
+import numpy as np
+from time import process_time as tm
+from ortools.linear_solver import pywraplp
+from binarytree import build
+from .TreeStructure import OptimalTree,Parent
+
+
+def optimal_OMT(df, features, labels, Splits, C, config):
+
+    gamma = 1 # this is the margin of the SVMs
+
+    df = df.reset_index(drop=True)
+    I = df.index.values
+
+    classes = df[labels[0]].unique()
+
+    LabelsPerClass = {
+        c: {
+            i: 1 if df.loc[i, labels[0]] == c else -1
+            for i in I
+        }
+        for c in classes
+    }
+
+    mu = {
+        feature: min([abs(first - second)
+                      for first, second in zip(df[feature][:-1], df[feature][1:])
+                      if second != first
+                      ])
+        for feature in features
+    }
+
+    mu_min = min(mu.values())
+
+    # depth of the tree DOES NOT include root level
+    nodes = [i for i in range(2 ** (int(np.ceil(np.log2(Splits + 1))) + 1) - 1)]
+    binary_tree = build(nodes)
+    root = binary_tree.levels[0][0]
+
+    # print(binary_tree)
+
+    T_L = [i.value for i in binary_tree.leaves]  # leave nodes
+    T_B = [i for i in binary_tree.values if i not in T_L] # branch nodes
+
+    A_l = {
+        i: [j.value for j in list(root) if j != i and j.left != None and i in j.left.values] for i in binary_tree.values
+    }
+
+    A_r = {
+        i: [j.value for j in list(root) if j != i and j.left != None and i in j.right.values] for i in
+        binary_tree.values
+    }
+
+    D_l = {
+            i : [k.value for k in j.left.leaves]
+            for i in T_B
+            for j in list(root)
+            if j.value == i
+            }
+
+    D_r = {
+        i: [k.value for k in j.right.leaves]
+        for i in T_B
+        for j in list(root)
+        if j.value == i
+    }
+
+
+    P = {
+        i: Parent(root, i) for i in binary_tree.values
+    }
+
+    m = pywraplp.Solver.CreateSolver("SCIP")
+
+    if m is None:
+        raise RuntimeError("SCIP not available")
+
+    INF = m.infinity()
+
+    # m.setParam('Threads',1)
+    m.SetTimeLimit( int(config["Timeout"] * 60 * 1000) )
+
+    feature_bounds = {}
+
+    for f in features:
+        mn = float(df[f].min())
+
+        mx = float(df[f].max())
+
+        feature_bounds[f] = (mn, mx)
+
+    M = (
+        sum(max(abs(df[f].min()), abs(df[f].max())) for f in features)
+        +
+        max(abs(df[f].min()), abs(df[f].max()))
+    )
+
+    # ==================================================
+    # VARIABLES
+    # ==================================================
+
+    d = { t: m.BoolVar(f"d[{t}]") for t in T_B }
+
+    # Parallel split variables
+    a = {
+        (f, t): m.BoolVar(f"a[{f},{t}]")
+          for f in features
+        for t in T_B
+    }
+
+    b = {
+        t: m.NumVar(-INF, INF, f"b[{t}]")
+        for t in T_B
+    }
+
+    z = {
+        (i, l): m.BoolVar(f"z[{i},{l}]")
+        for i in I
+        for l in T_L
+    }
+
+    lvar = {
+        t: m.BoolVar(f"l[{t}]")
+        for t in T_L
+    }
+
+    # ==================================================
+    # LEAF SVM
+    # ==================================================
+
+    binary_case = len(classes) == 2
+
+    if binary_case:
+        Beta = {
+            (f, t): m.NumVar(-INF, INF, f"Beta[{f},{t}]")
+            for f in features
+            for t in T_L
+        }
+
+        Bet_abs = {
+            (f, t): m.NumVar(0, INF, f"Bet_abs[{f},{t}]")
+            for f in features
+            for t in T_L
+        }
+
+        Delta = {
+            t: m.NumVar(-INF, INF, f"Delta[{t}]")
+            for t in T_L
+        }
+
+        e = {
+            (i, t): m.NumVar(0, INF, f"e[{i},{t}]")
+            for i in I
+            for t in T_L
+        }
+
+    else:
+        Beta = {
+            (c, f, t): m.NumVar(
+                -INF,
+                INF,
+                f"Beta[{c},{f},{t}]"
+            )
+            for c in classes
+            for f in features
+            for t in T_L
+        }
+        Bet_abs = {
+            (c, f, t): m.NumVar(
+                0,
+                INF,
+                f"Bet_abs[{c},{f},{t}]"
+            )
+            for c in classes
+            for f in features
+            for t in T_L
+        }
+        Delta = {
+            (c, t): m.NumVar(
+                -INF,
+                INF,
+                f"Delta[{c},{t}]"
+            )
+            for c in classes
+            for t in T_L
+        }
+        e = {
+            (c, i, t): m.NumVar(
+                0,
+                INF,
+                f"e[{c},{i},{t}]"
+            )
+            for c in classes
+            for i in I
+            for t in T_L
+        }
+
+    # ==================================================
+    # SPLIT STRUCTURE
+    # ==================================================
+
+    for t in T_B:
+        m.Add(
+            sum(a[f, t] for f in features)
+            == d[t]
+        )
+    for t in [i for i in T_B if i != root.value]:
+        m.Add(d[t] <= d[P[t]])
+
+    # ==================================================
+    # LEAF OCCUPANCY
+    # ==================================================
+
+    for t in T_L:
+        for i in I:
+            m.Add(z[i, t] <= lvar[t])
+
+    for t in T_L:
+        m.Add(
+            sum(z[i, t] for i in I)
+            >= lvar[t]
+        )
+    for i in I:
+        m.Add(
+            sum(z[i, t] for t in T_L)
+            == 1
+        )
+
+    # ==================================================
+    # ROUTING CONSTRAINTS
+    # Indicator -> Big-M
+    # ==================================================
+
+    for i in I:
+        for leaf in T_L:
+            # LEFT
+            for t in A_l[leaf]:
+                m.Add(
+                    sum(
+                        a[f, t]
+                        * (df.loc[i, f] + mu[f] - mu_min)
+                        for f in features
+                    )
+                    + mu_min
+                    <=
+                    b[t] + M * (1 - z[i, leaf])
+                )
+
+            # RIGHT
+            for t in A_r[leaf]:
+                m.Add(
+                    sum( a[f, t] * df.loc[i, f] for f in features )
+                    >=
+                    b[t] - M * (1 - z[i, leaf])
+                )
+
+    # ==================================================
+
+    # ACTIVE SPLIT => NONEMPTY DESCENDANTS
+
+    # ==================================================
+
+    for t in T_B:
+        m.Add(
+            d[t] <= sum( lvar[k] for k in D_l[t] )
+        )
+
+        m.Add(
+            d[t] <= sum( lvar[k] for k in D_r[t] )
+        )
+
+    # ==================================================
+    # LEAF CLASSIFIERS
+    # ==================================================
+
+    if binary_case:
+        # assumes labels encoded {-1,+1}
+        for i in I:
+            yi = float(df.loc[i, labels[0]])
+            for t in T_L:
+                svm_expr = (
+
+                        sum(
+
+                            Beta[f, t]
+
+                            * df.loc[i, f]
+
+                            for f in features
+
+                        )
+
+                        + Delta[t]
+
+                )
+
+                m.Add(
+
+                    gamma
+
+                    - e[i, t]
+
+                    <= svm_expr * yi
+
+                    + M * (1 - z[i, t])
+
+                )
+
+        # abs(Beta)
+
+        for f in features:
+
+            for t in T_L:
+                m.Add(
+
+                    Bet_abs[f, t]
+
+                    >= Beta[f, t]
+
+                )
+
+                m.Add(
+
+                    Bet_abs[f, t]
+
+                    >= -Beta[f, t]
+
+                )
+
+    else:
+
+        for c in classes:
+
+            for i in I:
+
+                for t in T_L:
+                    svm_expr = (
+
+                            sum(
+
+                                Beta[c,f,t]
+
+                                * df.loc[i, f]
+
+                                for f in features
+
+                            )
+
+                            + Delta[c,t]
+
+                    )
+
+                    m.Add(
+
+                        gamma
+
+                        - e[c,i,t]
+
+                        <= svm_expr
+
+                        * LabelsPerClass[c][i]
+
+                        + M * (1 - z[i, t])
+
+                    )
+
+        for c in classes:
+
+            for f in features:
+
+                for t in T_L:
+                    m.Add(
+
+                        Bet_abs[c,f,t]
+
+                        >= Beta[c,f,t]
+
+                    )
+
+                    m.Add(
+
+                        Bet_abs[c,f,t]
+
+                        >= -Beta[c,f,t]
+
+                    )
+
+    # ==================================================
+    # SPLIT BUDGET
+    # ==================================================
+
+    m.Add( sum(d[t] for t in T_B) <= Splits )
+
+    # ==================================================
+    # OBJECTIVE
+    # ==================================================
+
+    if binary_case:
+
+        objective = (
+
+                sum( Bet_abs[f, t] for f in features for t in T_L )
+                +
+                C * sum( e[i, t]
+
+            for i in I
+
+            for t in T_L
+
+        )
+
+        )
+
+    else:
+
+        objective = (
+
+                sum(
+
+                    Bet_abs[c,f,t]
+
+                    for c in classes
+
+                    for f in features
+
+                    for t in T_L
+
+                )
+
+                + C * sum( e[c,i,t] for c in classes for i in I for t in T_L )
+        )
+
+    m.Minimize(objective)
+
+    start = tm()
+    status = m.Solve()
+    runtime = tm() - start
+
+    splitting_nodes = {}
+
+    if status != pywraplp.Solver.INFEASIBLE:
+        vars = m.variables()
+        solution = {
+                i.name():i.solution_value()
+                for i in vars}
+
+        non_zero_vars = [key for key,value in solution.items() if value > 0]
+
+        if config["SplitType"] == "Parallel":
+            splitting_nodes = {
+                i:{
+                    'a': [f for f in features if solution[f'a[{f},{i}]'] > 0][0],
+                    'b': round(solution[f'b[{i}]'],6)
+                }
+                for i in T_B if f'd[{i}]' in non_zero_vars
+            }
+        elif config["SplitType"] == "Oblique":
+            splitting_nodes = {
+                i: {
+                    'a': {f: round(solution[f'a[{f},{i}]'], 6)
+                          for f in features
+                          },
+                    'b': round(solution[f'b[{i}]'], 6)
+                }
+                for i in T_B if f'd[{i}]' in non_zero_vars
+            }
+        if len(classes) == 2:
+            non_empty_nodes = {
+                i: {
+                    'Beta': {
+                        j: round(solution[f'Beta[{j},{i}]'], 6)
+                        for j in features
+                    },
+                    'Delta': round(solution[f'Delta[{i}]'], 6)
+                }
+                for i in T_L if f'l[{i}]' in non_zero_vars
+            }
+        else:
+            non_empty_nodes = {
+                i:{
+                    c:{
+                        'Beta':{
+                            j: round(solution[f'Beta[{c},{j},{i}]'],6)
+                            for j in features
+                        },
+                        'Delta':round(solution[f'Delta[{c},{i}]'],6)
+                    }
+                    for c in classes
+                }
+                for i in T_L if f'l[{i}]' in non_zero_vars
+            }
+
+        ODT = OptimalTree(
+            non_empty_nodes,
+            splitting_nodes,
+            int(np.ceil(np.log2(Splits + 1))),
+            config["SplitType"],
+            True,
+            classes
+        )
+
+    else:
+        print('MODEL IS INFEASIBLE')
+        ODT = None
+
+    return ODT,runtime
+
+# from sklearn.metrics import accuracy_score
+# from sklearn.utils import shuffle
+# from DatabaseParser import DataParser
+# if __name__ == "__main__":
+#
+#     ProbType = 'Classification'
+#     TestSize = 0.2
+#     file = 'blogger'
+#     Splits = 1
+#
+#     config ={
+#         'RandomSeed':7,
+#         'SplitType': 'Parallel',
+#         'label_name': 'class',
+#         'Timeout': 60,  # for the single iteration (IN MINUTES)
+#         'ConsoleLog':False
+#     }
+#
+#     df = DataParser(f'{file}.arff',ProbType, one_hot=True)
+#
+#     df = shuffle(df,random_state=config['RandomSeed'])
+#
+#     Test_df = df.iloc[:round(len(df) * TestSize)]
+#     Train_df = df.iloc[len(Test_df):]
+#
+#     # ELIMIATING A COLUMN FROM ALL DATASETS IF ALL THE VALUES IN IT ARE THE SAME IN THE TRAIN SET
+#     for i in Train_df.columns:
+#         if Train_df[i].nunique() == 1:
+#             Train_df = Train_df.drop(columns=[i])
+#             Test_df = Test_df.drop(columns=[i])
+#
+#     features = list(Train_df.columns.drop(['class']))
+#     labels = df['class'].unique()
+#     labels = ('class', labels)
+#
+#     for C in [1]:#[0.1, 1, 10, 100]:
+#         ODT,runtime = optimal_OMT(
+#             df= Train_df,
+#             features= features,
+#             labels= labels,
+#             Splits= Splits,
+#             C= C,
+#             config=config
+#         )
+#
+#         print('Runtime:',round(runtime,3),end=" ")
+#         print('C:',C,end=' ')
+#         the_tree = ODT.build_tree(ODT.root.value)
+#         # ODT.print_tree(the_tree)
+#
+#         # split train into features and labels
+#         X_train = Train_df.drop(columns='class')
+#         X_train = X_train.to_dict('index')
+#         Y_train = Train_df['class']
+#
+#         # split test set into features and labels
+#         X_test = Test_df.drop(columns='class')
+#         X_test = X_test.to_dict('index')
+#         Y_test = Test_df['class']
+#
+#         # Predict the train set
+#         train_pred = ODT.predict_class(X_train, the_tree, None)
+#         print('Train:', round(accuracy_score(Y_train, train_pred) * 100, 2), '%',end=' ')
+#
+#         # Predict the test set
+#         test_pred = ODT.predict_class(X_test, the_tree,None)
+#         print('Test:', round(accuracy_score(Y_test, test_pred)*100,2),'%')
+
+
+

optimal_omt-0.1.0/omt/TreeStructure.py

@@ -0,0 +1,226 @@
+import numpy as np
+import pandas as pd
+from binarytree import build
+
+
+class Node():
+    def __init__(self, name=None, feature=None, threshold=None, left=None, right=None, value=None):
+        # decision node
+        self.name = name
+        self.feature = feature
+        self.threshold = threshold
+        self.left = left
+        self.right = right
+        # leaf node
+        self.value = value
+
+    def __str__(self):
+        return f'Node {self.name}, feature {self.feature}, threshold {self.threshold}'
+
+class OptimalTree():
+    def __init__(self, non_empty_nodes,splitting_nodes,depth,SplitType='Parallel',ModelTree=True,classes=[]):
+        self.non_emtpy_nodes = non_empty_nodes
+        self.splitting_nodes = splitting_nodes
+        self.depth = depth
+        self.SplitType = SplitType
+        self.ModelTree = ModelTree
+        self.nodes = [i for i in range(2 ** (depth + 1) - 1)]
+        self.classes = classes
+
+        self.complete_tree = build(self.nodes)
+        self.T_L = [i.value for i in self.complete_tree.leaves]  # leave nodes
+        self.T_B = [i for i in self.complete_tree.values if i not in self.T_L]
+        self.root = self.complete_tree.levels[0][0]
+
+    def build_tree(self, current_node):
+
+        if current_node in self.splitting_nodes:
+            left_subtree = self.build_tree( Children(self.root,current_node)[0].value)
+            right_subtree = self.build_tree(Children(self.root, current_node)[1].value)
+            return Node(
+                current_node,
+                self.splitting_nodes[current_node]['a'],
+                self.splitting_nodes[current_node]['b'],
+                left_subtree,
+                right_subtree
+            )
+        elif current_node in self.non_emtpy_nodes:
+            return Node(
+                current_node,
+                value = self.non_emtpy_nodes[current_node]
+            )
+        else:
+            descendants = [i for i in self.non_emtpy_nodes if current_node in Ancestors(self.root,i)]
+            if len(descendants) > 0:
+                return Node(
+                    current_node,
+                    value=self.non_emtpy_nodes[descendants[0]]
+                )
+            else:
+                raise ValueError('THE TREE HAS TO MANY SPLITS')
+
+    def print_tree(self,tree, indent=" "):
+
+        if tree is not None:
+            print('Node',tree.name)
+            if tree.value is not None:
+                print(tree.value)
+            else:
+                print(f'{str(tree.feature)} < {tree.threshold} ')
+                print(f'{indent}left:', end="")
+                self.print_tree(tree.left, indent + indent)
+                print('%sright:' % (indent), end="")
+                self.print_tree(tree.right, indent + indent)
+        else:
+            print('No Node')
+
+    def predict_regr(self, X, tree,f2=None):
+        '''function to predict_regr a new dataset'''
+        predictions = [self.make_regression(x, tree,f2) for x in X.values()]
+        return predictions
+
+    def make_regression(self, x, tree,f2=None):
+        '''function to make a single prediction'''
+        features = f2 if f2 != None else x
+        if self.ModelTree:
+            if tree.value != None:
+                return sum([ tree.value['Beta'][f] * x[f] for f in features]) + tree.value['Delta']
+        else:
+            if tree.value != None:
+                return tree.value
+
+        if self.SplitType == 'Parallel':
+            if x[tree.feature] < tree.threshold:
+                return self.make_regression(x, tree.left,f2)
+            else:
+                return self.make_regression(x, tree.right,f2)
+        elif self.SplitType == 'Oblique':
+            if sum([x[key] * value for key, value in tree.feature.items()]) < tree.threshold:
+                return self.make_regression(x, tree.left,f2)
+            else:
+                return self.make_regression(x, tree.right,f2)
+
+
+    def predict_class(self, X, tree,f2=None):
+        '''function to predict_regr a new dataset'''
+        predictions = [self.make_classification(x, tree,f2) for x in X.values()]
+        return predictions
+
+    def make_classification(self, x, tree,f2=None):
+        '''function to make a single prediction'''
+        features = f2 if f2 != None else x
+
+        if self.ModelTree:
+            if tree.value != None:
+                if len(self.classes)>2:
+                    scores = {
+                        c:sum([tree.value[c]['Beta'][f] * x[f] for f in features]) + tree.value[c]['Delta']
+                        for c in self.classes
+                    }
+                    return max(scores, key=scores.get)
+
+                else:
+                    return 1 if sum([ tree.value['Beta'][f] * x[f] for f in features]) + tree.value['Delta'] > 0 else -1
+        else:
+            if tree.value != None:
+                return tree.value
+        if self.SplitType == 'Parallel':
+            if x[tree.feature] < tree.threshold:
+                return self.make_classification(x, tree.left,f2)
+            else:
+                return self.make_classification(x, tree.right,f2)
+        elif self.SplitType == 'Oblique':
+            if sum([x[key] * value for key, value in tree.feature.items()]) < tree.threshold:
+                return self.make_classification(x, tree.left,f2)
+            else:
+                return self.make_classification(x, tree.right,f2)
+
+# Some additional functions needed to deal with binary trees
+
+def Ancestors(root, target):
+    ancestors = []
+
+    def findAncestors(root, target):
+        # Base case
+        if root == None:
+            return False
+
+        if root.value == target:
+            return True
+
+        # If target is present in either left or right subtree
+        # of this node, then print this node
+        if (findAncestors(root.left, target) or
+                findAncestors(root.right, target)):
+            ancestors.append(root.value)
+            # print(root.value,end=' ')
+            return True
+
+        # Else return False
+        return False
+
+    findAncestors(root, target)
+    return ancestors
+
+def Parent(node, val):
+    the_parent = []
+
+    def findParent(node, val, parent=None):
+        if (node is None):
+            return
+
+            # If current node is the required node
+        if (node.value == val):
+            # assign its parent
+            the_parent.append(parent)
+
+        else:
+            # Recursive calls for the children of the current node. current node is now the new parent
+            findParent(node.left, val, node.value)
+            findParent(node.right, val, node.value)
+
+    findParent(node, val)
+    return the_parent[0]
+
+def Children(node, val):
+    children = {}
+    def findChildren(node, val):
+        if (node is None):
+            return
+
+        # # If current node is the required node
+        if (node.value == val):
+            # assign its parent
+            children.update({'left':node.left,'right':node.right})
+
+        else:
+            # Recursive calls for the children of the current node. current node is now the new parent
+            findChildren(node.left, val)
+            findChildren(node.right, val)
+
+    findChildren(node, val)
+    return children['left'],children['right']
+
+def RAE(Y_labels,Y_predicted):
+    mean_Y = np.average(Y_labels)
+    numerator = sum([ abs(i-j) for i,j in zip(Y_predicted,Y_labels)])
+    denominator = sum([abs(mean_Y - j) for j in Y_labels])
+    return round(numerator/denominator,2)
+
+def RRSE(Y_labels,Y_predicted):
+    mean_Y = np.average(Y_labels)
+    numerator = sum([ (i-j)**2 for i,j in zip(Y_predicted,Y_labels)])
+    denominator = sum([ (mean_Y - j)**2 for j in Y_labels])
+    return round(np.sqrt(numerator/denominator),2)
+
+def Multiplier(vector):
+    theVec = []
+    for i in vector:
+        if '.' in str(i):
+            theVec.append(len(str(i).split('.')[1]))
+        else:
+            theVec.append(0)
+    return 10**max(theVec)
+
+if __name__ == "__main__":
+    print(Multiplier([2.01,3.0101]))

optimal_omt-0.1.0/omt/__init__.py

@@ -0,0 +1,3 @@
+from.Estimator import OptimalModelTreeClassifier
+
+__all_= ["OptimalModelTreeClassifier"]

optimal_omt-0.1.0/optimal_omt.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: optimal-omt
+Version: 0.1.0
+Summary: Optimal Model Trees using OR-Tools
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: binarytree
+Requires-Dist: ortools
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"

optimal_omt-0.1.0/optimal_omt.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+omt/DatabaseParser.py
+omt/Estimator.py
+omt/ORToolsClassifier.py
+omt/TreeStructure.py
+omt/__init__.py
+optimal_omt.egg-info/PKG-INFO
+optimal_omt.egg-info/SOURCES.txt
+optimal_omt.egg-info/dependency_links.txt
+optimal_omt.egg-info/requires.txt
+optimal_omt.egg-info/top_level.txt

optimal_omt-0.1.0/optimal_omt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

optimal_omt-0.1.0/optimal_omt.egg-info/requires.txt

@@ -0,0 +1,8 @@
+numpy
+pandas
+scikit-learn
+binarytree
+ortools
+
+[dev]
+pytest

optimal_omt-0.1.0/optimal_omt.egg-info/top_level.txt

@@ -0,0 +1 @@
+omt

optimal_omt-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "optimal-omt"
+version = "0.1.0"
+description = "Optimal Model Trees using OR-Tools"
+readme = "README.md"
+requires-python = ">=3.9"
+
+dependencies = [
+    "numpy",
+    "pandas",
+    "scikit-learn",
+    "binarytree",
+    "ortools"
+]
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[tool.setuptools]
+packages = ["omt"]

optimal_omt-0.1.0/setup.cfg

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