Learning New Tasks from a Few Examples with Soft-Label Prototypes (2024)

Abstract: Existing approaches to few-shot learning in NLP rely on large language models (LLMs) and/or fine-tuning of these to generalise on outof-distribution data. In this work, we propose a novel few-shot learning approach based on soft-label prototypes (SLPs) designed to collectively capture the distribution of different classes across the input domain space. We focus on learning previously unseen NLP tasks from very few examples (4, 8, 16) per class and experimentally demonstrate that our approach achieves superior performance on the majority of tested tasks in this data-lean setting while being highly parameter efficient. We also show that our few-shot adaptation method can be integrated into more generalised learning settings, primarily meta-learning, to yield superior performance against strong baselines.

heading: 1 Introduction
text: Humans have a remarkable ability to adapt knowledge gained in one domain and apply it in another setting, and to identify or disambiguate objects after observing only a handful of examples (Lake et al., 2015). This has inspired research in few-shot learning that aims to build models that can learn a new task using only a small number of examples per class. Early few-shot learning in NLP relied on interventions at the data level, such as dataset augmentation (Clark et al., 2018) or generation of adversarial examples from few-shot datasets (Miyato et al., 2016), while more recent approaches (van der Heijden et al., 2021; Langedijk et al., 2022) utilise meta-learning (Finn et al., 2017; Snell et al., 2017) to optimise model parameters such that models adapt quickly to new tasks using past experience (Dou et al., 2019; Holla et al., 2020; van der Heijden et al., 2021). The advent of large language models (LLMs) has led to a plethora of further methods, including fine-tuning on different target tasks (Sun et al., 2020; Zhou and Srikumar, 2022), cre-
ating prompt-enhanced few-shot datasets for training (Gao et al., 2020; Schick and Schütze, 2020; Lester et al., 2021) as well as parameter-efficient fine-tuning methods for very large language models, with parameters running into billions (Hu et al., 2022; Dettmers et al., 2023).
In this paper, we propose a simple and effective approach to few-shot learning based on soft-label prototypes (SLPs) that capture the distribution of different classes across the input domain space, inspired by previous work on generating compact representations of input training data (Sucholutsky et al., 2021). Our contributions are summarised as follows: 1) We develop a novel neural framework for few-shot learning via soft-label prototypes that has a very small computational and memory footprint, and achieves state-of-the-art results in limited-resource settings. Our approach (DeepSLP) does not rely on (expensive) LLM parameter updates or auxiliary training data. 2) We focus on few-shot learning of new, unseen NLP tasks using as little as 4 examples per class, and demonstrate that we outperform strong baselines on the majority of test tasks. 3) We demonstrate that our approach can also be effectively adapted (MetaSLP) in highresource settings when auxiliary training data is available for few-shot learning, and performs competitively when compared against strong baselines. 4) We release our code and data to facilitate further research in the field.1

