{'fraction_non_alphanumeric': 0.0384603872975966, 'fraction_numerical': 0.012151686570291222, 'mean_word_length': 4.514441326951642, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 3, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Universal Domain Adaptation in Ordinal Regression

We address the problem of universal domain adaptation (UDA) in ordinal regression (OR), which attempts to solve classification problems in which labels are not independent, but follow a natural order. We show that the UDA techniques developed for classification and based on the clustering assumption, under-perform in OR settings. We propose a method that complements the OR classifier with an auxiliary task of order learning, which plays the double role of discriminating between common and private instances, and expanding class labels to the private target images via ranking. Combined with adversarial domain discrimination, our model is able to address the closed set, partial and open set configurations. We evaluate our method on three face age estimation datasets, and show that it outperforms the baseline methods.


I. INTRODUCTION
Domain adaptation techniques were introduced to address the domain shift between source and target domains [40], [48]. Domain adaptation (DA) is a form of transfer learning that aims to learn a model from a labeled source domain that can generalize well to a different (but related) unlabeled or sparsely labeled target domain. Domain adaptation has demonstrated a significant success in various applications, including image classification [18], semantic segmentation [46], object recognition [30] object detection, 3D point cloud segmentation [48], etc. These successes are due to the same semantic space shared by source and target domains. Common classes implicitly structure the output space, where separation between two classes in the source can be transferred to the target. Moreover this knowledge makes possible totally unsupervised domain adaptation [18], [29].
More challenging problems of partial and open set domain adaptation have been recently addressed [2], [37]. In universal domain adaptation(UDA) [36], [44], source and target domains share a set of common classes but each domain may have its private classes. The task is to identify source and target images in common classes to apply domain adaptation. Existing UDA methods count on entropy-based and uncertainty criteria to weigh down images estimated as being in private source classes [3], [24] or target clusters [20], [21], [33] and mark all private target images as "unknown".
In this paper we investigate the UDA problem in ordinal regression aiming to solve a classification problem where classes are not independent but follow a natural order. Ordinal regression (OR) is an important research topic in machine learning [12], [13], [27], [32]. Its applications include age estimation [22], [26], [32], depth estimation [13], human preferences [12] and ratings [17]. Moreover, any 1D regression task is convertable in OR by discretizing the target variable [8]. To take into account the class order, multiple shallow and deep methods have been developed for OR [1], [12], [17], [32], [34]. In this paper we build on the recent state of the art method of consistent rank logits (CoRaL) [1].
Domain shift in OR faces the same challenges as in classification. Transferring source OR classifier to target domain requires learning domain invariant representations. If source and target domains share the same classes, multiple well known solutions [14], [19], [29] can be adopted by ignoring the class order or by replacing the cross entropy loss in source classifier with the OR loss [9].
However, domain shift in OR usually comprises the output shift (also called category shift). Consider the example of domain shift in human face age estimation. UTKFace and AFAD are two popular datasets for training the age estimation models [1], [32]. AFAD is a collection of Asian face images aged between 15 and 40 years old; UTKFace is a universal face dataset with the age range from 1 to 80 years. The domain shift combines the input shift (faces of different human races) and output shift (ages). A model trained on UTKFace and adopted to AFAD should be able to constrain estimations to the target age range. Inversely, a model trained on AFAD and adopted to UTKFace should detect extra classes and, if possible, make predictions beyond the source age range.
Existing UDA methods for classification [2], [3], [24], [33], [36], [44] perform sub-optimally under output shift in OR, for two reasons. First, they assume class independence and follow an entropy minimization approach to enforce the decision boundary to pass through low-density area. The uncertainty of class predictions serves to detect outlier source classes in partial DA [2]; low confidence entropy helps detect source and target private images in open set DA [44]; neighbour clustering exploits the cluster structure of the target domain for cluster matching [36].
However the clustering assumption is often invalidated in OR. By their nature, ordinal data span a low-dimensional manifold where classes are assigned via thresholding [17], [28]. This can confuse the entropy-based criteria for separating common and private images and lead to domain misalignment and negative transfer. Second, as classes are treated independently, existing UDA methods are prone to making boundary decision order inconsistent where classes marked as common mix up with classes marked as private.
If trained separately, source and target domains form two separate manifolds due to their domain specific features (see Figure 2.a). Learning domain-invariant representations [14], [29] enables forming one unique manifold (see Figure 2.b). However, to avoid the misalignment, the DA method should accurately separate common and private classes and train the domain discriminator on the common classes only.
a) Auxiliary task of order learning.: To address the partial and open set DA in OR, we introduce an auxiliary task of order learning [26]. Order learning performs pairwise comparison between images, instead of directly estimating the class of an image. The advantage of such a complementary representation is two-fold. First, the order model aims to replace the cluster assumption when detecting the boundary between common and private classes.
Second, it can benefit from the aligned manifold structure and predict the relative position of private target images w.r.t. the common class set Y . Predicting exact classes requires some target labels [7], [26] and is beyond the unsupervised domain adaptation setting. However, we can assume homogeneity of relative positions of images in the common and private classes. Under this assumption, the order model can compare target private images pairwisely, transform these comparisons in the ranking and convert the ranks into classes (see Figure 2.c). In other words, we explore the ordinal data structure to assign true classes to private images.
Trained on source pairs, the order model can suffer from the negative transfer, just as the OR does. We propose a deep architecture for UDA which jointly learns OR, the order and domain invariant features through an adversarial domain discrimination. We then leverage the learned order relationships to rank private target images.
The contribution of this paper is three-fold. First, we introduce a new UDA solution, that focuses on OR tasks. We show that the existing UDA methods that process classes independently under-perform on OR in the presence of common and private classes. Second, we propose a solution based on order learning to address four UDA configurations: same  . We show how to train the order model to detect the boundary between common and private classes and weigh down private instances in domain discrimination. Third, we show that the order model permits to replace the "unknown" class assigned to private target instances with a ranking and, under a mild assumption, to convert these ranks into true target classes.

