Paper: One-Hot Encoding Strikes Back: Fully Orthogonal Coordinate-Aligned Class Representations (ICLR-2024)

Reviewer comment (Theory):
I do not see why we need orthogonal class representations -- because semantically I would like to have a substantial weight in the tail of similar but not the same classes. In case I do not want the semantic similarity between class prototypes to be smooth, one can normalize with the appropriate temperature.

Author response:
Q1.  Why should two classes which are distinct (say apple and orange) be associated?  A fruit cannot be an apple and an orange?  Note that our representation does not stop a new image (not in labeled training set) from have a representation that thinks it might be an apple or an orange.  A data points can have associations with two classes, but the distinct classes do not need correlation with each other.

Reviewer comment (Theory):
The second question is more about why we even need these transformations. If you learn a one-vs-all multi-class classifier for all these data points and classes you will end up generating a "one-hot" vector of dimensionality = number of classes.

Author response:
Q2.  If you just learn classifiers then, either:
   - these can have the same unnecessary associations discussed in Q1.  If something is clearly an apple, that does not mean a classifier should also guess that it might be an orange.  Note this is indeed what happens without these techniques.  
   - or these classifications are not part of the embedding layer.  So they do not aid to the interpretability.  Our goal is to put as much structure and utility into this one embedding layer.  There are many shifts in industrial machine learning to try to store the results of training as vectors (check out the new company "pinecone").  This aim of this is so that these learned representations capture the main desired properties of the data, and are also more interpretable.

Reviewer comment (Novelty):
This is the regular linear classifier with softmax after all the multi-class image classification networks we learn today. The classifier itself is the projection to ensure you obtain an orthogonal axis-aligned vector for each datapoint and in turn each class. Leaving it at softmax and not thresholding gives your semantically meaningful embeddings that can further be used for class embeddings.

Author response:
Q2.  If you just learn classifiers then, either:
   - these can have the same unnecessary associations discussed in Q1.  If something is clearly an apple, that does not mean a classifier should also guess that it might be an orange.  Note this is indeed what happens without these techniques.  
   - or these classifications are not part of the embedding layer.  So they do not aid to the interpretability.  Our goal is to put as much structure and utility into this one embedding layer.  There are many shifts in industrial machine learning to try to store the results of training as vectors (check out the new company "pinecone").  This aim of this is so that these learned representations capture the main desired properties of the data, and are also more interpretable.

Reviewer comment (Theory):
It would be great if these questions could be resolved and the paper heavily leans on OPL and CIDER at times and would be good to have a short background section on the math behind them.

Author response:
We believe that OPL and CIDR are two examples of ways to initially train a near-orthogonal embedding.  In principal they are somewhat interchangeable (although for SOTA in certain tasks, sometimes one is much better than there others for reasons probably beyond the scope of this paper).  The key part, we believe, is our method which finally achieves full orthogonality, and uncorrelated the representations of distinct labeled classes.

Reviewer comment (Novelty):
I also point the authors to error-correcting output code line of work (Dietterich & Bakiri, 1995) and probably a concise survey (Kusupati et al 2021) spanning interpretable and learned ECOCs. They aim at learning sub-linear cost class representations in binary space (not necessarily orthogonal, but can be made and also made interpretable in attribute space). This helps result in axis-aligned attribute interpretable binary codes for classes. This also deals with some notions of OOD detection.

Author response:
The code book methods seem to have as an aim to compress learned representations.  Our goal is to work within the space of generic vectorized representations, but add enforced structure that do not detract from performance while improving interpretability.

Our thinking is a natural representational goal for learning is a vectorized embedding, so let's see how far we can encode structure and utility into these structures.  Why defer classification into another step (even if it's fairly simple) when it can be directly encoded in the representation.  Ultimately, we think that the vectors in vector databases will be a mix of structured and unstructured parts -- both have advantages.  Our paper makes an argument for this particular balance in structures.  

The codebook approaches are similar, ensuring > Hamming Distance 1 separability between classes, as opposed to orthogonality between classes.  With this they observe additional correlation between related classes, however it does not prohibit unwanted correlation between unwanted classes.  Say for instance, as we do with the example in Figure 3, we want to remove the effect of one of the classes, the binary code representation does not seem to have a mechanism to do this.  There is not a single bit or coordinate to change, and there are k other representations that are 1 bit away, so it's not clear which to move to.  
Clearly, their compression is better, but that is not what we are aiming for in this case.

Reviewer comment (Evaluation):
The orthogonality objective of the method (although achieved) is not linked to a specific performance improvement in the experimental context, which makes its claim somewhat arbitrary. For example, the use of the post-processing step for Out-of-Distribution detection leads to a performance degradation.

Author response:
The main goals of the proposed methods are:
  1. Make embeddings more interpretable by having some coordinates associated with class means, and so these aspects are completely orthogonal
  2. Basically preserve the state of the art.  

We achieve these goals.  This method makes no attempt to directly further optimize performance metrics on any tasks, so we should not expect improvement -- although it sometimes happens.

Reviewer comment (Experiments):
In general, the choice of a smaller ResNet architecture (ResNet-9) does not allow to obtain experimental results equivalent to those provided by the mentioned methods for baseline comparison, although complete results and numerous details are provided.

Author response:
The main goals of the proposed methods are:
  1. Make embeddings more interpretable by having some coordinates associated with class means, and so these aspects are completely orthogonal
  2. Basically preserve the state of the art.  

We achieve these goals.  This method makes no attempt to directly further optimize performance metrics on any tasks, so we should not expect improvement -- although it sometimes happens.

