From 660eab2a879b63f0a86dab6ff14ccbc2e42900bc Mon Sep 17 00:00:00 2001
From: parthgvora <parthgvora@gmail.com>
Date: Thu, 12 Nov 2020 20:55:10 -0500
Subject: [PATCH 01/17] staging branch finally

---
 proglearn/oblique_tree.py            | 564 +++++++++++++++++++++++++++
 proglearn/tests/oblique_tree_test.py | 125 ++++++
 proglearn/transformers.py            |  62 +++
 3 files changed, 751 insertions(+)
 create mode 100644 proglearn/oblique_tree.py
 create mode 100644 proglearn/tests/oblique_tree_test.py

diff --git a/proglearn/oblique_tree.py b/proglearn/oblique_tree.py
new file mode 100644
index 0000000000..e5eedcfec3
--- /dev/null
+++ b/proglearn/oblique_tree.py
@@ -0,0 +1,564 @@
+"""
+Parth Vora
+
+Oblique Decision Tree (SPORF)
+"""
+import numpy as np
+from sklearn.base import BaseEstimator
+from sklearn.random_projection import SparseRandomProjection
+
+# debugging
+import sys
+# Parallelize things later
+from joblib import Parallel, delayed
+
+#--------------------------------------------------------------------------
+class SplitInfo:
+    """
+    A class used to store information about a certain split.
+
+    Parameters:
+    ---
+    feature : int
+        The feature which is used for the particular split.
+    threshold : float
+        The feature value which defines the split, if an example has a value less
+        than this threshold for the feature of this split then it will go to the
+        left child, otherwise it wil go the right child where these children are
+        the children nodes of the node for which this split defines.
+    proj_mat : array of shape [n_components, n_features]
+        The sparse random projection matrix for this split.
+    left_impurity : float
+        This is Gini impurity of left side of the split.
+    left_idx : array of shape [left_n_samples]
+        This is the indices of the nodes that are in the left side of this split.
+    left_n_samples : int
+        The number of samples in the left side of this split.
+    right_impurity : float
+        This is Gini impurity of right side of the split.
+    right_idx : array of shape [right_n_samples]
+        This is the indices of the nodes that are in the right side of this split.
+    right_n_samples : int
+        The number of samples in the right side of this split.
+    no_split : bool
+        A boolean specifying if there is a valid split or not. Here an invalid
+        split means all of the samples would go to one side.
+    improvement : float
+        A metric to determine if the split improves the decision tree.
+    """
+
+    def __init__(self, feature, threshold, proj_mat,
+                 left_impurity, left_idx, left_n_samples,
+                 right_impurity, right_idx, right_n_samples,
+                 no_split, improvement):
+
+        self.feature = feature
+        self.threshold = threshold
+        self.proj_mat = proj_mat
+        self.left_impurity = left_impurity
+        self.left_idx = left_idx
+        self.left_n_samples = left_n_samples
+        self.right_impurity = right_impurity
+        self.right_idx = right_idx
+        self.right_n_samples = right_n_samples
+        self.no_split = no_split
+        self.improvement = improvement
+
+class ObliqueSplitter:
+    """
+    A class used to represent an oblique splitter, where splits are done on
+    the linear combination of the features.
+
+    Parameters:
+    ---
+    X : array of shape [n_samples, n_features]
+        The input data X is a matrix of the examples and their respective feature
+        values for each of the features.
+    y : array of shape [n_samples]
+        The labels for each of the examples in X.
+    proj_dims : int
+        The dimensionality of the target projection space.
+    density : float
+        Ratio of non-zero component in the random projection matrix in the range '(0, 1]'.
+    random_state : int
+        Controls the pseudo random number generator used to generate the projection matrix.
+
+    Methods
+    ---
+    sample_proj_mat(sample_inds)
+        This gets the projection matrix and it fits the transform to the samples of interest.
+    leaf_label_proba(idx)
+        This calculates the label and the probability for that label for a particular leaf
+        node.
+    score(y_sort, t)
+        Finds the Gini impurity for a split.
+    impurity(idx)
+        Finds the impurity for a certain set of samples.
+    split(sample_inds)
+        Determines the best possible split for the given set of samples.
+    """
+
+    def __init__(self, X, y, proj_dims, density, random_state):
+
+        self.X = X
+        self.y = y
+
+        self.classes = np.array(np.unique(y), dtype=int)
+        self.n_classes = len(self.classes)
+        self.indices = np.indices(y.shape)[0]
+
+        self.n_samples = X.shape[0]
+
+        self.proj_dims = proj_dims
+        self.density = density
+        self.random_state = random_state
+
+    def sample_proj_mat(self, sample_inds):
+        """
+        Gets the projection matrix and it fits the transform to the samples of interest.
+
+        Parameters
+        ---
+        sample_inds : array of shape [n_samples]
+            The data we are transforming.
+        """
+
+        proj_mat = SparseRandomProjection(density=self.density,
+                                         n_components=self.proj_dims,
+                                         random_state=self.random_state)
+        
+        proj_X = proj_mat.fit_transform(self.X[sample_inds, :])
+        return proj_X, proj_mat
+
+    def leaf_label_proba(self, idx):
+        """
+        Finds the most common label and probability of this label from the samples at
+        the leaf node for which this is used on.
+
+        Parameters
+        ---
+        idx : array of shape [n_samples]
+            The indeces of the samples that are at the leaf node for which the label
+            and probability need to be found.
+        """
+
+        samples = self.y[idx]
+        n = len(samples)
+        labels, count = np.unique(samples, return_counts=True)
+        most = np.argmax(count)
+
+        label = labels[most]
+        proba = count[most] / n
+
+        return label, proba
+
+    # Returns gini impurity for split
+    # Expects 0 < t < n
+    def score(self, y_sort, t):
+        """
+        Finds the Gini impurity for the split of interest
+
+        Parameters
+        ---
+        y_sort : array of shape [n_samples]
+            A sorted array of labels for the examples for which the Gini impurity
+            is being calculated.
+        t : float
+            The threshold determining where to split y_sort.
+        """
+
+        left = y_sort[:t]
+        right = y_sort[t:]
+
+        n_left = len(left)
+        n_right = len(right)
+
+        left_unique, left_counts = np.unique(left, return_counts=True)
+        right_unique, right_counts = np.unique(right, return_counts=True)
+  
+        left_counts = left_counts / n_left
+        right_counts = right_counts / n_right
+
+        left_gini = 1 - np.sum(np.power(left_counts, 2))
+        right_gini = 1 - np.sum(np.power(right_counts, 2))
+
+        gini = (n_left / self.n_samples) * left_gini + (n_right / self.n_samples) * right_gini
+        return gini
+
+    # Returns impurity for a group of examples
+    # expects idx not None
+    def impurity(self, idx):
+        """
+        Finds the actual impurity for a set of samples
+
+        Parameters
+        ---
+        idx : array of shape [n_samples]
+            The indices of the nodes in the set for which the impurity is being calculated.
+        """
+
+        samples = self.y[idx]
+        n = len(samples)
+
+        if n == 0:
+            return 0
+
+        unique, count = np.unique(samples, return_counts=True)
+        count = count / n
+        gini = np.sum(np.power(count, 2))
+
+        return 1 - gini
+    
+    # Finds the best split
+    # This needs to be parallelized; its a major bottleneck
+    def split(self, sample_inds):
+        """
+        Finds the optimal split for a set of samples.
+        Note that the code for this method needs to be parallelized. This is a major
+        bottleneck in integration with scikit-learn.
+
+        Parameters
+        ---
+        sample_inds : array of shape [n_samples]
+            The indices of the nodes in the set for which the best split is found.
+        """
+
+        # Project the data
+        proj_X, proj_mat = self.sample_proj_mat(sample_inds)
+        y_sample = self.y[sample_inds]
+        n_samples = len(sample_inds)
+
+        # Score matrix
+        # No split score is just node impurity
+        Q = np.zeros((n_samples, self.proj_dims))
+        node_impurity = self.impurity(sample_inds)
+        Q[0, :] = node_impurity
+        Q[-1, :] = node_impurity
+
+        # Loop through projected features and examples to find best split
+        # This can be parallelized for sure
+        for j in range(self.proj_dims):
+
+            # Sort labels by the jth feature
+            idx = np.argsort(proj_X[:, j])
+            y_sort = y_sample[idx]
+
+            Q[1:-1, j] = np.array([self.score(y_sort, i) for i in range(1, n_samples - 1)])
+
+        # Identify best split feature, minimum gini impurity
+        best_split_ind = np.argmin(Q)
+        thresh_i, feature = np.unravel_index(best_split_ind, Q.shape)
+        best_gini = Q[thresh_i, feature]
+
+        # Sort samples by the split feature
+        feat_vec = proj_X[:, feature]
+        idx = np.argsort(feat_vec)
+        
+        feat_vec = feat_vec[idx]
+        sample_inds = sample_inds[idx]
+
+        # Get the threshold, split samples into left and right
+        threshold = feat_vec[thresh_i]
+        left_idx = sample_inds[:thresh_i]
+        right_idx = sample_inds[thresh_i:]
+
+        left_n_samples = len(left_idx)
+        right_n_samples = len(right_idx)
+
+        # See if we have no split
+        no_split = (left_n_samples == 0 or
+                    right_n_samples == 0)
+
+        # Evaluate improvement
+        improvement = node_impurity - best_gini
+
+        # Evaluate impurities for left and right children
+        left_impurity = self.impurity(left_idx)
+        right_impurity = self.impurity(right_idx)
+
+        split_info = SplitInfo(feature, threshold, proj_mat,
+                      left_impurity, left_idx, left_n_samples,
+                      right_impurity, right_idx, right_n_samples,
+                      no_split, improvement)
+
+        return split_info
+#--------------------------------------------------------------------------
+
+class Node:
+    def __init__(self): 
+        
+        self.node_id = None
+        self.is_leaf = None
+        self.parent = None
+        self.left_child = None
+        self.right_child = None
+        
+        self.feature = None
+        self.threshold = None
+        self.impurity = None
+        self.n_samples = None
+        
+        self.proj_mat = None
+        self.label = None
+        self.proba = None
+
+class StackRecord:
+    def __init__(self, parent, depth, is_left, 
+                 impurity, sample_idx, n_samples):
+
+        self.parent = parent
+        self.depth = depth
+        self.is_left = is_left
+        self.impurity = impurity
+        self.sample_idx = sample_idx
+        self.n_samples = n_samples
+
+class ObliqueTree:
+    
+    def __init__(self, splitter, min_samples_split, min_samples_leaf,
+                 max_depth, min_impurity_split, min_impurity_decrease):
+        
+        # Tree parameters
+        #self.n_samples = n_samples
+        #self.n_features = n_features
+        #self.n_classes = n_classes
+        self.depth = 0
+        self.node_count = 0
+        self.nodes = []
+
+        # Build parameters
+        self.splitter = splitter
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        self.max_depth = max_depth
+        self.min_impurity_split = min_impurity_split
+        self.min_impurity_decrease = min_impurity_decrease
+
+
+
+    def add_node(self, parent, is_left, 
+                 impurity, n_samples, is_leaf, 
+                 feature, threshold, proj_mat,
+                 label, proba):
+        
+        node = Node()
+        node.node_id = self.node_count
+        node.impurity = impurity
+        node.n_samples = n_samples
+
+        # If not the root node, set parents
+        if self.node_count > 0:
+            node.parent = parent
+            if is_left:
+                self.nodes[parent].left_child = node.node_id
+            else:
+                self.nodes[parent].right_child = node.node_id
+
+        # Set node parameters
+        if is_leaf:
+            node.is_leaf = True
+            node.label = label
+            node.proba = proba
+        else:
+            node.is_leaf = False
+            node.feature = feature
+            node.threshold = threshold
+            node.proj_mat = proj_mat
+
+        self.node_count += 1
+        self.nodes.append(node)
+
+        return node.node_id
+
+    def build(self):
+
+        # Initialize, add root node
+        stack = []
+        root = StackRecord(0, 1, False,
+                           self.splitter.impurity(self.splitter.indices),
+                           self.splitter.indices,
+                           self.splitter.n_samples)
+        stack.append(root)
+       
+
+        # Build tree
+        while len(stack) > 0:
+            
+            # Pop a record off the stack
+            cur = stack.pop()
+
+
+            # Evaluate if it is a leaf
+            is_leaf = (cur.depth >= self.max_depth or
+                       cur.n_samples < self.min_samples_split or
+                       cur.n_samples < 2 * self.min_samples_leaf or
+                       cur.impurity <= self.min_impurity_split)
+
+            # Split if not
+            if not is_leaf:
+                split = self.splitter.split(cur.sample_idx)
+
+                is_leaf = (is_leaf or 
+                           split.no_split or
+                           split.improvement <= self.min_impurity_decrease)
+
+            # Add the node to the tree
+            if is_leaf:
+                
+                label, proba = self.splitter.leaf_label_proba(cur.sample_idx)
+                
+                node_id = self.add_node(cur.parent,
+                                        cur.is_left,
+                                        cur.impurity,
+                                        cur.n_samples,
+                                        is_leaf,
+                                        None,
+                                        None,
+                                        None,
+                                        label,
+                                        proba)
+
+            else:
+                node_id = self.add_node(cur.parent,
+                                        cur.is_left,
+                                        cur.impurity,
+                                        cur.n_samples,
+                                        is_leaf,
+                                        split.feature,
+                                        split.threshold,
+                                        split.proj_mat,
+                                        None,
+                                        None)
+
+
+            # Push the right and left children to the stack if applicable
+            if not is_leaf:
+
+                right_child = StackRecord(node_id,
+                                          cur.depth + 1,
+                                          False,
+                                          split.right_impurity,
+                                          split.right_idx,
+                                          split.right_n_samples)
+                stack.append(right_child)
+
+                left_child = StackRecord(node_id, 
+                                          cur.depth + 1,
+                                          True,
+                                          split.left_impurity,
+                                          split.left_idx,
+                                          split.left_n_samples)
+                stack.append(left_child)
+
+            if cur.depth > self.depth:
+                self.depth = cur.depth
+
+    def predict(self, X):
+        predictions = np.zeros(X.shape[0])
+        for i in range(X.shape[0]):
+            cur = self.nodes[0]
+            while not cur is None and not cur.is_leaf:
+                proj_X = cur.proj_mat.transform(X)
+                if proj_X[i, cur.feature] < cur.threshold:
+                    id = cur.left_child
+                    cur = self.nodes[id]
+                else:
+                    id = cur.right_child
+                    cur = self.nodes[id]
+
+            predictions[i] = cur.node_id
+
+        return predictions
+
+#--------------------------------------------------------------------------
+
+""" Class for Oblique Tree """
+class ObliqueTreeClassifier(BaseEstimator):
+
+    def __init__(self, *,
+
+                 #criterion="gini",
+                 #splitter=None,
+                 max_depth=np.inf,
+                 min_samples_split=2,
+                 min_samples_leaf=1,
+                 #min_weight_fraction_leaf=0,
+                 #max_features="auto",
+                 #max_leaf_nodes=None,
+                 random_state=None,
+                 min_impurity_decrease=0,
+                 min_impurity_split=0,
+                 #class_weight=None,
+                 #ccp_alpha=0.0,
+                 
+                 #New args
+                 feature_combinations=1.2,
+                 density=0.7
+
+                 ):
+
+        #self.criterion=criterion
+        self.max_depth=max_depth
+        self.min_samples_split=min_samples_split
+        self.min_samples_leaf=min_samples_leaf
+        #self.min_weight_fraction_leaf=min_weight_fraction_leaf
+        #self.max_features=max_features
+        #self.max_leaf_nodes=max_leaf_nodes
+        self.random_state=random_state
+        self.min_impurity_decrease=min_impurity_decrease
+        self.min_impurity_split=min_impurity_split
+        #self.class_weight=class_weight
+        #self.ccp_alpha=ccp_alpha
+
+        self.feature_combinations=feature_combinations
+        self.density=density
+
+    def fit(self, X, y):
+
+        self.proj_dims = int(np.ceil(X.shape[1]) / self.feature_combinations)
+        splitter = ObliqueSplitter(X, y, 
+                                   self.proj_dims, 
+                                   self.density,
+                                   self.random_state)
+
+        self.tree = ObliqueTree(splitter,
+                                self.min_samples_split,
+                                self.min_samples_leaf,
+                                self.max_depth,
+                                self.min_impurity_split,
+                                self.min_impurity_decrease)
+        self.tree.build()
+        return self
+
+    def apply(self, X):
+        pred_nodes = self.tree.predict(X).astype(int)
+        return pred_nodes
+    
+    def predict(self, X):
+        preds = np.zeros(X.shape[0])
+        pred_nodes = self.tree.predict(X).astype(int)
+        for k in range(len(pred_nodes)):
+            id = pred_nodes[k]
+            preds[k] = self.tree.nodes[id].label
+
+        return preds
+
+
+    def predict_proba(self, X):
+        preds = np.zeros(X.shape[0])
+        pred_nodes = self.tree.predict(X).astype(int)
+        for k in range(len(preds)):
+            id = pred_nodes[k]
+            preds[k] = self.tree.nodes[id].proba
+
+        return preds
+
+    def predict_log_proba(self, X):
+        proba = self.predict_proba(X)
+
+        for k in range(len(preds)):
+            proba[k] = np.log(proba[k])
+
+        return proba
+
+
diff --git a/proglearn/tests/oblique_tree_test.py b/proglearn/tests/oblique_tree_test.py
new file mode 100644
index 0000000000..6e9155ef38
--- /dev/null
+++ b/proglearn/tests/oblique_tree_test.py
@@ -0,0 +1,125 @@
+import pytest
+import numpy as np
+from numpy import random as rng
+from numpy.testing import assert_almost_equal, assert_warns, assert_raises
+
+import sys
+sys.path.append("../")
+from oblique_tree import *
+
+
+class TestObliqueSplitter:
+
+    def test_sample_projmat(self):
+        
+        random_state = 0
+        rng.seed(random_state)
+
+        X = rng.rand(100, 100)
+        y = np.zeros(100)
+
+        density = 0.5
+        proj_dims = [10, 20, 40, 60, 80]
+        sample_inds = [np.linspace(0, 9, 10, dtype=int),
+                       np.linspace(0, 19, 20, dtype=int), 
+                       np.linspace(0, 39, 40, dtype=int), 
+                       np.linspace(0, 59, 60, dtype=int), 
+                       np.linspace(0, 79, 80, dtype=int)]
+
+        n_sample_inds = [10, 20, 40, 60, 80]
+
+        for pd in proj_dims:
+            splitter = ObliqueSplitter(X, y, pd, density, random_state)
+
+            for i in range(len(n_sample_inds)):
+                si = sample_inds[i]
+                n = n_sample_inds[i]
+
+                proj_X, projmat = splitter.sample_proj_mat(si)
+                assert n == proj_X.shape[0]
+                assert pd == proj_X.shape[1]
+
+    def test_score(self):
+
+        random_state = 0
+        rng.seed(random_state)
+
+        X = rng.rand(11, 11)
+
+        density = 0.5
+        proj_dims = 5
+
+        y = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
+        splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
+
+        score = splitter.score(y, 6)
+        assert 0 == score
+
+        score = splitter.score(y, 1)
+        assert_almost_equal(5/11, score)
+
+    def test_impurity(self):
+       
+        random_state = 0
+        rng.seed(random_state)
+
+        X = rng.rand(100, 100)
+
+        density = 0.5
+        proj_dims = 50
+
+        y = np.zeros(100)
+        for i in range(10):
+            for j in range(10):
+                y[10*i + j] = i
+        
+        splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
+        
+        # Impurity of empty thing should be throw exception 
+
+        # Impurity of one thing should be 0
+        impurity = splitter.impurity([0])
+        assert 0 == impurity
+        
+        # Impurity of one class should be 0
+        impurity = splitter.impurity(np.linspace(0, 9, 10, dtype=int))
+        assert 0 == impurity
+
+        # Impurity of two different classes with equal number should be 0.5
+        impurity = splitter.impurity(np.linspace(0, 19, 20, dtype=int))
+        assert 0.5 == impurity
+
+        # Impurity of all classes should be 10 * (1/10)(9/10) = 9/10
+        impurity = splitter.impurity(np.linspace(0, 99, 100, dtype=int))
+        assert_almost_equal(0.9, impurity)
+    
+    def test_split(self):
+
+        pass
+
+
+
+class TestObliqueTree:
+
+    def test_add_node(self):
+
+
+
+        pass
+
+
+    def test_build(self):
+
+        pass
+
+    def test_predict(self):
+        Xtrain = np.random.rand(6, 5)
+        ytrain = np.array([0, 0, 1, 1, 0, 1])
+        tree = ObliqueTreeClassifier()
+        tree.fit(Xtrain, ytrain)
+        Xtest = np.random.rand(3, 5)
+        preds = tree.predict(Xtest)
+
+        # Tried testing on Xtrain but didn't get 100% accuracy
+
+        assert len(preds) == 3
diff --git a/proglearn/transformers.py b/proglearn/transformers.py
index 3ce1f63e17..3c13846794 100755
--- a/proglearn/transformers.py
+++ b/proglearn/transformers.py
@@ -15,6 +15,7 @@
 import keras as keras
 
 from .base import BaseTransformer
