Original: P ROTOTYPE B ASED C LASSIFICATION FROM H IERARCHY TO F AIRNESS
Revised: P ROTOTYPE B ASED C LASSIFICATION FROM H IERARCHY TO F AIRNESS

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Artiﬁcial neural nets can represent and classify many types of high-dimensional data but are often tailored to particular applications – e.g., for “fair” or “hierarchical” classiﬁcation.
Revised: Artiﬁcial neural nets can represent and classify many types of high-dimensional data but are often tailored to particular applications – e.g., for “fair” or “hierarchical” classiﬁcation.

Original: Once an architecture has been selected, it is often difﬁcult for humans to adjust models for a new task; for example, a hierarchical classiﬁer cannot be easily transformed into a fair classiﬁer that shields a protected ﬁeld.
Revised: Once an architecture has been selected, it is often difﬁcult for humans to adjust models for a new task; for example, a hierarchical classiﬁer cannot be easily transformed into a fair classiﬁer that shields a protected ﬁeld.

Original: Our contribution in this work is a new neural network architecture, the concept subspace network (CSN), which generalizes existing specialized classiﬁers to produce a uniﬁed model capable of learning a spectrum of multi-concept relationships.
Revised: Our contribution in this work is a new neural network architecture, the concept subspace network (CSN), which generalizes existing specialized classiﬁers to produce a uniﬁed model capable of learning a spectrum of multi-concept relationships.

Original: We demonstrate that CSNs reproduce state-of-the-art results in fair classiﬁcation when enforcing concept independence, may be transformed into hierarchical classiﬁers, or may even reconcile fairness and hierarchy within a single classiﬁer.
Revised: We demonstrate that CSNs reproduce state-of-the-art results in fair classiﬁcation when enforcing concept independence, may be transformed into hierarchical classiﬁers, or may even reconcile fairness and hierarchy within a single classiﬁer.

Original: The CSN is inspired by and matches the performance of existing prototype-based classiﬁers that promote interpretability.
Revised: The CSN is inspired by and matches the performance of existing prototype-based classiﬁers that promote interpretability.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Neural networks are able to learn rich representations of data that support highly accurate classiﬁcation; however, understanding or controlling what neural nets learn remains challenging.
Revised: Neural networks are able to learn rich representations of data that support highly accurate classiﬁcation; however, understanding or controlling what neural nets learn remains challenging.

Original: Some techniques offer insight into pre-trained models by uncovering directions within latent spaces that correspond to particular concepts, image manipulations, or more (Goetschalckx et al., 2019; Kim et al., 2018), while approaches focused on interpretability provide techniques that are more comprehensible to humans (Li et al., 2018;
Revised: Some techniques offer insight into pre-trained models by uncovering directions within latent spaces that correspond to particular concepts, image manipulations, or more (Goetschalckx et al., 2019; Kim et al., 2018), while approaches focused on interpretability provide techniques that are more comprehensible to humans (Li et al., 2018;

Original: Chen et al., 2019).
Revised: Chen et al., 2019).

Original: While these methods provide insight, they fail to offer control: humans observe learned patterns but are unable to guide models such that learned relationships are useful for a particular setting or task.
Revised: While these methods provide insight, they fail to offer control: humans observe learned patterns but are unable to guide models such that learned relationships are useful for a particular setting or task.

Original: Another line of work has advanced the design of models for particular types of classiﬁcation tasks (such as fair or hierarchical classiﬁcation) but these techniques are often developed with only one problem in mind (Zemel et al., 2016;
Revised: Another line of work has advanced the design of models for particular types of classiﬁcation tasks (such as fair or hierarchical classiﬁcation) but these techniques are often developed with only one problem in mind (Zemel et al., 2016;

Original: Xie et al., 2017; Hase et al., 2019).
Revised: Xie et al., 2017; Hase et al., 2019).

Original: For example, models built for fair classiﬁcation (predicting an outcome regardless of information about a protected ﬁeld) are only used to enforce independence of concepts rather than hierarchy.
Revised: For example, models built for fair classiﬁcation (predicting an outcome regardless of information about a protected ﬁeld) are only used to enforce independence of concepts rather than hierarchy.

Original: Thus, humans may exert control over learned representations by selecting an appropriate technique rather than tuning training parameters within the same technique.
Revised: Thus, humans may exert control over learned representations by selecting an appropriate technique rather than tuning training parameters within the same technique.

Original: We have designed a new neural network architecture, the concept subspace network (CSN), which generalizes existing specialized classiﬁers to produce a uniﬁed model capable of learning a spectrum of multi-concept relationships.
Revised: We have designed a new neural network architecture, the concept subspace network (CSN), which generalizes existing specialized classiﬁers to produce a uniﬁed model capable of learning a spectrum of multi-concept relationships.

Original: CSNs use prototype-based representations, a technique employed in interpretable neural networks in prior art (Li et al., 2018; Chen et al., 2019; Garnot & Landrieu, 2020).
Revised: CSNs use prototype-based representations, a technique employed in interpretable neural networks in prior art (Li et al., 2018; Chen et al., 2019; Garnot & Landrieu, 2020).

Original: A single CSN uses sets of prototypes in order to simultaneously learn multiple concepts; classiﬁcation within a single concept (e.g., “type of animal”) is performed by projecting encodings into a concept subspace deﬁned by the prototypes for that concept (e.g., “bird,” “dog,” etc.).
Revised: A single CSN uses sets of prototypes in order to simultaneously learn multiple concepts; classiﬁcation within a single concept (e.g., “type of animal”) is performed by projecting encodings into a concept subspace deﬁned by the prototypes for that concept (e.g., “bird,” “dog,” etc.).

Original: Lastly, CSNs use a measure of concept subspace alignment to guide concept relationships such as independence or hierarchy.
Revised: Lastly, CSNs use a measure of concept subspace alignment to guide concept relationships such as independence or hierarchy.

Original: In our experiments, CSNs performed comparably to state-of-the art in fair classiﬁcation, despite prior methods only being designed for this type of problem.
Revised: In our experiments, CSNs performed comparably to state-of-the art in fair classiﬁcation, despite prior methods only being designed for this type of problem.

Original: In applying CSNs to hierarchical classiﬁcation tasks, networks automatically deduced interpretable representations of the hierarchical problem structure, allowing them to outperform state-of-the-art, for a given neural network backbone, in terms of both accuracy and average cost of errors on the CIFAR100 dataset.
Revised: In applying CSNs to hierarchical classiﬁcation tasks, networks automatically deduced interpretable representations of the hierarchical problem structure, allowing them to outperform state-of-the-art, for a given neural network backbone, in terms of both accuracy and average cost of errors on the CIFAR100 dataset.

Original: Lastly, in a human-motion prediction task, we demonstrated how a single CSN could enforce both fairness (to preserve participant privacy) and hierarchy (to exploit a known taxonomy of tasks).
Revised: Lastly, in a human-motion prediction task, we demonstrated how a single CSN could enforce both fairness (to preserve participant privacy) and hierarchy (to exploit a known taxonomy of tasks).

Original: Our ﬁndings suggest that CSNs may be applied to a wide range of problems that had previously only been addressed individually, or not at all.
Revised: Our ﬁndings suggest that CSNs may be applied to a wide range of problems that had previously only been addressed individually, or not at all.

Original:  R ELATED W ORK 2. I NTERPRETABILITY AND P ROTOTYPE N ETWORKS
Revised:  R ELATED W ORK 2. I NTERPRETABILITY AND P ROTOTYPE N ETWORKS

Original: Numerous post-hoc explanation techniques ﬁt models to pre-trained neural nets; if humans understand these auxiliary models, they can hypothesize about how the neural nets behave (Ribeiro et al., 2016; Lundberg & Lee, 2017).
Revised: Numerous post-hoc explanation techniques ﬁt models to pre-trained neural nets; if humans understand these auxiliary models, they can hypothesize about how the neural nets behave (Ribeiro et al., 2016; Lundberg & Lee, 2017).

Original: However, techniques in which explanations are decoupled from underlying logic may be susceptible to adversarial attacks or produce misleading explanations (Heo et al., 2019; Slack et al., 2020).
Revised: However, techniques in which explanations are decoupled from underlying logic may be susceptible to adversarial attacks or produce misleading explanations (Heo et al., 2019; Slack et al., 2020).

Original: Unlike such decoupled explanations, interpretability research seeks to expose a model’s reasoning.
Revised: Unlike such decoupled explanations, interpretability research seeks to expose a model’s reasoning.

Original: Numerous intepretability methods exist, but in this work we focus on prototype-based latent representations in neural nets.
Revised: In this work we focus on prototype-based latent representations in neural nets.

Revised: There is a long history of learning discrete representations in continuous spaces, originating under “vector quantization” literature (Kohonen, 1990; Schneider et al., 2009).

Original: The prototype case network (PCN) comprised an autoencoder model that clustered encodings around understandable, trainable prototypes, with classiﬁcations made via a linear weighting of the distances from encodings to prototypes (Li et al., 2018).
Revised: More recently, the prototype case network (PCN) comprised an autoencoder model that clustered encodings around understandable, trainable prototypes, with classiﬁcations made via a linear weighting of the distances from encodings to prototypes (Li et al., 2018).

Original: Further research in image classiﬁcation extended PCNs to use convolutional ﬁlters as prototypes and for hierarchical classiﬁcation in the hierarchical prototype network (HPN)
Revised: Further research in image classiﬁcation extended PCNs to use convolutional ﬁlters as prototypes and for hierarchical classiﬁcation in the hierarchical prototype network (HPN)

Original: (Chen et al., 2019; Hase et al., 2019).
Revised: (Chen et al., 2019; Hase et al., 2019).

Original: Lastly, Garnot & Landrieu (2020) use prototypes in Metric-Guided Prototype Learning (MGP) in conjunction with a loss function to cluster prototypes to minimize user-deﬁned costs.
Revised: Lastly, Garnot & Landrieu (2020) use prototypes in Metric-Guided Prototype Learning (MGP) in conjunction with a loss function to cluster prototypes to minimize user-deﬁned costs.

Original: Our model similarly uses trainable prototypes for classiﬁcation, but differs from prior art in two respects.
Revised: Our model similarly uses trainable prototypes for classiﬁcation, but differs from prior art in two respects.

Original: First, we modify the standard PCN architecture to support other changes, without degrading classiﬁcation performance.
Revised: First, we modify the standard PCN architecture to support other changes, without degrading classiﬁcation performance.

Original: Second, like HPNs (but not PCNs or MGP), CSNs leverage multiple sets of prototypes to enable hierarchical classiﬁcation but also allow for non-hierarchical concept relationships.
Revised: Second, like HPNs (but not PCNs or MGP), CSNs leverage multiple sets of prototypes to enable hierarchical classiﬁcation but also allow for non-hierarchical concept relationships.

Original: 2. F AIR AND H IERARCHICAL C LASSIFICATION
Revised: 2. F AIR AND H IERARCHICAL C LASSIFICATION

Original: AI fairness research considers how to mitigate undesirable patterns or biases in machine learning models.
Revised: AI fairness research considers how to mitigate undesirable patterns or biases in machine learning models.

Original: Consider the problem of predicting a person’s credit risk: non-causal correlations between age and risk may lead AI models to inappropriately penalize people according to their age (Zemel et al., 2016).
Revised: Consider the problem of predicting a person’s credit risk: non-causal correlations between age and risk may lead AI models to inappropriately penalize people according to their age (Zemel et al., 2016).

Original: The problem of fair classiﬁcation is often framed as follows: given inputs, x , which are informative of a protected ﬁeld, s , and outcome, y , predict y from x without being inﬂuenced by s (Zemel et al., 2013).
Revised: The problem of fair classiﬁcation is often framed as follows: given inputs, x , which are informative of a protected ﬁeld, s , and outcome, y , predict y from x without being inﬂuenced by s (Zemel et al., 2013).

