Title: Fair, Polylog-Approximate Low-Cost Hierarchical Clustering
Venue: NeurIPS 2023
Accepted: yes
Keywords: Fair machine learning

hierarchical clustering

clustering
Abstract: Research in fair machine learning, and particularly clustering, has been crucial in recent years given the many ethical controversies that modern intelligent systems have posed. Ahmadian et al. [2020] established the study of fairness in hierarchical clustering, a stronger, more structured variant of its well-known flat counterpart, though their proposed algorithm that optimizes for Dasgupta's [2016] famous cost function was highly theoretical. Knittel et al. [2023] then proposed the first practical fair approximation for cost, however they were unable to break the polynomial-approximate barrier they posed as a hurdle of interest. We break this barrier, proposing the first truly polylogarithmic-approximate low-cost fair hierarchical clustering, thus greatly bridging the gap between the best fair and vanilla hierarchical clustering approximations.

Fair, Polylog-Approximate Low-Cost Hierarchical Clustering

Abstract

Research in fair machine learning, and particularly clustering, has been crucial in recent years given the many ethical controversies that modern intelligent systems have posed. Ahmadian et al. [2020] established the study of fairness in hierarchical clustering, a stronger, more structured variant of its well-known flat counterpart, though their proposed algorithm that optimizes for Dasgupta's [2016] famous cost function was highly theoretical. Knittel et al. [2023] then proposed the first practical fair approximation for cost, however they were unable to break the polynomial-approximate barrier they posed as a hurdle of interest. We break this barrier, proposing the first truly polylogarithmic-approximate low-cost fair hierarchical clustering, thus greatly bridging the gap between the best fair and vanilla hierarchical clustering approximations.

1 Introduction

Clustering is a pervasive machine learning technique which has filled a vital niche in every day computer systems. Extending upon this, a hierarchical clustering is a recursively defined clustering where each cluster is partitioned into two or more clusters, and so on. This adds structure to flat clustering, giving an algorithm the ability to depict data similarity at different resolutions as well as an ancestral relationship between data points, as in the phylogenetic tree Kraskov et al. [2003].

On top of computational biology, hierarchical clustering has found various uses across computer imaging [Chen et al., 2021b, Selvan et al., 2005], computer security [Chen et al., 2020, 2021a], natural language processing [Ramanath et al., 2013], and much more. Moreover, it can be applied to any flat clustering problem where the number of desired clusters is not given. Specifically, a hierarchical clustering can be viewed as a structure of clusterings at different resolutions that all agree with each other (i.e., two points clustered together in a higher resolution clustering will also be together in a lower resolution clustering). Generally, hierarchical clustering techniques are quite impactful on modern technology, and it is important to guarantee they are both effective and unharmful.

Researchers have recognized the harmful biases unchecked machine learning programs pose. A few examples depicting racial discrimination include allocation of health care [Ledford, 2019], presentation of ads suggestive of arrest records [Sweeney, 2013], prediction of hiring success [Bogen and Rieke, 2018], and estimation of recidivism risk [Angwin et al., 2016]. A popular solution that has been extensively studied in the past decade is fair machine learning . Here, fairness concerns the mitigation of bias, particularly against protected classes. Most often, fairness is an additional constraint on the allowed solution space; we optimize for problems in light of this constraint. For instance, the notion of individual fairness introduced by the foundational work of Dwork et al. [2012] deems that an output must guarantee that any two individuals who are similar are classified similarly.

News

Query:

News

Query:

Articles

Global

Articles

00

Global

Warming

Warming

Immigration

Student

Health

Global

Immigration

Student

Health

Global

Debt/

Care/

warming/

Article 1

Debt/

Care

Warming

Article 1

Article 2

Article 2

Article3

Article3

o0

Debt

Ainsurance

Reducing

Air

Debt

Insurance

Reducing

Air

Relief

Rates

HC Costs

Pollution

Relief

Rates

HC Costs

Pollution

In line with previous work in clustering and hierarchical clustering, this paper utilizes the notion of group fairness , which enforces that different protected classes receive a proportionally similar distribution of classifications (in our case, cluster placement). Chierichetti et al. [2017] first introduced this as a constraint for the flat clustering problem, arguing that it mitigates a system's disparate impact, or non-proportional impact on different demographics. This notion of fair clustering has been similarly leveraged and extended by a vast range of works in both flat [Ahmadian et al., 2019, Bera et al., 2019, Bercea et al., 2019] and hierarchical [Ahmadian et al., 2020, Knittel et al., 2023] clustering.

To illustrate our fairness concept, consider the following application (Figure 1): a news database is structured as a hierarchical clustering of search terms, where a search term is associated with a cluster of news articles to output to the reader, and more specific search terms access finer-resolution clusters. When a user searches for a term, we simply identify the corresponding cluster and output the contained articles. However, as is, the system does not account for the political skew of articles. In Figure 1, we label conservative-leaning articles in red and liberal-leaning articles in blue. We can see that in this example, when the user searches for global warming articles, they will only see liberal articles. To resolve this, we add a group fairness constraint on our cluster: for example, require at least 1/3 of the articles in each cluster to be of each political skew. This guarantees (as depicted on the right) that the outputted articles will always be at least 1/3 liberal and 1/3 conservative, thus guaranteeing the user is exposed to a range of perspectives along this political axis. This notion of fairness, which we formally define in Definition 3, has been explored in the context of hierarchical clustering in both Ahmadian et al. [2020] and Knittel et al. [2023].