+from .oblique_tree import ObliqueTreeClassifier
 
 
 class NeuralClassificationTransformer(BaseTransformer):
@@ -194,3 +195,64 @@ def transform(self, X):
         check_is_fitted(self)
         X = check_array(X)
         return self.transformer_.apply(X)
+
+class ObliqueTreeClassificationTransformer(BaseTransformer):
+    """
+    A class used to transform data from a category to a specialized representation.
+
+    Parameters
+    ----------
+    kwargs : dict, default={}
+        A dictionary to contain parameters of the tree.
+
+    Attributes
+    ----------
+    transformer : sklearn.tree.DecisionTreeClassifier
+        an internal sklearn DecisionTreeClassifier
+    """
+
+    def __init__(self, kwargs={}):
+        self.kwargs = kwargs
+
+    def fit(self, X, y):
+        """
+        Fits the transformer to data X with labels y.
+
+        Parameters
+        ----------
+        X : ndarray
+            Input data matrix.
+        y : ndarray
+            Output (i.e. response data matrix).
+
+        Returns
+        -------
+        self : TreeClassificationTransformer
+            The object itself.
+        """
+        X, y = check_X_y(X, y)
+        self.transformer_ = ObliqueTreeClassifier(**self.kwargs).fit(X, y)
+        return self
+
+    def transform(self, X):
+        """
+        Performs inference using the transformer.
+
+        Parameters
+        ----------
+        X : ndarray
+            Input data matrix.
+
+        Returns
+        -------
+        X_transformed : ndarray
+            The transformed input.
+
+        Raises
+        ------
+        NotFittedError
+            When the model is not fitted.
+        """
+        check_is_fitted(self)
+        X = check_array(X)
+        return self.transformer_.apply(X)

From 273f96093c1f214e644d423bb172cd3b8f1475b1 Mon Sep 17 00:00:00 2001
From: parthgvora <parthgvora@gmail.com>
Date: Tue, 17 Nov 2020 20:48:31 -0500
Subject: [PATCH 02/17] all tests pass

---
 proglearn/tests/oblique_tree_test.py | 45 ++++++++++++++++++++++++----
 1 file changed, 39 insertions(+), 6 deletions(-)

diff --git a/proglearn/tests/oblique_tree_test.py b/proglearn/tests/oblique_tree_test.py
index 6e9155ef38..0ff93e0281 100644
--- a/proglearn/tests/oblique_tree_test.py
+++ b/proglearn/tests/oblique_tree_test.py
@@ -2,6 +2,7 @@
 import numpy as np
 from numpy import random as rng
 from numpy.testing import assert_almost_equal, assert_warns, assert_raises
+from sklearn.datasets import load_iris
 
 import sys
 sys.path.append("../")
@@ -75,8 +76,6 @@ def test_impurity(self):
         
         splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
         
-        # Impurity of empty thing should be throw exception 
-
         # Impurity of one thing should be 0
         impurity = splitter.impurity([0])
         assert 0 == impurity
@@ -95,22 +94,56 @@ def test_impurity(self):
     
     def test_split(self):
 
-        pass
+        random_state = 0
+        rng.seed(random_state)
+
+        X = rng.rand(100, 100)
 
+        density = 0.5
+        proj_dims = 50
 
+        y = np.zeros(100)
+        for i in range(10):
+            for j in range(10):
+                y[10*i + j] = i
+        
+        splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
+        
+        split_info = splitter.split(np.array([i for i in range(100)]))
 
 class TestObliqueTree:
 
     def test_add_node(self):
+        
+        # Add a root node
+        tree = ObliqueTree(None, 0, 0, 0, 0, 0)
+
+        tree.add_node(0, False,
+                      0, 0, False,
+                      0, 0, None,
+                      0, 0)
 
+        # Add a regular node
+        tree.add_node(0, False,
+                      0, 0, False,
+                      0, 0, None,
+                      0, 0)
 
+        # Add a leaf node
+        tree.add_node(1, False,
+                      0, 0, True,
+                      0, 0, None,
+                      0, 0)
 
-        pass
+        assert 3 == len(tree.nodes)
+        assert 3 == tree.node_count
 
 
-    def test_build(self):
+    def test_fit(self):
 
-        pass
+        data = load_iris() 
+        clf = ObliqueTreeClassifier()
+        clf.fit(data.data, data.target)
 
     def test_predict(self):
         Xtrain = np.random.rand(6, 5)

From fb8cb0f096f7bd2dc863a1c141ee3541ee1c336a Mon Sep 17 00:00:00 2001
From: Jay <jmandav1@jhu.edu>
Date: Fri, 20 Nov 2020 00:56:26 -0700
Subject: [PATCH 03/17] finished documentation

---
 proglearn/oblique_tree.py | 264 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 259 insertions(+), 5 deletions(-)

diff --git a/proglearn/oblique_tree.py b/proglearn/oblique_tree.py
index e5eedcfec3..417b945ddf 100644
--- a/proglearn/oblique_tree.py
+++ b/proglearn/oblique_tree.py
@@ -121,6 +121,13 @@ def sample_proj_mat(self, sample_inds):
         ---
         sample_inds : array of shape [n_samples]
             The data we are transforming.
+
+        Returns
+        ---
+        proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
+            The generated sparse random matrix.
+        proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
+            Projected matrix.
         """
 
         proj_mat = SparseRandomProjection(density=self.density,
@@ -138,8 +145,15 @@ def leaf_label_proba(self, idx):
         Parameters
         ---
         idx : array of shape [n_samples]
-            The indeces of the samples that are at the leaf node for which the label
+            The indices of the samples that are at the leaf node for which the label
             and probability need to be found.
+
+        Returns
+        ---
+       label : int
+            The label for any sample that is predicted to be at this node.
+        proba : float
+            The probability of the predicted sample to have this node's label.
         """
 
         samples = self.y[idx]
@@ -165,6 +179,11 @@ def score(self, y_sort, t):
             is being calculated.
         t : float
             The threshold determining where to split y_sort.
+
+        Returns
+        ---
+        gini : float
+            The Gini impurity of the split.
         """
 
         left = y_sort[:t]
@@ -195,6 +214,11 @@ def impurity(self, idx):
         ---
         idx : array of shape [n_samples]
             The indices of the nodes in the set for which the impurity is being calculated.
+
+        Returns
+        ---
+        impurity : float
+            Actual impurity of split.
         """
 
         samples = self.y[idx]
@@ -221,6 +245,11 @@ def split(self, sample_inds):
         ---
         sample_inds : array of shape [n_samples]
             The indices of the nodes in the set for which the best split is found.
+
+        Returns
+        ---
+        split_info : SplitInfo
+            Class holding information about the split.
         """
 
         # Project the data
@@ -285,8 +314,18 @@ def split(self, sample_inds):
 #--------------------------------------------------------------------------
 
 class Node:
-    def __init__(self): 
-        
+    """
+    A class used to represent an oblique node.
+
+    Parameters:
+    ---
+    None
+
+    Methods
+    ---
+    None
+    """
+    def __init__(self):
         self.node_id = None
         self.is_leaf = None
         self.parent = None
@@ -303,6 +342,29 @@ def __init__(self):
         self.proba = None
 
 class StackRecord:
+    """
+    A class used to keep track of a node's parent and other information about the node and its split.
+
+    Parameters:
+    ---
+    parent : int
+        The index of the parent node.
+    depth : int
+        The depth at which this node is.
+    is_left : bool
+        Represents if the node is a left child or not.
+    impurity : float
+        This is Gini impurity of this node.
+    sample_idx : array of shape [n_samples]
+        This is the indices of the nodes that are in this node.
+    n_samples : int
+        The number of samples in this node.
+
+    Methods
+    ---
+    None
+    """
+
     def __init__(self, parent, depth, is_left, 
                  impurity, sample_idx, n_samples):
 
@@ -314,7 +376,34 @@ def __init__(self, parent, depth, is_left,
         self.n_samples = n_samples
 
 class ObliqueTree:
-    
+    """
+    A class used to represent a tree with oblique splits.
+
+    Parameters:
+    ---
+    splitter : class
+        The type of splitter for this tree, should be an ObliqueSplitter.
+    min_samples_split : int
+        Minimum number of samples possible at a node.
+    min_samples_leaf : int
+        Minimum number of samples possible at a leaf.
+    max_depth : int
+        Maximum depth allowed for the tree.
+    min_impurity_split : float
+        Minimum Gini impurity value that must be achieved for a split to occur on the node.
+    min_impurity_decrease : float
+        Minimum amount Gini impurity value must decrease by for a split to be valid.
+
+    Methods
+    ---
+    add_node(parent, is_left, impurity, n_samples, is_leaf, feature, threshold, proj_mat, label, proba)
+        Adds a node to the existing tree
+    build()
+        This is what is initially called on to completely build the oblique tree.
+    predict(X)
+        Finds the final node for each input sample as it passes through the decision tree.
+    """
+
     def __init__(self, splitter, min_samples_split, min_samples_leaf,
                  max_depth, min_impurity_split, min_impurity_decrease):
         
@@ -340,7 +429,41 @@ def add_node(self, parent, is_left,
                  impurity, n_samples, is_leaf, 
                  feature, threshold, proj_mat,
                  label, proba):
-        
+        """
+        Adds a node to the existing oblique tree.
+
+        Parameters
+        ---
+        parent : int
+            The index of the parent node for the new node being added.
+        is_left : bool
+            Determines if this new node being added is a left or right child.
+        impurity : float
+            Impurity of this new node.
+        n_samples : int
+            Number of samples at this new node.
+        is_leaf : bool
+            Determines if this new node is a leaf of the tree or an internal node.
+        feature : int
+            Index of feature on which the split occurs at this node.
+        threshold : float
+            The threshold feature value for this node determining if a sample will go
+            to this node's left of right child. If a sample has a value less than the
+            threshold (for the feature of this node) it will go to the left childe,
+            otherwise it will go the right child.
+        proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
+            Projection matrix for this new node.
+        label : int
+            The label a sample will be given if it is predicted to be at this node.
+        proba : float
+            The probability a predicted sample has of being the node's label.
+
+        Returns
+        ---
+        node_id : int
+            Index of the new node just added.
+        """
+
         node = Node()
         node.node_id = self.node_count
         node.impurity = impurity
@@ -371,6 +494,17 @@ def add_node(self, parent, is_left,
         return node.node_id
 
     def build(self):
+        """
+        Builds the oblique tree.
+
+        Parameters
+        ---
+        None
+
+        Returns
+        ---
+        None
+        """
 
         # Initialize, add root node
         stack = []
@@ -454,6 +588,20 @@ def build(self):
                 self.depth = cur.depth
 
     def predict(self, X):
+        """
+        Predicts final nodes of samples given.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The input array for which predictions are made.
+
+        Returns
+        ---
+        predictions : array of shape [n_samples]
+            Array of the final node index for each input prediction sample.
+        """
+
         predictions = np.zeros(X.shape[0])
         for i in range(X.shape[0]):
             cur = self.nodes[0]
@@ -474,6 +622,41 @@ def predict(self, X):
 
 """ Class for Oblique Tree """
 class ObliqueTreeClassifier(BaseEstimator):
+    """
+    A class used to represent a classifier that uses an oblique decision tree.
+
+    Parameters:
+    ---
+    max_depth : int
+        Maximum depth allowed for oblique tree.
+    min_samples_split : int
+        Minimum number of samples possible at a node.
+    min_samples_leaf : int
+        Minimum number of samples possible at a leaf.
+    random_state : int
+        Maximum depth allowed for the tree.
+    min_impurity_decrease : float
+        Minimum amount Gini impurity value must decrease by for a split to be valid.
+    min_impurity_split : float
+        Minimum Gini impurity value that must be achieved for a split to occur on the node.
+    feature_combinations : float
+        The feature combinations to use for the oblique split.
+    density : float
+        Density estimate.
+
+    Methods
+    ---
+    fit(X,y)
+        Fits the oblique tree to the training samples.
+    apply(X)
+        Calls on the predict function from the oblique tree for the test samples.
+    predict(X)
+        Gets the prediction labels for the test samples.
+    predict_proba(X)
+        Gets the probability of the prediction labels for the test samples.
+    predict_log_proba(X)
+        Gets the log of the probability of the prediction labels for the test samples.
+    """
 
     def __init__(self, *,
 
@@ -514,6 +697,21 @@ def __init__(self, *,
         self.density=density
 
     def fit(self, X, y):
+        """
+        Predicts final nodes of samples given.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The training samples.
+        y : array of shape [n_samples]
+            Labels for the training samples.
+
+        Returns
+        ---
+        ObliqueTreeClassifier
+            The fit classifier.
+        """
 
         self.proj_dims = int(np.ceil(X.shape[1]) / self.feature_combinations)
         splitter = ObliqueSplitter(X, y, 
@@ -531,10 +729,38 @@ def fit(self, X, y):
         return self
 
     def apply(self, X):
+        """
+        Gets predictions form the oblique tree for the test samples.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The testing samples.
+
+        Returns
+        ---
+        pred_nodes : array of shape[n_samples]
+            The indices for each test sample's final node in the oblique tree.
+        """
+
         pred_nodes = self.tree.predict(X).astype(int)
         return pred_nodes
     
     def predict(self, X):
+        """
+        Determines final label predictions for each sample in the test data.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The testing samples.
+
+        Returns
+        ---
+        preds : array of shape[n_samples]
+            The predictions (labels) for each testing sample.
+        """
+
         preds = np.zeros(X.shape[0])
         pred_nodes = self.tree.predict(X).astype(int)
         for k in range(len(pred_nodes)):
@@ -545,6 +771,20 @@ def predict(self, X):
 
 
     def predict_proba(self, X):
+        """
+        Determines probabilities of the final label predictions for each sample in the test data.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The testing samples.
+
+        Returns
+        ---
+        preds : array of shape[n_samples]
+            The probabilities of the predictions (labels) for each testing sample.
+        """
+
         preds = np.zeros(X.shape[0])
         pred_nodes = self.tree.predict(X).astype(int)
         for k in range(len(preds)):
@@ -554,6 +794,20 @@ def predict_proba(self, X):
         return preds
 
     def predict_log_proba(self, X):
+        """
+        Determines log of the probabilities of the final label predictions for each sample in the test data.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The testing samples.
+
+        Returns
+        ---
+        preds : array of shape[n_samples]
+            The log of the probabilities of the predictions (labels) for each testing sample.
+        """
+
         proba = self.predict_proba(X)
 
         for k in range(len(preds)):

From c4cef8bfbb48fc6657acd60f32a48c3d8499ac50 Mon Sep 17 00:00:00 2001
From: Jay <jmandav1@jhu.edu>
Date: Fri, 20 Nov 2020 01:16:54 -0700
Subject: [PATCH 04/17] fixed some bugs and finished predict tests

---
 proglearn/oblique_tree.py            |  7 +++----
 proglearn/tests/oblique_tree_test.py | 13 +++++++++++--
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/proglearn/oblique_tree.py b/proglearn/oblique_tree.py
index 417b945ddf..97c48ca9b2 100644
--- a/proglearn/oblique_tree.py
+++ b/proglearn/oblique_tree.py
@@ -762,7 +762,7 @@ def predict(self, X):
         """
 
         preds = np.zeros(X.shape[0])
-        pred_nodes = self.tree.predict(X).astype(int)
+        pred_nodes = self.apply(X)
         for k in range(len(pred_nodes)):
             id = pred_nodes[k]
             preds[k] = self.tree.nodes[id].label
@@ -786,7 +786,7 @@ def predict_proba(self, X):
         """
 
         preds = np.zeros(X.shape[0])
-        pred_nodes = self.tree.predict(X).astype(int)
+        pred_nodes = self.apply(X)
         for k in range(len(preds)):
             id = pred_nodes[k]
             preds[k] = self.tree.nodes[id].proba
@@ -809,8 +809,7 @@ def predict_log_proba(self, X):
         """
 
         proba = self.predict_proba(X)
-
-        for k in range(len(preds)):
+        for k in range(len(proba)):
             proba[k] = np.log(proba[k])
 
         return proba
diff --git a/proglearn/tests/oblique_tree_test.py b/proglearn/tests/oblique_tree_test.py
index 0ff93e0281..96323b565a 100644
--- a/proglearn/tests/oblique_tree_test.py
+++ b/proglearn/tests/oblique_tree_test.py
@@ -153,6 +153,15 @@ def test_predict(self):
         Xtest = np.random.rand(3, 5)
         preds = tree.predict(Xtest)
 
-        # Tried testing on Xtrain but didn't get 100% accuracy
+        assert len(preds) == len(Xtest)
+
+        preds_proba = tree.predict_proba(Xtest)
+        preds_log_proba = tree.predict_log_proba(Xtest)
+
+        assert len(preds_proba) == len(Xtest)
+        assert len(preds_log_proba) == len(Xtest)
+
+        bool_inc = np.all(np.log(preds_proba) == preds_log_proba)
+
+        assert bool_inc
 
-        assert len(preds) == 3

From 2481e918e2e3abbed7315a8c01468b46f0c30912 Mon Sep 17 00:00:00 2001
From: parthgvora <58313394+parthgvora@users.noreply.github.com>
Date: Fri, 20 Nov 2020 11:45:45 -0500
Subject: [PATCH 05/17] Fixed header, unnecessary imports

---
 proglearn/oblique_tree.py | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/proglearn/oblique_tree.py b/proglearn/oblique_tree.py
index 97c48ca9b2..57458c79ca 100644
--- a/proglearn/oblique_tree.py
+++ b/proglearn/oblique_tree.py
@@ -1,5 +1,5 @@
 """
-Parth Vora
+Authors: Parth Vora and Jay Mandavilli
 
 Oblique Decision Tree (SPORF)
 """
@@ -7,11 +7,6 @@
 from sklearn.base import BaseEstimator
 from sklearn.random_projection import SparseRandomProjection
 
