Spaces:
Runtime error
Runtime error
File size: 15,878 Bytes
d2a8669 |
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 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 |
from aif360.explainers import Explainer
from aif360.metrics import Metric
class MetricTextExplainer(Explainer):
"""Class for explaining metric values with text.
These briefly explain what a metric is and/or how it is calculated unless it
is obvious (e.g. accuracy) and print the value.
This class contains text explanations for all metric values regardless of
which subclass they appear in. This will raise an error if the metric does
not apply (e.g. calling `true_positive_rate` if
`type(metric) == DatasetMetric`).
"""
def __init__(self, metric):
"""Initialize a `MetricExplainer` object.
Args:
metric (Metric): The metric to be explained.
"""
if isinstance(metric, Metric):
self.metric = metric
else:
raise TypeError("metric must be a Metric.")
def accuracy(self, privileged=None):
if privileged is None:
return "Classification accuracy (ACC): {}".format(
self.metric.accuracy(privileged=privileged))
return "Classification accuracy on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.accuracy(privileged=privileged))
def average_abs_odds_difference(self):
return ("Average absolute odds difference (average of abs(TPR "
"difference) and abs(FPR difference)): {}".format(
self.metric.average_abs_odds_difference()))
def average_odds_difference(self):
return ("Average odds difference (average of TPR difference and FPR "
"difference, 0 = equality of odds): {}".format(
self.metric.average_odds_difference()))
def between_all_groups_coefficient_of_variation(self):
return "Between-group coefficient of variation: {}".format(
self.metric.between_all_groups_coefficient_of_variation())
def between_all_groups_generalized_entropy_index(self, alpha=2):
return "Between-group generalized entropy index: {}".format(
self.metric.between_all_groups_generalized_entropy_index(alpha=alpha))
def between_all_groups_theil_index(self):
return "Between-group Theil index: {}".format(
self.metric.between_all_groups_theil_index())
def between_group_coefficient_of_variation(self):
return "Between-group coefficient of variation: {}".format(
self.metric.between_group_coefficient_of_variation())
def between_group_generalized_entropy_index(self, alpha=2):
return "Between-group generalized entropy index: {}".format(
self.metric.between_group_generalized_entropy_index(alpha=alpha))
def between_group_theil_index(self):
return "Between-group Theil index: {}".format(
self.metric.between_group_theil_index())
def coefficient_of_variation(self):
return "Coefficient of variation: {}".format(
self.metric.coefficient_of_variation())
def consistency(self, n_neighbors=5):
return "Consistency (Zemel, et al. 2013): {}".format(
self.metric.consistency(n_neighbors=n_neighbors))
def disparate_impact(self):
return ("Disparate impact (probability of favorable outcome for "
"unprivileged instances / probability of favorable outcome for "
"privileged instances): {}".format(
self.metric.disparate_impact()))
def error_rate(self, privileged=None):
if privileged is None:
return "Error rate (ERR = 1 - ACC): {}".format(
self.metric.error_rate(privileged=privileged))
return "Error rate on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.error_rate(privileged))
def error_rate_difference(self):
return ("Error rate difference (error rate on unprivileged instances - "
"error rate on privileged instances): {}".format(
self.metric.error_rate_difference()))
def error_rate_ratio(self):
return ("Error rate ratio (error rate on unprivileged instances / "
"error rate on privileged instances): {}".format(
self.metric.error_rate_ratio()))
def false_discovery_rate(self, privileged=None):
if privileged is None:
return "False discovery rate (FDR = FP / (FP + TP)): {}".format(
self.metric.false_discovery_rate(privileged=privileged))
return "False discovery rate on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.false_discovery_rate(privileged=privileged))
def false_discovery_rate_difference(self):
return ("False discovery rate difference (false discovery rate on "
"unprivileged instances - false discovery rate on privileged "
"instances): {}".format(
self.metric.false_discovery_rate_difference()))
def false_discovery_rate_ratio(self):
return ("False discovery rate ratio (false discovery rate on "
"unprivileged instances - false discovery rate on privileged "
"instances): {}".format(
self.metric.false_discovery_rate_ratio()))
def false_negative_rate(self, privileged=None):
if privileged is None:
return "False negative rate (FNR = FN / (TP + FN)): {}".format(
self.metric.false_negative_rate(privileged=privileged))
return "False negative rate on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.false_negative_rate(privileged=privileged))
def false_negative_rate_difference(self):
return ("False negative rate difference (false negative rate on "
"unprivileged instances - false negative rate on privileged "
"instances): {}".format(
self.metric.false_negative_rate_difference()))
def false_negative_rate_ratio(self):
return ("False negative rate ratio (false negative rate on "
"unprivileged instances / false negative rate on privileged "
"instances): {}".format(
self.metric.false_negative_rate_ratio()))
def false_omission_rate(self, privileged=None):
if privileged is None:
return "False omission rate (FOR = FN / (FN + TN)): {}".format(
self.metric.false_omission_rate(privileged=privileged))
return "False omission rate on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.false_omission_rate(privileged=privileged))
def falses_omission_rate_difference(self):
return ("False omission rate difference (falses omission rate on "
"unprivileged instances - falses omission rate on privileged "
"instances): {}".format(
self.metric.falses_omission_rate_difference()))
def false_omission_rate_ratio(self):
return ("False omission rate ratio (false omission rate on "
"unprivileged instances - false omission rate on privileged "
"instances): {}".format(
self.metric.false_omission_rate_ratio()))
def false_positive_rate(self, privileged=None):
if privileged is None:
return "False positive rate (FPR = FP / (FP + TN)): {}".format(
self.metric.false_positive_rate(privileged=privileged))
return "False positive rate on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.false_positive_rate(privileged=privileged))
def false_positive_rate_difference(self):
return ("False positive rate difference (false positive rate on "
"unprivileged instances - false positive rate on privileged "
"instances): {}".format(
self.metric.false_positive_rate_difference()))
def false_positive_rate_ratio(self):
return ("False positive rate ratio (false positive rate on "
"unprivileged instances / false positive rate on privileged "
"instances): {}".format(
self.metric.false_positive_rate_ratio()))
def generalized_entropy_index(self, alpha=2):
return "Generalized entropy index (GE(alpha)): {}".format(
self.metric.generalized_entropy_index(alpha=alpha))
def mean_difference(self):
return ("Mean difference (mean label value on unprivileged instances - "
"mean label value on privileged instances): {}".format(
self.metric.mean_difference()))
def negative_predictive_value(self, privileged=None):
if privileged is None:
return "Negative predictive value (NPV = TN / (TN + FN)): {}".format(
self.metric.negative_predictive_value(privileged=privileged))
return "Negative predictive value on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.negative_predictive_value(privileged=privileged))
def num_false_negatives(self, privileged=None):
if privileged is None:
return "Number of false negative instances (FN): {}".format(
self.metric.num_false_negatives(privileged=privileged))
return "Number of {} false negative instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.num_false_negatives(privileged=privileged))
def num_false_positives(self, privileged=None):
if privileged is None:
return "Number of false positive instances (FP): {}".format(
self.metric.num_false_positives(privileged=privileged))
return "Number of {} false positive instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.num_false_positives(privileged=privileged))
def num_instances(self, privileged=None):
if privileged is None:
return "Number of instances: {}".format(
self.metric.num_instances(privileged=privileged))
return "Number of {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.num_instances(privileged=privileged))
def num_negatives(self, privileged=None):
if privileged is None:
return "Number of negative-outcome instances: {}".format(
self.metric.num_negatives(privileged=privileged))
return "Number of {} negative-outcome instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.num_negatives(privileged=privileged))
def num_positives(self, privileged=None):
if privileged is None:
return "Number of positive-outcome instances: {}".format(
self.metric.num_positives(privileged=privileged))
return "Number of {} positive-outcome instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.num_positives(privileged=privileged))
def num_pred_negatives(self, privileged=None):
if privileged is None:
return "Number of negative-outcome instances predicted: {}".format(
self.metric.num_pred_negatives(privileged=privileged))
return "Number of {} negative-outcome instances predicted: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.num_pred_negatives(privileged=privileged))
def num_pred_positives(self, privileged=None):
if privileged is None:
return "Number of positive-outcome instances predicted: {}".format(
self.metric.num_pred_positives(privileged=privileged))
return "Number of {} positive-outcome instances predicted: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.num_pred_positives(privileged=privileged))
def num_true_negatives(self, privileged=None):
if privileged is None:
return "Number of true negative instances (TN): {}".format(
self.metric.num_true_negatives(privileged=privileged))
return "Number of {} true negative instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.num_true_negatives(privileged=privileged))
def num_true_positives(self, privileged=None):
if privileged is None:
return "Number of true positive instances (TP): {}".format(
self.metric.num_true_positives(privileged=privileged))
return "Number of {} true positive instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.num_true_positives(privileged=privileged))
def positive_predictive_value(self, privileged=None):
if privileged is None:
return "Positive predictive value (PPV, precision = TP / (TP + FP)): {}".format(
self.metric.positive_predictive_value(privileged=privileged))
return "Positive predictive value on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.positive_predictive_value(privileged=privileged))
def statistical_parity_difference(self):
return ("Statistical parity difference (probability of favorable "
"outcome for unprivileged instances - probability of favorable "
"outcome for privileged instances): {}".format(
self.metric.statistical_parity_difference()))
def theil_index(self):
return "Theil index (generalized entropy index with alpha = 1): {}".format(
self.metric.theil_index())
def true_negative_rate(self, privileged=None):
if privileged is None:
return "True negative rate (TNR, specificity = TN / (FP + TN)): {}".format(
self.metric.true_negative_rate(privileged=privileged))
return "True negative rate on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.true_negative_rate(privileged=privileged))
def true_positive_rate(self, privileged=None):
if privileged is None:
return "True positive rate (TPR, recall, sensitivity = TP / (TP + FN)): {}".format(
self.metric.true_positive_rate(privileged=privileged))
return "True positive rate on {} instances: {}".format(
'privileged' if privileged else 'unprivileged',
self.metric.true_positive_rate(privileged=privileged))
def true_positive_rate_difference(self):
return ("True positive rate difference (true positive rate on "
"unprivileged instances - true positive rate on privileged "
"instances): {}".format(
self.metric.true_positive_rate_difference()))
# ============================== ALIASES ===================================
def equal_opportunity_difference(self):
return self.true_positive_rate_difference()
def power(self, privileged=None):
return self.num_true_positives(privileged=privileged)
def precision(self, privileged=None):
return self.positive_predictive_value(privileged=privileged)
def recall(self, privileged=None):
return self.true_positive_rate(privileged=privileged)
def sensitivity(self, privileged=None):
return self.true_positive_rate(privileged=privileged)
def specificity(self, privileged=None):
return self.true_negative_rate(privileged=privileged)
|