Adam-Smith at SemEval-2023 Task 4: Discovering Human Values in Arguments with Ensembles of Transformer-based Models
Year: 2023

Abstract:
This paper presents the best-performing approach alias "Adam Smith" for the SemEval2023 Task 4: "Identification of Human Values behind Arguments". The goal of the task was to create systems that automatically identify the values within textual arguments. We train transformer-based models until they reach their loss minimum or f1-score maximum. Ensembling the models by selecting one global decision threshold that maximizes the f1-score leads to the best-performing system in the competition. Ensembling based on stacking with logistic regressions shows the best performance on an additional dataset provided to evaluate the robustness ("Nahj al-Balagha"). Apart from outlining the submitted system, we demonstrate that the use of the large ensemble model is not necessary and that the system size can be significantly reduced.

heading: 1 Introduction
text: "We should ban whaling, whaling is wiping out species for little in return." say some, "We shouldn’t, it is part of a great number of cultures." say others. Both arguments support their claim, but why are some arguments more convincing to us than others? This might relate to the underlying values they address. Whereas the first argument appeals to the value of "universalism: nature", the second one addresses the value of "tradition". Whether an argument is in agreement or disagreement with our values influences its ability to persuade. The task organizers (Kiesel et al., 2023) are the first who extend the field of argument mining by this "value" dimension. As part of the SemEval-2023 workshop, they organize the task of automatically detecting human values behind arguments. They decided to add two additional test datasets to evaluate the robustness of the developed systems (Mirzakhmedova et al., 2023).
Our system uses an ensemble of transformerbased models that are either trained until they reach
their loss minimum or the f1-score maximum. To ensemble the models we average the individual predictions and calculate a decision threshold for the final system on a separate "Leave-out-Dataset". This model achieves the best performance in the competition ("Main" dataset). Each team was allowed to submit up to four systems. Ensembling the predictions by using stacking with logistic regressions leads to the system with the best performance on the additional "Nahj al-Balagha" dataset. In this paper, we describe the best-performing system on the "Main" dataset and briefly outline the ideas behind the other submitted systems.
The system can be accessed through a web-based interface that is available online1. Furthermore, a docker container, models, and code are open source and publicly accessible (Appendix A).

heading: 2 Background
text: Mirzakhmedova et al. (2023) created a labeled dataset of 9324 arguments from 6 different sources. The arguments are structured as follows:
The arguments are in English and in total there are 20 different value categories to predict. Each argument is labeled with one or multiple values. Hence the task at hand can be characterized as a multi-labeling problem. The systems can be tested against two additional datasets to evaluate their robustness on unseen data from different domains. The "Nahj al-Balagha" dataset contains arguments from Islamic religious texts. The "New York Times" dataset contains arguments from texts about
1https://values.args.me/
532
COVID-19. A detailed introduction to the datasets can be found in Mirzakhmedova et al. (2023). The task organizers (Kiesel et al., 2023) created two baseline models: 1-baseline and a BERT-based system. The system we propose builds upon the transformer architecture by Vaswani et al. (2017) and in particular the BERT model (Devlin et al., 2018). In fact, we use two improved versions of the original BERT model called RoBERTa (Liu et al., 2019) and DeBERTa (He et al., 2021). Further, we apply wellknown techniques from the field of practical AI such as ensembling (Zhou, 2012), cross-validation and early-stopping (Goodfellow et al., 2016). By presenting the best-performing system in the task and outperforming the baselines by a large margin, this paper delivers valuable insights into how values can be automatically detected within text.