-# debugging
-import sys
-# Parallelize things later
-from joblib import Parallel, delayed
-
 #--------------------------------------------------------------------------
 class SplitInfo:
     """

From cf1b017b378e7d5ed175a0e1cfaddc4ad7646381 Mon Sep 17 00:00:00 2001
From: parthgvora <58313394+parthgvora@users.noreply.github.com>
Date: Fri, 20 Nov 2020 13:52:02 -0500
Subject: [PATCH 06/17] Including oblique_tree in proglearn

---
 proglearn/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/proglearn/__init__.py b/proglearn/__init__.py
index 37657e3dda..323e4439d7 100755
--- a/proglearn/__init__.py
+++ b/proglearn/__init__.py
@@ -1,4 +1,5 @@
 from .forest import *
 from .network import *
+from .oblique_tree import *
 
 __version__ = "0.0.3"

From 83c9f13241c06528d919f112e700c62b6f29bbb4 Mon Sep 17 00:00:00 2001
From: parthgvora <parthgvora@gmail.com>
Date: Fri, 20 Nov 2020 16:06:30 -0500
Subject: [PATCH 07/17] fixing importing issues

---
 proglearn/tests/oblique_tree_test.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/proglearn/tests/oblique_tree_test.py b/proglearn/tests/oblique_tree_test.py
index 96323b565a..294ce9784e 100644
--- a/proglearn/tests/oblique_tree_test.py
+++ b/proglearn/tests/oblique_tree_test.py
@@ -4,9 +4,7 @@
 from numpy.testing import assert_almost_equal, assert_warns, assert_raises
 from sklearn.datasets import load_iris
 
-import sys
-sys.path.append("../")
-from oblique_tree import *
+from proglearn.oblique_tree import *
 
 
 class TestObliqueSplitter:

From a7c31f0bcc718e75bbf2a79025f868276f05ebc3 Mon Sep 17 00:00:00 2001
From: parthgvora <parthgvora@gmail.com>
Date: Sat, 21 Nov 2020 15:02:51 -0500
Subject: [PATCH 08/17] black formatting

---
 proglearn/oblique_tree.py            | 361 ++++++++++++++++-----------
 proglearn/tests/oblique_tree_test.py |  58 ++---
 proglearn/transformers.py            |   1 +
 3 files changed, 234 insertions(+), 186 deletions(-)

diff --git a/proglearn/oblique_tree.py b/proglearn/oblique_tree.py
index 57458c79ca..60bfe84765 100644
--- a/proglearn/oblique_tree.py
+++ b/proglearn/oblique_tree.py
@@ -7,7 +7,7 @@
 from sklearn.base import BaseEstimator
 from sklearn.random_projection import SparseRandomProjection
 
-#--------------------------------------------------------------------------
+# --------------------------------------------------------------------------
 class SplitInfo:
     """
     A class used to store information about a certain split.
@@ -42,10 +42,20 @@ class SplitInfo:
         A metric to determine if the split improves the decision tree.
     """
 
-    def __init__(self, feature, threshold, proj_mat,
-                 left_impurity, left_idx, left_n_samples,
-                 right_impurity, right_idx, right_n_samples,
-                 no_split, improvement):
+    def __init__(
+        self,
+        feature,
+        threshold,
+        proj_mat,
+        left_impurity,
+        left_idx,
+        left_n_samples,
+        right_impurity,
+        right_idx,
+        right_n_samples,
+        no_split,
+        improvement,
+    ):
 
         self.feature = feature
         self.threshold = threshold
@@ -59,6 +69,7 @@ def __init__(self, feature, threshold, proj_mat,
         self.no_split = no_split
         self.improvement = improvement
 
+
 class ObliqueSplitter:
     """
     A class used to represent an oblique splitter, where splits are done on
@@ -125,30 +136,32 @@ def sample_proj_mat(self, sample_inds):
             Projected matrix.
         """
 
-        proj_mat = SparseRandomProjection(density=self.density,
-                                         n_components=self.proj_dims,
-                                         random_state=self.random_state)
-        
+        proj_mat = SparseRandomProjection(
+            density=self.density,
+            n_components=self.proj_dims,
+            random_state=self.random_state,
+        )
+
         proj_X = proj_mat.fit_transform(self.X[sample_inds, :])
         return proj_X, proj_mat
 
     def leaf_label_proba(self, idx):
         """
-        Finds the most common label and probability of this label from the samples at
-        the leaf node for which this is used on.
+         Finds the most common label and probability of this label from the samples at
+         the leaf node for which this is used on.
 
-        Parameters
-        ---
-        idx : array of shape [n_samples]
-            The indices of the samples that are at the leaf node for which the label
-            and probability need to be found.
+         Parameters
+         ---
+         idx : array of shape [n_samples]
+             The indices of the samples that are at the leaf node for which the label
+             and probability need to be found.
 
-        Returns
-        ---
-       label : int
-            The label for any sample that is predicted to be at this node.
-        proba : float
-            The probability of the predicted sample to have this node's label.
+         Returns
+         ---
+        label : int
+             The label for any sample that is predicted to be at this node.
+         proba : float
+             The probability of the predicted sample to have this node's label.
         """
 
         samples = self.y[idx]
@@ -189,14 +202,16 @@ def score(self, y_sort, t):
 
         left_unique, left_counts = np.unique(left, return_counts=True)
         right_unique, right_counts = np.unique(right, return_counts=True)
-  
+
         left_counts = left_counts / n_left
         right_counts = right_counts / n_right
 
         left_gini = 1 - np.sum(np.power(left_counts, 2))
         right_gini = 1 - np.sum(np.power(right_counts, 2))
 
-        gini = (n_left / self.n_samples) * left_gini + (n_right / self.n_samples) * right_gini
+        gini = (n_left / self.n_samples) * left_gini + (
+            n_right / self.n_samples
+        ) * right_gini
         return gini
 
     # Returns impurity for a group of examples
@@ -227,7 +242,7 @@ def impurity(self, idx):
         gini = np.sum(np.power(count, 2))
 
         return 1 - gini
-    
+
     # Finds the best split
     # This needs to be parallelized; its a major bottleneck
     def split(self, sample_inds):
@@ -267,7 +282,9 @@ def split(self, sample_inds):
             idx = np.argsort(proj_X[:, j])
             y_sort = y_sample[idx]
 
-            Q[1:-1, j] = np.array([self.score(y_sort, i) for i in range(1, n_samples - 1)])
+            Q[1:-1, j] = np.array(
+                [self.score(y_sort, i) for i in range(1, n_samples - 1)]
+            )
 
         # Identify best split feature, minimum gini impurity
         best_split_ind = np.argmin(Q)
@@ -277,7 +294,7 @@ def split(self, sample_inds):
         # Sort samples by the split feature
         feat_vec = proj_X[:, feature]
         idx = np.argsort(feat_vec)
-        
+
         feat_vec = feat_vec[idx]
         sample_inds = sample_inds[idx]
 
@@ -290,8 +307,7 @@ def split(self, sample_inds):
         right_n_samples = len(right_idx)
 
         # See if we have no split
-        no_split = (left_n_samples == 0 or
-                    right_n_samples == 0)
+        no_split = left_n_samples == 0 or right_n_samples == 0
 
         # Evaluate improvement
         improvement = node_impurity - best_gini
@@ -300,13 +316,25 @@ def split(self, sample_inds):
         left_impurity = self.impurity(left_idx)
         right_impurity = self.impurity(right_idx)
 
-        split_info = SplitInfo(feature, threshold, proj_mat,
-                      left_impurity, left_idx, left_n_samples,
-                      right_impurity, right_idx, right_n_samples,
-                      no_split, improvement)
+        split_info = SplitInfo(
+            feature,
+            threshold,
+            proj_mat,
+            left_impurity,
+            left_idx,
+            left_n_samples,
+            right_impurity,
+            right_idx,
+            right_n_samples,
+            no_split,
+            improvement,
+        )
 
         return split_info
-#--------------------------------------------------------------------------
+
+
+# --------------------------------------------------------------------------
+
 
 class Node:
     """
@@ -320,22 +348,24 @@ class Node:
     ---
     None
     """
+
     def __init__(self):
         self.node_id = None
         self.is_leaf = None
         self.parent = None
         self.left_child = None
         self.right_child = None
-        
+
         self.feature = None
         self.threshold = None
         self.impurity = None
         self.n_samples = None
-        
+
         self.proj_mat = None
         self.label = None
         self.proba = None
 
+
 class StackRecord:
     """
     A class used to keep track of a node's parent and other information about the node and its split.
@@ -360,8 +390,7 @@ class StackRecord:
     None
     """
 
-    def __init__(self, parent, depth, is_left, 
-                 impurity, sample_idx, n_samples):
+    def __init__(self, parent, depth, is_left, impurity, sample_idx, n_samples):
 
         self.parent = parent
         self.depth = depth
@@ -370,6 +399,7 @@ def __init__(self, parent, depth, is_left,
         self.sample_idx = sample_idx
         self.n_samples = n_samples
 
+
 class ObliqueTree:
     """
     A class used to represent a tree with oblique splits.
@@ -399,13 +429,20 @@ class ObliqueTree:
         Finds the final node for each input sample as it passes through the decision tree.
     """
 
-    def __init__(self, splitter, min_samples_split, min_samples_leaf,
-                 max_depth, min_impurity_split, min_impurity_decrease):
-        
+    def __init__(
+        self,
+        splitter,
+        min_samples_split,
+        min_samples_leaf,
+        max_depth,
+        min_impurity_split,
+        min_impurity_decrease,
+    ):
+
         # Tree parameters
-        #self.n_samples = n_samples
-        #self.n_features = n_features
-        #self.n_classes = n_classes
+        # self.n_samples = n_samples
+        # self.n_features = n_features
+        # self.n_classes = n_classes
         self.depth = 0
         self.node_count = 0
         self.nodes = []
@@ -418,12 +455,19 @@ def __init__(self, splitter, min_samples_split, min_samples_leaf,
         self.min_impurity_split = min_impurity_split
         self.min_impurity_decrease = min_impurity_decrease
 
-
-
-    def add_node(self, parent, is_left, 
-                 impurity, n_samples, is_leaf, 
-                 feature, threshold, proj_mat,
-                 label, proba):
+    def add_node(
+        self,
+        parent,
+        is_left,
+        impurity,
+        n_samples,
+        is_leaf,
+        feature,
+        threshold,
+        proj_mat,
+        label,
+        proba,
+    ):
         """
         Adds a node to the existing oblique tree.
 
@@ -503,80 +547,93 @@ def build(self):
 
         # Initialize, add root node
         stack = []
-        root = StackRecord(0, 1, False,
-                           self.splitter.impurity(self.splitter.indices),
-                           self.splitter.indices,
-                           self.splitter.n_samples)
+        root = StackRecord(
+            0,
+            1,
+            False,
+            self.splitter.impurity(self.splitter.indices),
+            self.splitter.indices,
+            self.splitter.n_samples,
+        )
         stack.append(root)
-       
 
         # Build tree
         while len(stack) > 0:
-            
+
             # Pop a record off the stack
             cur = stack.pop()
 
-
             # Evaluate if it is a leaf
-            is_leaf = (cur.depth >= self.max_depth or
-                       cur.n_samples < self.min_samples_split or
-                       cur.n_samples < 2 * self.min_samples_leaf or
-                       cur.impurity <= self.min_impurity_split)
+            is_leaf = (
+                cur.depth >= self.max_depth
+                or cur.n_samples < self.min_samples_split
+                or cur.n_samples < 2 * self.min_samples_leaf
+                or cur.impurity <= self.min_impurity_split
+            )
 
             # Split if not
             if not is_leaf:
                 split = self.splitter.split(cur.sample_idx)
 
-                is_leaf = (is_leaf or 
-                           split.no_split or
-                           split.improvement <= self.min_impurity_decrease)
+                is_leaf = (
+                    is_leaf
+                    or split.no_split
+                    or split.improvement <= self.min_impurity_decrease
+                )
 
             # Add the node to the tree
             if is_leaf:
-                
+
                 label, proba = self.splitter.leaf_label_proba(cur.sample_idx)
-                
-                node_id = self.add_node(cur.parent,
-                                        cur.is_left,
-                                        cur.impurity,
-                                        cur.n_samples,
-                                        is_leaf,
-                                        None,
-                                        None,
-                                        None,
-                                        label,
-                                        proba)
 
-            else:
-                node_id = self.add_node(cur.parent,
-                                        cur.is_left,
-                                        cur.impurity,
-                                        cur.n_samples,
-                                        is_leaf,
-                                        split.feature,
-                                        split.threshold,
-                                        split.proj_mat,
-                                        None,
-                                        None)
+                node_id = self.add_node(
+                    cur.parent,
+                    cur.is_left,
+                    cur.impurity,
+                    cur.n_samples,
+                    is_leaf,
+                    None,
+                    None,
+                    None,
+                    label,
+                    proba,
+                )
 
+            else:
+                node_id = self.add_node(
+                    cur.parent,
+                    cur.is_left,
+                    cur.impurity,
+                    cur.n_samples,
+                    is_leaf,
+                    split.feature,
+                    split.threshold,
+                    split.proj_mat,
+                    None,
+                    None,
+                )
 
             # Push the right and left children to the stack if applicable
             if not is_leaf:
 
-                right_child = StackRecord(node_id,
-                                          cur.depth + 1,
-                                          False,
-                                          split.right_impurity,
-                                          split.right_idx,
-                                          split.right_n_samples)
+                right_child = StackRecord(
+                    node_id,
+                    cur.depth + 1,
+                    False,
+                    split.right_impurity,
+                    split.right_idx,
+                    split.right_n_samples,
+                )
                 stack.append(right_child)
 
-                left_child = StackRecord(node_id, 
-                                          cur.depth + 1,
-                                          True,
-                                          split.left_impurity,
-                                          split.left_idx,
-                                          split.left_n_samples)
+                left_child = StackRecord(
+                    node_id,
+                    cur.depth + 1,
+                    True,
+                    split.left_impurity,
+                    split.left_idx,
+                    split.left_n_samples,
+                )
                 stack.append(left_child)
 
             if cur.depth > self.depth:
@@ -613,9 +670,12 @@ def predict(self, X):
 
         return predictions
 
-#--------------------------------------------------------------------------
+
+# --------------------------------------------------------------------------
 
 """ Class for Oblique Tree """
+
+
 class ObliqueTreeClassifier(BaseEstimator):
     """
     A class used to represent a classifier that uses an oblique decision tree.
@@ -653,43 +713,42 @@ class ObliqueTreeClassifier(BaseEstimator):
         Gets the log of the probability of the prediction labels for the test samples.
     """
 
-    def __init__(self, *,
-
-                 #criterion="gini",
-                 #splitter=None,
-                 max_depth=np.inf,
-                 min_samples_split=2,
-                 min_samples_leaf=1,
-                 #min_weight_fraction_leaf=0,
-                 #max_features="auto",
-                 #max_leaf_nodes=None,
-                 random_state=None,
-                 min_impurity_decrease=0,
-                 min_impurity_split=0,
-                 #class_weight=None,
-                 #ccp_alpha=0.0,
-                 
-                 #New args
-                 feature_combinations=1.2,
-                 density=0.7
-
-                 ):
-
-        #self.criterion=criterion
-        self.max_depth=max_depth
-        self.min_samples_split=min_samples_split
-        self.min_samples_leaf=min_samples_leaf
-        #self.min_weight_fraction_leaf=min_weight_fraction_leaf
-        #self.max_features=max_features
-        #self.max_leaf_nodes=max_leaf_nodes
-        self.random_state=random_state
-        self.min_impurity_decrease=min_impurity_decrease
-        self.min_impurity_split=min_impurity_split
-        #self.class_weight=class_weight
-        #self.ccp_alpha=ccp_alpha
-
-        self.feature_combinations=feature_combinations
-        self.density=density
+    def __init__(
+        self,
+        *,
+        # criterion="gini",
+        # splitter=None,
+        max_depth=np.inf,
+        min_samples_split=2,
+        min_samples_leaf=1,
+        # min_weight_fraction_leaf=0,
+        # max_features="auto",
+        # max_leaf_nodes=None,
+        random_state=None,
+        min_impurity_decrease=0,
+        min_impurity_split=0,
+        # class_weight=None,
+        # ccp_alpha=0.0,
+        # New args
+        feature_combinations=1.2,
+        density=0.7
+    ):
+
+        # self.criterion=criterion
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        # self.min_weight_fraction_leaf=min_weight_fraction_leaf
+        # self.max_features=max_features
+        # self.max_leaf_nodes=max_leaf_nodes
+        self.random_state = random_state
+        self.min_impurity_decrease = min_impurity_decrease
+        self.min_impurity_split = min_impurity_split
+        # self.class_weight=class_weight
+        # self.ccp_alpha=ccp_alpha
+
+        self.feature_combinations = feature_combinations
+        self.density = density
 
     def fit(self, X, y):
         """
@@ -709,17 +768,18 @@ def fit(self, X, y):
         """
 
         self.proj_dims = int(np.ceil(X.shape[1]) / self.feature_combinations)
-        splitter = ObliqueSplitter(X, y, 
-                                   self.proj_dims, 
-                                   self.density,
-                                   self.random_state)
-
-        self.tree = ObliqueTree(splitter,
-                                self.min_samples_split,
-                                self.min_samples_leaf,
-                                self.max_depth,
-                                self.min_impurity_split,
-                                self.min_impurity_decrease)
+        splitter = ObliqueSplitter(
+            X, y, self.proj_dims, self.density, self.random_state
+        )
+
+        self.tree = ObliqueTree(
+            splitter,
+            self.min_samples_split,
+            self.min_samples_leaf,
+            self.max_depth,
+            self.min_impurity_split,
+            self.min_impurity_decrease,
+        )
         self.tree.build()
         return self
 
@@ -740,7 +800,7 @@ def apply(self, X):
 
         pred_nodes = self.tree.predict(X).astype(int)
         return pred_nodes
-    
+
     def predict(self, X):
         """
         Determines final label predictions for each sample in the test data.
@@ -764,7 +824,6 @@ def predict(self, X):
 
         return preds
 
-
     def predict_proba(self, X):
         """
         Determines probabilities of the final label predictions for each sample in the test data.
@@ -808,5 +867,3 @@ def predict_log_proba(self, X):
             proba[k] = np.log(proba[k])
 
         return proba
-
-
diff --git a/proglearn/tests/oblique_tree_test.py b/proglearn/tests/oblique_tree_test.py
index 294ce9784e..f0659cbaff 100644
--- a/proglearn/tests/oblique_tree_test.py
+++ b/proglearn/tests/oblique_tree_test.py
@@ -8,9 +8,8 @@
 
 
 class TestObliqueSplitter:
-
     def test_sample_projmat(self):
-        
+
         random_state = 0
         rng.seed(random_state)
 
@@ -19,11 +18,13 @@ def test_sample_projmat(self):
 
         density = 0.5
         proj_dims = [10, 20, 40, 60, 80]
-        sample_inds = [np.linspace(0, 9, 10, dtype=int),
-                       np.linspace(0, 19, 20, dtype=int), 
-                       np.linspace(0, 39, 40, dtype=int), 
-                       np.linspace(0, 59, 60, dtype=int), 
-                       np.linspace(0, 79, 80, dtype=int)]
+        sample_inds = [
+            np.linspace(0, 9, 10, dtype=int),
+            np.linspace(0, 19, 20, dtype=int),
+            np.linspace(0, 39, 40, dtype=int),
+            np.linspace(0, 59, 60, dtype=int),
+            np.linspace(0, 79, 80, dtype=int),
+        ]
 
         n_sample_inds = [10, 20, 40, 60, 80]
 
@@ -55,10 +56,10 @@ def test_score(self):
         assert 0 == score
 
         score = splitter.score(y, 1)
-        assert_almost_equal(5/11, score)
+        assert_almost_equal(5 / 11, score)
 
     def test_impurity(self):
-       
+
         random_state = 0
         rng.seed(random_state)
 
@@ -70,14 +71,14 @@ def test_impurity(self):
         y = np.zeros(100)
         for i in range(10):
             for j in range(10):
-                y[10*i + j] = i
-        
+                y[10 * i + j] = i
+
         splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
-        
+
         # Impurity of one thing should be 0
         impurity = splitter.impurity([0])
         assert 0 == impurity
-        
+
         # Impurity of one class should be 0
         impurity = splitter.impurity(np.linspace(0, 9, 10, dtype=int))
         assert 0 == impurity
@@ -89,7 +90,7 @@ def test_impurity(self):
         # Impurity of all classes should be 10 * (1/10)(9/10) = 9/10
         impurity = splitter.impurity(np.linspace(0, 99, 100, dtype=int))
         assert_almost_equal(0.9, impurity)
-    
+
     def test_split(self):
 
         random_state = 0
@@ -103,43 +104,33 @@ def test_split(self):
         y = np.zeros(100)
         for i in range(10):
             for j in range(10):
-                y[10*i + j] = i
-        
+                y[10 * i + j] = i
+
         splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
