notebooks/notebook_fair-profession_bert_SAL.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "import sys\n",
    "sys.path.append(\"../src\")\n",
    "sys.path.append(\"../data/embeddings\")\n",
    "sys.path.append(\"../data/biasbios\")\n",
    "sys.path.append(\"../data/embeddings/biasbios\")\n",
    "import classifier\n",
    "import 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.neural_network import MLPClassifier\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from pytorch_transformers import BertTokenizer, BertModel, BertForMaskedLM\n",
    "\n",
    "import scipy\n",
    "from scipy import linalg\n",
    "from scipy import sparse\n",
    "from scipy.stats.stats import pearsonr\n",
    "import tqdm\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import SGDClassifier, SGDRegressor, Perceptron, LogisticRegression\n",
    "from sklearn.utils import shuffle\n",
    "\n",
    "%matplotlib inline\n",
    "matplotlib.rcParams['agg.path.chunksize'] = 10000\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import pickle\n",
    "from collections import defaultdict, Counter\n",
    "from typing import List, Dict\n",
    "\n",
    "import torch\n",
    "from torch import utils\n",
    "\n",
    "# import pytorch_lightning as pl\n",
    "# from pytorch_lightning import Trainer\n",
    "import copy\n",
    "import pandas as pd\n",
    "from gensim.models import FastText\n",
    "import time\n",
    "from gensim.scripts.glove2word2vec import glove2word2vec\n",
    "\n",
    "STOPWORDS = set([\"i\", \"me\", \"my\", \"myself\", \"we\", \"our\", \"ours\", \"ourselves\", \"you\", \"your\", \"yours\", \"yourself\", \"yourselves\", \"he\", \"him\", \"his\", \"himself\", \"she\", \"her\", \"hers\", \"herself\", \"it\", \"its\", \"itself\", \"they\", \"them\", \"their\", \"theirs\", \"themselves\", \"what\", \"which\", \"who\", \"whom\", \"this\", \"that\", \"these\", \"those\", \"am\", \"is\", \"are\", \"was\", \"were\", \"be\", \"been\", \"being\", \"have\", \"has\", \"had\", \"having\", \"do\", \"does\", \"did\", \"doing\", \"a\", \"an\", \"the\", \"and\", \"but\", \"if\", \"or\", \"because\", \"as\", \"until\", \"while\", \"of\", \"at\", \"by\", \"for\", \"with\", \"about\", \"against\", \"between\", \"into\", \"through\", \"during\", \"before\", \"after\", \"above\", \"below\", \"to\", \"from\", \"up\", \"down\", \"in\", \"out\", \"on\", \"off\", \"over\", \"under\", \"again\", \"further\", \"then\", \"once\", \"here\", \"there\", \"when\", \"where\", \"why\", \"how\", \"all\", \"any\", \"both\", \"each\", \"few\", \"more\", \"most\", \"other\", \"some\", \"such\", \"no\", \"nor\", \"not\", \"only\", \"own\", \"same\", \"so\", \"than\", \"too\", \"very\", \"s\", \"t\", \"can\", \"will\", \"just\", \"don\", \"should\", \"now\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def load_dataset(path):\n",
    "    \n",
    "    with open(path, \"rb\") as f:\n",
    "        \n",
    "        data = pickle.load(f)\n",
    "    return data\n",
    "\n",
    "def load_dictionary(path):\n",
    "    \n",
    "    with open(path, \"r\", encoding = \"utf-8\") as f:\n",
    "        \n",
    "        lines = f.readlines()\n",
    "        \n",
    "    k2v, v2k = {}, {}\n",
    "    for line in lines:\n",
    "        \n",
    "        k,v = line.strip().split(\"\\t\")\n",
    "        v = int(v)\n",
    "        k2v[k] = v\n",
    "        v2k[v] = k\n",
    "    \n",
    "    return k2v, v2k\n",
    "    \n",
    "def count_profs_and_gender(data: List[dict]):\n",
    "    \n",
    "    counter = defaultdict(Counter)\n",
    "    for entry in data:\n",
    "        gender, prof = entry[\"g\"], entry[\"p\"]\n",
    "        counter[prof][gender] += 1\n",
    "        \n",
    "    return counter\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = load_dataset(\"../data/biasbios/train.pickle\")\n",
    "dev = load_dataset(\"../data/biasbios/dev.pickle\")\n",
    "test = load_dataset(\"../data/biasbios/test.pickle\")\n",
    "\n",
    "p2i, i2p = load_dictionary(\"../data/biasbios/profession2index.txt\")\n",
    "g2i, i2g = load_dictionary(\"../data/biasbios/gender2index.txt\")\n",
    "counter = count_profs_and_gender(train+dev+test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'g': 'f',\n",
       " 'p': 'professor',\n",
       " 'text': 'Dr. Jessica Orlofske is an Assistant Professor of Biology at the University of Wisconsin-Parkside. Her research program areas include invertebrate biodiversity and conservation and biomonitoring and assessment of ecological integrity. She obtained her PhD from the University of New Brunswick under the direction of Dr. Donald Baird. Dr. Orlofske was also a post-doctoral fellow with the CRI before taking up her current position, making her the first CRI student to become a Science Director.',\n",
       " 'start': 98,\n",
       " 'hard_text': 'Her research program areas include invertebrate biodiversity and conservation and biomonitoring and assessment of ecological integrity. She obtained her PhD from the University of New Brunswick under the direction of Dr. Donald Baird. Dr. Orlofske was also a post-doctoral fellow with the CRI before taking up her current position, making her the first CRI student to become a Science Director.',\n",
       " 'text_without_gender': '_ research program areas include invertebrate biodiversity and conservation and biomonitoring and assessment of ecological integrity. _ obtained _ PhD from the University of New Brunswick under the direction of Dr. Donald Baird. Dr. _ was also a post-doctoral fellow with the CRI before taking up _ current position, making _ the first CRI student to become a Science Director.',\n",
       " 'hard_text_tokenized': 'Her research program areas include invertebrate biodiversity and conservation and biomonitoring and assessment of ecological integrity . She obtained her PhD from the University of New Brunswick under the direction of Dr. Donald Baird . Dr. Orlofske was also a post - doctoral fellow with the CRI before taking up her current position , making her the first CRI student to become a Science Director .'}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'accountant': 0, 'architect': 1, 'attorney': 2, 'chiropractor': 3, 'comedian': 4, 'composer': 5, 'dentist': 6, 'dietitian': 7, 'dj': 8, 'filmmaker': 9, 'interior_designer': 10, 'journalist': 11, 'model': 12, 'nurse': 13, 'painter': 14, 'paralegal': 15, 'pastor': 16, 'personal_trainer': 17, 'photographer': 18, 'physician': 19, 'poet': 20, 'professor': 21, 'psychologist': 22, 'rapper': 23, 'software_engineer': 24, 'surgeon': 25, 'teacher': 26, 'yoga_teacher': 27}\n"
     ]
    }
   ],
   "source": [
    "print(p2i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.44541700643683746\n",
      "{'professor': 0.4533699535765501, 'psychologist': 0.627327974906881, 'pastor': 0.2583668005354752, 'comedian': 0.21605667060212513, 'nurse': 0.9126009126009126, 'yoga_teacher': 0.825, 'attorney': 0.3766122913505311, 'photographer': 0.3563658099222953, 'composer': 0.16329625884732052, 'model': 0.7858407079646018, 'surgeon': 0.12832108535895986, 'physician': 0.4158485273492286, 'software_engineer': 0.17130434782608694, 'poet': 0.5133630289532294, 'painter': 0.47116788321167885, 'dj': 0.1636828644501279, 'journalist': 0.5159589626674266, 'architect': 0.23372781065088757, 'paralegal': 0.8618677042801557, 'dentist': 0.3672911787665886, 'personal_trainer': 0.4410377358490566, 'teacher': 0.5943396226415094, 'accountant': 0.3950091296409008, 'interior_designer': 0.7874493927125507, 'dietitian': 0.934412955465587, 'filmmaker': 0.3533007334963325, 'chiropractor': 0.3069908814589666, 'rapper': 0.09438775510204081}\n"
     ]
    }
   ],
   "source": [
    "counter = count_profs_and_gender(train+dev+test)\n",
    "f,m = 0., 0.\n",
    "prof2fem = dict()\n",
    "\n",
    "for k, values in counter.items():\n",
    "    f += values['f']\n",
    "    m += values['m']\n",
    "    prof2fem[k] = values['f']/(values['f'] + values['m'])\n",
    "\n",
    "print(f / (f + m))\n",
    "print(prof2fem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'accountant': 0, 'architect': 1, 'attorney': 2, 'chiropractor': 3, 'comedian': 4, 'composer': 5, 'dentist': 6, 'dietitian': 7, 'dj': 8, 'filmmaker': 9, 'interior_designer': 10, 'journalist': 11, 'model': 12, 'nurse': 13, 'painter': 14, 'paralegal': 15, 'pastor': 16, 'personal_trainer': 17, 'photographer': 18, 'physician': 19, 'poet': 20, 'professor': 21, 'psychologist': 22, 'rapper': 23, 'software_engineer': 24, 'surgeon': 25, 'teacher': 26, 'yoga_teacher': 27}\n"
     ]
    }
   ],
   "source": [
    "print(p2i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### get input representatons "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def load_word_vectors(fname):\n",
    "    \n",
    "    model = KeyedVectors.load_word2vec_format(fname, binary=False)\n",
    "    vecs = model.vectors\n",
    "    words = list(model.vocab.keys())\n",
    "    return model, vecs, words\n",
    "\n",
    "\n",
    "def get_embeddings_based_dataset(data: List[dict], word2vec_model, p2i, filter_stopwords = False):\n",
    "    \n",
    "    X, Y = [], []\n",
    "    unk, total = 0., 0.\n",
    "    unknown = []\n",
    "    vocab_counter = Counter()\n",
    "    \n",
    "    for entry in tqdm.tqdm_notebook(data, total = len(data)):\n",
    "        \n",
    "        y = p2i[entry[\"p\"]]\n",
    "        words = entry[\"hard_text_tokenized\"].split(\" \")\n",
    "        if filter_stopwords:\n",
    "            words = [w for w in words if w.lower() not in STOPWORDS]\n",
    "            \n",
    "        vocab_counter.update(words) \n",
    "        bagofwords = np.sum([word2vec_model[w] if w in word2vec_model else word2vec_model[\"unk\"] for w in words], axis = 0)\n",
    "        #print(bagofwords.shape)\n",
    "        X.append(bagofwords)\n",
    "        Y.append(y)\n",
    "        total += len(words)\n",
    "        \n",
    "        unknown_entry = [w for w in words if w not in word2vec_model]\n",
    "        unknown.extend(unknown_entry)\n",
    "        unk += len(unknown_entry)\n",
    "    \n",
    "    X = np.array(X)\n",
    "    Y = np.array(Y)\n",
    "    print(\"% unknown: {}\".format(unk/total))\n",
    "    return X,Y,unknown,vocab_counter\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "word2vec, vecs, words = load_word_vectors(\"../data/embeddings/crawl-300d-2M.vec\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "126757347998435c9ef77686b565b727",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/74882 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "% unknown: 0.010167678378823583\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5f8a4c87dd214faf8567f15fb7aec4b9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/11550 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "% unknown: 0.010116209992979287\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ed317762b9134e9ca709e745ef65232b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/28842 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "% unknown: 0.01018950257509165\n"
     ]
    }
   ],
   "source": [
    "x_train, y_train, unknown_train, vocab_counter_train = get_embeddings_based_dataset(train, word2vec, p2i)\n",
    "x_dev, y_dev, unknown_dev, vocab_counter_dev =  get_embeddings_based_dataset(dev, word2vec, p2i)\n",
    "x_test, y_test, unknown_test, vocab_counter_test =  get_embeddings_based_dataset(test, word2vec, p2i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def save_in_word2vec_format(vecs: np.ndarray, words: np.ndarray, fname: str):\n",
    "\n",
    "\n",
    "#     with open(fname, \"w\", encoding = \"utf-8\") as f:\n",
    "\n",
    "#         f.write(str(len(vecs)) + \" \" + \"300\" + \"\\n\")\n",
    "#         for i, (v,w) in tqdm.tqdm_notebook(enumerate(zip(vecs, words))):\n",
    "\n",
    "#             vec_as_str = \" \".join([str(x) for x in v])\n",
    "#             f.write(w + \" \" + vec_as_str + \"\\n\")\n",
    "\n",
    "\n",
    "# vocab_bios, _ = list(zip(*vocab_counter_train.most_common(120000)))\n",
    "# words_set = set(words)\n",
    "# vocab_bios = [w for w in tqdm.tqdm_notebook(vocab_bios) if w in words_set]\n",
    "# vecs_for_vocab = np.array([word2vec[w] for w in tqdm.tqdm_notebook(vocab_bios)])\n",
    "# print(\"here\")\n",
    "# save_in_word2vec_format(vecs_for_vocab, vocab_bios, \"vecs.vocab.bios.txt\")\n",
    "# word2vec_bios, _, _ = load_word_vectors(\"vecs.vocab.bios.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len train: 74882; len dev: 11550; len test: 28842\n"
     ]
    }
   ],
   "source": [
    "print(\"len train: {}; len dev: {}; len test: {}\".format(len(train), len(dev), len(test)))\n",
    "mean_train = np.mean(x_train, axis = 0, keepdims = True)\n",
    "mean_dev = np.mean(x_dev, axis = 0, keepdims = True)\n",
    "mean_test = np.mean(x_test, axis = 0, keepdims = True)\n",
    "\n",
    "#X_train -= mean_train\n",
    "#X_dev -= mean_dev\n",
    "#X_test -= mean_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len train: 74882; len dev: 11550; len test: 28842\n"
     ]
    }
   ],
   "source": [
    "print(\"len train: {}; len dev: {}; len test: {}\".format(len(train), len(dev), len(test)))\n",
    "mean_train = np.mean(x_train, axis = 0, keepdims = True)\n",
    "mean_dev = np.mean(x_dev, axis = 0, keepdims = True)\n",
    "mean_test = np.mean(x_test, axis = 0, keepdims = True)\n",
    "\n",
    "#X_train -= mean_train\n",
    "#X_dev -= mean_dev\n",
    "#X_test -= mean_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classify by profession"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Using backend ThreadingBackend with 64 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_iter reached after 17 seconds\n",
      "time: 17.493760347366333\n",
      "0.7554112554112554\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Done   1 tasks      | elapsed:   17.3s\n",
      "[Parallel(n_jobs=64)]: Done   1 out of   1 | elapsed:   17.3s finished\n"
     ]
    }
   ],
   "source": [
    "#clf = LinearSVC(max_iter = 10) #LogisticRegression()\n",
    "#clf = SGDClassifier(warm_start = True, loss = 'log', n_jobs = 64, max_iter = 250, random_state = 0)\n",
    "\n",
    "clf = LogisticRegression(warm_start = True, penalty = 'l2',\n",
    "                         solver = \"sag\", multi_class = 'multinomial', fit_intercept = True,\n",
    "                         verbose = 10, max_iter = 4, n_jobs = 64, random_state = 1)\n",
    "#clf = SGDClassifier(loss= 'log', max_iter= 3000, fit_intercept= True, class_weight= None, n_jobs= 100)\n",
    "#clf = LinearSVC(max_iter = 50) #LogisticRegression()\n",
    "\n",
    "start = time.time()\n",
    "idx = np.random.rand(x_train.shape[0]) < 1.0\n",
    "clf.fit(x_train[idx], y_train[idx])\n",
    "print(\"time: {}\".format(time.time() - start))\n",
    "print(clf.score(x_dev, y_dev))\n",
    "#print(clf.score(X_test, Y_test))\n",
    "clf_original = copy.deepcopy(clf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7553914430344636\n"
     ]
    }
   ],
   "source": [
    "print(clf.score(x_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### perform debiasing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_dev_gender = np.array([g2i[d[\"g\"]] for d in dev])\n",
    "y_test_gender = np.array([g2i[d[\"g\"]] for d in test])\n",
    "y_train_gender = np.array([g2i[d[\"g\"]] for d in train])\n",
    "y_train_gender_2d = np.asarray([y_train_gender, - y_train_gender + 1]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((11550,), (74882,), (28842,))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_dev_gender.shape, y_train_gender.shape, y_test_gender.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sal took 0.1637871265411377 seconds\n",
      "u has shape (300, 300), s has shape (2,), vh has shape (2, 2)\n"
     ]
    }
   ],
   "source": [
    "t = time.time()\n",
    "A = np.dot(x_train.T, y_train_gender_2d) / x_train.shape[0]\n",
    "u, s, vh = np.linalg.svd(A, full_matrices=True)\n",
    "elapsed = time.time() - t\n",
    "print(f\"sal took {elapsed} seconds\")\n",
    "print(f\"u has shape {u.shape}, s has shape {s.shape}, vh has shape {vh.shape}\")"
   ]
  },
  {
   "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": [
    "# To save the model\n",
    "\n",
    "# removal = 1\n",
    "# u_r = u[:, removal:]\n",
    "# proj = u_r @ u_r.T\n",
    "# P = proj\n",
    "\n",
    "# debiased_x_train_1 = P.dot(x_train.T).T\n",
    "# debiased_x_dev_1 = P.dot(x_dev.T).T\n",
    "# debiased_x_test_1 = P.dot(x_test.T).T\n",
    "\n",
    "# removal = 2\n",
    "# u_r = u[:, removal:]\n",
    "# proj = u_r @ u_r.T\n",
    "# P = proj\n",
    "\n",
    "# debiased_x_train_2 = P.dot(x_train.T).T\n",
    "# debiased_x_dev_2 = P.dot(x_dev.T).T\n",
    "# debiased_x_test_2 = P.dot(x_test.T).T\n",
    "\n",
    "# rm -rf FastText.npz\n",
    "\n",
    "# np.savez(\"FastText.npz\", u = u, s = s, vh = vh, \n",
    "#          x_train = x_train, x_test = x_test, \n",
    "#          debiased_x_train_1 = debiased_x_train_1, debiased_x_test_1 = debiased_x_test_1, \n",
    "#          debiased_x_train_2 = debiased_x_train_2, debiased_x_test_2 = debiased_x_test_2, \n",
    "#          y_train_gender = y_train_gender, y_train = y_train, \n",
    "#          y_test_gender = y_test_gender, y_test = y_test)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perform finetuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# clf = LogisticRegression(warm_start = True, penalty = 'l2',\n",
    "#                          solver = \"sag\", multi_class = 'multinomial', fit_intercept = True,\n",
    "#                          verbose = 10, max_iter = 6, n_jobs = 64, random_state = 0, class_weight = None)\n",
    "\n",
    "# clf.fit(debiased_x_train, y_train)\n",
    "\n",
    "# print(clf.score(debiased_x_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### test again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_TPR(y_pred, y_true, p2i, i2p, gender):\n",
    "    \n",
    "    scores = defaultdict(Counter)\n",
    "    prof_count_total = defaultdict(Counter)\n",
    "    \n",
    "    assert len(y_pred) == len(y_true) == len(gender)\n",
    "               \n",
    "    for y_hat, y, g in zip(y_pred, y_true, gender):\n",
    "                \n",
    "        if y == y_hat:\n",
    "            \n",
    "            scores[i2p[y]][g] += 1\n",
    "        \n",
    "        prof_count_total[i2p[y]][g] += 1\n",
    "    \n",
    "    tprs = defaultdict(dict)\n",
    "    tprs_change = dict()\n",
    "    tprs_ratio = []\n",
    "    \n",
    "    for profession, scores_dict in scores.items():\n",
    "        \n",
    "        good_m, good_f = scores_dict[\"m\"], scores_dict[\"f\"]\n",
    "        prof_total_f = prof_count_total[profession][\"f\"]\n",
    "        prof_total_m = prof_count_total[profession][\"m\"]\n",
    "        tpr_m = (good_m) / prof_total_m\n",
    "        tpr_f = (good_f) / prof_total_f\n",
    "        \n",
    "        tprs[profession][\"m\"] = tpr_m\n",
    "        tprs[profession][\"f\"] = tpr_f\n",
    "        tprs_ratio.append(0)\n",
    "        tprs_change[profession] = tpr_f - tpr_m\n",
    "        \n",
    "    return tprs, tprs_change, np.mean(np.abs(tprs_ratio))\n",
    "\n",
    "def get_FPR(y_pred, y_true, p2i, i2p, gender):\n",
    "    \n",
    "    fp = defaultdict(Counter)\n",
    "    neg_count_total = defaultdict(Counter)\n",
    "    pos_count_total = defaultdict(Counter)\n",
    "    \n",
    "    \n",
    "               \n",
    "    for y_hat, y, g in zip(y_pred, y_true, gender):\n",
    "        \n",
    "        if y != y_hat:\n",
    "            \n",
    "            fp[i2p[y_hat]][g] += 1 # count false positives for y_hat\n",
    "        \n",
    "        neg_count_total[i2p[y_hat]][g] += 1 # count \"not y_hat\"\n",
    "                \n",
    "    fprs = defaultdict(dict)\n",
    "    fprs_change = dict()\n",
    "    fprs_ratio = []\n",
    "    \n",
    "    #print(prof_count_total)\n",
    "    \n",
    "    for profession, scores_dict in fp.items():\n",
    "        \n",
    "        good_m, good_f = scores_dict[\"m\"], scores_dict[\"f\"]\n",
    "        prof_total_f = neg_count_total[profession][\"f\"]\n",
    "        prof_total_m = neg_count_total[profession][\"m\"]\n",
    "        print(profession)\n",
    "        fpr_m = (good_m+good_f) / prof_total_m\n",
    "        fpr_f = (good_m+good_f) / prof_total_f\n",
    "        \n",
    "        fprs[profession][\"m\"] = fpr_m\n",
    "        fprs[profession][\"f\"] = fpr_f\n",
    "        fprs_ratio.append(0)\n",
    "        fprs_change[profession] = fpr_m - fpr_f\n",
    "        \n",
    "    return fprs, fprs_change, np.mean(np.abs(fprs_ratio))    \n",
    "    \n",
    "def similarity_vs_tpr(tprs, word2vec, title, measure, prof2fem):\n",
    "    \n",
    "    professions = list(tprs.keys())\n",
    "    #\n",
    "    \"\"\" \n",
    "    sims = dict()\n",
    "    gender_direction = word2vec[\"he\"] - word2vec[\"she\"]\n",
    "    \n",
    "    for p in professions:\n",
    "        sim = word2vec.cosine_similarities(word2vec[p], [gender_direction])[0]\n",
    "        sims[p] = sim\n",
    "    \"\"\"\n",
    "    tpr_lst = [tprs[p] for p in professions]\n",
    "    sim_lst = [prof2fem[p] for p in professions]\n",
    "\n",
    "    #professions = [p.replace(\"_\", \" \") for p in professions if p in word2vec]\n",
    "    \n",
    "    plt.plot(sim_lst, tpr_lst, marker = \"o\", linestyle = \"none\")\n",
    "    plt.xlabel(\"% women\", fontsize = 13)\n",
    "    plt.ylabel(r'$GAP_{female,y}^{TPR}$', fontsize = 13)\n",
    "    for p in professions:\n",
    "        x,y = prof2fem[p], tprs[p]\n",
    "        plt.annotate(p , (x,y), size = 7, color = \"red\")\n",
    "    \n",
    "    plt.ylim(-0.4,0.55)\n",
    "    z = np.polyfit(sim_lst, tpr_lst, 1)\n",
    "    p = np.poly1d(z)\n",
    "    plt.plot(sim_lst,p(sim_lst),\"b--\")\n",
    "\n",
    "    plt.savefig(\"{}_vs_bias_{}_fasttext\".format(measure, title), dpi = 600)\n",
    "    print(\"Correlation: {}; p-value: {}\".format(*pearsonr(sim_lst, tpr_lst)))\n",
    "    plt.show()\n",
    "    \n",
    "def rms_diff(tpr_diff):\n",
    "    \n",
    "    return np.sqrt(np.mean(tpr_diff**2))\n",
    "    \n",
    "def save_vecs_and_words(vecs, words):\n",
    "    def to_string(arr):\n",
    "        return \"\\t\".join([str(x) for x in arr])\n",
    "    \n",
    "    with open(\"vecs.txt\", \"w\") as f:\n",
    "        for v in vecs:\n",
    "            assert len(v) == 300\n",
    "            f.write(to_string(v) + \"\\n\")\n",
    "    \n",
    "    with open(\"labels.txt\", \"w\") as f:\n",
    "            f.write(\"Profession\\n\")\n",
    "            for w in words:\n",
    "                f.write(w + \"\\n\")"
   ]
  },
  {
   "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": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "removal = 1\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",
    "debiased_x_test = P.dot(x_test.T).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation: 0.8229158334674403; p-value: 7.657770186244778e-08\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Using backend ThreadingBackend with 64 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_iter reached after 26 seconds\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Done   1 tasks      | elapsed:   25.9s\n",
      "[Parallel(n_jobs=64)]: Done   1 out of   1 | elapsed:   25.9s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation: 0.8414221239242293; p-value: 2.0380691845191047e-08\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rms-diff before: 0.20125138721368724; rms-diff after: 0.18630195968662291\n"
     ]
    }
   ],
   "source": [
    "y_pred_before = clf_original.predict(x_test)\n",
    "test_gender = [d[\"g\"] for d in test]\n",
    "dev_gender = [d[\"g\"] for d in dev]\n",
    "train_gender = [d[\"g\"] for d in train]\n",
    "\n",
    "tprs_before, tprs_change_before, mean_ratio_before = get_TPR(y_pred_before, y_test, p2i, i2p, test_gender)\n",
    "similarity_vs_tpr(tprs_change_before, word2vec, \"before\", \"TPR\", prof2fem)\n",
    "\n",
    "clf = LogisticRegression(warm_start = True, penalty = 'l2',\n",
    "                         solver = \"sag\", multi_class = 'multinomial', fit_intercept = True,\n",
    "                         verbose = 10, max_iter = 6, n_jobs = 64, random_state = 0, class_weight = None)\n",
    "clf.fit(debiased_x_train, y_train)\n",
    "y_pred_after = clf.predict(debiased_x_test)\n",
    "\n",
    "tprs, tprs_change_after, mean_ratio_after = get_TPR(y_pred_after, y_test, p2i, i2p, test_gender)\n",
    "similarity_vs_tpr(tprs_change_after, word2vec, \"after\", \"TPR\", prof2fem)\n",
    "\n",
    "change_vals_before = np.array(list((tprs_change_before.values())))\n",
    "change_vals_after = np.array(list(tprs_change_after.values()))\n",
    "\n",
    "print(\"rms-diff before: {}; rms-diff after: {}\".format(rms_diff(change_vals_before), rms_diff(change_vals_after)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Using backend ThreadingBackend with 64 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_iter reached after 26 seconds\n",
      "0.7596907287982803\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Done   1 tasks      | elapsed:   26.2s\n",
      "[Parallel(n_jobs=64)]: Done   1 out of   1 | elapsed:   26.2s finished\n"
     ]
    }
   ],
   "source": [
    "clf = LogisticRegression(warm_start = True, penalty = 'l2',\n",
    "                         solver = \"sag\", multi_class = 'multinomial', fit_intercept = True,\n",
    "                         verbose = 10, max_iter = 6, n_jobs = 64, random_state = 0, class_weight = None)\n",
    "\n",
    "clf.fit(debiased_x_train, y_train)\n",
    "\n",
    "print(clf.score(debiased_x_test, y_test))"
   ]
  },
  {
   "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": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "removal = 2\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",
    "debiased_x_test = P.dot(x_test.T).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation: 0.8229158334674403; p-value: 7.657770186244778e-08\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Using backend ThreadingBackend with 64 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_iter reached after 26 seconds\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Done   1 tasks      | elapsed:   25.9s\n",
      "[Parallel(n_jobs=64)]: Done   1 out of   1 | elapsed:   25.9s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation: 0.5988793708459228; p-value: 0.0007596910522041412\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rms-diff before: 0.20125138721368724; rms-diff after: 0.11933701391761586\n"
     ]
    }
   ],
   "source": [
    "y_pred_before = clf_original.predict(x_test)\n",
    "test_gender = [d[\"g\"] for d in test]\n",
    "dev_gender = [d[\"g\"] for d in dev]\n",
    "train_gender = [d[\"g\"] for d in train]\n",
    "\n",
    "tprs_before, tprs_change_before, mean_ratio_before = get_TPR(y_pred_before, y_test, p2i, i2p, test_gender)\n",
    "similarity_vs_tpr(tprs_change_before, word2vec, \"before\", \"TPR\", prof2fem)\n",
    "\n",
    "clf = LogisticRegression(warm_start = True, penalty = 'l2',\n",
    "                         solver = \"sag\", multi_class = 'multinomial', fit_intercept = True,\n",
    "                         verbose = 10, max_iter = 6, n_jobs = 64, random_state = 0, class_weight = None)\n",
    "clf.fit(debiased_x_train, y_train)\n",
    "y_pred_after = clf.predict(debiased_x_test)\n",
    "\n",
    "tprs, tprs_change_after, mean_ratio_after = get_TPR(y_pred_after, y_test, p2i, i2p, test_gender)\n",
    "similarity_vs_tpr(tprs_change_after, word2vec, \"after\", \"TPR\", prof2fem)\n",
    "\n",
    "change_vals_before = np.array(list((tprs_change_before.values())))\n",
    "change_vals_after = np.array(list(tprs_change_after.values()))\n",
    "\n",
    "print(\"rms-diff before: {}; rms-diff after: {}\".format(rms_diff(change_vals_before), rms_diff(change_vals_after)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Using backend ThreadingBackend with 64 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_iter reached after 26 seconds\n",
      "0.7558075029470911\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=64)]: Done   1 tasks      | elapsed:   25.8s\n",
      "[Parallel(n_jobs=64)]: Done   1 out of   1 | elapsed:   25.8s finished\n"
     ]
    }
   ],
   "source": [
    "clf = LogisticRegression(warm_start = True, penalty = 'l2',\n",
    "                         solver = \"sag\", multi_class = 'multinomial', fit_intercept = True,\n",
    "                         verbose = 10, max_iter = 6, n_jobs = 64, random_state = 0, class_weight = None)\n",
    "\n",
    "clf.fit(debiased_x_train, y_train)\n",
    "\n",
    "print(clf.score(debiased_x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "removal = 20\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",
    "debiased_x_test = P.dot(x_test.T).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_before = clf_original.predict(x_test)\n",
    "test_gender = [d[\"g\"] for d in test]\n",
    "dev_gender = [d[\"g\"] for d in dev]\n",
    "train_gender = [d[\"g\"] for d in train]\n",
    "\n",
    "tprs_before, tprs_change_before, mean_ratio_before = get_TPR(y_pred_before, y_test, p2i, i2p, test_gender)\n",
    "similarity_vs_tpr(tprs_change_before, word2vec, \"before\", \"TPR\", prof2fem)\n",
    "#y_pred_after = clf.predict(X_test.dot(P))\n",
    "y_pred_after = clf.predict(debiased_x_test)\n",
    "tprs, tprs_change_after, mean_ratio_after = get_TPR(y_pred_after, y_test, p2i, i2p, test_gender)\n",
    "similarity_vs_tpr(tprs_change_after, word2vec, \"after\", \"TPR\", prof2fem)\n",
    "\n",
    "change_vals_before = np.array(list((tprs_change_before.values())))\n",
    "change_vals_after = np.array(list(tprs_change_after.values()))\n",
    "\n",
    "print(\"rms-diff before: {}; rms-diff after: {}\".format(rms_diff(change_vals_before), rms_diff(change_vals_after)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = LogisticRegression(warm_start = True, penalty = 'l2',\n",
    "                         solver = \"sag\", multi_class = 'multinomial', fit_intercept = True,\n",
    "                         verbose = 10, max_iter = 6, n_jobs = 64, random_state = 0, class_weight = None)\n",
    "\n",
    "clf.fit(debiased_x_train, y_train)\n",
    "\n",
    "print(clf.score(debiased_x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = LogisticRegression(warm_start = True, penalty = 'l2',\n",
    "                         solver = \"sag\", multi_class = 'multinomial', fit_intercept = True,\n",
    "                         verbose = 10, max_iter = 6, n_jobs = 64, random_state = 0, class_weight = None)\n",
    "\n",
    "clf.fit(x_train, y_train)\n",
    "\n",
    "print(f\"Biased Train accuracy {clf.score(x_train, y_train)}\")\n",
    "print(f\"Biased Test accuracy {clf.score(x_test, y_test)}\")\n",
    "print(f\"Train accuracy {clf.score(debiased_x_train, y_train)}\")\n",
    "print(f\"Test accuracy {clf.score(debiased_x_test, y_test)}\")"
   ]
  },
  {
   "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": 2
}