heading: 3 System Overview
text: This section is dedicated to precisely describing the best-performing submission as a baseline for future research and further development. The proposed system is an ensemble of 12 individual models. Figure 1 provides an overview of the inference pipeline of the final system. We briefly outline the process of making a prediction and subsequently describe each of the individual steps in detail. To make a prediction the following steps are performed:
1. We take an input argument and concatenate the premise, stance, and conclusion.
2. The input is then fed into the neural networks. The output of each neural network is a vector containing 20 values with the "confidence" (values between 0 and 1) whether the sample has the corresponding label. The final system consists of 12 models, so we get 12 of these vectors.
3. We ensemble the opinions of the models by taking the average of the 12 vectors per label.
4. As we now have the averaged values for each of the 20 labels we must decide which labels to assign. Therefore we use a threshold. For the values in the vector that are above the threshold, the corresponding label is assigned.

heading: 3.1 Data Preprocessing
text: Transformer-based models are trained on large corpora of natural text. Hence, it seems reasonable to transform the input in a format that is most similar to a human-like formulation. Therefore we concatenate the premise, stance and conclusion into a single text string. This transforms the above ex-

heading: Average predictions
text: ample (Table 1) into whaling is part of a great number of cultures against We should ban whaling.

heading: 3.2 The Models
text: The final system is an ensemble of 12 individual models that are based on the transformer architecture. Each model has the same structure: It consists of a transformer-based language model with one additional fully connected linear layer on top. We use the CLS token as input for the additional layer as described by Devlin et al. (2018). The sigmoid function maps the values for each label to the (0,1) interval.
We use two deviations of BERT (Devlin et al., 2018), namely "microsoft/deberta-large" ("Deberta") and a pretrained roberta-large model ("IBMRoberta") as base models. They are then optimized for loss minimization or f1-score maximization leading to four different configurations as depicted in blue in Figure 1. Each of the four configurations is trained on 3 folds, leading to the 12 models in the final system (Table 9 in the Appendix). In the following sections, we describe the different configurations in more detail.

heading: 3.2.1 Pretraining
text: According to Mirzakhmedova et al. (2023) 83% of the arguments are retrieved from the IBM-ArgQRank-30kArgs dataset (Gretz et al., 2019). We pretrain our models on the IBM-dataset using masked language modeling (Devlin et al., 2018) to shift the language understanding capabilities of our model
towards the specific language in the arguments. Table 2 shows that pretraining only improves the roberta model but not the deberta model. Subsequently, we proceeded with the pre-trained roberta model (IBM-Roberta) and used the deberta model in its base version.

heading: 3.2.2 Optimizing for Loss and f1-score
text: A traditional training procedure requires a trainvalidation split. To prevent models from overfitting, the training is stopped as soon as the validation loss reaches its minimum. Within the task, the models are evaluated against the f1-score. So instead of training until the minimum loss is reached we train the models until they reach the maximum f1-score.
f1 = 2 ∗ recallmacro ∗ precisionmacro recallmacro + precisionmacro
(1)
The used f1-score (1) differs slightly from the f1-scores as defined in most software packages (e.g macro average f1-score in sklearn2). Instead of calculating the f1-score for each label and then taking the average, the "macro average recall"3 and "macro average precision"4 are calculated first and are then used in the f1-score (formula 1).
Now the question arises of how to optimize for the f1-score. During one validation step, we get the predictions for the validation set. Instead of calculating the loss, we could binarize the predictions according to a threshold and use them to calculate the f1-score. We could then train the model until no further improvement in the f1-score is observed. This procedure would require that we select the threshold at each validation step that maximizes the f1-score.
2https://scikit-learn.org/stable/modules/ generated/sklearn.metrics.f1_score.html
3https://scikit-learn.org/stable/modules/ generated/sklearn.metrics.recall_score.html
4https://scikit-learn.org/stable/modules/ generated/sklearn.metrics.precision_score.html
Algorithm 1 Threshold selection with f1-score maximization 1: Input: yTrue, yPred 2: Output: optimal threshold optT 3: 4: threshold← 0 5: maxF1← 0 6: optT ← 0 7: while threshold ≤ 1 do 8: yPredBin← binarize yPred with threshold 9: recall← recall(yTrue, yPredBin, average="macro") 10: precision← precision(yTrue, yPredBin, average="macro") 11: if precision+ recall ̸= 0 then 12: f1← 2 ∗ recall ∗ precision (recall + precision) 13: if f1 ≥ maxF1 then 14: optT ← threshold 15: maxF1← f1 16: end if 17: end if 18: threshold← threshold+ 0.01 19: end while 20: return optT
Consequently, we define Algorithm 1 to determine the threshold that maximizes the f1-score. As input, it takes a set of true labels and a set of predictions with values between 0 and 1. We iterate over all possible thresholds in small steps (0.01). In each iteration, we binarize the predictions according to the threshold and calculate the corresponding f1-score. As output, we return the threshold that maximizes the f1-score.
In Figure 2 we can clearly see, how the model improves its performance during training. It further shows that the training step that minimizes the average validation loss and the training step maximizing the f1-score can differ. The average
validation loss (blue) has its minimum at step 3, whereas the f1-score (green) has its maximum at training step 4. Subsequently, we decide to optimize each model with respect to the f1-score and with respect to the loss. This leads to the two blue rows in Figure 1. The first blue row in Figure 1 indicates the training with the goal of f1-score maximization, whereas the second row indicates the validation loss minimization.

