notebooks/notebook_fair-sentiment_kSAL.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append(\"../src\")\n",
    "sys.path.append(\"../data/embeddings\")\n",
    "import classifier\n",
    "import debias\n",
    "#import debias_old as debias\n",
    "import gensim\n",
    "import codecs\n",
    "import json\n",
    "from gensim.models.keyedvectors import Word2VecKeyedVectors\n",
    "from gensim.models import KeyedVectors\n",
    "import numpy as np\n",
    "import random\n",
    "import sklearn\n",
    "from sklearn import model_selection\n",
    "from sklearn import cluster\n",
    "from sklearn import metrics\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.svm import LinearSVC, SVC\n",
    "from sklearn.linear_model import SGDClassifier, Perceptron, LogisticRegression, PassiveAggressiveClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from sklearn.decomposition import PCA\n",
    "import scipy\n",
    "from scipy import linalg\n",
    "from scipy.stats.stats import pearsonr\n",
    "import tqdm\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "# %matplotlib inline\n",
    "# matplotlib.rcParams['agg.path.chunksize'] = 10000\n",
    "from sklearn.utils import shuffle\n",
    "\n",
    "# import warnings\n",
    "# warnings.filterwarnings(\"ignore\")\n",
    "# %load_ext autoreload\n",
    "# %autoreload\n",
    "\n",
    "from collections import Counter, defaultdict\n",
    "import seaborn as sns\n",
    "# sns.set_style(\"whitegrid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data(path, size, ratio=0.5):\n",
    "    fnames = [\"neg_neg.npy\", \"neg_pos.npy\", \"pos_neg.npy\", \"pos_pos.npy\"]\n",
    "    protected_labels = [0, 1, 0, 1]\n",
    "    main_labels = [0, 0, 1, 1]\n",
    "    X, Y_p, Y_m = [], [], []\n",
    "    n1 = int(size * ratio / 2)\n",
    "    n2 = int(size * (1 - ratio) / 2)\n",
    "#     print(n1, n2)\n",
    "\n",
    "    for fname, p_label, m_label, n in zip(fnames, protected_labels, main_labels, [n1, n2, n2, n1]):\n",
    "#         print(path + '/' + fname)\n",
    "#         print(np.load(path + '/' + fname).shape)\n",
    "        data = np.load(path + '/' + fname)[:n]\n",
    "        for x in data:\n",
    "            X.append(x)\n",
    "        for _ in data:\n",
    "            Y_p.append(p_label)\n",
    "        for _ in data:\n",
    "            Y_m.append(m_label)\n",
    "\n",
    "    Y_p = np.array(Y_p)\n",
    "    Y_m = np.array(Y_m)\n",
    "    X = np.array(X)\n",
    "    X, Y_p, Y_m = shuffle(X, Y_p, Y_m, random_state=0)\n",
    "    return X, Y_p, Y_m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_TPR(y_main, y_hat_main, y_protected):\n",
    "    \n",
    "    all_y = list(Counter(y_main).keys())\n",
    "    \n",
    "    protected_vals = defaultdict(dict)\n",
    "    for label in all_y:\n",
    "        for i in range(2):\n",
    "            used_vals = (y_main == label) & (y_protected == i)\n",
    "            y_label = y_main[used_vals]\n",
    "            y_hat_label = y_hat_main[used_vals]\n",
    "            protected_vals['y:{}'.format(label)]['p:{}'.format(i)] = (y_label == y_hat_label).mean()\n",
    "            \n",
    "    diffs = {}\n",
    "    for k, v in protected_vals.items():\n",
    "        vals = list(v.values())\n",
    "        diffs[k] = vals[0] - vals[1]\n",
    "    return protected_vals, diffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rms(arr):\n",
    "    return np.sqrt(np.mean(np.square(arr)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_plot_tpr(P):\n",
    "    \n",
    "    results = defaultdict(dict)\n",
    "    for ratio in [0.5, 0.6, 0.7, 0.8]:\n",
    "\n",
    "        x_train, y_p_train, y_m_train = load_data(\n",
    "            '../data/emoji_sent_race_{}/train/'.format(ratio),\n",
    "            size=100000, ratio=ratio)\n",
    "        x_dev, y_p_dev, y_m_dev = load_data(\n",
    "            '../data/emoji_sent_race_{}/test/'.format(ratio),\n",
    "            size=100000, ratio=0.5)\n",
    "\n",
    "        biased_classifier = LinearSVC(fit_intercept=True, class_weight='balanced', dual=False, C=0.1, max_iter=10000)\n",
    "\n",
    "        biased_classifier.fit(x_train, y_m_train)\n",
    "        biased_score = biased_classifier.score(x_dev, y_m_dev)\n",
    "\n",
    "    #     P = np.load('../data/emoji_sent_race_{}/P_svm.num-clfs=300.npy'.format(ratio), allow_pickle=True)\n",
    "    #     P = P[1]\n",
    "\n",
    "    #     n_dims = 120\n",
    "    # #     n_dims = 70\n",
    "    #     if ratio == 0.5:\n",
    "    #         n_dims = 200\n",
    "    #     elif ratio == 0.6:\n",
    "    #         n_dims = 100\n",
    "    #     elif ratio == 0.7:\n",
    "    #         n_dims = 115\n",
    "    #     elif ratio == 0.8:\n",
    "    #         n_dims = 200\n",
    "\n",
    "    #     P = debias.get_projection_to_intersection_of_nullspaces(P[:n_dims], input_dim=300)\n",
    "\n",
    "        debiased_x_train = P.dot(x_train.T).T\n",
    "        debiased_x_dev = P.dot(x_dev.T).T\n",
    "\n",
    "        classifier = LinearSVC(fit_intercept=True, class_weight='balanced', dual=False, C=0.1, max_iter=10000)\n",
    "\n",
    "        classifier.fit(debiased_x_train, y_m_train)\n",
    "        debiased_score = classifier.score(debiased_x_dev, y_m_dev)\n",
    "\n",
    "        p_classifier = SGDClassifier(warm_start=True, loss='log', n_jobs=64, max_iter=10000, random_state=0, tol=1e-3)\n",
    "        p_classifier.fit(debiased_x_train, y_p_train)\n",
    "        p_score = p_classifier.score(debiased_x_dev, y_p_dev)\n",
    "        results[ratio]['p_acc'] = p_score\n",
    "\n",
    "        _, biased_diffs = get_TPR(y_m_dev, biased_classifier.predict(x_dev), y_p_dev)\n",
    "\n",
    "        _, debiased_diffs = get_TPR(y_m_dev, classifier.predict(debiased_x_dev), y_p_dev)\n",
    "\n",
    "    #     results[ratio]['biased_diff_tpr'] = biased_diffs['y:0']\n",
    "        results[ratio]['biased_diff_tpr'] = rms(list(biased_diffs.values()))\n",
    "    #     results[ratio]['debiased_diff_tpr'] = debiased_diffs['y:0']\n",
    "        results[ratio]['debiased_diff_tpr'] = rms(list(debiased_diffs.values()))\n",
    "\n",
    "        results[ratio]['biased_acc'] = biased_score\n",
    "        results[ratio]['debiased_acc'] = debiased_score\n",
    "\n",
    "    plot_results = defaultdict(list)\n",
    "    for r in [0.5, 0.6, 0.7, 0.8]:\n",
    "        plot_results['biased_diff_tpr'].append(results[r]['biased_diff_tpr'])\n",
    "        plot_results['debiased_diff_tpr'].append(results[r]['debiased_diff_tpr'])\n",
    "        plot_results['biased_acc'].append(results[r]['biased_acc'])\n",
    "        plot_results['debiased_acc'].append(results[r]['debiased_acc'])\n",
    "\n",
    "    return results, plot_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data2plot(results, removal_range):\n",
    "    x = removal_range\n",
    "\n",
    "    fig, ax1 = plt.subplots()\n",
    "\n",
    "    color = 'tab:red'\n",
    "    ax1.set_xlabel('ratio')\n",
    "    ax1.set_ylabel('diff tpr', color=color)\n",
    "    ax1.plot(x, results['biased_diff_tpr'], '.--', label='biased tpr diff', color=color)\n",
    "    ax1.plot(x, results['debiased_diff_tpr'], '*:', label='debiased tpr diff', color=color)\n",
    "    ax1.tick_params(axis='y', labelcolor=color)\n",
    "    plt.ylim(0.,0.6)\n",
    "\n",
    "    ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis\n",
    "\n",
    "    color = 'tab:blue'\n",
    "    ax2.set_ylabel('acc', color=color)  # we already handled the x-label with ax1\n",
    "    ax2.plot(x, results['biased_acc'], '^-', label='biased acc', color=color)\n",
    "    ax2.plot(x, results['debiased_acc'], 'o--', label='debiased acc', color=color)\n",
    "    ax2.tick_params(axis='y', labelcolor=color)\n",
    "    \n",
    "    # ask matplotlib for the plotted objects and their labels\n",
    "    lines, labels = ax1.get_legend_handles_labels()\n",
    "    lines2, labels2 = ax2.get_legend_handles_labels()\n",
    "    ax2.legend(lines, labels, loc='lower right')\n",
    "    \n",
    "    from matplotlib.legend import Legend\n",
    "    leg = Legend(ax2, lines2, labels2,\n",
    "             loc='upper left', frameon=False)\n",
    "    ax2.add_artist(leg);\n",
    "\n",
    "    plt.title('TPR rates as a function of the ratio')\n",
    "    plt.ylim(0.5,.85)\n",
    "#     plt.legend()\n",
    "#     plt.savefig('tpr_rates_ratio.png', dpi=1000)\n",
    "    plt.show()\n",
    "    \n",
    "# data2plot(plot_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cross-validate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_result(u, removel_range, x_train, x_dev, y_m_train, y_m_dev, y_p_train, y_p_dev):\n",
    "    results = defaultdict(dict)\n",
    "\n",
    "    biased_classifier = LinearSVC(fit_intercept=True, class_weight='balanced', dual=False, C=0.1, max_iter=10000)\n",
    "\n",
    "    biased_classifier.fit(x_train, y_m_train)\n",
    "    biased_score = biased_classifier.score(x_dev, y_m_dev)\n",
    "    _, biased_diffs = get_TPR(y_m_dev, biased_classifier.predict(x_dev), y_p_dev)\n",
    "    \n",
    "    for removal in removel_range:\n",
    "        u_r = u[:, removal:]\n",
    "        proj = u_r @ u_r.T\n",
    "        P = proj\n",
    "\n",
    "        debiased_x_train = P.dot(x_train.T).T\n",
    "        debiased_x_dev = P.dot(x_dev.T).T\n",
    "\n",
    "        classifier = LinearSVC(fit_intercept=True, class_weight='balanced', dual=False, C=0.1, max_iter=10000)\n",
    "\n",
    "        classifier.fit(debiased_x_train, y_m_train)\n",
    "        debiased_score = classifier.score(debiased_x_dev, y_m_dev)\n",
    "\n",
    "        p_classifier = SGDClassifier(warm_start=True, loss='log', n_jobs=64, max_iter=10000, random_state=0, tol=1e-3)\n",
    "        p_classifier.fit(debiased_x_train, y_p_train)\n",
    "        p_score = p_classifier.score(debiased_x_dev, y_p_dev)\n",
    "\n",
    "        _, debiased_diffs = get_TPR(y_m_dev, classifier.predict(debiased_x_dev), y_p_dev)\n",
    "\n",
    "\n",
    "        results[removal]['p_acc'] = p_score\n",
    "        #     results[ratio]['biased_diff_tpr'] = biased_diffs['y:0']\n",
    "        results[removal]['biased_diff_tpr'] = rms(list(biased_diffs.values()))\n",
    "        #     results[ratio]['debiased_diff_tpr'] = debiased_diffs['y:0']\n",
    "        results[removal]['debiased_diff_tpr'] = rms(list(debiased_diffs.values()))\n",
    "\n",
    "        results[removal]['biased_acc'] = biased_score\n",
    "        results[removal]['debiased_acc'] = debiased_score\n",
    "        \n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_result_ksal(x_train, x_test, y_m_train, y_m_test, y_p_train, y_p_test, debiased_x_train_all, debiased_x_test_all):\n",
    "    \n",
    "    results = defaultdict(dict)\n",
    "\n",
    "    biased_classifier = LinearSVC(fit_intercept=True, class_weight='balanced', dual=False, C=0.1, max_iter=10000)\n",
    "\n",
    "    biased_classifier.fit(x_train, y_m_train)\n",
    "    biased_score = biased_classifier.score(x_test, y_m_test)\n",
    "    _, biased_diffs = get_TPR(y_m_test, biased_classifier.predict(x_test), y_p_test)\n",
    "    \n",
    "    assert len(debiased_x_train_all) == len(debiased_x_test_all)\n",
    "    \n",
    "    for removal in range(len(debiased_x_train_all)):\n",
    "        debiased_x_train = debiased_x_train_all[removal]\n",
    "        debiased_x_test = debiased_x_test_all[removal]\n",
    "        \n",
    "        classifier = LinearSVC(fit_intercept=True, class_weight='balanced', dual=False, C=0.1, max_iter=10000)\n",
    "        classifier.fit(debiased_x_train, y_m_train)\n",
    "        debiased_score = classifier.score(debiased_x_test, y_m_test)\n",
    "    \n",
    "        p_classifier = SGDClassifier(warm_start=True, loss='log', n_jobs=64, max_iter=10000, random_state=0, tol=1e-3)\n",
    "        p_classifier.fit(debiased_x_train, y_p_train)\n",
    "        p_score = p_classifier.score(debiased_x_test, y_p_test)\n",
    "        _, debiased_diffs = get_TPR(y_m_test, classifier.predict(debiased_x_test), y_p_test)\n",
    "\n",
    "        results[removal]['p_acc'] = p_score\n",
    "        results[removal]['biased_diff_tpr'] = rms(list(biased_diffs.values()))\n",
    "        results[removal]['debiased_diff_tpr'] = rms(list(debiased_diffs.values()))\n",
    "        results[removal]['biased_acc'] = biased_score\n",
    "        results[removal]['debiased_acc'] = debiased_score\n",
    "        \n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_plot_results(results, removel_range):\n",
    "    plot_results = defaultdict(list)\n",
    "    for r in removel_range:\n",
    "        plot_results['biased_diff_tpr'].append(results[r]['biased_diff_tpr'])\n",
    "        plot_results['debiased_diff_tpr'].append(results[r]['debiased_diff_tpr'])\n",
    "        plot_results['biased_acc'].append(results[r]['biased_acc'])\n",
    "        plot_results['debiased_acc'].append(results[r]['debiased_acc'])\n",
    "    return plot_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ratio = 0.5\n",
    "\n",
    "# x_train, y_p_train, y_m_train = load_data(\n",
    "#     '../data/emoji_sent_race_{}/train/'.format(ratio),\n",
    "#     size=100000, ratio=ratio)\n",
    "# x_dev, y_p_dev, y_m_dev = load_data(\n",
    "#     '../data/emoji_sent_race_{}/test/'.format(ratio),\n",
    "#     size=100000, ratio=0.5)\n",
    "# np.savetxt(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/x_train.csv\", x_train, delimiter=\",\")\n",
    "# np.savetxt(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/y_p_train.csv\", y_p_train, delimiter=\",\")\n",
    "# np.savetxt(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/y_m_train.csv\", y_m_train, delimiter=\",\")\n",
    "# np.savetxt(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/x_dev.csv\", x_dev, delimiter=\",\")\n",
    "# np.savetxt(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/y_p_dev.csv\", y_p_dev, delimiter=\",\")\n",
    "# np.savetxt(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/y_m_dev.csv\", y_m_dev, delimiter=\",\")\n",
    "# np.savez(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/all.npz\", x_train = x_train, y_p_train = y_p_train, y_m_train = y_m_train, x_dev = x_dev, y_p_dev = y_p_dev, y_m_dev = y_m_dev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Null it out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ratio = 0.5\n",
    "\n",
    "# saved_dataset = np.load(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/all.npz\")\n",
    "\n",
    "# x_train = saved_dataset['x_train']\n",
    "# y_m_train = saved_dataset['y_m_train']\n",
    "# y_p_train = saved_dataset['y_p_train']\n",
    "\n",
    "# x_dev = saved_dataset['x_dev']\n",
    "# y_p_dev = saved_dataset['y_p_dev']\n",
    "# y_m_dev = saved_dataset['y_m_dev']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = defaultdict(dict)\n",
    "\n",
    "for ratio in [0.5, 0.6, 0.7, 0.8]:\n",
    "\n",
    "#     x_train, y_p_train, y_m_train = load_data(\n",
    "#         '../data/emoji_sent_race_{}/train/'.format(ratio),\n",
    "#         size=100000, ratio=ratio)\n",
    "#     x_dev, y_p_dev, y_m_dev = load_data(\n",
    "#         '../data/emoji_sent_race_{}/test/'.format(ratio),\n",
    "#         size=100000, ratio=0.5)\n",
    "    saved_dataset = np.load(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/all.npz\")\n",
    "\n",
    "    x_train = saved_dataset['x_train']\n",
    "    y_m_train = saved_dataset['y_m_train']\n",
    "    y_p_train = saved_dataset['y_p_train']\n",
    "\n",
    "    x_dev = saved_dataset['x_dev']\n",
    "    y_p_dev = saved_dataset['y_p_dev']\n",
    "    y_m_dev = saved_dataset['y_m_dev']\n",
    "    \n",
    "    biased_classifier = LinearSVC(fit_intercept=True, class_weight='balanced', dual=False, C=0.1, max_iter=10000)\n",
    "\n",
    "    biased_classifier.fit(x_train, y_m_train)\n",
    "    biased_score = biased_classifier.score(x_dev, y_m_dev)\n",
    "    \n",
    "    P = np.load('../data/emoji_sent_race_{}/P_svm.num-clfs=300.npy'.format(ratio), allow_pickle=True)\n",
    "    P = P[1]\n",
    "    n_dims = 120\n",
    "#     n_dims = 70\n",
    "    if ratio == 0.5:\n",
    "        n_dims = 200\n",
    "    elif ratio == 0.6:\n",
    "        n_dims = 100\n",
    "    elif ratio == 0.7:\n",
    "        n_dims = 115\n",
    "    elif ratio == 0.8:\n",
    "        n_dims = 200\n",
    "    P = debias.get_projection_to_intersection_of_nullspaces(P[:n_dims], input_dim=300)\n",
    "    \n",
    "    debiased_x_train = P.dot(x_train.T).T\n",
    "    debiased_x_dev = P.dot(x_dev.T).T\n",
    "\n",
    "    classifier = LinearSVC(fit_intercept=True, class_weight='balanced', dual=False, C=0.1, max_iter=10000)\n",
    "\n",
    "    classifier.fit(debiased_x_train, y_m_train)\n",
    "    debiased_score = classifier.score(debiased_x_dev, y_m_dev)\n",
    "    \n",
    "    p_classifier = SGDClassifier(warm_start=True, loss='log', n_jobs=64, max_iter=10000, random_state=0, tol=1e-3)\n",
    "    p_classifier.fit(debiased_x_train, y_p_train)\n",
    "    p_score = p_classifier.score(debiased_x_dev, y_p_dev)\n",
    "    results[ratio]['p_acc'] = p_score\n",
    "    \n",
    "    _, biased_diffs = get_TPR(y_m_dev, biased_classifier.predict(x_dev), y_p_dev)\n",
    "    \n",
    "    _, debiased_diffs = get_TPR(y_m_dev, classifier.predict(debiased_x_dev), y_p_dev)\n",
    "    \n",
    "#     results[ratio]['biased_diff_tpr'] = biased_diffs['y:0']\n",
    "    results[ratio]['biased_diff_tpr'] = rms(list(biased_diffs.values()))\n",
    "#     results[ratio]['debiased_diff_tpr'] = debiased_diffs['y:0']\n",
    "    results[ratio]['debiased_diff_tpr'] = rms(list(debiased_diffs.values()))\n",
    "    \n",
    "    results[ratio]['biased_acc'] = biased_score\n",
    "    results[ratio]['debiased_acc'] = debiased_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(dict,\n",
       "            {0.5: {'p_acc': 0.5396349087271818,\n",
       "              'biased_diff_tpr': 0.14560632483708713,\n",
       "              'debiased_diff_tpr': 0.11974302439852863,\n",
       "              'biased_acc': 0.7653163290822705,\n",
       "              'debiased_acc': 0.7625656414103525},\n",
       "             0.6: {'p_acc': 0.5946486621655414,\n",
       "              'biased_diff_tpr': 0.22630502371727185,\n",
       "              'debiased_diff_tpr': 0.19067232927585404,\n",
       "              'biased_acc': 0.7531882970742686,\n",
       "              'debiased_acc': 0.7579394848712178},\n",
       "             0.7: {'p_acc': 0.6257814453613403,\n",
       "              'biased_diff_tpr': 0.31864557675474753,\n",
       "              'debiased_diff_tpr': 0.26266284955843594,\n",
       "              'biased_acc': 0.741185296324081,\n",
       "              'debiased_acc': 0.7478119529882471},\n",
       "             0.8: {'p_acc': 0.5043760940235059,\n",
       "              'biased_diff_tpr': 0.4043010400370602,\n",
       "              'debiased_diff_tpr': 0.010947167516829342,\n",
       "              'biased_acc': 0.7200550137534384,\n",
       "              'debiased_acc': 0.5290072518129533}})"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list,\n",
       "            {'biased_diff_tpr': [0.14560632483708713,\n",
       "              0.22630502371727185,\n",
       "              0.31864557675474753,\n",
       "              0.4043010400370602],\n",
       "             'debiased_diff_tpr': [0.11974302439852863,\n",
       "              0.19067232927585404,\n",
       "              0.26266284955843594,\n",
       "              0.010947167516829342],\n",
       "             'biased_acc': [0.7653163290822705,\n",
       "              0.7531882970742686,\n",
       "              0.741185296324081,\n",
       "              0.7200550137534384],\n",
       "             'debiased_acc': [0.7625656414103525,\n",
       "              0.7579394848712178,\n",
       "              0.7478119529882471,\n",
       "              0.5290072518129533]})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_results = defaultdict(list)\n",
    "for r in [0.5, 0.6, 0.7, 0.8]:\n",
    "    plot_results['biased_diff_tpr'].append(results[r]['biased_diff_tpr'])\n",
    "    plot_results['debiased_diff_tpr'].append(results[r]['debiased_diff_tpr'])\n",
    "    plot_results['biased_acc'].append(results[r]['biased_acc'])\n",
    "    plot_results['debiased_acc'].append(results[r]['debiased_acc'])\n",
    "plot_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KSAL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We recommend you to use the code in src/ksal, coz it took very long time and large memory to calculated the debiased_x by ksal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 15000\n",
    "N_test = 7998"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.Ratio = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "ratio = 0.5\n",
    "saved_dataset = np.load(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/all.npz\")\n",
    "\n",
    "x_train = saved_dataset['x_train']\n",
    "y_m_train = saved_dataset['y_m_train']\n",
    "y_p_train = saved_dataset['y_p_train']\n",
    "\n",
    "x_test = saved_dataset['x_dev']\n",
    "y_p_test = saved_dataset['y_p_dev']\n",
    "y_m_test = saved_dataset['y_m_dev']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Linear Kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kernel_fn = \"linear\"\n",
    "kernel_coef = 0\n",
    "\n",
    "saved_model = np.load(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/cleaned_{kernel_fn}_{kernel_coef}_Train{N}_Test{N_test}.npz\")\n",
    "debiased_x_train_0 = saved_model['debiased_x_train_0']\n",
    "debiased_x_test_0 = saved_model['debiased_x_test_0']\n",
    "debiased_x_train_1 = saved_model['debiased_x_train_1']\n",
    "debiased_x_test_1 = saved_model['debiased_x_test_1']\n",
    "debiased_x_train_2 = saved_model['debiased_x_train_2']\n",
    "debiased_x_test_2 = saved_model['debiased_x_test_2']\n",
    "\n",
    "\n",
    "debiased_x_train_all = [debiased_x_train_0, debiased_x_train_1, debiased_x_train_2]\n",
    "debiased_x_test_all = [debiased_x_test_0, debiased_x_test_1, debiased_x_test_2]\n",
    "\n",
    "removel_range = np.arange(0, len(debiased_x_train_all))\n",
    "removel_range\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(dict,\n",
       "            {0: {'p_acc': 0.8698424606151538,\n",
       "              'biased_diff_tpr': 0.1502091848184275,\n",
       "              'debiased_diff_tpr': 0.1504968261279982,\n",
       "              'biased_acc': 0.7619404851212803,\n",
       "              'debiased_acc': 0.7616904226056515},\n",
       "             1: {'p_acc': 0.8615903975993998,\n",
       "              'biased_diff_tpr': 0.1502091848184275,\n",
       "              'debiased_diff_tpr': 0.15201284243714744,\n",
       "              'biased_acc': 0.7619404851212803,\n",
       "              'debiased_acc': 0.7616904226056515},\n",
       "             2: {'p_acc': 0.48637159289822457,\n",
       "              'biased_diff_tpr': 0.1502091848184275,\n",
       "              'debiased_diff_tpr': 0.10883716039415621,\n",
       "              'biased_acc': 0.7619404851212803,\n",
       "              'debiased_acc': 0.7639409852463116}})"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = check_result_ksal(x_train[:N], x_test[:N_test], y_m_train[:N], y_m_test[:N_test], y_p_train[:N], y_p_test[:N_test], \\\n",
    "                      debiased_x_train_all, debiased_x_test_all)\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list,\n",
       "            {'biased_diff_tpr': [0.1502091848184275,\n",
       "              0.1502091848184275,\n",
       "              0.1502091848184275],\n",
       "             'debiased_diff_tpr': [0.1504968261279982,\n",
       "              0.15201284243714744,\n",
       "              0.10883716039415621],\n",
       "             'biased_acc': [0.7619404851212803,\n",
       "              0.7619404851212803,\n",
       "              0.7619404851212803],\n",
       "             'debiased_acc': [0.7616904226056515,\n",
       "              0.7616904226056515,\n",
       "              0.7639409852463116]})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_results = convert_to_plot_results(results, removel_range)\n",
    "plot_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data2plot(plot_results, removel_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 RBF kernel at gamma = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kernel_fn = \"rbf\"\n",
    "kernel_coef = 0.1\n",
    "\n",
    "saved_model = np.load(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/cleaned_{kernel_fn}_{kernel_coef}_Train{N}_Test{N_test}.npz\")\n",
    "debiased_x_train_0 = saved_model['debiased_x_train_0']\n",
    "debiased_x_test_0 = saved_model['debiased_x_test_0']\n",
    "debiased_x_train_1 = saved_model['debiased_x_train_1']\n",
    "debiased_x_test_1 = saved_model['debiased_x_test_1']\n",
    "debiased_x_train_2 = saved_model['debiased_x_train_2']\n",
    "debiased_x_test_2 = saved_model['debiased_x_test_2']\n",
    "\n",
    "\n",
    "debiased_x_train_all = [debiased_x_train_0, debiased_x_train_1, debiased_x_train_2]\n",
    "debiased_x_test_all = [debiased_x_test_0, debiased_x_test_1, debiased_x_test_2]\n",
    "\n",
    "removel_range = np.arange(0, len(debiased_x_train_all))\n",
    "removel_range\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(dict,\n",
       "            {0: {'p_acc': 0.8448362090522631,\n",
       "              'biased_diff_tpr': 0.1502091848184275,\n",
       "              'debiased_diff_tpr': 0.15173285176162127,\n",
       "              'biased_acc': 0.7619404851212803,\n",
       "              'debiased_acc': 0.7634408602150538},\n",
       "             1: {'p_acc': 0.8442110527631908,\n",
       "              'biased_diff_tpr': 0.1502091848184275,\n",
       "              'debiased_diff_tpr': 0.15103294642036444,\n",
       "              'biased_acc': 0.7619404851212803,\n",
       "              'debiased_acc': 0.7641910477619405},\n",
       "             2: {'p_acc': 0.49987496874218557,\n",
       "              'biased_diff_tpr': 0.1502091848184275,\n",
       "              'debiased_diff_tpr': 0.12146052772714196,\n",
       "              'biased_acc': 0.7619404851212803,\n",
       "              'debiased_acc': 0.7651912978244562}})"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = check_result_ksal(x_train[:N], x_test[:N_test], y_m_train[:N], y_m_test[:N_test], y_p_train[:N], y_p_test[:N_test], \\\n",
    "                      debiased_x_train_all, debiased_x_test_all)\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list,\n",
       "            {'biased_diff_tpr': [0.1502091848184275,\n",
       "              0.1502091848184275,\n",
       "              0.1502091848184275],\n",
       "             'debiased_diff_tpr': [0.15173285176162127,\n",
       "              0.15103294642036444,\n",
       "              0.12146052772714196],\n",
       "             'biased_acc': [0.7619404851212803,\n",
       "              0.7619404851212803,\n",
       "              0.7619404851212803],\n",
       "             'debiased_acc': [0.7634408602150538,\n",
       "              0.7641910477619405,\n",
       "              0.7651912978244562]})"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_results = convert_to_plot_results(results, removel_range)\n",
    "plot_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data2plot(plot_results, removel_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Polynomial kernel at degree=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kernel_fn = \"poly\"\n",
    "kernel_coef = 2\n",
    "\n",
    "saved_model = np.load(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/cleaned_{kernel_fn}_{kernel_coef}_Train{N}_Test{N_test}.npz\")\n",
    "debiased_x_train_0 = saved_model['debiased_x_train_0']\n",
    "debiased_x_test_0 = saved_model['debiased_x_test_0']\n",
    "debiased_x_train_1 = saved_model['debiased_x_train_1']\n",
    "debiased_x_test_1 = saved_model['debiased_x_test_1']\n",
    "debiased_x_train_2 = saved_model['debiased_x_train_2']\n",
    "debiased_x_test_2 = saved_model['debiased_x_test_2']\n",
    "\n",
    "\n",
    "debiased_x_train_all = [debiased_x_train_0, debiased_x_train_1, debiased_x_train_2]\n",
    "debiased_x_test_all = [debiased_x_test_0, debiased_x_test_1, debiased_x_test_2]\n",
    "\n",
    "removel_range = np.arange(0, len(debiased_x_train_all))\n",
    "removel_range\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(dict,\n",
       "            {0: {'p_acc': 0.865216304076019,\n",
       "              'biased_diff_tpr': 0.1502091848184275,\n",
       "              'debiased_diff_tpr': 0.14451395083761795,\n",
       "              'biased_acc': 0.7619404851212803,\n",
       "              'debiased_acc': 0.7509377344336085},\n",
       "             1: {'p_acc': 0.8643410852713178,\n",
       "              'biased_diff_tpr': 0.1502091848184275,\n",
       "              'debiased_diff_tpr': 0.14486564891478834,\n",
       "              'biased_acc': 0.7619404851212803,\n",
       "              'debiased_acc': 0.750812703175794},\n",
       "             2: {'p_acc': 0.4441110277569392,\n",
       "              'biased_diff_tpr': 0.1502091848184275,\n",
       "              'debiased_diff_tpr': 0.13027443128532498,\n",
       "              'biased_acc': 0.7619404851212803,\n",
       "              'debiased_acc': 0.7504376094023506}})"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = check_result_ksal(x_train[:N], x_test[:N_test], y_m_train[:N], y_m_test[:N_test], y_p_train[:N], y_p_test[:N_test], \\\n",
    "                      debiased_x_train_all, debiased_x_test_all)\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list,\n",
       "            {'biased_diff_tpr': [0.1502091848184275,\n",
       "              0.1502091848184275,\n",
       "              0.1502091848184275],\n",
       "             'debiased_diff_tpr': [0.14451395083761795,\n",
       "              0.14486564891478834,\n",
       "              0.13027443128532498],\n",
       "             'biased_acc': [0.7619404851212803,\n",
       "              0.7619404851212803,\n",
       "              0.7619404851212803],\n",
       "             'debiased_acc': [0.7509377344336085,\n",
       "              0.750812703175794,\n",
       "              0.7504376094023506]})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_results = convert_to_plot_results(results, removel_range)\n",
    "plot_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data2plot(plot_results, removel_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 Polynomial kernel at degree=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kernel_fn = \"poly\"\n",
    "kernel_coef = 5\n",
    "\n",
    "saved_model = np.load(f\"../data/saved_models/fair_emoji_sent_race/{ratio}/cleaned_{kernel_fn}_{kernel_coef}_Train{N}_Test{N_test}.npz\")\n",
    "debiased_x_train_0 = saved_model['debiased_x_train_0']\n",
    "debiased_x_test_0 = saved_model['debiased_x_test_0']\n",
    "debiased_x_train_1 = saved_model['debiased_x_train_1']\n",
    "debiased_x_test_1 = saved_model['debiased_x_test_1']\n",
    "debiased_x_train_2 = saved_model['debiased_x_train_2']\n",
    "debiased_x_test_2 = saved_model['debiased_x_test_2']\n",
    "\n",
    "\n",
    "debiased_x_train_all = [debiased_x_train_0, debiased_x_train_1, debiased_x_train_2]\n",
    "debiased_x_test_all = [debiased_x_test_0, debiased_x_test_1, debiased_x_test_2]\n",
    "\n",
    "removel_range = np.arange(0, len(debiased_x_train_all))\n",
    "removel_range\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = check_result_ksal(x_train[:N], x_test[:N_test], y_m_train[:N], y_m_test[:N_test], y_p_train[:N], y_p_test[:N_test], \\\n",
    "                      debiased_x_train_all, debiased_x_test_all)\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_results = convert_to_plot_results(results, removel_range)\n",
    "plot_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data2plot(plot_results, removel_range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}