-        
+
         split_info = splitter.split(np.array([i for i in range(100)]))
 
-class TestObliqueTree:
 
+class TestObliqueTree:
     def test_add_node(self):
-        
+
         # Add a root node
         tree = ObliqueTree(None, 0, 0, 0, 0, 0)
 
-        tree.add_node(0, False,
-                      0, 0, False,
-                      0, 0, None,
-                      0, 0)
+        tree.add_node(0, False, 0, 0, False, 0, 0, None, 0, 0)
 
         # Add a regular node
-        tree.add_node(0, False,
-                      0, 0, False,
-                      0, 0, None,
-                      0, 0)
+        tree.add_node(0, False, 0, 0, False, 0, 0, None, 0, 0)
 
         # Add a leaf node
-        tree.add_node(1, False,
-                      0, 0, True,
-                      0, 0, None,
-                      0, 0)
+        tree.add_node(1, False, 0, 0, True, 0, 0, None, 0, 0)
 
         assert 3 == len(tree.nodes)
         assert 3 == tree.node_count
 
-
     def test_fit(self):
 
-        data = load_iris() 
+        data = load_iris()
         clf = ObliqueTreeClassifier()
         clf.fit(data.data, data.target)
 
@@ -162,4 +153,3 @@ def test_predict(self):
         bool_inc = np.all(np.log(preds_proba) == preds_log_proba)
 
         assert bool_inc
-
diff --git a/proglearn/transformers.py b/proglearn/transformers.py
index 3c13846794..756d0bde28 100755
--- a/proglearn/transformers.py
+++ b/proglearn/transformers.py
@@ -196,6 +196,7 @@ def transform(self, X):
         X = check_array(X)
         return self.transformer_.apply(X)
 
+
 class ObliqueTreeClassificationTransformer(BaseTransformer):
     """
     A class used to transform data from a category to a specialized representation.

From 0e50784a506319a965b47caefc1dc8d68d08f0c5 Mon Sep 17 00:00:00 2001
From: Haoyin Xu <haoyinxu@gmail.com>
Date: Sat, 21 Nov 2020 15:20:07 -0800
Subject: [PATCH 09/17] Fix docstring indents

---
 proglearn/oblique_tree.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/proglearn/oblique_tree.py b/proglearn/oblique_tree.py
index 60bfe84765..ea6bcbe632 100644
--- a/proglearn/oblique_tree.py
+++ b/proglearn/oblique_tree.py
@@ -147,21 +147,21 @@ def sample_proj_mat(self, sample_inds):
 
     def leaf_label_proba(self, idx):
         """
-         Finds the most common label and probability of this label from the samples at
-         the leaf node for which this is used on.
+        Finds the most common label and probability of this label from the samples at
+        the leaf node for which this is used on.
 
-         Parameters
-         ---
-         idx : array of shape [n_samples]
-             The indices of the samples that are at the leaf node for which the label
-             and probability need to be found.
+        Parameters
+        ---
+        idx : array of shape [n_samples]
+            The indices of the samples that are at the leaf node for which the label
+            and probability need to be found.
 
-         Returns
-         ---
+        Returns
+        ---
         label : int
-             The label for any sample that is predicted to be at this node.
-         proba : float
-             The probability of the predicted sample to have this node's label.
+            The label for any sample that is predicted to be at this node.
+        proba : float
+            The probability of the predicted sample to have this node's label.
         """
 
         samples = self.y[idx]

From 1328b75312cca03ffcc6e94b69c704332a01ee54 Mon Sep 17 00:00:00 2001
From: parthgvora <parthgvora@gmail.com>
Date: Fri, 11 Dec 2020 11:53:29 -0500
Subject: [PATCH 10/17] black formatting

---
 proglearn/__init__.py                |   1 -
 proglearn/forest.py                  |  36 +-
 proglearn/oblique_tree.py            | 869 --------------------------
 proglearn/tests/oblique_tree_test.py | 155 -----
 proglearn/tests/test_transformer.py  | 159 ++++-
 proglearn/transformers.py            | 875 ++++++++++++++++++++++++++-
 6 files changed, 1063 insertions(+), 1032 deletions(-)
 delete mode 100644 proglearn/oblique_tree.py
 delete mode 100644 proglearn/tests/oblique_tree_test.py
 mode change 100755 => 100644 proglearn/transformers.py

diff --git a/proglearn/__init__.py b/proglearn/__init__.py
index 323e4439d7..37657e3dda 100755
--- a/proglearn/__init__.py
+++ b/proglearn/__init__.py
@@ -1,5 +1,4 @@
 from .forest import *
 from .network import *
-from .oblique_tree import *
 
 __version__ = "0.0.3"
diff --git a/proglearn/forest.py b/proglearn/forest.py
index 6deddf4e40..e8812b8148 100644
--- a/proglearn/forest.py
+++ b/proglearn/forest.py
@@ -48,13 +48,26 @@ def __init__(
         default_tree_construction_proportion=0.67,
         default_kappa=np.inf,
         default_max_depth=30,
+        oblique=False,
+        default_feature_combinations=1.5,
+        default_density=0.5,
     ):
         self.default_n_estimators = default_n_estimators
         self.default_tree_construction_proportion = default_tree_construction_proportion
         self.default_kappa = default_kappa
         self.default_max_depth = default_max_depth
+        self.oblique = oblique
+
+        if oblique:
+            default_transformer_class = ObliqueTreeClassificationTransformer
+            self.default_feature_combinations = default_feature_combinations
+            self.default_density = default_density
+
+        else:
+            default_transformer_class = TreeClassificationTransformer
+
         self.pl_ = ClassificationProgressiveLearner(
-            default_transformer_class=TreeClassificationTransformer,
+            default_transformer_class=default_transformer_class,
             default_transformer_kwargs={},
             default_voter_class=TreeClassificationVoter,
             default_voter_kwargs={"kappa": default_kappa},
@@ -71,6 +84,8 @@ def add_task(
         tree_construction_proportion="default",
         kappa="default",
         max_depth="default",
+        feature_combinations="default",
+        density="default",
     ):
         """
         adds a task with id task_id, max tree depth max_depth, given input data matrix X