II. RELATED WORK
There exist multiple families of solutions for domain adaptation [11], [48]. Feature-level strategies focus on learning domain invariant data representations mainly by minimizing different domain shift measures [39]. Discrepancy-based methods explicitly measure the discrepancy between the source and target domains on corresponding activation layers of the two network streams [29]. Optimal transport models try to align the representations of the source and target domains via the optimal distribution matching [10], [21] and domain structure exploration [42].
Domain adversarial training of neural networks is another popular approach to learn domain invariant and task discriminative representations [14]. Adversarial discriminative models employ an adversarial objective with respect to a domain discriminator to encourage domain confusion [41]. This approach has multiple variants, some of which also exploit class-specific and group-specific domain recognition components [23], [37]. a) Universal Domain Adaptation.: Recent works revised the main assumption of the source and target sharing the same class set and study more realistic scenarios [2], [3], [36], [37], [44]. In partial DA, the target is allowed to cover only a subset of the source class set. In this case the adaptation process should be adjusted so that the samples with not-shared labels would not influence the learned model. Common techniques consist in adding a re-weight source sample strategy to a standard DA approach [2], [45]. Alternative solutions leverage two separate deep classifiers and their prediction inconsistency on feature norm matching [43], or include adversarial alignment and adaptive uncertainty suppression [24].
The open set scenario is not trivial since the target samples in unknown class are not expected to align with the source. This problem is addressed by measuring the entropy of class predictions [44] or by augmenting the domain adaptation with class-agnostic clusters in target domain [33]. [20] proposed a method to model the synchronization relationship among the local distribution pieces and global distribution, aiming for more precise domain-invariant features in hierarchical manner. The sample transfer scoring scheme in [25] couples target pseudo-labeling with careful sample selection to ensure class diversity in a batch.
A new UDA framework has been proposed in [36]. It relies on a neighborhood clustering to learn the structure of the target domain in a self-supervised way. It also uses entropybased feature alignment and rejection to align target features with the source, or reject them as "unknown".
All mentioned methods address the classification tasks. Domain adaptation in regression is less studied [48] and represented by eye gaze [38] and hand pose estimation [6], [31]. In both tasks, a model trained on synthetically generated images is transferred to real images by adjusting the loss function or by reweighting source images. The process of generating synthetic images ensures the same output space across the domains and therefore prevents any output shift. In [31], this is addressed exploiting topological properties, which are invariant to the shift across domains.