This paper is concerned with approximations for fair lowcost hierarchical clustering. Cost, first defined by Dasgupta [2016] and formally stated in Definition 2, is perhaps the most natural and well-motivated optimization metric for hierarchical clustering evaluation. Effectively, every pair of points contributes an additive cost of similarity × clust _ size , where the latter is the size of the smallest cluster in the hierarchy containing both points. Unfortunately, it is quite difficult to optimize for (the best being O ( √ log n ) -approximations [Charikar and Chatziafratis, 2017, Dasgupta, 2016]; it hypothesized to not be O (1) -approximable [Charikar and Chatziafratis, 2017]). This appears to be even more difficult in the hierarchical clustering literature. The first work to attempt this problem, Ahmadian et al. [2020], achieved a highly impractical O ( n 5 / 6 log 3 / 2 n ) -approximation (not too far from the trivial O ( n ) upper bound), posing fair low-cost hierarchical clustering as an interesting and inherently difficult problem. Knittel et al. [2023] greatly improved this to a near-polylog approximation factor of O ( n δ polylog( n )) , where δ can be arbitrarily close to 0, and parameterizes a trade-off between approximation factor and degree of fairness. Still, a true polylog approximation was left as an open problem, one which we solve in this paper.

1.1 Our Contributions

This work proposes the first polylogarithmic approximation for fair, low-cost hierarchical clustering. We leverage the work of Knittel et al. [2023] as a starting inspiration and create something much simpler, more direct, and better in both fairness and approximation. Like their algorithm, our algorithm starts with a low-cost unfair hierarchical clustering and then alters it with multiple welldefined and limited tree operators. This gives it a degree of explainability, in that the user can understand exactly the steps the algorithm took to achieve its result and why. In addition, our

algorithm achieves both relative cluster balance (i.e., clusters who are children of the same cluster have similar size) and fairness, along with a parameterizeable trade-off between the two.

On top of the benefits of Knittel et al. [2023]'s techniques, we propose a greatly simplified algorithm. They initially proposed an algorithm that required four tree operators, however, we only require two of the four, and we greatly simplify the more complicated operator. This makes the algorithm simpler to understand and more implementable. We show that even with this reduced functionality, we can cleverly achieve both a better approximation and degree of fairness:

Theorem 1 (High-Level) . Given a γ -approximation to the cost objective for a hierarchical clustering on set of n points, Algorithm 2 yields an O (log 2 n ) approximation to cost which is relatively fair in time O ( n log 2 n ) . Moreover, all clusters are O (1 / log n ) balanced, i.e., any cluster's children clusters are within O (1 / log n ) size different.

To put this in perspective, previously, the best approximation for fair hierarchical clustering previously was O ( n δ polylog( n )) , whereas the best unfair approximation is O ( √ log n ) . Our work greatly reduces this gap by providing a true O (polylog( n )) approximation, moreover with a low degree of 2. Note that this is not the most general and rigorous form of our result-for that, we defer to Theorem 1 as stated in the body of our paper. This simpler version is found by setting k = O (1) , h = O (log n ) , and /epsilon1 = O (1 / log n ) in the more general theorem (note we assume λ = O (1) ).

2 Preliminaries

2.1 The Vanilla Problem

Fair clustering literature refers to the original problem variant, without fairness, as the 'vanilla' problem. We define the vanilla problem of finding a low-cost hierarchical clustering here using our specific notation.

In this problem, we are given a complete graph G = ( V, E, w ) with a weight function w : E → R + is a measure of the similarity between datapoints. Note the data is encoded as a complete tree because we require knowledge of all point-point relationships. We must construct a hierarchical clustering, represented by its dendrogram, T , with root denoted root( T ) . T is a tree with vertices corresponding to all clusters of the hierarchical clustering. Leaves of T , denoted leaves(root( T )) correspond to the points in the dataset (i.e., singleton clusters). An internal node v corresponds to the cluster containing all leaf-data of the maximal subtree (i.e., contains all its descendants) rooted at v , T [ v ] . In addition, we let u ∧ v denote the lowest common ancestor of u and v in T .

In order to define Dasgupta [2016]'s cost function, we use the same notational simplifications as Knittel et al. [2023]. For an edge e = ( x, y ) ∈ E , we say n T ( e ) = | leaves( T [ x ∧ y ]) | is the size of the smallest cluster in the hierarchy containing e . Similarly, for a hierarchy node v , n T ( v i ) = | leaves( T [ v i ]) | is the size of the corresponding cluster. This is sufficient to introduce the notion of cost .

Definition 1 (Knittel et al. [2023]) . The cost of e ∈ E in a graph G = ( V, E, w ) in a hierarchy T is cost T ( e ) = w ( e ) · n T ( e ) .

Dasgupta's cost function can then be written as a sum over the costs of all edges.

Definition 2 (Dasgupta [2016]) . The cost of a hierarchy T on graph G = ( V, E, w ) is:

Our algorithm begins by assuming we have some approximate vanilla hierarchy, T . That is, if OPT is the optimal hierarchy tree, then cost( T ) ≤ α · cost( OPT ) for some approximation factor α . According to Dasgupta [2016], we can transform this hierarchy to be binary without increasing the cost. Our paper simply assumes our input is binary. We then produce a modified hierarchy T ′ which similar structure to T that guarantees fairness, i.e., cost( T ′ ) ≤ α ′ · cost( OPT ) for some approximation factor α ′ ≥ α . Note this comparison is being made to the vanilla OPT , as we are unsure, at this time, how to classify the optimal fair hierarchy. Note that the binary assumption may not hold when we consider adding a fairness constraint.

2.2 Fairness and Balance Constraints

We consider the fairness constraints based off those introduced by Chierichetti et al. [2017] and extended by Bercea et al. [2019]. On a graph G with colored vertices, let /lscript ( C ) count the number of /lscript -colored points in cluster C .

