synthetic_experiments_supplement.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T00:57:53.437729Z",
     "start_time": "2019-05-12T00:57:50.408059Z"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "from pprint import pprint\n",
    "\n",
    "import numpy as np\n",
    "import scipy.optimize\n",
    "import scipy.stats\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T01:44:49.269801Z",
     "start_time": "2019-05-12T01:44:49.259832Z"
    }
   },
   "outputs": [],
   "source": [
    "# OUTPUTS:\n",
    "# 1. universe = list of all players, i.e. [1, ..., n]\n",
    "# 2. pi_list = list of all partial rankings. each partial ranking is tuple (ordering, scores)\n",
    "# e.g. ([1,3,2],[5,6,7]) means player 1 < player 3 < player 2, with player 1 getting score 5, etc.\n",
    "\n",
    "# INPUTS:\n",
    "# 1. n = size of universe\n",
    "# 2. s is such that\n",
    "# partial rankings = min(s, #of partial rankings needed so that each element of the universe is in >1 ranking)\n",
    "# 3. p = prob an element is in s \n",
    "# 4. means[i] is mean score for elt i\n",
    "# 5. sigma = stdev of scores\n",
    "def create_pi_list(n, s, p, means, sigma):\n",
    "    pi_list = []\n",
    "    included_elts = set() # list of all elements in some partial ranking\n",
    "    while (len(included_elts) < n) or (len(pi_list) < s):\n",
    "        pi=[]\n",
    "        for v in range(1, n+1):\n",
    "            if random.uniform(0,1) < p:\n",
    "                pi += [v]\n",
    "        scaling = np.random.uniform(low=1/3,high=3)\n",
    "        scores = [np.random.normal(means[w-1] / 5, sigma) * scaling for w in pi]\n",
    "\n",
    "        if len(pi) > 1:\n",
    "            scores_sorted = [x for x, _ in sorted(zip(scores, pi), key=lambda pair: pair[0])]\n",
    "            pi_sorted = [x for _, x in sorted(zip(scores, pi), key=lambda pair: pair[0])]\n",
    "            pi_list += [(pi_sorted, scores_sorted)]\n",
    "            included_elts.update(pi_sorted)\n",
    "    universe=np.array(list(included_elts))\n",
    "    return (universe, pi_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T01:35:45.209376Z",
     "start_time": "2019-05-12T01:35:45.202082Z"
    }
   },
   "outputs": [],
   "source": [
    "##################################################\n",
    "# COMPUTE PAGERANK\n",
    "##################################################\n",
    "\n",
    "# given probability transition matrix P\n",
    "# where P_{v,w} = Prob(w -> v)\n",
    "# find pagerank scores with restart probability r\n",
    "def compute_pr(P, r, n, eps=1e-8):\n",
    "    x = np.ones(n) / n*1.0\n",
    "    flag = True\n",
    "    t=0\n",
    "    while flag:\n",
    "        x_new = (1-r)*P.dot(x)\n",
    "        x_new = x_new + np.ones(n) * r / n\n",
    "        diff = np.linalg.norm(x_new - x)\n",
    "        if np.linalg.norm(x_new - x,ord=1) < eps and t > 100:\n",
    "            flag = False\n",
    "        t=t+1\n",
    "        x = x_new\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hypergraph ranking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T02:27:37.268334Z",
     "start_time": "2019-05-12T02:27:37.255856Z"
    }
   },
   "outputs": [],
   "source": [
    "# OUTPUT:\n",
    "# ordering of players using hypergraph rank aggregation algorithm\n",
    "# expressed via a list, e.g. [1,3,2,4] means player 1 < player 3 < ...\n",
    "def hg_rank(universe, pi_list):\n",
    "    # first create these matrices\n",
    "    # R = |E| x |V|, H(e, v) = lambda_e(v)\n",
    "    # W = |V| x |E|, W(v, e) = w(e) 1(v in e)\n",
    "    m = len(pi_list) # number of hyperedges\n",
    "    n = len(universe) # number of items to be ranked \n",
    "    R = np.zeros([m, n])\n",
    "    W = np.zeros([n, m])\n",
    "\n",
    "    for i in range(len(pi_list)):\n",
    "        pi, scores = pi_list[i]\n",
    "        if len(pi) > 1:   \n",
    "            for j in range(len(pi)):\n",
    "                v = pi[j]\n",
    "                v = np.where(universe == v)[0][0] #equivalent to universe.index(v) but for np arrays\n",
    "                R[i, v] = np.exp(scores[j])\n",
    "                W[v, i] = 1.0\n",
    "\n",
    "            # edge weight is stdev of vertex weights\n",
    "            W[:, i] = (np.std(scores) + 1.0) * W[:, i]\n",
    "\n",
    "            R[i, :] = R[i,:] / sum(R[i,:])\n",
    "\n",
    "    # create diagonal matrix with entries d(v)\n",
    "    D_V = np.diag(np.sum(W, 1))\n",
    "\n",
    "    # create prob trans matrix\n",
    "    P = np.linalg.inv(D_V).dot(W).dot(R)\n",
    "    P = np.transpose(P) # since we're using column vectors\n",
    "\n",
    "    # create RWR matrix\n",
    "    r=0.40\n",
    "    rankings = compute_pr(P, r, n)\n",
    "    return universe[np.argsort(rankings)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clique graph ranking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T01:57:57.480195Z",
     "start_time": "2019-05-12T01:57:57.472185Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create matrix A, where A_{u,v} is given in Eq 10 in main text\n",
    "def compute_gh_weights(R, W):\n",
    "    E, V = R.shape\n",
    "    A = np.zeros([V,V]) # to return\n",
    "    \n",
    "    # first, create edge weight vector\n",
    "    WE = np.zeros(E)\n",
    "    # for each edge, find first non-zero value that is >0\n",
    "    for e in range(E):\n",
    "        WE[e] = W[np.where(W[:,e] > 0)[0],e][0]\n",
    "    \n",
    "    # iterate over edges, add w(e) * gam_e(u) * gam_e(v) term\n",
    "    # for each pair of vertices u,v \\in e\n",
    "    for e in range(E):\n",
    "        nodes_in_e = np.nonzero(R[e,:])[0]\n",
    "        for u in nodes_in_e:\n",
    "            for v in nodes_in_e:\n",
    "                A[u,v] += WE[e] * R[e,u] * R[e,v]\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T02:27:35.430677Z",
     "start_time": "2019-05-12T02:27:35.418867Z"
    }
   },
   "outputs": [],
   "source": [
    "# OUTPUT:\n",
    "# ordering of players using hypergraph rank aggregation algorithm\n",
    "# expressed via a list, e.g. [1,3,2,4] means player 1 < player 3 < ...\n",
    "def gh_rank(universe, pi_list):\n",
    "    # first create these matrices\n",
    "    # R = |E| x |V|, H(e, v) = lambda_e(v)\n",
    "    # W = |V| x |E|, W(v, e) = w(e) 1(v in e)\n",
    "    m = len(pi_list) # number of hyperedges\n",
    "    n = len(universe) # number of items to be ranked \n",
    "    R = np.zeros([m, n])\n",
    "    W = np.zeros([n, m])\n",
    "\n",
    "    for i in range(len(pi_list)):\n",
    "        pi, scores = pi_list[i]\n",
    "        if len(pi) > 1:   \n",
    "            for j in range(len(pi)):\n",
    "                v = pi[j]\n",
    "                v = np.where(universe == v)[0][0] #equivalent to universe.index(v) but for np arrays\n",
    "                R[i, v] = np.exp(scores[j])\n",
    "                W[v, i] = 1.0\n",
    "\n",
    "            # edge weight is stdev of vertex weights?\n",
    "            W[:, i] = (np.std(scores) + 1.0) * W[:, i]\n",
    "\n",
    "            R[i, :] = R[i,:] / sum(R[i,:])\n",
    "\n",
    "    # compute edge weights of G^H\n",
    "    A = compute_gh_weights(R, W)\n",
    "            \n",
    "    # create prob trans matrix by normalizing columns to sum to 1\n",
    "    P = A/A.sum(axis=1)[:,None]\n",
    "    P=P.T\n",
    "\n",
    "    # create RWR matrix\n",
    "    r=0.40\n",
    "    rankings = compute_pr(P, r, n)\n",
    "    return universe[np.argsort(rankings)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MC3 ranking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T02:04:44.329303Z",
     "start_time": "2019-05-12T02:04:44.318545Z"
    }
   },
   "outputs": [],
   "source": [
    "# OUTPUT:\n",
    "# ordering of players using hypergraph rank aggregation algorithm\n",
    "# expressed via a list, e.g. [1,3,2,4] means player 1 < player 3 < ...\n",
    "def dwork_mc3_rank(universe, pi_list):\n",
    "\n",
    "    n = len(universe)\n",
    "\n",
    "    P = np.zeros([n, n]) #Pij = prob i -> j\n",
    "    # print('pi list')\n",
    "    # print([p[0] for p in pi_list])\n",
    "    # print('')\n",
    "    for i in universe:\n",
    "        # print('i: ' + str(i))\n",
    "        i_counts = np.zeros(n)\n",
    "        i_deg = 0 #number of hyperedges where i can traverse to some other vertex\n",
    "\n",
    "        i_index = np.where(universe == i)\n",
    "        for pi, scores in pi_list:\n",
    "            if i in pi and len(pi) > 1:\n",
    "                pi_filtered = pi[pi.index(i)+1:] #everything ranked better than i\n",
    "\n",
    "                # if i can use this hyperedge\n",
    "                if len(pi_filtered) > 0:\n",
    "                    # essentially, for each j in pi_filtered\n",
    "                    # grab k=universe.index(j) and increment i_counts[k] by 1/len(pi)\n",
    "                    i_counts[np.where(np.isin(universe, pi_filtered))] += 1/len(pi)\n",
    "\n",
    "                i_counts[i_index] += 1 - (len(pi_filtered) / len(pi))\n",
    "                i_deg += 1\n",
    "        if i_deg > 0:\n",
    "            i_counts /= i_deg\n",
    "        else:\n",
    "            i_counts[i_index] = 1\n",
    "        P[i_index,:] = i_counts\n",
    "\n",
    "    P = np.transpose(P) # since we're using column vectors\n",
    "\n",
    "    # create RWR matrix\n",
    "    r=0.40\n",
    "    rankings = compute_pr(P, r, n)\n",
    "    return universe[np.argsort(rankings)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T03:01:14.140164Z",
     "start_time": "2019-05-12T03:01:11.889400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.7805109  0.81606967 0.83631536]]\n",
      "[[0.74508915 0.79889666 0.81579132]]\n",
      "[[0.37376943 0.55427578 0.7025499 ]]\n"
     ]
    }
   ],
   "source": [
    "sigma_list=[1]\n",
    "p_list = [0.03, 0.05, 0.07]\n",
    "num_trials = 10 #number of trials for each (sigma, p) pair\n",
    "n = 100 #number of elements to collectively rank\n",
    "\n",
    "def ranking(n, rank_agg_fns, names, sigma_list, p_list, num_trials):\n",
    "    sl = len(sigma_list)\n",
    "    pl = len(p_list)\n",
    "\n",
    "    wkt_means_hg = np.zeros([sl, pl])\n",
    "    wkt_stdevs_hg = np.zeros([sl, pl])\n",
    "    \n",
    "    wkt_means_gh = np.zeros([sl, pl])\n",
    "    wkt_stdevs_gh = np.zeros([sl, pl])\n",
    "    \n",
    "    wkt_means_dwork = np.zeros([sl, pl])\n",
    "    wkt_stdevs_dwork = np.zeros([sl, pl])\n",
    "\n",
    "    for ind1 in range(len(sigma_list)):\n",
    "        for ind2 in range(len(p_list)):\n",
    "            sigma = sigma_list[ind1]\n",
    "            p = p_list[ind2]\n",
    "            # store results of trials\n",
    "            hg_wkt_list = np.zeros([num_trials])\n",
    "            gh_wkt_list = np.zeros([num_trials])\n",
    "            dwork_wkt_list = np.zeros([num_trials])\n",
    "            \n",
    "            for k in range(num_trials):\n",
    "                # give each element a mean score from [0, 10]\n",
    "                means = np.zeros([n])\n",
    "                for i in range(n):\n",
    "                    means[i] = i\n",
    "\n",
    "                # create partial rankings\n",
    "                # for each elt, create 2 partial rankings with that elt?\n",
    "                # ill start with 1\n",
    "                universe, pi_list = create_pi_list(n, s, p, means, sigma) #middle is s, currently using s=n\n",
    "\n",
    "                # true ranking\n",
    "                # lol the -1 bc i still want to use 1-indexing\n",
    "                true_ranking = [x for _, x in sorted(zip(means[universe - 1], universe), key=lambda pair: pair[0])]\n",
    "\n",
    "                # compute ranking for HG\n",
    "                hg_ranking = hg_rank(universe, pi_list)\n",
    "                hg_wkt_dist = scipy.stats.weightedtau(hg_ranking, true_ranking).correlation\n",
    "                hg_wkt_list[k] = hg_wkt_dist\n",
    "                \n",
    "                # compute ranking for G^H\n",
    "                gh_ranking = gh_rank(universe, pi_list)\n",
    "                gh_wkt_dist = scipy.stats.weightedtau(gh_ranking, true_ranking).correlation\n",
    "                gh_wkt_list[k] = gh_wkt_dist\n",
    "                \n",
    "                # compute ranking for dwork\n",
    "                dwork_ranking = dwork_mc3_rank(universe, pi_list)\n",
    "                dwork_wkt_dist = scipy.stats.weightedtau(dwork_ranking, true_ranking).correlation\n",
    "                dwork_wkt_list[k] = dwork_wkt_dist\n",
    "            \n",
    "            # compute mean, stdev for each fn and add to kt_means, kt_stdevs [and wkt variants]\n",
    "            wkt_means_hg[ind1, ind2] = np.mean(hg_wkt_list)\n",
    "            wkt_stdevs_hg[ind1, ind2] = np.std(hg_wkt_list)\n",
    "            \n",
    "            wkt_means_gh[ind1, ind2] = np.mean(gh_wkt_list)\n",
    "            wkt_stdevs_gh[ind1, ind2] = np.std(gh_wkt_list)\n",
    "            \n",
    "            wkt_means_dwork[ind1, ind2] = np.mean(dwork_wkt_list)\n",
    "            wkt_stdevs_dwork[ind1, ind2] = np.std(dwork_wkt_list)\n",
    "\n",
    "    return wkt_means_hg, wkt_stdevs_hg, wkt_means_gh, wkt_stdevs_gh, wkt_means_dwork, wkt_stdevs_dwork\n",
    "\n",
    "wkt_means_hg, wkt_stdevs_hg, wkt_means_gh, wkt_stdevs_gh, wkt_means_dwork, wkt_stdevs_dwork = ranking(n, rank_agg_fns, names, sigma_list, p_list, num_trials)\n",
    "\n",
    "print(wkt_means_hg)\n",
    "print(wkt_means_dwork)\n",
    "print(wkt_means_gh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-12T03:01:20.265438Z",
     "start_time": "2019-05-12T03:01:19.904981Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ind = np.arange(3)  # the x locations for the groups\n",
    "width = 0.15       # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(ind, wkt_means_hg[0,:], width, color='r', yerr=wkt_stdevs_hg[0,:])\n",
    "rects2 = ax.bar(ind + width, wkt_means_dwork[0,:], width, color='g', yerr=wkt_stdevs_hg[0,:])\n",
    "rects3 = ax.bar(ind + 2*width, wkt_means_gh[0,:], width, color='b', yerr=wkt_stdevs_gh[0,:])\n",
    "\n",
    "# add some text for labels, title and axes ticks\n",
    "ax.set_xlabel('p, Proportion of Vertices in each Partial Ranking')\n",
    "ax.set_ylabel('Weighted Kendall Tau Distance')\n",
    "ax.set_title('Hypergraph vs Dwork Performance in Rank Aggregation')\n",
    "ax.set_xticks(ind + width / 2)\n",
    "ax.set_xticklabels(('0.03', '0.05', '0.07'))\n",
    "ax.set_ylim(bottom=0.3,top=0.95)\n",
    "\n",
    "ax.legend((rects1[0], rects2[0], rects3[0]), ('Hypergraph', 'Dwork', 'Clique Graph'), prop=dict(size=7), loc='best')\n",
    "plt.savefig('hg_dwork_clique_sigma_1.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}