A bias detection tree approach for detecting disparities in a recommendation model’s errors

Abstract

Many of the current recommendation systems are considered to be blackboxes that are tuned to optimize some global objective function. However, their error distribution may differ dramatically among different combinations of attributes, and such algorithms may lead to propagating hidden data biases. Identifying potential disparities in an algorithm’s functioning is essential for building recommendation systems in a fair and responsible way. In this work, we propose a model-agnostic technique to automatically detect the combinations of user and item attributes correlated with unequal treatment by the recommendation model. We refer to this technique as the Bias Detection Tree. In contrast to the existing works in this field, our method automatically detects disparities related to combinations of attributes without any a priori knowledge about protected attributes, assuming that relevant metadata is available. Our results on five public recommendation datasets show that the proposed technique can identify hidden biases in terms of four kinds of metrics for multiple collaborative filtering models. Moreover, we adapt a minimax model selection technique to control the trade-off between the global and the worst-case optimizations and improve the recommendation model’s performance for biased attributes.

Appendix A: Computational complexity

In this section, we perform an analysis of the computational complexity of the proposed algorithm, and the execution time is measured for experimental data.

1.1 Appendix A.1: Theoretical analysis

In the complexity analysis, let L denote the number of attributes, N is the number of ratings and D is the maximum depth of the tree ($1 \le D \le L$). Next, let $n_k$ be the number of subsets of $T_k$ with significant difference in the error metric distribution ($p<\alpha _{{\textit{merge}}}$). Without loss of generality, let us assume that the number of attribute values $|T_k|$ and $n_k$ is equal for all attributes k:

$$\begin{aligned} |T_{k_1}|=|T_{k_2}|=\cdots =|T_{k_L}|=K, n_{k_1}=n_{k_2}= \cdots = n_{k_L}=n_k \end{aligned}$$

(23)

Then $K-n_k$ is the number of iterations in the merge phase for an attribute k. Since the complexity of the split-phase is linear O(L), we only consider the complexity of the merge phase in the analysis. Assuming that the complexity of operations in each node is equal (Eq. 23), the overall complexity of BDT algorithm can be calculated as:

$$\begin{aligned} A(L,K) = \sum _{p \in P}F(p)=|P|F(p) \end{aligned}$$

(24)

where F(p) denotes the complexity of the merge phase for a non-leaf tree node where the split of this node is performed based on attribute $x_k$ with values $T_k=\{k_1, \ldots k_K\}$ and P denotes the set of all parent nodes in the tree.

In each iteration of the merge phase, the significance test is calculated for all pairs of attribute values from $T_k$ for each k. Next, one pair $k_m, k_n$ with the least significant difference (if $p>\alpha _{{\textit{merge}}}$) will be merged. Hence, the algorithm will make K comparisons of single values in the first step ($i=1$) and the pair $k_{m,n}$ will be merged such that the number of values that will be processed in $i=2$ is $|T_k^1|=|T_k|-1=K-1$. Consequently, $K_i=K-(i-1)$ values will be compared in the i-th iteration, until no further merges can be performed ($p<\alpha _{{\textit{merge}}}$ for all combinations). The difference in error distribution is tested for each pair of attribute values, resulting in $K_i^2$ operations in each iteration. Accordingly, the complexity of the merge stage for one attribute in a node is given by:

$$\begin{aligned} \sum _{i=1}^{K-n_{k}}(K-(i-1))^2 \end{aligned}$$

(25)

The number of nodes on tree level $d, 1\le d \le D$ is equal to $n_k^{d-1}$ and the number of non-leaf nodes in the tree of depth D can be calculated as:

$$\begin{aligned} |P|= \sum ^{D}_{d=1}n_k^{d-1} = n_k^0+n_k^1+\cdots n_k^{D-1} \end{aligned}$$

(26)

For a simple mean-based significance test, the comparison of the error metric $\sigma _k^2$ between two attribute values $k_i, k_j \in T_k$ requires N operations, where N is the number of samples.

Since the number of attributes available for a node on level d is $L-d+1$, the number of operations for the merge stage in one node on level d is given by (From Formula 25):

$$\begin{aligned} F(p)=N(L-d+1)\sum _{i=1}^{K-n_{k}}(K-(i-1))^2 \end{aligned}$$

(27)

Hence, the overall general complexity can be bounded by (based on Formulas 27, 26):

$$\begin{aligned} A(L,K)=\sum ^{D}_{d=1}n_k^{d-1} F(p)=O(n_k^{D-2}LK^3N) \end{aligned}$$

(28)

To be more precise, let us consider the computational complexity of the BDT method in the following most extreme cases:

• 1. Optimistic case

  In the optimistic case, there are no significant differences in the error metric distribution among the parameter values for any attribute (as in the first simulated example):

  $$\begin{aligned} \forall _{k \in 1 \ldots L, k_i, k_j \in T_k}: p_{k_i, k_j}>\alpha _{{\textit{merge}}}, n_k=1 \end{aligned}$$

  In this case, in the merge phase, the values $k_i$ will be merged successively until all values are merged into one set $T^*_k=\{k_1, \ldots k_K\}$. Since there are no significant differences between the attribute values, no further splits will be made and the algorithm stops after the merge phase ($D=1)$ and the overall complexity will be (Eq. 27):

  $$\begin{aligned} A(L,K)=LN\sum _{i=1}^{K-1}(K-(i-1))^2=O(LNK^3) \end{aligned}$$

  (29)

• 2. Pessimistic case

  In the worst case, all pairs of parameter values have significant differences in error metric distribution:

  $$\begin{aligned} \forall _{k \in 1 \ldots L, k_i, k_j \in T_k}: p_{k_i, k_j}<\alpha _{{\textit{merge}}} \end{aligned}$$

  In this case, there is only one iteration in the merge phase ($n_k=K$) as no values are merged together but the depth of the tree is equal to the number of attributes ($D=L$). Then, the complexity of merge phase of one node is (Eq. 27):

  $$\begin{aligned} F(P)=N(L-d+1)K^2 \end{aligned}$$

  (30)

  And the overall complexity can be restricted by:

  $$\begin{aligned} A(L,K)&=N\sum ^{L}_{d=1}K^{d-1}(L-d+1)K^2\nonumber \\&=N\sum ^{L}_{d=1}K^{d+1}(L-d+1)=O(NLK^{L+2}) \end{aligned}$$

  (31)

1.2 Appendix A.2: Experimental computation time

To verify the practical complexity of the proposed algorithm, we performed an experiment on synthetic data generated in an analogous way as in Sect. 4.3; however, instead of a pre-defined set of attributes, we compared the result for varying parameters of the data characteristics (with $\alpha =0.01$):

• N—the number of examples varies between 100 and 100.000 (default 10.000),

• L—the number of attributes between 1 and 50 (default 5),

• K—the number of categories per attribute between 2 and 20 (default 4),

• $n_k$—ratio of categories with a different error metric distribution 0–1 (default 0.5),

• D—maximum depth of the tree (3 or 20).

The computation times were calculated for a single machine (CPU Intel Core i5-4210U, 1.7 GHz), and the results were averaged over ten iterations.

Fig. 9

Execution time of the BDT algorithm depending on different parameters: a Number of examples; b Number of attributes; c Number of categories in each attribute; d Ratio of categories with a significant difference in the error metric distribution. For each case, we compared the time for a maximum depth limited to 3 and 20 levels

Results The results for each parameter are presented in Fig. 9 for maximum depth limited to 3 and 20 levels. The correlation between the computation time and the number of examples is linear and does not depend on D (Fig. 9a) This shows that our proposed method scales well in terms of dataset size. Figure 9b shows that the relationship between the time and the number of attributes L for the two tree depths (D) we investigated does not differ significantly for small L; but, the difference starts increasing for $L>20$. This observation indicates that restricting the depth of the tree may be important, especially when the number of attributes is large. A similar observation holds for the number of attribute categories K (Fig. 9c) and the ratio of categories with a significant difference in the error metric distribution (Fig. 9d). Moreover, as shown in Fig. 9d, the computation time is the lowest in the optimistic case when no categories have a significantly different error metric distribution. Importantly, it is worth noticing that the complexity is reduced significantly after limiting the maximum depth of the tree. Since for practical usage in detecting disparities, a large complexity may lead to difficulties in interpreting the model results, this parameter should be limited for the sake of optimization.

1.3 Appendix A.3: Limiting computation time

In practice, the number of splits for each node is usually significantly lower than K unless there are significant differences between the error metric distribution in all nodes. However, since the pessimistic computational complexity can be large, some steps can be undertaken to limit the complexity of the algorithm for practical applications:

• Limiting L—to reduce the number of attributes, standard feature extraction techniques may be applied to remove the correlations and group attributes into fewer categories. For instance, the movie tags could be grouped into several categories with a topic modeling technique. Additional optimization steps may include subsampling techniques and training multiple trees on subsets of the features or examples.

• Limiting K—may be achieved, for instance, by bucketizing the numerical attributes (such as the user’s age or movie production year), removing the outliers, or filtering the less frequent values.

• Limiting D—to reduce the complexity and avoid selecting too specific rules that would be hard to interpret, the tree can be regularized by limiting the maximum depth. Then, parameter D will be constant.

• Limiting $n_k$—the number of splits in each node can be controlled by the attributes $\alpha$ that define the statistical significance threshold for the merge or split stages or by setting the minimum number of samples in a node.