Definition 3 (Knittel et al. [2023]) . Consider a graph G = ( V, E, w ) with vertices colored one of λ colors, and two vectors of parameters α , β ∈ (0 , 1) λ with α /lscript ≤ β /lscript for all /lscript ∈ [ λ ] . A hierarchy T on G is fair if for any non-singleton cluster C in T and for every /lscript ∈ [ λ ] , α /lscript | C | ≤ /lscript ( C ) ≤ β /lscript | C | . Additionally, any cluster with a leaf child has only leaf children.

Effectively, we are given bounds α /lscript and β /lscript for each color /lscript . Every non-singleton cluster must have at least an α /lscript fraction and at most a β /lscript fraction of color /lscript . This guarantees proportional representational fairness of each color in each cluster.

As an intermediate step in achieving fairness, we will create splits in our hierarchy that achieve relative balance in terms of subcluster size. Thus, the following definition will come in handy.

Definition 4. In a hierarchy, a vertex v (corresponding to cluster C ) with c v children is /epsilon1 -relatively balanced if for every cluster { C i } i ∈ [ c v ] that corresponds to a child of v , ( 1 c v -/epsilon1 ) | C | ≤ | C i | ≤ ( 1 c v + /epsilon1 ) | C | .

While this definition is quite similar to that from Knittel et al. [2023], it deviates in two ways: 1) we only define it on a single split as opposed to the entire hierarchy and 2) we allow splits to be non-binary. If we apply it to the entire hierarchy and constrain it to be binary, it is equivalent to the former definition.

2.3 Tree Operators

Our work simplifies the work of Knittel et al. [2023]. In doing so, we follow the same framework, using tree operators to make well-defined and limited alterations to a given hierarchical clustering (Figure 2). In addition, our algorithm simplifies operator use in two ways: 1) we only utilize two of their four tree operators, and 2) we greatly simplified their most complicated operator and show that it can still be used to create a fair hierarchy.

Definition 5 (Knittel et al. [2023]) . Consider a binary tree T with internal nodes u , some nonancestor v , u 's sibling s , and v 's parent g . Subtree deletion at u removes T [ u ] from T and contracts s into its parent. Subtree insertion of T [ u ] at v inserts a new parent p between v and g and adds u as a second child of p . The operator del _ ins( u, v ) deletes u and inserts T [ u ] at v .

The other operator we leverage is their tree folding operator, however we greatly simplify it. In the previous work, tree folding took two or more isomorphic trees and mapped the internal nodes to each other. Instead, we simply take two or more subtrees and merge their roots. The new root then directly splits into all children of the roots of all folded trees. In a way, this is an implementation of their folding operator but only at a single vertex in the tree topology. This is why we call it a shallow tree fold.

Definition 6. Consider a set of subtrees T 1 , . . . , T k of T such that all root( T i ) have the same parent p in T . A shallow tree folding of trees T 1 , . . . , T k ( shallow _ fold( T 1 , . . . , T k ) ) modifies T such that all T 1 , . . . , T k are replaced by a single tree T f whose root root( T f ) is made a child of p , and whose root-children are ∪ i ∈ [ k ] children(root( T i )) .

In addition, we assume the subtree T f is then arbitrarily binarized [Dasgupta, 2016] after folding. Since our algorithm works top-bottom, creating balanced vertices as it goes, we don't yet care about the fairness of the descendants of T f . Moreover, we will then recursively call our algorithm on T f to do precisely this.

3 Main Algorithm

In this section, we present our fair, low-cost, hierarchical clustering algorithm along with its analysis. Ultimately, we achieve the following (for a more intuitive explanation, see Section 1):

Theorem 1. When T is a γ -approximate low-cost vanilla hierarchical clustering over /lscript ( V ) = c /lscript n = O ( n ) vertices of each color /lscript ∈ [ λ ] , MakeFair (Algorithm 2), for any constants /epsilon1 , h, k with h /greatermuch k λ and n /greatermuch h , runs in O ( n log n ( h + λ log n )) time and yields a hierarchy T ′ satisfying:

All internal nodes in T ′ are /epsilon1 -relatively balanced.

The main idea of our algorithm is to leverage similar tree operators to that of Knittel et al. [2023], but greatly simplify their usage and apply them in a more direct, careful manner. Specifically, the previous work processes the tree four times: once to achieve 1 / 6 -relative balance everywhere, next to achieve /epsilon1 -relative balance, next to remove the bottom of the hierarchy, and finally to achieve fairness. The problem is that this causes proportional cost increases to grow in an exponential manner, particularly because the relative balance significantly degrades as you descend the hierarchy. Our solution is to instead do a single top to bottom pass of the tree, rebalancing and folding to achieve fairness as we go. We describe this in detail now.

First, we assume our input is some given hierarchical clustering tree. Ideally, this will be a good approximation for the vanilla problem, but our results do work as a black box on top of any hierarchical clustering algorithm. Second, we apply SplitRoot in order to balance the root (Section 3.1). And finally, we apply shallow tree folding on the children of the root to achieve fairness (Section 3.2). This gives us the first layer of our output, and then we recurse.

3.1 Root Splitting and Balancing

SplitRoot is depicted in Algorithm 1. This fills the role of Knittel et al. [2023]'s Refine Rebalance Tree algorithm (and skips their Rebalance Tree algorithm), but it functions differently in that it only rebalances the root and it immediately splits the root into h children, according to our input parameter h .

We start SplitRoot by adding dummy children to v until it has h children (recall we can assume the input is binary). A dummy or null child is just a placeholder for a child to be constructed, or alternatively simply a zero-sized tree (note: this does not add any leaves to the tree). None of these children will be left empty in the end. Next, we define v max and v min , the maximal subtrees rooted at children(root( T ′ )) which have the most and fewest leaves, respectively.