heading: 3.2.3 Cross-Validation
text: To make use of as much training data as possible we apply a variant of 3-fold-cross-validation. Each of the four model configurations is trained three times, with a validation set of 500 samples. Each validation set is created by taking a different random split from the training dataset. Figure 1 reflects these 3 versions of each model with the blue boxes in the background.

heading: 3.3 Ensembling
text: During the training process, various models (section 3.2) are developed. Hence, the question arises of how to ensemble them to create the final labels. Our final submissions contain two different approaches.
The best-performing system uses Algorithm 1 to select an optimal threshold that can be used for the test dataset. In order to do so, the models are not trained on the whole dataset but instead, we split a "Leave-Out-Dataset" of 300 samples apart. These 300 samples are not seen by any of the models before and are used to determine the optimal threshold.
Recipe I: 1. Get the predictions on the "LeaveOut-Dataset" for all single models. 2. Average the individual predictions. 3. Select the optimal threshold for the "Leave-Out-Dataset" that maximizes the f1-score with Algorithm 1 4. Repeat steps 1 and 2 for the test dataset and use the optimal threshold for the final prediction.
We also submitted the best-performing system on the "Nahj al-Balagha"-dataset. This system has the same architecture but uses stacking (Wolpert, 1992) as an ensemble method. Instead of defining one "global" threshold for all labels, we train logistic regressions for each label to decide whether a label should be 0 or 1. The models are trained on the entire dataset.
Recipe II: 1. Get the predictions for 3000 samples of the training dataset for all single models. 2.
Train multiple logistic regressions5 (input: predictions, output: true labels) to predict the labels based on the predictions. 3. Get the predictions for the test dataset and use the trained logistic regressions to predict the final labels.

heading: 4 Experimental Setup
text: The final system was trained on the data provided by the task organizers (training + validation set) except for a "Leave-Out-Dataset" of 300 samples. During the different cross-validation runs a validation set of 500 samples is taken from the training data. We use a linear learning rate schedule and early stopping. We stop the training process if the validation loss or f1-score does not improve in 3 consecutive evaluation steps. Especially the parameter for the learning rate schedule (total_training_steps) was manually optimized because it defines the speed at which the learning rate decays and is therefore crucial for the learning process. The hyperparameters for pretraining and finetuning, used model versions as well as links to the code and a docker container reproducing the results can be found in Appendix A.
During the competition, we used an internal test dataset of 500 samples to create an internal "leaderboard" and choose the final systems to submit in the competition.
The models are implemented with PyTorchLightning and are trained on an NVIDIA Tesla T4 GPU.