A. Ordinal regression
Ordinal regression is also called ordinal classification [12], [32], [34]. Its goal is to predict the category of an input instance from a discrete set of classes which form a natural order. Common examples of such tasks are movie ratings, customer satisfaction surveys, age estimation, etc. [1], [13], [17].
In a sense, ordinal regression attempts to solve classification problems in which wrong classes are not equally wrong. In age estimation, if a given person is 25 years old, estimation of his age of 30 years is less incorrect than the estimation of 40 years.
Shallow methods framed the OR problem as classification with a set of thresholds on the output space [17]. In deep learning, [32] first proposed Ordinal Regression CNN by reducing ordinal regression with m classes into m−1 binary classification problems, with the k-th classifier predicting whether the age label of a face image exceeds rank r k , k = 1, . . . , m−1. While the binary classification approach is able to achieve state-of-the-art performance, it does not guarantee consistent predictions, such that predictions for individual binary tasks may disagree. This inconsistency leads to suboptimal performance when the m − 1 task predictions are combined to obtain the estimated age.
The consistent rank logits method (Coral) [1] addresses the inconsistency issue and provides a theoretical guarantee for classifier consistency without increasing training complexity. Using the binary classifier responses, the predicted class for an input x is obtained by where f k (x) ∈ {0, 1} is the prediction of the k-th binary classifier in the output layer. Classifiers f k , k = 1..m − 1 are required to reflect the ordinal information and to be order- , which guarantees consistent predictions. To achieve order-monotonicity and guarantee binary classifier consistency, the m − 1 binary tasks share the same intermediate layers but are assigned distinct weight parameters in the output layer [1].

III. UNIVERSAL DOMAIN ADAPTATION IN OR
We address the problem of Universal Domain Adaptation in OR, where a source domain D s = {(x i s , y i s )} consisting of n s labeled samples and a target domain The set of common classes shared by both domains is denoted Y = Y s ∩ Y t . Private classes in source and target domains are denoted Y p s = Y s \ Y and Y p t = Y t \ Y . Target data is fully unlabeled, the target class set is only used for defining the UDA problem. We define the commonness between two domains [3] as the Jaccard distance of two class sets, ξ = |Ys∩Yt| |Ys∪Yt| . The smaller ξ is, the less knowledge is shared by the domains. We assume that ξ > 0 and therefore the common class set Y is not empty. Figure 3 shows four possible configurations of UDA in OR. Case (a) shows the closed set combines the partial and open set (OSPA). Our goal is to design a model that works well across a wide spectrum of ξ. It must be able to distinguish between images data coming from the common set Y and private sets Y p s and Y p t .
A. UDA for OR through the manifold hypothesis We propose a method that trains a transferable feature extractor f = F (x) and an ordinal regressor y = G r (z). Trained on labeled source images and unlabeled target images, our model provides an accurate adaptation of the source OR model to the target domain, by adopting the domainlevel adversarial discriminator G d [3], [14], [44] to reduce the discrepancy between domains and learn domain-invariant image representations f = F (x).  The special UDA requirements for handling samples from private target classes Y p t during learning, and to make predictions for them during testing, are dealt with the following assumption: Assumption 1 (Manifold assumption): (a) The ordinal instances live in a low-dimensional manifold where classes form a natural order. (b) The relative difference/order between images on the manifold is a monotonic function invariant to the domain shift. Assumption 1 frames our learning approach. Assumption 1.a is exploited during learning through a new pairwise order classifier G o (f 1 , f 1 ), which predicts whether a pair of samples (x 1 , x 2 ), and in particular their domain invariant features f 1 = F (x 1 ), f 2 = F (x 2 ), follows the class order or not. Building on this classifier, we design a procedure providing estimates on whether given target samples (whose labels are unknown) are in common or private classes, and reweigh their contribution to learning accordingly. This is detailed in Section III-B. Assumption 1.b is exploited during the testing. Instead of classifying all samples using the ordinal regressor G r , which would be acting out of its domain in the case of samples of the private target space Y p t , we deal with these samples differently. We first mark these images as private using the order classifier, and we take decisions jointly for the full set of private samples, assigning class labels according to Assumption 1.b; this is described in detail in Section IV-A. Figure 4 illustrates the UDA model for OR. All different branches F, G r , G d and G o are trained jointly end-to-end in a minimax optimization procedure, where the feature extractor F is trained by maximizing the loss of domain discriminator G d , while G d is trained by minimizing the domain discrimination loss, as described in Section IV.
The order model is the main novelty in our method, we describe it in details in the following section.