As long as the root is not /epsilon1 -relatively balanced (which is equivalent to n T ′ ( v max ) or n T ′ ( v min ) deviating from the target n/h by over n /epsilon1 , as they are extreme points), we will attempt to rebalance. We define δ 1 and δ 2 to be the proportional deviation of n T ′ ( v min ) and n T ′ ( v max ) from the target size n/h respectively, and δ to be the minimum of the two. In effect, δ measures the maximum number of leaves we can move from the large subtree to the small subtree without causing n T ′ ( v max ) to dip below n/h or n T ′ ( v min ) to peak above n/h . This is important to guarantee our runtime: as an accounting scheme, we show that clusters monotonically approach size n/h , and thus we can quantify how fast our algorithm completes. We fully analyze this later, in Lemma 2.

Now we must attempt exactly this procedure: move a large subtree from v max to v min , though this subtree can have no more than δ n leaves. To do this, we simply start at v max and traverse down its right children (recall below v max , the tree is still binary). We halt on the first child that is of size δ n or smaller. We then remove it and find a place to reinsert it under v min .

The insertion spot is found similarly by descending down v min 's left children until the right child of the current vertex has fewer leaves in its subtree than the tree we are inserting. Thus, we have

completed our insertion and deletion operations. We repeat until the tree is relatively balanced as desired.

Algorithm 1

Input: Abinary hierarchy tree T of size n ≥ 1 / 2 /epsilon1 over a graph G = ( V, E, w ) , with smaller cluster always on the left, and parameters h ∈ [ n ] and /epsilon1 ∈ (0 , min(1 / 6 , 1 /h )) .

Output: A hierarchical clustering T ′ with an /epsilon1 -relatively balanced root that has k children.

We now analyze this part of the algorithm. The full proofs can be found in Appendix B, and we proceed to give the intuition here. To start, consider the tree we are deleting and reinserting, T ′ [ v ] . Ideally, we want this to have many leaves, but no more than δ n . We demonstrate that:

Lemma 1. For a subtree T ′ [ v ] that is deleted and reinserted in SplitRoot (Algorithm 1), we must have that /epsilon1 n/ (2( h -1)) < n T ( v ) ≤ δ n .

The upper bound simply comes from our stopping condition in the first nested while loop: we ensure n T ′ ( v ) ≤ δ n before selecting it. The lower bound is slightly more complicated. Effectively, we start by noting that max( δ 1 , δ 2 ) > /epsilon1 , because otherwise the stopping condition for the outer loop would be met. Then, consider the total amount of 'excess of large clusters', or more precisely, the sum over all deviations from n/h of clusters larger than n/h (note if all clusters were n/h , it would be perfectly balanced). This total excess must be matched in the 'deficiency of small clusters', which is the sum of deviations of clusters smaller than n/h . Therefore, since there are at least h small or h large clusters, the largest deviation must be at most h times the smallest deviation, according to our accounting scheme. This allows us to bound δ ≥ /epsilon1 / ( h -1) . The tree that is inserted and deleted must have at least half this many leaves, since it is the larger child of a node with over δ n leaves in its subtree. This gives our lower bound, showing we move at least a significant number of vertices each step.

Next, we aim to illustrate the relative balance. In addition to our analysis, we also obtain the runtime, which exhibits near-linearity when the condition h /lessmuch n holds.

Lemma 2. SplitRoot (Algorithm 1) yields a hierarchy whose root is /epsilon1 -relatively balanced with h children. In addition, it requires O ( nh ) time to terminate.

The root has h children by definition at the algorithm start and this remains invariant. The runtime comes from our aforementioned accounting scheme: the total excess and deficiency is reduced by the number of leaves in the subtree we move at each step, which we showed in Lemma 1 is n /epsilon1 / (2( h -1)) at least. This gives us a convergence time of O ( h ) , and each step can be bounded by O ( n ) time as we search for our insertion and deletion spots. Finally, the balance comes from the fact that our stopping condition is equivalent to the root being relatively balanced.

All that remains is to show the negative impact on the cost of edges that are separated by the algorithm. We bound this via the following lemma.

Lemma 3. In SplitRoot (Algorithm 1), for all e ∈ E that are separated:

Lemma 1 gives us that moved subtrees are at least of size /epsilon1 n/ (2( h -1)) , which is a lower bound on the size of the smallest cluster containing any edge separated by the algorithm. This is due to the fact that separated edges must have one endpoint in the deleted subtree and one outside, so their least common ancestor is an ancestor of the subtree. At worst, the final size of the smallest cluster containing such an edge is n , so the proportional increase is 2( h -1) / /epsilon1 at worst.

3.2 Fair Tree Folding

Next, we discuss how to achieve fairness by using MakeFair , as seen in Algorithm 2. This is our final recursive algorithm which utilizes SplitRoot . Assume we are given some hierarchical clustering. We start by running SplitRoot , to balance the split at the root and give it h children. Next we use a folding process similar to that of Knittel et al. [2023], but we use our shallow tree fold operator.

More specifically, we first sort the children of the root by the proportional representation of the first color (say, red). Then, we do a shallow fold across various k -sized sets, defined as follows: according to our ordering over the children, partition the vertices into k contiguous chunks starting from the first vertex. For each i ∈ [ h/k ] , we find the i -th vertex in each chunk and fold them together. Notice that this is a k -wise fold since there are k chunks, and we end up with h/k vertices. This is repeated on each color. After this, we simply recurse on the children. If a child is too small to be balanced by SplitRoot , then we stop and give it a trivial topology (a root with many leaf-children).