heading: 5 Results
text: Each team was allowed to make up to four submissions (Table 3).
EN-Thres-LoD: The system described in this paper and the best-performing system in the competition. The ensemble threshold is calculated on a "Leave-out-Dataset" ("EN-Thres-LoD"), and the model achieves an f1-score of 0.56 (Table 3).
EN-Log-Reg: A system that uses stacking with logistic regressions as an ensemble method (Section 3.3). It has an f1-score of 0.54 on the "Main" dataset and was the best-performing system with an f1-score of 0.40 on the "Nahj al-Balagha" dataset.
EN-Thres-Train: The same system architecture as EN-Thres-LoD. Instead of calculating the threshold on the "Leave-Out-Dataset", the entire dataset
5https://scikit-learn.org/stable/ modules/generated/sklearn.multioutput. MultiOutputClassifier.html#sklearn.multioutput. MultiOutputClassifier
was used for training and the optimal threshold was calculated on the training data.
EN-Silver-Labels: The system uses a selftraining approach (Appendix B.1). A first version of a system creates additional training data ("silver labels") for arguments from the IBM-30k dataset. The model architecture is the same as "EN-ThresLoD". The size of the training data is then increased to 140% by adding the "silver-label" data. We followed a similar approach as in Jurkiewicz et al. (2020). The performance during training seems to slightly improve (Figure B.1), but when ensembled the system was outperformed by the other architectures.
All of our four submitted systems rank high in the competition on the "Main" dataset and the "Nahj al-Balagha". On these datasets, our systems outperform the BERT baseline by a large margin. However, there is a different picture for the "New York Times" dataset. With a maximum score of 0.27, the systems are only slightly better than the BERT baseline and are outperformed by other systems by a large margin (0.34 as "best approach" in Table 3).
The scores reported in Table 3 refer to the overall scores across all labels. Clearly, the model delivers better results for some labels than for others. A table with the scores for each label can be found in Table B in the appendix. The system delivers the best performances for the labels "Universalism: nature" and "Security: personal" with f1-scores of 0.82 and 0.76 respectively. The weakest performances are seen for the labels "Hedonism" (0.25) and "Stimulation" (0.32). The dataset is imbalanced and there seems to be a correlation between the frequencies of labels in the training data and the performance of the system (Figure 4).

heading: 5.1 Ablation study
text: The above-presented approach turned out to be suboptimal. Based on our own "internal leaderboard" it seemed like the suggested ensemble of all 12 models has slightly superior performance (F1 inter. in Table 8 in Appendix B.3). After submission, we evaluated the individual components of the final ensemble on the official test dataset. Table 3 shows that ensembling the 3 deberta models, which are optimized for the f1-score (EN-Deberta-F1) leads to slightly better performance (0.57) on the "Main" dataset and significantly better performance on the "New York Times" dataset (0.34). A sin-
gle Deberta model, optimized for f1-score (SingleDeberta-F1) leads to slightly worse performance on the test dataset (0.55) but significantly better performance on the "New York Times" dataset (0.37). The model selection for these ensembles can be found in Table 9 in the Appendix.

heading: 5.2 Other approaches
text: Besides the different approaches submitted for the competition, we have experimented with the generative T5 transformer model. The T5 model is trained on multiple downstream tasks including natural language inference. We assumed that this multi-tasking ability might have a beneficial influence on our task. Therefore we fine-tuned a T5large model to predict the values. With an f1-score of 0.493 on the validation set it beats the baseline BERT model but is far from the performance of the other approaches. We further weighted the loss function according to the class distribution in order to account for the class imbalance problem. This was ruled out in the early stages of the system development because it showed slightly lower performance. Comparing several approaches can be complicated due to the randomness in training procedures and the need for different hyperparameter optimizations. These modeling decisions are based on the performances captured in Table 7 in the appendix.