heading: 2 Related work
text: Early few-shot learning approaches in NLP include data augmentation and semi-supervised learning; e.g., augmentation with adversarial examples (Miyato et al., 2016), interpolation of training data into a learnable higher dimensional embedding space (Chen et al., 2020), and consistency training to
1https://github.com/avyavkumar/ meta-learned-lines
215
make models more resistant to noise (Xie et al., 2019). Recent research efforts on large-scale pretraining of language models (Devlin et al., 2019; Radford et al., 2019; Brown et al., 2020; Touvron et al., 2023; BigScience Workshop, 2023; OpenAI, 2024) reduce the amount of data required for their subsequent fine-tuning or utilisation in a given task. Instruction tuning and in-context learning (Brown et al., 2020; Gao et al., 2020; Sanh et al., 2021; Liu et al., 2021; Min et al., 2022; Sun et al., 2024; Zhou et al., 2024) show that natural language instructions or prompts can enhance a model’s few-shot learning abilities by leveraging the language (instruction) understanding abilities of the given pretrained LLM (Zhao et al., 2021; Liu et al., 2022). To finetune extremely large language models (with billions of parameters) efficiently, a host of parameterefficient fine-tuning techniques have also been developed (Hu et al., 2022; Dettmers et al., 2023), which leverage pre-trained LLMs and produce superior results on tasks such as question answering, reasoning, text summarisation, coding, etc. (Kotitsas et al., 2024; Jiaramaneepinit et al., 2024; Yang et al., 2024; Ding et al., 2023).
However, the search space over LLMs, prompt templates and few-shot learning is so great that there is yet to be an established standard. Different models require different styles of (few-shot) prompting, and certain prompt templates may work better with specific LLMs and datasets rather than universally across the board (e.g., Davis et al. (2024)). Furthermore, evaluating robustness of state-of-the-art / generative LLMs on new, unseen tasks (OOD generalisation) presents a significant challenge due to their vast and unknown training data, resulting in artificially inflated performance as a result of data leakage (Yang et al., 2023).
Previous work has also tackled few-shot learning within the meta-learning paradigm of “learning to learn” (Schmidhuber, 1987; Bengio et al., 1990; Thrun and Pratt, 1998), utilising methods that are trained to adapt quickly (in a few gradient steps) to new tasks and from a small number of examples, using past experience. Meta-learning has emerged as a promising technique for a range of tasks (Finn et al., 2017; Koch et al., 2015; Ravi and Larochelle, 2017), including NLP such as natural language inference, text classification, etc. (Obamuyide and Vlachos, 2019a,b; Holla et al., 2020; Bansal et al., 2020b; Nooralahzadeh et al., 2020; Wang et al., 2020; Langedijk et al., 2022; Mueller et al., 2023).
In a similar spirit to parameter-efficient fine-
tuning (Hu et al., 2022; Dettmers et al., 2023), our work shifts away from the aforementioned paradigms that suffer from lack of standardisation (LLM few-shot prompting) and increased computational complexity for fine-tuning (e.g., fine-tuning extremely large language models such as GPT (OpenAI, 2024). We present a novel, parameterefficient few-shot learning framework (DeepSLP) based on soft-label prototypes (SLPs), which we show to be effective on a range of tasks in limited and high-resource settings, while having a substantially smaller computational and memory footprint. While DeepSLP does not rely on LLM fine-tuning or auxiliary training data, we present a variant (MetaSLP) that can be used for few-shot learning via auxiliary data and fine-tuned encoders.
We target few-shot learning of new, unseen tasks (i.e., tasks and classes not previously trained on) (a) in limited-resource settings, without access to auxiliary training data, and with frozen model parameters, and (b) in high-resource settings, with access to auxiliary training data, which are used to update model parameters. For the latter, our work is similar to Bansal et al. (2020a). The authors target few-shot learning of unseen tasks via meta-learning, utilising auxiliary training data.

heading: 3 Approach: few-shot learning with Soft-Label Prototypes (SLPs)
text: A soft label is defined as a vector Y representing a data point’s simultaneous membership to several classes (Sucholutsky and Schonlau, 2021), essentially denoting a point’s partial association to different classes. Using this definition, a soft-label prototype (SLP) is defined as (X⃗, Y ), where X⃗ is a point in input space (e.g., an input feature vector) and Y is its corresponding soft label. The underlying idea in Sucholutsky and Schonlau (2021)’s work is that a small set of soft-label prototypes can be used to accurately represent a training set. We build on this idea and reframe SLPs for the task of few-shot learning of new, unseen tasks where very small amounts of data are available per class.

heading: 3.1 Generating soft-label prototypes
text: Soft-label prototypes assign soft labels to every point in the input domain; therefore, a soft-label prototype at point X⃗ represents the class distribution (determined from the training data) at X⃗ . The fundamental idea behind a “soft-label” is that, unlike hard labels, which are one-hot encoded la-
bels, soft-labels contain a distribution of probabilistic label values at a particular point in a highdimensional embedding space.
The process of generating soft-label prototypes from training data can be split into a two step process (Sucholutsky et al., 2021): (1) finding lines that connect the class centroids in the training data, where each line connects some of the centroids, and every centroid belongs to one line; and (2) using linear constraints to derive soft-label prototypes capturing the class distribution at the ends of each line. The two steps are presented in detail below.

heading: 3.1.1 Finding lines connecting all centroids
text: Here we seek to find classes that lie on the same manifold. First, we compute the centroid of each class in the input training data. Then, we find and fit class centroids on the minimum number of lines using recursive regression (Sucholutsky et al., 2021). This method clusters centroids hierarchically to group similar (interval) centroids together, and fits a regression line on the centroids. The similarity of centroids within a single cluster is judged by how well all the centroids fit on a regression line. If the Euclidean distance of a particular centroid is beyond a pre-defined tolerance threshold ϵ from a line, it is removed from that cluster and assigned to another one. We use this method for all our experiments, as we experimentally find (on our dev data) that it performs well on high-dimensional data spread across many classes such as the ones we test here. In Appendix A.1, Figure 3a, we present an example set of lines connecting all centroids.

heading: 3.1.2 Learning soft-label prototypes
text: Once we find the lines, we use the endpoints of each line as the location of soft-label prototypes. Therefore, for l lines fitted on n centroids we have 2l prototypes. Then, we need to find the class distribution at each end point / soft-label prototype.
We develop and experiment with two different approaches to finding the class distributions, one based on constraint optimisation (constraintSLP), and another based on gradient descent (DeepSLP).

heading: Learning via linear constraints (constraintSLP)
text: One way in which we can approach this is via constraint optimisation and, specifically, an optimisation problem that consists of two main sets of constraints (Sucholutsky et al., 2021): (i) the target class at each centroid has the maximum influence amongst all classes at certain points along the line (endpoint of the line and midpoints between classes); and (ii) the difference between the influence of the target class and the sum of the influences of all other classes along the line is maximised. In order to make this approach powerful enough for large, high-dimensional NLP data, we require an optimiser that scales on such complex data. To this end, we use the MOSEK solver for linear programming (MOSEK ApS, 2019) in the CVXPY library (Diamond and Boyd, 2016) to perform the required computations to generate the soft-label prototype class distributions. The output of this is then a set of soft-label prototypes which “sit” at the ends of each line (i.e., X⃗) as shown in Appendix A.1, Figure 3b.

heading: Learning via gradient descent (DeepSLP)
text: Rather than use linear constraints to generate softlabel prototypes, we develop a novel gradient-based approach to generate soft labels as a function of an input x by minimising training loss on a few-shot dataset. After generating lines connecting all class centroids (Section 3.1.1), we set two soft-label prototypes at the ends of the lines. Each soft-label prototype pi is denoted by gi(f(x)) where g is a neural network parameterised by θi and f(x) is a point in the input space. The neural network consists of a fixed BERT (Devlin et al., 2019) encoder2 given by f(x), and a trainable linear layer which returns the soft-label probability distribution at any point x given by gi(x). Figure 1 presents a visual representation of our model. Compared to constraintSLP where we find soft-label probability distributions via linear constraint optimisation, we now parameterise our soft-label probability distribution with a neural network.
2We use BERT as our encoder given its comparatively higher computational efficiency, and do not include LLMs such as Llama and the GPT family as they have already been pre-trained on our test tasks (found here) and hence suffer from data contamination.
Algorithm 1: DeepSLP 1 λ← set of lines connecting all centroids 2 fθl is the network parameterised by θl for
the left-end prototype on a line 3 fθr is the network parameterised by θr for
the right-end prototype on a line 4 J ← loss function 5 D ← training data 6 Require λ ̸= ∅ 7 for i ∈ λ do 8 for epoch 1.....N do 9 pil ← location of left prototype
10 pir ← location of right prototype 11 for x ∈ minibatch(D) do 12 d1 ← ||pil − x|| 13 d2 ← ||pir − x|| 14 pred.append ( fθil (x)
d1 +
fθir (x)
d2
)
15 end 16 d_loss← J (pred,D) 17 loss1 ← d2d1+d2 ∗ d_loss 18 loss2 ← d1d1+d2 ∗ d_loss 19 θil ← θil − η∇θil loss1 20 θir ← θir − η∇θir loss2 21 end 22 end
Crucially, the encoder parameters are frozen as we need our input data points to have an unchanged location in the input space – changing their position might result in class centroids that were previously lying on a straight line to no longer lie on the line. The model is optimised using both soft-label prototypes along a line (see Algorithm 1 below and Section 3.2, Equation 1). Specifically, a higher distance between a data point x and a prototype leads to a correspondingly smaller effect of the prototype on the final classification; therefore, we want to penalise the prototype that is closer to x more if there is an incorrect classification. Each prototype is therefore assigned a fraction of the total loss that is proportional to the other prototype’s Euclidean distance from x. This way, the closer prototype’s weights are corrected more in case of a misclassification. The complete algorithm can be seen in Algorithm 1, while an example optimisation is presented in Figure 2.
We use cross entropy loss which gives a measure of the difference between the true and predicted labels. We initialise the weights of g1(x) and g2(x)
using a uniform Xavier initialisation (Glorot and Bengio, 2010) and use warmup steps to adjust the learning rate. Epochs vary based on the number of classes in the classifier head (between 15 and 25; see datasets used in Section 4): preliminary experiments on the development data show that more epochs are needed when a higher number of classes lie along a line.

heading: 3.2 Classification with soft-label prototypes
text: Given M soft-label prototypes representing the input distribution of N classes, we define S = (X⃗1, Y1), ..., (X⃗M , YM ) to be our set of prototypes, where X⃗i is the location of the ith prototype in the input feature space and Yi is a matrix of dimension [N × 1] denoting the soft labels. Given a test datapoint x⃗, we calculate the Euclidean distances D = (X⃗i, x⃗)i=1,2...M from each prototype to x⃗. We then sort S in ascending order of distances using D, weigh the probability distribution of the ith nearest prototype inversely by its distance to x⃗, and select the line containing the closest prototype to get Y ∗ (Sucholutsky et al., 2021):
Y ∗ = k∑
i=1
Yi
d(X⃗i, x⃗) (1)
As we consider the two nearest neighbours / prototypes, we set k to 2. x⃗ is then assigned the class CSLP (x⃗) = argmax
j Y ∗j where Y ∗ j is the j th el-
ement of Y ∗. In other words, we sum over the k-nearest soft-label prototypes (i.e., vectors) to x⃗, and weigh each prototype inversely proportional to its distance from x⃗. x⃗ is then assigned the class with the largest value in the resulting vector (see Appendix A.1 for a toy classification example).

heading: 3.3 Meta-training DeepSLP (MetaSLP)
text: We further test the suitability of soft-labels in highresource settings, tuning our text encoder using auxiliary training data. This is similar to the work of (Bansal et al., 2020a) that develop a meta-learning approach for few-shot learning of new, unseen tasks while utilising auxiliary training data. We employ a similar approach for rapid generalisation by utilising first-order meta-learning algorithms (which we describe in detail in Appendix A.2). Our model architecture is similar to DeepSLP – it comprises a BERT encoder with two linear layers on top. We train only the last v layers of our encoder to reduce computational overhead, where v is a hyperparameter (See Appendix A.6). We denote the encoder by fθ(x), and each soft-label prototype at the end of a line by g1 and g2, parameterised by θ1 and θ2 respectively. The difference between DeepSLP and MetaSLP is that MetaSLP is trained using metalearning (using auxiliary data described in Section 4), and the encoder fθ(x) in MetaSLP is fine-tuned (as opposed to being fixed in DeepSLP), following previous work (Bansal et al., 2020a).
Inner-loop training We optimise the soft-label prototypes in the same manner as DeepSLP; i.e., we use Algorithmn 1 to few-shot train the linear layers g1(x) and g2(x) parameterised by θ1 and θ2 respectively. However, meta-learning requires a large set of diverse and balanced meta-learning tasks for effective learning (Holla et al., 2020). To ameliorate this, we split the auxiliary datasets (Section 4) used for meta-learning into multiple pairwise tasks to meta-train MetaSLP (Bansal et al., 2020a). This means that, during training, we now consider a large number of two-class problems, as opposed to a small number of multi-class problems where the number of classes n ≥ 2. Such a setting also enables fine-tuning of our encoder fθ(x). In general, allowing the physical location of encodings to change (in this case via meta-learning’s inner-loop training process), may result in centroids originally connected by a line to no longer be connected by that line (i.e., in the next inner-loop optimisation step). However, if we only meta-train on tasks that focus on two classes at a time, this can trivially ensure that the same line is utilised each time. Our inner-loop optimisation process is given in Algorithm 3 in Appendix A.4.
Outer-loop training We perform meta-learning using the updated parameters in the inner-loop
training process. We experiment with both Reptile (Nichol et al., 2018) and FOMAML (Finn et al., 2017) as our meta-learning algorithms. Reptile can be considered a simpler variant to MAML-based meta-learning algorithms. We present our outerloop process in Algorithm 4, Appendix A.4.
Meta-testing We construct lines for the test sets using the trained MetaSLP model, and fine-tune them on the few-shot adaptation training data for each test task. We then use these lines for classification as described in Section 3.2.

heading: 4 Experimental settings and datasets
text: Experimental settings We experiment with two settings in terms of amounts of available data. The first is a limited-resource setting where we only train / fine-tune our models in a few-shot manner on small amounts of training data (i.e., in the absence of auxiliary training data). The other setting is a high-resource setting where we assume that auxiliary training data is available for additional training / fine-tuning.
Datasets We tackle few-shot learning of previously unseen tasks (i.e., not seen during training/fine-tuning), and so our work is similar to Bansal et al. (2020a). For our high-resource setting, we train and test our models on the same data as Bansal et al. (2020a) to ensure direct comparability. For our limited-resource setting, we test in the same way but do not utilise any auxiliary training data; i.e., we only utilise few-shot fine-tuning data for unseen tasks (i.e., only using a very small set of training/fine-tuning examples for the test tasks).
High-resource setting auxiliary training data Similar to Bansal et al. (2020a), we use GLUE (Wang et al., 2018) to train our models in the highresource setting. This dataset consists of a range of natural language tasks such as entailment, classification and textual similarity, which are used for model training and evaluation. We use only the training split for meta-learning. Similar to Bansal et al. (2020a), the MNLI (Williams et al., 2018) and SNLI (Bowman et al., 2015) entailment tasks, which are three-label classification problems, are split in a pairwise manner such that they are included as multiple two-label datasets during training. Following Bansal et al. (2020a), we also train for detecting the sentiment contained within phrases of a sentence by using the phrase-level annotations in SST2 (Wang et al., 2018). We utilise
the same validation sets – labelled Amazon review data from music, toys and videos for sentiment classification (Blitzer et al., 2007). We provide dataset and training details in Appendix A.5.
Evaluation data We use the same test datasets and evaluation setting as Bansal et al. (2020a) for both the high-resource and low-resource settings. These cover a variety of text classification tasks: (a) Entity typing – the CoNLL-2003 (Tjong Kim Sang and De Meulder, 2003) and MIT-Restaurant (Liu et al., 2013) datasets; (b) Review rating classification – review ratings from Amazon Reviews (Blitzer et al., 2007) with a three-way classification; (c) Text classification – scraped social media data from crowdflower comprising sentiment and emotion classification in a range of domains, as well as political bias detection; and (d) Natural language inference in the scientific domain – the SciTail dataset (Khot et al., 2018). We use the same data splits, which are publicly available. During evaluation, Bansal et al. (2020a) fine-tune their models using a small few-shot (support) training set per test task (using a k-shot setting of 4, 8, 16 examples per class), and then evaluate performance on each task’s dedicated, unseen test set. As model performance can be affected by the k examples chosen for training/fine-tuning, for each task and for every k, they sample 10 few-shot training sets and report the mean and standard deviation, which we also adopt in our experiments.

heading: 5 Baselines
text: Our aim is to determine how well our models – DeepSLP and MetaSLP – perform in the low and high-resource setting respectively, compared to strong baselines when given the same few-shot adaptation sets. Our focus is on (a) evaluating in an extreme few-shot learning scenario where no auxiliary data is available (using DeepSLP), and (b) evaluating in a high-resource setting when additional (auxiliary) training data is available (MetaSLP). We use BERT (Devlin et al., 2019) as our text encoder throughout to facilitate model comparisons. We report DeepSLP and MetaSLPREPTILE (i.e., using Reptile as our meta-learning algorithm) in our main table of results (given their effectiveness), and present additional baselines as well as hyperparameters and training details in Appendix A.6.
We use BERT (Devlin et al., 2019) as our encoder as it is a text encoder that allows us to get passage-level encodings, it is computationally light-
weight compared to decoder-based LLMs such as Llama (Touvron et al., 2023) and GPT (OpenAI, 2024) (and we can carry out full fine-tuning) and, crucially, it does not suffer from data contamination as, in contrast to the more recent LLMs, it has not been pre-trained on our test data3.

heading: 5.1 Low-resource setting baselines
text: BERTfine-tuned We use BERTfine-tuned reported in Bansal et al. (2020a), which is fine-tuned (all layers) on the few-shot training set of each test task.
LORABERT LORA (Hu et al., 2022) decomposes a fine-tuned weight matrix to two low-rank matrices, which – when multiplied and added to the original weights – reproduce the fine-tuned weights. This is advantageous as, instead of fine-tuning all parameters, we fine-tune these two matrices with a low computational cost, as they are much smaller individually compared to fully fine-tuned weights.
constraintSLP We use constraintSLP as a baseline to evaluate the effectiveness of soft-label prototypes that are based on linear constraints.

heading: 5.2 High-resource setting baselines
text: Reptile We train a meta-learning Reptile (Nichol et al., 2018) model on our auxiliary data and use it as another baseline. This allows us to directly assess the added advantage of utilising SLPs in MetaSLPREPTILE.
Prototypical Networks We use ProtoNet (Snell et al., 2017) as another baseline for both the high and low-resource settings. ProtoNets use Euclidean distance as a measure of similarity between points and clusters, which is similar to DeepSLP and MetaSLP that assign test points to the closest line.
LEOPARD Bansal et al. (2020a) present LEOPARD, a meta-learning algorithm that achieves the best performance across most test tasks for entity typing, ratings classification and text classification, and which we also use.
We do not include HSMLMT (Bansal et al., 2020b) as a baseline as it is pretrained on semisupervised meta-training tasks in addition to supervised learning and therefore it is not directly comparable.
3https://github.com/iesl/leopard/tree/master/ data/json

heading: 6 Results and Discussion
text: Due to space restrictions, we present and discuss our best models in Table 1. All other baselines and results are discussed in Appendix A.7.
Low-resource setting In the low-resource setting with no auxiliary data (left side of Table 1), DeepSLP outperforms all baselines, including BERTfine-tuned in 31/48 tasks and LORABERT in 45/48 tasks, achieving a new state-of-the-art result. Our results demonstrate the usefulness of soft-label prototypes and their superiority over strong baselines (i.e., LLM fine-tuning and LORA / low-rank adaptation) in the low-resource setting.
Unlike BERTfine-tuned, DeepSLP and LORABERT do not fine-tune the encoder. Specifically, we only need to fine-tune 1500−10K parameters (based on the number of classes) for each line with two softlabel prototypes for DeepSLP, compared to 50K − 100K parameters for LORABERT with rank = 2, and > 108 parameters for BERTfine-tuned. We also note that DeepSLP is lightweight and does not require a GPU. LORABERT mostly achieves accuracies within 90% of BERTfine-tuned, in line with previous work (Hu et al., 2022; Dettmers et al., 2023) (even outperforming BERTfine-tuned in 15/48 tasks), except for entity-typing tasks where LORABERT struggles to generalise and achieves substantially lower performance compared to BERTfine-tuned.
On the other hand, constraintSLP, a simpler variant of DeepSLP (see Appendix A.7, Table 5 for results) is one of the lower performing baselines, together with ProtoNet. We find that constraintSLP exhibits a substantial weakness (see further details in Theorem A.2, Appendix A.3): given Euclidean distance, constraintSLP does not always select the nearest class centroid to a test point. This violates our inductive bias that points located closest to a class centroid are assigned to that class. If we consider the case where N = 2, constraintSLP essentially acts as a 1-NN with soft labels trivially at [1, 0] and [0, 1], with class centroids acting as the nearest neighbour. However, when generalising beyond this setting, the model’s stability is affected. constraintSLP optimises soft labels using the geometric properties of a line and does not consider each (training) data point individually – the soft labels produced by SLP are constants. DeepSLP, on the other hand, learns from training data and produces soft labels as a function of the input; therefore, it has the ability to output soft labels based on the location of an input (test) point (with
the location of the prototypes being fixed).
High-resource setting MetaSLPREPTILE has the highest performance overall in text classification and entailment tasks (Tasks 1-14), with the best accuracy in 33/42 tasks/settings. LEOPARD, on the other hand, achieves the highest score in only 8/42. Interestingly, we find that all models in the highresource setting have lower performance for Disaster compared to the models in the low-resource setting. We surmise this to be due to the auxiliary data and the fact that the meta-training distribution differs substantially from the test distribution.
For entity typing tasks (CoNLL and Restaurant), LEOPARD outperforms all models, with MetaSLPREPTILE and Reptile performing comparatively poorly, even outperformed by the lowresource methods (DeepSLP and BERTfine-tuned). It should be noted that there seems to be little benefit of meta-learning with auxiliary data when tackling entity typing tasks, even for LEOPARD, as the difference between LEOPARD and BERTfine-tuned is not substantial. We surmise this to be due to the fact that the meta-training distribution (i.e., GLUE tasks) is different from the test distribution for entity typing tasks which degrades performance for the test tasks. Note that we do not meta-train the entire model (only top 4 layers for Reptile and MetaSLPREPTILE), unlike LEOPARD.
Overall, MetaSLPREPTILE outperforms all models and baselines, including Reptile in 42/48 tasks and LEOPARD in 34/48 tasks. Specifically, MetaSLPREPTILE consistently outperforms Reptile, demonstrating the effectiveness of our approach over its meta-learning variant (i.e., Reptile) that does not use SLPs. In Appendix A.8 we present detailed analyses of DeepSLP and show that it displays several desirable properties of ensemble methods which drive its performance, in addition to it being a computationally efficient approach that only utilises a small number of parameters.

heading: 7 Conclusion and future work
text: We presented a novel few-shot learning paradigm that is based on soft-label prototypes capturing the simultaneous membership of data points over several classes, and demonstrated its effectiveness in low and high-resource settings. We evaluated our approach on 48 different tasks / settings and showed that it outperforms a range of strong baselines. In the future, we plan to use meta-learning algorithms such as PACMAML (Ding et al., 2021)
and Bayesian MAML (Kim et al., 2018) that relax assumptions with respect to train–test set distributions and thus alleviate this current limitation in our work.

heading: 8 Ethics
text: To the best of our knowledge, there are no ethical concerns involved in this research. We conduct our work using publicly available English datasets and tasks, and models pre-trained on English text. Our results may not generalise to other languages. To facilitate further research in the field, we release our source code and models.

heading: A Appendix
text: A.1 Deriving soft-label prototypes using constraintSLP
Finding lines connecting all centroids In Figure 3a, we present an example set of lines connecting all class centroids. For further details on recursive regression, we refer the reader to Sucholutsky et al. (2021).
Deriving soft-label prototypes by optimising for linear constraints Example soft-label prototypes which are “set” at the ends of each line are shown in Figure 3b.

heading: Classification with constraintSLP: A toy example
text: Figure 4 presents an example classification with soft-label prototypes. Given the class centroids for blue, green and yellow are located at (0, 0), (1.5, 0) and (3, 0) respectively, two soft-label prototypes are defined by a line connecting yellow and blue, and are thus located at (3, 0) and (0, 0) respectively. The soft labels in Figure 4a contain
the per-class probability distribution derived by the constraintSLP method; for example, p(x = blue) = 0.6 and p(x = green) = 0.4 for the left prototype, and p(x = green) = 0.4 and p(x = yellow) = 0.6 for the right prototype. When a new test instance x located at (1.5, 0.8) is presented, we make predictions as follows: we find the nearest line to x and consider its distance from the two prototypes at the ends of the line and multiply the class distribution of each prototype by the inverse distance as per Eq. 1.
Since x is equidistant from both prototypes, the distance between the x and each prototype is 1.5. Therefore, the values for blue and yellow (given both soft-label prototypes) become soft_label(x = blue) = 0.61.5 + 0 1.5 = 0.4 and soft_label(x = yellow) = 01.5 + 0.6 1.5 = 0.4 respectively. In contrast, for green, which is directly informed by both prototypes (i.e., no zero values in the numerator), the probability distribution becomes soft_label(x = green) = 0.41.5 + 0.4 1.5 = 0.53. Therefore x is classified as green. This decision boundary can be seen in Figure 4b.

heading: A.2 Meta-learning
text: For encoder-based models, meta-learning has emerged as a viable methodology for few-shot learning. In the meta-learning paradigm, the training and test sets, referred to as Dmeta-train and Dmeta-test, are split into episodes. Each episode encompasses a task T i and consists of a support set D(i)support and a query set D(i)query. Metalearning algorithms initially fit the model on the support set of the episode (inner-loop optimisation) and then achieve generalisation across episodes by optimising performance on the query sets of the episodes (outer-loop optimisation). For evaluation, the model is first fine-tuned on the support set and then evaluated on the query set for each task T i ∈ Dmeta-test. We describe the process algorithmically in Algorithm 2 and describe the MetaUpdate process for different algorithms subsequently.
Algorithm 2: Meta-learning 1 α, β ← learning rates 2 Sample batch of tasks {Ti} ∼ p(T ) 3 Initialise θ′i ← θ 4 for Ti ∼ p(T ) do 5 Partition Ti into Dsi and D q i 6 θ′i ← θ − α∇θLsDi(fθ) for k steps 7 end 8 θ ←MetaUpdate(θi, Dqi , β)
Model Agnostic Meta-Learning MAML (Finn et al., 2017) is an optimisation-based metalearning approach which incorporates generalisability across tasks in its cost function. The task loss LqTi is computed on the query examples in each episode, using this task-specific model. The initial model parameters θ are then updated so as to minimize the sum of the losses of all tasks in a batch, leading to improved generalisation across tasks. The MetaUpdate step is thus defined as
θ ← θ − β ∇θ ∑
Ti∼p(T ) LqDi(fθ′i)
Note that the MetaUpdate expression calculates the gradients of each θi with respect to θ, thus necessitating the computation of second-order gradients. To ease computation, we use a first-order approximation of MAML (FOMAML) wherein the gradients of each θi are calculated with respect to θi and reduce the MetaUpdate term to
θ ← θ − β ∇θi ∑
Ti∼p(T ) LqDi(fθ′i)
LEOPARD Bansal et al. (2020a) employ metalearning for diverse NLP tasks in an approach inspired from MAML which integrates a text encoder model with a meta-learned parameter generator to tailor task-specific initialisations for the classification head. Their inner-loop update learns the parameter generator for the task, adapts task-specific model parameters and the MetaUpdate step adapts model parameters as done in MAML. They show that their method, LEOPARD, outperforms multitask trained models as well as a range of other meta-learning methods.
Reptile This meta-learning algorithm, introduced by Nichol et al. (2018), is computationally simple compared to MAML and LEOPARD - the MetaUpdate step simply moves the model parameters towards inner-loop fine-tuned model parameters, thus assuming the form:
θ ← θ + β 1|{Ti}| ∑
Ti∼p(T ) (θi − θ)
Despite it’s simplicity, it reports strong performance on a variety of few-shot learning tasks (Dou et al., 2019).
Prototypical Networks Unlike optimisationdriven meta-learning methods, Prototypical Networks (Snell et al., 2017) is a metric-based metalearning method that uses an embedding function fθ to encode training support samples and compute a high-dimensional vector µc that is the arithmetic mean of the training data points of class c. It then uses a distance function d to compute the similarity between a query instance x and the mean vector of
each class to get the class distribution as:
p(y = c|x) = softmax(−d(fθ(x), µc))
= exp(−d(fθ(x), µc))∑
c′∈C exp(−d(fθ(x), µ′c)) Model optimisation is done using the loss function J(θ) = −log(p(y = c∗|x, θ)).
A.3 Analysis of soft-labels derived from linear constraints: constraintSLP
Theorem A.1. The soft-label value of each class within a single soft-label prototype generated using constraintSLP is inversely proportional to its distance from the soft-label prototype along the line connecting all classes captured by it.
Proof of Theorem A.1 (Informal) Consider a line l connecting three class centroids (while we focus on a three class system, the conclusions generalise to n > 3 classes too). The class centroids are represented by A, B and C. The soft-label prototypes at ends A and C contain the values [a1, a2, a3] and [c1, c2, c3] respectively. Consider a support example x ∈ A at a distance da and db from A and C respectively. Directly using the constraints in Algorithm 4 of Sucholutsky et al. (2021), we state that the influence of A (i.e., the distance-weighted sum of the soft-labels at x) should be more than the sum of the influence of the other two classes. Thus, we need to maximise:
a1 da + c1 db > ( a2 da + c2 db ) + ( a3 da + c3 db ) (2)
As we move x further towards A, da → 0 and the influence of [a1/d1, a2/d2, a3/d3] increases thus ∑i=3 i=2 ci/db <<< ∑i=3 i=2 ai/da. Therefore we have the approximation: a1 da > a2 da + a3 da =⇒ a1 > a2 + a3 (3) If we take a support example x ∈ C, by symmetry as x is moved towards C, db → 0, we can also write:
c3 db > c2 db + c1 db =⇒ c3 > c2 + c1 (4)
Furthermore, consider a point x in the middle of l equidistant from A and C (by a distance d) – such a point will always be classified as x ∈ B. Thus, the influence of B should be higher than both A and C. Thus we have: a2 d + c2 d > a1 d + c1 d & a2 d + c2 d > a3 d + c3 d
=⇒ a2 + c2 > a1 + c1 & a2 + c2 > a3 + c3
From Equation 3 and Equation 4 we can replace a1 and c3 and get:
a2 + c2 > a2 + a3 + c1 =⇒ c2 > c1 a2 + c2 > a3 + c2 + c1 =⇒ a2 > a3
Therefore, we have:
a1 > a2 > a3 & c3 > c2 > c1
This is an intuitive result as the soft-label value of each class decreases as the distance of the class centroid increases from the prototype location – the class nearest to the prototype has the highest soft-label value and the class furthest away has the lowest soft-label value.
Recall that ∑3 i=1 ai = 1 and ∑3
i=1 ci = 1 and ai, ci ≥ 0 ∀i = {1, 2, 3} otherwise the optimisation problem becomes unbounded. Therefore, the ranges of values for [a1, a2, a3] and [c1, c2, c3] are:
a3 ∈ [0, a2), a2 ∈ (a3, a1), a1 ∈ (a2, 1] c3 ∈ (c2, 1], c2 ∈ (c1, c3), c1 ∈ [0, c2)
Using Algorithm 4 in Sucholutsky et al. (2021), we see that there are multiple constraints for a1 and a2 which require them to be maximised, but there are none for a3. Thus, to maximise Equation 3, a3 adjusts to the minimum value it can get:
a3 = min(0, a2) = ϵ ≃ 0 By symmetry, we can also conclude that:
c1 = min(0, c2) = ϵ ≃ 0 These approximations are also generalisable to multiple classes connected by a line, for example, if a line connects only two centroids, the soft-labels at each end are derived as [0, 1] and [1, 0] - the same as a “hard" label. These findings are substantiated experimentally in Table 2 where we examine the soft-labels generated by DeepSLP and constraintSLP using a few-shot training support set of the task airline with 8 examples per class – the constraintSLP soft label corresponding to the furthest class from the prototype location drops to almost zero compared to other soft label values. On the other hand, DeepSLP prevents overfitting on the nearest classes and produces a more generalised distribution of soft-labels. This is a trend generally observed in other tasks and classes as well. We further use this theorem to prove the main theorem given by Theorem A.2. Theorem A.2. The constant soft-labels in constraintSLP do not always select the closest class centroid to a test point.
Proof of Theorem A.2 (Informal) Furthermore, consider a line b perpendicular to l – it intersects l between A and B. We select θ such that ϕ = π/2. We denote the complete setup diagrammatically in Figure 5.
Consider the distance weighted influences at x for class A. We have the influence as a1sinθe + c1cosθ
e = a1sinθ e as c1 ≃ 0. Similarly, for class B, we have the weighted influence as a2sinθe + c2cosθ e . To calculate values of θ where the weighted influence of B is more than the weighted influence of A, we get:
a2sinθ
e +
c2cosθ
e >
a1sinθ
e =⇒ a2sinθ + c2cosθ > a1sinθ =⇒ c2cosθ − (a1 − a2)sinθ > 0 =⇒ c2cosθ − (a1 − a2)sinθ√ c22 + (a1 − a2)2 > 0
=⇒ cos(θ + α) > 0
where α = tan−1 ( a1−a2
c2
) . Since cos(θ+α) > 0
a Denoting the decision boundaries calculated with constraintSLP. Green represents points classified as class A, pink represents the points classified as class B, and brown represents the points classified as C.
we have (θ + α) ∈ (−π/2, π/2) and since θ > 0, thus for θ ∈ [0, π/2− α), the weighted influence of B is more than the weighted influence of A.
However, it is worth observing the result for θ derived above can contain points closer to A (using Euclidean distance) which are actually classified as B. We can easily demonstrate this with a counter example explained in Figure 6.
Therefore, for points closer to A compared to B using an Euclidean measure, constraintSLP can still return a higher value for the influence at B compared to A. This adversely affects performance in classifiers where we rely on selection of the closest class centroid for classification – such as
Algorithm 3: Inner-loop training of MetaSLP 1 Ti ← meta-training task 2 L ← line connecting both centroids of a
task 3 α← inner-loop learning rate 4 S ← inner-loop optimisation steps 5 Initialise g1x(x) and g2(x) randomly 6 while s < S do 7 Sample support examples Xs for Ti 8 Calculate locations of each soft-label prototype in L 9 Use Equation 1 to classify x ∈ Xs 10 Calculate ∇LTi(fθ(x), g1(x), g2(x)) 11 Scale∇ϕLTi(g1(x)) and
∇ωLTi(g2(x)) by the distances from the soft-label prototypes
12 θ′i ← θ − α∇θLTi(fθ(x)) 13 θ′1i ← θ1 − α∇ϕLTi(g1(x)) 14 θ′2i ← θ2 − α∇ωLTi(g2(x)) 15 end
1-NN, Prototypical Networks, and constraintSLP – and we believe this is the reason behind the poor performance of constraintSLP for cases where the total classes is greater than two.

heading: A.4 Training algorithms for MetaSLP
text: Inner-loop training Our inner-loop training algorithm for MetaSLP is presented in Algorithm 3. The inner-loop encoder optimisation can be understood as updating the parameters of the encoder to “push” different classes away from each other and “pull” points belonging to the same class together; i.e., increase inter-class distance and decrease intraclass distance which leads to well-defined clusters per class. We present this process in Figure 7.
Outer-loop training Our outer-loop training algorithm is presented in Algorithm 4.

heading: A.5 Meta-training details
text: GLUE (Wang et al., 2018) tasks and their details are provided in Table 3. These tasks include MNLI (Williams et al., 2018), SST2 (Socher et al., 2013), CoLA (Warstadt et al., 2018), MRPC (Dolan and Brockett, 2005), QQP (Wang et al., 2017), QNLI (Wang et al., 2018), RTE (Giampiccolo et al., 2008) and SNLI (Bowman et al., 2015). We employ the same tasks as Bansal et al. (2020a) to ensure direct comparability. Note that the datasets and
Algorithm 4: Outer-loop training of MetaSLP 1 T ← batch of meta-training tasks, |T | = n 2 M← batch of distinct inner-loop
optimised models parameterised by θi, |M| = n
3 β ← outer-loop learning rate 4 for Ti, Mi ∈ T , M do 5 if FOMAML then 6 Sample query examples Xq for Ti, Xs ∩Xq = Φ 7 Use Equation 1 to classify x ∈ Xq 8 Calculate ∇θ′iLTi(fθ′i(x), gϕ′i(x), hω′i(x)) 9 Update∇θLTi(fθ(x))+ =
∇θ′iLTi(fθ′i(x), gϕ′i(x), hω′i(x)) 10 end 11 if Reptile then 12 Update∇θLTi(fθ(x))+ = θ − θi 13 end 14 end 15 Update θ ← θ − βn ∑n i=1∇θLTi(fθ(x))
classes in GLUE are completely different from the datasets used for evaluating the model - thus the final model fine-tunes on unseen few-shot data and learns classes it has previously not encountered.
To train our model to detect the sentiment contained within phrases of a sentence by using the annotations for phrases within sentences for SST2, we append a separator token and the annotated phrase for each sentence at the end of the sentence in the form “[CLS] <sentence_1> [SEP] <sentence_2> [SEP]" and obtain the passage level embedding for training.

heading: A.6 Hyperparameters
text: Generating lines The hyperparameters used to generate lines are: (a) ϵ, which is a control factor used to denote the maximum tolerance between a centroid and the line assigned to it using Euclidean distance—we use a tolerance value of 1e− 1; and (b) l, which denotes the maximum number of lines used to connect all centroids. We experiment with a range of values (l ∈ {0.25n, 0.5n, 0.75n, n− 1}, where n is the number of centroids), but find l = ⌈n/2⌉ to give the best accuracy on the validation data with the minimum number of lines required.4
DeepSLP For DeepSLP, we find that more epochs are needed to train models with a higher number of soft labels (i.e., a higher number of classes in the output of the classifier head) - essentially, 3 classes fitted on a line need more epochs compared to 2 classes fitted on a line. We use AdamW (Loshchilov and Hutter, 2017a) as our optimiser and perform hyperparameter tuning on the validation set. We only need a few epochs (5 to 10) to generalise well depending on the training task. We fix a random seed, train our models and evaluate performance on the test tasks. We repeat
4The right choice of hyperparameters is key as the optimisation process fails when it is not possible to connect n centroids with l lines.
this process across three different seeds and report the mean and standard deviation. Hyperparameters for all baselines in this setting can be found online in our code repository5.
Meta-training For inner-loop optimisation, we use SGD as an optimiser with Nesterov and a momentum factor. We use a cosine annealing learning rate scheduler (Loshchilov and Hutter, 2017b) on our outer-loop learning rate to decay the learning rate from a starting rate to an end rate without restarts across one epoch for MetaSLPREPTILE. We use AdamW (Loshchilov and Hutter, 2017a) as our outer-loop optimiser with AMSGrad (Reddi et al., 2018). We employ early stopping and stop training if our model does not improve it’s validation set accuracy over 100 batches. We use learnable inner-loop learning rates for MetaSLPFOMAML per parameter group for better optimisation as indicated by previous literature (Antoniou et al., 2019). All meta-training hyperparameters can be found in Appendix A.6, Table 4.
Meta-testing Similar to inner-loop optimisation at meta-training, we use SGD with Nesterov and the same optimiser hyperparameters. However, we decay the learning rate using a cosine scheduler across all fine-tuning epochs to prevent overfitting on the few-shot (support) training set per task for MetaSLPREPTILE.

heading: A.7 Results
text: The complete set of results of all models and baselines can be seen in Table 5 for the low-resource setting and DeepSLP, and Table 6 for the highresource setting and MetaSLP.
5<anon-url>
DeepSLP Our results (Table 5) demonstrate that DeepSLPBERT outperforms BERTfine-tuned in 31/48 tasks, constraintSLPBERT in 43/48 tasks and LORABERT in 45/48 tasks, demonstrating the usefulness of soft-label prototypes and superiority over the “standard” LLM fine-tuning paradigm, as well as the simpler constraintSLP variant. constraintSLPBERT, on the other hand, fares worse than BERTfine-tuned and LORA, outperforming the former in only 19/48 tasks and the latter in 25/48 tasks, while exhibiting high standard deviations which can be explained by Theorem A.2, as constraintSLP can behave erratically and not select the closest point to the class centroid. Overall, DeepSLP is the best performing method, demonstrating the highest accuracy in 31/48 tasks, while being on-par with the second best model (BERTfine-tuned) on the remaining tasks (15/48 tasks). Fine-tuned BERT is, overall, the next best model with 13/48 tasks while constraintSLP achieves the best performance amongst all methods in only 1/48 tasks. ProtoNet’s comparatively lower performance can be explained by the fact that meta-learning approaches tend to require a large number of diverse and structured metatraining tasks for effective learning — thus not making them readily suited for (extreme) few-shot learning settings.
MetaSLP In Table 6, MetaSLPREPTILE outperforms all baselines achieving the highest performance in 33/48 tasks. LEOPARD is the next best model with the highest performance in 11/48 tasks. Interestingly, MetaSLPFOMAML does not fare as well as MetaSLPREPTILE and achieves the highest performance in only 1/48 tasks while outperforms LEOPARD in only 6/48 tasks. MetaSLPFOMAML nevertheless outperforms
MetaSLPREPTILE and Reptile in natural language inference tasks – demonstrating the usefulness of learnable inner-loop learning rates across multiple task distributions while meta-training.

heading: A.8 Ensemble properties of DeepSLP
text: In this study, we compare and contrast DeepSLP to ensembles and draw similarities between the two, shedding further light into the effectiveness of our approach. Each prediction decision by DeepSLP is the result of two soft-label prototypes – those that lie on each end of the line nearest to a test point x. An analogy can then be drawn between the prototypes used at prediction time and those individual (albeit independent) models that are utilised by an ensemble when producing the final classification.
While DeepSLP prototypes are not independent but are rather trained jointly (and share the same encoder), in what follows, we demonstrate that they display several properties of ensemble methods, while being computationally efficient and utilising a small number of parameters. For the analyses below, we consider the tasks Airline and Disaster using an 8-shot setting and evaluate on the test data for each. However, we find the below properties to generalise across all tasks.
A.8.1 Individual vs joint prediction In a similar way as an ensemble exhibits superior performance to the individual models it utilises, we seek to assess whether the joint utilisation of prototypes at prediction time is indeed more effective than utilising each prototype individually. To evaluate this, we measure the probability distribution of each setting on the test data using negative log-likelihood:
NLL(f(x), y) ≜ −log(f (y)(x)) Following Abe et al. (2022), for a strictly convex function such as NLL, we use Jensen’s inequality:
NLL(F(x), y) ≤ E[NLL(f(x), y)]
where F (x) is the ensemble and f(x) are the constituent models. The idea is that the probability distribution of the ensemble fits the target distribution more closely than the corresponding expected probability distributions of its constituent models. For joint soft-label prototypes parameterised by g1 and g2 and located at p1 and p2, we have:
NLL ( softmax ( g1(f(x))
||f(x)− p1|| ) +
g2(f(x))
||f(x)− p2||
) , y )
= − ∑ log ( softmax ( gy1 (f(x))
||f(x)− p1|| ) +
gy2 (f(x))
||f(x)− p2||
))
For the individual soft-label prototypes, weighing the outputs by distance does not change the final softmax probability distribution; therefore, we can define E[NLL(f(x), y)] as their average:
−1 2
∑ log(softmax(gy1 (f(x)) + log(softmax(g y 2 (f(x))
We plot the negative log likelihoods for Airline and Disaster on the test set after fine-tuning each model on ten subsets of few-shot training data (as explained before in Section 4) in Figure 8 to assess whether DeepSLP exhibits this property of ensemble methods. We find that NLL(F(x), y) is much lower than E[NLL(f(x), y)], which confirms that the joint utilisation of prototypes results in better predictions than if they were to be used individually. Our experiments confirm that this is a general trend we observe across tasks. In the following sections, we investigate the reasons behind the high values observed for E[NLL(f(x), y)], and compare the jointly trained prototypes against a strong baseline, the fine-tuned BERT baseline.
A.8.2 Jointly utilised soft-label prototypes improve diversity
Diversity in ensemble classifications refers to the difference in the probability distribution on out-ofdistribution (ood) data for classifications between
individual models and the ensemble. We use this definition to ascertain the diversity of classifications provided by the jointly utilised soft-label prototypes. Diversity is a desirable property as ensemble predictions are generally more robust due to diversity between the predictions of their individual members (Lee et al., 2015).
Existing work (Ashukha et al., 2020; Lakshminarayanan et al., 2017) defines ensemble uncertainty as the sum of ensemble diversity and the expected average model uncertainty on ood data. Based on Abe et al. (2022), it is calculated as:
H([y|F (x)] = −1 C ∑ p(yi|F (x))log(p(yi|F (x)))
If we use the Jenson-Shannon divergence as a diversity measure for an ensemble given by
JSDp(f)[y|f(x)] = 1
M
∑ KL[y|f(x)||y|F (x)]
where KL is the average KL divergence between the output distribution of each soft-label prototype and the jointly utilised soft-label prototypes, from Abe et al. (2022), this expression reduces to: H([y|F (x)] = ens. diversity JSDp(f)[y|f(x)] + avg. model uncert.
Ep(f)[H[y|f(x)]] We contrast ensemble uncertainty and single
model uncertainty using the fine-tuned BERT model for the task airline in Figure 9, but note that similar trends are observed across all tasks. We note that the uncertainty of jointly utilised softlabel prototypes is generally higher than that of the fine-tuned BERT model. As the average model uncertainty of individual soft-label prototypes is negligibly low, the uncertainty in the joint case is driven mainly by the diversity of the ensemble.
This is in line with previous work which attributes an increase in uncertainty in ensembles due to diversity (Lakshminarayanan et al., 2017; Dietterich, 2000; Wilson and Izmailov, 2020). Though not strictly an ensemble, our approach exhibits similar properties (higher uncertainty driven by model diversity), as well as a general reduction in standard deviation compared to fine-tuned BERT.
The above provide evidence that our approach as a whole exhibits desirable properties of ensembles which drive a higher performance but which do not lead to higher training time nor compute.

heading: Future Work
text: In the future, we plan to use meta-learning algorithms such as PACMAML (Ding et al. , 2021)
and Bayesian MAML (Kim et al. , 2018) that relax assumptions with respect to train–test set distributions and thus alleviate this current limitation in our work