B. Order learning
We start by defining the ideal scenario, which defines an order relationship between input samples through the relationships between their classes. Building on this definition, we detect private target images and exclude them from domain discrimination by assigning low weights. For the source domain, we follow a similar approach and weigh down classes detected as being private. Our initial definition is deterministic and does not yet model any uncertainties. This definition will then be relaxed and implemented as trained network in the subsequent section.
Let x 1 and x 2 be two images belonging to classes in Y s . Their ordering relationship is defined according to their classes as follows where τ is a threshold [26]. Note that we use '≺' for the instance ordering and '≤' for the class order. Private target instance. By the definition of class order, a target image x t is private if it is bigger or smaller than all source images. Let p(x t ≺ D s ) denote the probability of target image x t to be smaller than all source images, where the indicator function 1(·) is 1 if the condition is satisfied, 0 otherwise. In the ideal case, when all order relationships x t ≺ x s are known, a value 1 (or 0) of p(x t ≺ D s ) means that x t is smaller (or bigger) than the source set and therefore is private. All intermediate values of p(x t ≺ D s ) indicate that x t is in the common set Y . 1 This binary decision can be expressed as p(x t ∈ Y ) = (p(x t ≺ D s )) where () is a binary filter Private source class. Symmetrically, we denote p(x s ≺ D t ) the probability that a source image x s is smaller than all target images. A source class y s is private if all images of this class are bigger or smaller that all target images, p(y s ∈ Y p s ) = (p(y s ≺ D t )), where p(y s ≺ D t ) = E xs,y(xs)=ys p(x s ≺ D t ) = E xt∈Dt,xs,y(xs)=ys 1(x s ≺ x t ) (5) and (·) is the binary filter (4).
Eqs. (3)-(5) define three steps to estimate if a target image x t or source class y s is in the common set Y . First, we dispose a model to estimate the order relationship for any two images x 1 and x 2 . Second, we estimate p(x t ≺ D s ) and p(y s ≺ D t ) using Eqs. (3) and (5). Third, we apply the binary filter (4) to estimate p(x t ∈ Y ) and p(y s ∈ Y ).

C. Training the order model
The ideal scenario presented in the previous section assumes knowing all order relationships between source and target images. In this section we adjust the ideal scenario to the UDA setup, where we know source labels only and have no order relationships between source and target images.
We train the order model to estimate p(x 1 ≺ x 2 ) using source image pairs. And we can not expect the model to be 100% accurate as it is shown in [26]. To tolerate order model errors, we first replace the binary filter (4) with a smoothed filter˜ (x) when x values are close to 0 and 1. Figure 5 plots the binary filter (4) and the smoothed filter implemented as a symmetric n-order Butterworth low-pass filter widely used in signal processing [35]. The filter is available in scipy package and controlled by two parameters, width w and order n . 2 a) Curriculum learning.: The order model is trained on source image pairs (x 1 , x 2 ). Since the exhaustive enumeration of image pairs is computationally expensive, we sample source pairs. Moreover we avoid random sampling and propose a special strategy aimed at faster training.
Curriculum learning (CL) [46] proceeds by presenting easy examples to the learner before hard ones. For age estimation, easy examples are those having a clear visual clue on which face is younger. So we initially present image pairs having a big age difference. We start with the symmetricshape (blue) and -shape (orange) distributions for sampling image pairs (x 1 , x 2 ) in Figure 6.a.
The sampling policy changes over epochs by presenting harder pairs with smaller class difference. The sampling distribution at epoch ep is defined by Beta function, B(α, 1.0) for image x 1 and B(1.0, α) for image x 2 , where α = 1 − exp(ep). Symmetric distributions flatten over epochs (Figure 6.b) and tend to the uniform distribution B(1, 1) (Figure 6.c) which mixes up easy and hard pairs. b) Target images and source class in common class set Y .: The probability of a target image x t to be in Y is estimated as p(x t ∈ Y ) =˜ (p(x t ≺ D s )), by applying the order model on randomly sampled l s source images, The probability of source class y s to be common is p(y s ∈ Y ) =˜ (p(y s ≺ D t )), where p(y s ≺ D t ) = E xs,y(xs)=ys,xt∼Dt is the average over all images in y s compared with randomly sampled l t target images.