Original: Merely removing s from x (e.g., not including age as an input to a credit predictor) rarely removes all information about s , so researchers have developed a variety of techniques to create representations
Revised: Merely removing s from x (e.g., not including age as an input to a credit predictor) rarely removes all information about s , so researchers have developed a variety of techniques to create representations

Original: that “purge” information about s (Zemel et al., 2016; Xie et al., 2017; Jiang et al., 2020).
Revised: that “purge” information about s (Zemel et al., 2016; Xie et al., 2017; Jiang et al., 2020).

Original: Hierarchical classiﬁcation solves a different problem: given a hierarchical taxonomy of classes (e.g., birds vs. dogs at a high level and sparrows vs. toucans at a low level), output the correct label at each classiﬁcation level.
Revised: Hierarchical classiﬁcation solves a different problem: given a hierarchical taxonomy of classes (e.g., birds vs. dogs at a high level and sparrows vs. toucans at a low level), output the correct label at each classiﬁcation level.

Original: Neural nets using convolution and recurrent layers in specialized designs have achieved remarkable success in hierarchical image classiﬁcation (Zhu & Bain, 2017; Guo et al., 2018).
Revised: Neural nets using convolution and recurrent layers in specialized designs have achieved remarkable success in hierarchical image classiﬁcation (Zhu & Bain, 2017; Guo et al., 2018).

Original: The hierarchical prototype network (HPN) uses prototypes and a training routine based upon conditional subsets of training data to create hierarchically-organized prototypes (Hase et al., 2019).
Revised: The hierarchical prototype network (HPN) uses prototypes and a training routine based upon conditional subsets of training data to create hierarchically-organized prototypes (Hase et al., 2019).

Original: Garnot & Landrieu (2020) also use prototypes for hierarchical classiﬁcation in Metric-Guided Prototype Learning (MGP) by adjusting the training loss to guide prototype arrangement.
Revised: Garnot & Landrieu (2020) also use prototypes for hierarchical classiﬁcation in Metric-Guided Prototype Learning (MGP) by adjusting the training loss to guide prototype arrangement.

Original: Neither HPN nor MGP explicitly models relationships between multiple subsets of prototypes.
Revised: Neither HPN nor MGP explicitly models relationships between multiple subsets of prototypes.

Original: Lastly, recent works propose hyperbolic latent spaces as a natural way to model hierarchical data (Dai et al., 2021;
Revised: Lastly, recent works propose hyperbolic latent spaces as a natural way to model hierarchical data (Dai et al., 2021;

Original: Mathieu et al., 2019; Nickel & Kiela, 2017; Liu et al., 2020).
Revised: Mathieu et al., 2019; Nickel & Kiela, 2017; Liu et al., 2020).

Original: Our method, conversely, relies upon concepts from Euclidean geometry.
Revised: Our method, conversely, relies upon concepts from Euclidean geometry.

Original: Extending the principle of subspace alignment that we develop to non-Euclidean geometric spaces is a promising direction but is beyond the scope of this work.
Revised: Extending the principle of subspace alignment that we develop to non-Euclidean geometric spaces is a promising direction but is beyond the scope of this work.

Original:  T ECHNICAL A PPROACH
Revised:  T ECHNICAL A PPROACH

Original: In this section, we outlined the design of the CSN, which was inspired by desires for both interpretable representations and explicit concept relationships.
Revised: In this section, we outlined the design of the CSN, which was inspired by desires for both interpretable representations and explicit concept relationships.

Original: First, we wished for interpretable representations, so we built upon the PCN design, with modiﬁcations.
Revised: First, we wished for interpretable representations, so we built upon the PCN design, with modiﬁcations.

Original: Second, we explicitly encoded relationships between concepts by introducing multiple sets of prototypes, instead of just one in
Revised: Second, we explicitly encoded relationships between concepts by introducing multiple sets of prototypes, instead of just one in

Original: PCNs.
Revised: PCNs.

Original: Third, we enabled guidance of the concept relationships by modifying the CSN training loss.
Revised: Third, we enabled guidance of the concept relationships by modifying the CSN training loss.

Original: Together, these changes supported not only interpretable classiﬁcation, but also provided a ﬂexible framework for a single model architecture to learn different concept relationships.
Revised: Together, these changes supported not only interpretable classiﬁcation, but also provided a ﬂexible framework for a single model architecture to learn different concept relationships.

Original: As a direct consequence, CSNs supported both fair and hierarchical classiﬁcation, as well as more complex problems in which multiple concept relationships must be deﬁned.

Original: 3. C ONCEPT S UBSPACE C LASSIFICATION
Revised: 3. C ONCEPT S UBSPACE C LASSIFICATION

Original: A CSN performing a single classiﬁcation task (e.g., identifying a digit in an image) is deﬁned by three sets of trainable weights.
Revised: A CSN performing a single classiﬁcation task (e.g., identifying a digit in an image) is deﬁned by three sets of trainable weights.

Original: First, an encoder parametrized by weights θ , e θ , maps from inputs of dimension X to encodings of dimension Z : e θ : R X
Revised: First, an encoder parametrized by weights θ , e θ , maps from inputs of dimension X to encodings of dimension Z : e θ : R X

Original: → R Z .
Revised: → R Z .

Original: Second, a decoder parametrized by weights φ , d φ , performs the decoding function of mapping from encodings to reconstructed inputs: d φ : R Z → R X .
Revised: Second, a decoder parametrized by weights φ , d φ , performs the decoding function of mapping from encodings to reconstructed inputs: d φ : R Z → R X .

Original: Third, there exist a set of k trainable prototype weights, p , that are each Zdimensional vectors: p 1 , p 2 , ..., p k ∈ R Z .
Revised: Third, there exist a set of k trainable prototype weights, p , that are each Zdimensional vectors: p 1 , p 2 , ..., p k ∈ R Z .

Original: This architecture resembles that of the PCN, but without the additional linear classiﬁcation layer (Li et al., 2018).
Revised: This architecture resembles that of the PCN, but without the additional linear classiﬁcation layer (Li et al., 2018).

Original: Here, we focus brieﬂy on the set of prototypes, p .
Revised: Here, we focus brieﬂy on the set of prototypes, p .

Original: Given a set of k prototypes in R Z , the prototypes deﬁne a  subspace generated by starting at the ﬁrst prototype, p 1 , and addingall linear combinations of vector differencesfrom p 1 to all other p i ; i ∈ [2 , k ] .
Revised: Given a set of k prototypes in R Z , we deﬁne a “concept subspace,” C as follows: [Equation] C is the linear subspace in R Z deﬁned by starting at the ﬁrst prototype and adding linear scalings of vector differences to all other prototypes.

Original: We call this subspace a “concept subspace,” because it represents a space of encodings between prototypes deﬁning a single concept (e.g., prototypes for digits 0, 1, 2, etc. deﬁne a concept subspace for digit classiﬁcation).
Revised: We call this subspace a concept subspace because it represents a space of encodings between prototypes deﬁning a single concept (e.g., prototypes for digits 0, 1, 2, etc. deﬁne a concept subspace for digit classiﬁcation).

Original: Note that one may project points from anywhere in the latent space into a concept subspace.

Original: A CSN’s architecture — consisting of an encoder, a decoder, and a set of prototypes and the associated concept subspace — enables two types of functionality: the encoder and decoder may be composed to reconstruct inputs via their latent representations, and CSNs may perform classiﬁcation tasks by mapping an input, x , to one of Y discrete categories.
Revised: A CSN’s architecture — consisting of an encoder, a decoder, and a set of prototypes and the associated concept subspace — enables two types of functionality: the encoder and decoder may be composed to reconstruct inputs via their latent representations, and CSNs may perform classiﬁcation tasks by mapping an input, x , to one of Y discrete categories.

Original: Classiﬁcation is performed by ﬁrst encoding an input into a latent representation, z = e θ ( x ); that encoding is then projected into the concept subspace via z proj = proj ( z, p ) .
Revised: Classiﬁcation is performed by ﬁrst encoding an input into a latent representation, z = e θ ( x ) .

Original: The l 2 distance from zproj to each prototype is then calculated, yielding k distance values: d i ( z proj , p ) =
Revised: The l 2 distance from z to each prototype is then calculated, yielding k distance values: d i ( z, p ) =

Original: ||
Revised: ||

Original: zproj − p
Revised: z − p

Original: i || 22 ); i ∈ [1 , k ] .
Revised: i || 22 ; i ∈ [1 , k ] .

Original: These distances are mapped to a probability distribution, P K ( i ); i ∈ [1 , k ] , by taking the softmax of their negatives.
Revised: These distances are mapped to a probability distribution, P K ( i ); i ∈ [1 , k ] , by taking the softmax of their negatives.

Original: Lastly, the distribution over k is converted to a distribution over Y categories via a ﬁxed, manyto-one mapping from prototype to category and the summing of probabilities. (Each prototype p i has an associated class, class ( p i ) — for example even-indexed prototypes mapping 0 and oddindexed ones to 1 in a binary classiﬁcation task.
Revised: Lastly, if there are more prototypes than classes, (e.g., two prototypes for dogs, two for cats, etc.)

Original: The probability of a classiﬁcation is  thesum of all P K probabilities for that class: P Y ( y ) = (cid:80) i ∈ [1 ,k ] 1 class ( p i )= y P K ( i ) .)
Revised: the distribution over k is converted to a distribution over Y categories summing the probabilities for prototypes belonging to the same class.

Original: Classiﬁcation by a CSN differs from that by a PCN in two ways. First, a CSN uses the projected encoding, z proj , for classiﬁcation rather than z .
Revised: For single-concept classiﬁcation, CSNs differ from PCNs primarily by removing the linear layer that PCNs used to transform distances to prototypes into classiﬁcations.

Original: Second, PCNs incorporate a linear layer to transform distances from prototypes to a distribution over classes, while CSNs directly take the softmax of the negativeof distances. Figure 1a depicts a simpliﬁed example of classiﬁcation, wherein a three-dimensional latent space is used in conjunction with three prototypes for a ternary classiﬁcation task.
Revised: We found this unnecessary for high classiﬁcation accuracy (Appendix A) and instead directly used negative distances. Without the linear layer, CSN classiﬁcation is equivalent to projecting encodings, z , onto a concept subspace before calculating distances.

Original: An encoding,  z = e ( x ) , is generated in the latent space.
Revised: The distances between projected encoding, dubbed z proj , and prototypes will induce the same softmax distribution as when the orthogonal component remains.

Original: The prototypes, p i ; i ∈ [1 , 3] , deﬁne a plane (corresponding in this case to the x − y plane). Projecting z into the plane deﬁnes z proj , which isthen used to calculate distances to each prototype. The softmax of the negative of these distances generates a distribution over categories.
Revised: Indeed, we ﬁnd projection more intuitive - only the component of z that corresponds to the subspace is used for classiﬁcation - and list projection as a standard step in the remainder of this paper. A simple example of projecting an encoding and calculating distances to prototypes is shown in Figure 1 a.

Original: For some tasks, we used an encoder design from variational-autoencoders (VAEs) in order to regularize the distribution of encodings to conform to unit Gaussians (Kingma & Welling, 2014).
Revised: For some tasks, we used an encoder design from variational-autoencoders (VAEs) in order to regularize the distribution of encodings to conform to unit Gaussians (Kingma & Welling, 2014).

Original: By default, this regularization loss was set to 0, but it sometimes proved useful in some domains to prevent overﬁtting.
Revised: By default, this regularization loss was set to 0, but it sometimes proved useful in some domains to prevent overﬁtting (as detailed in experiments later).