This completes our algorithm description. We now evaluate its runtime, degree of fairness, and approximation factor. To start, we show the degree of fairness achieved at the top level of the hierarchy.

Lemma 4. MakeFair (Algorithm 2) yields a hierarchy such that all depth 1 vertices satisfy fairness under α i ≤ λ i n · 1 -/epsilon1 (1+ /epsilon1 ) 2 ( 1 -k (1+ /epsilon1 ) c i h ) and β i ≥ λ i n · 1+ /epsilon1 (1 -/epsilon1 ) 2 ( 1 + 1 -/epsilon1 c i k ) , where λ i = c i n .

This proof is quite in depth, and most details are deferred to Appendix B. At a high level, we are showing that the folding process guarantees a level of fairness. The parts in our partition are ordered by the density of the color (say, red). Since each final vertex is made by folding across one vertex in each part, meaning that the vertices have a relatively wide spread in terms of their density of red points. This means that red vertices are distributed relatively well across our final subtrees. This guarantees a degree of balance.

The problem is that the degree of fairness still exhibits a compounding affect as we recurse. More specifically, since the first children are not perfectly balanced, then in the next recursive step, the total data subset we are working on may now deviate from the true color proportions. This deviation is bounded by our result in Lemma 4, but it will increase proportionally at each step.

Lemma 5. In MakeFair (Algorithm 2), let { λ i } i ∈ [ λ ] be the proportion of each color and assume k λ /lessmuch h . At any recursive call, the proportion of any color is (where λ i = 1 /c i for constant c i ):

Moreover, the recursive depth is bounded above by O (log( n/h )) .

This result derives directly from Lemma 4. Effectively, we increase the proportion of each color by the same factor each recursive step. All that is left to do is bound the recursive depth. Notice we start with n vertices. After splitting, our subtrees have size at most (1 + /epsilon1 ) n/h . After one fold, this is increased by a factor of k , and thus k λ after all folds. Interestingly, this doesn't impact the final result significantly; it's fairly similar to turning an n -sized tree into an n/h -sized tree, giving an O (log( n/h )) recursive depth. This will be sufficient to show our fairness.

Next, we evaluate the cost incurred at each stage in the hierarchy.

Lemma 6. In MakeFair (Algorithm 2), for all e ∈ E that is separated before the recursive call:

Algorithm 2 MakeFair

Input: A hierarchy tree T of size n ≥ 1 / 2 /epsilon1 over a graph G = ( V, E, w ) with vertices given one of λ colors, and parameters h [ n ] , k [ h/ ( λ 1)] , and /epsilon1 (0 , min(1 / 6 , 1 /h )) .

As discussed before, the final cluster size should be (1 + /epsilon1 ) nk λ /h . Any separated edge must have a starting cluster size of at least (1 -/epsilon1 ) n/h , as this is the size of the smallest cluster involved in tree folding. From this, it is straightforward to compute the proportional cost increase of a single recursive level, as well as the cost increase from the initial splitting in Lemma 3.

Weadditionally demonstrate that, whenever an edge is separated, its endpoints' least common ancestor will no longer be involved in any further recursive step. More formally:

Lemma 7. In MakeFair (Algorithm 2), any edge e ∈ E is separated at only one level of recursion.

Putting these two together pretty directly gives us our cost approximation.

Finally, Theorem 1 comes directly from Lemmas 6 and 8.

4 Simulations

This section validates the theoretical guarantees of Algorithm 2. Specifically, we demonstrate that modifying an unfair hierarchical clustering using the presented procedure yields a fair hierarchy that incurs only a modest increase in cost.

Datasets. We use two data sets, Census and Bank , from the UCI data repository Dua and Graff [2017]. Within each, we subsample only the features with numerical values. To compute the cost of a hierarchical clustering we set the similarity to be w ( i, j ) = 1 1+ d ( i,j ) where d ( i, j ) is the Euclidean distance between points i and j . We color data based on binary (represented as blue and red) protected features: race for Census and marital status for Bank (both in line with the prior work of Ahmadian et al. [2020]). As a result, Census has a blue to red ratio of 1:7 while Bank has 1:3. We then subsample each color in each data set such that we retain (approximately) the data's original balance. We use samples of size 512 for the balance experiments, and vary the sample sizes when assessing cost. For each experiment we conduct 10 independent replications (with different random seeds for the subsampling), and report the average results. We vary the parameters ( c, h, k, ε ) 1 to experimentally assess their theoretical impact on the approximate guarantees of Section 3. Due to space constrains, we here present only the results for the Census dataset and defer the complimentary results on Bank to the appendix.

8

A

17.5

B

17.5

25

D

15.0

15.0

Frequency

6

12.5

12.5

20

10.0

10.0

15

4

7.5

7.5

10

2

5.0

5.0

2.5

2.5

5

0

0.0

0.0

0

0.00

0.25

0.500.751.001.25

1.50

0.00

0.25

0.500.75

1.00

1.25

1.50

0.00

0.25

0.500.751.00

1.25

1.50

0.00

0.25

0.500.751.001.25

1.50

ClusterBalance

Cluster Balance

Cluster Balance

Cluster Balance

Implementation. The Python code for the following experiments are available in the Supplementary Material. We start by running average-linkage, a popular hierarchical clustering algorithm. We then apply Algorithm 2 to modify this structure and induce a fair hierarchical clustering that exhibits a mild increase in the cost objective.

Metrics. In our results we track the approximate cost objective increase as follows: Let G be our given graph, T be average-linkage's output, and T ′ be Algorithm 2's output. We then measure the ratio RATIO cost = cost G ( T ′ ) /cost G ( T ) . We additionally quantify the fairness that results from application of our algorithm by reporting the balances of each cluster in the final hierarchical clustering, where true fairness would match the color proportions of the underlying dataset.