@@ -120,6 +135,23 @@ def add_task(
         if max_depth == "default":
             max_depth = self.default_max_depth
 
+        if self.oblique:
+            if feature_combinations == "default":
+                feature_combinations = self.default_feature_combinations
+            if density == "default":
+                density = self.default_density
+
+            transformer_kwargs = {
+                "kwargs": {
+                    "max_depth": max_depth,
+                    "feature_combinations": feature_combinations,
+                    "density": density,
+                }
+            }
+
+        else:
+            transformer_kwargs = ({"kwargs": {"max_depth": max_depth}},)
+
         X, y = check_X_y(X, y)
         return self.pl_.add_task(
             X,
@@ -131,7 +163,7 @@ def add_task(
                 0,
             ],
             num_transformers=n_estimators,
-            transformer_kwargs={"kwargs": {"max_depth": max_depth}},
+            transformer_kwargs=transformer_kwargs,
             voter_kwargs={
                 "classes": np.unique(y),
                 "kappa": kappa,
diff --git a/proglearn/oblique_tree.py b/proglearn/oblique_tree.py
deleted file mode 100644
index 60bfe84765..0000000000
--- a/proglearn/oblique_tree.py
+++ /dev/null
@@ -1,869 +0,0 @@
-"""
-Authors: Parth Vora and Jay Mandavilli
-
-Oblique Decision Tree (SPORF)
-"""
-import numpy as np
-from sklearn.base import BaseEstimator
-from sklearn.random_projection import SparseRandomProjection
-
-# --------------------------------------------------------------------------
-class SplitInfo:
-    """
-    A class used to store information about a certain split.
-
-    Parameters:
-    ---
-    feature : int
-        The feature which is used for the particular split.
-    threshold : float
-        The feature value which defines the split, if an example has a value less
-        than this threshold for the feature of this split then it will go to the
-        left child, otherwise it wil go the right child where these children are
-        the children nodes of the node for which this split defines.
-    proj_mat : array of shape [n_components, n_features]
-        The sparse random projection matrix for this split.
-    left_impurity : float
-        This is Gini impurity of left side of the split.
-    left_idx : array of shape [left_n_samples]
-        This is the indices of the nodes that are in the left side of this split.
-    left_n_samples : int
-        The number of samples in the left side of this split.
-    right_impurity : float
-        This is Gini impurity of right side of the split.
-    right_idx : array of shape [right_n_samples]
-        This is the indices of the nodes that are in the right side of this split.
-    right_n_samples : int
-        The number of samples in the right side of this split.
-    no_split : bool
-        A boolean specifying if there is a valid split or not. Here an invalid
-        split means all of the samples would go to one side.
-    improvement : float
-        A metric to determine if the split improves the decision tree.
-    """
-
-    def __init__(
-        self,
-        feature,
-        threshold,
-        proj_mat,
-        left_impurity,
-        left_idx,
-        left_n_samples,
-        right_impurity,
-        right_idx,
-        right_n_samples,
-        no_split,
-        improvement,
-    ):
-
-        self.feature = feature
-        self.threshold = threshold
-        self.proj_mat = proj_mat
-        self.left_impurity = left_impurity
-        self.left_idx = left_idx
-        self.left_n_samples = left_n_samples
-        self.right_impurity = right_impurity
-        self.right_idx = right_idx
-        self.right_n_samples = right_n_samples
-        self.no_split = no_split
-        self.improvement = improvement
-
-
-class ObliqueSplitter:
-    """
-    A class used to represent an oblique splitter, where splits are done on
-    the linear combination of the features.
-
-    Parameters:
-    ---
-    X : array of shape [n_samples, n_features]
-        The input data X is a matrix of the examples and their respective feature
-        values for each of the features.
-    y : array of shape [n_samples]
-        The labels for each of the examples in X.
-    proj_dims : int
-        The dimensionality of the target projection space.
-    density : float
-        Ratio of non-zero component in the random projection matrix in the range '(0, 1]'.
-    random_state : int
-        Controls the pseudo random number generator used to generate the projection matrix.
-
-    Methods
-    ---
-    sample_proj_mat(sample_inds)
-        This gets the projection matrix and it fits the transform to the samples of interest.
-    leaf_label_proba(idx)
-        This calculates the label and the probability for that label for a particular leaf
-        node.
-    score(y_sort, t)
-        Finds the Gini impurity for a split.
-    impurity(idx)
-        Finds the impurity for a certain set of samples.
-    split(sample_inds)
-        Determines the best possible split for the given set of samples.
-    """
-
-    def __init__(self, X, y, proj_dims, density, random_state):
-
-        self.X = X
-        self.y = y
-
-        self.classes = np.array(np.unique(y), dtype=int)
-        self.n_classes = len(self.classes)
-        self.indices = np.indices(y.shape)[0]
-
-        self.n_samples = X.shape[0]
-
-        self.proj_dims = proj_dims
-        self.density = density
-        self.random_state = random_state
-
-    def sample_proj_mat(self, sample_inds):
-        """
-        Gets the projection matrix and it fits the transform to the samples of interest.
-
-        Parameters
-        ---
-        sample_inds : array of shape [n_samples]
-            The data we are transforming.
-
-        Returns
-        ---
-        proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
-            The generated sparse random matrix.
-        proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
-            Projected matrix.
-        """
-
-        proj_mat = SparseRandomProjection(
-            density=self.density,
-            n_components=self.proj_dims,
-            random_state=self.random_state,
-        )
-
-        proj_X = proj_mat.fit_transform(self.X[sample_inds, :])
-        return proj_X, proj_mat
-
-    def leaf_label_proba(self, idx):
-        """
-         Finds the most common label and probability of this label from the samples at
-         the leaf node for which this is used on.
-
-         Parameters
-         ---
-         idx : array of shape [n_samples]
-             The indices of the samples that are at the leaf node for which the label
-             and probability need to be found.
-
-         Returns
-         ---
-        label : int
-             The label for any sample that is predicted to be at this node.
-         proba : float
-             The probability of the predicted sample to have this node's label.
-        """
-
-        samples = self.y[idx]
-        n = len(samples)
-        labels, count = np.unique(samples, return_counts=True)
-        most = np.argmax(count)
-
-        label = labels[most]
-        proba = count[most] / n
-
-        return label, proba
-
-    # Returns gini impurity for split
-    # Expects 0 < t < n
-    def score(self, y_sort, t):
-        """
-        Finds the Gini impurity for the split of interest
-
-        Parameters
-        ---
-        y_sort : array of shape [n_samples]
-            A sorted array of labels for the examples for which the Gini impurity
-            is being calculated.
-        t : float
-            The threshold determining where to split y_sort.
-
-        Returns
-        ---
-        gini : float
-            The Gini impurity of the split.
-        """
-
-        left = y_sort[:t]
-        right = y_sort[t:]
-
-        n_left = len(left)
-        n_right = len(right)
-
-        left_unique, left_counts = np.unique(left, return_counts=True)
-        right_unique, right_counts = np.unique(right, return_counts=True)
-
-        left_counts = left_counts / n_left
-        right_counts = right_counts / n_right
-
-        left_gini = 1 - np.sum(np.power(left_counts, 2))
-        right_gini = 1 - np.sum(np.power(right_counts, 2))
-
-        gini = (n_left / self.n_samples) * left_gini + (
-            n_right / self.n_samples
-        ) * right_gini
-        return gini
-
-    # Returns impurity for a group of examples
-    # expects idx not None
-    def impurity(self, idx):
-        """
-        Finds the actual impurity for a set of samples
-
-        Parameters
-        ---
-        idx : array of shape [n_samples]
-            The indices of the nodes in the set for which the impurity is being calculated.
-
-        Returns
-        ---
-        impurity : float
-            Actual impurity of split.
-        """
-
-        samples = self.y[idx]
-        n = len(samples)
-
-        if n == 0:
-            return 0
-
-        unique, count = np.unique(samples, return_counts=True)
-        count = count / n
-        gini = np.sum(np.power(count, 2))
-
-        return 1 - gini
-
-    # Finds the best split
-    # This needs to be parallelized; its a major bottleneck
-    def split(self, sample_inds):
-        """
-        Finds the optimal split for a set of samples.
-        Note that the code for this method needs to be parallelized. This is a major
-        bottleneck in integration with scikit-learn.
-
-        Parameters
-        ---
-        sample_inds : array of shape [n_samples]
-            The indices of the nodes in the set for which the best split is found.
-
-        Returns
-        ---
-        split_info : SplitInfo
-            Class holding information about the split.
-        """
-
-        # Project the data
-        proj_X, proj_mat = self.sample_proj_mat(sample_inds)
-        y_sample = self.y[sample_inds]
-        n_samples = len(sample_inds)
-
-        # Score matrix
-        # No split score is just node impurity
-        Q = np.zeros((n_samples, self.proj_dims))
-        node_impurity = self.impurity(sample_inds)
-        Q[0, :] = node_impurity
-        Q[-1, :] = node_impurity
-
-        # Loop through projected features and examples to find best split
-        # This can be parallelized for sure
-        for j in range(self.proj_dims):
-
-            # Sort labels by the jth feature
-            idx = np.argsort(proj_X[:, j])
-            y_sort = y_sample[idx]
-
-            Q[1:-1, j] = np.array(
-                [self.score(y_sort, i) for i in range(1, n_samples - 1)]
-            )
-
-        # Identify best split feature, minimum gini impurity
-        best_split_ind = np.argmin(Q)
-        thresh_i, feature = np.unravel_index(best_split_ind, Q.shape)
-        best_gini = Q[thresh_i, feature]
-
-        # Sort samples by the split feature
-        feat_vec = proj_X[:, feature]
-        idx = np.argsort(feat_vec)
-
-        feat_vec = feat_vec[idx]
-        sample_inds = sample_inds[idx]
-
-        # Get the threshold, split samples into left and right
-        threshold = feat_vec[thresh_i]
-        left_idx = sample_inds[:thresh_i]
-        right_idx = sample_inds[thresh_i:]
-
-        left_n_samples = len(left_idx)
-        right_n_samples = len(right_idx)
-
-        # See if we have no split
-        no_split = left_n_samples == 0 or right_n_samples == 0
-
-        # Evaluate improvement
-        improvement = node_impurity - best_gini
-
-        # Evaluate impurities for left and right children
-        left_impurity = self.impurity(left_idx)
-        right_impurity = self.impurity(right_idx)
-
-        split_info = SplitInfo(
-            feature,
-            threshold,
-            proj_mat,
-            left_impurity,
-            left_idx,
-            left_n_samples,
-            right_impurity,
-            right_idx,
-            right_n_samples,
-            no_split,
-            improvement,
-        )
-
-        return split_info
-
-
-# --------------------------------------------------------------------------
-
-
-class Node:
-    """
-    A class used to represent an oblique node.
-
-    Parameters:
-    ---
-    None
-
-    Methods
-    ---
-    None
-    """
-
-    def __init__(self):
-        self.node_id = None
-        self.is_leaf = None
-        self.parent = None
-        self.left_child = None
-        self.right_child = None
-
-        self.feature = None
-        self.threshold = None
-        self.impurity = None
-        self.n_samples = None
-
-        self.proj_mat = None
-        self.label = None
-        self.proba = None
-
-
-class StackRecord:
-    """
-    A class used to keep track of a node's parent and other information about the node and its split.
-
-    Parameters:
-    ---
-    parent : int
-        The index of the parent node.
-    depth : int
-        The depth at which this node is.
-    is_left : bool
-        Represents if the node is a left child or not.
-    impurity : float
-        This is Gini impurity of this node.
-    sample_idx : array of shape [n_samples]
-        This is the indices of the nodes that are in this node.
-    n_samples : int
-        The number of samples in this node.
-
-    Methods
-    ---
-    None
-    """
-
-    def __init__(self, parent, depth, is_left, impurity, sample_idx, n_samples):
-
-        self.parent = parent
-        self.depth = depth
-        self.is_left = is_left
-        self.impurity = impurity
-        self.sample_idx = sample_idx
-        self.n_samples = n_samples
-
-
-class ObliqueTree:
-    """
-    A class used to represent a tree with oblique splits.
-
-    Parameters:
-    ---
-    splitter : class
-        The type of splitter for this tree, should be an ObliqueSplitter.
-    min_samples_split : int
-        Minimum number of samples possible at a node.
-    min_samples_leaf : int
-        Minimum number of samples possible at a leaf.
-    max_depth : int
-        Maximum depth allowed for the tree.
-    min_impurity_split : float
-        Minimum Gini impurity value that must be achieved for a split to occur on the node.
-    min_impurity_decrease : float
-        Minimum amount Gini impurity value must decrease by for a split to be valid.
-
-    Methods
-    ---
-    add_node(parent, is_left, impurity, n_samples, is_leaf, feature, threshold, proj_mat, label, proba)
-        Adds a node to the existing tree
-    build()
-        This is what is initially called on to completely build the oblique tree.
-    predict(X)
-        Finds the final node for each input sample as it passes through the decision tree.
-    """
-
-    def __init__(
-        self,
-        splitter,
-        min_samples_split,
-        min_samples_leaf,
-        max_depth,
-        min_impurity_split,
-        min_impurity_decrease,
-    ):
-
-        # Tree parameters
-        # self.n_samples = n_samples
-        # self.n_features = n_features
-        # self.n_classes = n_classes
-        self.depth = 0
-        self.node_count = 0
-        self.nodes = []
-
-        # Build parameters
-        self.splitter = splitter
-        self.min_samples_split = min_samples_split
-        self.min_samples_leaf = min_samples_leaf
-        self.max_depth = max_depth
-        self.min_impurity_split = min_impurity_split
-        self.min_impurity_decrease = min_impurity_decrease
-
-    def add_node(
-        self,
-        parent,
-        is_left,
-        impurity,
-        n_samples,
-        is_leaf,
-        feature,
-        threshold,
-        proj_mat,
-        label,
-        proba,
-    ):
-        """
-        Adds a node to the existing oblique tree.
-
-        Parameters
-        ---
-        parent : int
-            The index of the parent node for the new node being added.
-        is_left : bool
-            Determines if this new node being added is a left or right child.
-        impurity : float
-            Impurity of this new node.
-        n_samples : int
-            Number of samples at this new node.
-        is_leaf : bool
-            Determines if this new node is a leaf of the tree or an internal node.
-        feature : int
-            Index of feature on which the split occurs at this node.
-        threshold : float
-            The threshold feature value for this node determining if a sample will go
-            to this node's left of right child. If a sample has a value less than the
-            threshold (for the feature of this node) it will go to the left childe,
-            otherwise it will go the right child.
-        proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
-            Projection matrix for this new node.
-        label : int
-            The label a sample will be given if it is predicted to be at this node.
-        proba : float
-            The probability a predicted sample has of being the node's label.
-
-        Returns
-        ---
-        node_id : int
-            Index of the new node just added.
-        """
-
-        node = Node()
-        node.node_id = self.node_count
-        node.impurity = impurity
-        node.n_samples = n_samples
-
-        # If not the root node, set parents
-        if self.node_count > 0:
-            node.parent = parent
-            if is_left:
-                self.nodes[parent].left_child = node.node_id
-            else:
-                self.nodes[parent].right_child = node.node_id
-
-        # Set node parameters
-        if is_leaf:
-            node.is_leaf = True
-            node.label = label
-            node.proba = proba
-        else:
-            node.is_leaf = False
-            node.feature = feature
-            node.threshold = threshold
-            node.proj_mat = proj_mat
-
-        self.node_count += 1
-        self.nodes.append(node)
-
-        return node.node_id
-
-    def build(self):
-        """
-        Builds the oblique tree.
-
-        Parameters
-        ---
-        None
-
-        Returns
-        ---
-        None
-        """
-
-        # Initialize, add root node
-        stack = []
-        root = StackRecord(
-            0,
-            1,
-            False,
-            self.splitter.impurity(self.splitter.indices),
-            self.splitter.indices,
-            self.splitter.n_samples,
-        )
-        stack.append(root)
-
-        # Build tree
-        while len(stack) > 0:
-
-            # Pop a record off the stack
-            cur = stack.pop()
-
-            # Evaluate if it is a leaf
-            is_leaf = (
-                cur.depth >= self.max_depth
-                or cur.n_samples < self.min_samples_split
-                or cur.n_samples < 2 * self.min_samples_leaf
-                or cur.impurity <= self.min_impurity_split
-            )
-
-            # Split if not
-            if not is_leaf:
-                split = self.splitter.split(cur.sample_idx)
-
-                is_leaf = (
-                    is_leaf
-                    or split.no_split
-                    or split.improvement <= self.min_impurity_decrease
-                )
-
-            # Add the node to the tree
-            if is_leaf:
-
-                label, proba = self.splitter.leaf_label_proba(cur.sample_idx)
-
-                node_id = self.add_node(
-                    cur.parent,
-                    cur.is_left,
-                    cur.impurity,
-                    cur.n_samples,
-                    is_leaf,
-                    None,
-                    None,
-                    None,
-                    label,
-                    proba,
-                )
-
-            else:
-                node_id = self.add_node(
-                    cur.parent,
-                    cur.is_left,
-                    cur.impurity,
-                    cur.n_samples,
-                    is_leaf,
-                    split.feature,
-                    split.threshold,
-                    split.proj_mat,
-                    None,
-                    None,
-                )
-
-            # Push the right and left children to the stack if applicable
-            if not is_leaf:
-
-                right_child = StackRecord(
-                    node_id,
-                    cur.depth + 1,
-                    False,
-                    split.right_impurity,
-                    split.right_idx,
-                    split.right_n_samples,
-                )
-                stack.append(right_child)
-
-                left_child = StackRecord(
-                    node_id,
-                    cur.depth + 1,
-                    True,
-                    split.left_impurity,
-                    split.left_idx,
-                    split.left_n_samples,
-                )
-                stack.append(left_child)
-
-            if cur.depth > self.depth:
-                self.depth = cur.depth
-
-    def predict(self, X):
-        """
-        Predicts final nodes of samples given.
-
-        Parameters
-        ---
-        X : array of shape [n_samples, n_features]
-            The input array for which predictions are made.
-
-        Returns
-        ---
-        predictions : array of shape [n_samples]
-            Array of the final node index for each input prediction sample.
-        """
-
-        predictions = np.zeros(X.shape[0])
-        for i in range(X.shape[0]):
-            cur = self.nodes[0]
-            while not cur is None and not cur.is_leaf:
-                proj_X = cur.proj_mat.transform(X)
-                if proj_X[i, cur.feature] < cur.threshold:
-                    id = cur.left_child
-                    cur = self.nodes[id]
-                else:
-                    id = cur.right_child
-                    cur = self.nodes[id]
-
-            predictions[i] = cur.node_id
-
-        return predictions
-
-
-# --------------------------------------------------------------------------
-
-""" Class for Oblique Tree """
-
-
-class ObliqueTreeClassifier(BaseEstimator):
-    """
-    A class used to represent a classifier that uses an oblique decision tree.
-
-    Parameters:
-    ---
-    max_depth : int
-        Maximum depth allowed for oblique tree.
-    min_samples_split : int
-        Minimum number of samples possible at a node.
-    min_samples_leaf : int
-        Minimum number of samples possible at a leaf.
-    random_state : int
-        Maximum depth allowed for the tree.
-    min_impurity_decrease : float
-        Minimum amount Gini impurity value must decrease by for a split to be valid.
-    min_impurity_split : float
-        Minimum Gini impurity value that must be achieved for a split to occur on the node.
-    feature_combinations : float
-        The feature combinations to use for the oblique split.
-    density : float
-        Density estimate.
-
-    Methods
-    ---
-    fit(X,y)
-        Fits the oblique tree to the training samples.
-    apply(X)
-        Calls on the predict function from the oblique tree for the test samples.
-    predict(X)
-        Gets the prediction labels for the test samples.
-    predict_proba(X)
-        Gets the probability of the prediction labels for the test samples.
-    predict_log_proba(X)
-        Gets the log of the probability of the prediction labels for the test samples.
-    """
-
-    def __init__(
-        self,
-        *,
-        # criterion="gini",
-        # splitter=None,
-        max_depth=np.inf,
-        min_samples_split=2,
-        min_samples_leaf=1,
-        # min_weight_fraction_leaf=0,
-        # max_features="auto",
-        # max_leaf_nodes=None,
-        random_state=None,
-        min_impurity_decrease=0,
-        min_impurity_split=0,
-        # class_weight=None,
-        # ccp_alpha=0.0,
-        # New args
-        feature_combinations=1.2,
-        density=0.7
-    ):
-
-        # self.criterion=criterion
-        self.max_depth = max_depth
-        self.min_samples_split = min_samples_split
-        self.min_samples_leaf = min_samples_leaf
-        # self.min_weight_fraction_leaf=min_weight_fraction_leaf
-        # self.max_features=max_features
-        # self.max_leaf_nodes=max_leaf_nodes
-        self.random_state = random_state
-        self.min_impurity_decrease = min_impurity_decrease
-        self.min_impurity_split = min_impurity_split
-        # self.class_weight=class_weight
-        # self.ccp_alpha=ccp_alpha
-
-        self.feature_combinations = feature_combinations
-        self.density = density
-
-    def fit(self, X, y):
-        """
-        Predicts final nodes of samples given.
-
-        Parameters
-        ---
-        X : array of shape [n_samples, n_features]
-            The training samples.
-        y : array of shape [n_samples]
-            Labels for the training samples.
-
-        Returns
-        ---
-        ObliqueTreeClassifier
-            The fit classifier.
-        """
-
-        self.proj_dims = int(np.ceil(X.shape[1]) / self.feature_combinations)
-        splitter = ObliqueSplitter(
-            X, y, self.proj_dims, self.density, self.random_state
-        )
-
-        self.tree = ObliqueTree(
-            splitter,
-            self.min_samples_split,
-            self.min_samples_leaf,
-            self.max_depth,
-            self.min_impurity_split,
-            self.min_impurity_decrease,
-        )
-        self.tree.build()
-        return self
-
-    def apply(self, X):
-        """
-        Gets predictions form the oblique tree for the test samples.
-
-        Parameters
-        ---
-        X : array of shape [n_samples, n_features]
-            The testing samples.
-
-        Returns
-        ---
-        pred_nodes : array of shape[n_samples]
-            The indices for each test sample's final node in the oblique tree.
-        """
-
-        pred_nodes = self.tree.predict(X).astype(int)
-        return pred_nodes
-
-    def predict(self, X):
-        """
-        Determines final label predictions for each sample in the test data.
-
-        Parameters
-        ---
-        X : array of shape [n_samples, n_features]
-            The testing samples.
-
-        Returns
-        ---
-        preds : array of shape[n_samples]
-            The predictions (labels) for each testing sample.
-        """
-
-        preds = np.zeros(X.shape[0])
-        pred_nodes = self.apply(X)
-        for k in range(len(pred_nodes)):
-            id = pred_nodes[k]
-            preds[k] = self.tree.nodes[id].label
-
-        return preds
-
-    def predict_proba(self, X):
-        """
-        Determines probabilities of the final label predictions for each sample in the test data.
-
-        Parameters
-        ---
-        X : array of shape [n_samples, n_features]
-            The testing samples.
-
-        Returns
-        ---
-        preds : array of shape[n_samples]
-            The probabilities of the predictions (labels) for each testing sample.
-        """
-
-        preds = np.zeros(X.shape[0])
-        pred_nodes = self.apply(X)
-        for k in range(len(preds)):
-            id = pred_nodes[k]
-            preds[k] = self.tree.nodes[id].proba
-
-        return preds
-
-    def predict_log_proba(self, X):
-        """
-        Determines log of the probabilities of the final label predictions for each sample in the test data.
-
-        Parameters
-        ---
-        X : array of shape [n_samples, n_features]
-            The testing samples.
-
-        Returns
-        ---
-        preds : array of shape[n_samples]
-            The log of the probabilities of the predictions (labels) for each testing sample.
-        """
-
-        proba = self.predict_proba(X)
-        for k in range(len(proba)):
-            proba[k] = np.log(proba[k])
-
-        return proba
diff --git a/proglearn/tests/oblique_tree_test.py b/proglearn/tests/oblique_tree_test.py
deleted file mode 100644
index f0659cbaff..0000000000
--- a/proglearn/tests/oblique_tree_test.py
+++ /dev/null
@@ -1,155 +0,0 @@
-import pytest
-import numpy as np
-from numpy import random as rng
-from numpy.testing import assert_almost_equal, assert_warns, assert_raises
-from sklearn.datasets import load_iris
-
-from proglearn.oblique_tree import *
-
-
-class TestObliqueSplitter:
-    def test_sample_projmat(self):
-
-        random_state = 0
-        rng.seed(random_state)
-
-        X = rng.rand(100, 100)
-        y = np.zeros(100)
-
-        density = 0.5
-        proj_dims = [10, 20, 40, 60, 80]
-        sample_inds = [
-            np.linspace(0, 9, 10, dtype=int),
-            np.linspace(0, 19, 20, dtype=int),
-            np.linspace(0, 39, 40, dtype=int),
-            np.linspace(0, 59, 60, dtype=int),
-            np.linspace(0, 79, 80, dtype=int),
-        ]
-
-        n_sample_inds = [10, 20, 40, 60, 80]
-
-        for pd in proj_dims:
-            splitter = ObliqueSplitter(X, y, pd, density, random_state)
-
-            for i in range(len(n_sample_inds)):
-                si = sample_inds[i]
-                n = n_sample_inds[i]
-
-                proj_X, projmat = splitter.sample_proj_mat(si)
-                assert n == proj_X.shape[0]
-                assert pd == proj_X.shape[1]
-
-    def test_score(self):
-
-        random_state = 0
-        rng.seed(random_state)
-
-        X = rng.rand(11, 11)
-
-        density = 0.5
-        proj_dims = 5
-
-        y = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
-        splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
-
-        score = splitter.score(y, 6)
-        assert 0 == score
-
-        score = splitter.score(y, 1)
-        assert_almost_equal(5 / 11, score)
-
-    def test_impurity(self):
-
-        random_state = 0
-        rng.seed(random_state)
-
-        X = rng.rand(100, 100)
-
-        density = 0.5
-        proj_dims = 50
-
-        y = np.zeros(100)
-        for i in range(10):
-            for j in range(10):
-                y[10 * i + j] = i
-
-        splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
-
-        # Impurity of one thing should be 0
-        impurity = splitter.impurity([0])
-        assert 0 == impurity
-
-        # Impurity of one class should be 0
-        impurity = splitter.impurity(np.linspace(0, 9, 10, dtype=int))
-        assert 0 == impurity
-
-        # Impurity of two different classes with equal number should be 0.5
-        impurity = splitter.impurity(np.linspace(0, 19, 20, dtype=int))
-        assert 0.5 == impurity
-
-        # Impurity of all classes should be 10 * (1/10)(9/10) = 9/10
-        impurity = splitter.impurity(np.linspace(0, 99, 100, dtype=int))
-        assert_almost_equal(0.9, impurity)
-
-    def test_split(self):
-
-        random_state = 0
-        rng.seed(random_state)
-
-        X = rng.rand(100, 100)
-
-        density = 0.5
-        proj_dims = 50
-
-        y = np.zeros(100)
-        for i in range(10):
-            for j in range(10):
-                y[10 * i + j] = i
-
-        splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
-
-        split_info = splitter.split(np.array([i for i in range(100)]))
-
-
-class TestObliqueTree:
-    def test_add_node(self):
-
-        # Add a root node
-        tree = ObliqueTree(None, 0, 0, 0, 0, 0)
-
-        tree.add_node(0, False, 0, 0, False, 0, 0, None, 0, 0)
-
-        # Add a regular node
-        tree.add_node(0, False, 0, 0, False, 0, 0, None, 0, 0)
-
-        # Add a leaf node
-        tree.add_node(1, False, 0, 0, True, 0, 0, None, 0, 0)
-
-        assert 3 == len(tree.nodes)
-        assert 3 == tree.node_count
-
-    def test_fit(self):
-
-        data = load_iris()
-        clf = ObliqueTreeClassifier()
-        clf.fit(data.data, data.target)
-
-    def test_predict(self):
-        Xtrain = np.random.rand(6, 5)
-        ytrain = np.array([0, 0, 1, 1, 0, 1])
-        tree = ObliqueTreeClassifier()
-        tree.fit(Xtrain, ytrain)
-        Xtest = np.random.rand(3, 5)
-        preds = tree.predict(Xtest)
-
-        assert len(preds) == len(Xtest)
-
-        preds_proba = tree.predict_proba(Xtest)
-        preds_log_proba = tree.predict_log_proba(Xtest)
-
-        assert len(preds_proba) == len(Xtest)
-        assert len(preds_log_proba) == len(Xtest)
-
-        bool_inc = np.all(np.log(preds_proba) == preds_log_proba)
-
-        assert bool_inc
diff --git a/proglearn/tests/test_transformer.py b/proglearn/tests/test_transformer.py
index f7d66f2b39..a4de499ef3 100644
--- a/proglearn/tests/test_transformer.py
+++ b/proglearn/tests/test_transformer.py
@@ -1,9 +1,16 @@
 import pytest
 import numpy as np
-from numpy.testing import assert_allclose
+from numpy.testing import (
+    assert_almost_equal,
+    assert_warns,
+    assert_raises,
+    assert_allclose,
+)
+from numpy import random as rng
+from sklearn.datasets import load_iris
 from sklearn.exceptions import NotFittedError
 
-from proglearn.transformers import TreeClassificationTransformer
+from proglearn.transformers import *
 
 
 class TestTreeClassificationTransformer:
@@ -31,3 +38,151 @@ def test_correct_transformation(self):
         u1 = trt.transform(np.array([0]).reshape(1, -1))
         u2 = trt.transform(np.array([1]).reshape(1, -1))
         assert u1 != u2
+
+
+class TestObliqueSplitter:
+    def test_sample_projmat(self):
+
+        random_state = 0
+        rng.seed(random_state)
+
+        X = rng.rand(100, 100)
+        y = np.zeros(100)
+
+        density = 0.5
+        proj_dims = [10, 20, 40, 60, 80]
+        sample_inds = [
+            np.linspace(0, 9, 10, dtype=int),
+            np.linspace(0, 19, 20, dtype=int),
+            np.linspace(0, 39, 40, dtype=int),
+            np.linspace(0, 59, 60, dtype=int),
+            np.linspace(0, 79, 80, dtype=int),
+        ]
+
+        n_sample_inds = [10, 20, 40, 60, 80]
+
+        for pd in proj_dims:
+            splitter = ObliqueSplitter(X, y, pd, density, random_state)
+
+            for i in range(len(n_sample_inds)):
+                si = sample_inds[i]
+                n = n_sample_inds[i]
+
+                proj_X, projmat = splitter.sample_proj_mat(si)
+                assert n == proj_X.shape[0]
+                assert pd == proj_X.shape[1]
+
+    def test_score(self):
+
+        random_state = 0
+        rng.seed(random_state)
+
+        X = rng.rand(11, 11)
+
+        density = 0.5
+        proj_dims = 5
+
+        y = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
+        splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
+
+        score = splitter.score(y, 6)
+        assert 0 == score
+
+        score = splitter.score(y, 1)
+        assert_almost_equal(5 / 11, score)
+
+    def test_impurity(self):
+
+        random_state = 0
+        rng.seed(random_state)
+
+        X = rng.rand(100, 100)
+
+        density = 0.5
+        proj_dims = 50
+
+        y = np.zeros(100)
+        for i in range(10):
+            for j in range(10):
+                y[10 * i + j] = i
+
+        splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
+
+        # Impurity of one thing should be 0
+        impurity = splitter.impurity([0])
+        assert 0 == impurity
+
+        # Impurity of one class should be 0
+        impurity = splitter.impurity(np.linspace(0, 9, 10, dtype=int))
+        assert 0 == impurity
+
+        # Impurity of two different classes with equal number should be 0.5
+        impurity = splitter.impurity(np.linspace(0, 19, 20, dtype=int))
+        assert 0.5 == impurity
+
+        # Impurity of all classes should be 10 * (1/10)(9/10) = 9/10
+        impurity = splitter.impurity(np.linspace(0, 99, 100, dtype=int))
+        assert_almost_equal(0.9, impurity)
+
+    def test_split(self):
+
+        random_state = 0
+        rng.seed(random_state)
+
+        X = rng.rand(100, 100)
+
+        density = 0.5
+        proj_dims = 50
+
+        y = np.zeros(100)
+        for i in range(10):
+            for j in range(10):
+                y[10 * i + j] = i
+
+        splitter = ObliqueSplitter(X, y, proj_dims, density, random_state)
+
+        split_info = splitter.split(np.array([i for i in range(100)]))
+
+
+class TestObliqueTree:
+    def test_add_node(self):
+
+        # Add a root node
+        tree = ObliqueTree(None, 0, 0, 0, 0, 0)
+
+        tree.add_node(0, False, 0, 0, False, 0, 0, None, 0, 0)
+
+        # Add a regular node
+        tree.add_node(0, False, 0, 0, False, 0, 0, None, 0, 0)
+
+        # Add a leaf node
+        tree.add_node(1, False, 0, 0, True, 0, 0, None, 0, 0)
+
+        assert 3 == len(tree.nodes)
+        assert 3 == tree.node_count
+
+    def test_fit(self):
+
+        data = load_iris()
+        clf = ObliqueTreeClassifier()
+        clf.fit(data.data, data.target)
+
+    def test_predict(self):
+        Xtrain = np.random.rand(6, 5)
+        ytrain = np.array([0, 0, 1, 1, 0, 1])
+        tree = ObliqueTreeClassifier()
+        tree.fit(Xtrain, ytrain)
+        Xtest = np.random.rand(3, 5)
+        preds = tree.predict(Xtest)
+
+        assert len(preds) == len(Xtest)
+
+        preds_proba = tree.predict_proba(Xtest)
+        preds_log_proba = tree.predict_log_proba(Xtest)
+
+        assert len(preds_proba) == len(Xtest)
+        assert len(preds_log_proba) == len(Xtest)
+
+        bool_inc = np.all(np.log(preds_proba) == preds_log_proba)
+
+        assert bool_inc
diff --git a/proglearn/transformers.py b/proglearn/transformers.py
old mode 100755
new mode 100644
index 756d0bde28..cc22acaa20
--- a/proglearn/transformers.py
+++ b/proglearn/transformers.py
@@ -5,6 +5,9 @@
 import numpy as np
 
 from sklearn.tree import DecisionTreeClassifier
+from sklearn.base import BaseEstimator
+from sklearn.random_projection import SparseRandomProjection
+
 
 from sklearn.utils.validation import (
     check_X_y,
@@ -15,7 +18,6 @@
 import keras as keras
 
 from .base import BaseTransformer
-from .oblique_tree import ObliqueTreeClassifier
 
 
 class NeuralClassificationTransformer(BaseTransformer):
@@ -208,8 +210,8 @@ class ObliqueTreeClassificationTransformer(BaseTransformer):
 
     Attributes
     ----------
-    transformer : sklearn.tree.DecisionTreeClassifier
-        an internal sklearn DecisionTreeClassifier
+    transformer : ObliqueTreeClassifier
+        an sklearn compliant oblique decisiotn tree (SPORF)
     """
 
     def __init__(self, kwargs={}):
@@ -257,3 +259,870 @@ def transform(self, X):
         check_is_fitted(self)
         X = check_array(X)
         return self.transformer_.apply(X)
+
+
+"""
+Authors: Parth Vora and Jay Mandavilli
+
+Oblique Decision Tree (SPORF)
+"""
+# --------------------------------------------------------------------------
+class SplitInfo:
+    """
+    A class used to store information about a certain split.
+
+    Parameters:
+    ---
+    feature : int
+        The feature which is used for the particular split.
+    threshold : float
+        The feature value which defines the split, if an example has a value less
+        than this threshold for the feature of this split then it will go to the
+        left child, otherwise it wil go the right child where these children are
+        the children nodes of the node for which this split defines.
+    proj_mat : array of shape [n_components, n_features]
+        The sparse random projection matrix for this split.
+    left_impurity : float
+        This is Gini impurity of left side of the split.
+    left_idx : array of shape [left_n_samples]
+        This is the indices of the nodes that are in the left side of this split.
+    left_n_samples : int
+        The number of samples in the left side of this split.
+    right_impurity : float
+        This is Gini impurity of right side of the split.
+    right_idx : array of shape [right_n_samples]
+        This is the indices of the nodes that are in the right side of this split.
+    right_n_samples : int
+        The number of samples in the right side of this split.
+    no_split : bool
+        A boolean specifying if there is a valid split or not. Here an invalid
+        split means all of the samples would go to one side.
+    improvement : float
+        A metric to determine if the split improves the decision tree.
+    """
+
+    def __init__(
+        self,
+        feature,
+        threshold,
+        proj_mat,
+        left_impurity,
+        left_idx,
+        left_n_samples,
+        right_impurity,
+        right_idx,
+        right_n_samples,
+        no_split,
+        improvement,
+    ):
+
+        self.feature = feature
+        self.threshold = threshold
+        self.proj_mat = proj_mat
+        self.left_impurity = left_impurity
+        self.left_idx = left_idx
+        self.left_n_samples = left_n_samples
+        self.right_impurity = right_impurity
+        self.right_idx = right_idx
+        self.right_n_samples = right_n_samples
+        self.no_split = no_split
+        self.improvement = improvement
+
+
+class ObliqueSplitter:
+    """
+    A class used to represent an oblique splitter, where splits are done on
+    the linear combination of the features.
+
+    Parameters:
+    ---
+    X : array of shape [n_samples, n_features]
+        The input data X is a matrix of the examples and their respective feature
+        values for each of the features.
+    y : array of shape [n_samples]
+        The labels for each of the examples in X.
+    proj_dims : int
+        The dimensionality of the target projection space.
+    density : float
+        Ratio of non-zero component in the random projection matrix in the range '(0, 1]'.
+    random_state : int
+        Controls the pseudo random number generator used to generate the projection matrix.
+
+    Methods
+    ---
+    sample_proj_mat(sample_inds)
+        This gets the projection matrix and it fits the transform to the samples of interest.
+    leaf_label_proba(idx)
+        This calculates the label and the probability for that label for a particular leaf
+        node.
+    score(y_sort, t)
+        Finds the Gini impurity for a split.
+    impurity(idx)
+        Finds the impurity for a certain set of samples.
+    split(sample_inds)
+        Determines the best possible split for the given set of samples.
+    """
+
+    def __init__(self, X, y, proj_dims, density, random_state):
+
+        self.X = X
+        self.y = y
+
+        self.classes = np.array(np.unique(y), dtype=int)
+        self.n_classes = len(self.classes)
+        self.indices = np.indices(y.shape)[0]
+
+        self.n_samples = X.shape[0]
+
+        self.proj_dims = proj_dims
+        self.density = density
+        self.random_state = random_state
+
+    def sample_proj_mat(self, sample_inds):
+        """
+        Gets the projection matrix and it fits the transform to the samples of interest.
+
+        Parameters
+        ---
+        sample_inds : array of shape [n_samples]
+            The data we are transforming.
+
+        Returns
+        ---
+        proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
+            The generated sparse random matrix.
+        proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
+            Projected matrix.
+        """
+
+        proj_mat = SparseRandomProjection(
+            density=self.density,
+            n_components=self.proj_dims,
+            random_state=self.random_state,
+        )
+
+        proj_X = proj_mat.fit_transform(self.X[sample_inds, :])
+        return proj_X, proj_mat
+
+    def leaf_label_proba(self, idx):
+        """
+         Finds the most common label and probability of this label from the samples at
+         the leaf node for which this is used on.
+
+         Parameters
+         ---
+         idx : array of shape [n_samples]
+             The indices of the samples that are at the leaf node for which the label
+             and probability need to be found.
+
+         Returns
+         ---
+        label : int
+             The label for any sample that is predicted to be at this node.
+         proba : float
+             The probability of the predicted sample to have this node's label.
+        """
+
+        samples = self.y[idx]
+        n = len(samples)
+        labels, count = np.unique(samples, return_counts=True)
+        most = np.argmax(count)
+
+        label = labels[most]
+        proba = count[most] / n
+
+        return label, proba
+
+    # Returns gini impurity for split
+    # Expects 0 < t < n
+    def score(self, y_sort, t):
+        """
+        Finds the Gini impurity for the split of interest
+
+        Parameters
+        ---
+        y_sort : array of shape [n_samples]
+            A sorted array of labels for the examples for which the Gini impurity
+            is being calculated.
+        t : float
+            The threshold determining where to split y_sort.
+
+        Returns
+        ---
+        gini : float
+            The Gini impurity of the split.
+        """
+
+        left = y_sort[:t]
+        right = y_sort[t:]
+
+        n_left = len(left)
+        n_right = len(right)
+
+        left_unique, left_counts = np.unique(left, return_counts=True)
+        right_unique, right_counts = np.unique(right, return_counts=True)
+
+        left_counts = left_counts / n_left
+        right_counts = right_counts / n_right
+
+        left_gini = 1 - np.sum(np.power(left_counts, 2))
+        right_gini = 1 - np.sum(np.power(right_counts, 2))
+
+        gini = (n_left / self.n_samples) * left_gini + (
+            n_right / self.n_samples
+        ) * right_gini
+        return gini
+
+    # Returns impurity for a group of examples
+    # expects idx not None
+    def impurity(self, idx):
+        """
+        Finds the actual impurity for a set of samples
+
+        Parameters
+        ---
+        idx : array of shape [n_samples]
+            The indices of the nodes in the set for which the impurity is being calculated.
+
+        Returns
+        ---
+        impurity : float
+            Actual impurity of split.
+        """
+
+        samples = self.y[idx]
+        n = len(samples)
+
+        if n == 0:
+            return 0
+
+        unique, count = np.unique(samples, return_counts=True)
+        count = count / n
+        gini = np.sum(np.power(count, 2))
+
+        return 1 - gini
+
+    # Finds the best split
+    # This needs to be parallelized; its a major bottleneck
+    def split(self, sample_inds):
+        """
+        Finds the optimal split for a set of samples.
+        Note that the code for this method needs to be parallelized. This is a major
+        bottleneck in integration with scikit-learn.
+
+        Parameters
+        ---
+        sample_inds : array of shape [n_samples]
+            The indices of the nodes in the set for which the best split is found.
+
+        Returns
+        ---
+        split_info : SplitInfo
+            Class holding information about the split.
+        """
+
+        # Project the data
+        proj_X, proj_mat = self.sample_proj_mat(sample_inds)
+        y_sample = self.y[sample_inds]
+        n_samples = len(sample_inds)
+
+        # Score matrix
+        # No split score is just node impurity
+        Q = np.zeros((n_samples, self.proj_dims))
+        node_impurity = self.impurity(sample_inds)
+        Q[0, :] = node_impurity
+        Q[-1, :] = node_impurity
+
+        # Loop through projected features and examples to find best split
+        # This can be parallelized for sure
+        for j in range(self.proj_dims):
+
+            # Sort labels by the jth feature
+            idx = np.argsort(proj_X[:, j])
+            y_sort = y_sample[idx]
+
+            Q[1:-1, j] = np.array(
+                [self.score(y_sort, i) for i in range(1, n_samples - 1)]
+            )
+
+        # Identify best split feature, minimum gini impurity
+        best_split_ind = np.argmin(Q)
+        thresh_i, feature = np.unravel_index(best_split_ind, Q.shape)
+        best_gini = Q[thresh_i, feature]
+
+        # Sort samples by the split feature
+        feat_vec = proj_X[:, feature]
+        idx = np.argsort(feat_vec)
+
+        feat_vec = feat_vec[idx]
+        sample_inds = sample_inds[idx]
+
+        # Get the threshold, split samples into left and right
+        threshold = feat_vec[thresh_i]
+        left_idx = sample_inds[:thresh_i]
+        right_idx = sample_inds[thresh_i:]
+
+        left_n_samples = len(left_idx)
+        right_n_samples = len(right_idx)
+
+        # See if we have no split
+        no_split = left_n_samples == 0 or right_n_samples == 0
+
+        # Evaluate improvement
+        improvement = node_impurity - best_gini
+
+        # Evaluate impurities for left and right children
+        left_impurity = self.impurity(left_idx)
+        right_impurity = self.impurity(right_idx)
+
+        split_info = SplitInfo(
+            feature,
+            threshold,
+            proj_mat,
+            left_impurity,
+            left_idx,
+            left_n_samples,
+            right_impurity,
+            right_idx,
+            right_n_samples,
+            no_split,
+            improvement,
+        )
+
+        return split_info
+
+
+# --------------------------------------------------------------------------
+
+
+class Node:
+    """
+    A class used to represent an oblique node.
+
+    Parameters:
+    ---
+    None
+
+    Methods
+    ---
+    None
+    """
+
+    def __init__(self):
+        self.node_id = None
+        self.is_leaf = None
+        self.parent = None
+        self.left_child = None
+        self.right_child = None
+
+        self.feature = None
+        self.threshold = None
+        self.impurity = None
+        self.n_samples = None
+
+        self.proj_mat = None
+        self.label = None
+        self.proba = None
+
+
+class StackRecord:
+    """
+    A class used to keep track of a node's parent and other information about the node and its split.
+
+    Parameters:
+    ---
+    parent : int
+        The index of the parent node.
+    depth : int
+        The depth at which this node is.
+    is_left : bool
+        Represents if the node is a left child or not.
+    impurity : float
+        This is Gini impurity of this node.
+    sample_idx : array of shape [n_samples]
+        This is the indices of the nodes that are in this node.
+    n_samples : int
+        The number of samples in this node.
+
+    Methods
+    ---
+    None
+    """
+
+    def __init__(self, parent, depth, is_left, impurity, sample_idx, n_samples):
+
+        self.parent = parent
+        self.depth = depth
+        self.is_left = is_left
+        self.impurity = impurity
+        self.sample_idx = sample_idx
+        self.n_samples = n_samples
+
+
+class ObliqueTree:
+    """
+    A class used to represent a tree with oblique splits.
+
+    Parameters:
+    ---
+    splitter : class
+        The type of splitter for this tree, should be an ObliqueSplitter.
+    min_samples_split : int
+        Minimum number of samples possible at a node.
+    min_samples_leaf : int
+        Minimum number of samples possible at a leaf.
+    max_depth : int
+        Maximum depth allowed for the tree.
+    min_impurity_split : float
+        Minimum Gini impurity value that must be achieved for a split to occur on the node.
+    min_impurity_decrease : float
+        Minimum amount Gini impurity value must decrease by for a split to be valid.
+
+    Methods
+    ---
+    add_node(parent, is_left, impurity, n_samples, is_leaf, feature, threshold, proj_mat, label, proba)
+        Adds a node to the existing tree
+    build()
+        This is what is initially called on to completely build the oblique tree.
+    predict(X)
+        Finds the final node for each input sample as it passes through the decision tree.
+    """
+
+    def __init__(
+        self,
+        splitter,
+        min_samples_split,
+        min_samples_leaf,
+        max_depth,
+        min_impurity_split,
+        min_impurity_decrease,
+    ):
+
+        # Tree parameters
+        # self.n_samples = n_samples
+        # self.n_features = n_features
+        # self.n_classes = n_classes
+        self.depth = 0
+        self.node_count = 0
+        self.nodes = []
+
+        # Build parameters
+        self.splitter = splitter
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        self.max_depth = max_depth
+        self.min_impurity_split = min_impurity_split
+        self.min_impurity_decrease = min_impurity_decrease
+
+    def add_node(
+        self,
+        parent,
+        is_left,
+        impurity,
+        n_samples,
+        is_leaf,
+        feature,
+        threshold,
+        proj_mat,
+        label,
+        proba,
+    ):
+        """
+        Adds a node to the existing oblique tree.
+
+        Parameters
+        ---
+        parent : int
+            The index of the parent node for the new node being added.
+        is_left : bool
+            Determines if this new node being added is a left or right child.
+        impurity : float
+            Impurity of this new node.
+        n_samples : int
+            Number of samples at this new node.
+        is_leaf : bool
+            Determines if this new node is a leaf of the tree or an internal node.
+        feature : int
+            Index of feature on which the split occurs at this node.
+        threshold : float
+            The threshold feature value for this node determining if a sample will go
+            to this node's left of right child. If a sample has a value less than the
+            threshold (for the feature of this node) it will go to the left childe,
+            otherwise it will go the right child.
+        proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
+            Projection matrix for this new node.
+        label : int
+            The label a sample will be given if it is predicted to be at this node.
+        proba : float
+            The probability a predicted sample has of being the node's label.
+
+        Returns
+        ---
+        node_id : int
+            Index of the new node just added.
+        """
+
+        node = Node()
+        node.node_id = self.node_count
+        node.impurity = impurity
+        node.n_samples = n_samples
+
+        # If not the root node, set parents
+        if self.node_count > 0:
+            node.parent = parent
+            if is_left:
+                self.nodes[parent].left_child = node.node_id
+            else:
+                self.nodes[parent].right_child = node.node_id
+
+        # Set node parameters
+        if is_leaf:
+            node.is_leaf = True
+            node.label = label
+            node.proba = proba
+        else:
+            node.is_leaf = False
+            node.feature = feature
+            node.threshold = threshold
+            node.proj_mat = proj_mat
+
+        self.node_count += 1
+        self.nodes.append(node)
+
+        return node.node_id
+
+    def build(self):
+        """
+        Builds the oblique tree.
+
+        Parameters
+        ---
+        None
+
+        Returns
+        ---
+        None
+        """
+
+        # Initialize, add root node
+        stack = []
+        root = StackRecord(
+            0,
+            1,
+            False,
+            self.splitter.impurity(self.splitter.indices),
+            self.splitter.indices,
+            self.splitter.n_samples,
+        )
+        stack.append(root)
+
+        # Build tree
+        while len(stack) > 0:
+
+            # Pop a record off the stack
+            cur = stack.pop()
+
+            # Evaluate if it is a leaf
+            is_leaf = (
+                cur.depth >= self.max_depth
+                or cur.n_samples < self.min_samples_split
+                or cur.n_samples < 2 * self.min_samples_leaf
+                or cur.impurity <= self.min_impurity_split
+            )
+
+            # Split if not
+            if not is_leaf:
+                split = self.splitter.split(cur.sample_idx)
+
+                is_leaf = (
+                    is_leaf
+                    or split.no_split
+                    or split.improvement <= self.min_impurity_decrease
+                )
+
+            # Add the node to the tree
+            if is_leaf:
+
+                label, proba = self.splitter.leaf_label_proba(cur.sample_idx)
+
+                node_id = self.add_node(
+                    cur.parent,
+                    cur.is_left,
+                    cur.impurity,
+                    cur.n_samples,
+                    is_leaf,
+                    None,
+                    None,
+                    None,
+                    label,
+                    proba,
+                )
+
+            else:
+                node_id = self.add_node(
+                    cur.parent,
+                    cur.is_left,
+                    cur.impurity,
+                    cur.n_samples,
+                    is_leaf,
+                    split.feature,
+                    split.threshold,
+                    split.proj_mat,
+                    None,
+                    None,
+                )
+
+            # Push the right and left children to the stack if applicable
+            if not is_leaf:
+
+                right_child = StackRecord(
+                    node_id,
+                    cur.depth + 1,
+                    False,
+                    split.right_impurity,
+                    split.right_idx,
+                    split.right_n_samples,
+                )
+                stack.append(right_child)
+
+                left_child = StackRecord(
+                    node_id,
+                    cur.depth + 1,
+                    True,
+                    split.left_impurity,
+                    split.left_idx,
+                    split.left_n_samples,
+                )
+                stack.append(left_child)
+
+            if cur.depth > self.depth:
+                self.depth = cur.depth
+
+    def predict(self, X):
+        """
+        Predicts final nodes of samples given.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The input array for which predictions are made.
+
+        Returns
+        ---
+        predictions : array of shape [n_samples]
+            Array of the final node index for each input prediction sample.
+        """
+
+        predictions = np.zeros(X.shape[0])
+        for i in range(X.shape[0]):
+            cur = self.nodes[0]
+            while not cur is None and not cur.is_leaf:
+                proj_X = cur.proj_mat.transform(X)
+                if proj_X[i, cur.feature] < cur.threshold:
+                    id = cur.left_child
+                    cur = self.nodes[id]
+                else:
+                    id = cur.right_child
+                    cur = self.nodes[id]
+
+            predictions[i] = cur.node_id
+
+        return predictions
+
+
+# --------------------------------------------------------------------------
+
+""" Class for Oblique Tree """
+
+
+class ObliqueTreeClassifier(BaseEstimator):
+    """
+    A class used to represent a classifier that uses an oblique decision tree.
+
+    Parameters:
+    ---
+    max_depth : int
+        Maximum depth allowed for oblique tree.
+    min_samples_split : int
+        Minimum number of samples possible at a node.
+    min_samples_leaf : int
+        Minimum number of samples possible at a leaf.
+    random_state : int
+        Maximum depth allowed for the tree.
+    min_impurity_decrease : float
+        Minimum amount Gini impurity value must decrease by for a split to be valid.
+    min_impurity_split : float
+        Minimum Gini impurity value that must be achieved for a split to occur on the node.
+    feature_combinations : float
+        The feature combinations to use for the oblique split.
+    density : float
+        Density estimate.
+
+    Methods
+    ---
+    fit(X,y)
+        Fits the oblique tree to the training samples.
+    apply(X)
+        Calls on the predict function from the oblique tree for the test samples.
+    predict(X)
+        Gets the prediction labels for the test samples.
+    predict_proba(X)
+        Gets the probability of the prediction labels for the test samples.
+    predict_log_proba(X)
+        Gets the log of the probability of the prediction labels for the test samples.
+    """
+
+    def __init__(
+        self,
+        *,
+        # criterion="gini",
+        # splitter=None,
+        max_depth=np.inf,
+        min_samples_split=2,
+        min_samples_leaf=1,
+        # min_weight_fraction_leaf=0,
+        # max_features="auto",
+        # max_leaf_nodes=None,
+        random_state=None,
+        min_impurity_decrease=0,
+        min_impurity_split=0,
+        # class_weight=None,
+        # ccp_alpha=0.0,
+        # New args
+        feature_combinations=1.2,
+        density=0.7
+    ):
+
+        # self.criterion=criterion
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        # self.min_weight_fraction_leaf=min_weight_fraction_leaf
+        # self.max_features=max_features
+        # self.max_leaf_nodes=max_leaf_nodes
+        self.random_state = random_state
+        self.min_impurity_decrease = min_impurity_decrease
+        self.min_impurity_split = min_impurity_split
+        # self.class_weight=class_weight
+        # self.ccp_alpha=ccp_alpha
+
+        self.feature_combinations = feature_combinations
+        self.density = density
+
+    def fit(self, X, y):
+        """
+        Predicts final nodes of samples given.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The training samples.
+        y : array of shape [n_samples]
+            Labels for the training samples.
+
+        Returns
+        ---
+        ObliqueTreeClassifier
+            The fit classifier.
+        """
+
+        self.proj_dims = int(np.ceil(X.shape[1]) / self.feature_combinations)
+        splitter = ObliqueSplitter(
+            X, y, self.proj_dims, self.density, self.random_state
+        )
+
+        self.tree = ObliqueTree(
+            splitter,
+            self.min_samples_split,
+            self.min_samples_leaf,
+            self.max_depth,
+            self.min_impurity_split,
+            self.min_impurity_decrease,
+        )
+        self.tree.build()
+        return self
+
+    def apply(self, X):
+        """
+        Gets predictions form the oblique tree for the test samples.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The testing samples.
+
+        Returns
+        ---
+        pred_nodes : array of shape[n_samples]
+            The indices for each test sample's final node in the oblique tree.
+        """
+
+        pred_nodes = self.tree.predict(X).astype(int)
+        return pred_nodes
+
+    def predict(self, X):
+        """
+        Determines final label predictions for each sample in the test data.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The testing samples.
+
+        Returns
+        ---
+        preds : array of shape[n_samples]
+            The predictions (labels) for each testing sample.
+        """
+
+        preds = np.zeros(X.shape[0])
+        pred_nodes = self.apply(X)
+        for k in range(len(pred_nodes)):
+            id = pred_nodes[k]
+            preds[k] = self.tree.nodes[id].label
+
+        return preds
+
+    def predict_proba(self, X):
+        """
+        Determines probabilities of the final label predictions for each sample in the test data.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The testing samples.
+
+        Returns
+        ---
+        preds : array of shape[n_samples]
+            The probabilities of the predictions (labels) for each testing sample.
+        """
+
+        preds = np.zeros(X.shape[0])
+        pred_nodes = self.apply(X)
+        for k in range(len(preds)):
+            id = pred_nodes[k]
+            preds[k] = self.tree.nodes[id].proba
+
+        return preds
+
+    def predict_log_proba(self, X):
+        """
+        Determines log of the probabilities of the final label predictions for each sample in the test data.
+
+        Parameters
+        ---
+        X : array of shape [n_samples, n_features]
+            The testing samples.
+
+        Returns
+        ---
+        preds : array of shape[n_samples]
+            The log of the probabilities of the predictions (labels) for each testing sample.
+        """
+
+        proba = self.predict_proba(X)
+        for k in range(len(proba)):
+            proba[k] = np.log(proba[k])
+
+        return proba

From ecb7b0718d7a26141b856bee85e71e1d7caaec42 Mon Sep 17 00:00:00 2001
From: parthgvora <parthgvora@gmail.com>
Date: Fri, 11 Dec 2020 12:06:21 -0500
Subject: [PATCH 11/17] oblique trees added

---
 proglearn/forest.py            |  5 ++++-
 proglearn/tests/test_forest.py | 12 +++++++++++-
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/proglearn/forest.py b/proglearn/forest.py
index e8812b8148..50ff12a3b8 100644
--- a/proglearn/forest.py
+++ b/proglearn/forest.py
@@ -3,7 +3,10 @@
 Corresponding Email: levinewill@icloud.com
 """
 from .progressive_learner import ClassificationProgressiveLearner
-from .transformers import TreeClassificationTransformer
+from .transformers import (
+    TreeClassificationTransformer,
+    ObliqueTreeClassificationTransformer,
+)
 from .voters import TreeClassificationVoter
 from .deciders import SimpleArgmaxAverage
 
diff --git a/proglearn/tests/test_forest.py b/proglearn/tests/test_forest.py
index acf7e9976b..b03a4d1323 100644
--- a/proglearn/tests/test_forest.py
+++ b/proglearn/tests/test_forest.py
@@ -4,7 +4,10 @@
 import random
 
 from proglearn.forest import LifelongClassificationForest
-from proglearn.transformers import TreeClassificationTransformer
+from proglearn.transformers import (
+    TreeClassificationTransformer,
+    ObliqueTreeClassificationTransformer,
+)
 from proglearn.voters import TreeClassificationVoter
 from proglearn.deciders import SimpleArgmaxAverage
 
@@ -47,3 +50,10 @@ def test_correct_default_n_estimators(self):
     def test_correct_true_initilization_finite_sample_correction(self):
         l2f = LifelongClassificationForest(default_kappa=np.inf)
         assert l2f.pl_.default_voter_kwargs == {"kappa": np.inf}
+
+    def test_oblique_transformer(self):
+        l2f = LifelongClassificationForest(oblique=True)
+        assert l2f.pl_.default_transformer_class == ObliqueTreeClassificationTransformer
+        assert l2f.default_feature_combinations == 1.5
+        assert l2f.default_density == 0.5
+        assert l2f.pl_.default_transformer_kwargs == {}

From 39cf94a311427212630f83098c1ea54125d9c770 Mon Sep 17 00:00:00 2001
From: parthgvora <parthgvora@gmail.com>
Date: Fri, 11 Dec 2020 12:36:32 -0500
Subject: [PATCH 12/17] consistency of default params

---
 proglearn/transformers.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/proglearn/transformers.py b/proglearn/transformers.py
index cc22acaa20..ea042606b1 100644
--- a/proglearn/transformers.py
+++ b/proglearn/transformers.py
@@ -989,8 +989,8 @@ def __init__(
         # class_weight=None,
         # ccp_alpha=0.0,
         # New args
-        feature_combinations=1.2,
-        density=0.7
+        feature_combinations=1.5,
+        density=0.5
     ):
 
         # self.criterion=criterion

From df391b6a7afc8139203803561dd72364e504ec71 Mon Sep 17 00:00:00 2001
From: Jay <jmandav1@jhu.edu>
Date: Fri, 11 Dec 2020 17:41:29 -0700
Subject: [PATCH 13/17] made some documentation changes and created decision
 boundaries notebook

---
 .../oblique_decision_boundaries_functions.py  |  96 +++++
 .../functions/sporf_datasets_functions.py     |  90 +++++
 .../oblique_decision_boundaries.ipynb         | 138 ++++++++
 docs/tutorials/sporf_datasets.ipynb           | 331 ++++++++++++++++++
 proglearn/forest.py                           |  15 +
 proglearn/transformers.py                     |  86 ++---
 6 files changed, 713 insertions(+), 43 deletions(-)
 create mode 100644 docs/tutorials/functions/oblique_decision_boundaries_functions.py
 create mode 100644 docs/tutorials/functions/sporf_datasets_functions.py
 create mode 100644 docs/tutorials/oblique_decision_boundaries.ipynb
 create mode 100644 docs/tutorials/sporf_datasets.ipynb

diff --git a/docs/tutorials/functions/oblique_decision_boundaries_functions.py b/docs/tutorials/functions/oblique_decision_boundaries_functions.py
new file mode 100644
index 0000000000..7be5367339
--- /dev/null
+++ b/docs/tutorials/functions/oblique_decision_boundaries_functions.py
@@ -0,0 +1,96 @@
+from rerf.rerfClassifier import rerfClassifier
+
+import numpy as np
+np.random.seed(42)
+
+import matplotlib.pyplot as plt
+from matplotlib.colors import ListedColormap
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.datasets import make_moons, make_circles, make_classification
+from sklearn.ensemble import RandomForestClassifier
+
+from proglearn.forest import LifelongClassificationForest
+from proglearn.voters import TreeClassificationVoter
+from proglearn.transformers import TreeClassificationTransformer
+from proglearn.transformers import ObliqueTreeClassificationTransformer
+from proglearn.deciders import SimpleArgmaxAverage
+
+def test(NT, h, names, classifiers, datasets):
+    i = 1
+    # iterate over datasets
+    for ds_cnt, ds in enumerate(datasets):
+        # preprocess dataset, split into training and test part
+        X, y = ds
+        X = StandardScaler().fit_transform(X)
+        X_train, X_test, y_train, y_test = \
+            train_test_split(X, y, test_size=.4, random_state=42)
+
+        x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
+        y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
+        xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
+                             np.arange(y_min, y_max, h))
+
+        # just plot the dataset first
+        cm = plt.cm.RdBu
+        cm_bright = ListedColormap(['#FF0000', '#0000FF'])
+        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
+        if ds_cnt == 0:
+            ax.set_title("Input data")
+        # Plot the training points
+        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,
+                   edgecolors='k')
+        # Plot the testing points
+        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6,
+                   edgecolors='k')
+        ax.set_xlim(xx.min(), xx.max())
+        ax.set_ylim(yy.min(), yy.max())
+        ax.set_xticks(())
+        ax.set_yticks(())
+        i += 1
+
+        # iterate over classifiers
+        for name, clf in zip(names, classifiers):
+            ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
+
+            if "Proglearn" in name:
+
+                clf = LifelongClassificationForest(oblique=True,
+                                                   default_feature_combinations=1, default_density=0.5)
+                clf.add_task(X_train, y_train, n_estimators=NT)
+                y_hat = clf.predict(X_test, task_id=0)
+                score = np.sum(y_hat == y_test) / len(y_test)
+
+            else:
+                clf.fit(X_train, y_train)
+                score = clf.score(X_test, y_test)
+
+            # Plot the decision boundary. For that, we will assign a color to each
+            # point in the mesh [x_min, x_max]x[y_min, y_max].
+            if hasattr(clf, "decision_function"):
+                Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
+            elif "Proglearn" in name:
+                Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()], task_id=0)[:, 1]
+            else:
+                Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
+
+            # Put the result into a color plot
+            Z = Z.reshape(xx.shape)
+            ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)
+
+            # Plot the training points
+            ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,
+                       edgecolors='k')
+            # Plot the testing points
+            ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,
+                       edgecolors='k', alpha=0.6)
+
+            ax.set_xlim(xx.min(), xx.max())
+            ax.set_ylim(yy.min(), yy.max())
+            ax.set_xticks(())
+            ax.set_yticks(())
+            if ds_cnt == 0:
+                ax.set_title(name)
+            ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),
+                    size=15, horizontalalignment='right')
+            i += 1
\ No newline at end of file
diff --git a/docs/tutorials/functions/sporf_datasets_functions.py b/docs/tutorials/functions/sporf_datasets_functions.py
new file mode 100644
index 0000000000..cbee97c497
--- /dev/null
+++ b/docs/tutorials/functions/sporf_datasets_functions.py
@@ -0,0 +1,90 @@
+import sys
+import numpy as np
+import pandas as pd
+import csv
+from numpy import genfromtxt
+
+from proglearn.progressive_learner import ProgressiveLearner
+from proglearn.voters import TreeClassificationVoter
+from proglearn.transformers import TreeClassificationTransformer
+from proglearn.transformers import ObliqueTreeClassificationTransformer
+from proglearn.deciders import SimpleArgmaxAverage
+
+from sklearn.model_selection import train_test_split, cross_val_score
+
+def load_simulated_data(file):
+    data = genfromtxt(file, delimiter=',')
+    X = data[:, :-1]
+    y = data[:, -1]
+
+    return X, y
+
+def load_data(data_file, task_num):
+    if "Hill_Valley" in data_file:
+        df = pd.read_csv(data_file)
+        X = df[df.columns[:-1]].to_numpy()
+        y = df[df.columns[-1]].to_numpy()
+
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, shuffle=True, stratify=y)
+
+    if "acute" in data_file:
+
+        df = pd.read_table(data_file, encoding='utf-16')
+        df[df == "no"] = 0
+        df[df == "yes"] = 1
+
+        data = df.to_numpy()
+        temps = data[:, 0]
+
+        temperature = []
+        for i in range(len(temps)):
+            temp_str = temps[i]
+            temp_str = temp_str.replace(",", ".")
+            temperature.append(float(temp_str))
+
+        data[:, 0] = np.array(temperature)
+
+        X = np.array(data[:, :5], dtype=float)
+
+        # 6 for task 1, 7 for task 2
+        if task_num == 1:
+            y = np.array(data[:, 6], dtype=float)
+        else:
+            y = np.array(data[:, 7], dtype=float)
+
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, shuffle=True, stratify=y)
+
+    return X_train, X_test, y_train, y_test, len(np.unique(y))
+
+
+def test(data_file, reps, n_trees, task_num,
+         default_transformer_class, default_transformer_kwargs):
+    default_voter_class = TreeClassificationVoter
+    default_voter_kwargs = {}
+
+    default_decider_class = SimpleArgmaxAverage
+
+    kappa = np.zeros(reps)
+    for i in range(reps):
+        X_train, X_test, y_train, y_test, n_classes = load_data(data_file, task_num)
+        default_decider_kwargs = {"classes": np.arange(n_classes)}
+
+        pl = ProgressiveLearner(
+            default_transformer_class=default_transformer_class,
+            default_transformer_kwargs=default_transformer_kwargs,
+            default_voter_class=default_voter_class,
+            default_voter_kwargs=default_voter_kwargs,
+            default_decider_class=default_decider_class,
+            default_decider_kwargs=default_decider_kwargs)
+
+        pl.add_task(X_train, y_train, num_transformers=n_trees)
+
+        y_hat = pl.predict(X_test, task_id=0)
+
+        acc = np.sum(y_test == y_hat) / len(y_test)
+        print("Accuracy after iteration ", i, ": ", acc)
+
+        chance_pred = 1 / n_classes
+        kappa[i] = (acc - chance_pred) / (1 - chance_pred)
+
+    return np.mean(kappa) * 100, (np.std(kappa) * 100) / np.sqrt(reps)
\ No newline at end of file
diff --git a/docs/tutorials/oblique_decision_boundaries.ipynb b/docs/tutorials/oblique_decision_boundaries.ipynb
new file mode 100644
index 0000000000..4332508d39
--- /dev/null
+++ b/docs/tutorials/oblique_decision_boundaries.ipynb
@@ -0,0 +1,138 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Use SPORF to Draw Decision Boundaries"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The purpose of this notebook is to show that the oblique tree in ProgLearn is correct and can accurately determine oblique splits."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import required packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from rerf.rerfClassifier import rerfClassifier\n",
+    "\n",
+    "import numpy as np\n",
+    "np.random.seed(42)\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.colors import ListedColormap\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.datasets import make_moons, make_circles, make_classification\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "\n",
+    "from proglearn.forest import LifelongClassificationForest\n",
+    "from proglearn.voters import TreeClassificationVoter\n",
+    "from proglearn.transformers import TreeClassificationTransformer\n",
+    "from proglearn.transformers import ObliqueTreeClassificationTransformer\n",
+    "from proglearn.deciders import SimpleArgmaxAverage\n",
+    "\n",
+    "from functions.oblique_decision_boundaries_functions import test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set parameters, initialize datasets, and initialize classifiers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "NT = 10\n",
+    "\n",
+    "h = .1  # step size in the mesh\n",
+    "\n",
+    "names = [\"RF\", \"RerF\", \"Proglearn-SPORF\"]\n",
+    "\n",
+    "classifiers = [\n",
+    "    RandomForestClassifier(max_depth=5, n_estimators=NT, max_features=1),\n",
+    "    rerfClassifier(n_estimators = NT, feature_combinations=1.5, max_features=2),\n",
+    "    LifelongClassificationForest(oblique=True, default_feature_combinations=1, default_density=0.5)]\n",
+    "\n",
+    "X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,\n",
+    "                           random_state=1, n_clusters_per_class=1)\n",
+    "rng = np.random.RandomState(2)\n",
+    "X += 2 * rng.uniform(size=X.shape)\n",
+    "linearly_separable = (X, y)\n",
+    "\n",
+    "datasets = [make_moons(noise=0.3, random_state=0),\n",
+    "            make_circles(noise=0.2, factor=0.5, random_state=1),\n",
+    "            linearly_separable\n",
+    "            ]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run on all datasets for all models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x648 with 12 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "figure = plt.figure(figsize=(15, 9))\n",
+    "test(NT, h, names, classifiers, datasets)\n",
+    "plt.tight_layout()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "venv"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/tutorials/sporf_datasets.ipynb b/docs/tutorials/sporf_datasets.ipynb
new file mode 100644
index 0000000000..31ab947477
--- /dev/null
+++ b/docs/tutorials/sporf_datasets.ipynb
@@ -0,0 +1,331 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# SPORF Tutorial"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The purpose of this tutorial is to prove that this pure python implementation of SPORF is identical, in terms of functionality, to the one used in the SPORF paper (Tomita, Tyler M., et al. \"Sparse projection oblique randomer forests.\" Journal of Machine Learning Research 21.104 (2020): 1-39.). In order to do this, this notebook runs this implementation of SPORF on 3 different data sets: hill valley, acute inflammation task 1, and acute inflammation task 2. Cohen's Kappa (fractional decrease in error rate over the chance error rate) is the metric that is being used to compare the implementations. If this implementation has the same kappa values (for the same data sets) as the one in the SPORF paper, we can say with confidence that this implementation is accurate. The datasets used in this notebook all had kappa values of 100 ± 0 in the SPORF paper implementation, which is also what is found when run on this SPORF implementation, as seen below. Thus, we can say with confidence that this implementation of SPORF is accurate."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import required packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "from proglearn.progressive_learner import ProgressiveLearner\n",
+    "from proglearn.forest import LifelongClassificationForest\n",
+    "from proglearn.voters import TreeClassificationVoter\n",
+    "from proglearn.transformers import TreeClassificationTransformer\n",
+    "from proglearn.transformers import ObliqueTreeClassificationTransformer\n",
+    "from proglearn.deciders import SimpleArgmaxAverage\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split, cross_val_score\n",
+    "\n",
+    "from functions.sporf_datasets_functions import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SPORF\n",
+    "\n",
+    "## Set parameters and run on hill valley without noise data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy after iteration  0 :  1.0\n",
+      "Accuracy after iteration  1 :  1.0\n",
+      "Accuracy after iteration  2 :  1.0\n",
+      "Accuracy after iteration  3 :  1.0\n",
+      "Accuracy after iteration  4 :  1.0\n",
+      "kappa:  100.0 , error: 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "max_depth = 10\n",
+    "feature_combinations = 2\n",
+    "density = 0.01\n",
+    "reps = 5\n",
+    "n_trees = 10\n",
+    "task_num = 1\n",
+    "\n",
+    "kwargs = {\"kwargs\" : {\"max_depth\" : max_depth, \"feature_combinations\" : feature_combinations, \"density\" : density}}\n",
+    "\n",
+    "kappa, err = test(\"https://archive.ics.uci.edu/ml/machine-learning-databases/hill-valley/Hill_Valley_without_noise_Training.data\", reps, n_trees, task_num,\n",
+    "                            ObliqueTreeClassificationTransformer,\n",
+    "                            kwargs)\n",
+    "\n",
+    "print(\"kappa: \", kappa, \", error:\", err)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set parameters and run on acute inflammation task 1 data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy after iteration  0 :  1.0\n",
+      "Accuracy after iteration  1 :  1.0\n",
+      "Accuracy after iteration  2 :  1.0\n",
+      "Accuracy after iteration  3 :  1.0\n",
+      "Accuracy after iteration  4 :  1.0\n",
+      "kappa:  100.0 , error: 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "max_depth = 10\n",
+    "feature_combinations = 1.5\n",
+    "density = 0.5\n",
+    "reps = 5\n",
+    "n_trees = 10\n",
+    "task_num = 1\n",
+    "\n",
+    "kwargs = {\"kwargs\" : {\"max_depth\" : max_depth, \"feature_combinations\" : feature_combinations, \"density\" : density}}\n",
+    "\n",
+    "kappa, err = test(\"https://archive.ics.uci.edu/ml/machine-learning-databases/acute/diagnosis.data\", reps, n_trees, task_num,\n",
+    "                            ObliqueTreeClassificationTransformer,\n",
+    "                            kwargs)\n",
+    "\n",
+    "print(\"kappa: \", kappa, \", error:\", err)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set parameters and run on acute inflammation task 2 data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy after iteration  0 :  1.0\n",
+      "Accuracy after iteration  1 :  1.0\n",
+      "Accuracy after iteration  2 :  1.0\n",
+      "Accuracy after iteration  3 :  1.0\n",
+      "Accuracy after iteration  4 :  1.0\n",
+      "kappa:  100.0 , error: 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "max_depth = 10\n",
+    "feature_combinations = 1.5\n",
+    "density = 0.5\n",
+    "reps = 5\n",
+    "n_trees = 10\n",
+    "task_num = 2\n",
+    "\n",
+    "kwargs = {\"kwargs\" : {\"max_depth\" : max_depth, \"feature_combinations\" : feature_combinations, \"density\" : density}}\n",
+    "\n",
+    "kappa, err = test(\"https://archive.ics.uci.edu/ml/machine-learning-databases/acute/diagnosis.data\", reps, n_trees, task_num,\n",
+    "                            ObliqueTreeClassificationTransformer,\n",
+    "                            kwargs)\n",
+    "\n",
+    "print(\"kappa: \", kappa, \", error:\", err)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Random Forest (RF)\n",
+    "\n",
+    "Now we will run the same datasets on a base Random forest. The goal of this is to show how SPORF can clearly outperform or perform as well as the Random Forest algorithm. As seen by the results below, SPORF has a much higher kappa value, than RF, for the hill valley without noise data and has the same value for the acute inflammation data sets. Having a high kappa value is desired since as mentioned above, it is a measure of how much the error rate over the chance error rate decreases."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set parameters and run on hill valley without noise data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy after iteration  0 :  0.5409836065573771\n",
+      "Accuracy after iteration  1 :  0.5901639344262295\n",
+      "Accuracy after iteration  2 :  0.5901639344262295\n",
+      "Accuracy after iteration  3 :  0.6885245901639344\n",
+      "Accuracy after iteration  4 :  0.5245901639344263\n",
+      "kappa:  17.37704918032787 , error: 5.1130724431784715\n"
+     ]
+    }
+   ],
+   "source": [
+    "max_depth = 10\n",
+    "feature_combinations = 2\n",
+    "density = 0.01\n",
+    "reps = 5\n",
+    "n_trees = 10\n",
+    "task_num = 1\n",
+    "\n",
+    "kwargs = {\"kwargs\" : {\"max_depth\" : max_depth} }\n",
+    "\n",
+    "kappa, err = test(\"https://archive.ics.uci.edu/ml/machine-learning-databases/hill-valley/Hill_Valley_without_noise_Training.data\", reps, n_trees, task_num,\n",
+    "                            TreeClassificationTransformer,\n",
+    "                            kwargs)\n",
+    "\n",
+    "print(\"kappa: \", kappa, \", error:\", err)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set parameters and run on acute inflammation task 1 data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy after iteration  0 :  1.0\n",
+      "Accuracy after iteration  1 :  1.0\n",
+      "Accuracy after iteration  2 :  1.0\n",
+      "Accuracy after iteration  3 :  1.0\n",
+      "Accuracy after iteration  4 :  1.0\n",
+      "kappa:  100.0 , error: 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "max_depth = 10\n",
+    "feature_combinations = 1.5\n",
+    "density = 0.5\n",
+    "reps = 5\n",
+    "n_trees = 10\n",
+    "task_num = 1\n",
+    "\n",
+    "kwargs = {\"kwargs\" : {\"max_depth\" : max_depth} }\n",
+    "\n",
+    "kappa, err = test(\"https://archive.ics.uci.edu/ml/machine-learning-databases/acute/diagnosis.data\", reps, n_trees, task_num,\n",
+    "                            TreeClassificationTransformer,\n",
+    "                            kwargs)\n",
+    "\n",
+    "print(\"kappa: \", kappa, \", error:\", err)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set parameters and run on acute inflammation task 2 data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy after iteration  0 :  1.0\n",
+      "Accuracy after iteration  1 :  1.0\n",
+      "Accuracy after iteration  2 :  1.0\n",
+      "Accuracy after iteration  3 :  1.0\n",
+      "Accuracy after iteration  4 :  1.0\n",
+      "kappa:  100.0 , error: 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "max_depth = 10\n",
+    "feature_combinations = 1.5\n",
+    "density = 0.5\n",
+    "reps = 5\n",
+    "n_trees = 10\n",
+    "task_num = 2\n",
+    "\n",
+    "kwargs = {\"kwargs\" : {\"max_depth\" : max_depth} }\n",
+    "\n",
+    "kappa, err = test(\"https://archive.ics.uci.edu/ml/machine-learning-databases/acute/diagnosis.data\", reps, n_trees, task_num,\n",
+    "                            TreeClassificationTransformer,\n",
+    "                            kwargs)\n",
+    "\n",
+    "print(\"kappa: \", kappa, \", error:\", err)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "venv"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/proglearn/forest.py b/proglearn/forest.py
index 50ff12a3b8..5b04099535 100644
--- a/proglearn/forest.py
+++ b/proglearn/forest.py
@@ -38,6 +38,15 @@ class LifelongClassificationForest(ClassificationProgressiveLearner):
         The maximum depth of a tree in the Lifelong Classification Forest.
         This is used if 'max_depth' is not fed to add_task.
 
+    oblique : bool, default=False
+        Specifies if an oblique tree should used for the classifier or not.
+
+    feature_combinations : float, default=1.5
+        The feature combinations to use for the oblique split.
+
+    density : float, default=0.5
+        Density estimate.
+
     Attributes
     ----------
     pl_ : ClassificationProgressiveLearner
@@ -124,6 +133,12 @@ def add_task(
             The maximum depth of a tree in the Lifelong Classification Forest.
             The default is used if 'default' is provided.
 
+        feature_combinations : float, default='default'
+            The feature combinations to use for the oblique split.
+
+        density : float, default='default'
+            Density estimate.
+
         Returns
         -------
         self : LifelongClassificationForest
diff --git a/proglearn/transformers.py b/proglearn/transformers.py
index ea042606b1..93546fc116 100644
--- a/proglearn/transformers.py
+++ b/proglearn/transformers.py
@@ -271,8 +271,8 @@ class SplitInfo:
     """
     A class used to store information about a certain split.
 
-    Parameters:
-    ---
+    Parameters
+    ----------
     feature : int
         The feature which is used for the particular split.
     threshold : float
@@ -334,8 +334,8 @@ class ObliqueSplitter:
     A class used to represent an oblique splitter, where splits are done on
     the linear combination of the features.
 
-    Parameters:
-    ---
+    Parameters
+    ----------
     X : array of shape [n_samples, n_features]
         The input data X is a matrix of the examples and their respective feature
         values for each of the features.
@@ -349,7 +349,7 @@ class ObliqueSplitter:
         Controls the pseudo random number generator used to generate the projection matrix.
 
     Methods
-    ---
+    -------
     sample_proj_mat(sample_inds)
         This gets the projection matrix and it fits the transform to the samples of interest.
     leaf_label_proba(idx)
@@ -383,12 +383,12 @@ def sample_proj_mat(self, sample_inds):
         Gets the projection matrix and it fits the transform to the samples of interest.
 
         Parameters
-        ---
+        ----------
         sample_inds : array of shape [n_samples]
             The data we are transforming.
 
         Returns
-        ---
+        -------
         proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
             The generated sparse random matrix.
         proj_mat : {ndarray, sparse matrix} of shape (n_samples, n_features)
@@ -410,13 +410,13 @@ def leaf_label_proba(self, idx):
          the leaf node for which this is used on.
 
          Parameters
-         ---
+         ----------
          idx : array of shape [n_samples]
              The indices of the samples that are at the leaf node for which the label
              and probability need to be found.
 
          Returns
-         ---
+         -------
         label : int
              The label for any sample that is predicted to be at this node.
          proba : float
@@ -440,7 +440,7 @@ def score(self, y_sort, t):
         Finds the Gini impurity for the split of interest
 
         Parameters
-        ---
+        ----------
         y_sort : array of shape [n_samples]
             A sorted array of labels for the examples for which the Gini impurity
             is being calculated.
@@ -448,7 +448,7 @@ def score(self, y_sort, t):
             The threshold determining where to split y_sort.
 
         Returns
-        ---
+        -------
         gini : float
             The Gini impurity of the split.
         """
@@ -480,12 +480,12 @@ def impurity(self, idx):
         Finds the actual impurity for a set of samples
 
         Parameters
-        ---
+        ----------
         idx : array of shape [n_samples]
             The indices of the nodes in the set for which the impurity is being calculated.
 
         Returns
-        ---
+        -------
         impurity : float
             Actual impurity of split.
         """
@@ -511,12 +511,12 @@ def split(self, sample_inds):
         bottleneck in integration with scikit-learn.
 
         Parameters
-        ---
+        ----------
         sample_inds : array of shape [n_samples]
             The indices of the nodes in the set for which the best split is found.
 
         Returns
-        ---
+        -------
         split_info : SplitInfo
             Class holding information about the split.
         """
@@ -599,12 +599,12 @@ class Node:
     """
     A class used to represent an oblique node.
 
-    Parameters:
-    ---
+    Parameters
+    ----------
     None
 
     Methods
-    ---
+    -------
     None
     """
 
@@ -629,8 +629,8 @@ class StackRecord:
     """
     A class used to keep track of a node's parent and other information about the node and its split.
 
-    Parameters:
-    ---
+    Parameters
+    ----------
     parent : int
         The index of the parent node.
     depth : int
@@ -645,7 +645,7 @@ class StackRecord:
         The number of samples in this node.
 
     Methods
-    ---
+    -------
     None
     """
 
@@ -663,8 +663,8 @@ class ObliqueTree:
     """
     A class used to represent a tree with oblique splits.
 
-    Parameters:
-    ---
+    Parameters
+    ----------
     splitter : class
         The type of splitter for this tree, should be an ObliqueSplitter.
     min_samples_split : int
@@ -679,7 +679,7 @@ class ObliqueTree:
         Minimum amount Gini impurity value must decrease by for a split to be valid.
 
     Methods
-    ---
+    -------
     add_node(parent, is_left, impurity, n_samples, is_leaf, feature, threshold, proj_mat, label, proba)
         Adds a node to the existing tree
     build()
@@ -731,7 +731,7 @@ def add_node(
         Adds a node to the existing oblique tree.
 
         Parameters
-        ---
+        ----------
         parent : int
             The index of the parent node for the new node being added.
         is_left : bool
@@ -757,7 +757,7 @@ def add_node(
             The probability a predicted sample has of being the node's label.
 
         Returns
-        ---
+        -------
         node_id : int
             Index of the new node just added.
         """
@@ -796,11 +796,11 @@ def build(self):
         Builds the oblique tree.
 
         Parameters
-        ---
+        ----------
         None
 
         Returns
-        ---
+        -------
         None
         """
 
@@ -903,12 +903,12 @@ def predict(self, X):
         Predicts final nodes of samples given.
 
         Parameters
-        ---
+        ----------
         X : array of shape [n_samples, n_features]
             The input array for which predictions are made.
 
         Returns
-        ---
+        -------
         predictions : array of shape [n_samples]
             Array of the final node index for each input prediction sample.
         """
@@ -939,8 +939,8 @@ class ObliqueTreeClassifier(BaseEstimator):
     """
     A class used to represent a classifier that uses an oblique decision tree.
 
-    Parameters:
-    ---
+    Parameters
+    ----------
     max_depth : int
         Maximum depth allowed for oblique tree.
     min_samples_split : int
@@ -959,7 +959,7 @@ class ObliqueTreeClassifier(BaseEstimator):
         Density estimate.
 
     Methods
-    ---
+    -------
     fit(X,y)
         Fits the oblique tree to the training samples.
     apply(X)
@@ -1014,14 +1014,14 @@ def fit(self, X, y):
         Predicts final nodes of samples given.
 
         Parameters
-        ---
+        ----------
         X : array of shape [n_samples, n_features]
             The training samples.
         y : array of shape [n_samples]
             Labels for the training samples.
 
         Returns
-        ---
+        -------
         ObliqueTreeClassifier
             The fit classifier.
         """
@@ -1047,12 +1047,12 @@ def apply(self, X):
         Gets predictions form the oblique tree for the test samples.
 
         Parameters
-        ---
+        ----------
         X : array of shape [n_samples, n_features]
             The testing samples.
 
         Returns
-        ---
+        -------
         pred_nodes : array of shape[n_samples]
             The indices for each test sample's final node in the oblique tree.
         """
@@ -1065,12 +1065,12 @@ def predict(self, X):
         Determines final label predictions for each sample in the test data.
 
         Parameters
-        ---
+        ----------
         X : array of shape [n_samples, n_features]
             The testing samples.
 
         Returns
-        ---
+        -------
         preds : array of shape[n_samples]
             The predictions (labels) for each testing sample.
         """
@@ -1088,12 +1088,12 @@ def predict_proba(self, X):
         Determines probabilities of the final label predictions for each sample in the test data.
 
         Parameters
-        ---
+        ----------
         X : array of shape [n_samples, n_features]
             The testing samples.
 
         Returns
-        ---
+        -------
         preds : array of shape[n_samples]
             The probabilities of the predictions (labels) for each testing sample.
         """
@@ -1111,12 +1111,12 @@ def predict_log_proba(self, X):
         Determines log of the probabilities of the final label predictions for each sample in the test data.
 
         Parameters
-        ---
+        ----------
         X : array of shape [n_samples, n_features]
             The testing samples.
 
         Returns
-        ---
+        -------
         preds : array of shape[n_samples]
             The log of the probabilities of the predictions (labels) for each testing sample.
         """

From 822430499394f099c11eef8c4240324a4d238ce6 Mon Sep 17 00:00:00 2001
From: Haoyin Xu <haoyinxu@gmail.com>
Date: Sat, 12 Dec 2020 15:12:09 -0800
Subject: [PATCH 14/17] Update tutorials.rst

Co-Authored-By: jmandav1 <39231283+jmandavilli@users.noreply.github.com>
Co-Authored-By: parthgvora <parthgvora@gmail.com>
---
 docs/tutorials.rst | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/docs/tutorials.rst b/docs/tutorials.rst
index b1f18032af..c269c60894 100644
--- a/docs/tutorials.rst
+++ b/docs/tutorials.rst
@@ -8,8 +8,18 @@ The following tutorials highlight what one can do with the ``ProgLearn`` package
     :maxdepth: 1
 
     tutorials/installation_guide
-    tutorials/xor_nxor_exp
+    tutorials/fte_bte_food101
     tutorials/label_shuffle_exp
     tutorials/random_class_exp
-    tutorials/uncertaintyforest_fig1
+    tutorials/rotation_cifar
+    tutorials/spiral_exp
+    tutorials/sporf_datasets
+    tutorials/oblique_decision_boundaries
     tutorials/uncertaintyforest_running_example
+    tutorials/uncertaintyforest_posteriorestimates
+    tutorials/uncertaintyforest_conditionalentropyestimates
+    tutorials/uncertaintyforest_mutualinformationestimates
+    tutorials/xor_nxor_exp
+    tutorials/xor_rxor_exp
+    tutorials/xor_rxor_with_cpd
+    tutorials/xor_rxor_with_icp

From cf93af41af9a18ae104bb3a9f1772a8d8e92ee06 Mon Sep 17 00:00:00 2001
From: Jay <jmandav1@jhu.edu>
Date: Mon, 14 Dec 2020 20:28:37 -0700
Subject: [PATCH 15/17] renamed notebooks

---
 docs/tutorials.rst                                              | 2 +-
 ...ecision_boundaries.ipynb => sporf_decision_boundaries.ipynb} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename docs/tutorials/{oblique_decision_boundaries.ipynb => sporf_decision_boundaries.ipynb} (100%)

diff --git a/docs/tutorials.rst b/docs/tutorials.rst
index f6f777b9cc..8f7900f709 100644
--- a/docs/tutorials.rst
+++ b/docs/tutorials.rst
@@ -14,7 +14,7 @@ The following tutorials highlight what one can do with the ``ProgLearn`` package
     tutorials/rotation_cifar
     tutorials/spiral_exp
     tutorials/sporf_datasets
-    tutorials/oblique_decision_boundaries
+    tutorials/sporf_decision_boundaries
     tutorials/uncertaintyforest_running_example
     tutorials/uncertaintyforest_posteriorestimates
     tutorials/uncertaintyforest_conditionalentropyestimates
diff --git a/docs/tutorials/oblique_decision_boundaries.ipynb b/docs/tutorials/sporf_decision_boundaries.ipynb
similarity index 100%
rename from docs/tutorials/oblique_decision_boundaries.ipynb
rename to docs/tutorials/sporf_decision_boundaries.ipynb

From 706ef4243d40ac868df3a11623d4663bc834638f Mon Sep 17 00:00:00 2001
From: Haoyin Xu <haoyinxu@gmail.com>
Date: Mon, 14 Dec 2020 19:38:48 -0800
Subject: [PATCH 16/17] Update and rename
 oblique_decision_boundaries_functions.py to
 sporf_decision_boundaries_functions.py

Co-Authored-By: jmandav1 <39231283+jmandavilli@users.noreply.github.com>
Co-Authored-By: parthgvora <parthgvora@gmail.com>
---
 ...ries_functions.py => sporf_decision_boundaries_functions.py} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename docs/tutorials/functions/{oblique_decision_boundaries_functions.py => sporf_decision_boundaries_functions.py} (97%)