IV. OPTIMIZATION AND TRAINING
We now define losses for three main components of the ORUDA network (see Fig 4): source regressor G r , order classifier G o and domain discriminator G d . First, the OR loss for G r is defined on labeled source images, where L coral is the Coral loss defined in Section II-A. Second, the order loss for G o is defined on pairs of source images and their order relationships, where L ord is the cross entropy loss, F compares the two image feature vectors. Instead of feature concatenation implemented in [26], we use the vector difference, Third, the adversarial domain discriminator G d is trained to distinguish between feature representations of source and target images, with the adversarial loss where weights w(x t ) and w(x s ) for target and source images are obtained in Section III-C, w( , where y s = y(x s ). Note the instance weighing in Eq.(9) is similar to [44]; however the weights are estimated by the order classifier and not by the source classifier. The total loss for training the ORUDA network is where γ is a hyper-parameter controlling the importance of the order and domain discrimination adversarial losses. The training objective of the minimax game is the following Eq. (11) is solved by alternating between optimizing F, G r , G o and G d until the total loss (10) converges. The ORUDA network (Figure 4) takes as input a batch of source images and a batch of target images. The feature extractor F generates image representations f = F (x) for both batches. The domain discriminator G d is trained on representations f to distinguish between source and target images. The ordinal regressor G r is trained on a full set of source images. The order classifier G o takes a pair of source images and their order relationship as input, and pushes the difference of their feature vectors, F (x ) − F (x ). Source and target image weights are updated over epochs using estimations p(x t ∈ Y ) and p(x s ∈ Y ). A. Order to ranking to classes After training, the ORUDA network estimates the boundary between common and private classes. It marks a source class y s as common if p(y s ∈ Y ) > 0.5 and private otherwise. It marks a target image x t as common if p(x t ∈ Y ) > 0.5 and as private otherwise. For target images marked as common, it uses the ordinal classifier to estimate their classes (see Figure 7). At this stage, classical UDA methods for classification mark all private target images as "unknown" and terminate. In our case, we can proceed by applying the order model to target private images and classify them using Assumption 1b. We proceed in two steps: (i) conversion of pairwise comparisons to rankings, followed by (ii) conversion of rankings to classes. a) Image order to image ranking.: In information retrieval, ranking problems involve a collection of n items and some unknown underlying total ordering of these items. In many applications, one may observe noisy comparisons between items. Examples include matches between teams in a football tournament and consumer's preference ratings. Given a set of noisy item comparisons, any ranking method tries to find the true underlying ordering of all n items.
The problem of finding approximate rankings based on noisy pairwise comparisons is well studied [4]. In our case, to rank the private target images, we resort to the Bradley-Terry model which is used in multiple applications [15], [16]. It deals with pairwise comparisons among n images and assumes that there are positive quantities π i , i = 1, . . . , n such that p(x i ≺ x j ) = πi πi+πj . Assuming independence of all comparisons, the probability p ij = p(x j ≺ x j ) satisfies the logit model All parameters π i can be estimated by maximum likelihood using standard software for generalized linear models. Once we detected n private target images, we randomly sample image pairs, apply the order classifier to estimate their relative order and run the Bradley-Terry model to convert the comparisons into a ranking. This private image ranking forms an extension of the common class set Y (see Figure 7). The target image ranked 1 is the closest to Y , while the target image ranked n is the farthest from Y . 3 b) Image ranking to private classes.: Our model classifies the common target images and ranks the private target images, leading to two different perfmance metrics: 1) Mean square error (MAE) in the common classes Y .
2) Ranking error of the private target part Y p t . The first measure is analogous to the classification UDA, where classification error is measured on common classes and "unknown" for all images in Y p t . The ranking error, however, is specific to ORUDA, it estimates how well the order model generalizes to target domain.
While ranking error is well defined in information retrieval, it is non obvious in OR, where private classes with multiple images per class allow for an exponential number of totally valid rankings. To simplify the evaluation, we convert the ranking to classes exploiting an assumption of knowing the number of private target classes, m p t = |Y p t |. As the target class thresholds are unknown, we split the full image ranking equally among m p t classes, by simply following their order (see Figure 7). The image ranked 1 goes to the first private class while the last ranked image goes to class m p t . As a result, we can give a true class label to every target image including OS and OSPA cases. We can measure MAE on the entire target set, we denote this extended version e-MAE. Note that the number of private target classes m p t is not used during training nor ranking, it is used for the evaluation only.