Results. We first demonstrate how our algorithm adapts an unfair hierarchy into one that achieves fair representation of the protected attributes as desired in the original problem formulation.

In Figure 3, we depict the cluster balances of an unfair hierarchical clustering algorithm, namely 'average-linkage', and subsequently demonstrate that our algorithm effectively concentrates all clusters around the underlying data balance. In particular, we first apply the algorithm and then show how we the balance is further refined by tuning the parameters. The application of Algorithm 2 dramatically improves the representation of the protected attributes in the final clustering and, as such, firmly resolves the problem of achieving fairness.

While reaching this fair partitioning of the data is the overall goal, we further demonstrate that, in modifying the unfair clustering, we only increase the cost approximation by a modest amount. Figure 4 illustrates the change in relative cost as we increase the sample size n , the primary influence on our theoretical cost guarantees of Section 3. Specifically, we vary n in { 128 , 256 , 512 , 1024 , 2048 } and compute 10 replications (on different random seeds) of the fair hierarchical clustering procedure. Figure 4 depicts the mean relative cost of these replications with standard error bars. Notably, we see that the cost does increase with n as expected, but the increase relative to the unfair cost obtain by average linkage is only by a small multiplicative factor.

10

Relative Cost

6

4

500

1000

1500

2000

As demonstrated through this experimentation, the simplistic procedure of Algorithm 2 not only ensures the desired fairness properties absent in conventional (unfair) clustering algorithms but accomplishes this feat with a negligible rise in the overall cost. These results further highlight the immense value of our work.

References

Sara Ahmadian, Alessandro Epasto, Ravi Kumar, and Mohammad Mahdian. Clustering without over-representation. In KDD , pages 267-275, 2019.

Sara Ahmadian, Alessandro Epasto, Marina Knittel, Ravi Kumar, Mohammad Mahdian, Benjamin Moseley, Philip Pham, Sergei Vassilvitskii, and Yuyan Wang. Fair hierarchical clustering. In Hugo Larochelle, Marc'Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin, editors, Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual , 2020.

Julia Angwin, Jeff Larson, Surya Mattu, and Lauren Kirchner. Machine bias: There's software used across the country to predict future criminals. and it's biased against blacks. 2016.

Solon Barocas, Moritz Hardt, and Arvind Narayanan. Fairness and Machine Learning . www. fairmlbook.org , 2019.

Omer Ben-Porat, Fedor Sandomirskiy, and Moshe Tennenholtz. Protecting the protected group: Circumventing harmful fairness. In Thirty-Fifth AAAI Conference on Artificial Intelligence , pages 5176-5184. AAAI Press, 2021.

Suman Kalyan Bera, Deeparnab Chakrabarty, Nicolas Flores, and Maryam Negahbani. Fair algorithms for clustering. In NeurIPS , pages 4955-4966, 2019.

Ioana O Bercea, Martin Groß, Samir Khuller, Aounon Kumar, Clemens Rösner, Daniel R Schmidt, and Melanie Schmidt. On the cost of essentially fair clusterings. In APPROX-RANDOM , pages 18:1-18:22, 2019.

Bogen and A. Rieke. Help wanted: An examination of hiring algorithms, equity, and bias. Technical report, Upturn, 2018.

Brian Brubach, Darshan Chakrabarti, John P. Dickerson, Samir Khuller, Aravind Srinivasan, and Leonidas Tsepenekas. A pairwise fair and community-preserving approach to k-center clustering. In Proceedings of the 37th International Conference on Machine Learning , volume 119 of Proceedings of Machine Learning Research , pages 1178-1189. PMLR, 2020.

Moses Charikar and Vaggos Chatziafratis. Approximate hierarchical clustering via sparsest cut and spreading metrics. In SODA , pages 841-854, 2017.

Junjie Chen, Shu Zhang, Xiaoting He, Qingwei Lin, Hongyu Zhang, Dan Hao, Yu Kang, Feng Gao, Zhangwei Xu, Yingnong Dang, and Dongmei Zhang. How incidental are the incidents? characterizing and prioritizing incidents for large-scale online service systems. Association for Computing Machinery, 2021a. ISBN 9781450367684.

Junjie Chen, Shu Zhang, Xiaoting He, Qingwei Lin, Hongyu Zhang, Dan Hao, Yu Kang, Feng Gao, Zhangwei Xu, Yingnong Dang, and Dongmei Zhang. How incidental are the incidents? characterizing and prioritizing incidents for large-scale online service systems. Association for Computing Machinery, 2021b. ISBN 9781450367684.

Yujun Chen, Xian Yang, Hang Dong, Xiaoting He, Hongyu Zhang, Qingwei Lin, Junjie Chen, Pu Zhao, Yu Kang, Feng Gao, Zhangwei Xu, and Dongmei Zhang. Identifying linked incidents in large-scale online service systems. Association for Computing Machinery, 2020. ISBN 9781450370431.

Flavio Chierichetti, Ravi Kumar, Silvio Lattanzi, and Sergei Vassilvitskii. Fair clustering through fairlets. In NIPS , pages 5029-5037, 2017.

Vincent Cohen-Addad, Varun Kanade, Frederik Mallmann-Trenn, and Claire Mathieu. Hierarchical clustering: Objective functions and algorithms. In SODA , pages 378-397, 2018.

Sanjoy Dasgupta. A cost function for similarity-based hierarchical clustering. In STOC , pages 118-127, 2016.

Dheeru Dua and Casey Graff. UCI machine learning repository, 2017. URL http://archive.ics. uci.edu/ml .

