diff --git "a/benchmarking/randomForest_token_classifier_dosageTF_10k.ipynb" "b/benchmarking/randomForest_token_classifier_dosageTF_10k.ipynb"
new file mode 100644--- /dev/null
+++ "b/benchmarking/randomForest_token_classifier_dosageTF_10k.ipynb"
@@ -0,0 +1,745 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Example of Evaluating Performance of Alternative Modeling Approaches"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import random\n",
+    "import datetime\n",
+    "import subprocess\n",
+    "import math\n",
+    "import pickle\n",
+    "from tqdm.notebook import tqdm\n",
+    "import anndata\n",
+    "import scanpy as sc\n",
+    "from datasets import load_from_disk\n",
+    "\n",
+    "# visualization\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# ML\n",
+    "from sklearn.model_selection import StratifiedKFold\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.metrics import roc_curve, auc, confusion_matrix\n",
+    "\n",
+    "seed_num=0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# cpu cores\n",
+    "num_proc = 16\n",
+    "\n",
+    "# training dataset size\n",
+    "subsample_size = 10_000"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load Token Dictionary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load gene_ensembl_id:token dictionary\n",
+    "with open(\"/path/to/token_dictionary.pkl\", \"rb\") as fp:\n",
+    "    token_dictionary = pickle.load(fp)\n",
+    "token_gene_dict = {v: k for k,v in token_dictionary.items()}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load Training Data and Classes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# prepare targets and labels\n",
+    "def prep_inputs(genegroup1, genegroup2, balance):\n",
+    "\n",
+    "    targets1 = [gene for gene in genegroup1 if gene in token_dictionary]\n",
+    "    targets2 = [gene for gene in genegroup2 if gene in token_dictionary]\n",
+    "    \n",
+    "    if balance == \"balance\":\n",
+    "        min_sample = min(len(targets1), len(targets2))\n",
+    "        random.seed(seed_num)\n",
+    "        targets1 = random.sample(targets1, min_sample)\n",
+    "        random.seed(seed_num)\n",
+    "        targets2 = random.sample(targets2, min_sample)\n",
+    "\n",
+    "    targets1_id = [token_dictionary[gene] for gene in targets1]\n",
+    "    targets2_id = [token_dictionary[gene] for gene in targets2]\n",
+    "    \n",
+    "    targets = np.array(targets1_id + targets2_id)\n",
+    "    labels = np.array([0]*len(targets1_id) + [1]*len(targets2_id))\n",
+    "    nsplits = min(5, min(len(targets1_id), len(targets2_id))-1)\n",
+    "    assert nsplits > 2\n",
+    "    print(f\"# targets1: {len(targets1_id)}\\n# targets2: {len(targets2_id)}\\n# splits: {nsplits}\")\n",
+    "    return targets, labels, nsplits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# targets1: 122\n",
+      "# targets2: 122\n",
+      "# splits: 5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load training labels for dosage sensitive vs. insensitive TFs (format: Ensembl IDs)\n",
+    "dosage_tfs = pd.read_csv(\"/path/to/dosage_sens_tfs.csv\", header=0)\n",
+    "sensitive = dosage_tfs[\"dosage_sensitive\"].dropna()\n",
+    "insensitive = dosage_tfs[\"dosage_insensitive\"].dropna()\n",
+    "targets, labels, nsplits = prep_inputs(sensitive, insensitive, \"balance\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load training dataset\n",
+    "train_dataset=load_from_disk(\"/path/to/genecorpus_30M_2048.dataset\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "shuffled_train_dataset = train_dataset.shuffle(seed=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# reduce training dataset to 5x subsample size (to leave room for further filtering for cells that express target genes)\n",
+    "subsampled_training_dataset = shuffled_train_dataset.select([i for i in range(subsample_size*5)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def if_contains_target(example):\n",
+    "    a = targets\n",
+    "    b = example['input_ids']\n",
+    "    return not set(a).isdisjoint(b)\n",
+    "\n",
+    "# filter dataset for cells that express target genes\n",
+    "data_w_target = subsampled_training_dataset.filter(if_contains_target, num_proc=num_proc)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# subsample data to desired number of training examples\n",
+    "data_subsample = data_w_target.select([i for i in range(subsample_size)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_ranks(example):\n",
+    "    example_rank_dict = dict(zip(example[\"input_ids\"],[2048-i for i in range(example[\"length\"])]))\n",
+    "    target_vector = [example_rank_dict.get(target,0) for target in targets]\n",
+    "    example[\"target_vector\"] = target_vector\n",
+    "    return example\n",
+    "\n",
+    "# get ranks of target genes within training cells for rank-based trials\n",
+    "data_w_target_vectors = data_subsample.map(get_ranks, num_proc=num_proc)\n",
+    "target_arr = np.transpose(np.array(data_w_target_vectors[\"target_vector\"]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cross-Validate Token Classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# functions to evaluate classifier\n",
+    "\n",
+    "def classifier_predict(model_type, model, eval_arr, labels_eval, mean_fpr):\n",
+    "    y_pred = model.predict(eval_arr)\n",
+    "    y_true = labels_eval\n",
+    "    conf_mat = confusion_matrix(y_true, y_pred)\n",
+    "    # probability of class 1\n",
+    "    if model_type == \"SVM\":\n",
+    "        y_prob = model.decision_function(eval_arr)\n",
+    "        fpr, tpr, _ = roc_curve(y_true, y_prob)\n",
+    "    else:\n",
+    "        y_prob = model.predict_proba(eval_arr)\n",
+    "        fpr, tpr, _ = roc_curve(y_true, y_prob[:,1])\n",
+    "    # plot roc_curve for this split\n",
+    "    plt.plot(fpr, tpr)\n",
+    "    plt.xlim([0.0, 1.0])\n",
+    "    plt.ylim([0.0, 1.05])\n",
+    "    plt.xlabel('False Positive Rate')\n",
+    "    plt.ylabel('True Positive Rate')\n",
+    "    plt.title('ROC')\n",
+    "    plt.show()\n",
+    "    # interpolate to graph\n",
+    "    interp_tpr = np.interp(mean_fpr, fpr, tpr)\n",
+    "    interp_tpr[0] = 0.0\n",
+    "    return fpr, tpr, interp_tpr, conf_mat \n",
+    "\n",
+    "# get cross-validated AUC mean and sd metrics\n",
+    "def get_cross_valid_metrics(all_tpr, all_roc_auc, all_tpr_wt):\n",
+    "    wts = [count/sum(all_tpr_wt) for count in all_tpr_wt]\n",
+    "    print(wts)\n",
+    "    all_weighted_tpr = [a*b for a,b in zip(all_tpr, wts)]\n",
+    "    mean_tpr = np.sum(all_weighted_tpr, axis=0)\n",
+    "    mean_tpr[-1] = 1.0\n",
+    "    all_weighted_roc_auc = [a*b for a,b in zip(all_roc_auc, wts)]\n",
+    "    roc_auc = np.sum(all_weighted_roc_auc)\n",
+    "    roc_auc_sd = math.sqrt(np.average((all_roc_auc-roc_auc)**2, weights=wts))\n",
+    "    return mean_tpr, roc_auc, roc_auc_sd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# cross-validate token classifier\n",
+    "def cross_validate(model_type, model, target_arr, labels, nsplits, subsample_size, num_proc):\n",
+    "    print(f\"# training cells: {target_arr.shape[1]}\")\n",
+    "    \n",
+    "    # initiate eval metrics to return\n",
+    "    num_classes = len(set(labels))\n",
+    "    mean_fpr = np.linspace(0, 1, 100)\n",
+    "    all_tpr = []\n",
+    "    all_roc_auc = []\n",
+    "    all_tpr_wt = []\n",
+    "    confusion = np.zeros((num_classes,num_classes))\n",
+    "    \n",
+    "    # set up cross-validation splits\n",
+    "    skf = StratifiedKFold(n_splits=nsplits, random_state=0, shuffle=True)\n",
+    "    # train and evaluate\n",
+    "    iteration_num = 0\n",
+    "    for train_index, eval_index in tqdm(skf.split(target_arr, labels)):\n",
+    "\n",
+    "        print(f\"****** Crossval split: {iteration_num}/{nsplits-1} ******\\n\")\n",
+    "        # generate cross-validation splits\n",
+    "        targets_train, targets_eval = target_arr[train_index], target_arr[eval_index]\n",
+    "        labels_train, labels_eval = labels[train_index], labels[eval_index]\n",
+    "        \n",
+    "        model = model\n",
+    "    \n",
+    "        # train the token classifier\n",
+    "        model.fit(targets_train, labels_train)\n",
+    "\n",
+    "        # evaluate model\n",
+    "        fpr, tpr, interp_tpr, conf_mat = classifier_predict(model_type, model, targets_eval, labels_eval, mean_fpr)\n",
+    "\n",
+    "        # append to tpr and roc lists\n",
+    "        confusion = confusion + conf_mat\n",
+    "        all_tpr.append(interp_tpr)\n",
+    "        all_roc_auc.append(auc(fpr, tpr))\n",
+    "        # append number of eval examples by which to weight tpr in averaged graphs\n",
+    "        all_tpr_wt.append(len(tpr))\n",
+    "        \n",
+    "        iteration_num = iteration_num + 1\n",
+    "        \n",
+    "    # get overall metrics for cross-validation\n",
+    "    mean_tpr, roc_auc, roc_auc_sd = get_cross_valid_metrics(all_tpr, all_roc_auc, all_tpr_wt)\n",
+    "    return all_roc_auc, roc_auc, roc_auc_sd, mean_fpr, mean_tpr, confusion"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# plot ROC curve\n",
+    "def plot_ROC(bundled_data, title):\n",
+    "    fig = plt.figure()\n",
+    "    fig.set_size_inches(17, 10.5)\n",
+    "    plt.rcParams.update({'font.size': 20})\n",
+    "    lw = 4\n",
+    "    for roc_auc, roc_auc_sd, mean_fpr, mean_tpr, sample, color, linestyle in bundled_data:\n",
+    "        plt.plot(mean_fpr, mean_tpr, color=color,\n",
+    "                 lw=lw, label=\"{0} (AUC {1:0.2f} $\\pm$ {2:0.2f})\".format(sample, roc_auc, roc_auc_sd), linestyle=linestyle)\n",
+    "    plt.plot([0, 1], [0, 1], color='black', lw=lw, linestyle='--')\n",
+    "    plt.xlim([0.0, 1.0])\n",
+    "    plt.ylim([0.0, 1.05])\n",
+    "    plt.xlabel('False Positive Rate')\n",
+    "    plt.ylabel('True Positive Rate')\n",
+    "    plt.title(title)\n",
+    "    plt.legend(loc=\"lower right\")\n",
+    "\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Random Forest - Ranks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# cross-validate token classifier\n",
+    "model = RandomForestClassifier(max_depth=2, random_state=0)\n",
+    "all_roc_auc0, roc_auc0, roc_auc_sd0, mean_fpr0, mean_tpr0, confusion0 \\\n",
+    "    = cross_validate(\"RF\", model, target_arr, labels, nsplits, subsample_size, 1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Logistic Regression - Ranks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# cross-validate token classifier\n",
+    "model = LogisticRegression(random_state=0)\n",
+    "all_roc_auc1, roc_auc1, roc_auc_sd1, mean_fpr1, mean_tpr1, confusion1 \\\n",
+    "    = cross_validate(\"LR\", model, target_arr, labels, nsplits, subsample_size, 1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SVM - Ranks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# cross-validate token classifier\n",
+    "model = SVC(random_state=0)\n",
+    "all_roc_auc2, roc_auc2, roc_auc_sd2, mean_fpr2, mean_tpr2, confusion2 \\\n",
+    "    = cross_validate(\"SVM\", model, target_arr, labels, nsplits, subsample_size, 1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Classifiers Using Counts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rootdir = \"/path/to/count_data/\"\n",
+    "\n",
+    "adata_list = []\n",
+    "\n",
+    "for subdir, dirs, files in os.walk(rootdir):\t\n",
+    "    for file in files:\n",
+    "        if file.endswith(\".loom\"):\n",
+    "            print(f\"{rootdir}{file}\")\n",
+    "            adata = anndata.read_loom(f\"{rootdir}{file}\")\n",
+    "            adata_list += [adata]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for adata in adata_list:\n",
+    "    sc.pp.normalize_total(adata, target_sum=1e4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "targets_ensembl = np.array([token_gene_dict[target] for target in targets])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "target_arr = []\n",
+    "for target in targets_ensembl:\n",
+    "    target_vectors = np.zeros((0,0))\n",
+    "    for adata in adata_list:\n",
+    "        if target in list(adata.var[\"ensembl_id\"]):\n",
+    "            target_vectors = np.append(target_vectors, np.array(adata[:,adata.var.ensembl_id == target].X.todense()))\n",
+    "        else:\n",
+    "            target_vectors = np.append(target_vectors, np.array([0]*adata.shape[0]))\n",
+    "    target_arr += [np.transpose(target_vectors)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "target_arr = np.array(target_arr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "idx = np.argwhere(np.all(target_arr[..., :] == 0, axis=0))\n",
+    "target_arr = np.delete(target_arr, idx, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "random_indices = np.random.choice(target_arr.shape[1], size=10_000, replace=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "target_arr = target_arr[:,random_indices]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SVM - Counts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# cross-validate token classifier\n",
+    "model = SVC(random_state=0)\n",
+    "all_roc_auc20, roc_auc20, roc_auc_sd20, mean_fpr20, mean_tpr20, confusion20 \\\n",
+    "    = cross_validate(\"SVM\", model, target_arr, labels, nsplits, subsample_size, 1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Random Forest - Counts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# cross-validate token classifier\n",
+    "model = RandomForestClassifier(max_depth=2, random_state=0)\n",
+    "all_roc_auc00, roc_auc00, roc_auc_sd00, mean_fpr00, mean_tpr00, confusion00 \\\n",
+    "    = cross_validate(\"RF\", model, target_arr, labels, nsplits, subsample_size, 1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Logistic Regression - Counts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# cross-validate token classifier\n",
+    "model = LogisticRegression(random_state=0)\n",
+    "all_roc_auc10, roc_auc10, roc_auc_sd10, mean_fpr10, mean_tpr10, confusion10 \\\n",
+    "    = cross_validate(\"LR\", model, target_arr, labels, nsplits, subsample_size, 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# bundle data for plotting\n",
+    "bundled_data = []\n",
+    "bundled_data += [(roc_auc2, roc_auc_sd2, mean_fpr2, mean_tpr2, \"SVM rank\", \"purple\", \"solid\")]\n",
+    "bundled_data += [(roc_auc0, roc_auc_sd0, mean_fpr0, mean_tpr0, \"Random Forest rank\", \"blue\", \"solid\")]\n",
+    "bundled_data += [(roc_auc1, roc_auc_sd1, mean_fpr1, mean_tpr1, \"Logistic Regression rank\", \"green\", \"solid\")]\n",
+    "bundled_data += [(roc_auc20, roc_auc_sd20, mean_fpr20, mean_tpr20, \"SVM counts\", \"purple\", \"dashed\")]\n",
+    "bundled_data += [(roc_auc00, roc_auc_sd00, mean_fpr00, mean_tpr00, \"Random Forest counts\", \"blue\", \"dashed\")]\n",
+    "bundled_data += [(roc_auc10, roc_auc_sd10, mean_fpr10, mean_tpr10, \"Logistic Regression counts\", \"green\", \"dashed\")]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1224x756 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot ROC\n",
+    "plot_ROC(bundled_data, 'Dosage Sensitive vs Insensitive TFs')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Save Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# create output directory\n",
+    "current_date = datetime.datetime.now()\n",
+    "datestamp = f\"{str(current_date.year)[-2:]}{current_date.month:02d}{current_date.day:02d}\"\n",
+    "training_output_dir = f\"/path/to/output_dir/{datestamp}_alternativeTokenClassifier_dosageTF_n{subsample_size}/\"\n",
+    "\n",
+    "# make training and model output directories\n",
+    "subprocess.call(f'mkdir {training_output_dir}', shell=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(os.path.join(training_output_dir, f\"bundled_data.pickle\"), \"wb\") as fp:\n",
+    "     pickle.dump(bundled_data, fp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(os.path.join(training_output_dir, f\"confusion_RF_ranks.pickle\"), \"wb\") as fp:\n",
+    "     pickle.dump(confusion0, fp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(os.path.join(training_output_dir, f\"confusion_LogReg_ranks.pickle\"), \"wb\") as fp:\n",
+    "     pickle.dump(confusion1, fp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(os.path.join(training_output_dir, f\"confusion_SVM_ranks.pickle\"), \"wb\") as fp:\n",
+    "     pickle.dump(confusion2, fp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(os.path.join(training_output_dir, f\"confusion_RF_counts.pickle\"), \"wb\") as fp:\n",
+    "     pickle.dump(confusion00, fp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(os.path.join(training_output_dir, f\"confusion_LogReg_counts.pickle\"), \"wb\") as fp:\n",
+    "     pickle.dump(confusion10, fp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(os.path.join(training_output_dir, f\"confusion_SVM_counts.pickle\"), \"wb\") as fp:\n",
+    "     pickle.dump(confusion20, fp)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "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.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}