diff --git a/docs/tutorials/functions/oblique_decision_boundaries_functions.py b/docs/tutorials/functions/sporf_decision_boundaries_functions.py
similarity index 97%
rename from docs/tutorials/functions/oblique_decision_boundaries_functions.py
rename to docs/tutorials/functions/sporf_decision_boundaries_functions.py
index 7be5367339..baef1cfc89 100644
--- a/docs/tutorials/functions/oblique_decision_boundaries_functions.py
+++ b/docs/tutorials/functions/sporf_decision_boundaries_functions.py
@@ -93,4 +93,4 @@ def test(NT, h, names, classifiers, datasets):
                 ax.set_title(name)
             ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),
                     size=15, horizontalalignment='right')
-            i += 1
\ No newline at end of file
+            i += 1

From 6e1205e8b16f4baafe31a327bc67cf82c8effd41 Mon Sep 17 00:00:00 2001
From: Haoyin Xu <haoyinxu@gmail.com>
Date: Mon, 14 Dec 2020 19:40:00 -0800
Subject: [PATCH 17/17] Rename function for consistency

Co-Authored-By: jmandav1 <39231283+jmandavilli@users.noreply.github.com>
Co-Authored-By: parthgvora <parthgvora@gmail.com>
---
 docs/tutorials/sporf_decision_boundaries.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/tutorials/sporf_decision_boundaries.ipynb b/docs/tutorials/sporf_decision_boundaries.ipynb
index 4332508d39..70b10f2802 100644
--- a/docs/tutorials/sporf_decision_boundaries.ipynb
+++ b/docs/tutorials/sporf_decision_boundaries.ipynb
@@ -45,7 +45,7 @@
     "from proglearn.transformers import ObliqueTreeClassificationTransformer\n",
     "from proglearn.deciders import SimpleArgmaxAverage\n",
     "\n",
-    "from functions.oblique_decision_boundaries_functions import test"
+    "from functions.sporf_decision_boundaries_functions import test"
    ]
   },
   {