Reviewer comment (Experiments):
The method does not seem to perform consistently depending on the evaluation criteria for image classification. This affects the evaluation of the performance in the case of classification. Since classification performance does not seem to be the main objective of the post-processing steps, other experiments could have been tried, such as robustness to label noise or robustness to adversarial attacks, as for example in the OPL method paper.

Author response:
The main goals of the proposed methods are:
  1. Make embeddings more interpretable by having some coordinates associated with class means, and so these aspects are completely orthogonal
  2. Basically preserve the state of the art.  

We achieve these goals.  This method makes no attempt to directly further optimize performance metrics on any tasks, so we should not expect improvement -- although it sometimes happens.

Reviewer comment (Theory):
The assumption that class means should be entirely orthogonal raises questions. While it makes sense for entirely independent classes, it doesn't account for cases where classes share features or have relationships. The logic behind making every pair of classes orthogonal, especially when some classes naturally have similarities (e.g., apple and orange), remains unclear.

Author response:
Weakness #2:   We feel that distinct classes should indeed be uncorrelated.  Although apples and oranges are both fruits they are completely different fruits, and a labeled image is in exactly one such class.  For an unknown object (not labeled in the training set), it is still possible for it to have association with both classes if it is not clear which it is.  However, if it is clearly an apple, that should *not* imply that it is associated with the class orange.  Our orthogonal representation allows this.  

W2 -> R2: Regarding Weakness #2 and orthogonality:
  Orthogonality could still allow for the embedding network to capture shared features, and if only some shared feature was observed on a test image, then it could be placed to have large dot product along both directions.  

Moreover, imagine a scenario where the training data has numerous pictures of apples and oranges, each labeled correctly.  However, half of each type of image also has a special bit or pattern which accidentally encodes a label (e.g., a logo), and so the classifier can use this to definitely classify them.  Yet, since it's only half of the images, and they share features, then the embeddings left to its own devices will embed the class means or classifier normals for apples and oranges to be aligned.  But then if we get a test data point with the apple logo, so the classifier will definitely know it is an apple, it may be directly aligned with the apple class mean, but also have association with the orange class even though the classifier should know it is not an orange -- it has the apple logo and not the orange logo.  This pattern in representation seems undesirable to us, and the aim of this paper is to address this.  Our orthogonal representations successfully do just that.

Reviewer comment (Experiments):
Despite emphasizing the method's potential for enhanced embedding interpretability, by orthogonalizing them, the paper does not provide empirical evidence that assesses this claim of improved interpretability.

Author response:
Weakness #3:  We believe the example uses in Figure 2,3 provide clear evidence of the interpretability.

Reviewer comment (Writing):
The method primary objective and results appear straightforward, yet the paper presents the method in a very convoluted manner.

Author response:
Weakness #4:  We have updated the presentation of the method a bit based on another reviewers request.  However, we feel that although the objective is simple to state, it does not have a simple solution (we looked for ones, and prior simpler approaches did not achieve orthogonality).  If you have a simpler approach in mind, that would be great!

Reviewer comment (Theory):
Why is it necessary for classes to be orthogonal before projecting them into the new basis? Wouldn't it be possible to simply compute the coefficients and execute a change of basis, e.g., using a least squares approach? The rationale behind the choice to orthogonalize vectors first and then execute a change of basis using an orthogonal matrix remains ambiguous. Why not directly learn a non-orthogonal matrix for this transformation?

Author response:
Question:  Attempts to learn how to make classes orthogonal (OPL and CIDR) did not fully orthogonalize class means.  We tried other variants which also did not achieve close to full orthogonality.  Our ISR method does.  
What you are describing sounds similar to running one step of ISR; as we show running a few more iterations is required so that the class means of the embedded data are actually orthogonal.  Transformations that orthogonalize the vectors v1 and v2 at the current class means apply to the actual data non-uniformly, so if one recomputes the class means again afterwards, they are no longer orthogonal.

Reviewer comment (Writing):
W1. The introduction of the proposed methods is rather convoluted, short, and unclear. Besides, it relies too much on the reader having previous knowledge of how ISR works. The authors should work on providing more context and explanations to the reader. This is the biggest concern I have with the current state of the manuscript.

Author response:
Thank you for the feedback on the writing of the paper, we have updated things to try to address these issues.

Reviewer comment (Experiments):
W3. The explanation of why we cannot simply run Gram-Schmidt (GS) is unclear to me and, in any case, traditional orthogonalization methods (GS, Householder transformations, etc.) should be added as baselines in the experimental section.

Author response:
W3:  Gram-Schmidt can by applied to a pair of vectors (e.g., the class means), but we need an operation that applies to every embedded point, including ones were we may not know the label.  In short, it is not even clear what a baseline of Gram-Schmidt would be.  If there is something we are missing, please let us know what you have in mind.

Reviewer comment (Writing):
Q1. What does it mean that DCR uses a "discontinuous operation"? Discontinuous wrt what exactly?

Author response:
Q1:  DCR segments the embedding space, and applies a Gram-Schmidt-driven rotation to part of the embedding space, leaving the rest fixed.  The boundary between the transformed space and the fixed space causes a discontinuity in how the update step affects the embedding.

Reviewer comment (Theory):
Q2. Why is it sensible to normalize the class means? That is, why is it a good idea to completely disregard the magnitude of the class means (since $\arg\min_j D(x, v_j) \neq \arg\min_j D(x, v_j / ||v_j||)$ in general).

Author response:
Q2:  The goal is interpretability of the embeddings.  We believe a normalized value will be more interpretable since the length now has some meaning.  
In particular, when the class means are all normalized, then the relative relationship for an evaluation point between classes can be easily understood by directly comparing their coordinates.