io/CARC).
Images in the CACD dataset are preprocessed such that the faces spanned the whole image with the nose tip being in the center. In UTKFace and AFAD datasets, the centered images were already provided. Each image dataset is randomly divided into 80% training data and 20% test data. All images were resized to 128×128×3 pixels and then randomly cropped to 120×120×3 pixels. During model evaluation, the 128×128×3 face images were center-cropped to a model input size of 120 × 120 × 3.
b) Implementation and Setup.: The ORUDA network is implemented in PyTorch. The feature extractor F is finetuned on ResNet-34 network. The ordinal regressor G r , order classifier G o and domain discriminator G d were all trained from scratch. G r includes three FC layers with 512, 512 and m s nodes; G o is also composed of three FC layers with 512, 512 and 1 nodes. Domain discriminator G d is similar to one used in the UDA network [44]; it includes three FC layers with 1024, 1024 and 1 nodes, interleaved with ReLu layers, the drop-out Bernoulli parameter is 0.5. A     All network components are trained jointly. The network inputs a batch of source images and a batch of target images to fine-tune F and to train G r , G o and G d . The CL changes the image sampling policy over epochs. Target image and source class weights are updated after each epoch.
For all experiments, we use the same hyper-parameters, batch-size, and learning rate. We train the network using the Adam optimizer with a learning rate of lr = 10 −4 and a batch size of 64 images. Hyper-parameter γ in the ORUDA loss is set to 1.0. The symmetric Butterworth filter is configured with width w = 0.9 and order n = 6. The threshold for the order relationship is τ = 3. Training images are shuffled at each epoch before they are fed to the network.
For target images x t marked as common, the OR classifier predicts their classes as G r (F (x t )). Target images marked as private are sampled pairwisely for ranking, with at most l t = 100 comparisons per image. We run each experiment three times and report the average values.
Baselines. We validate the effectiveness of our system comparing them to several baselines. We build the baselines by disregarding the class order in OR. It permits to apply UDA methods for classification and compare to our method in MAE setup where all private target images are considered as "unknown". We compare the ORUDA method to UAN [44] and DANCE [36] designed to address all UDA cases in classification; we also add two baselines for the special cases: PADA [2] for PA and CS cases, and OPDA-BP [37] for OS and CS cases. Here, MAE refers to classification setup described in Section IV-A with the "unknown" class for all private target images [36], [44]. e-MAE refers to the classification and ranking setup in OS and OSPA where the private target images are classified using the order classifier followed by ranking.

A. Evaluation results
The ORUDA method is compared to the source model transfer without adaptation, four UDA baselines for classification and supervised training. Without adaptation, the OR model (Coral) is trained on source and tested on target data. The supervised OR model is trained on labeled target data; it aims to provide the lowest error any UDA method would try to achieve on the task.
As the table shows, the smaller values of ξ, the larger the performance gap between the supervised and no adaptation cases. Our method tends to halve this gap in many tasks. Our method and baseline methods show comparable performance in the CS cases, however our method outperforms by large margin the baselines in PA, OS and OSPA cases. The e-MAE values are rather close to MAE; this validates Assumption 1.a stated in Section III-A an supports classification of private target images via ranking. a) Ablation study.: Table II evaluates contributions of ORUDA components introduced in Sections III and IV using AFAD →UTKFace  OSPA configuration.
First, we replace the Coral loss with the cross entropy loss used in UDA methods for classification. It makes the class predictions order-inconsistent and leads to performance drop. Second, we test the binary filter (·) (4) used in the ideal case. The binary filter fails to discriminate private source and target images, and marks them as common thus leading to domain misalignment. Instead, using the smoothed filter (SF)˜ (·) helps find the optimal trade-off between false positives and false negatives in common/private split. Curriculum learning (CL) helps boost the order model performance, especially on starting epochs. The order classifier achieves 98% and 89% on the source train and test sets, respectively. Its accuracy on the target test starts at 50% and grows to 76% at the end of training, thanks to domain invariant image representations.
b) TSNE projections.: Figure 8 plots four TSN-E projections of image features f = F (x) when adapting UTK-Face [0-40] OR model to AFAD  domain (PA case). The first projection shows a well formed manifold with a perfect class order, obtained by learning the OR model on source images. Second and third projections show target images before and after domain adaptation, with a clearly formed manifold and better ordinal classification. The last  projection is on the concatenation of source and target image features after adaptation. Plotted with domain colors (blue for source images and red for target images) it shows how images from the two domains contribute to the common manifold. Figure 9 plots TSN-E projections of image features for the symmetric task of adapting AFAD  model to UTKFace  domain (OS case).

VI. CONCLUSION
We addressed the problem of universal domain adaptation in ordinal regression. Instead of the clustering assumption adopted by UDA methods for classification and semantic segmentation, we assume that ordinal data live in a lowdimensional manifold with classes forming a nature order. We proposed a method that complements the OR classifier with an auxiliary task of order learning and introduced the ORUDA network where the order model can be trained to discriminate between common and private instances, jointly with adversarial domain discrimination. We showed that the order model can expand the natural order to the private target label space on the manifold through ranking. We explained how our model is able to address CS, DA, OS and OSPA configurations. We evaluated the proposed method on a variety of UDA tasks defined on three age estimation datasets and demonstrated its superiority over baselines.