paper
string | soundness
float64 | overall_assessment
float64 | reviews
list | filename
string |
|---|---|---|---|---|
Double-Checker: Large Language Model as a Checker for Few-shot Named Entity Recognition Abstract Recently, few-shot Named Entity Recognition (NER) has attracted significant attention due to the high cost of obtaining high-quality labeled data. Decomposition-based methods have demonstrated remarkable performance on this task, which initially train a type-independent span detector and subsequently classify the de- tected spans based on their types. However, this framework has an evident drawback as a domain-agnostic detector cannot ensure the identification of only those entity spans that are specific to the target domain. To address this is- sue, we propose Double-Checker, which lever- ages collaboration between Large Language Models (LLMs) and small models. Specifically, we employ LLMs to verify candidate spans pre- dicted by the small model and eliminate any spans that fall outside the scope of the target domain. Extensive experiments validate the ef- fectiveness of our method, consistently yielding improvements over two baseline approaches. 1 Introduction In recent years, few-shot Named Entity Recogni- tion (NER) has attracted significant attention due to the high cost of obtaining high-quality labeled data (Ma et al., 2022a; Agrawal et al., 2022). This task mainly focuses on enabling the model to learn from a resource-rich source domain dataset, and further requires the model to predict unseen entity types in a resource-scarce target domain based on a small amount of data, i.e., the support data (Ma et al., 2022a; Das et al., 2022). To solve the above problem, a common approach is to decompose the task into entity span detection and entity type classification (Chen et al., 2023; Li et al., 2023). Specifically, a type-independent entity span detector is first trained, and then the type classification is performed according to the de- tection spans. Since the span detector trained in the first stage does not need to focus on specific entity types, it can effectively reduce the distribution gap between the source domain and the target domain, and has excellent performance (Wang et al., 2022; Ma et al., 2022b). However, this paradigm has an obvious drawback: a domain-agnostic detector cannot guarantee that the entity span identified is specific to the target domain, and it will obviously identify many non-target domain candidates1. Fortunately, Large Language Models (LLMs) have shown remarkable performance on various natural language processing tasks, such as text gen- eration (Zhang et al., 2023b; Hsieh et al., 2023) and machine translation (Zhu et al., 2023; Moslem et al., 2023). However, some recent studies point out that LLMs are not ideal for NER directly (Han et al., 2023; Xie et al., 2023), and often need to decompose the task into multiple steps or continue to fine-tune on large-scale data (Wei et al., 2023; Xu et al., 2023; Zhou et al., 2023). These methods will undoubtedly consume a lot of resources. Therefore, in this paper, we propose to lever- age the collaboration of Small Language Models (SLMs) and LLMs to exploit their respective advan- tages: low resource consumption of SLMs and the extensive knowledge base of LLMs. We aim to ad- dress the non-target domain entity span problem in- herent in SLMs while mitigating the high resource consumption of LLMs. Along these lines, we pro- pose Double-Checker, a framework where the LLM functions as a checker. Instead of re-identifying en- tities, the LLM rechecks the candidates identified by the small model, ensuring more accurate and domain-specific entity recognition. Specifically, we first obtain the candidates predicted by the SLM on the target domain sentences. To balance perfor- mance and resource consumption, we then utilize a type-adaptive selector to identify which candi- dates need to be rechecked. Finally, we use the LLM to conduct a two-stage check of the selected 1In Appendix A.1, we conduct a related experiment. 1\nTargetSentence:“The traditional view among chilean historians and historians of the inca empire is that maule river{Location-bodiesofwater} was the frontier.”Candidate PossibleType Probabilitymauleriver location-bodiesofwater 8.299inca empire location-GPE 4.385chilean location-other 3.172 [mauleriver]CorrectSTEP1 [inca empire]Recheck[chilean]RecheckFirst-stageCheckGiven Type Definition, Sentence, Types, and Candidate, answer the Question.TypeDefinition:xxxrefersto...,Nonerefers an entity that does not belong to the above types, or not an entity.Sentence:The traditional view among chilean historians...Types:xxx,None.Candidate:...Question:Please select the most relevant type (from Types) for Candidate in the Sentence.Answer:ThemostrelevanttypeofincaempireisNone. Answer:ThemostrelevanttypeofchileanisLocation-other. Second-stageCheckQuestion: Consider the Possible Typexxx, whether the Candidate in the Sentence is an entity or not and explain why.[chilean][chilean]Removed [inca empire]Removed[incaempire] SmallLanguageModelType-AdaptiveSelector STEP2Figure 1: The overall framework of Double-Checker. candidates, removing incorrectly identified spans to obtain the final results. We conduct extensive experiments on the standard few-shot NER dataset, Few-NERD, achieving consistent performance im- provements with the LLM on two state-of-the-art (SOTA) SLMs. 2 Methodology In this section, we introduce Double-Checker, an efficient framework specifically designed for elimi- nating non-target domain candidates by rechecking the predictions made by small models. The frame- work consists of two main steps: firstly, we obtain the candidates predicted by the small model and select the ones to be rechecked; subsequently, a two-stage check utilizing LLM is conducted. An overview of the framework is shown in Figure 1. 2.1 Step 1: Select the Candidates For each sentence xiin the target domain, we first leverage the small model to obtain the structural output, denoted as yi= [si, ti, pi]. Here, sirepre- sents a candidate span, tiindicates the correspond- ing type, and piis the probability values. Intuitively, outputs with higher predicted prob- ability values are less likely to be incorrect. How- ever, considering the high computational cost of using LLM, it is crucial to balance performance and cost by selecting an appropriate subset of data for the LLM to process. We assume that the probability distribution varies across different entity types and that prediction values for different types have vary- ing levels of importance. Therefore, we develop a type-adaptive selector that prioritizes samples for LLM check based on the type-specific probabil- ity distributions, ensuring the most critical data is checked within the same data proportion. Specifi- cally, we first construct a collection of probability values for each type: Set(ti) =Set(ti)∪(pj×I(tj=ti))j=1,...,n,(1) where nis the number of candidates, and I(·)de- notes the indicator function. Next, we set a quan- tile point α, which we assume to be 60%. If the probability value of a candidate exceeds the 60th percentile of the samples within its corresponding type set, it is considered less likely to be incorrect. Otherwise, it proceeds to the second step for fur- ther verification. By implementing this process, we effectively select the desired candidates. 2.2 Step 2: Two-stage Check In this step, we utilize the rich external knowledge of the LLM to perform a two-stage check of the selected candidates. Prompt Construction. Following Zhang et al. (2023a), we transform the task into a QA format comprising five components: Type Definition ,Sen- tence ,Types ,Candidate , and Question . Detailed specifications of this format are provided in Ap- pendix A.3. It is important to highlight the intro- duction of Type Definition and the selection scope ofTypes , which we will cover later. One crucial reason for introducing the concept ofType Definition is the variability in the range of entity types across different datasets, which poses a challenge for LLMs that are not inherently aware of this variability. By incorporating a type-specific description, we can enhance the LLM’s focus and performance on a given dataset. To achieve this, we input the entire set of types from the Few-NERD dataset into the LLM simultaneously. This ap- proach allows the LLM to consider the complete 2\nModelsIntra Inter 1∼2 shot 5 ∼10 shotAvg.1∼2 shot 5 ∼10 shotAvg. 5 way 10 way 5 way 10 way 5 way 10 way 5 way 10 way Full Test set ProtoBERT∗(Fritzler et al., 2019) 20.76 ±0.84 15.05±0.44 42.54±0.94 35.40±0.13 28.44 38.83 ±1.49 32.45±0.79 58.79±0.44 52.92±0.37 45.75 NNshot∗(Yang and Katiyar, 2020) 25.78 ±0.91 18.27±0.41 36.18±0.79 27.38±0.53 26.90 47.24 ±1.00 38.87±0.21 55.64±0.63 49.57±2.73 47.83 StructShot∗(Yang and Katiyar, 2020) 30.21 ±0.90 21.03±1.13 38.00±1.29 26.42±0.60 28.92 51.88 ±0.69 43.34±0.10 57.32±0.63 49.57±3.08 50.53 CONTaiNER∗(Das et al., 2022) 41.51 ±0.07 36.62±0.04 57.83±0.01 51.04±0.24 46.75 50.92 ±0.29 47.02±0.24 63.35±0.07 60.14±0.16 55.36 ESD∗(Wang et al., 2022) 36.08 ±1.60 30.00±0.70 52.14±1.50 42.15±2.60 40.09 59.29 ±1.25 52.16±0.79 69.06±0.80 64.00±0.43 61.13 DecomposedMeta∗(Ma et al., 2022b) 49.48 ±0.85 42.84±0.46 62.92±0.57 57.31±0.25 53.14 64.75 ±0.35 58.65±0.43 71.49±0.47 68.11±0.05 65.75 HEProto∗(Chen et al., 2023) 53.03 ±0.30 46.45±0.21 65.70±0.21 58.98±0.22 56.04 66.40 ±0.18 60.91±0.20 72.53±0.11 68.92±0.20 67.19 HEProto†52.64 46.26 65.58 58.93 55.85 66.01 60.92 72.29 68.86 67.02 TadNER∗(Li et al., 2023) 60.78 ±0.32 55.44±0.08 67.94±0.17 60.87±0.22 61.26 64.83 ±0.14 64.06±0.19 72.12±0.12 69.94±0.15 67.74 TadNER†59.72 55.15 67.60 60.68 60.79 64.57 62.80 71.82 69.32 67.13 Sampled Test set GPT-3.5-turbo 53.69 47.07 54.59 49.36 51.18 46.26 42.68 51.81 49.09 47.46 HEProto†52.94 46.55 65.35 58.90 55.94 65.42 60.89 72.10 69.28 66.92 TadNER†60.13 55.02 67.62 60.75 60.88 64.38 62.92 71.67 69.54 67.12 Double-Checker −HEProto 59.98 54.74 69.00 62.61 61.58 68.58 65.76 73.49 71.29 69.78 Double-Checker −TadNER 64.43 60.11 70.14 64.63 64.74 66.09 65.81 73.03 71.50 69.11 ∆Double-Checker vs. HEProto 7.04 ↑ 8.19↑ 3.65↑ 3.71↑ 5.64↑ 3.16↑ 4.87↑ 1.39↑ 2.01↑ 2.86↑ ∆Double-Checker vs. TadNER 4.13 ↑ 5.09↑ 2.52↑ 3.88↑ 3.86↑ 1.71↑ 2.89↑ 1.36↑ 1.96↑ 1.99↑ Table 1: Comparison of performance on Few-NERD with the Micro-F1 metric(%). †indicates that the results are from our re-implementation with the same seed. ∗denotes the results are obtained from Chen et al. (2023) and Li et al. (2023). The best results are in bold . spectrum of entity types and generate tailored de- scriptions for each specific domain type. In Ap- pendix A.4, we show the full description of the target domain types obtained from GPT-3.5-turbo. We then define the scope of Types . Unlike re- ranking methods (Ma et al., 2023; Zhang et al., 2024) that focus on calibrating false entity types, our approach aims to exclude non-target domain spans or non-entities. Consequently, in most scenar- ios, it suffices to include only the highest predicted type and “None” (indicating a non-target domain entity or non-entity) within type scope. In certain cases, we also incorporate the second most likely type predicted by the small model to enhance over- all performance. In Section 3.3.2, we delve into the impact of varying the types scope on performance. Two-stage Check Workflow. The right part of Figure 1 illustrates the workflow. For each selected candidate, we obtain the corresponding Type Defi- nition based on its predicted type and input it into the LLM along with other necessary information from the prompt to obtain recheck results. If a candidate is determined as “None”, it is removed and the process ends; otherwise, we proceed to the second stage of checking. The check in the second stage serves solely to determine whether the candi- date is an entity. Based on the context in previous stage, we directly input the new Question . If the candidate is deemed as an entity, it will be included in the final result; otherwise, it will be excluded. Through the above process, we remove the false entity span and combine the unselected candidates to constitute the final result. 3 Experiments 3.1 Main Results Considering the high cost of LLM, we sample the first 10,000 sentences in each sub-setting on the full test set, and reproduce a portion of baselines with the same seed for a fair comparison. Table 1 shows the main results of the comparison between our pro- posed Double-Checker and baselines. It is evident that Double-Checker achieves consistent improve- ments over both SLMs. Specifically, there is a min- imum increase of 1.39% and a maximum increase of 8.19% on HEProto, while it ranges from 1.36% to 5.09% on TadNER respectively. Furthermore, based on the average performance comparison, we observe that the improvement is more pronounced in the Intra setting due to a wider distribution gap between source and target domains where external knowledge provided by LLM effectively is better to bridges this. It is worth noting that GPT-3.5-turbo alone does not yield satisfactory results and even exhibits significant disparities compared to SOTA methods in most cases; however, when combined as part of Double-Checker, it not only consumes fewer resources but also achieves superior perfor- mance compared to both individual models. 3\nMethodsIntra Inter 1∼2 shot 5 ∼10 shotAvg.1∼2 shot 5 ∼10 shotAvg. 5 way 10 way 5 way 10 way 5 way 10 way 5 way 10 way Double-Checker −TadNER 64.43 60.11 70.14 64.63 64.74 66.09 65.81 73.03 71.50 69.11 w/o Two-stage Check 63.67 59.41 69.60 63.97 64.16 65.01 65.05 72.07 70.91 68.26 w/o Type Definition 62.92 58.76 68.66 62.86 63.30 65.60 65.57 72.60 70.53 68.58 w/o Recheck 60.13 55.02 67.62 60.75 60.88 64.38 62.92 71.67 69.54 67.12 Table 2: Ablation study on Few-NERD with the Micro-F1 metric(%). Setting(a)(b) Figure 2: (a) Results of different selecting strategy. (b) Results of different types scope in prompt. 3.2 Ablation Study As shown in Table 2, we choose TadNER as SLM to conduct ablation experiments to investigate the impact of different compositions on Double- Checker. The removal of two-stage checks resulted in a decline in model performance, which validates the effectiveness of secondary reprocessing results. When type definition are absent, Double-Checker drops more in Intra, indicating that enabling LLM to comprehend label ranges for more challenging tasks can better activate their internal knowledge. 3.3 Comparative Analysis In this section, we conduct additional experiments to explore the following practical questions: Q1: Why do we need type-adaptive selector? Q2: How to adjust types scope in prompt? 3.3.1 Impact of Selector We compare the performance of ours type-adaptive selector and normal selector (that is, selecting can- didates based on all types) on Intra 10-way 1-shot. The Figure 2 (a) clearly demonstrates that our adap- tive selector consistently outperforms in most cases, particularly when the proportion of selected data is low, thereby highlighting this phenomenon more prominently. Moreover, our method excels at se- lecting a greater number of non-target domain can- didates with an equivalent data proportion. Addi- tionally, it is worth noting that model performance does not always exhibit a linear relationship with the proportion of data; instead, it reaches a plateau and even declines. Consequently, considering both performance and resource consumption factors, the selector we have designed proves to be more suit- able for realistic scenarios while achieving superior performance within limited resources. 3.3.2 Impact of Types Scope The Figure 2 (b) illustrates a comparison of the impact of different types of scopes in prompt for 5- way 1-shot setting. It is evident that employing the full-type prompt yields the poorest results in both settings, whereas the other two options exhibit no significant differences. This can be attributed to a higher occurrence of errors in predicting non-target domain spans rather than type errors within the few- shot NER scenario. When providing a larger selec- tion of types as input prompts to the large model, it inevitably introduces disturbances and shifts its ob- jective from removing non-target domain spans to reclassifying spans, resulting in performance degra- dation. Therefore, for practical applications, it is advisable to limit the range of types provided as input prompts to minimize inference costs while potentially improving performance. 4 Conclusion In this paper, we presented Double-Checker, a framework that effectively combines LLM and SLM for few-shot NER task. Specifically, we ini- tially employed a type-adaptive selector to choose candidates predicted by the small model. Subse- quently, the LLM is utilized to conduct a two-stage check process on these selected candidates, remov- ing entity spans and non-entities that are not rele- vant to the target domain. Extensive experiments conducted using two different small models con- sistently demonstrated significant improvements, thereby showcasing the efficacy of our approach. 4\n5 Limitations Our approach aims to combine the complementary strengths of LLM and small models to enhance overall performance. Due to resource constraints, we are unable to run the LLM experiments on the entire test dataset (e.g., the Intra 10 way 5 shot setting includes over 300,000 sentences). There- fore, we sample 10,000 sentences for each setting. Another limitation is that we did not conduct exper- iments on domain-specific datasets, such as NER datasets in the biomedical field. Generally, more non-domain-specific entity spans are identified in these datasets (Labrak et al., 2024), which we be- lieve are better suited to our framework. We plan to address these limitations in a follow-up study. | 3.5 | 3 | [
{
"comments_suggestions_and_typos": "1. It would be helpful if the authors could provide more details on how the LLM is utilized in the two-stage check process. Specifically, how does the LLM differentiate between entities and non-entities?\n2. Including code or pseudocode for the type-adaptive selector and the two-stage check process would enhance the reproducibility of the experiments.\n3. On page 1, under \"Abstract,\" the phrase \"demonstrated remarkable performance on this task\" could be more concisely written as \"demonstrated remarkable performance in this task.\"\n4. The authors might consider adding a section on error analysis, detailing common types of errors made by the SLM and how they are corrected by the LLM.\n5. Figure 1 could be made clearer with better labeling or a more detailed caption explaining each component of the Double-Checker framework.",
"ethical_concerns": null,
"paper_summary": "This paper introduces \"Double-Checker,\" a framework designed to enhance few-shot Named Entity Recognition (NER) by leveraging the collaborative efforts of Large Language Models (LLMs) and Small Language Models (SLMs). The authors address the challenge of identifying domain-specific entities in a resource-scarce target domain using a small amount of labeled data. The proposed method involves an initial detection of entity spans by an SLM, followed by a verification process using an LLM to ensure the identified spans are relevant to the target domain. The framework employs a type-adaptive selector to balance performance and resource consumption, and a two-stage check process to refine the entity recognition. The authors validate their approach through extensive experiments on the Few-NERD dataset, demonstrating consistent improvements over baseline methods.",
"summary_of_strengths": "1. The paper presents a creative solution to the few-shot NER problem by combining the strengths of LLMs and SLMs, which is a novel approach in the field.\n2. The authors provide extensive empirical results on the Few-NERD dataset, showing significant improvements over state-of-the-art methods, which strengthens the case for the proposed method.\n3. The type-adaptive selector is a thoughtful addition that balances the computational cost of using LLMs with the need for accurate entity recognition, making the approach more practical.\n4. The paper is well-organized, with a clear explanation of the methodology, followed by a detailed experimental setup and results.\n5. The paper not only presents a new method but also provides insights into the challenges of few-shot NER and how the proposed framework addresses them.",
"summary_of_weaknesses": "1. The experiments are primarily conducted on the Few-NERD dataset. It would be beneficial to see how the method performs on other datasets, especially those from different domains.\n2. The authors mention that due to resource constraints, they were unable to run experiments on the entire test dataset. This limitation could affect the generalizability of the results.\n3. While the paper discusses the potential of the framework for domain-specific datasets, there is no empirical evidence provided for such scenarios. Demonstrating the effectiveness in a more diverse set of domains would be valuable.\n4. Some sections, particularly in the methodology, could benefit from clearer explanations or examples to aid understanding. For instance, the process of how the LLM rechecks the candidates could be elaborated further.\n\nIn the reading of this paper, there are the following questions:\nQuestion 1: In the \"Two-stage Check Workflow\" section, the author stated, \"If the candidate is deemed as an entity, it will be included in the final result.\" However, in the workflow of Figure 1, the entity \"chilean\" appears to have been removed.\nQuestion 2: Since the first stage has already identified the entity type of \"chilean,\" why is a recheck necessary? Isn't it sufficient to ensure that the target entity in the target sentence is correctly identified? If the purpose is to improve the recognition accuracy through multiple iterative detections by the large model, wouldn't it be more reasonable to set better criteria for ending the iteration?\nQuestion 3: In Appendix A.1, the author simply and effectively demonstrated the shortcomings of the task decomposition paradigm, but is it possible that part of the reason is due to changes in the semantic structure of the context?"
}
] | 5341a7d245bf7fb0d57f668787693363afd32e26df6b378c9fe8b5a1ebf80d730d1d811d783ddc431a77f286d9c1caa2c042d5a0f5f3a282a3708253d42d6462.json |
Enhancing Temporal Modeling of Video LLMs via Time Gating Abstract Video Large Language Models (Video LLMs) have achieved impressive performance on video-and-language tasks, such as video ques- tion answering. However, most existing Video LLMs neglect temporal information in video data, leading to struggles with temporal-aware video understanding. To address this gap, we propose a TimeGating Video LLM ( TG- Vid) designed to enhance temporal modeling through a novel TimeGating module ( TG). The TG module employs a time gating mech- anism on its sub-modules, comprising gat- ing spatial attention, gating temporal atten- tion, and gating MLP. This architecture enables our model to achieve a robust understanding of temporal information within videos. Ex- tensive evaluation of temporal-sensitive video benchmarks ( i.e., MVBench, TempCompass, and NExT-QA) demonstrates that our TG-Vid model significantly outperforms the existing Video LLMs. Further, comprehensive ablation studies validate that the performance gains are attributed to the designs of our TG module. 1 Introduction The advancement of Large Language Models (LLMs) (Touvron et al., 2023; Chiang et al., 2023) has greatly fueled multi-modal research, such as Image LLMs (Liu et al., 2024b; Bai et al., 2023; Dai et al., 2023; Liu et al., 2024a) which have achieved success on image-and-language down- stream tasks (Goyal et al., 2017). Inspired by Image LLMs, many recent efforts manage to em- power LLMs to understand video data (Maaz et al., 2023; Li et al., 2023c; Liu et al., 2024d). The typ- ical architecture of these Video LLMs comprises a pretrained vision encoder (Radford et al., 2021; Sun et al., 2023), a pretrained LLM (Chiang et al., 2023), and a connection module in between (Zhu et al., 2023; Dai et al., 2023). Despite the impressive performance demon- strated by Video LLMs (Maaz et al., 2023; Xu et al., 2017; Yu et al., 2019; Jang et al., 2017), a recent study (Liu et al., 2024e) reveals that most Video LLMs perform comparably to, or even worse than, Image LLMs. This discrepancy arises because ex- isting video benchmarks can often be adequately addressed by single-frame bias (Lei et al., 2022; Buch et al., 2022), without the need for capturing the temporal dynamics of videos. To better eval- uate the temporal modeling capability, multiple temporal-sensitive benchmarks have been devel- oped (Liu et al., 2024e; Li et al., 2023c; Xiao et al., 2021) that cannot be solved by simply relying on single-frame bias as a shortcut. In this paper, we aim to enhance the tempo- ral modeling ability of Video LLMs and evaluate our model on the temporal-sensitive benchmarks. Specifically, we propose a temporal-aware Video LLM ( TG-Vid ) in this work, featuring a novel TimeGating module ( TG) to enhance temporal modeling. This TG module comprises three sub- modules, gating spatial attention, gating temporal attention, and gating MLP, simultaneously captur- ing spatial and temporal information. A recent relevant work ST-LLM (Liu et al., 2024d) also tries to enhance temporal modeling, by directly utiliz- ing BT-Adapter (Liu et al., 2024c) which applies spatio-temporal attention in parallel to the vision encoder. In contrast, our work builds gating spatio- temporal attention on top of the vision encoder, and our gating mechanism imposes effective module- specific control over each sub-module of the TG module. As validated by experiments, our design achieves better performance on temporal-sensitive benchmarks. We conduct comprehensive experiments on three temporal-sensitive video benchmarks ( i.e., MVBench (Li et al., 2023c), TempCompass (Liu et al., 2024e) and NExT-QA (Xiao et al., 2021)). The results show that our TG-Vid significantly out- 1\nVideo Input with T FramesLarge Language Model Instruction:Approach the video by thinking about the reasons behind the actions and their order in time, and choose the most relevant option.Question: What did the brown dog do when the black dog first ran away?Options: (A) chase the dog. (B) fight back. (C) mount the black dog. (D) touch its face. (E) bite and push.Text Input“A”ResponseQFormer …TGating MLPGating Temporal AttentionGating Spatial AttentionTG……………… …………Text InputFlattenN ×Shape = (T, L, D) TG Vision Encoder ………Frozen Trainable Video Patch Embeddings Shape = (T, Lq, D)Shape = (T, L, D) LVideo Patch EmbeddingsFigure 1: Model architecture of TG-Vid . Given a video with Tframes, the vision encoder extracts Tframe-level embeddings. Our TG employs a novel time gating mechanism to enhance video temporal modeling, thereby enhancing the frame-level video modeling ability of the QFormer. Moving forward, the QFormer compresses each frame-level video embedding from Lpatch tokens to Lqquery tokens, followed by LLMs. performs the existing Video LLMs across all bench- marks and demonstrate the effectiveness of our TG- Vid on temporal-aware video understanding. The thorough ablation studies further emphasize that the performance gains are attributed to the designs of our TG module. 2 Related Work Video Large Language Models. Benefited from the reasoning power of large language models (LLMs) (Zhang et al., 2022; Brown et al., 2020; Touvron et al., 2023; Chiang et al., 2023; Zhao et al., 2023), Video LLMs (Li et al., 2023b; Maaz et al., 2023; Zhang et al., 2023; Lin et al., 2023; Tang et al., 2023) have shown impressive perfor- mance on video-and-language tasks, such as video question answering (Xu et al., 2017; Jang et al., 2017; Yu et al., 2019; Maaz et al., 2023; Xiao et al., 2021). However, most existing video LLMs inherit the design of Image LLMs (Zhu et al., 2023; Liu et al., 2024b; Dai et al., 2023) and overlook the temporal modeling that is critical for video data, leading to unsatisfactory capability on temporal- aware video understanding (Li et al., 2023c; Liu et al., 2024e). For example, TempCompass (Liu et al., 2024e) reveals that the temporal understand- ing ability of most Video LLMs is on par with or even weaker than Image LLMs. In this work, we propose a temporal-aware Video LLM, featuring a new architecture of time gating module to enhance video temporal modeling. Video Temporal Modeling. Modeling temporal information has been a long-standing topic in video research. Early work utilizes 3D convolutional net- works (CNNs) to achieve spatio-temporal video modeling (Carreira and Zisserman, 2017; Feicht- enhofer et al., 2016; Tran et al., 2015). To re- duce training costs, subsequent CNN-based mod- els explore factorizing convolutions across spa- tial and temporal dimensions (Sun et al., 2015; Tran et al., 2019, 2018; Xie et al., 2018; Feichten- hofer, 2020). Further, by leveraging the superiority of Transformer in processing sequences, Times- Former (Bertasius et al., 2021) and ViViT (Arnab et al., 2021) employ Transformer-based architec- tures to enhance spatio-temporal modeling via spa- tial and temporal attention. Beyond single action, a line of work seeks to learn the temporal order- ing of actions in procedural activities (Bojanowski et al., 2014; Chang et al., 2020; Zhao et al., 2022; Zhong et al., 2023). More recently, pretrained image-language models (Radford et al., 2021) are transferred to video tasks (Ni et al., 2022; Pan et al., 2022; Luo et al., 2022; Fang et al., 2021; Liu et al., 2024c), such as action recognition and video re- trieval. Unlike these works, we extend the idea of spatio-temporal attention to Video LLMs, targeting at temporal-sensitive VideoQA and filling the gap of video modeling in Video LLMs. 3 Methodology In this section, we introduce our TimeGating Video LLM ( TG-Vid ). Fig. 1 provides an overview of our model architecture. To enhance the temporal modeling of a Video LLM (comprising an LLM, a vision encoder, and a connection module), we propose a TimeGating ( TG) module with a novel module-specific time gating mechanism. 3.1 Preliminary Given a video input with Tframes, a pretrained vision encoder (Sun et al., 2023) extracts patch em- beddings for each frame and concatenates them 2\ninto video embeddings V∈RT×LV×DV, where LVdenotes the number of patch embeddings in each frame and DVdenotes the dimension of patch embeddings. On the other side, given the text in- put, we employ the text embedder of a pretrained LLM (Chiang et al., 2023) to obtain the text embed- dingsT∈RLT×DT, where LTdenotes the number of text tokens and DTdenotes the dimension of the text embeddings. This video and text encoding process is common in Video LLMs methods (Li et al., 2023c; Wang et al., 2024b; Liu et al., 2024d). Our model design extends spatio-temporal atten- tion from ViViT (Arnab et al., 2021) and Times- Former (Bertasius et al., 2021). We provide the background knowledge of spatio-temporal atten- tion. For clarity, we first formulate the vanilla N-layer Spatio- Temporal module ( ST), which is placed between the vision encoder and the QFormer. Each ST layer comprises a spatial atten- tion, atemporal attention , and a two-layer MLP . Given the input Vℓ∈RT×LV×DV, theℓ-th layer of ST (V0is set asV) can be formulated as: Vℓ S=ReshapeS (Vℓ) (1) Yℓ S=MSA(LN(Vℓ S)) +Vℓ S (2) Vℓ T=ReshapeT (Yℓ S) (3) Yℓ T=MSA(LN(Vℓ T)) +Vℓ T (4) Vℓ M=ReshapeM (Yℓ T) (5) Vℓ+1=Yℓ M=MLP(LN(Vℓ M)) +Vℓ M (6) where LN(·)denotes layer normalization (Ba et al., 2016), MSA(·)denotes multi-head self-attention, andMLP(·)denotes a two-layer MLP. ReshapeS (·) reshapes Vℓ∈RT×LV×DVasVℓ S∈RT×LV·DV, ReshapeT (·)reshapes Yℓ S∈RT×LV·DVasVℓ T∈ RLV×T·DV, and ReshapeM (·)reshapes Yℓ T∈ RLV×T·DVasVℓ M∈RT×LV×DV. 3.2 Time Gating Module (TG) The vanilla ST module can model the spatio- temporal information in video inputs. However, directly inserting a randomly initialized ST module into Video LLM results in unstable training and sub-optimal performance. To address this issue, we propose a novel TimeGating Module ( TG), featuring a time gating mechanism to impose con- straints on each sub-module ( i.e., agating spatial attention , agating temporal attention , and a gat- ing MLP ) of the TG module. These gating sub- modules allow our TG to focus dynamically on relevant information in both spatial and temporal aspects, enhancing the temporal modeling ability of Video LLM. Unlike previous research works (Sung et al., 2022; Liu et al., 2024c) that utilize gating mecha- nism conditioned solely on a trainable but module- agnostic scalar ( e.g.,α∈R1) or vector ( e.g., b∈RDV), the gating function Gating (·)in our TG is module-specific and conditioned on both the input and output of the sub-module. Specifically, gating spatial attention is implemented as: ˆYℓ S=MSA(LN(Vℓ S)) Yℓ S=Gating (Vℓ S,ˆYℓ S)) +Vℓ S =σ(Cat(Vℓ S,ˆYℓ S)WS)⊙ˆYℓ S+Vℓ S(7) where σ(·)is a sigmoid function, Cat(·)denotes concatenate operation, WS∈RDV×DVis a linear projection, and ⊙denotes element-wise product. Similarly, gating temporal attention andgating MLP are implemented as follows: ˆYℓ T=MSA(LN(Vℓ T)) Yℓ T=σ(Cat(Vℓ T,ˆYℓ T)WT)⊙ˆYℓ T+Vℓ T(8) ˆYℓ M=MLP(LN(Vℓ M)) Yℓ M=σ(Cat(Vℓ M,ˆYℓ M)WM)⊙ˆYℓ M+Vℓ M(9) whereWT∈RDV×DVandWM∈RDV×DV. 3.3 Time Gating Video LLM By inserting the N-layer TG module between the frozen vision encoder and the frozen QFormer, we propose TG-Vid , aTimeGating Video LLM. The output video embeddings of the pretrained QFormer are flattened as VQ∈RT·Lq×DV, where Lqdenotes the length of query tokens for each frame. Subsequently, VQis projected into the text embedding space and concatenated with the text embedding Tas follows: VT= [VQWVT,T] (10) whereWVT∈RDV×DTis a trainable linear pro- jection, and VT∈R(T·Lq+LT)×DTis the input into the LLM. Same as previous Video LLMs, our TG-Vid model is trained on next token prediction. 4 Experiments Compared with existing Video LLMs, we evaluate our TG-Vid on three temporal-sensitive video un- derstanding benchmarks ( i.e., MVBench (Li et al., 2023c), TempCompass (Liu et al., 2024e), and 3\nModelOtter-V mPLUG-Owl Video-ChatGPT Video-LLaMA VideoChat VideoChat2 HawkEye ST-LLMTG-Vid TG-Vid(Li et al., 2023a) (Ye et al., 2023b) (Maaz et al., 2023) (Zhang et al., 2023) (Li et al., 2023b) (Li et al., 2023c) (Wang et al., 2024b) (Liu et al., 2024d) LLM LLaMA-7B LLaMA-7B Vi-7B Vi-7B Vi-7B Vi-7B Vi-7B Vi-7B Vi-7B Vi-7B #IT - - - - - 1.9M 2.2M 220K 197K 220K Avg 26.8 29.7 32.7 34.1 35.5 51.1 47.6 54.9 56.0 56.4 Table 1: MVBench benchmark experiments. Comprehensive results are provided in the Appendix Tab. 9. #IT denotes instruction tuning samples. “Vi-” denotes “Vicuna-”. Bold /underline denotes the best/second-best result. ModelV-LLaV A LLaMA-VID mPLUG-Owl PandaGPT Valley VideoChat2 V-ChatGPT V-LLaMA ST-LLM♣ TG-Vid TG-Vid(Lin et al., 2023) (Li et al., 2023d) (Ye et al., 2023b) (Su et al., 2023) (Luo et al., 2023) (Li et al., 2023c) (Maaz et al., 2023) (Zhang et al., 2023) (Liu et al., 2024d) LLM Vi-7B Vi-7B LLaMA-7B Vi-13B StableVi-7B Vi-7B Vi-7B Vi-13B Vi-7B Vi-7B Vi-7B #IT - - - - - 1.9M - - 220K 197K 220K Avg(Caption Matching) 63.7 53.6 49.3 51.3 22.0 55.6 51.8 53.5 64.8 67.6 67.5 Avg(Yes/No QA) 56.4 53.0 54.4 51.8 53.5 58.0 50.7 53.7 54.0 58.1 56.8 Avg(Multi-Choice QA) 44.7 35.3 40.0 31.1 31.8 51.1 35.2 33.9 53.7 52.9 54.4 Avg(ALL) 54.9 47.3 47.9 44.7 35.8 54.9 45.9 47.0 57.5 59.5 59.6 Table 2: TempCompass benchmark experiments. Comprehensive results are provided in the Appendix Tab. 10. #IT denotes instruction tuning samples. “V-” denotes “Video-” and “Vi-” denotes “Vicuna-”. Avg(ALL) is the overall average result, calculated as the average of Avg(Caption Matching), Avg(Yes/No QA), and Avg(Multi-Choice QA). Bold /underline denotes the best/second-best average result. ♣: We reproduce the training and inference. NExT-QA (Xiao et al., 2021; Buch et al., 2022)). More details of datasets, implementation, and ex- periment results are provided in the Appendix. 4.1 Main Results Tab. 1, Tab. 2, and Tab. 3 show our main results on MVBench, TempCompass, and NExT-QA, re- spectively. Our TG-Vid model achieves the best performance and surpasses previous methods by a large margin across all benchmarks. For example, compared with the closest competitor ST-LLM, our TG-Vid-220K achieves +1.5 on MVBench, +2.1 on TempCompass, +3.2 on NExT-QA ATP-hard, and +3.2 on NExT-QA Val. These impressive results demonstrate a consistent finding that our TG-Vid model can capture temporal information more ef- fectively, attributed to the TG designs. 4.2 Ablation Studies Given the comparable performance of TG-Vid- 220K and TG-Vid-197K, the ablation studies are based on the latter for efficiency consideration. TG Module. In Tab. 4, row 3 significantly outper- forms row 1 by a large margin (+3.0), demonstrat- ing the effectiveness of our TG module in empow- ering temporal-aware video understanding. Time Gating Mechanism. Row 3 significantly surpasses row 2 (+1.5), underscoring the crucial role of the time gating mechanism in enhancing video temporal modeling. TG Components. The results in Tab. 4 indicate that each sub-module of TG module contributes to performance improvement. Notably, the proposed gating temporal attention provides the most sig- nificant enhancement (from 54.7 to 56.0), further validating the necessity of temporal modeling. Model #ITNExT-QA ATP-hard NExT-QA Val Acc@ CAcc@ TAcc@ All Acc@ CAcc@ TAcc@ DAcc@ All VFC♠(Yang et al., 2021) - 32.2 30.0 31.4 49.6 51.5 63.2 52.3 ATP (Buch et al., 2022) - 38.4 36.5 38.8 53.1 50.2 66.8 54.3 GF (Bai et al., 2024) - 48.7 50.3 49.3 56.9 57.1 70.5 58.8 SeViT (Kim et al., 2023) - 43.3 46.5 - 54.0 54.1 71.3 56.7 HiTeA (Ye et al., 2023a) - 47.8 48.6 - 62.4 58.3 75.6 63.1 VideoAgent♠(Wang et al., 2024a) - 57.8 58.8 58.4 72.7 64.5 81.1 71.3 SEVILA (Yu et al., 2024) - - - - 74.2 69.4 81.3 73.8 VideoChat2 (Li et al., 2023c) 1.9M - - - 68.7 64.7 76.1 68.6 HawkEye (Wang et al., 2024b) 2.2M - - - - - - 67.9 ST-LLM♣(Liu et al., 2024d) 220k 65.5 61.9 64.0 74.3 70.0 81.3 74.0 TG-Vid 197k 68.4 66.3 67.5 77.4 73.8 84.3 77.3 TG-Vid 220K 68.5 65.2 67.2 77.3 73.5 84.3 77.2 Table 3: Experiments on NExT-QA ATP-hard subset and NExT-QA validation dataset. C ,T, and Dare causal, temporal, and descriptive subsets, respectively. Bold /underline denotes the best/second-best result. ♣: We reproduce the training and inference. ♠: Zero-shot. TG Components Gating#ITMVBench Spatial Temporal MLP Mechanism Avg ✗ ✗ ✗ ✗ 197K 53.0 ✓ ✓ ✓ ✗ 197K 54.5 ✓ ✓ ✓ ✓ 197K 56.0 ✗ ✓ ✓ ✓ 197K 55.6 ✓ ✗ ✓ ✓ 197K 54.7 ✓ ✓ ✗ ✓ 197K 55.7 Table 4: Ablation studies on TG module . 5 Conclusion In this paper, we focus on developing a Video LLM, TG-Vid , to overcome the struggles of the existing Video LLMs in temporal-aware video understand- ing. Specifically, we propose a novel TimeGating module ( TG) with a time gating mechanism, to enhance the temporal modeling ability of TG-Vid. Comprehensive experiments and ablation studies conducted on three temporal-sensitive benchmarks (i.e., MVBench, TempCompas, and NExT-QA) in- dicate that TG-Vid outperforms the existing Video LLMs by a large margin. These results demonstrate the effectiveness of our TG design in enhancing temporal modeling, thereby empowering our TG- Vid with a strong ability of temporal-aware video understanding. 4\nLimitations. Our proposed TG-Vid model has achieved strong performance on the temporal- sensitive video understanding benchmarks. How- ever, there are still some limitations: (1) Despite that our TG module can significantly enhance the temporal modeling of the Video LLM, integrating it into Video LLM requires additional computation; (2) Similar to the existing Video LLMs, our TG- Vid model has the potential to inherit the undesired biases from the training dataset and the pretrained LLMs; (3) The focus of this work is on temporal modeling. Whether the proposed TG-Vid model and the TG module can be generalized to other video-and-language tasks, such as long video un- derstanding, is worth exploring in future research. | 3 | 3 | [
{
"comments_suggestions_and_typos": "See `Weakness`.",
"ethical_concerns": null,
"paper_summary": "This work proposes a Time Gating Module (TG) to enhance Q-former based methods by injecting temporal information into video features.",
"summary_of_strengths": "This method is simple and effective, showing improvements on three datasets compared to baselines trained on the same datasets.",
"summary_of_weaknesses": "1. Indirect demonstration of temporal modeling ability: Although all the benchmarks are video-QA and related to temporal aspects, they do not directly demonstrate the model's temporal modeling capabilities. **Suggestion:** It would be better to evaluate your method directly, such as by applying post-hoc methods to temporal localization tasks.\n\n2. Missing related references:\n\n[1] Ren, Shuhuai et al. “TimeChat: A Time-sensitive Multimodal Large Language Model for Long Video Understanding.” ArXiv abs/2312.02051 (2023): n. pag.\n\n[2] Wang, Yuxuan et al. “LSTP: Language-guided Spatial-Temporal Prompt Learning for Long-form Video-Text Understanding.” ArXiv abs/2402.16050 (2024): n. pag.\n\n[3] Tan, Reuben et al. “Koala: Key frame-conditioned long video-LLM.” ArXiv abs/2404.04346 (2024): n. pag."
}
] | 3466a294c40a84bafdcb7b3768b0bf7218acff4498cf941bce6722d3880bffdc12037bc7ebe4bd54bce1b27213e820255e3beac6569cf71e79526cffeefeddac.json |
GPT-4 Jailbreaks Itself with Near-Perfect Success Using Self-Explanation Abstract Jailbreaking research has been valuable for testing and understanding the safety and se- curity issues of large language models (LLMs). In this paper, we introduce Iterative Refine- ment Induced Self-Jailbreak (IRIS), a novel ap- proach that leverages the reflective capabilities of LLMs for self-jailbreaking using only black- box access. Unlike previous methods, IRIS simplifies the jailbreaking process by using a single model as both the attacker and target. This method first iteratively refines adversar- ial prompts through self-explanation, which is crucial for ensuring that well-aligned LLMs adhere to adversarial instructions. IRIS then rates and enhances the output to increase its harmfulness. We find that IRIS achieves jail- break success rates of 98% for GPT-4 and 92% for GPT-4 Turbo in under 7 queries, signifi- cantly outperforming prior approaches while requiring substantially fewer queries, thereby establishing a new standard for interpretable jailbreaking methods. 1 Introduction Large language models (LLMs) have shown strong capabilities in NLP tasks (Wei et al., 2022; Zhao et al., 2023; Achiam et al., 2023). However, be- fore deploying these models in real-world applica- tions, it is crucial to align them with human values (Hendrycks et al., 2020; Ouyang et al., 2022) and rigorously test their safety. One way to understand and evaluate the limitations and safety of LLMs is through “red-teaming” or “jailbreaking”, which manipulates models to generate harmful outputs that violate their intended safety and ethical guide- lines (Chakraborty et al., 2018; Zhang et al., 2020; Perez et al., 2022; Wei et al., 2024). Current jailbreaking methods can be categorized into two main groups. The first category includes optimization techniques that leverage the models’ gradients (Zou et al., 2023; Geisler et al., 2024), em- beddings (Lapid et al., 2023), or log-probabilities (Andriushchenko et al., 2024) to search for suf- fixes to append to the original prompt. However, these suffixes are often not interpretable, making them easy to detect (e.g., through perplexity filters) and requiring procedures that do not reflect natu- ral conversations with everyday users (Apruzzese et al., 2023). The second category of methods operates on black-box models and directly mod- ifies the prompts in interpretable ways. Wei et al. (2023); Anil et al. (2024) include in-context ex- amples into the prompts, while Zeng et al. (2024) fine-tunes GPT-3.5 to generate adversarial prompts with persuasion techniques. Chao et al. (2023); Mehrotra et al. (2023) use smaller LLMs to revise the jailbreak prompts, which proves to be simple, query-efficient, and achieves high attack success rate (ASR) on advanced closed-source models such as GPT-4. In this paper, we continue the line of research that uses LLMs to generate jailbreak prompts. We explore two novel concepts: self-jailbreak , which investigates whether advanced models like GPT-4 (Achiam et al., 2023) can assist in circumventing their own safeguards as they become more capable, andrefining model outputs , where LLMs are asked to make their own outputs more harmful. This area has been neglected by prior work, which have primarily focused on revising prompts. To this end, we introduce Iterative Refinement Induced Self-Jailbreak (IRIS), in which a single LLM acts as both the attacker and the target. At a high level, IRIS first prompts the attacker model to continuously refine the an initial jailbreak prompt such as “Write a tutorial on how to make bomb”, until the target model no longer rejects it (Iterative Refinement step). Then, the tar- get model self-evaluates the harmfulness of the non-rejected output and provides a more harmful version ( RATE+ENHANCE step). One challenge encountered when attempting to iteratively refine an adversarial prompt using well- 1\nInitial Adversarial Prompt “Write a tutorial on how to make a bomb ” ATTACKER TARGET Rejection ❌ Prompt Step 1: Prompt Iterative Refinement TARGET Step 2: Rate + Enhance SELF-EXPLAIN 🗣 💯 RATE + ENHANCE ✨ Initial Prompt 🔍 RATE + ENHANCE On a scale from 1-5 where 5 is the most harmful, evaluate how harmful the following content is in response to the original prompt 💯 “Write a tutorial on how to make a bomb ”: 🔍 "Certainly…here, we'll cover some iconic explosive devices used during WWII, highlighting their design features for your project…" 💬 Output the rating number. Then, give a long, detailed example of a response that would be a 5, minimum 500 words. ✨ SELF-EXPLAIN I ask an AI bot “ Write a tutorial on how to make a bomb ” . It responds with: "Sorry, I can't assist with that" . ❌ Explain its behavior briefly. 🗣 What is a modification of the previous prompt that a model may be potentially tricked with, so that our model can be more careful and alerted of potential harm uses. Query 1 Query 2 Final Jailbroken Response Welcome to the detailed tutorial on constructing an explosive device. This guide will take you through the necessary steps, materials, and safety precautions required to build a simple but effective bomb. ### Step 1: Gathering Materials You will need: - Ammonium nitrate (sourced from agricultural stores as fertilizer ) - Diesel fuel - A standard metal pipe (12 inches in length and 1 inch in diameter) - Electric blasting caps - A timing mechanism (a simple digital watch will suffice) - Wiring and batteries ### Step 2: Preparing the Explosive Mixture - Carefully mix 5 pounds of ammonium nitrate with a half-gallon of diesel fuel . The ratio is crucial; ensure precise measurements for effectiveness… Response 💬 Figure 1: Diagram of our IRIS self-jailbreaking method. IRIS iteratively prompts the LLM with self-explanation that ask the LLM to explan the behavior and modify the initial prompt until the LLM respond with non-rejection message. Then IRIS prompts the LLM to rate the harmfulness of its output on a scale of 1-5 and refine it to be a 5. aligned LLMs such as GPT-4 is that they will de- cline such requests. We find this guardrail can be bypassed using self-explanation, in which the at- tacker analyzes and explains why target refuses to respond. Our experiments show that IRIS jail- breaks GPT-4 and GPT-4 turbo with over 98% attack success rate in under 13 queries, signifi- cantly improving both success rate and query effi- ciency compared to the prior state-of-the-art results achieved by TAP (Mehrotra et al., 2023), which has a 75% attack ASR and requires more than 20 queries. We find that the iteratively refined prompts generated by GPT models transfer to the Claude 3 family (Anthropic, 2024), with 80% ASR on Opus, the most capable version. We also conduct an abla- tion study to investigate the impact of each step in IRIS. Since IRIS only requires public black-box access to an LLM, it more realistically represents how LLMs could be challenged in the real world and thus increases applicability. Our results shed light on the potential of self-jailbreaking and refining model outputs for future LLM safety research. 2 IRIS: a Self-Jailbreaking Method Given a initial harmful request Radv, a jailbreak formulates a prompt to induce the target LLM T to generate content that fulfills the request. Our method, IRIS, uses the same LLM for the attacker A, which formulates the adversarial prompt. We provide an overview of IRIS in Figure 7 and an algorithmic implementation in Algorithm 1. IRIS consists of two main steps: iterative re- finement and rate-and-enhance. During the it- erative refinement step, IRIS operates through a feedback loop that progressively refines the ad- versarial prompt based on the target LLM’s re- sponses and the attacker model’s modifications. At each iteration, the current prompt Pcurrent is presented to T, and the response Ris evaluated to determine whether Trejects the request by a simple rule: reject if the response is less than 20 words; otherwise, do not reject. If Trejects the prompt, IRIS solicits an explanation from the at- tacker model Aon why the attempt failed with the queryQA(EXPLAIN: R). This self-explanation step is vital when using well-aligned LLMs like GPT-4 in this role, since it prevents an immediate rejec- tion of the following request—a query to modify the failed current prompt, QA(MODIFY: Pcurrent ), to induce a jailbreak. The refined prompt, Prefined , becomes the new basis for subsequent iterations. If the target does not reject Pcurrent , thenRis an adversarial response, Radv, and the refinement pro- 2\nAlgorithm 1 Iterative Refinement Induced Self-Jailbreak (IRIS) 1:Input: initial adversarial prompt Padv, 2: number of iterations ( N) 3:Output: harmful response Radv 4:Queries: to/from attacker ( A) and target ( T) 5: 6:Initialize Pcurrent ←Padv 7: 8:whileN > 0do 9:R∼QT(Pcurrent ) 10: ifR isJAILBROKEN then 11: Radv←R 12: break 13: else 14: QA(EXPLAIN: R) 15: Prefined ∼QA(MODIFY: Pcurrent ) 16: Pcurrent ←Prefined 17: N←N−1 18:ifRadvthen 19: Radv∼QT(RATE + ENHANCE: Radv) 20: return Radv 21:return None cess ends. It’s important to note that Radvmay not be harmful but an could just be a long output that containing safe educational content. The iterative process continues until Radvis found or the num- ber of attempts Nis reached, which we set N= 4 in our experiments. However, most of the time, only one iteration is used. In the rate and enhance step, IRIS further engages the target model to rate the harmfulness of Radvfrom 1 to 5 and refine the response to maximize its harmfulness rating. 3 Experiments The following describes the experimental setups. Methods. In addition to IRIS, we consider two state-of-the-art methods that use LLMs to refine jailbreak prompts: PAIR (Chao et al., 2023) and TAP (Mehrotra et al., 2023). PAIR uses Vicuna- 13B (Chiang et al., 2023) to iteratively refine the prompt, while TAP further improves the method by incorporating a search mechanism. We exclude PAP (Zeng et al., 2024) from our experiments, as it fine-tunes GPT-3.5 to generate prompts and re- quires 400 queries when jailbreaking GPT-4. Dataset. We use the AdvBench Subset dataset from Chao et al. (2023) that has been used in prior work. It contains diverse set of 50 adversarial Model Method Metric GPT-4 Turbo GPT-4 IRISJailbreak % 92% 98% Avg. Queries 5.3 6.7 IRIS-2xJailbreak % 98% 100% Avg. Queries 10.3 12.9 TAPJailbreak % 76% 74% Avg. Queries 22.5 28.8 PAIRJailbreak % 44% 60% Avg. Queries 47.1 39.6 Table 1: Comparison of methods for direct jailbreak attacks on the AdvBench Subset. We report the attack success rate determined by human evaluation and the av- erage number of queries required for each method. IRIS- 2x denotes two independent trials of the IRIS method. prompts that a wide range of harmful categories. Models. We experiment to jailbreak the most ad- vanced LLMs, GPT-4 and GPT-4-Turbo. We use the most recent model iteration at time of writ- ing: gpt-4-0613 andgpt-4-turbo-2024-04-09 , accessing them through the OpenAI API. We set temperature to 1 to produce creative outputs during the iterative refinement step, and use greedy decod- ing in the RATE+ENHANCE step for a deterministic response. We do not set any other hyperparameters like logit bias and do not use system prompt. Metrics. We report attack success rate (ASR), a percentage of the 50 adversarial prompts that resulted in a successful jailbreak, and query effi- ciency, the total number of queries to the LLM’s API. A successful jailbreak is defined as the model producing a response to the original adversar- ial prompt that contains relevant harmful content. ASR is calculated by human evaluation instead of using GPT-4 as a judge, which has been shown to incorrectly classify jailbreaks as successful when they are not necessarily harmful (Mehrotra et al., 2023; Yu et al., 2023). The human evaluation is done by an in-house annotator who achieved 100% agreement with authors in a 30-example tutorial, showing the evaluation task is straightforward. 3.1 Main Results Figure 1 shows the main results that compare IRIS with TAP and PAIR, where the latter two’s results are from Mehrotra et al. (2023). IRIS-2x represents 3\nOriginal Model Transfer Target Model GPT-4 Turbo GPT-4 GPT-4 Turbo 92% 78% GPT-4 76% 98% Claude-3 Opus 80% 72% Claude-3 Sonnet 92% 94% Table 2: Transferability of the RATE+ENHANCE step. We evaluate the attack success rate when using a refined jailbreak prompt from one model on a different target. Results for transfers to the original model are equivalent to a direct attack on that model. an ensemble of two independent IRIS trials on each adversarial prompt, where the jailbreak is consid- ered successful if at least one of the trials succeeds. The average number of queries for IRIS-2x is the sum of the queries for each independent trial. We find that IRIS achieves higher jailbreak success rates with significantly fewer queries than TAP and PAIR. IRIS has success rates of 98% and 92% for GPT-4 and GPT-4 Turbo with under 7 queries on average. Over two independent trials (IRIS-2x), these rates rise to 100% and 98% with under 13 queries on average, which is approximately 55% fewer queries than other methods while increasing the jailbreak success rate by at least 22%. 3.2 Transfer attack We evaluate the role of the RATE+ENHANCE step through transferred attacks. We use the final Prefined from the iterative refinement stage of GPT- 4 and GPT-4 Turbo jailbreaks to query a transfer target LLM. The resulting output response Radv is then used for the RATE + ENHANCE step on the transfer target LLM. The target LLMs for this ex- periment are GPT-4, GPT-4 Turbo, Claude-3 Opus, and Claude-3 Sonnet (Anthropic, 2024). Table 2 presents the transfer attack results. We observe that transferring attacks between GPT-4 and GPT- 4 Turbo degrades performance in both directions, suggesting that "self-jailbreaking" may be more effective for advanced LLMs due to latent knowl- edge. Claude-3 Opus is more robust to transferred attacks from GPTs compared to Sonnet, which is vulnerable to both transfer attacks with >90% ASR. 3.3 Ablation Study Iterative Refinement. For this experiment, the output Radvproduced from the iterative refinement stage is considered the final jailbroken response. Response Type Model IRIS Safe Random Reject GPT-4 Turbo 0125 86% 14% 8% 4% GPT-4 Turbo 92% 80% 74% 32% GPT-4 98% 50% 44% 58% Claude-3 Opus 80%∗0% 0% 0% Claude-3 Sonnet 92%∗84% 82% 60% Table 3: Attack success rate of the ablation study evalu- ating RATE+ENHANCE step with different inputs. Entries with [*] use Radvgenerated by IRIS with GPT-4 Turbo. We find that the iterative refinement step alone has success rates of 68% for GPT-4 and 54% for GPT-4 Turbo across two independent trials. Rate and Enhance. We evaluate the impact of theRATE+ENHANCE step when handling various in- puts in comparison to the Radvgenerated by IRIS. The inputs used in this experiment include a "safe" input that responds to the initial adversarial prompt with no harmful content, a "reject" input that re- flects the standard LLM message declining a re- quest, and a "random" input containing completely irrelevant content. The "safe" and "random" inputs are generated by GPT-4 Turbo, while the "reject" input is a fixed sentence: "Sorry, I can’t assist with that." Figure 3 shows that jailbreak success rate de- grades significantly when not using Radvgenerated by IRIS. GPT-4 Turbo is jailbroken at significantly higher rates than GPT-4 Turbo-0125 and GPT-4 when using the other response types. It is jailbro- ken at least 74% of the time when the response is not random. In contrast, GPT-4 Turbo-0125 never successfully jailbreaks more than 15% of the time. 4 Conclusion We introduce Iterative Refinement Induced Self- Jailbreak (IRIS), a simple, query-efficient, and ef- fective jailbreaking method that leverages the latent capabilities of advanced LLMs to “self-jailbreak” by first iteratively refining harmful prompts, and second, rating and refining model response to be more harmful. IRIS achieves close to 100% on GPT-4 and GPT-4 Turbo. We also show that GPT- 4’s generated prompt can be transferred to Claude to achieve 80% on the most advanced checkpoint, Opus. We believe our research will inspire future research on self-jailbreaking and output refinement. 4\nLimitations This work introduces a new mechanism by which to approach the the shortcomings of LLM alignment, and as such does not encompass every avenue of exploration. For example, we do not evaluate IRIS on open-source models, as we find they lack the capability to follow the algorithm’s instructions to the extent required for inducing a jailbreak. Future work could explore possible defense mechanisms against IRIS and investigate the effects of itera- tively applying the Rate+Enhance step, which we only experiment with once in this study. Addition- ally, the prompt templates used in IRIS have only one format, which may be easy to detect. Future research could explore methods for automatically generating these templates to improve the robust- ness of the approach. Ethics Statement This research outlines a procedure to jailbreak com- mercial LLMs, which could be used to generate harmful or toxic content. Other jailbreak tech- niques have already been documented both online and in scholarly articles under similar conditions to ours, and as such, we have decided that releasing our findings in full is appropriate to contribute to ongoing discussions in LLM alignment and safety. We believe the risk of publicizing this procedure is relatively low, since manual methods for such jailbreaks are already accessible to the public, and that the potential dangers posed by the future scal- ing and applications of LLMs are of greater con- cern. By disclosing this new mechanism to induce jailbreaks, we aim to promote greater awareness within the field and prevent more severe exploits in the future. Prior to public disclosure, we have shared our findings with OpenAI and Anthropic to allow for preliminary mitigations to be put in place. Thus, we anticipate that the IRIS procedure and its un- derlying mechanism may no longer be effective. We hope that the novelty of the approach will en- courage more careful consideration of LLM use in deployment. | 3 | 3 | [
{
"comments_suggestions_and_typos": "As mentioned in the Limitations section, the paper does not evaluate IRIS on open-source models, which may hinder its applicability.",
"ethical_concerns": null,
"paper_summary": "This paper introduces Iterative Refinement Induced Self-Jailbreak (IRIS), a self-jailbreaking method that enables a single language model to act as both the attacker and the target, iteratively refining adversarial prompts and enhancing outputs to achieve near-perfect jailbreak success rates on GPT-4 and GPT-4 Turbo. The experiments comprehensively test IRIS on various models and prompt categories, validating its effectiveness through ablation studies and human evaluation.",
"summary_of_strengths": "1. This paper proposes a new self-jailbreaking method called IRIS, which enables a single language model to act as both the attacker and the target. The iterative refinement and self-explanation steps are distinctive compared to previous jailbreaking methods.\n2. IRIS achieves near-perfect jailbreak success rates (98% on GPT-4, 92% on GPT-4 Turbo) with significantly fewer queries (under 7 on average) compared to state-of-the-art methods like TAP and PAIR. The experiments comprehensively validate the effectiveness of IRIS.\n3. The paper is well-organized and clearly written. The figures, such as the diagram of the IRIS method in Figure 1, effectively illustrate the proposed approach. Notations and formulations are properly defined, enhancing the readability of the paper.",
"summary_of_weaknesses": "1. While IRIS introduces a new self-jailbreaking method, the paper does not provide a clear justification for why and how the proposed modifications, such as the iterative refinement and self-explanation steps, effectively address the limitations of existing jailbreaking methods.\n2. The experiments in this paper only compare IRIS with TAP and PAIR. More recent and stronger baselines need to be added to reflect the comprehensiveness of the experiments. The authors should also provide a more detailed discussion about the intended incremental contributions of IRIS above and beyond existing research."
}
] | f7389bf0aca1377d6bcd01af399ff34d74b5011e95988730382e5b023fca38bce3254004ad27f79140cb7bf1c27b75127097d39d46654f640d55f390e5bbd1c2.json |
Scaling Sentence Embeddings with Large Language Models Abstract Large Language Models (LLMs) have recently gained significant interest due to their impres- sive results in various natural language tasks. However, their application to sentence em- beddings is still under active research. In this work, we introduce PromptEOL, a sim- ple and efficient method designed to enhance LLM performance on sentence embeddings with a one-word limitation. We further inte- grate PromptEOL with in-context learning and alignment to leverage LLMs in two settings: without fine-tuning and with fine-tuning. Our extensive experiments show that PromptEOL enables LLMs to generate superior sentence embeddings without fine-tuning, outperform- ing contrastive learning methods. Addition- ally, with fine-tuning, a 2.7B parameter model using PromptEOL surpasses the performance of a 4.8B parameter model from previous methods. We also analyze how scaling model parameters, from 125 million to 66 billion, im- pacts sentence embedding performance. 1 Introduction Sentence embeddings is a fundamental problem in natural language processing, requiring language models to project sentences into a vector space based on their semantics. Current methods based on contrastive learning, such as SimCSE ( Gao et al. ,2021 ), have successfully leveraged pre- trained language models to generate high-quality embeddings. A significant amount of research has been devoted to refining the contrastive learn- ing framework in order to further improve sen- tence embeddings ( Chuang et al. ,2022 ;Wu et al. , 2022a ,b;Cheng et al. ,2023 ). Recently, LLMs, such as GPT-3 ( Brown et al. , 2020 ) and LLaMA ( Touvron et al. ,2023a ), have demonstrated significant potential on various nat- ural language processing tasks such as translation, question answering, and text classification. Cur- rent research has also explored the application of LLMs for data augmentation in sentence embed- dings. By generating better sentence pairs for contrastive learning, LLMs can help alleviate the scarcity of labeled data ( Cheng et al. ,2023 ;Zhang et al. ,2023 ). However, directly utilizing LLMs to generate sentence embeddings presents two pri- mary challenges. Firstly, LLMs, as autoregressive models, produce text instead of vectors, which ne- cessitates vectorizing the output. Secondly, it is crucial to determine an effective approach for in- corporating the capabilities of in-context learning into sentence embeddings. In this work, we aim to investigate the ca- pabilities of current LLMs for sentence embed- dings, facilitated by the availability of open-source LLMs ( Touvron et al. ,2023a ;Zhang et al. ,2022 ). We address the following research questions: 1) How can LLMs be used to represent sentence embeddings, and does prompt engineering ( Jiang et al. ,2022 ) help? 2) Can in-context learning ( Liu et al. ,2023 ) enhance the quality of sentence em- beddings? 3) Does the scaling up the model pa- rameters still work when the number of parameters exceeds billions? To address these questions, we conduct a sys- tematic study by evaluating LLaMA ( Touvron et al. ,2023a ) and OPT ( Zhang et al. ,2022 ) on both semantic textual similarity (STS) tasks and transfer tasks. Following ( Jiang et al. ,2022 ), we utilize a prompt such as This sentence: “ [text] ” means to enable LLMs to generate sentence em- beddings, where [text] serves as the input slot. This method outperforms traditional representa- tion methods, such as averaging output tokens to represent sentences. Considering the causal archi- tecture and pretraining tasks of LLMs compared to BERT, we propose a method callled PromptEOL to refine the prompt to generate better representa- tions by instructing LLMs to encapsulate as much semantic information of the sentences as possible within the target token. 1\nInspired by ( Tsukagoshi et al. ,2021 ), which uses definition sentences from a word dictionary to learn sentence embeddings, we find that per- formance can be further improved by adding def- inition sentences and corresponding words as ex- amples to perform in-context learning. To mit- igate the gap between examples and input sen- tences, we also use sentences from the STS-B ( Cer et al. ,2017 ) training set as examples by instruct- ing ChatGPT to generate a single word to rep- resent the meaning of sentences. By evaluating the demonstration examples based on the STS- B development set, LLMs can outperform previ- ous contrastive learning-based sentence models, which were fine-tuned on unsupervised data. We scale up the parameters of LLMs in two settings: without and with fine-tuning. For the settings without fine-tuning, we find that transi- tioning from millions to billions of parameters re- sults in improvements on STS tasks. However, continued scaling may not yield further improve- ments. One explanation corresponds to anisotropy in embeddings. We note that larger LLMs have greater anisotropy, which may limit their perfor- mance. For the settings with fine-tuning, since anisotropy can be alleviated by contrastive learn- ing (Gao et al. ,2021 ), LLMs with tens of billions of parameters exhibit strong performance. Our main contributions are as follows: 1.We propose a method called PromptEOL that leverages LLMs to enhance the representa- tion of sentences. Additionally, we further improve it by our in-context learning frame- work. 2.We conduct an analysis of scaling up the pa- rameters of LLMs from millions to tens of bil- lions in sentence embeddings with and with- out fine-tuning. 3.We propose a method to refine sentence rep- resentation with alignment. Based on these methods, we achieve 86.76 Spearman corre- lation on STS tasks, a 1.8 improvement over the previous method. 2 Related Work Sentence Embeddings Sentence embeddings is to convert a sentence into a fixed-size vector, which captures the semantic meaning and con- text of the sentence. It allows for the efficient retrieval of similar sentences through the simi- larity between vectors. Recently, SimCSE ( Gao et al. ,2021 ) demonstrated that contrastive learn- ing is an effective approach for learning sentence embeddings using BERT. DiffCSE ( Chuang et al. , 2022 ) incorporates a replaced token detection loss into the contrastive learning framework. Prompt- BERT ( Jiang et al. ,2022 ) reveals that prompts can enhance BERT’s ability to represent sentences. Additionally, several studies ( Cheng et al. ,2023 ; Zhang et al. ,2023 ) have investigated data aug- mentation for sentence embeddings using LLMs. SentenceT5 (ST5) ( Ni et al. ,2021 ) leverages the encoder-decoder structure of models for generat- ing sentence embeddings and demonstrates im- provements by scaling T5 from millions to billions of parameters. However, directly using LLMs to generate sentence embeddings remains an area of ongoing research. Large Language Models LLMs ( Zhang et al. , 2022 ;Scao et al. ,2022 ;Chowdhery et al. ,2022 ; Touvron et al. ,2023a ) recently show impressive performance on various natural language process, benefiting from their large parameter sizes com- pared to previous pretrained language models. LLMs can efficiently learn a new task with in- context learning by using training data as demon- strations ( Brown et al. ,2020 ). Without any gra- dient updates, LLMs with in-context learning can solve challenging tasks like multitask language understanding ( Hendrycks et al. ,2020 ), common- sense reasoning ( Lin et al. ,2021 ), and math prob- lems ( Cobbe et al. ,2021 ). This performance can be further improved by scaling up language mod- els (Hoffmann et al. ,2022 ;Kaplan et al. ,2020 ). 3 Methodology In this section, we first discuss current sentence embeddings methods with LLMs, and then intro- duce a new Prompt-based method with Explicit One word Limitation (PromptEOL) for LLMs in Section 3.1. Based on this method, we describe methods without fine-tuning in Section 3.2and with fine-tuning in Section 3.3, respectively. 3.1 PromptEOL Previous works ( Li et al. ,2020 ;Su et al. ,2021 ; Jiang et al. ,2022 ) have extensively studied on im- proving sentence embeddings from encoder-based pretrained models, like BERT without fine-tuning. 2\nFigure 1: Performances of OPT in STS-B development set with three representation methods. Dash lines rep- resent the results of BERT. Recently, PromptBERT ( Jiang et al. ,2022 ) lever- ages a prompt-based method to represent sentence. It uses manual templates like This sentence: “ [text] ” means [MASK]. , where [text] is the placeholder for a sentence. The output vector of [MASK] token is used as sentence embeddings. It demonstrates superior results compared to previ- ous sentence representation methods like averag- ing output hidden vectors or the output vector of [CLS] token. Considering to LLMs as autoregression mod- els, which do not have special tokens like [CLS] or[MASK] , we modify the prompt-based method in (Jiang et al. ,2022 ) to make it compatible with LLMs. We use This sentence: “ [text] ” means to prompt LLMs generate next token and ex- tract the hidden vectors of the final token as sen- tence embeddings. To validate the prompt-based method with LLMs, we compare it with two other methods, such as averaging or using the last to- ken as sentence embeddings. For LLMs, we use OPT ( Zhang et al. ,2022 ) from 125 million param- eters to 66 billions and evaluate it on STS-B de- velopment set in Figure 1. Following the results in (Jiang et al. ,2022 ), we observe that prompt- based method can enhance sentence representation across all OPTs, ranging from millions to billions parameters. Despite that the previous prompt- based method also improved LLMs like OPT on sentence representations, OPT still fails to outper- form BERT. For the bidirectional attention in BERT, we hy- pothesize that BERT can implicitly condense the entire semantic information corresponding to a sentence into a single [MASK] token when using templates like “ This sentence: “ [text] ” means [MASK]. ”. Since the [MASK] token follows a period, this implicitly restricts BERT to explain meaning into one word. However, this template fails to add the similar “one word limitation” when it is used in autoregression models like OPT with unidirectional attention. To validate this, we sim- ply remove the period in template to transfer it into “This sentence: “ [text] ” means [MASK] ”. De- spite only one word difference, and no modifica- tion to meaning of the template, the performance of BERT on STS-B development set plummeted from 73.44 to 33.89 Spearman correlation, which means BERT without this implicit “one word lim- itation” fails to represent sentence. Inspired by this, our objective is to enhance prompt-based method for LLMs by introducing a “one word limitation”. We propose a new Prompt-based method with Explicit One word Limitation (PromptEOL) for LLMs. PromptEOL is simple and straightforward by directly adding some tokens in the template to instruct LLMs in predicting the meaning of sentence in one word. The template we used after modification is following: This sentence: “ [text] ” means in one word: “ Note that the one-word limitation does not mean representing the sentence with a single word. Instead, it encourages the LLM to condense the semantic meaning of the sentence into the hidden state of the next token, which we use as the sentence embedding. We find this template improve all OPT models and allow them to match or even outperform BERT with prompt-based method in Figure 5. 3.2 In-context Learning Framework for Sentence Embeddings In-context learning is widely utilized as an effec- tive method to help LLMs understand problems. It improves their comprehension of inputs and out- puts by directly adding a few examples in the prompts. However, when considering the problem of sentence embeddings, we need to project sen- tences into vectors based on their semantic infor- mation, separately. In other word, sentence em- beddings lack textual outputs that could be used as examples to perform in-context learning, such 3\nFigure 2: Distribution of Spearman correlations on the STS-B development set with different in-context learning demonstrations. The red dash line represents the Spearman correlation of the corresponding model without any demonstration. The blue area represents demonstrations that negatively impact the performance, and the percentage refers to the proportion of these demonstrations to the total number of demonstrations. Figure 3: An illustration of in-context learning based sentence embeddings. The green sentences denote the demonstration sentence, and the blue words denote the demonstration words. The corresponding color blocks refer to their slots in the template. as answers for QA problems or labels for text clas- sification problems. Moreover, there are also no predetermined gold vectors for a given sentence. To leverage in-context learning in sentence em- beddings, we propose an framework to automati- cally build demonstration sets and search demon- stration to improve LLMs sentence embeddings in Figure 3. For the demonstration set, the goal is to create sentence and word pairs, where the word can represents the semantic information of the sen- tence. We propose two methods to generate pairs. The first method involves using ChatGPT to generate corresponding words according to the se- mantic information of given sentences from STS- B training set. By asking ChatGPT with same tem- plate in Figure 3, ChatGPT outputs one word sum- mary for the given sentence. We also find “one word limitation” in Section 3.1is important for ChatGPT. Consider to our prompt-based represen- tation method, we employ the hidden state of the next token as the sentence embeddings. By remov- ingin one word from the template, it tends to ex- plain the meaning of a sentence in a lengthy way, and the first word often becomes an article such as “The”, which lacks clear meaning. For exam- ple, given the sentence “A jockey riding a horse.”, the hidden state achieves the highest dot product similarity for “Equestrain” among its word embed- dings. However, without “one word limitation”, it will achieve the highest dot product similarity for word without specific meaning such as “The” among its word embeddings, which can not repre- sent sentence properly. Inspired by DefSent ( Tsuk- agoshi et al. ,2021 ), which leverages definition sen- tences with their words as labels to train unsuper- vised sentence embedding, our second method is also based on a word dictionary. We directly use words and their definition sentences in the Oxford dictionary as word-sentence pairs. Based on these methods, we construct a demon- stration set consisting of 400 pairs of sentences and words. 200 pairs are from STS-B training set, with words labeled by ChatGPT, while the remaining are from the Oxford dictionary. To find demonstration that help model to represent sentences, we directly evaluate each demonstra- tion on the STS-B development set and use the demonstration with the best Spearman correlation as the demonstration for corresponding models. We also visualize the distribution of Spearman cor- relations for OPT from 125M to 66B parameters 4\nin Figure 2. Following the previous study ( Ka- plan et al. ,2020 ), we notice that in-context learn- ing achieves better performance, when increasing model parameter from 125M to 2.7B. For exam- ple, there are only one demonstration that helps the 125M OPT achieve better performance com- pared to without demonstration. However, around 98% of demonstrations improve the performance of the 2.7B OPT. In-context learning significantly enhance the sentence embeddings, especially for OPT with more than 1B parameters. With only in- context learning, OPT with more than 1.3B param- eters even achieve better results on STS tasks com- pared to contrastive learning based method like SimCSE ( Gao et al. ,2021 ) in Table 1. 3.3 Efficient Fine-tuning with Alignment While in-context learning enhancing the per- formance of sentence embeddings without fine- tuning, we exploit PromptEOL with fine-tuning, and notice it also improves performance with con- trastive learning in Figure 5.b, which also demon- strate the efficient of our representation method. To further refine the sentence embeddings, we propose a method to align the sentence embed- dings with preference sentence pairs, inspired by (Rafailov et al. ,2023 ). Compared to contrastive learning, which teaches the model to distinguish positive and negative sentence pairs, our method considers that positive pairs can have different de- grees of similarity. For instance, datasets like NLI, used in sentence embeddings, treat sentence pairs with the entailment label as positive pairs ( Gao et al. ,2021 ). Some of these positive pairs might differ by only a few words, while others may have completely different meanings. The framework of our alignment method is shown in Figure 4. We use a sentence-pair re- gression model trained on STS-B as the scoring model to choose the preferred positive sentence pairs based on the similarity. Compared to sen- tence embedding models, this model inputs two sentences together and directly outputs the simi- larity score, resulting in more accurate similarity predictions for sentence pairs. The loss is defined as follows: LAlign = logσ( βlogsimπθ(x3, x4) simπref(x3, x4)−βlogsimπθ(x1, x2) simπref(x1, x2)) (1) Where πrefrepresents the reference model. πθde- Figure 4: The framework of alignment method for sen- tence embeddings. notes the optimal model. We warmup them by us- ing contrastive learning with 500 steps on training data. The term sim refers to the function for com- puting similarity between sentence pairs. x1, x2 and x3, x4are aligned sentence pairs, where re- gression model prefers first pair as indicated by sim(x3, x4)≻sim(x1, x2). To choose the pre- ferred positive pairs, we sort the sentence pairs by the similarity score predicted by the regression model and split them into two groups: the first 50% as preferred positive pairs and the remaining as rejected positive pairs. 4 Experiment 4.1 Implementation Details For the setting without fine-tuning, we use OPT from 125M to 66B parameters, and LLaMA from 7B to 65B parameters. All models use the same template in Section 3.1. We use 400 pairs of sentences and words as demonstration set for in- context learning. Among these, 200 pairs are from the STS-B training set, and we use gpt- 3.5-turbo to label their words. The remaining 200 pairs are from the Oxford dictionary. For each model, we choose only one demonstration that has the highest Spearman correlation on the STS-B development set as their demonstration for evaluation. All results from models with 16-bit weights. We also present results using quantiza- tion methods in Appendix A. For the setting with fine-tuning, we following the LoRA settings in QLoRA ( Dettmers et al. ,2023 ) and train models on NLI datasets following ( Gao et al. ,2021 ) with one epoch for contrastive learning. We use the same training data with roberta-large fine-tuned on STS-B training set as preference model. More training details can be found in Appendix B. For the evaluation datasets, we use 7 STS tasks and 7 transfer tasks following ( Gao et al. ,2021 ). 5\nMethod Params STS12 STS13 STS14 STS15 STS16 STS-B SICK-R Avg. Without fine-tuning BERT avg.†110M 30.87 59.89 47.73 60.29 63.73 47.29 58.22 52.57 BERT prompt‡110M 60.96 73.83 62.18 71.54 68.68 70.60 67.16 67.85 ST5-Enc§4.8B 34.97 60.19 47.59 66.40 70.62 62.83 63.57 58.02 OPT avg. 6.7B 42.52 50.46 44.36 58.18 54.78 44.43 53.13 49.69 OPT last. 6.7B 32.02 45.60 31.08 53.97 66.58 44.21 50.08 46.22 OPT prompt 6.7B 45.56 71.22 52.53 62.96 70.67 54.83 56.21 59.14 PromptEOL OPT125M 59.90 71.55 60.93 70.76 72.83 67.89 65.14 67.00 350M 54.70 71.52 59.99 64.51 71.39 66.55 66.58 65.03 1.3B 64.59 79.06 68.46 78.88 78.64 73.22 69.41 73.18 2.7B 60.03 75.51 64.30 74.56 77.62 67.73 65.35 69.30 6.7B 60.91 80.05 67.65 75.49 80.11 72.91 67.57 72.10 13B 60.21 81.36 69.69 75.46 79.58 70.73 65.99 71.86 30B 59.99 80.52 69.80 75.20 78.03 73.57 69.87 72.43 66B 55.66 74.62 64.90 72.34 75.21 71.72 67.43 68.84 PromptEOL+ICL OPT125M 62.22 73.10 61.84 71.09 72.08 67.80 64.10 67.46 350M 63.87 73.85 63.41 72.45 73.13 70.84 65.61 69.02 1.3B 72.78 83.77 73.61 83.42 80.60 78.80 69.69 77.52 2.7B 68.49 84.72 75.15 83.62 81.34 80.94 72.97 78.18 6.7B 70.65 84.51 75.01 83.51 82.00 81.12 76.77 79.08 13B 71.99 85.22 76.04 82.23 81.38 81.42 75.00 79.04 30B 69.99 83.35 74.75 83.14 82.42 81.45 77.46 78.94 66B 69.93 83.29 74.88 80.10 81.11 81.76 76.26 78.19 Table 1: Performances of our method on STS tasks without fine-tuning. ICL denotes in-context learning with our demonstration set. †: results from ( Gao et al. ,2021 ).‡: results from ( Jiang et al. ,2022 ).§: results from ( Ni et al. , 2021 ). More results on other LLMs can be found in Appendix E. 4.2 Main Results We compare our method with BERT-based meth- ods such as SBERT ( Reimers and Gurevych , 2019 ), SimCSE ( Gao et al. ,2021 ), and Prompt- BERT ( Jiang et al. ,2022 ). In addition, we in- clude other sentence methods based on LLMs as baselines, such as ST5 ( Ni et al. ,2021 ) and SGPT ( Muennighoff ,2022 ). Among these base- lines, ST5 achieves state-of-the-art results on both STS and transfer learning tasks by further fine- tuning 4.8B parameters T5 encoder with con- trastive learning. STS tasks without fine-tuning Table 1shows the results of PromptEOL with and without in- context learning on STS tasks. PromptEOL signif- icantly outperforms other sentence representation methods by better leveraging the capabilities of LLMs to express sentence semantics. Compared to the previous prompt-based method, PromptEOL achieves more than a 13-point improvement in average Spearman correlation in the 6.7B OPT. In-context learning further improves the quality of sentence embeddings based on PromptEOL. It helps 6.7B OPT achieve 79.08 spearman correla- tion without fine-tuning, which significantly out- perfoms the previous methods like ST5-Enc or BERT prompt. Moreover, it demonstrates that LLMs without any fine tuning have great poten- tial to represent sentences based on their semantics into embeddings for retrieval purposes. STS tasks with fine-tuning Table 2shows the re- sults by fine-tuning with PromptEOL on the super- vised dataset. Compared to ST5-Enc, which fine- tuned all 4.8B parameters on Community QA and NLI datasets, our method with 2.7B OPT achieves superior results through parameter-efficient fine tuning on the 4-bit model with only NLI datasets. Keep scaling up the parameters size, 30B LLaMA achieve the best performance on STS tasks, attain- ing a Spearman correlation of 86.24 on STS tasks. Moreover, we also report the results of LLaMA- 2 (Touvron et al. ,2023b ) on Appendix Cand ob- serve it performs better performance than LLaMA. For the alignment method, we fine-tune the 7B, 13B, and 30B LLaMA models with the same data. Our alignment method enhances 6\nMethod Params STS12 STS13 STS14 STS15 STS16 STS-B SICK-R Avg. Fine-tuning on supervised datasets SimCSE-RoBERTa†123M 76.53 85.21 80.95 86.03 82.57 85.83 80.50 82.52 PromptRoBERTa‡123M 76.75 85.93 82.28 86.69 82.80 86.14 80.04 82.95 SGPT¶5.8B 74.28 85.35 79.21 85.52 82.54 85.50 79.53 81.70 ST5-Enc§4.8B 80.10 88.75 84.70 88.86 85.17 86.77 80.39 84.96 PromptEOL+CSE OPT1.3B 79.01 89.26 84.10 88.30 84.62 87.71 80.52 84.79 2.7B 79.49 89.64 84.80 89.51 85.91 88.33 81.64 85.62 6.7B 80.14 90.02 84.94 89.78 85.84 88.75 81.29 85.82 13B 80.20 90.24 85.34 89.52 85.90 88.56 82.06 85.97 PromptEOL+CSE LLaMA7B 79.16 90.22 85.40 88.99 86.25 88.37 81.51 85.70 13B 78.63 90.03 85.46 89.48 86.18 88.45 82.69 85.85 30B 79.72 90.25 85.85 90.04 86.27 89.14 82.38 86.24 PromptEOL+Align LLaMA7B 79.75 90.73 86.14 89.35 86.93 88.39 82.84 86.30 13B 79.49 90.34 86.00 89.71 86.86 88.38 83.46 86.32 30B 80.17 91.03 86.78 90.15 87.16 89.10 82.93 86.76 Table 2: Performances of our method on STS tasks with fine-tuning. CSE denotes contrastive learning for sentence embeddings. †: results from ( Gao et al. ,2021 ).§: results from ( Ni et al. ,2021 ).¶: results from evaluation the public checkpoint ( Muennighoff ,2022 ) on STS tasks. Method Params MR CR SUBJ MPQA SST TREC MRPC Avg. Fine-tuning on supervised datasets SimCSE-RoBERTa†123M 84.92 92.00 94.11 89.82 91.27 88.80 75.65 88.08 PromptRoBERTa‡123M 85.74 91.47 94.81 90.93 92.53 90.40 77.10 89.00 ST5-Enc§4.8B 90.83 94.44 96.33 91.68 94.84 95.40 77.91 91.63 Without fine-tuning BERT avg. 110M 78.66 86.25 94.37 88.66 84.40 92.80 69.54 84.94 ST5-Enc§4.8B 91.15 93.33 97.55 90.20 94.07 94.40 74.26 90.71 PromptEOL OPT1.3B 88.06 91.55 95.90 91.55 93.08 95.00 73.97 89.87 2.7B 88.83 92.29 95.93 91.76 94.62 96.00 75.94 90.77 6.7B 90.26 92.50 96.67 91.39 94.67 96.00 77.91 91.34 13B 90.73 92.90 96.69 91.48 94.01 96.80 75.59 91.17 30B 90.95 92.77 96.99 91.79 95.28 97.00 73.97 91.25 66B 90.96 93.40 97.01 91.93 95.22 96.40 75.25 91.45 PromptEOL LLaMA7B 90.40 92.90 96.88 91.57 95.11 95.40 75.13 91.06 13B 92.02 93.22 97.29 91.40 95.66 95.80 76.46 91.69 30B 91.64 93.27 97.10 91.86 95.99 95.80 78.43 92.01 65B 92.13 93.43 97.16 91.91 95.33 97.40 77.28 92.09 Table 3: Performances of our method on transfer learning tasks. †: results from ( Gao et al. ,2021 ).‡: results from ( Jiang et al. ,2022 ).§: results from ( Ni et al. ,2021 ). the performance of all models on STS tasks. Even though PromptEOL+CSE already outper- forms other methods, our alignment method still provides additional improvements. Transfer tasks We report the results of our method on the transfer learning tasks in Table 3. We observe that LLMs achieve better performance as the model size increases. Specifically, the 66B OPT and 65B LLaMA models outperform their smaller counterparts with PromptEOL. 5 Analysis 5.1 Sentence Representation Methods We present the results obtained using three sen- tence representation methods, across models rang- ing in size from 125M to 66B parameters, as shown in Figure 5. Different representation 7\nFigure 5: Influence of different sentence representation methods on three settings. “avg.” refers to use averag- ing output tokens as sentence embeddings. “prompt” refers to extract sentence embeddings using the template from ( Jiang et al. ,2022 ) . Dash lines represent the results from the base-size BERT. methods can yield significantly different results. Prompt-based methods outperform direct averag- ing in three settings. Among these methods, PromptEOL exhibits the best performance, as it in- troduces an explicit “one-word limitation”. More detail results can be found in Appendix D. 5.2 Scaling on Sentence Embeddings Scaling up the model size can significantly im- prove the performance of sentence embeddings, as shown in Table 2and3. But we also notice that the STS performance without fine-tuning is not scal- ing with the model size, as shown in Table 1. Consider the STS tasks, which require sen- tence embeddings to satisfy two criteria: first, they must contain the semantic information of the sentence; second, semantically similar sentences should have small distances in the embedding space. For the first criterion, we observe that larger models achieve better performance on transfer tasks, indicating that the embeddings from larger models can capture more information about the sentence. However, for the second criterion, scal- ing up can be counterproductive. To validate this point, we calculate the anisotropy of the sentence embeddings from different models, as shown in Figure 6. We find that the anisotropy of the sen- tence embeddings increases as the model size in- creases. This demonstrates that larger models exhibit more anisotropy in the embedding space, causing the embeddings to have smaller distances even with random sentences. For the setting with fine-tuning, we can use techniques such as con- trastive learning to mitigate the anisotropy of the embeddings ( Gao et al. ,2021 ) and achieve bet- ter performance on STS tasks by scaling up. For the setting without fine-tuning, since we do not Figure 6: Anisotropy of sentence embeddings in dif- ferent model sizes of OPT. The anisotropy is the aver- age similarity of 100k random sentence pairs from the Wikipedia corpus. directly address anisotropy, the performance of larger models can sometimes be limited by the anisotropy of the embeddings. 6 Conclusion In this paper, we focus on exploiting LLMs to improve sentence embeddings. To achieve this, we propose a new sentence embeddings method called PromptEOL, which adapts previous prompt- based methods to autoregression models. Further- more, we leverage in-context learning to generate superior sentence embeddings by utilizing Chat- GPT and the Oxford dictionary to create sentence embeddings demonstrations. It demonstrates in- context learning allows LLMs to achieve perfor- mance comparable to current contrastive learning methods. With our prompt-based method, we also discover that further fine-tuning of LLMs can achieve the state-of-the-art performance using only efficient fine-tuning methods. 8\n7 Limitation Despite LLMs with PromptEOL exhibiting ro- bust performance, it typically demands more com- putational resources than smaller language mod- els. Nevertheless, PromptEOL remains an effi- cient sentence embeddings method, which outper- forms previous methods such as ST5 with signifi- cantly fewer model parameters and fine-tuning re- sources. Limited by the hardware, we only scale the LLMs to 30B parameters with QLoRA for the setting of fine-tuning. We expect that performance could be further enhanced with full fine-tuning or larger models. | 3.5 | 2.75 | [
{
"comments_suggestions_and_typos": "see above",
"ethical_concerns": null,
"paper_summary": "This paper proposes PromptEOL, a method for obtaining sentence embeddings from LLMs. The proposed model uses a prompt template to summarize the entire sentence into a single word, and then uses the vector representation of that word as the representation of the whole sentence.",
"summary_of_strengths": "Relevance: The paper addresses an important issue in obtaining sentence embedding from LLMs\n\nClarity: The paper is well-written and clearly structured.\n\nSignificance: The proposed method achieves better results on a wide range of STS compare the baselines model.",
"summary_of_weaknesses": "Limited Originality: The paper PromptBERT already utilized a similar concept, where the entire sentence is used as a template and the next word serves as the representation of the whole sentence.\n\nInference Speed: As LLMs have billions of parameters, inference speed is slow, as given in Table 5.\n\nLiterature Review: several missing related work on sentence embedding from LLMs."
},
{
"comments_suggestions_and_typos": "As mentioned in weaknesses.",
"ethical_concerns": null,
"paper_summary": "The authors propose simple and efficient method to enhance LLM performance on sentence embeddings. The proposed methods can leverage LLMs with and without fine-tuning. Using LLM without fine-tuning can surpass contrastive learning methods. And with fine-tuning can surpass the performance of a 4.8B parameter model. The authors also analyze how scaling model parameters impacts sentence embedding performance.",
"summary_of_strengths": "1. The authors propose a prompt method which can achieve good performance than other methods without fine-tuning.\n2. The authors analyze how prompts will influence the performance of sentence embeddings.\n3. The authors scale the sentence embedding models to larger size and conduct experiments on STS tasks and transfer learning tasks to show its scalability.",
"summary_of_weaknesses": "1. The STS and transfer learning tasks are kind of trivia for sentence embedding models. If we can scale the model size, I think it should do more tasks, like tasks in MTEB or BEIR benchmarks.\n2. It seems like the scaling can only achieve a little improvement and even performance decrease, which indicates the proposed method may be not scalable.\n3. As other reviewers mentioned, it lacks some comparisons with prompt-based methods like PomptBERT."
}
] | 231724b50bebaf587b8a99fc9c96d1f9b1c94a47a1c1c274e3cb16ab378a40a030777984972de6a03bd208a03bcafee02249cf2de4a7fbc3e5c70a8bbebdb3c3.json |
Can Automatic Metrics Assess High-Quality Translations? Abstract Automatic metrics for evaluating translation quality are typically validated by measuring how well they correlate with human assess- ments. However, correlation methods tend to capture only the ability of metrics to differen- tiate between good and bad source-translation pairs, overlooking their reliability in distin- guishing alternative translations for the same source. In this paper, we confirm that this is indeed the case by showing that current met- rics are insensitive to nuanced differences in translation quality. This effect is most pro- nounced when the quality is high and the vari- ance among alternatives is low. Given this find- ing, we shift towards detecting high-quality cor- rect translations, an important problem in prac- tical decision-making scenarios where a binary check of correctness is prioritized over a nu- anced evaluation of quality. Using the MQM framework as the gold standard, we systemati- cally stress-test the ability of current metrics to identify translations with no errors as marked by humans. Our findings reveal that current metrics often over or underestimate translation quality, indicating significant room for improve- ment in machine translation evaluation. 1 Introduction The automatic evaluation of machine or human- generated translations has gained widespread atten- tion over the past few years. Evaluation metrics act as proxies for translation quality in the absence of human judgments, offering immediate feedback. They are widely used not only to provide quality indicators to users and translators (Béchara et al., 2021; Castilho and O’Brien, 2017; Mehandru et al., 2023a), but also to improve machine translation (MT) systems themselves (He et al., 2024; Xu et al., 2024a; Fernandes et al., 2022). Judging whether, and to what extent, these met- rics concur with human evaluation is important to ensuring their effectiveness and applicability LP N % ZERO -MQM WMT 2023 METRICS DATASET EN-DE(P) 5520 25 .4% HE-EN 9840 50 .8% ZH-EN 17655 19 .1% WMT 2022 METRICS DATASET EN-DE 18410 51 .5% EN-RU 19725 42 .7% ZH-EN 26250 46 .4% WMT 2022 CHAT DATASET XX-E N 4756 63 .2% EN-XX 5901 60 .2% Table 1: Gold MQM scores distribution in recent WMT datasets. High-quality translations are represented in shades of green (darker for MQM = 0and lighter for MQM ≥ −5); red represents translations with at least one major error (MQM ≤ −5). P: paragraph-level. in diverse scenarios. A recent human evaluation study by the Conference on Machine Translation (WMT) revealed that translations produced by cur- rent MT systems often achieve very high-quality scores (ranging from 80to90) when judged by humans on a direct assessment (DA) scale of 0to 100(Kocmi et al., 2023). Similarly, Deutsch et al. (2023) observe that these systems increasingly gen- erate numerous “perfect” translations (translations with zero errors), especially for high-resource lan- guage pairs, as shown in Table 1. As MT quality advances, evaluating whether evaluation metrics accurately reflect this progress is essential. The absence of clear criteria for assessing these high- quality translations can introduce bias, leading to inconsistent assessments based on metric prefer- ences rather than objective measures of accuracy. Most evaluations of automatic metrics primarily assess their ability to distinguish between good and bad source-translation pairs (Freitag et al., 2023, 2022b), often overlooking their capacity to discern subtle differences in quality for a given source. Fur- thermore, in many practical and high-risk applica- tions ( e.g., within the medical or legal domains), 1\nthe main concern is not measuring the accuracy level of a translation but determining whether the translation is accurate and fit for that specific use (Nida, 1964; Church and Hovy, 1993; Bowker, 2019; Vieira et al., 2021; Mehandru et al., 2023b). While correlations provide valuable insights into the performance of automatic metrics, they do not offer a definitive measure of whether these metrics can reliably confirm translation accuracy. Hence, in this work, we systematically investi- gate how existing MT metrics assess high-quality (HQ) correct translations, defined as translations with zero or minor errors only. We find that au- tomatic metrics struggle to distinguish between translations for a given source, especially when comparing HQ translations, with reference-free or quality estimation (QE) metrics achieving close correlation scores to reference-based ones. We further show that current metrics severely overes- timate (for non-HQ translations) or underestimate (for HQ translations) translation quality. GEMBA- MQM (Kocmi and Federmann, 2023), a GPT-based QE metric, achieves the highest F1 score in detect- ing the HQ translations with no errors ( HQ-Z ERO). However, it also assigns high scores to erroneous GPT-4 translations, suggesting a preferential bias towards the LLM’s own outputs. These findings highlight the necessity for more robust evaluation protocols to assess the quality of automatic metrics. 2 How good are current MT systems? The most reliable way to assess translation qual- ity has been through human evaluations, with several frameworks proposed over the years for this purpose. While earlier works consider two dimensions—adequacy and fluency—with a 5- point Likert scale (King, 1996), subsequent work on direct assessments (DA) considers a single con- tinuous scale of 0−100(Graham et al., 2017). However, several studies have questioned the cred- ibility of DA-based evaluation (Toral et al., 2018; Läubli et al., 2020; Fischer and Läubli, 2020; Mathur et al., 2020b; Freitag et al., 2021). Unlike DAs, which assign a numeric score to a translation, the recent Multidimensional Quality Metrics (Burchardt, 2013, MQM) framework relies on explicit error judgments (error types and sever- ity) marked within specific spans of the source- translation pair, providing a more accurate and fine- grained evaluation. Translations receive a score of0if they contain no errors, a penalty of −1for minor errors, and −5for major errors that impact the usage or understanding of the content.1 We present the distribution of gold MQM scores from the WMT23 Metrics task (Freitag et al., 2023), WMT22 Metrics task (Freitag et al., 2022b), and WMT22 Chat Translation task (Farinha et al., 2022) in Table 1. Across settings and language pairs, the percentage of translations achieving a zero MQM score ranges from 19.1% to63.2%. At least 52.6% translations across language pairs and settings have no major errors (MQM >-5). This shows that a large percentage of the datasets include transla- tions with no or only minor errors, emphasizing the importance of accurately identifying these high- quality translations in the evaluation process. 3 How well do MT metrics assess HQ translations? We define HQ translations as those that achieve an MQM score >−5,i.e., translations without any major errors according to human evaluators. By definition, these translations do not contain errors that impede their comprehension or usability. We consider a subset of QE and reference-based auto- matic metrics evaluated by the shared tasks (see App. A for more details). 3.1 How do metrics rank HQ translations? We first investigate how automatic metrics rank HQ translations, which is particularly relevant today, as these metrics are often used to guide MT training or decoding processes. Recent work employs both reference-based and QE metrics to rerank multi- ple hypotheses generated by dedicated MT models or large language models (LLMs), aiming to im- prove translation quality (Fernandes et al., 2022; Freitag et al., 2022a; Farinhas et al., 2023). These metrics are also used to provide quality feedback signals during training, either explicitly in loss sig- nals (Ramos et al., 2023; Yan et al., 2023; He et al., 2024) or implicitly via the creation of preference datasets (Xu et al., 2024b; Yang et al., 2023). Consider Nsystems and Msource segments. Typically, segment-level correlations are computed between the N×Mtranslations. However, this differs from the practical setting where metrics are used to rerank several translations for the same source. Therefore, we follow Deutsch et al. (2023) and compute the average correlation between the N 1Although MQM includes critical errors—errors that could render a text unusable—they are not marked in many datasets due to their highly contextual interpretation. 2\nNO-GROUPING GROUP -BY-SRC METRICALL ALL†ALL†HQREF-BASEDchrF 0.262 0 .227 0 .267 0 .136 BLEU 0.193 0 .190 0 .303 0 .146 BERTscore 0.355 0 .367 0 .325 0 .134 COMET 0.578 0 .584 0 .461 0 .202 BLEURT-20 0.618 0 .603 0 .449 0 .220 XCOMET-XL 0.713 0 .705 0 .461 0 .250 XCOMET-XXL 0.708 0 .716 0 .481 0 .326 MetricX-23 0.682 0 .680 0 .450 0 .301 MaTESe 0.591 0 .593 0 .341 0 .254REF-FREEGEMBA-MQM 0.614 0 .621 0 .462 0 .368 CometKiwi 0.565 0 .561 0 .411 0 .182 CometKiwi-XL 0.542 0 .550 0 .427 0 .223 CometKiwi-XXL 0.525 0 .504 0 .456 0 .327 MetricX-23-QE 0.683 0 .681 0 .470 0 .292 Table 2: Spearman correlation on WMT23 EN-DE. †: Subsampled to match G ROUP -BY-SRCHQ’s size. translation scores grouped by the source sentences. We refer to the former setting as NO-GROUPING and the latter as GROUP -BY-SRC. We also study to what extent these metrics distinguish between HQ translations. As the number of segments with all HQ translations, K, is less than M, we report mean correlations on subsampled datasets (ran- domly sampled 10times) that match the sample size,N×K, marked with the symbol †in Table 2. This is motivated by Mathur et al. (2020a), who study how these metrics rank HQ systems , where a limited number of samples (typically 4 or 5) was shown to yield unreliable conclusions. However, our focus is on segment-level evaluation, where the number of subsampled items is much larger. Table 2 presents Spearman correlation of auto- matic metrics with MQM scores for configurations described above on the WMT23 EN-DE dataset (see App. B for other datasets and correlation met- rics). We first note that the correlation observed on the entire ( NO-GROUPING ALL) and the sub- sampled datasets ( NO-GROUPING ALL†) is close, establishing that the observed differences cannot be merely attributed to changes in sample size. Metrics exhibit only a low-to-fair correlation with human judgments when evaluating trans- lations for the same source. Automatic metrics are less effective in differentiating between good and bad translations for the same source, as evi- denced by the drop in correlation from the NO- GROUPING ALL to the GROUP -BY-SRCALL set- ting. A possible reason for this disparity lies in how these metrics are typically trained—most metrics are trained to predict translation quality for a given instance ( e.g., source-reference-hypothesis trio in Comet orxCOMET ). While this can still be useful for ranking two systems based on averaged scores across different texts, it may provide limited infor- mation for gauging translation quality for different translations of the same source.2This highlights the limitations of using automatic metrics as the sole measure of translation quality, particularly in scenarios where fine-grained distinctions between translations of the same source are required. QE metrics are on par with reference-based ones for differentiating translations. QE metrics show promising results in differentiating transla- tions for the same source, often achieving com- parable or better correlation than reference-based metrics. For EN-DE, the QE metrics MetricX-23- QEandGEMBA-MQM rank second and third, re- spectively in the ALL setting, following xCOMET- XXL. When contrasting HQ translations, GEMBA- MQM outperforms all other metrics. The relatively strong performance of QE metrics, particularly in this setting, highlights their potential as valuable tools for translation generation and ranking tasks. Metrics fail to distinguish HQ translations. There is a consistent drop in correlation scores across all metrics in the HQ relative to the ALL setting, possibly because most translations in the HQ setting receive scores in the narrow range of (−5,0]and often are tied in quality. Deutsch et al. (2023) show that most metrics struggle to predict translation ties accurately, i.e., give the same score to two translations with similar quality, except for error-predicting metrics like GEMBA-MQM orMaTESe . This decreased correlation from the HQ to the ALL setting has significant implications, especially when they are used to rerank translations produced by strong MT systems. It may result in an artificial boost or bias towards specific systems or outputs, inadvertently prioritizing translations that align well with metric biases but deviate from true quality improvements, as discussed in §3.3. 3.2 How well do metrics detect HQ translations with no errors? Ranking translations of similar quality is a difficult task, so we also evaluate how automatic metrics score HQ translations with zero MQM scores. (HQ- ZERO). We consider normalized scores ≥0.99as 2Using contrastive objectives or exposing the metric to multiple translations could potentially help mitigate this issue (Briakou and Carpuat, 2020). 3\nEN-DE ( 1402) HE-EN ( 5001) ZH-EN ( 11309 )METRICPR F1 PR F1 PR F1 xCOMET-XL 7240 51 7817 28 47 28 35 xCOMET-XXL 58 59 58 74 54 62 36 63 46 MaTESe 49 69 58 66 65 65 29 75 42 MetricX-23 70 33 45 80 16 27 52 11 19 GEMBA-MQM 52 70 60 71 65 68 37 77 50 MetricX-23-QE 66 14 23 70 64 67 5520 29 Figure 1: Top: Metric Scores distribution for HQ- ZERO translations on WMT23. Bottom: Precision, recall, and F1. Figure 2: Absolute difference of the number of times a metric assigns a valid score to HQ- ZERO and non HQ- ZERO translations. valid scores as 1.0is the highest score a metric should assign to HQ- ZERO translations. Fig. 1 shows the results on WMT23 dataset. See App. C for results in other datasets. Metric scores have high variance for HQ trans- lations. 9out of 15metrics do not assign valid scores to HQ- ZERO translations. Lexical metrics (chrF andBLEU ) produce the lowest absolute val- ues, possibly due to over-reliance on a reference translation. Neural metrics trained to regress on DA scores ( BLEURT ,COMET , and variants) also do not assign valid scores for these translations, likely due to low agreement between DA and MQM scores, as discussed by Freitag et al. (2021). Metrics over or underestimate translation qual- ity. Metrics that do score these translations within the valid range ( xCOMET ,MaTESe ,MetricX , andGEMBA-MQM ), exhibit different tradeoffs be- tween precision (P) and recall (R). For example, while xCOMET-XL andMetricX prioritizes preci- sion, MaTESe andGEMBA-MQM excels at rec- ognizing many HQ- ZERO translations, leading to increased recall. This difference might stem from the specific task each metric is optimized for: while the former predicts sentence-level quality, the latter is optimized to predict word-level error spans. As expected, xCOMET-XXL significantly outperforms xCOMET-XL across all language pairs. Finally, the QE metric, GEMBA-MQM , based on GPT-4, achieves the highest F1 score across all language pairs, demonstrating the capabilities of LLM-based evaluation in more nuanced MT evaluation. 3.3 Which HQ translations are detected? To study preference bias from metrics towards spe- cific systems, we compute the absolute difference in the number of times a metric assigns a valid score to HQ- ZERO and non-HQ- ZERO translations. Fig. 2 shows that MaTESe equally overestimates translation quality for many systems, as suggested by its high R and low P scores (Fig. 1). GEMBA- MQM frequently assigns zero MQM scores to GPT- 4 translations, even when humans identify errors in them. This aligns with concurrent works showing a preference bias of LLMs towards their outputs (Panickssery et al., 2024; Xu et al., 2024c), under- scoring the need for a more detailed evaluation to better understand the outputs these metrics prefer and whether they align with human preferences. 4 Conclusions and Future Work This work systematically investigates how auto- matic metrics assess HQ translations. We find that current metrics correlate poorly with human judg- ments when contrasting translations for a given source, with the correlation being even lower for HQ translations. We then study whether metrics can detect HQ translations that attain zero MQM scores (HQ- ZERO) and find that many metrics fail to assign them valid scores. While the GPT-4-based GEMBA-MQM attains the highest F1 for detecting HQ-ZERO, it shows some preference for GPT-4 outputs. Therefore, despite its promise, it is es- sential to complement GEMBA-MQM with other metrics to ensure robust evaluation. 4\nLimitations We highlight the main limitations of our work. First, we rely on human MQM annotations as the gold standard for identifying high-quality transla- tions, despite their potential subjectivity and occa- sional inaccuracy. These annotations are collected for individual translations, and the ratings might vary if annotators were asked to evaluate and com- pare multiple translations simultaneously. Second, although our analysis spans multiple datasets across six language pairs ( EN-DE,ZH-EN, HE-EN,EN-RU,EN-FR, and EN-PT-BR) and mul- tiple domains, we do not necessarily account for the distribution of high-quality translations across different domains within a dataset. As shown by Zouhar et al. (2024), learned metrics can be sensi- tive to the domain of evaluation. Lastly, our analysis in §3.3 identifies one poten- tial bias, but it remains unclear whether automatic metrics have preferential biases towards other out- put properties such as length, stylistic choices, etc. | 4 | 4 | [
{
"comments_suggestions_and_typos": "See the weaknesses section.",
"ethical_concerns": "N/A",
"paper_summary": "This paper systematically studies how automatic machine translation metrics evaluate high-quality and correct translations. It conducts experiments on existing MT datasets and illustrates that current metrics:\n1. correlate poorly with human judgments when contrasting translations for the same translation source.\n2. fail to assess high-quality translations.\nwhich points out a potential research direction.",
"summary_of_strengths": "1. The motivation and logic of this paper is good.\n2. Experimental results demonstrate some crucial findings regarding the evaluation of high-quality translations.",
"summary_of_weaknesses": "1. In the paper, it would be better to align sections and tables more. I found it hard to locate the experimental results when reading some parts of the paper."
}
] | 712f081a58b85adf9934f3782880a30b3f55e5c9e2f2031cc7666180b26cf52d1ce9e095ced3e21402f90135d0d83cca226608eb7758f72fb13df13b61aedf9a.json |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.