Cynthia Dwork, Moritz Hardt, Toniann Pitassi, Omer Reingold, and Richard S. Zemel. Fairness through awareness. In Shafi Goldwasser, editor, Innovations in Theoretical Computer Science 2012, Cambridge, MA, USA, January 8-10, 2012 , pages 214-226. ACM, 2012.

Marina Knittel, Max Springer, John P. Dickerson, and MohammadTaghi Hajiaghayi. Generalized reductions: Making any hierarchical clustering fair and balanced with low cost, 2023.

Alexander Kraskov, Harald Stögbauer, Ralph G. Andrzejak, and Peter Grassberger. Hierarchical clustering using mutual information. CoRR , q-bio.QM/0311037, 2003.

Heidi Ledford. Millions of black people affected by racial bias in healthcare algorithms. Nature , 2019.

Benjamin Moseley and Joshua Wang. Approximation bounds for hierarchical clustering: Average linkage, bisecting k -means, and local search. In NIPS , pages 3094-3103, 2017.

Rohan Ramanath, Monojit Choudhury, and Kalika Bali. Entailment: An effective metric for comparing and evaluating hierarchical and non-hierarchical annotation schemes. In Stefanie Dipper, Maria Liakata, and Antonio Pareja-Lora, editors, Proceedings of the 7th Linguistic Annotation Workshop and Interoperability with Discourse, LAW-ID@ACL 2013, August 8-9, 2013, Sofia, Bulgaria , pages 42-50. The Association for Computer Linguistics, 2013.

AN Selvan, LM Cole, L Spackman, S Naylor, and Wright C. Hierarchical cluster analysis to aid diagnostic image data visualization of ms and other medical imaging modalities. In Molecular Biotechnology , 2005.