Original: We emphasize that CSNs are discriminative, rather than generative, models, so we did not seek to learn a latent space from which to sample.
Revised: We emphasize that CSNs are discriminative, rather than generative, models, so we did not seek to learn a latent space from which to sample.

Original: [Figure]
Revised: [Figure]

Original: 3. M ULTI -C ONCEPT L EARNING
Revised: 3. M ULTI -C ONCEPT L EARNING

Original: We deﬁned the CSN architecture for single classiﬁcation tasks in the previous section; here, we demonstrate how a CSN may be used for multiple classiﬁcation tasks.
Revised: We deﬁned the CSN architecture for single classiﬁcation tasks in the previous section; here, we explain how a CSN may be used for multiple classiﬁcation tasks.

Original: (For example, consider a scenario involving classifying both what type of bird a photo depicts and whether the photo was taken outdoors or indoors.)
Revised: (For example, consider a scenario involving classifying both what type of bird a photo depicts and whether the photo was taken outdoors or indoors.)

Original: Extending CSNs to support multiple classiﬁcations requires the addition of new sets of prototypes.
Revised: Extending CSNs to support multiple classiﬁcations requires the addition of new sets of prototypes.

Revised: This is the primary contribution of our work.

Original: Multiple classiﬁcation tasks are performed by deﬁning a set consisting of sets of prototypes: P = { p 1 , ..., p c } , with a set of prototypes for each of c classiﬁcation tasks.
Revised: Multiple classiﬁcation tasks are performed by deﬁning a set consisting of sets of prototypes: P = { p 1 , ..., p c } , with a set of prototypes for each of c classiﬁcation tasks.

Original: A classiﬁcation task is performed by using the CSN’s encoder to generate an encoding, z , and projecting z into the concept subspace deﬁned by the set of prototypes particular to the given task.
Revised: A classiﬁcation task is performed by using the CSN’s encoder to generate an encoding, z , and projecting z into the concept subspace deﬁned by the set of prototypes particular to the given task.

Original: Figure 1  depicts simpliﬁed examples of two concept subspaces.
Revised: Figure 1 (b-d) depicts simpliﬁed examples of two concept subspaces.

Original: In each example, each concept uses three prototypes, yielding two planar concept spaces; z may be projected into either plane depending upon the classiﬁcation task at hand.
Revised: In each example, each concept uses three prototypes, yielding two planar concept spaces (one of which corresponds to the x − y plane for illustrative purposes); z may be projected into either plane depending upon the classiﬁcation task at hand.

Original: While the prototypes in different sets are separate from each other, correlations present in training data may lead to a range of relationships among prototypes.
Revised: While the prototypes in different sets are separate from each other, correlations present in training data may lead to a range of relationships among prototypes.

Original: Returning to the previous example scenario, prototypes of birds may represent canaries and toucans, while prototypes of indoor and outdoor scenes may represent living rooms and jungles; each set of prototypes is independent in principle, but in reality, prototypes may represent canaries in living rooms and toucans in jungles.
Revised: Returning to the previous example scenario, prototypes of birds may represent canaries and toucans, while prototypes of indoor and outdoor scenes may represent living rooms and jungles; each set of prototypes is independent in principle, but in reality, prototypes may represent canaries in living rooms and toucans in jungles.

Original: In fact, two sets of prototypes can exhibit a range of relationships from highly correlated to fully independent, as shown in Figure 1.
Revised: In fact, two sets of prototypes can exhibit a range of relationships from highly correlated to fully independent, as shown in Figure 1.

Original: We deﬁned a metric, concept subspace alignment , to reﬂect this range of relationships.
Revised: We deﬁned a metric, concept subspace alignment , to reﬂect this range of relationships.

Original: Mathematically, the alignment of two subspaces is the mean of the cosine squared of the angle between all pairs of vectors drawn from the basis of each subspace.
Revised: Mathematically, the alignment of two subspaces is the mean of the cosine squared of the angle between all pairs of vectors drawn from the basis of each subspace.

Original: Given orthonormal bases, efﬁciently computed via QR factorization, Q 1 and Q 2 , of ranks m and n , we deﬁne alignment as follows:
Revised: Given orthonormal bases, efﬁciently computed via QR factorization, Q 1 and Q 2 , of ranks m and n , we deﬁne alignment as follows:

Original: [Equation]
Revised: [Equation]

Original: Given the range of values for the cosine squared function, alignment values range from 0 tofor orthogonal and parallel subspaces, respectively.
Revised: Given the range of values for the cosine squared function, alignment values range from 0 tofor orthogonal and parallel subspaces, respectively.

Original: Intuitively, orthogonality lends itself well to independent concepts and therefore supports fair classiﬁcation, whereas parallel subspaces naturally correspond to hierarchical classiﬁcation.
Revised: Intuitively, orthogonality lends itself well to independent concepts and therefore supports fair classiﬁcation, whereas parallel subspaces naturally correspond to hierarchical classiﬁcation.

Original: We elaborated on this intuition in Section 3.4.
Revised: We elaborated on this intuition in Section 3.4.

Original: 3. T RAINING P ROCEDURE
Revised: 3. T RAINING P ROCEDURE

Original: When training a CSN, we assume access to a set of training data, ( X, Y ) for Y =
Revised: When training a CSN, we assume access to a set of training data, ( X, Y ) for Y =

Original: ( Y 1 , Y 2 , ...
Revised: ( Y 1 , Y 2 , ...

Original: Y c ) .
Revised: Y c ) .

Original: For each entry in the dataset, there is an input x and a label y i , for each of c classiﬁcation tasks.
Revised: For each entry in the dataset, there is an input x and a label y i , for each of c classiﬁcation tasks.

Original: We trained CSNs in an end-to-end manner to minimize a single loss function, deﬁned in Equation 2.
Revised: We trained CSNs in an end-to-end manner to minimize a single loss function, deﬁned in Equation 4.

Original: The four terms in the loss function were as follows: 1) reconstruction error;
Revised: The four terms in the loss function were as follows: 1) reconstruction error;

Original: 2) the loss introduced for the PCN, encouraging classiﬁcation accuracy and the clustering of encodings around prototypes (applied within each concept subspace); 3) a KL divergence regularization term; and 4) a term penalizing alignment between concept subspaces.
Revised: 2) the loss introduced for the PCN, encouraging classiﬁcation accuracy and the clustering of encodings around prototypes (applied within each concept subspace); 3) a KL divergence regularization term; and 4) a term penalizing alignment between concept subspaces.

Original: Each term was weighted by a choice of real- valued λ s. We emphasize that the PCN loss — clustering and classiﬁcation accuracy — is calculated within each concept subspace using the projections of encodings; thus, encodings were encouraged to cluster around prototypes only along dimensions within the subspace.
Revised: Each term was weighted by a choice of real- valued λ s. We emphasize that the PCN loss — clustering and classiﬁcation accuracy, deﬁned in Equation 7 of Li et al. (2018) — is calculated within each concept subspace using the projections of encodings; thus, encodings were encouraged to cluster around prototypes only along dimensions within the subspace.

Original: The encoder, decoder, and prototype weights were trained simultaneously.
Revised: The encoder, decoder, and prototype weights were trained simultaneously.

Original: [Equation]
Revised: [Equation]

Original: The KL regularization term mimics training losses often used in VAEs that penalize the divergence between the distribution of encodings and a zero-mean unit Gaussian (Kingma & Welling, 2014).
Revised: The KL regularization term mimics training losses often used in VAEs that penalize the divergence between the distribution of encodings and a zero-mean unit Gaussian (Kingma & Welling, 2014).

Original: In our case, we wished to induce a similar distribution of encodings, but centered around prototypes rather than the origin.
Revised: In our case, we wished to induce a similar distribution of encodings, but centered around prototypes rather than the origin.

Original: Furthermore, rather than induce a Gaussian distribution within a concept subspace (which would dictate classiﬁcation probabilities and therefore potentially worsen classiﬁcation accuracy), we wished to regularize the out-of-subspace components of encodings.
Revised: Furthermore, rather than induce a Gaussian distribution within a concept subspace (which would dictate classiﬁcation probabilities and therefore potentially worsen classiﬁcation accuracy), we wished to regularize the out-of-subspace components of encodings.

Original: Concretely, we implemented this regularization loss in three steps.
Revised: Concretely, we implemented this regularization loss in three steps.

Original: First, we computed the orthogonal component of an encoding as z orth =
Revised: First, we computed the orthogonal component of an encoding as z orth =

Original: z − z proj .
Revised: z − z proj .

Original: We then computed the KL divergence between the distribution of z orth and unit Gaussians centered at each prototype in each subspace.
Revised: We then computed the KL divergence between the distribution of z orth and unit Gaussians centered at each prototype in each subspace.

Original: Finally, we took the softmax over distances between encodings and prototypes in order to only select the  prototype  the encoding was closest to; we then multiplied the softmaxmatrix by the divergences toonly enforce that encodings were distributed as unit Gaussians around the nearest prototype in each subspace.
Revised: Finally, we took the softmax over distances between encodings and prototypes in order to only select the closest prototype to the encoding; we then multiplied the softmax by the divergences to enforce that encodings were distributed as unit Gaussians around the nearest prototype in each subspace.

Original: Together, these operations led the distributions out of each subspace to conform to unit Gaussians around each prototype.
Revised: Together, these operations led the distributions out of each subspace to conform to unit Gaussians around each prototype.

Original: As conﬁrmed in later experiments, this component was crucial in training fair classiﬁers.
Revised: As conﬁrmed in later experiments, this component was crucial in training fair classiﬁers.

Original: 3. H IERARCHICAL AND F AIR C LASSIFICATION
Revised: 3. H IERARCHICAL AND F AIR C LASSIFICATION

Original: We conclude this section by demonstrating how CSNs may support hierarchical or fair classiﬁcations.
Revised: We conclude this section by demonstrating how CSNs may support hierarchical or fair classiﬁcations.

Original: Hierarchical and fair classiﬁcation may be thought of as extremes along a spectrum of concept alignment.
Revised: Hierarchical and fair classiﬁcation may be thought of as extremes along a spectrum of concept alignment.

Original: In hierarchical classiﬁcation, concepts are highly aligned and therefore parallel: the difference between a toucan and a Dalmatian is similar to the difference between a generic bird and dog.
Revised: In hierarchical classiﬁcation, concepts are highly aligned and therefore parallel: the difference between a toucan and a Dalmatian is similar to the difference between a generic bird and dog, and so the vector differences between prototypes associated with different classes should also be parallel (e.g., “bird” - “dog” = “toucan” - “Dalmatian.”).

Original: In fair classiﬁcation, concepts are not aligned: switching belief about someone’s sex should not alter predictions about their income.
Revised: In fair classiﬁcation, concepts are not aligned: switching belief about someone’s sex should not alter predictions about their income.

Original: Thus, based on the classiﬁcation task, moving an encoding relative to one subspace should either affect (for hierarchical) or not affect (for fair) that encoding’s projection onto the other subspace.
Revised: Thus, based on the classiﬁcation task, moving an encoding relative to one subspace should either affect (for hierarchical) or not affect (for fair) that encoding’s projection onto the other subspace.

Original: We provide a geometric interpretation of these two tasks in Figure 1 b and d.
Revised: We provide a geometric interpretation of these two tasks in Figure 1 b and d.

Original: CSNs can be trained to adopt either form of concept relationship by penalizing or encouraging concept subspace alignment (already present as a ( Q i , Q j ) in the training loss).
Revised: CSNs can be trained to adopt either form of concept relationship by penalizing or encouraging concept subspace alignment (already present as a ( Q i , Q j ) in the training loss).

Original: Our single model reconciles these two types of problems by viewing them as opposite extremes along a spectrum of concept relationships that our technique is able to learn; this is the main contribution of our work.
Revised: Our single model reconciles these two types of problems by viewing them as opposite extremes along a spectrum of concept relationships that our technique is able to learn; this is the main contribution of our work.

