diff --git a/docs/tutorials.rst b/docs/tutorials.rst
index aae1ab989f..8f7900f709 100644
--- a/docs/tutorials.rst
+++ b/docs/tutorials.rst
@@ -13,6 +13,8 @@ The following tutorials highlight what one can do with the ``ProgLearn`` package
     tutorials/random_class_exp
     tutorials/rotation_cifar
     tutorials/spiral_exp
+    tutorials/sporf_datasets
+    tutorials/sporf_decision_boundaries
     tutorials/uncertaintyforest_running_example
     tutorials/uncertaintyforest_posteriorestimates
     tutorials/uncertaintyforest_conditionalentropyestimates
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/functions/sporf_decision_boundaries_functions.py b/docs/tutorials/functions/sporf_decision_boundaries_functions.py
new file mode 100644
index 0000000000..baef1cfc89
--- /dev/null
+++ b/docs/tutorials/functions/sporf_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
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/docs/tutorials/sporf_decision_boundaries.ipynb b/docs/tutorials/sporf_decision_boundaries.ipynb
new file mode 100644
index 0000000000..70b10f2802
--- /dev/null
+++ b/docs/tutorials/sporf_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.sporf_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/proglearn/forest.py b/proglearn/forest.py
index 3539eb87e2..c464529272 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
 
@@ -35,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
@@ -48,13 +60,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 +96,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
@@ -106,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
@@ -120,6 +153,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 +181,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/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 == {}
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 3ce1f63e17..93546fc116
--- 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,
@@ -194,3 +197,932 @@ 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 : ObliqueTreeClassifier
+        an sklearn compliant oblique decisiotn tree (SPORF)
+    """
+
+    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)
+
+
+"""
+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.5,
+        density=0.5
+    ):
+
+        # 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