Latanya Sweeney. Discrimination in online ad delivery. ACM Queue , 2013.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper studies the clustering problem in a fair setting. It proposes an approximation algorithm that achieves polylogarithmic factors for fair and cost while also keep relative balance. This work has greatly improved the result of Knittel et al. [2023] that has an approximation factor of $O(n^\\delta\\text{polylog}(n))$. The simulation results on two datasets verifies the effectiveness of their algorithm (replacing the binary clustering algorithm that theoretically achieves a factor of $O(\\sqrt{\\log n})$ with average-linkage).\n\nSTRENGTHS:\n(1) A theoretical result of an approximation algorithm for the fair clustering problem, with great improvement in approximation factor.\n\n(2) Simple and intuitive tree operations in clustering adjustment that can be theoretically analysed.\n\nWEAKNESSES:\n(1) This work seems to heavily depend on Knittel et al. [2023], although the authors are probably overlapping heavily.\n\n(2) Scalability of $h$, $k$ and $\\lambda$ is doubtful. According to Theorem 1, $h$ should be much larger than $k^\\lambda$, but in the experiments, $h=4$, $k=\\lambda=2$ such that $h=k^\\lambda$, which seems to be a violation of the settings.\n\n(3) There are some unclear points (refer to the questions).\n\nQUESTIONS:\n(1) What is the role of $\\gamma$ in Theorem 1? Do you mean an approximation algorithm for the cost of the input binary clustering tree (as described in Lemma 8) rather than the optimal cost of the original problem? So, for the latter, $\\gamma$ needs to be multiplied outside the approximation factor, right?\n\n(2) How do you define the cluster balance? What does $c$ mean in the simulation settings?\n\n(3) Line 171, Def. 6, do you mean root$(T_f)$, rather than root$(T)$?\n\n(4) Line 236, do you mean \"at most $h$\" rather than \"at least $h$\"?\n\n(5) A typo: Line 281, \"poitns\" should be \"points\".\n\n(6) A ref error: Line 581.\n\n(7) Please delete Line 532 that has revealed author information!\n\nLIMITATIONS:\nYes, the authors have addressed the limitations in a specific section (Appendix A).", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-06"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper addresses the problem of fair hierarchical clustering.\nGiven a hierarchical clustering with a certain cost (determined by\nDasgupta's cost function), the paper shows how the hierarchy (tree) can be\nefficiently modified so that fairness constraints are satisfied\nand the cost of the tree increases (provably) by only by a\nsmall factor. The theoretical results are validated through experiments\non two data sets.\n\nSTRENGTHS:\n(a) The paper provides the first (provable) polylog approximation\n  for the cost of hierarchical clustering while satisfying fairness\n  requirements. This is an important advance in fair hierarchical clustering.\n\n  (b) The algorithm simplifies a previously known algorithm while\n  achieving the approximation bound.\n\n  (c) The paper is written very well.\n\nWEAKNESSES:\nA (very) minor weakness is that the statements of theorems require\na good amount of effort to understand since they involve many different\nparameters.\n\nQUESTIONS:\n(1) On lines 124--126 (page 4), it is mentioned that the approximation\n  factor is with respect to an optimal vanilla hierarchy (which doesn't\n  consider fairness).  Did the previous work also use this assumption?\n\n  (2) Are any hardness of approximation results known for the problem? (It will\n  be interesting to see how close the polylog approximation is compared to\n  what can't be achieved in polynomial time under a standard assumption\n  such as P != NP.)\n\n  (3) The statements of theorems/lemmas etc. involve many parameters. This\n  reviewer agrees that this is unavoidable for making the theorems precise.\n  Would it be possible to include informal statements of results that are easier\n  to understand (even if they are not mathematically accurate)?\n\n  Some minor typos:\n\n  (a) Line 62 (page 2): \"as a in\" ---> \"as an\"\n  (a) Line 121 (page 4): \"increasing cost\" ---> \"increasing the cost\"\n\nLIMITATIONS:\nNone", "TITLE": "Official Review", "RECOMMENDATION": 8, "REVIEWER_CONFIDENCE": 2, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2023-07-08"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper considers finding a hierarchical clustering of (approximately) minimum Dasgupta cost under fairness and balance constraints. It appears that for any constant fairness range (i.e. the quantities a_i and b_i) they have a quasi-linear time algorithm which has a polylogarithmic approximation ratio. In fact - their algorithm takes any (unfair) hierarchical clustering and converts it into a fair one.\n\nSTRENGTHS:\nThe best previous polynomial-time algorithm for approximately minimising the Dasgupta cost under fairness constriants had a polynomial approximation ratio (with exponent dependent on the fairness range). I think that going from a polynomial to polylogarithmic approximation ratio is a big step.\nThe authors have conducted experiments on their algorithm - showing empirically that the cost of the fair clustering produced is not much greater than the cost of the original (unfair) clustering. However, there are no experiments comparing to other algorithms.\n\nWEAKNESSES:\nThe algorithm is tailored to the Dasgupta cost which is only one measure of goodness of a hierarchical clustering and in itself can be seen as a heuristic. However - I believe this cost to be very famous so the result is significant.\nThe way the bound is written at the moment is completely impenetrable - please see the “Questions” section for advice on this.\nThere are issues with the writing of the paper which I shall now list (I include here any typos etc.):\n- The Introduction section uses a lot of notation that is not defined until later in the paper. This should definitely be fixed.\n- The authors state that the cost is hypothesised not to be O(1) approximatable. What they mean is not O(1) approximatable by a polynomial-time algorithm.\n- Definition 6 is ambiguous and hence is not a proper definition.\n- In line 60 I believe the authors mean “fairness literature”\n- In line 84 \\gamma must surely appear in the approximation ratio\n- Line 103 should start with “which is” instead of “is”\n- In line 103 “tree” should be replaced by “graph”\n- The use of “i.e.” in line 123 is wrong.\n- Line 161 should say “inserts a new vertex p…”\n- In line 133 \\ell(C) (which I assume is the number of elements of C of colour \\ell) is not defined. This notation also overloads \\ell - it is both a colour and a function (corresponding to the colour). I recommend something like N_{\\ell}(C).\n\nQUESTIONS:\nSuppose I give you a<1 and b>1 and I enforce you to create a fair hierarchical clustering with a_i=a and b_i=b for all colours i (where a_i and b_i are as in line 95). Can you write the parameters, the time complexity and the approximation ratio in terms of a and b? This is not just a question - doing this will vastly improve the presentation of the result since this is the logical way round (I give you the fairness constraints and you give me the (approximately) best hierarchical clustering satisfying those constraints).\n\nLIMITATIONS:\nAuthors have addressed limitations", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-12"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper considers fairness in hierarchical clustering and proposes an approximation algorithm that modifies a given unfair approximate vanilla hierarchy $T$, of which the cost is bounded by $\\alpha$-factor of the optimal (OPT) hierarchy tree, i.e., $cost(T)\\leq \\alpha \\cdot cost(OPT)$, to a polylogarithmic-approximate fair hierarchical clustering. This work is developed based on the ideas by Knittel et al. [2023] but simplifies some of the key operators, e.g., tree holding operator, and achieves the polylogarithmic approximation for cost for the first time.\n\nSTRENGTHS:\n- Proposed an algorithm that modifies an unfair hierarchical clustering and yields a fair hierarchy with only a modest increase in cost.\n- Provided real dataset experiments showing that their proposed algorithm improves the fairness in clustering (i.e., balances the portion of nodes from different parties) with a modest cost ratio increase.\n\nWEAKNESSES:\n- I think the presentation of this paper needs to be largely modified. First, this paper addresses some technical terminologies before there are defined, which makes it hard to understand what the statements mean before reading until the end of the paper. For example, in Introduction the last paragraph, “O(function(N)))-approximation”is used to compare previous methodologies. But, neither the definition of the cost in hierarchical clustering nor what this approximation means was provided. Theorem 1 in page 3 is an exact same copy of the same theorem in page 5. But just presenting the same theorem without even defining what approximation means and how $\\alpha_i$ and $\\beta_i$ are related to the quantification of fairness makes it very hard to understand the meaning of the paper in introduction. If the authors want to summarize the key contributions in introduction, they need to properly define the terminologies and important parameters to make it self-contained. \n- Another issue is related to the reference. The techniques in this paper is highly dependent on the previous techniques by Knittel et al [2023] and the authors refer the paper many times. Especially in Sec. 2.3 when tree operators are introduced, they refer the same operators introduced in Knittel. But it is hard to see what was the original way these operators were defined, what are the main changes this paper addresses, and why this change generates a better approximation.\n- In experiment Fig.4, the ratio of cost increase due to fair clustering is about 8x when n is about 10^3. Can we call this a modest cost increase? Intuitively, isn't it relatively easier to achieve the fairness for larger $n$ since there are many nodes and balancing those nodes without hurting the cost can be easier due to much more ways to modify the tree? Can the authors compare their result with other algorithms in terms of achievable fairness and cost increase? There is no baseline comparison in the experiment. Also, it is not clear whether the performance of the proposed algorithm is robust to the change of the original hierarchical clustering algorithm. In the experiment, only the average-linkage was considered as an initial algorithm.\n\nQUESTIONS:\n- Can the authors provide experiments to compare their performance with other baselines?\n- Can the authors show that the performance of proposed algorithm is robust to the change of the originally given (unfair) hierarchical clustering?\n\nLIMITATIONS:\nLimitations are not well addressed by the authors.", "TITLE": "Official Review", "RECOMMENDATION": 3, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-22"}