-
Notifications
You must be signed in to change notification settings - Fork 10
/
Aequitas_Fully_Directed_Sklearn.py
222 lines (161 loc) · 6.98 KB
/
Aequitas_Fully_Directed_Sklearn.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
from __future__ import division
from random import seed, shuffle
import random
import math
import os
from collections import defaultdict
from sklearn import svm
import os,sys
import urllib2
sys.path.insert(0, './fair_classification/') # the code for fair classification is in this directory
import numpy as np
import loss_funcs as lf # loss funcs that can be optimized subject to various constraints
import random
import time
from scipy.optimize import basinhopping
import config
from sklearn.externals import joblib
random.seed(time.time())
start_time = time.time()
init_prob = 0.5
params = config.params
direction_probability = [init_prob] * params
direction_probability_change_size = 0.001
param_probability = [1.0/params] * params
param_probability_change_size = 0.001
sensitive_param = config.sensitive_param
name = 'sex'
cov = 0
perturbation_unit = config.perturbation_unit
threshold = config.threshold
global_disc_inputs = set()
global_disc_inputs_list = []
local_disc_inputs = set()
local_disc_inputs_list = []
tot_inputs = set()
global_iteration_limit = 2000
local_iteration_limit = 1000
input_bounds = config.input_bounds
classifier_name = config.classifier_name
model = joblib.load(classifier_name)
def normalise_probability():
probability_sum = 0.0
for prob in param_probability:
probability_sum = probability_sum + prob
for i in range(params):
param_probability[i] = float(param_probability[i])/float(probability_sum)
class Local_Perturbation(object):
def __init__(self, stepsize=1):
self.stepsize = stepsize
def __call__(self, x):
s = self.stepsize
param_choice = np.random.choice(xrange(params) , p=param_probability)
act = [-1, 1]
direction_choice = np.random.choice(act, p=[direction_probability[param_choice], (1 - direction_probability[param_choice])])
if (x[param_choice] == input_bounds[param_choice][0]) or (x[param_choice] == input_bounds[param_choice][1]):
direction_choice = np.random.choice(act)
x[param_choice] = x[param_choice] + (direction_choice * perturbation_unit)
x[param_choice] = max(input_bounds[param_choice][0], x[param_choice])
x[param_choice] = min(input_bounds[param_choice][1], x[param_choice])
ei = evaluate_input(x)
if (ei and direction_choice == -1) or (not ei and direction_choice == 1):
direction_probability[param_choice] = min(
direction_probability[param_choice] + (direction_probability_change_size * perturbation_unit), 1)
elif (not ei and direction_choice == -1) or (ei and direction_choice == 1):
direction_probability[param_choice] = max(
direction_probability[param_choice] - (direction_probability_change_size * perturbation_unit), 0)
if ei:
param_probability[param_choice] = param_probability[param_choice] + param_probability_change_size
normalise_probability()
else:
param_probability[param_choice] = max(param_probability[param_choice] - param_probability_change_size, 0)
normalise_probability()
return x
class Global_Discovery(object):
def __init__(self, stepsize=1):
self.stepsize = stepsize
def __call__(self, x):
s = self.stepsize
for i in xrange(params):
random.seed(time.time())
x[i] = random.randint(input_bounds[i][0], input_bounds[i][1])
x[sensitive_param - 1] = 0
# print x
return x
def evaluate_input(inp):
inp0 = [int(i) for i in inp]
inp1 = [int(i) for i in inp]
inp0[sensitive_param - 1] = 0
inp1[sensitive_param - 1] = 1
inp0 = np.asarray(inp0)
inp0 = np.reshape(inp0, (1, -1))
inp1 = np.asarray(inp1)
inp1 = np.reshape(inp1, (1, -1))
out0 = model.predict(inp0)
out1 = model.predict(inp1)
# return (abs(out0 - out1) > threshold)
# for binary classification, we have found that the
# following optimization function gives better results
return abs(out1 + out0)
def evaluate_global(inp):
inp0 = [int(i) for i in inp]
inp1 = [int(i) for i in inp]
inp0[sensitive_param - 1] = 0
inp1[sensitive_param - 1] = 1
inp0 = np.asarray(inp0)
inp0 = np.reshape(inp0, (1, -1))
inp1 = np.asarray(inp1)
inp1 = np.reshape(inp1, (1, -1))
out0 = model.predict(inp0)
out1 = model.predict(inp1)
tot_inputs.add(tuple(map(tuple, inp0)))
if (abs(out0 - out1) > threshold and tuple(map(tuple, inp0)) not in global_disc_inputs):
global_disc_inputs.add(tuple(map(tuple, inp0)))
global_disc_inputs_list.append(inp0.tolist()[0])
# return not abs(out0 - out1) > threshold
# for binary classification, we have found that the
# following optimization function gives better results
return abs(out1 + out0)
def evaluate_local(inp):
inp0 = [int(i) for i in inp]
inp1 = [int(i) for i in inp]
inp0[sensitive_param - 1] = 0
inp1[sensitive_param - 1] = 1
inp0 = np.asarray(inp0)
inp0 = np.reshape(inp0, (1, -1))
inp1 = np.asarray(inp1)
inp1 = np.reshape(inp1, (1, -1))
out0 = model.predict(inp0)
out1 = model.predict(inp1)
tot_inputs.add(tuple(map(tuple, inp0)))
if (abs(out0 - out1) > threshold and (tuple(map(tuple, inp0)) not in global_disc_inputs)
and (tuple(map(tuple, inp0)) not in local_disc_inputs)):
local_disc_inputs.add(tuple(map(tuple, inp0)))
local_disc_inputs_list.append(inp0.tolist()[0])
# return not abs(out0 - out1) > threshold
# for binary classification, we have found that the
# following optimization function gives better results
return abs(out1 + out0)
initial_input = [7, 4, 26, 1, 4, 4, 0, 0, 0, 1, 5, 73, 1]
minimizer = {"method": "L-BFGS-B"}
global_discovery = Global_Discovery()
local_perturbation = Local_Perturbation()
basinhopping(evaluate_global, initial_input, stepsize=1.0, take_step=global_discovery, minimizer_kwargs=minimizer,
niter=global_iteration_limit)
print "Finished Global Search"
print "Percentage discriminatory inputs - " + str(float(len(global_disc_inputs_list)
+ len(local_disc_inputs_list)) / float(len(tot_inputs))*100)
print ""
print "Starting Local Search"
for inp in global_disc_inputs_list:
basinhopping(evaluate_local, inp, stepsize=1.0, take_step=local_perturbation, minimizer_kwargs=minimizer,
niter=local_iteration_limit)
print "Percentage discriminatory inputs - " + str(float(len(global_disc_inputs_list) + len(local_disc_inputs_list))
/ float(len(tot_inputs))*100)
print ""
print "Local Search Finished"
print "Percentage discriminatory inputs - " + str(float(len(global_disc_inputs_list) + len(local_disc_inputs_list))
/ float(len(tot_inputs))*100)
print ""
print "Total Inputs are " + str(len(tot_inputs))
print "Number of discriminatory inputs are " + str(len(global_disc_inputs_list)+len(local_disc_inputs_list))