Original:  R ESULTS
Revised:  R ESULTS

Original: Our experiments were divided in four parts.
Revised: Our experiments were divided in four parts.

Original: First, we demonstrated how CSNs matched standard performance on single classiﬁcation tasks: in other words, that using a CSN did not degrade performance.
Revised: First, we demonstrated how CSNs matched standard performance on single classiﬁcation tasks: in other words, that using a CSN did not degrade performance.

Original: We omit these unsurprising results from the paper; full details are included in Appendix A.
Revised: We omit these unsurprising results from the paper; full details are included in Appendix A.

Original: Second, we showed that CSNs matched state-of-the-art performance in two fair classiﬁcation tasks.
Revised: Second, we showed that CSNs matched state-of-the-art performance in two fair classiﬁcation tasks.

Original: Third, we used CSNs for hierarchical classiﬁcation tasks, exceeding performance demonstrated by
Revised: Third, we used CSNs for hierarchical classiﬁcation tasks, exceeding performance demonstrated by

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: prior art along several metrics.
Revised: prior art along several metrics.

Original: Fourth, we showed how CSNs enabled both fair and hierarchical classiﬁcation in a dataset describing human motion in an assembly task that exploited hierarchical knowledge while preserving participant anonymity.
Revised: Fourth, we showed how CSNs enabled both fair and hierarchical classiﬁcation in a dataset describing human motion in an assembly task that exploited hierarchical knowledge while preserving participant anonymity.

Original: Implementation details of CSNs in all experiments are included in Appendix F.
Revised: Implementation details of CSNs in all experiments are included in Appendix F.

Original: 4. F AIR C LASSIFICATION
Revised: 4. F AIR C LASSIFICATION

Original: We evaluated CSN’s performance in fair classiﬁcation tasks in the Adult and German datasets.
Revised: We evaluated CSN’s performance in fair classiﬁcation tasks in the Adult and German datasets.

Original: These datasets are commonly used in fairness literature and contain data that can be used to predict people’s income or credit risks (Dua & Graff, 2017).We compared CSN performance to our implementations of an advesarial purging technique (Adv.), the variational fair autoencoder (VFAE), Wasserstein
Revised: These datasets are commonly used in fairness literature and contain data that can be used to predict people’s income or credit risks (Dua & Graff, 2017).We compared CSN performance to our implementations of an advesarial purging technique (Adv.), the variational fair autoencoder (VFAE), Wasserstein

Original: Fair Classiﬁcation (Wass. DB), and a mutual-information-based fairness approach (FR Train) (Xie et al., 2017; Zemel et al., 2016; Jiang et al., 2020; Roh et al., 2020).
Revised: Fair Classiﬁcation (Wass. DB), and a mutual-information-based fairness approach (FR Train) (Xie et al., 2017; Zemel et al., 2016; Jiang et al., 2020; Roh et al., 2020).

Original: Implementation details of fair classiﬁcation baselines and full results including standard deviations are included in Appendix G.
Revised: Implementation details of fair classiﬁcation baselines and full results including standard deviations are included in Appendix G.

Original: For the Adult dataset, the protected attribute was sex, and for the German dataset, the protected attribute was a binary variable indicating whether the person was older than 25 years of age.
Revised: For the Adult dataset, the protected attribute was sex, and for the German dataset, the protected attribute was a binary variable indicating whether the person was older than 25 years of age.

Original: In evaluation, we measured y Acc., the accuracy of predicting income or credit, s Acc., the accuracy of a linear classiﬁer trained to predict the protected ﬁeld from the latent space, disparate impact (DI), as deﬁned in Roh et al.
Revised: In evaluation, we measured y Acc., the accuracy of predicting income or credit, s Acc., the accuracy of a linear classiﬁer trained to predict the protected ﬁeld from the latent space, disparate impact (DI), as deﬁned in Roh et al.

Original: (2020), and demographic disparity (DD-0.5), as deﬁned by Jiang et al.
Revised: (2020), and demographic disparity (DD-0.5), as deﬁned by Jiang et al.

Original: Mean results over 20 trials for both datasets were included in Tables 1 and 2.
Revised: Mean results over 20 trials for both datasets were included in Tables 1 and 2.

Original: In both datasets, we observed that CSNs matched state-of-the-art performance.
Revised: In both datasets, we observed that CSNs matched state-of-the-art performance.

Original: CSNs produced high y Acc., indicating high task performance for predicting income or credit.
Revised: CSNs produced high y Acc., indicating high task performance for predicting income or credit.

Original: Furthermore, fairness measures demonstrate that CSNs purged protected information successfully (low s Acc.) and achieved high D.I. and low
Revised: Furthermore, fairness measures demonstrate that CSNs purged protected information successfully (low s Acc.) and achieved high D.I. and low

Original: DD-0.5, as desired.
Revised: DD-0.5, as desired.

Original: A visualization of the latent space of a fair classiﬁer, trained on the German dataset, is shown in Figure 2 and conﬁrmed that CSNs learned orthogonal concept subspaces.
Revised: A visualization of the latent space of a fair classiﬁer, trained on the German dataset, is shown in Figure 2 and conﬁrmed that CSNs learned orthogonal concept subspaces.

Original: In addition to reproducing the state of the art, we conducted an ablation study to demonstrate the importance of two terms in our training loss: the alignment and KL losses.
Revised: In addition to reproducing the state of the art, we conducted an ablation study to demonstrate the importance of two terms in our training loss: the alignment and KL losses.

Original: Using the German dataset, we trained 20 CSNs, setting the KL, alignment, or both loss weights to 0.
Revised: Using the German dataset, we trained 20 CSNs, setting the KL, alignment, or both loss weights to 0.

Original: The mean results of these trials are reported in Table 3.
Revised: The mean results of these trials are reported in Table 3.

Original: Table 3 demonstrates the necessity of both KL and alignment losses to train fair predictors (with higher disparate impact and lower demographic disparity values).
Revised: Table 3 demonstrates the necessity of both KL and alignment losses to train fair predictors (with higher disparate impact and lower demographic disparity values).

Original: Including both loss terms resulted in the fairest predictors; removing those losses could enable better classiﬁcation accuracy, but at the expense of fairness.
Revised: Including both loss terms resulted in the fairest predictors; removing those losses could enable better classiﬁcation accuracy, but at the expense of fairness.

Original: This conﬁrms geometric intuition: the alignment loss created orthogonal subspaces and the KL regularization created distributional equivalence based on the subspaces.
Revised: This conﬁrms geometric intuition: the alignment loss created orthogonal subspaces and the KL regularization created distributional equivalence based on the subspaces.

Original: Jointly, these losses therefore produced statistical independence.
Revised: Jointly, these losses therefore produced statistical independence.

Original: Table 3 also includes causal analysis of trained CSNs via the ρ metric.
Revised: Table 3 also includes causal analysis of trained CSNs via the ρ metric.

Original: Intuitively, this metric reﬂected the learned correlation between s and y ; it was calculated by updating embeddings in the
Revised: Intuitively, this metric reﬂected the learned correlation between s and y ; it was calculated by updating embeddings in the

Original: CSN latent space along the gradient of s and recording the change in prediction over y .
Revised: CSN latent space along the gradient of s and recording the change in prediction over y .

Original: We reported the ratio of these changes as ρ ; as expected, enforcing orthogonality via alignment loss led to ρ values of 0.
Revised: We reported the ratio of these changes as ρ ; as expected, enforcing orthogonality via alignment loss led to ρ values of 0.

