Dany gituser768

Fair Ranking Extentions

Two sided marketplace extension
- Recommendation system with fairness to suppliers with inverse-popularity score (like in our presentation)
Feldman or Celis et al. methods of enforcing fairness constraints
- Show that problem is exponential in number of protected attributes
- Use approximation by being fair for each attribute and then performing rank aggregation

Cant have a ranking that has all the following properties (Arrow 1950):
- Non-dictatorship

	import numpy as np
	import numpy.linalg as la
	import pandas as pd
	import numpy.random as rn
	import matplotlib.pyplot as plt
	import matplotlib

	def calc_coverage(var, est, val):
	ci_l = est - 1.96 * np.sqrt(var)
	ci_r = est + 1.96 * np.sqrt(var)

	def calc_ndcg(a, b, num_rel):
	ranking_len = len(a)
	len_diff = int(num_rel - a.sum())
	a = np.r_[a, np.ones(len_diff)]
	b = np.r_[b, (b.min() - 1) * np.ones(len_diff)]
	if (a.mean() < 1) and (a.mean() > 0): return ndcg_score([a], [b], k=ranking_len)
	else: return np.nan

	def calc_auc(a, b, num_rel, population_size):
	assert a.sum() <= num_rel

	import numpy as np
	from sklearn.metrics import roc_auc_score

	y_true = np.r_[np.ones(10000), np.zeros(10000)]
	alpha = 0.5
	beta = 0.2
	y_known = np.r_[(np.random.rand(10000) < alpha).astype(np.float),
	(np.random.rand(10000) < beta).astype(np.float)]
	# rankings = [np.random.permutation(2000) for i in range(100)]
	rankings = [-np.arange(20000) + 100 np.random.randn(20000) i for i in range(100)]

	from collections import defaultdict

	import numpy as np
	import numpy.linalg as la
	import pandas as pd
	import numpy.random as rn
	import matplotlib.pyplot as plt


	def hmean(a, b):

	# in ~/.ipython/profile_default/startup/startup.py
	import pandas as pd
	import numpy as np
	import matplotlib.pyplot as plt
	from itertools import *
	from collections import *
	from operator import itemgetter

	# in ~/.ipython/profile_default/python_config.py
	c = get_config()

	def locs_available_here(d, h, cur):
	if cur[0] < d - 1: yield (cur[0] + 1, cur[1])
	if cur[1] < h - 1: yield (cur[0], cur[1] + 1)

	def new_paths(d, h, path_so_far, to_loc):
	end_loc = (d - 1, h - 1)
	if to_loc == end_loc:
	yield path_so_far + [end_loc]
	else:
	for new_loc in locs_available_here(d, h, to_loc):