heading: 6 Conclusion
text: We have presented the best-performing system for the task of automatically detecting human values in arguments. Our system ensembles 12 models that have been either optimized for loss minimization or f1-score maximization. As an ensemble method, we choose one global decision threshold for all labels. The threshold maximizes the f1-score for a "Leave-out-Dataset". This approach outperforms stacking as an ensemble method, where for each label a logistic regression is trained. Even though our systems show the best performances on the "Main" and "Nahj al-Balagha" datasets, they are outperformed by other approaches on the "New York Times" dataset. In the ablation study, we show that such a large ensemble is not necessary. In fact, an ensemble of only 3 models shows better performance and robustness while decreasing the system’s memory requirements significantly.
For future work, an analysis of this phenomenon could be considered. Does the reduction of ensemble size lead to a more robust system and what are the counter-productive elements in the larger ensemble? Furthermore, we have only manually combined a few different models into an ensemble. Hence, it would be interesting to see whether a systematic selection of different approaches within an ensemble could further boost performance.

heading: 7 Limitations
text: The proposed system is trained on a very specific argument structure taken from the IBM-30k dataset. The system’s performance noticeably declines when tested on additional datasets, which raises questions about their ability to handle new, unprepared datasets and textual arguments with robustness. Furthermore, the best performing system consists of 12 individual models leading to a high resource requirements.

heading: 8 Acknowledgments
text: We would like to thank Nicolas Handke and Johannes Kiesel for creating the docker container and the web application and thereby making the system easier accessible for future research.

heading: A Experimental Setup
text: This section includes the appendices for the experimental setup such as links to relevant resources and hyperparameters.

heading: A.1 Code, Docker Container and Models
text: The Code6 and Docker Container7 for the final system are available online. We pushed the Single Deberta Model8 from the ablation studies to Huggingface for simple usage. Furthermore, all models are publicly available.9

heading: A.2 Language Models
text: We used the microsoft/deberta-large10 model from huggingface and the pretrained roberta-large.11

heading: A.3 Hyperparameters
text: 6https://github.com/danielschroter/human_ value_detector
7https://github.com/touche-webis-de/ team-adam-smith23
8https://huggingface.co/tum-nlp/Deberta_Human_ Value_Detector
9https://zenodo.org/record/7656534#.Y_ yKdyaZP30
10https://huggingface.co/microsoft/ deberta-large
11https://huggingface.co/danschr/ roberta-large-BS_16-EPOCHS_8-LR_5e-05-ACC_GRAD_ 2-MAX_LENGTH_165/tree/main?doi=true

heading: B Results

heading: B.1 Self-training and Silver Labels
text: We further applied a self-training procedure: 1) First we trained the IBM-Roberta and Deberta Model for f1-score-maximization. 2) We then ensembled the models and defined the optimal threshold based on a small Leave_out_Dataset. 3) We used the ensemble to created additional silver labels (additional training data) from the IBM-30k dataset. Thereby we ensured to not include samples, that are in our internal test dataset or the test dataset of the competition. 4) We retrained the models on an extended dataset including the silver labels in the training data. (During Cross-Validation, it is ensured that silver-labels are not added to the validation set). Figure 3 shows how pretraining might have a positive impact on the performance of the model. The values are the averages from crossvalidating with 3 folds. However, the submitted system (ensemble of 12) containing the self-trained models was outperformed by the other models.

heading: B.2 Results per category
text: Table 6 contains the performances of the systems submitted for the competition and developed in the ablation studies. It shows the performance for each label individually.
B.3 Internal Leaderboard for Ensembling
Table 8 compares the performance of the different ensembles. Based on the f1-score performance on an internal test-split we decided to submit the system with 12 models.

heading: B.4 Error Analysis
text: We plotted the frequencies of the labels in the training data against their f1-score performance (Figure 4)

heading: B.5 Other Approaches
text: We provide the results of some different approaches. They have been calculated on the same validation set of 500 samples, but we initialized the training with three different random seeds. Table 7 contains different methodologies.

heading: B.6 Model Mapping - Ablation Studies
text: Table 9 shows the identifier of the models in the model repository together with optimization goals and random seeds. The Table also shows which model is included in the Ensembles in the Ablation Studies.

heading: Future Work
text: We would like to thank Nicolas Handke and Johannes Kiesel for creating the docker container and the web application and thereby making the system easier accessible for future research