Original: This technique is inspired by work in causally probing language models (e.g., Tucker et al.
Revised: This technique is inspired by work in causally probing language models (e.g., Tucker et al.

Original: ; full details for calculating ρ are included in Appendix D.
Revised: ; full details for calculating ρ are included in Appendix D.

Original: 4. H IERARCHICAL C LASSIFICATION
Revised: 4. H IERARCHICAL C LASSIFICATION

Original: We compared CSNs to our implementation of HPNs and results for Metric-Guided Prototype Learning (MGP), reported by Garnot & Landrieu (2020), for hierarchical classiﬁcation tasks.
Revised: We compared CSNs to our implementation of HPNs and results for Metric-Guided Prototype Learning (MGP), reported by Garnot & Landrieu (2020), for hierarchical classiﬁcation tasks.

Original: Our HPN baseline used the same architecture as CSN (same encoder, decoder, and number of prototypes).
Revised: Our HPN baseline used the same architecture as CSN (same encoder, decoder, and number of prototypes).

Original: It differed from CSNs by setting alignment losses to 0 and by adopting the conditional probability training loss introduced by Hase et al.
Revised: It differed from CSNs by setting alignment losses to 0 and by adopting the conditional probability training loss introduced by Hase et al.

Original: We further included results of a randomly-initialized
Revised: We further included results of a randomly-initialized

Original: CSN under “Init.”
Revised: CSN under “Init.”

Original: in tables.
Revised: in tables.

Original: In these experiments, we sought to test the hypothesis that CSNs with highly aligned subspaces would support hierarchical classiﬁcation, just as orthogonal subspaces enabled fair classiﬁcation.
Revised: In these experiments, we sought to test the hypothesis that CSNs with highly aligned subspaces would support hierarchical classiﬁcation, just as orthogonal subspaces enabled fair classiﬁcation.

Original: In addition to standard accuracy metrics, we measured two aspects of CSNs trained on hierarchical tasks.
Revised: In addition to standard accuracy metrics, we measured two aspects of CSNs trained on hierarchical tasks.

Original: First, we recorded the “average cost” (AC) of errors.
Revised: First, we recorded the “average cost” (AC) of errors.

Original: AC is deﬁned as the mean distance between the predicted and true label in a graph of the hierarchical taxonomy (e.g., if true and predicted label shared a common parent, the cost was 2; if the common ancestor was two levels up, the cost was 4, etc.)
Revised: AC is deﬁned as the mean distance between the predicted and true label in a graph of the hierarchical taxonomy (e.g., if true and predicted label shared a common parent, the cost was 2; if the common ancestor was two levels up, the cost was 4, etc.)

Original: (Garnot & Landrieu, 2020).
Revised: (Garnot & Landrieu, 2020).

Original: Second, we measured the quality of trees derived from the learned prototypes.
Revised: Second, we measured the quality of trees derived from the learned prototypes.

Original: After a CSN was trained, we deﬁned a fully-connected graph G =
Revised: After a CSN was trained, we deﬁned a fully-connected graph G =

Original: ( V , E ) with vertices V = P (cid:83) { 0 } (the set of all prototypes and a point at the origin) and undirected edges between each node with lengths equal to the l 2 distance between nodes in the latent space.
Revised: ( V , E ) with vertices V = P (cid:83) { 0 } (the set of all prototypes and a point at the origin) and undirected edges between each node with lengths equal to the l 2 distance between nodes in the latent space.

Original: We recovered the minimum spanning tree, T , from G , (which is unique given distinct edge lengths, which we observed in all experiments), and converted all edges to directed edges through a global ordering of nodes.
Revised: We recovered the minimum spanning tree, T , from G , (which is unique given distinct edge lengths, which we observed in all experiments), and converted all edges to directed edges through a global ordering of nodes.

Original: Lastly, we calculated the graph edit distance (ED) between isomorphisms of the recovered tree and the ground-truth hierarchical tree (with edges that obeyed the same ordering constraints)
Revised: Lastly, we calculated the graph edit distance (ED) between isomorphisms of the recovered tree and the ground-truth hierarchical tree (with edges that obeyed the same ordering constraints)

Original: (Abu-Aisheh et al., 2015).
Revised: (Abu-Aisheh et al., 2015).

Original: Intuitively, this corresponded to counting how many edges had to be deleted or added to the minimum spanning tree to match the taxonomy tree, ignoring edge lengths, with a minimum value of 0 for perfect matches.
Revised: Intuitively, this corresponded to counting how many edges had to be deleted or added to the minimum spanning tree to match the taxonomy tree, ignoring edge lengths, with a minimum value of 0 for perfect matches.

Original: As a basic test of CSNs in hierarchical classiﬁcation tasks, we created simple hierarchies from the
Revised: As a basic test of CSNs in hierarchical classiﬁcation tasks, we created simple hierarchies from the

Original: MNIST Digit and Fashion datasets.
Revised: MNIST Digit and Fashion datasets.

Original: The Digit dataset used the standard low-level labels of digit, supplemented with high-level labels of parity (two classes); the Fashion dataset used the standard low-level labels for item of clothing, with a ternary label for a high-level classiﬁcation of “tops” (tshirts, pullovers, coats, and shirts), “shoes” (sandals, sneakers, and ankle boots), or “other” (trousers, dresses, and bags).
Revised: The Digit dataset used the standard low-level labels of digit, supplemented with high-level labels of parity (two classes); the Fashion dataset used the standard low-level labels for item of clothing, with a ternary label for a high-level classiﬁcation of “tops” (tshirts, pullovers, coats, and shirts), “shoes” (sandals, sneakers, and ankle boots), or “other” (trousers, dresses, and bags).

Original: Mean results from 10 trials for both MNIST datasets were included in Tables 4 and 5.
Revised: Mean results from 10 trials for both MNIST datasets were included in Tables 4 and 5.

Original: The HPN baselines were implemented using the same number of prototypes as the CSNs being compared against.
Revised: The HPN baselines were implemented using the same number of prototypes as the CSNs being compared against.

Original: Both tables show that CSNs exhibit comparable or better accuracy than HPNs for both the low-level ( Y 0 ) and high-level ( Y 1 ) classiﬁcation tasks.
Revised: Both tables show that CSNs exhibit comparable or better accuracy than HPNs for both the low-level ( Y 0 ) and high-level ( Y 1 ) classiﬁcation tasks.

Original: In addition, the average cost (A.C.) and edit distance (E.D.) values show that CSNs recovered minimum spanning trees that nearly perfectly matched the ground truth tree, and that when CSNs did make errors, they were less “costly” than errors made by HPNs (although admittedly, a dominant force in A.C. is classiﬁcation accuracy alone).
Revised: In addition, the average cost (A.C.) and edit distance (E.D.) values show that CSNs recovered minimum spanning trees that nearly perfectly matched the ground truth tree, and that when CSNs did make errors, they were less “costly” than errors made by HPNs (although admittedly, a dominant force in A.C. is classiﬁcation accuracy alone).

Original: A 2D visualization of the latent space of a CSN trained on the Digit task is shown in Figure 3: encodings for particular digits clustered around prototypes for those digits (X), while prototypes for even and odd digits (circles) separated the digit clusters into the left and right halves of the latent space.
Revised: A 2D visualization of the latent space of a CSN trained on the Digit task is shown in Figure 3: encodings for particular digits clustered around prototypes for those digits (X), while prototypes for even and odd digits (circles) separated the digit clusters into the left and right halves of the latent space.

Original: Visualizations of latent spaces for more fair and hierarchical classiﬁcation tasks are included in Appendix C; they conﬁrmed the theoretical derivations of orthogonal and parallel subspaces.
Revised: Visualizations of latent spaces for more fair and hierarchical classiﬁcation tasks are included in Appendix C; they conﬁrmed the theoretical derivations of orthogonal and parallel subspaces.

Original: Lastly, we trained 10 CSNs and HPNs on the substantially more challenging CIFAR100 dataset.
Revised: Lastly, we trained 10 CSNs and HPNs on the substantially more challenging CIFAR100 dataset.

Original: The dataset is inherently hierarchical: the 100 low-level classes are grouped into 20 higher-level
Revised: The dataset is inherently hierarchical: the 100 low-level classes are grouped into 20 higher-level

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: classes, each of size 5.
Revised: classes, each of size 5.

Original: Using a resnet18 encoder, pre-trained on ImageNet, in conjunction withprototypes for low-level classiﬁcation and 20 for high-level, we trained CSNs and HPNs.
Revised: Using a resnet18 encoder, pre-trained on ImageNet, in conjunction withprototypes for low-level classiﬁcation and 20 for high-level, we trained CSNs and HPNs.

Original: CSNs additionally used an alignment loss weight of -10 to encourage parallelism between the two concept subspaces.
Revised: CSNs additionally used an alignment loss weight of -10 to encourage parallelism between the two concept subspaces.

Original: The mean results over 10 trials are shown in the top half of Table 6.
Revised: The mean results over 10 trials are shown in the top half of Table 6.

Original: We also compared CSNs to MGP and other hierarchical classiﬁers using the CIFAR100 dataset and a deeper hierarchy, consisting of 5 levels of sizes 100, 20, 8, 4, and 2, as done by Garnot & Landrieu (2020).
Revised: We also compared CSNs to MGP and other hierarchical classiﬁers using the CIFAR100 dataset and a deeper hierarchy, consisting of 5 levels of sizes 100, 20, 8, 4, and 2, as done by Garnot & Landrieu (2020).

Original: The additional information provided by this deeper hierarchy resulted in improved classiﬁcation performance.
Revised: The additional information provided by this deeper hierarchy resulted in improved classiﬁcation performance.

Original: Median results (as done by Garnot & Landrieu (2020)) for 10 CSNs using this dataset are shown in the bottom half of Table 6.
Revised: Median results (as done by Garnot & Landrieu (2020)) for 10 CSNs using this dataset are shown in the bottom half of Table 6.

Original: Changing the hierarchy changed how average cost was calculated, so values from the top and bottom halves of the table should not be compared.
Revised: Changing the hierarchy changed how average cost was calculated, so values from the top and bottom halves of the table should not be compared.

Original: Within the bottom half, we note that CSNs outperformed MGP on both A.C. and classiﬁcation accuracy.
Revised: Within the bottom half, we note that CSNs outperformed MGP on both A.C. and classiﬁcation accuracy.

Original: Furthermore, according to values generated in the extensive experiments conducted by Garnot & Landrieu (2020), CSNs outperformed numerous other baselines, including HXE and soft-labels (Bertinetto et al.
Revised: Furthermore, according to values generated in the extensive experiments conducted by Garnot & Landrieu (2020), CSNs outperformed numerous other baselines, including HXE and soft-labels (Bertinetto et al.

Original: , YOLO (Redmon et al.
Revised: , YOLO (Redmon et al.

Original: (2016)), and a hyperspherical prototype network (Mettes et al.
Revised: (2016)), and a hyperspherical prototype network (Mettes et al.

Original: (2019)), all of which were built upon a resnet18 pretrained on ImageNet.
Revised: (2019)), all of which were built upon a resnet18 pretrained on ImageNet.

Original: In fact, our
Revised: In fact, our

Original: CSNs achieve SOTA classiﬁcation accuracy for any classiﬁer built upon a resnet18 backbone, without data augmentation.
Revised: CSNs achieve SOTA classiﬁcation accuracy for any classiﬁer built upon a resnet18 backbone, without data augmentation.

Original: Furthermore, the decrease in A.C. is especially surprising given that other techniques explicitly optimized for average cost reductions, while CSNs merely trained on classiﬁcation at each level.
Revised: Furthermore, the decrease in A.C. is especially surprising given that other techniques explicitly optimized for average cost reductions, while CSNs merely trained on classiﬁcation at each level.

Original: Notably, the decrease in A.C. is not fully explained by the increase in accuracy, indicating that CSN not only exhibited higher accuracy but also, when it did make mistakes, those mistakes were less severe.
Revised: Notably, the decrease in A.C. is not fully explained by the increase in accuracy, indicating that CSN not only exhibited higher accuracy but also, when it did make mistakes, those mistakes were less severe.

Original: Lastly, we note that CSNs support a range of learned relationships other than fair or hierarchical.
Revised: Lastly, we note that CSNs support a range of learned relationships other than fair or hierarchical.

Original: The varying values of ρ in Table 3 indicate that CSNs may learn different relationships when alignment loss is set to 0.
Revised: The varying values of ρ in Table 3 indicate that CSNs may learn different relationships when alignment loss is set to 0.

Original: However, in general, one could train models to learn desired relationships by penalizing or rewarding alignment relative to some intercept.
Revised: However, in general, one could train models to learn desired relationships by penalizing or rewarding alignment relative to some intercept.

Original: We trained and evaluated such models in Appendix E and found that models indeed learned the desired alignment.
Revised: We trained and evaluated such models in Appendix E and found that models indeed learned the desired alignment.

Original: 4. F AIR AND H IERARCHICAL C LASSIFICATION
Revised: 4. F AIR AND H IERARCHICAL C LASSIFICATION

Original: Prior experiments demonstrated how CSNs could solve different classiﬁcation problems separately; in this section, we applied a single CSN to a task that required it to use both fair and hierarchical classiﬁcation.
Revised: Prior experiments demonstrated how CSNs could solve different classiﬁcation problems separately; in this section, we applied a single CSN to a task that required it to use both fair and hierarchical classiﬁcation.

Original: Intuitively, fairness was used to protect privacy, while hierarchical structure was used for better performance.
Revised: Intuitively, fairness was used to protect privacy, while hierarchical structure was used for better performance.

Original: We used a dataset describing human motion in a bolt-placement task.
Revised: We used a dataset describing human motion in a bolt-placement task.

Original: The dataset was gathered from a similar setup to (Lasota et al., 2014) - motion was recorded at 50 Hz, using the 3D location of each of the 8 volunteer participant’s gloved right hands as they reached towards one of 8 holes arranged
Revised: The dataset was gathered from a similar setup to (Lasota et al., 2014) - motion was recorded at 50 Hz, using the 3D location of each of the 8 volunteer participant’s gloved right hands as they reached towards one of 8 holes arranged

Original: [Table]
Revised: [Table]

Original: in a line to place a bolt in the hole.
Revised: in a line to place a bolt in the hole.

Original: The bolt holes may be thought of hierarchically by dividing destinations into left vs. right (LR) groupings, in addition to the label of the speciﬁc hole.
Revised: The bolt holes may be thought of hierarchically by dividing destinations into left vs. right (LR) groupings, in addition to the label of the speciﬁc hole.

Original: Initial exploration of the dataset showed promising results for prototype-based classiﬁcation: the target locations were identiﬁed with 81% accuracy, and further analysis showed that prototypes corresponded to human-like motions (details in Appendix B).
Revised: Initial exploration of the dataset showed promising results for prototype-based classiﬁcation: the target locations were identiﬁed with 81% accuracy, and further analysis showed that prototypes corresponded to human-like motions (details in Appendix B).

Original: Troublingly, however a trained CSN could identify the participant with over 60% accuracy, which posed privacy concerns.
Revised: Troublingly, however a trained CSN could identify the participant with over 60% accuracy, which posed privacy concerns.

Original: Nevertheless, from a robotic safety perspective, it is important for robots to exploit as much information as possible to avoid collisions with humans.
Revised: Nevertheless, from a robotic safety perspective, it is important for robots to exploit as much information as possible to avoid collisions with humans.

Original: Ultimately, we wished to predict which hole a participant was reaching towards given the pastsecond of their motion, while preserving privacy and exploiting hierarchical structure.
Revised: Ultimately, we wished to predict which hole a participant was reaching towards given the pastsecond of their motion, while preserving privacy and exploiting hierarchical structure.

Original: Thus, we designed a CSN with three concept subspaces: one for predicting the bolt (8 prototypes), one for predicting the high-level grouping of a left or right destination (2 prototypes) and one for predicting the participant i
Revised: Thus, we designed a CSN with three concept subspaces: one for predicting the bolt (8 prototypes), one for predicting the high-level grouping of a left or right destination (2 prototypes) and one for predicting the participant i

Original: d (8 prototypes).
Revised: d (8 prototypes).

Original: We enforced that the bolt and LR subspaces were parallel while the bolt and participant subpsaces were orthogonal.
Revised: We enforced that the bolt and LR subspaces were parallel while the bolt and participant subpsaces were orthogonal.

Original: Results from our experiments are presented in Table 7.
Revised: Results from our experiments are presented in Table 7.

Original: Means and standard deviations over 10 trials for each row are reported.
Revised: Means and standard deviations over 10 trials for each row are reported.

Original: (A.C. was calculated only for prediction errors, due to the large differences in accuracy rates across models.)
Revised: (A.C. was calculated only for prediction errors, due to the large differences in accuracy rates across models.)

Original: When training a CSN with no constraints on subspace alignment, we found a highly accurate but unfair predictor (81% accuracy for bolt location, but sub-optimal disparate impact and demographic disparity values).
Revised: When training a CSN with no constraints on subspace alignment, we found a highly accurate but unfair predictor (81% accuracy for bolt location, but sub-optimal disparate impact and demographic disparity values).

Original: Switching the CSNs to be fair classiﬁers by only enforcing orthogonality between bolts and participants yielded a fair classiﬁer (illustrated by ρ , D.I., and DD-0.5), but with much worse bolt prediction accuracy (44%).
Revised: Switching the CSNs to be fair classiﬁers by only enforcing orthogonality between bolts and participants yielded a fair classiﬁer (illustrated by ρ , D.I., and DD-0.5), but with much worse bolt prediction accuracy (44%).

Original: However, by using a hierarchical subspace for LR groupings, the ﬁnal CSN both improved classiﬁcation accuracy and decreased the average cost of errors, while maintaining desired fairness characteristics.
Revised: However, by using a hierarchical subspace for LR groupings, the ﬁnal CSN both improved classiﬁcation accuracy and decreased the average cost of errors, while maintaining desired fairness characteristics.

Original:  C ONTRIBUTIONS
Revised:  C ONTRIBUTIONS

Original: The primary contribution of this work is a new type of model, the Concept Subspace Network, that supports inter-concept relationships.
Revised: The primary contribution of this work is a new type of model, the Concept Subspace Network, that supports inter-concept relationships.

Original: CSNs’ design, motivated by prior art in interpretable neural network models, use sets of prototypes to deﬁne concept subspaces in neural net latent spaces.
Revised: CSNs’ design, motivated by prior art in interpretable neural network models, use sets of prototypes to deﬁne concept subspaces in neural net latent spaces.

Original: The relationships between these subspaces may be controlled during training in order to guide desired model characteristics.
Revised: The relationships between these subspaces may be controlled during training in order to guide desired model characteristics.

Original: Critically, we note that two popular classiﬁcation problems — fair and hierarchical classiﬁcation — are located at either end of a spectrum of concept relationships, allowing
Revised: Critically, we note that two popular classiﬁcation problems — fair and hierarchical classiﬁcation — are located at either end of a spectrum of concept relationships, allowing

Original: CSNs to solve each type of problem in a manner on par with techniques that had previously been designed to solve only one.
Revised: CSNs to solve each type of problem in a manner on par with techniques that had previously been designed to solve only one.

Original: Furthermore, a single CSN may exhibit multiple concept relationships, as demonstrated in a privacy-preserving hierarchical classiﬁcation task.
Revised: Furthermore, a single CSN may exhibit multiple concept relationships, as demonstrated in a privacy-preserving hierarchical classiﬁcation task.

Original: While we have demonstrated the utility of CSNs within several domains, numerous extensions could improve their design.
Revised: While we have demonstrated the utility of CSNs within several domains, numerous extensions could improve their design.

Original: First, the idea of subspace alignment could be applied to non-Euclidean geometries like hyperbolic latent spaces that are sometimes used for hierarchical classiﬁcation.
Revised: First, the idea of subspace alignment could be applied to non-Euclidean geometries like hyperbolic latent spaces that are sometimes used for hierarchical classiﬁcation.

Original: Second, CSNs could additionally beneﬁt from relaxation of some simplifying assumptions: notably, allowing for more complex relationships rather than those deﬁned by subspace cosine similarity, or using adversarial approaches for distributional regularization rather than only supporting unit
Revised: Second, CSNs could additionally beneﬁt from relaxation of some simplifying assumptions: notably, allowing for more complex relationships rather than those deﬁned by subspace cosine similarity, or using adversarial approaches for distributional regularization rather than only supporting unit

Original: Gaussians.
Revised: Gaussians.

Original: Lastly, we note that CSNs, while designed with ethical applications such as fair classiﬁcation in mind, may lead to undesired consequences.
Revised: Lastly, we note that CSNs, while designed with ethical applications such as fair classiﬁcation in mind, may lead to undesired consequences.

Original: For example, malicious actors could enforce undesirable concept relationships, or simply observing emergent concept relationships within a CSN could reinforce undesirable correlations.
Revised: For example, malicious actors could enforce undesirable concept relationships, or simply observing emergent concept relationships within a CSN could reinforce undesirable correlations.

Original: In addition, although prototypes encourage interpretability, which we posit can be used for good, the reductive nature of prototypes may be problematic when classifying human-related data (e.g., the COMPAS fair classiﬁcation task we avoided).
Revised: In addition, although prototypes encourage interpretability, which we posit can be used for good, the reductive nature of prototypes may be problematic when classifying human-related data (e.g., the COMPAS fair classiﬁcation task we avoided).

Original: A S INGLE -C ONCEPT C LASSIFICATION B ASELINES
Revised: A S INGLE -C ONCEPT C LASSIFICATION B ASELINES

Original: In addition to the specialized fair and hierarchical classiﬁcation tasks, we tested CSNs on two standard classiﬁcation tasks: identifying digits in the MNIST Digit dataset, and identifying one ofcategories in the CIFAR100 dataset.
Revised: In addition to the specialized fair and hierarchical classiﬁcation tasks, we tested CSNs on two standard classiﬁcation tasks: identifying digits in the MNIST Digit dataset, and identifying one ofcategories in the CIFAR100 dataset.

Original: There were no concept relationships present because this was a single classiﬁcation task; instead, the tests established that using a CSN did not degrade classiﬁcation performance relative to PCNs or other neural architectures.
Revised: There were no concept relationships present because this was a single classiﬁcation task; instead, the tests established that using a CSN did not degrade classiﬁcation performance relative to PCNs or other neural architectures.

Original: On the Digit dataset, we trained a CSN using the same encoding and decoding layer architectures with 20 prototypes (two for each digit) and applied the same Gaussian distortions to training images as Li et al.
Revised: On the Digit dataset, we trained a CSN using the same encoding and decoding layer architectures with 20 prototypes (two for each digit) and applied the same Gaussian distortions to training images as Li et al.

Original: Over ﬁve trials, training for 50 epochs with batches of size 250, we achieved the same mean classiﬁcation accuracy as PCN (99.22%), demonstrating that the use of a CSN did not worsen classiﬁcation accuracy (Li et al., 2018).
Revised: Over ﬁve trials, training for 50 epochs with batches of size 250, we achieved the same mean classiﬁcation accuracy as PCN (99.22%), demonstrating that the use of a CSN did not worsen classiﬁcation accuracy (Li et al., 2018).

Original: On the CIFAR100 dataset, we extended a resnet18 backbone (pretrained on ImageNet) as our encoder with 100 prototypes, 1 for each class, and trained 10 models for 60 epochs He et al.
Revised: On the CIFAR100 dataset, we extended a resnet18 backbone (pretrained on ImageNet) as our encoder with 100 prototypes, 1 for each class, and trained 10 models for 60 epochs He et al.

Original: We achieved a mean classiﬁcation accuracy of 76%, the standard result for networks built upon a resnet18 framework (Hase et al., 2019).
Revised: We achieved a mean classiﬁcation accuracy of 76%, the standard result for networks built upon a resnet18 framework (Hase et al., 2019).

Original: Thus, CSNs exhibited high performance in a challenging domain, matching performance of normal networks, with the beneﬁt of interpretable prototypes.
Revised: Thus, CSNs exhibited high performance in a challenging domain, matching performance of normal networks, with the beneﬁt of interpretable prototypes.

Original: B V ISUALIZING D ECODED P ROTOTYPES
Revised: B V ISUALIZING D ECODED P ROTOTYPES

Original: Because CSNs are built upon prototype-based classiﬁcation, they are at least as interpretable as prior art, such as PCNs.
Revised: Because CSNs are built upon prototype-based classiﬁcation, they are at least as interpretable as prior art, such as PCNs.

Original: In this section, we demonstrate how prototypes may be decoded to visualize their representations.
Revised: In this section, we demonstrate how prototypes may be decoded to visualize their representations.

Original: These ﬁgures were generated by decoding prototypes from the models used throughout the paper.
Revised: These ﬁgures were generated by decoding prototypes from the models used throughout the paper.

Original: Figure 4 shows the ﬁrst 10 prototypes from the MNIST digit classiﬁer in Appendix A. Unlike PCNs,
Revised: Figure 4 shows the ﬁrst 10 prototypes from the MNIST digit classiﬁer in Appendix A. Unlike PCNs,

Original: CSNs beneﬁt from an inductive bias that leads to an equal number of prototypes per class.
Revised: CSNs beneﬁt from an inductive bias that leads to an equal number of prototypes per class.

Original: Figure 5 depicts the decoded prototypes when training a CSN to predict human reaching motions, as described in Section 3.4.
Revised: Figure 5 depicts the decoded prototypes when training a CSN to predict human reaching motions, as described in Section 3.4.

Original: This model was only trained on motion prediction, without using fair or hierarchical training terms.
Revised: This model was only trained on motion prediction, without using fair or hierarchical training terms.

Original: Interestingly, by over-parametrizing the number of prototypes (there were only 8 possible destinations, but twice as many prototypes), the model learned different forms of trajectories that reached towards the same destination: short movements near the targets, and longer loops when reaching from farther away.
Revised: Interestingly, by over-parametrizing the number of prototypes (there were only 8 possible destinations, but twice as many prototypes), the model learned different forms of trajectories that reached towards the same destination: short movements near the targets, and longer loops when reaching from farther away.

Original: C V ISUALIZING L EARNED L ATENT S PACES
Revised: C V ISUALIZING L EARNED L ATENT S PACES

Original: In addition to decoding prototypes, we visualized the latent spaces of trained classiﬁers.
Revised: In addition to decoding prototypes, we visualized the latent spaces of trained classiﬁers.

Original: For the purposes of visualization, we trained new models from scratch, using only 2D latent spaces.
Revised: For the purposes of visualization, we trained new models from scratch, using only 2D latent spaces.

Original: Encodings and prototypes for both fair classiﬁcation tasks, as well as the digit and fashion hierarchical classiﬁcation tasks, are shown in Figure 6.
Revised: Encodings and prototypes for both fair classiﬁcation tasks, as well as the digit and fashion hierarchical classiﬁcation tasks, are shown in Figure 6.

Original: In all diagrams, encodings of test inputs are denoted by small colored dots.
Revised: In all diagrams, encodings of test inputs are denoted by small colored dots.

Original: All classiﬁcation tasks used 2 sets of prototypes: we depicted one set of prototypes as large black dots, and the other as X’s.
Revised: All classiﬁcation tasks used 2 sets of prototypes: we depicted one set of prototypes as large black dots, and the other as X’s.

Original: The arrangement of the prototypes in the latent spaces conﬁrms that CSNs have learned the right concept alignment.
Revised: The arrangement of the prototypes in the latent spaces conﬁrms that CSNs have learned the right concept alignment.

Original: Speciﬁcally, for the fair classiﬁcation tasks, the X’s form a line segment that is orthogonal to the line formed by the black dots.
Revised: Speciﬁcally, for the fair classiﬁcation tasks, the X’s form a line segment that is orthogonal to the line formed by the black dots.

Original: This orthogonality leads to fairness, as discussed in our paper.
Revised: This orthogonality leads to fairness, as discussed in our paper.

Original: In the hierarchical domains, we similarly observed that CSNs had learned the “right” latent structure.
Revised: In the hierarchical domains, we similarly observed that CSNs had learned the “right” latent structure.

Original: In these domains, the black dots denoted prototypes for high-level classiﬁcation (such as even vs. odd).
Revised: In these domains, the black dots denoted prototypes for high-level classiﬁcation (such as even vs. odd).

Original: We observed that the lower-level prototypes (e.g., for digit), denoted by ‘X’s were clustered around the high level prototypes.
Revised: We observed that the lower-level prototypes (e.g., for digit), denoted by ‘X’s were clustered around the high level prototypes.

Original: As a whole, these visualizations conﬁrm that CSNs learn the desired latent structure, all controlled by changing the alignment loss weight.
Revised: As a whole, these visualizations conﬁrm that CSNs learn the desired latent structure, all controlled by changing the alignment loss weight.

Original: D C ALCULATING L EARNED C ASUAL R ELATIONSHIPS
Revised: D C ALCULATING L EARNED C ASUAL R ELATIONSHIPS

Original: In Sections 4.1 and 4.3, we report a metric, ρ , to denote the learned causal relationship between concepts.
Revised: In Sections 4.1 and 4.3, we report a metric, ρ , to denote the learned causal relationship between concepts.

Original: Here, we explain how we calculate ρ in greater detail.
Revised: Here, we explain how we calculate ρ in greater detail.

Original: Intuitively, ρ corresponds to the mean change in belief for one classiﬁcation task divided by changes in belief for another classiﬁcation task.
Revised: Intuitively, ρ corresponds to the mean change in belief for one classiﬁcation task divided by changes in belief for another classiﬁcation task.

Original: For example, in fair classiﬁcation, prediction of a person’s credit risk should not change based on changes in belief over the person’s age; this notion corresponds to ρ = 0 .
Revised: For example, in fair classiﬁcation, prediction of a person’s credit risk should not change based on changes in belief over the person’s age; this notion corresponds to ρ = 0 .

Original: We calculate ρ in CSNs using a technique inspired by Tucker et al.
Revised: We calculate ρ in CSNs using a technique inspired by Tucker et al.

Original: In that work, the authors studied if a language model’s output changed when the model’s internal representation changed according to syntactic principles.
Revised: In that work, the authors studied if a language model’s output changed when the model’s internal representation changed according to syntactic principles.

Original: In our work, we change latent representations, z , by taking the gradient of z with respect to the loss of one classiﬁcation task given true label y ∗ , creating a new z (cid:48) taken by moving z along that gradient, and then calculating the new classiﬁcation likelihoods using z (cid:48) .
Revised: In our work, we change latent representations, z , by taking the gradient of z with respect to the loss of one classiﬁcation task given true label y ∗ , creating a new z (cid:48) taken by moving z along that gradient, and then calculating the new classiﬁcation likelihoods using z (cid:48) .

Original: For simplicity, we limit our analysis to CSNs with two concept subspaces.
Revised: For simplicity, we limit our analysis to CSNs with two concept subspaces.

Original: We denote the encoding of an input, x , as z = e θ ( x ) .
Revised: We denote the encoding of an input, x , as z = e θ ( x ) .

Original: Prediction for each of the two tasks may be denoted as prediction functions, pred i , for i ∈ [0 , 1] indicating the two tasks; the prediction function corresponds to projecting z into the relevant subspace and calculating distances to prototypes, as discussed earlier.
Revised: Prediction for each of the two tasks may be denoted as prediction functions, pred i , for i ∈ [0 , 1] indicating the two tasks; the prediction function corresponds to projecting z into the relevant subspace and calculating distances to prototypes, as discussed earlier.

Original: Using this notation, we deﬁne ρ formally:
Revised: Using this notation, we deﬁne ρ formally:

Original: [Equation]
Revised: [Equation]

Original: Thus, ρ captures how the model’s change in belief about one attribute affects its change in belief over another attribute, in other words the causal learned relationship between prediction tasks.
Revised: Thus, ρ captures how the model’s change in belief about one attribute affects its change in belief over another attribute, in other words the causal learned relationship between prediction tasks.

Original: E C ORRELATED -C ONCEPT C LASSIFICATION B ASELINES
Revised: E C ORRELATED -C ONCEPT C LASSIFICATION B ASELINES

Original: A single CSN may be used to perform multiple classiﬁcation tasks simultaneously without explicitly guiding concept relationships.
Revised: A single CSN may be used to perform multiple classiﬁcation tasks simultaneously without explicitly guiding concept relationships.

Original: In the Adult and German fair classiﬁcation domains, CSNs predicted both s , the protected ﬁeld, and y , the desired ﬁnal prediction, while we explicitly guided the learned concept relationships to enforce fairness.
Revised: In the Adult and German fair classiﬁcation domains, CSNs predicted both s , the protected ﬁeld, and y , the desired ﬁnal prediction, while we explicitly guided the learned concept relationships to enforce fairness.

Original: In a separate set of experiments conducted on the same datasets, we demonstrated how CSNs can learn more complex concept relationships.
Revised: In a separate set of experiments conducted on the same datasets, we demonstrated how CSNs can learn more complex concept relationships.

Original: In these experiments, we trained CSNs with two subspaces, each with two prototypes, and set both the KL and alignment losses to zero.
Revised: In these experiments, we trained CSNs with two subspaces, each with two prototypes, and set both the KL and alignment losses to zero.

Original: The CSNs were trained to predict both s and y , using the two subspaces.
Revised: The CSNs were trained to predict both s and y , using the two subspaces.

Original: We recorded prediction accuracy of y and ρ , the learned causal correlation between s and y .
Revised: We recorded prediction accuracy of y and ρ , the learned causal correlation between s and y .

Original: Over 10 trials, for the German and Adult datasets, CSNs achieved mean y classiﬁcation accuracies of 85% and 74%, on par with prior art on these datasets when not enforcing fairness (Xie et al., 2017).
Revised: Over 10 trials, for the German and Adult datasets, CSNs achieved mean y classiﬁcation accuracies of 85% and 74%, on par with prior art on these datasets when not enforcing fairness (Xie et al., 2017).

Original: We also found non-zero ρ : for the German dataset, we found a value of 0.20; for the Adult dataset, a mean value of 0.23.
Revised: We also found non-zero ρ : for the German dataset, we found a value of 0.20; for the Adult dataset, a mean value of 0.23.

Original: An example latent space from a CSN trained on the German dataset in this manner is shown in Figure 7, using the same visualization mechanism as introduced in Appendix C.
Revised: An example latent space from a CSN trained on the German dataset in this manner is shown in Figure 7, using the same visualization mechanism as introduced in Appendix C.

Original: In this example, the model learned a non-zero correlation between prototypes for credit (Xs) andfor an applicant’s age (circles).
Revised: In this example, the model learned a non-zero correlation between prototypes for credit (Xs) and

Original: This type of learned correlation is undesirable in fair classiﬁcation domains but may be useful in other scenarios.

Original: As a demonstration of useful learned correlations, we implemented a CSN in a classiﬁcation task using synthetic data.
Revised: As a demonstration of useful learned correlations, we implemented a CSN in a classiﬁcation task using synthetic data.

Original: Consider a simpliﬁed weather prediction task in which, given noisy observations of temperature and precipitation, a weather station must classify the day as hot or cold and rainy or sunny.
Revised: Consider a simpliﬁed weather prediction task in which, given noisy observations of temperature and precipitation, a weather station must classify the day as hot or cold and rainy or sunny.

Original: In the artiﬁcial world, in the last year of weather data, half of the days are rainy and half are sunny, and all rainy days are cold and all sunny days are hot.
Revised: In the artiﬁcial world, in the last year of weather data, half of the days are rainy and half are sunny, and all rainy days are cold and all sunny days are hot.

Original: Cold days have a true temperature uniformly drawn between 0.0 and 0.2 and warm days have a true temperature uniformly drawn between 0.8 and 1.0.
Revised: Cold days have a true temperature uniformly drawn between 0.0 and 0.2 and warm days have a true temperature uniformly drawn between 0.8 and 1.0.

Original: Similarly, sunny days have a precipitation value drawn uniformly between 0.0 and 0.
Revised: Similarly, sunny days have a precipitation value drawn uniformly between 0.0 and 0.

Original: and rainy days have precipitation values are drawn uniformly between 0.8 and 1.0.
Revised: and rainy days have precipitation values are drawn uniformly between 0.8 and 1.0.

Original: Observations of temperature and precipitation are corrupted by zero-mean gaussian noise with σ = 0 .
Revised: Observations of temperature and precipitation are corrupted by zero-mean gaussian noise with σ = 0 .

Original: Given noisy observations of temperature and precipitation, a model’s task is to predict binary labels for whether the day is hot or cold and rainy or sunny.
Revised: Given noisy observations of temperature and precipitation, a model’s task is to predict binary labels for whether the day is hot or cold and rainy or sunny.

Original: Numerous causal paths could explain observational data recorded from this environment in which hot days are sunny and cold days are rainy: rain could cause cold weather, some latent factor like atmospheric pressure could affect both precipitation and temperature, etc..
Revised: Numerous causal paths could explain observational data recorded from this environment in which hot days are sunny and cold days are rainy: rain could cause cold weather, some latent factor like atmospheric pressure could affect both precipitation and temperature, etc..

Original: Trained simply from observational data, models are unable to learn the right causal relationship between these variables.
Revised: Trained simply from observational data, models are unable to learn the right causal relationship between these variables.

Original: Unlike traditional neural networks, however, CSNs allow humans to encode desirable causal relationships.
Revised: Unlike traditional neural networks, however, CSNs allow humans to encode desirable causal relationships.

Original: We designed a CSN with two concept subspaces (for temperature and precipitation), each with two prototypes.
Revised: We designed a CSN with two concept subspaces (for temperature and precipitation), each with two prototypes.

Original: We then penalized ( a ( Q rs , Q hc ) − √ ρ ∗ ) 2 ; that is, we set an intercept of √ ρ ∗ for the alignment loss between the two subspaces for rainy and sunny ( rs ) and hot and cold ( hc ).
Revised: We then penalized ( a ( Q rs , Q hc ) − √ ρ ∗ ) 2 ; that is, we set an intercept of √ ρ ∗ for the alignment loss between the two subspaces for rainy and sunny ( rs ) and hot and cold ( hc ).

Original: (We used √ ρ ∗ as the notation for setting desired alignment for reasons that will become apparent in the next paragraph.)
Revised: (We used √ ρ ∗ as the notation for setting desired alignment for reasons that will become apparent in the next paragraph.)

Original: In our experiments, we sought to identify if CSNs could learn the desired causal relationship between temperature and precipitation.
Revised: In our experiments, we sought to identify if CSNs could learn the desired causal relationship between temperature and precipitation.

Original: We did so by setting √ ρ ∗ to some value, training CSNs using standard losses, and then measuring if the ρ metric we calculated from the trained CSNs matched ρ ∗ .
Revised: We did so by setting √ ρ ∗ to some value, training CSNs using standard losses, and then measuring if the ρ metric we calculated from the trained CSNs matched ρ ∗ .

Original: We trained 10 CSNs with latent dimension 2 with √ ρ ∗ = 0 .
Revised: We trained 10 CSNs with latent dimension 2 with √ ρ ∗ = 0 .

Original: This corresponds to a cosine value of 0.7, or about 45 degrees.
Revised: This corresponds to a cosine value of 0.7, or about 45 degrees.

Original: This is intuitively interpreted as meaning that for every percentage increase in likelihood in the weather being sunny, the likelihood of it being warm should increase by 0.7 percent.
Revised: This is intuitively interpreted as meaning that for every percentage increase in likelihood in the weather being sunny, the likelihood of it being warm should increase by 0.7 percent.

Original: As desired, the trained CSNs had a mean ρ value of 0.72 (standard deviation 0.14).
Revised: As desired, the trained CSNs had a mean ρ value of 0.72 (standard deviation 0.14).

Original: An example latent space from one such CSN is shown in Figure 7: the two subspaces are arranged at roughlydegrees.
Revised: An example latent space from one such CSN is shown in Figure 7: the two subspaces are arranged at roughlydegrees.

Original: Moving an embedding of a cold and rainy day to increase the likelihood of it begin sunny by 1% increases the predicted likelihood of it being warm by 0 .
Revised: Moving an embedding of a cold and rainy day to increase the likelihood of it begin sunny by 1% increases the predicted likelihood of it being warm by 0 .

Original: This demonstrates that we were able to train CSNs to learn the causal relationship we wished for.
Revised: This demonstrates that we were able to train CSNs to learn the causal relationship we wished for.

Original: Lastly, we note that we repeated these experiments with other √ ρ ∗ and found similar ﬁndings, and if we did not include alignment training loss, CSNs learned arbitrary concept relationships.
Revised: Lastly, we note that we repeated these experiments with other √ ρ ∗ and found similar ﬁndings, and if we did not include alignment training loss, CSNs learned arbitrary concept relationships.

Original: F CSN I MPLEMENTATIONS
Revised: F CSN I MPLEMENTATIONS

Original: In this section, we include details necessary for replication of experimental results that did not ﬁt in the main paper.
Revised: In this section, we include details necessary for replication of experimental results that did not ﬁt in the main paper.

Original: In all experiments, we used random seeds ranging from 0 to the number of trials used for that experiment.
Revised: In all experiments, we used random seeds ranging from 0 to the number of trials used for that experiment.

Original: Although CSNs support several prototypes per class (e.g., 2 prototypes for the digit 0, 2 prototypes for the digit 1, etc.), unless otherwise noted, we used an equal number of prototypes and classes.
Revised: Although CSNs support several prototypes per class (e.g., 2 prototypes for the digit 0, 2 prototypes for the digit 1, etc.), unless otherwise noted, we used an equal number of prototypes and classes.

Original: In the German fairness experiments, we trained for 30 epochs, with batch size 32, with classiﬁcation loss weights of 1, alignment loss of 100 between the two subspaces, and KL lossses of 0.5.
Revised: In the German fairness experiments, we trained for 30 epochs, with batch size 32, with classiﬁcation loss weights of 1, alignment loss of 100 between the two subspaces, and KL lossses of 0.5.

Original: In the
Revised: In the

Original: Adult fairness experiments, we trained for 20 epochs, with batch size 128, with classiﬁcation loss weights of [1 , 0 . 1] for y and s , respectively, alignment loss of 100 between the two subspaces, and
Revised: Adult fairness experiments, we trained for 20 epochs, with batch size 128, with classiﬁcation loss weights of [1 , 0 . 1] for y and s , respectively, alignment loss of 100 between the two subspaces, and

Original: KL losses of 0.1.
Revised: KL losses of 0.1.

Original: For both fair classiﬁcation tasks, the CSN encoders comprised 2 fully-connected layers with ReLu activations and hidden dimension 128, outputting into a 32-dimensional latent space, and the decoder comprised 2, 128-dimensional ReLu layers followed by a sigmoid layer.
Revised: For both fair classiﬁcation tasks, the CSN encoders comprised 2 fully-connected layers with ReLu activations and hidden dimension 128, outputting into a 32-dimensional latent space, and the decoder comprised 2, 128-dimensional ReLu layers followed by a sigmoid layer.

Original: The whole model was trained with an Adam optimizer with default parameters.
Revised: The whole model was trained with an Adam optimizer with default parameters.

Original: For the digit and fashion hierarchical classiﬁcation tasks, CSNs were trained for 20 epochs with batch size 128.
Revised: For the digit and fashion hierarchical classiﬁcation tasks, CSNs were trained for 20 epochs with batch size 128.

Original: CSNs for both datastes used identical architectures to the networks created for the fair classiﬁcation tasks.
Revised: CSNs for both datastes used identical architectures to the networks created for the fair classiﬁcation tasks.

Original: For the CIFAR100 hierarchical classiﬁcation task, we built upon a ResNet18 backbone, as done by
Revised: For the CIFAR100 hierarchical classiﬁcation task, we built upon a ResNet18 backbone, as done by

Original: Garnot & Landrieu (2020).
Revised: Garnot & Landrieu (2020).

Original: The encoder consisted of a ResNet encoder, pre-trained on imagenet, followed by two fully-connected layers with hidden dimension 4096, feeding into a latent space of dimension 100.
Revised: The encoder consisted of a ResNet encoder, pre-trained on imagenet, followed by two fully-connected layers with hidden dimension 4096, feeding into a latent space of dimension 100.

Original: The decoder (and decoding training loss) was removed in this domain to reduce training time.
Revised: The decoder (and decoding training loss) was removed in this domain to reduce training time.

Original: The network was trained using an SGD optimizer with learning rate 0.001 and momentum 0.9, with batch size 32.
Revised: The network was trained using an SGD optimizer with learning rate 0.001 and momentum 0.9, with batch size 32.

Original: Training terminated after 60 epochs or due to early stopping, with a patience of 10 epochs.
Revised: Training terminated after 60 epochs or due to early stopping, with a patience of 10 epochs.

Original: Classiﬁcation loss weights were set to [1 , 5] for classifying the high- and lowlevel categories, respectively.
Revised: Classiﬁcation loss weights were set to [1 , 5] for classifying the high- and lowlevel categories, respectively.

Original: KL losses were set to 0; alignment loss was set to − 10 to encourage parallel subspaces.
Revised: KL losses were set to 0; alignment loss was set to − 10 to encourage parallel subspaces.

Original: For the fair and hierarchical classiﬁcation task with bolts, CSNs used the same architecture as for the fair classiﬁcation task.
Revised: For the fair and hierarchical classiﬁcation task with bolts, CSNs used the same architecture as for the fair classiﬁcation task.

Original: Models were trained for 50 epochs, with batch size 256.
Revised: Models were trained for 50 epochs, with batch size 256.

Original: All classiﬁcation loss weights were set to 1; alignment loss between bolts and LR was set to − 10 and between bolts and participant was set to 100 .
Revised: All classiﬁcation loss weights were set to 1; alignment loss between bolts and LR was set to − 10 and between bolts and participant was set to 100 .

Original: KL losses were set to 2.
Revised: KL losses were set to 2.

Original: G F AIR C LASSIFICATION B ASELINES
Revised: G F AIR C LASSIFICATION B ASELINES

Original: In Section 4.1, we compared CSNs to several fair classiﬁcation baselines on the standard German and Adult datasets.
Revised: In Section 4.1, we compared CSNs to several fair classiﬁcation baselines on the standard German and Adult datasets.

Original: Although the datasets are standard in the literature, there are a wide variety of fairness metrics, only a subset of which each method has published.
Revised: Although the datasets are standard in the literature, there are a wide variety of fairness metrics, only a subset of which each method has published.

Original: Therefore, we implemented each fair classiﬁcation baseline and recorded all metrics of interest for each method.
Revised: Therefore, we implemented each fair classiﬁcation baseline and recorded all metrics of interest for each method.

Original: In this section, we demonstrated the soundness of our implementations by comparing to published metrics.
Revised: In this section, we demonstrated the soundness of our implementations by comparing to published metrics.

Original: Implementations of our baselines are available here: https://anonymous.4open.science/status/fairbaselines-44A7.
Revised: Implementations of our baselines are available here: https://anonymous.4open.science/status/fairbaselines-44A7.

Original: Tables 8 and 9 report the recorded metrics for each fairness technique.
Revised: Tables 8 and 9 report the recorded metrics for each fairness technique.

Original: Values reported in prior literature are included in the table using the technique’s name (e.g., the second row of Table 8, labeled ‘Adv.’
Revised: Values reported in prior literature are included in the table using the technique’s name (e.g., the second row of Table 8, labeled ‘Adv.’

Original: includes the values reported by Xie et al.
Revised: includes the values reported by Xie et al.

Original: Values that we measured using our implementations of each technique are marked with asterisks.
Revised: Values that we measured using our implementations of each technique are marked with asterisks.

Original: We report means and standard errors for our implementations for each method and compare to the metrics that prior methods published for each dataset.
Revised: We report means and standard errors for our implementations for each method and compare to the metrics that prior methods published for each dataset.

Original: The bottom halves of Tables 8 and 9 are separated from the top halves to indicate modiﬁed datasets.
Revised: The bottom halves of Tables 8 and 9 are separated from the top halves to indicate modiﬁed datasets.

Original: The Wass.
Revised: The Wass.

Original: DB baseline used the German and Adult datasets but treated protected ﬁelds differently (e.g., by creating binary age labels at the cutoff age of 30 instead of 25, as all other techniques did).
Revised: DB baseline used the German and Adult datasets but treated protected ﬁelds differently (e.g., by creating binary age labels at the cutoff age of 30 instead of 25, as all other techniques did).

Original: We therefore evaluated CSNs and our own implementations of Wass.
Revised: We therefore evaluated CSNs and our own implementations of Wass.

Original: DB on these different datasets as well and reported them below the horizontal line.
Revised: DB on these different datasets as well and reported them below the horizontal line.

Original: Interestingly, while we were able to recreate the Wass.
Revised: Interestingly, while we were able to recreate the Wass.

Original: DB results on these modiﬁed datasets, the technique, when applied to the standard datasets, demonstrated better fairness than most techniques but worse y Acc..
Revised: DB results on these modiﬁed datasets, the technique, when applied to the standard datasets, demonstrated better fairness than most techniques but worse y Acc..

Original: (We repeated the hyperparameter sweeps reported by Jiang et al.
Revised: (We repeated the hyperparameter sweeps reported by Jiang et al.

Original: and used the best results.)
Revised: and used the best results.)

Original: We attribute the low y Acc.
Revised: We attribute the low y Acc.

Original: to the fact that Jiang et al.
Revised: to the fact that Jiang et al.

Original: (2020) call for a linear model as opposed to deeper neural nets used by other approaches.
Revised: (2020) call for a linear model as opposed to deeper neural nets used by other approaches.

Original: When using the datasets suggested by
Revised: When using the datasets suggested by

Original: Wass.
Revised: Wass.

Original: DB, we reproduced their published results, as did CSNs trained on the same datasets.
Revised: DB, we reproduced their published results, as did CSNs trained on the same datasets.

Original: We note, however, that predictors on this dataset are of limited use, as both Wass.
Revised: We note, however, that predictors on this dataset are of limited use, as both Wass.

Original: DB and CSNs fail to outperform random classiﬁcation accuracy.
Revised: DB and CSNs fail to outperform random classiﬁcation accuracy.

Original: As a whole, Tables 8 and 9 give us conﬁdence in our implementations of the fairness baselines.
Revised: As a whole, Tables 8 and 9 give us conﬁdence in our implementations of the fairness baselines.

Original: Our implementations were able to match or exceed metrics reported from prior art.
Revised: Our implementations were able to match or exceed metrics reported from prior art.

Original: This suggests that our underlying implementations were correct and that new metrics we gathered on them were valid.
Revised: This suggests that our underlying implementations were correct and that new metrics we gathered on them were valid.

Original: [Table] [Table]
Revised: [Table] [Table]