Entity Alignment with Noisy Annotations from Large Language Models

Authors: shengyuan  chen
qinggang  zhang
junnan  dong
wen  hua
qing  li
xiao  huang
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-14 10:25:42

Abstract: Entity alignment (EA) aims to merge two knowledge graphs (KGs) by identifying equivalent entity pairs. While existing methods heavily rely on human-generated labels, it is prohibitively expensive to incorporate cross-domain experts for annotation in real-world scenarios. The advent of Large Language Models (LLMs) presents new avenues for automating EA with annotations, inspired by their comprehensive capability to process semantic information. However, it is nontrivial to directly apply LLMs for EA since the annotation space in real-world KGs is large. LLMs could also generate noisy labels that may mislead the alignment. To this end, we propose a unified framework, LLM4EA, to effectively leverage LLMs for EA. Specifically, we design a novel active learning policy to significantly reduce the annotation space by prioritizing the most valuable entities based on the entire inter-KG and intra-KG structure. Moreover, we introduce an unsupervised label refiner to continuously enhance label accuracy through in-depth probabilistic reasoning. We iteratively optimize the policy based on the feedback from a base EA model. Extensive experiments demonstrate the advantages of LLM4EA on four benchmark datasets in terms of effectiveness, robustness, and efficiency.

Main paper: 
 introduction: 
 Knowledge graphs (KGs) serve as a foundational structure for storing and organizing structured knowledge about entities and their relationships, which facilitates effective and efficient search capabilities across various applications. They have been widely applied in question-answering systems (Dong et al., 2023 (Dong et al., , 2024c)) , recommendation systems (Catherine & Cohen, 2016; Chen et al., 2024a) , social network analysis (Tang et al., 2008) , Natural Language Processing (Weikum & Theobald, 2010) , etc. Despite their extensive utility, real-world KGs often suffer from issues such as incompleteness, domain specificity, or language constraints, which limit their effectiveness in cross-disciplinary or multilingual contexts. To address these challenges, entity alignment (EA) aims to merge disparate KGs into a unified, comprehensive knowledge base by identifying and linking equivalent entities across different KGs. For instance, by aligning entities between a financial KG and a legal KG, EA facilitates the understanding of complex relationships, such as identifying the same corporations across the two KGs to assess how legal regulations impact their financial performance. This alignment enables a more nuanced exploration and interrogation of interconnected data, providing richer insights into how entities operate across multiple domains.Entity alignment models predict the equivalence of two entities by measuring their alignment probability. Specifically, rule-based methods (Suchanek et al., 2012; Jiménez-Ruiz & Cuenca Grau, 2011; Qi et al., 2021) utilize predefined rules or heuristics to update alignment probabilities and propagate alignment labels. Conversely, embedding-based models seek to exploit advanced techniques in graph learning (Li et al., 2024; Liu et al., 2024b Liu et al., ,a, 2023)) , parameterizing these probabilities using similarity scores between entity representations learned through knowledge graph embedding algorithms such as translation models (Chen et al., 2017; Sun et al., 2018) or Graph Convolutional Networks (GCNs) (Wu et al., 2019; Mao et al., 2021; Wang et al., 2018; Huang et al., 2023) . However, these methods heavily rely on extensive and accurate seed alignments for training-a requirement that poses significant challenges. The need for substantial, cross-domain knowledge to annotate such alignments often makes their acquisition prohibitively expensive.Recently, Large Language Models (LLMs) have showcased their superior capability in processing semantic information Dong et al. (2024a) , which has significantly advanced various graph learning tasks such as node classification (Chen et al., 2024d) , graph reasoning (Zhao et al., 2023a; Chai et al., 2023) , recommender systems (Zhou et al., 2022; Wu et al., 2023) , SQL query generation (Zhang et al., 2024a) , and knowledge graph-based question answering (Wang et al., 2024; Zhang et al., 2024b; Dong et al., 2024b) . Their capacity to extract meaningful insights from graph data opens up new possibilities for automating EA. Notably, recent studies (Zhong et al., 2022; Zhao et al., 2023b; Jiang et al., 2024) have explored the use of LLMs in EA, primarily focusing on finetuning a pretrained LLM such as Bert to learn semantic-aware representations, relying on accurate seed alignments as training labels. Yet, the potential of LLMs for label-free EA via in-context learning remains unexplored.However, directly applying LLMs to automate EA poses significant challenges. Firstly, conventional EA models presume that all annotations are correct; yet, LLMs can generate false labels due to LLMs' inherent randomness and the potential incompleteness or ambiguity in the semantic information of entities. Training an EA model directly on these noisy labels can severely impair the final alignment performance. Secondly, given the vast number of entity pairs, annotation with LLMs would be prohibitively expensive. Maximizing the utility of a limited LLM query budget is essential. Existing solutions such as active learning cannot be directly applied since the annotations are noisy.In response to the outlined challenges, we introduce LLM4EA, a unified framework designed to effectively learn from noisy pseudo-labels generated by LLMs while dynamically optimizing the utility of a constrained query budget. LLM4EA actively selects source entities based on feedback from a base EA model, focusing on those that significantly reduce uncertainty for both the entities themselves and their neighbors. This approach allocates the query budget to important entities, guided by the intra-KG and inter-KG structure. To manage the noisy pseudo-labels effectively, LLM4EA incorporates an unsupervised label refiner that enhances label accuracy by selecting a subset of confident pseudo-labels through probabilistic reasoning. These refined labels are then utilized to train the base EA model for entity alignment. The confident alignment results inferred by the EA model inform active selection in subsequent iterations, thereby progressively improving the framework's effectiveness in a coherent and integrated manner. Contributions are summarized as follows:• Novel LLM-based framework for entity alignment: We propose LLM4EA, an in-context learning framework that uses an LLM to annotate entity pairs. Leveraging the LLMs' zeroshot learning capability, this framework generates pseudo-labels, providing a foundation for entity alignment without ground truth labels.• Unsupervised label refinement: Our framework introduces an unsupervised label refiner informed by probabilistic reasoning. This component significantly improves the accuracy of LLM-derived pseudo-labels, enabling effective training of entity alignment models. • Active sampling module: We propose an active selection algorithm that dynamically searches entities in the huge annotation space. Guided by feedback from the EA model, this algorithm adjusts its policy based on inter-KG and intra-KG structures, optimizing the utility of LLM queries and ensuring efficient use of resources.• Empirical validation and superior performance: We rigorously evaluate our framework through extensive experiments and ablation studies. The results demonstrate that LLM4EA not only outperforms baselines by a large margin but also shows robustness and efficiency. Each component of the framework is shown to contribute meaningfully to the overall performance, with clear synergistic effects observed among the components.Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?Answer: [Yes] Justification: We have clearly made the main claims in both the abstract and introduction. Specifically, we have summarized and itemized the contributions at the end of the introduction section.Guidelines:• The answer NA means that the abstract and introduction do not include the claims made in the paper. • The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers. • The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings. • It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper. 
problem definition: 
 A knowledge graph G comprises a set of entities E, a set of relations R, and a set of relation triples T where each triple (e h , r, e t ) ∈ T represents a directional relationship between its head entity and tail entity. Given two KGs G = {E, R, T }, G ′ = {E ′ , R ′ , T ′ }Question: Does the paper discuss the limitations of the work performed by the authors?Answer: [Yes] Justification: Please see page 9, Section 6 for the Limitations section.Guidelines:• The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper. • The authors are encouraged to create a separate "Limitations" section in their paper.• The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be. • The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated. • The authors should reflect on the factors that influence the performance of the approach.For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon. • The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size. • If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness. • While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations. 
entity alignment with noisy annotations from llms: 
 We aim to design a framework to perform entity alignment with LLMs. Our design is motivated by the following insights. Firstly, we have a huge search space (the overall annotation space isO(|E||E ′ |))to identify the core entity pairs to annotate. Secondly, we don't know whether the annotated labels are correct or not, because we have no prior knowledge or heuristic of the label distribution. Finally, we perform annotations iteratively, requiring the model to adjust its search policy based on annotation effectiveness, while we have no verifiable feedback of this annotation accuracy.Based on these insights, we propose LLM4EA-an iterative framework that consists of four interconnected steps in each cycle, as illustrated in Figure 1 . Initially, an active selection technique optimizes the use of resources by choosing critical source entities that significantly reduce uncertainty for themselves and their neighbors. Subsequently, an LLM-based annotator identifies the counterparts for the selected source entities, generating a set of pseudo-labels. Next, a label refiner improves label accuracy by eliminating structurally incompatible labels. This process involves formulating a combinatorial optimization problem and utilizing a probabilistic-reasoning-based greedy search algorithm to efficiently find a local-optimal solution. Finally, these refined labels are used to train a base EA model for the entity alignment task. The outcomes of the alignment then serve as feedback to inform subsequent rounds of the active selection policy. Further details are provided below.Target KG We aim to maximize the utility of the budget by actively allocating the budget to those beneficial entities. To do this, we sample source entities that reduce the most uncertainty of both themselves and their neighboring entities, by a dynamically adjusted policy. The measurement of uncertainty reduction is based on two assumptions: 1) an entity's own uncertainty is inversely proportional to its alignment probability with its most probable counterpart; 2) the amount of uncertainty an entity eliminates for its neighbors is closely linked to the relational ties between them. To systematically assess this, we introduce the concept of relational uncertainty, quantified as follows:U r (e h ) = (1 -P (e h )) +(e h ,r,et)∈T w r (1 -P (e t )) .(1)Here, w r is a weight coefficient reflecting the significance of relation r and signifies how much e h contributes to reducing the uncertainty of e t through the relation r. For this purpose, we employ functionality F(r) (formally defined in Eq. ( 4)) as the weight w r , as it quantifies the uniqueness of the tail entity for a given specified head entity. P (e) := max e ′ ∈E ′ P (e ≡ e ′ ) represents the alignment probability of the top-match entity for e. These alignment probabilities P (e ≡ e ′ ) are obtained through probabilistic reasoning during label refinement (Section 3.3.2) and are augmented by the inferred alignments from the base EA model (Section 3.4). In the initial iteration, all alignment probabilities are set to 0.It's important to note that some source entities are linked to a large number of uncertain neighbors (those with low P (e)). These source entities are crucial but may be overlooked if their connected relations have low functionality. Hence, we introduce neighbor uncertainty as another metric to assess an entity's importance, by removing the functionality-based weight coefficient:EQUATIONTo integrate these two metrics, we employ rank aggregation by mean reciprocal rank:EQUATIONHere, r ur (e h ) and r un (e h ) denote the ranking of e h when using U r and U n as metric, respectively. This simple-effective aggregation technique is advantageous for our task since it's scale invariant and requires no validation set for tuning hyperparameters, making it more practical in this task.Counterpart filtering. With the selected source entities, we employ an LLM as an annotator to identify the counterpart from E ′ for each source entity, generating a set of pseudo-labels L = {(e, e ′ )|e ∈ E, e ′ ∈ E ′ }. To narrow down the search space, we first filter out the less likely counterparts before querying the LLM, selecting only the top-k most similar counterparts from E ′ . The similarity metric is flexible: we use a string matching score based on word edit distance, but other methods are also viable, such as semantic embedding distances derived from word embedding models. By adjusting k, we can trade-off between the recall rate of counterparts and the query cost.Prompt design. There are primarily two methods for retrieving context information to construct textual prompts: randomly generated prompts and dynamically tuned prompts. The former involves randomly selecting neighbors to construct contexts for the entity, while the latter dynamically selects neighbors based on feedback from the EA model. For a fair comparison, we use randomly generated prompts across all baselines and the proposed LLM4EA. These prompts include the name of each entity and a set of relation triples to three randomly selected neighbors. For the baseline models, pseudo-labels are generated at once and used for training. For LLM4EA, we evenly divide the budget B into n iterations and generate pseudo-labels at each iteration using the allocated B/n budget.The pseudo-labels generated by the LLM can be noisy, and directly using these labels to train an entity alignment (EA) model could undermine the final performance. Although estimating the label distribution by asking the LLM for confidence scores or querying multiple times to measure consistency are potential solutions, these approaches can be vulnerable or introduce additional costs.In light of this, we propose a label refiner that leverages the structure of knowledge graphs. The refinement process is framed as a combinatorial optimization problem aimed at minimizing overall structural incompatibility among labels. Utilizing a probabilistic reasoning technique, we progressively update our confidence estimation for each label and select those that are mutually compatible, ultimately producing a set of accurate pseudo-labels. Detailed explanations follow below.Functionality. The functionality of a relation quantifies the uniqueness of tail entities for a specified head entity, calculated as the ratio of unique head entities to total head-tail pairs linked by the relation. Conversely, inverse functionality quantifies the tail entity uniqueness for a specified head entity. Formally, these are defined as: F(r) := |{e h |(e h ,For instance, suppose a KG contains two triples for the relation locate_in: (Hawaii, locate_in, U S) and (M iami, locate_in, U S). Then F(locate_in) = 1.0 and F -1 (locate_in) = 0.5. In other words, given (M iami, locate_in, ?), the answer for the missing tail entity is unique; while given (?, locate_in, U S), there are multiple answers for the missing head entity. Such relational patterns are useful for identifying an entity based on its connections within the intra-graph structure.Probabilistic reasoning. If two entities are each connected to entities that are aligned across KGs, this increases the likelihood that they should be aligned as well. Based on this heuristic, an entity pair's alignment probability P (e h ≡ e ′ h ) can be inferred by aggregating its neighbors' alignment probability via relation functionality:EQUATIONHere, P (r ⊆ r ′ ) denotes the probability of r being a subrelation of r ′ , estimated by alignment probabilities of connected entities: 1 -(e ′ h ,These formulations allow for the propagation and updating of alignment probabilities in a manner that is cognizant of relational structures. We employ this technique to design a label refiner below.Label incompatibility. We exploit the "incompatibility" of labels for label refinement, based on the assumption that correct labels can infer each other, while a false label could be incompatible with its correctly aligned neighbors. We define the overall incompatibility on a label set L as:EQUATIONHere, 1 P (e h ≡e ′ h )<max e∈E P (e,e ′ h ) = 1 if e h is not the top-match for e ′ h , otherwise 0. It's important to note that a detected incompatibility doesn't necessarily indicate the false alignment of (e h , e ′ h ): it may suggest a misalignment of their neighbors. Given this, the key to label refinement is to jointly optimize the label's overall incompatibility while avoiding accidentally filtering out correct labels.Objective. To enhance label quality, we propose to refine the pseudo-label set L by finding a subset L * ⊂ L that minimizes its overall incompatibility: L * = argmin L ′ ⊂L Φ(L ′ ). Noteworthy that a trivial solution for this optimization problem is only preserving a set of isolated labels, such that max e∈E P (e ≡ e ′ h ) = 0 and max e ′ ∈E ′ P (e h ≡ e ′ ) = 0 for all (e h , e ′ h ) ∈ L ′ . This trivial solution would lead to the exclusion of most accurate labels, an outcome we aim to avoid. Considering this, we introduce an l1 penalty term to penalize the removal of labels, leading to our overall objective:EQUATIONHere λ > 0 is a weight coefficient. Solving the above combinatorial problem is intractable as it requires computing Φ(L ′ ) for each possible set L ′ ⊂ L, which is NP-hard. Below we propose to search for a local-optimal solution by a greedy algorithm powered by probabilistic reasoning.Greedy search. The algorithm begins by initializing the alignment probability P (e ≡ e ′ ) = δ 0 for every pair (e, e ′ ) within the set L, where δ 0 is a constant within the range (0,1). It then iteratively performs a search for an optimal label set L ′ through a series of voting steps. Each iteration is comprised of two main steps: probabilistic reasoning and label adjustment.During the probabilistic reasoning step, the alignment probabilities and subrelation probabilities are updated according to Eq. ( 5) and Eq. ( 6), respectively. This update process refines our estimates of label confidence based on the latest information. During the label adjustment step, the label set L ′ is updated based on these updated probabilities. Labels are appended to L ′ if their updated alignment probabilities exceed δ 0 , indicative of high confidence in their alignment, supported by their neighbors:EQUATIONConversely, labels demonstrating structural incompatibilities are excluded from L ′ :EQUATIONIn this manner, labels are removed if they are incompatible with updated aligned neighbors, ensuring the preservation of only the most confident pairs within L ′ . To further refine the search process in subsequent iterations, we augment all entity alignment probabilities within L ′ to a superior score:EQUATION)Here δ 1 ∈ (δ 0 , 1) serves as a new threshold, elevating the alignment probabilities of confident pairs to foster a more directed and effective search. After n lr iterations, we get a set of confidently selected labels L * that have high compatibility. The detailed algorithm is presented in Appendix A.2, and analyses of parameter efficiency and computational efficiency are provided in Appendix A.3.With the refined labels, we train an embedding-based EA model to learn structure-aware representations for each entity. After training, the EA model computes a matching score m θ (e, e ′ ) for each entity pair (e, e ′ ) for evaluation. The selection of the base EA model is flexible, tailored to the task requirements. We chose a recently proposed GCN-based model, Dual-AMN (Mao et al., 2021) , for its effectiveness and efficiency.Feedback from the base EA model is crucial for dynamic update of the active selection policy.To generate effective feedback, we infer high-confidence pairs (e, e ′ ) with the trained EA model, by selecting the pairs that both entities rank top for each other. These pairs are injected into the probabilistic reasoning system. Similar to the label refinement process, this system initializes with an alignment probability of δ 0 for these pairs and updates the estimation of alignment and subrelation probabilities using Eq. ( 5) and Eq. ( 6). The updated probabilities are used to construct the uncertainty terms (i.e., U r and U n ) to inform the active selection policy in subsequent iterations, thereby optimizing the budget utility and improving final performance continuously.Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof? Justification: We present the experimental setting details at the beginning of the experiment section. We also provide the dataset statistics and the preprocessing details in the appendix. Guidelines:• The answer NA means that the paper does not include experiments.• The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them. • The full details can be provided either with the code, in appendix, or as supplemental material. 
experiments: 
 In this section, we conduct experiments to evaluate the effectiveness of our framework. We begin by introducing the experimental settings. Then, we present experiments to answer the following research questions: RQ1. How effective is the overall framework? RQ2. What is the impact of the choice of LLM on the cost and performance of LLM4EA? RQ3. What is the effect of the label refiner? RQ4.What is the impact of active selection?Datasets and LLM. In this study, we use the widely-adopted OpenEA dataset (Sun et al., 2020) , including two monolingual datasets (D-W-15K and D-Y-15K) and two cross-lingual datasets (EN-DE-15K and EN-FR-15K). OpenEA comes in two versions: "V1" the normal version, and "V2" the dense version. We employ "V2" in the experiments in the main text. The LLM version in this experiment is and GPT-4 (gpt-4-turbo-2024-04-09) . By default, the overall query budget is B = 0.1|E|.Baselines. Baseline models include three GCN-based models -GCNAlign (Wang et al., 2018) , RDGCN (Wu et al., 2019) , Dual-AMN (Mao et al., 2021) , and three translation-based models -IMUSE (He et al., 2019) , AlignE, BootEA (Sun et al., 2018) , Here, BootEA is a variant of AlignE that adopts a bootstrapping strategy, equipped with a label calibration component for improving the accuracy of bootstrapped labels. Baseline models are directly trained on the pseudo-labels generated by the LLM annotator, without label refinement or active selection. Every experiment is repeated three times to report statistics.Setup of LLM4EA. We employ GPT-3.5 as the default LLM due to its cost efficiency. Other parameters are n = 3, n lr , k = 20, δ 0 = 0.5, δ 1 = 0.9.Table 1 : Evaluation of entity alignment performance, measured by Hit@K for K ∈ {1, 10}, and Mean Reciprocal Rank (MRR), presented in %. Experiment statistics are computed over three trials.Hit@1 Hit@10 MRR Hit@1 Hit@10 MRR Hit@1 Hit@10 MRR Hit@1 Hit@10 MRR Group1. Entity Alignment with GPT-3.5. To answer RQ1 and RQ2, we conducted two groups of experiments on OpenEA datasets, using GPT-3.5 and GPT-4 as the annotator, respectively. Results are presented in Table 1 . We also investigated the performance-cost comparison between the GPT-3.5 annotator and the GPT-4 annotator, illustrated in Figure 2 . To control the randomness introduced by the LLMs, each experiment was repeated three times to report mean and standard deviation. These results lead to several key observations:IMUSEFirst, LLM4EA surpasses all baseline EA models, which are directly trained on the pseudolabels, by a large margin. This can be attributed to 1) our label refiner's capability in filtering out false labels, reducing noise during training and enabling more accurate optimization towards the ground true objective; 2) our active selection component's ability to smartly identify important entities to annotate, which takes full advantage of the fixed query budget.Second, using the GPT-4 results in higher performance than using the GPT-3.5 as the annotator. This observation conforms to the fact that GPT-4 is a more advanced LLM with higher reasoning capacity and stronger semantic analysis, resulting in more precise annotation results and higher recall, thus providing more labels of high quality. We also observe that translation-based models (e.g., AlignE) are sensitive to noisy labels under GPT-3.5, while state-of-the-art GCN-based models (e.g., RDGCN and Dual-AMN) are more robust. BootEA also demonstrates superior performance and robustness, attributed to its bootstrapping technique and enhanced by its capability in calibrating bootstrapped labels. However, its label calibration is only applied to the bootstrapped labels, so it still suffers from the false training labels. Our proposed LLM4EA, on the other hand, refines the label accuracy before training the EA model, thus ensuring more accurate training. Figure 2 : Performance-cost comparison between GPT-3.5 and GPT-4 as the annotator, evaluated by MRR. We increase the budget for GPT-3.5 to evaluate its performance. [n×] denotes using n× of the default query budget. Each experiment is repeated three times to show mean and standard deviation.Finally, LLM4EA is noise adaptive, enabling cost-efficient entity alignment. To further investigate the effect of the choice of LLM, we examined the performance-cost comparison between GPT-3.5 and GPT-4 as the annotator. We illustrate MRR in Figure 2 (detailed results are available in Appendix B.3). The results show that, by increasing the query budgets (measured by the number of tokens) for GPT-3.5, the performance gradually increases. When the budget is 2× that of GPT-4, the performance is comparable to or exceeds the performance of using GPT-4 as the annotator. According to the pricing scheme of OpenAI, the input/output cost for 1 million tokens for GPT-3.5 and GPT-4 is $0.50/$1.5 and $10/$30, respectively. This means that our noise-adaptive framework enables cost-efficient entity alignment with less advanced LLMs at 10× less actual cost than using more advanced LLMs, simply by increasing the token budget for the less advanced LLMs. We illustrate the evolution of the true positive rate (TPR) (left) and recall (middle) for refined labels across four datasets. Furthermore, we assess the robustness of the label refinement process by examining the TPR of refined labels against varying initial TPRs within the D-W-15K dataset (right), with initial pseudo-labels synthesized at different TPR levels.To answer RQ3, we first analyze the evolution of the True Positive Rate (TPR) and the recall rate of the refined labels. Specifically, at each label refinement iteration, the TPR is calculated as|A∩L ′ | |L ′ | , and the recall is calculated as |A∩L ′ ||A∩L| . The left and middle subfigures of Figure 3 demonstrate how our label refiner progressively discovers accurate labels and optimizes the TPR. Initially, the TPR of the refined label set is high (approximately 1.0), then it decreases by a certain percentage, and eventually increases again to a high TPR. We attribute this pattern to: 1) the most confident labels being discovered in the earliest iterations, which are obvious alignments with many connected alignments; 2) as the algorithm progresses, some false pseudo-labels being erroneously added to the label set L ′ ; 3) as the label refinement continues, L ′ is adjusted and the false pseudo-labels are replaced with the correct labels inferred by the updated probability as in Eq. ( 10). Furthermore, we assess the robustness of our label refiner, as depicted in the right subfigure of Figure 3 . We synthesize noisy labels and evaluate the output TPR in relation to varying input TPR levels, using two experimental schemes: fixed budget, where the budget remains constant at 0.1|E| while the TPR changes, and fixed TP, where the number of true positives is fixed but the TPR and corresponding budgets are adjusted. The results demonstrate that the label refiner consistently elevates the TPR to over 0.9, even when the initial TPR is around 0.5, showcasing its high robustness to noisy pseudo-labels. This result also reveals why our framework demonstrates robust performance with the less advanced GPT-3.5 annotator.Table 2 : Ablation study overview. The table presents the performance of the LLM4EA (Ours) with various modifications. Group 1: removing the label refiner (w/o LR) and the active selection component (w/o Act); Group 2: replacing the active selection technique with relational uncertainty (-ru), neighbor uncertainty (-nu), degree (-degree), and functionality sum (-funcSum).EN-DE-15K D-W-15K D-Y-15K Hit@1 Hit@10 MRR Hit@1 Hit@10 MRR Hit@1 Hit@10 MRR Hit@1 Hit@10 MRR Ablation studies detailed in Table 2 answer RQ4 and reveal several key insights: 1) Necessity of the Label Refiner for Effective Active Selection: The performance of "w/o LR", which lacks a label refiner, is inferior not only to other model variants but also to the base model, Dual-AMN. This underscores that active selection depends crucially on reliable feedback, which is compromised when the label refiner is absent; 2) Contribution of Relation and Neighbor Uncertainty in Active Selection: Incorporating both relation and neighbor uncertainties significantly enhances the utility of the budget. Methods like "Ours-degree" and "Ours-funcSum" focus only on their connections to neighbors and ignore the uncertainty of neighbors. In contrast, "Ours-ru" and "Ours-nu", which take these uncertainties into account, exhibit superior performance. This underscores the importance of considering neighbor uncertainty for effective active selection; 3) Robust Active Selection through Combined Metrics: Our active selection approach integrates both relation uncertainty and neighbor uncertainty to enable robust active selection. By employing rank aggregation, it prioritizes entities that are deemed significant by both metrics, ensuring a more effective and nuanced selection process. The runtime overhead is directly proportional to the number of active selection iterations, n, since each iteration involves a subsequent label refinement process. To explore the runtime-performance trade-off in the LLM4EA approach, we examine the Pareto frontier of runtime versus performance. We conduct entity alignment experiments with a fixed query budget, varying the number of active selection iterations. The results of these experiments are illustrated in Figure 4 .The results indicate that performance initially increases as the number of iterations rises from 1 to around 3, but further increases beyond this point lead to a decline. This pattern can be attributed to two main factors: (1) More iterations allow for extensive learning from feedback during the active selection phase. (2) However, when iterations are excessively high, the number of generated pseudo-labels per iteration becomes small, leading to isolated pseudo-labels that undermine the label refinement process. These findings suggest that an optimal balance between runtime efficiency and performance can be achieved without excessive trade-offs, indicating a specific threshold for iterations beyond which no further performance gains are observed. 
related work: 
 LLMs for Entity Alignment. Recent approaches have sought to leverage LLMs for entity alignment in knowledge graphs, primarily focusing on integrating structural and semantic information for improved alignment performance. BERT-INT (Tang et al., 2020) fine-tunes a pretrained BERT model to capture interactions and attribute information between entities. Similarly, SDEA (Zhong et al., 2022) employs a pretrained BERT to encode attribute data, while integrating neighbor information via a GRU to enhance structural representation. TEA (Zhao et al., 2023b) reconceptualizes entity alignment as a bidirectional textual entailment task, utilizing pretrained language models to estimate entailment probabilities between unified textual sequences representing entities. A novel approach, ChatEA (Jiang et al., 2024) , introduces a KG-code translation module that converts knowledge graph structures into a format comprehensible to LLMs, enabling these models to apply their extensive background knowledge to boost the accuracy of entity alignment. Notably, these models primarily focus on fine-tuning pretrained language models using a set of training labels and do not exploit the zero-shot capabilities of LLMs. In contrast, our proposed model, LLM4EA, leverages the zero-shot potential of LLMs, enabling it to generalize to new datasets without the need for labeled data.Probabilistic Reasoning. In the literature on knowledge graph reasoning, probabilistic reasoning has been effectively applied to infer new soft labels and their associated probabilities from existing labels. It has been utilized in domains such as knowledge graph completion (Qu & Tang, 2019; Zhang et al., 2020; Fang et al., 2023; Chen et al., 2024b) and entity alignment (Suchanek et al., 2012; Qi et al., 2021; Liu et al., 2022; Chen et al., 2024c) , where it naturally represents complex relational patterns with simple rules and performs precise inferences. In this work, however, due to the potential inaccuracies in the pseudo-labels generated by LLMs, the newly inferred alignments may be incorrect. Consequently, we opt not to employ probabilistic reasoning directly for the entity alignment task. Instead, we emphasize its use primarily for filtering false pseudo-labels that demonstrate structural incompatibilities within our framework. For completeness, we include the results of comparison with a probabilistic reasoning model -PARIS (Suchanek et al., 2012) in Appendix B.4. 
limitations: 
 Firstly, during active selection, we distribute the query budget evenly for each selection rather than dynamically customizing the budget allocation for each iteration. This allocation approach could be improved by developing a more adaptive budget allocation strategy. Secondly, the framework currently does not provide direct support for temporal KGs. Although the probabilistic reasoning and active selection components inherently support entity alignment on evolving KGs, the base EA model is transductive. This necessitates retraining the model whenever new entities and relation triples are introduced into the KGs. However, this can be complemented by the research line of inductive entity alignment, such as path-based embedding models or logic-based models, which can generalize to previously unseen entities without the need for retraining. 
conclusions: 
 In this paper, we address the challenge of automating entity alignment with Large Language Models (LLMs) under budget constraints and noisy annotations. We introduce LLM4EA, a framework that maximizes the utility of a fixed query budget using active sampling and mitigates erroneous labels with a label refiner employing probabilistic reasoning. Empirical results show that LLM4EA's noise-adaptive capabilities reduce costs without sacrificing performance, achieving comparable or superior results with less advanced LLMs at up to 10 times lower cost. This highlights the potential of LLM-based models in merging cross-domain and cross-lingual KGs. Future work will explore incorporating real-time learning capabilities to dynamically adjust to evolving knowledge bases.Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments? Answer: [Yes] Justification: To control for the randomness introduced by the Large Language Models, we repeat each experiment three times and report the mean and standard deviation in tables such as Table 1 , Table 2 , Table 6 , and Table 7 . For visualized figures such as Figure 2 and Figure 4 , we show the error bars representing the standard deviation. Guidelines:• The answer NA means that the paper does not include experiments.• The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.• The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions). • The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.) • The assumptions made should be given (e.g., Normally distributed errors).• It should be clear whether the error bar is the standard deviation or the standard error of the mean. Justification: We checked and ensured that our paper conforms with the NeurIPS Code of Ethics in every respect.Guidelines:• The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.• If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics. • The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction). 
broader impacts: 
 Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?Answer: [NA] Justification: The paper focuses on technical improvements in entity alignment using large language models and does not introduce direct societal impacts.Guidelines:• The answer NA means that there is no societal impact of the work performed.• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. • Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster. • The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML). 
safeguards: 
 Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)? Answer: [NA] Justification: This paper poses no such risks, as the work involves only querying the API of an LLM to get pseudo-labels, without releasing a generative model or datasets. Guidelines:• The answer NA means that the paper poses no such risks.• Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters. • Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images. • We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort. 12. Licenses for existing assets Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected? Answer: [Yes] Justification: We have cited the original papers of the datasets and EA models used in our experiments, ensuring proper credit and respect for their licenses and terms of use. For the open-source code and datasets, we have also stated the licenses they use in the readme.txt file in our code repository. Guidelines:• The answer NA means that the paper does not use existing assets.• The authors should cite the original paper that produced the code package or dataset.• The authors should state which version of the asset is used and, if possible, include a URL.• The name of the license (e.g., CC-BY 4.0) should be included for each asset.• For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided. • If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset. • For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided. • If this information is not available online, the authors are encouraged to reach out to the asset's creators. 
new assets: 
 Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?Answer: [Yes] Justification: Code of the proposed framework is released and accessible via this anonymouse URL: https://anonymous.4open.science/r/llm4ea_neurips2024-E763/.It contains a readme.md file and a GPLv3 license.Guidelines:• The answer NA means that the paper does not release new assets.• Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc. • The paper should discuss whether and how consent was obtained from people whose asset is used. • At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file. 
crowdsourcing and research with human subjects: 
 Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?Answer: [NA] Justification: The paper does not involve crowdsourcing nor research with human subjects.Guidelines:• The answer NA means that the paper does not involve crowdsourcing nor research with human subjects. • Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper. • According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector. 
institutional review board (irb) approvals or equivalent for research with human subjects: 
 Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?Answer: [NA] Justification: The paper does not involve crowdsourcing nor research with human subjects.Guidelines:• The answer NA means that the paper does not involve crowdsourcing nor research with human subjects. • Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper. • We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution. • For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review. 
 
 Appendix: A.1 Notations The source and target knowledge graphs, respectively E, E ′The sets of entities in G and G ′ , respectively R, R ′The sets of relations in G and G ′ , respectively T , T ′The sets of relational triplets in G and G ′ , respectively AThe ground truth set of aligned entity pairs BThe query budget for the LLM F(r)The functionality of relation r P (e ≡ e ′ )The alignment probability of entity pair (e, e ′ ) P (e) = max e ′ ∈E ′ P (e ≡ e ′ ) The alignment probability of the top-match entity for e L, L * The annotated pseudo-label set and the refined pseudo-label set Φ(L)The overall incompatibility of the pseudo-label set L nThe number of iterations of active selection n lrThe number of iterations of label refinementBelow we present the pseudo-code of the greedy algorithm, that incorporates probabilistic reasoning to refine the label set.Inputs: The pseudo-label set L Parameters: The intialization probability δ0 ∈ (0, 1), the threshold δ1 ∈ (δ0, 1), probabilistic reasoning iterations n lr Outputs: The refined pseudo-label set L * ⊂ L L ′ ← ∅. ∀e ∈ E, ∀e ′ ∈ E ′ , P (e ≡ e ′ ) ← 0 ∀(e, e ′ ) ∈ L, P (e ≡ e ′ ) ← δ0 i ← 0 while i < n lr do ∀e h ∈ E, ∀e ′ h ∈ E ′ , P (e h ≡ e ′ h ) ← 1 - (e h ,r,e t )∈T , (e ′ h ,r ′ ,e ′ t )∈T ′ 1 -F -1 (r)P (r ⊆ r ′ )P (et ≡ e ′ t ) × 1 -F -1 (r ′ )P (r ′ ⊆ r)P (et ≡ e ′ t ) . /* Update entity alignment probabilities.*/ ∀r ∈ R, ∀r ′ ∈ R ′ , P (r ⊆ r ′ ) ← 1-(e ′ h ,Probabilities of other entity pairs can be inferred from these saved alignment probabilities using Eq.(5) when necessary. In this way, parameter complexity is reduced to O(max(|E| + |E ′ |)).Computation efficiency of probabilistic reasoning. Probabilistic reasoning is executed iteratively, with each iteration updating the alignment probabilities of all entities and relations following Eq. ( 5) and Eq. ( 6). We detail the analysis of these two update phases in the following separately.Since we adopt a lazy inference strategy, the update of entity alignment probabilities involves updating the set of most probable alignments and associated probabilities as shown in Eq. ( 12). This update requires the estimation of all P (e, e ′ h ), e ∈ E and all P (e h , e ′ ), e ′ ∈ E ′ , for each current pair (e h , e ′ h ) to determine if this pair needs an update. Consequently, the computational complexity of this process is proportional to the size of this set, which is O(|E|). The estimated scores P (e, e ′ h ), e ∈ E and P (e h , e ′ ), e ′ ∈ E ′ can be precomputed in advance and reused for all pairs (e h , e ′ h ), leading to a computation complexity of O(|E||E ′ |). Thus, the overall computational complexity for updating entity alignment probabilities isO(|E||E ′ | + |E|) = O(|E||E ′ |).The update process for sub-relation probabilities involves updating all P (r ⊂ r ′ ) for r ∈ R and r ′ ∈ R ′ , resulting in a complexity of O(|R||R ′ |). The estimation of Eq. ( 6) utilizes the probabilities of the most probable alignments from Eq. ( 12). Notably, most relation pairs (r, r ′ ) do not have aligned head entities (e h , e ′ h ) or aligned tail entities (e t , e ′ t ), thus most relation pairs can be excluded for efficient computation by exploiting this sparsity heuristic, reducing the computations by orders.It is worth noting that these computations can be further accelerated through parallelization, as their execution solely depends on the results from the previous iteration.Our experiments were conducted on a server equipped with six NVIDIA GeForce RTX 3090 GPUs, 48 Intel(R) Xeon(R) Silver 4214R CPUs, and 376GB of host memory. The models were implemented using TensorFlow, NumPy, and SciPy. It was observed that the software version significantly affects hardware-software compatibility. Specifically, the original implementation of Dual-AMN was based on TensorFlow 1.14.0, which is not compatible with newer GPUs such as the NVIDIA GeForce RTX 3090. Therefore, we updated the code to be compatible with TensorFlow 2.7.0, enabling the model to leverage GPU acceleration effectively. The details of the software packages used in our experiments are listed in Table 4 . In our experiments, we utilized the OpenEA dataset version 1.1 (V2), specifically the 15K set. The statistics are detailed in Table 5 . It's important to highlight that the destination dataset for D-W-15K, originating from Wikidata, contains only entity IDs, lacking explicit names. These IDs, devoid of semantic content, are not inherently meaningful to a language model. To rectify this, we processed the dataset using the 'wikidatawiki-20160801-abstract.xml' dump file from Wikidata. This file provided the raw data necessary for constructing the D-W-15K dataset, enabling us to extract meaningful entity names.We shown the quantity of entities with names (after name extraction) for each KG in the 'Named entities' column in Table 5 . In the counterpart filtering phase, we selected the top-k (where k = 20 for our experiments) most similar candidates. The 'Target in top-k' column of Table 5 shows the number of target entities included in this selection.Table 6 : Performance-cost comparison between GPT-3.5 and GPT-4 as annotator. We increase the budget for GPT-3.5 to evaluate its performance.[n×] denotes using n× of the default query budget.Hit@1 Hit@10 MRR Hit@1 Hit@10 MRR Hit@1 Hit@10 MRR Hit@1 Hit@10 MRR GPT-3. In this section, we compare the LLM4EA model with several rule-based models, including two lexical matching-based approaches: Emb-Match and Str-Match. Emb-Match uses cosine similarities between word embeddings to identify aligned pairs, employing a pretrained language model. Str-Match utilizes the Levenshtein Distance to calculate similarity scores. Additionally, the probabilistic reasoning model PARIS performs entity alignment by relying on probabilistic methods.For the lexical matching-based models, we compute the similarity and evaluate the confident entity pairs, specifically targeting those whose normalized similarity scores exceed 0.8. The pretrained language model used for Emb-Match is bert-base-uncased for its ability to process unseen words as a subword model. To reduce false positives, we implementing a filtering process that only considers 1-1 matching for embedding-based matching. For PARIS, we assess all inferred aligned pairs by setting the threshold to zero. The entity alignment (EA) model of LLM4EA generates a ranked score list, which is not directly comparable with these rule-based models. To facilitate comparison, we use the trained EA model to generate confident pairs, ensuring that each entity is the top-ranked candidate for its counterpart. These pairs are then processed through our label refiner, and the refined pairs are evaluated. Experiments for PARIS and LLM4EA are repeated three times to ensure statistical reliability; for Emb-Match and Str-Match, experiments are performed once as these algorithms are deterministic. The results are presented in Table 7 .The findings highlight several key observations: 1) Lexical matching-based methods show a degree of alignment ability by leveraging name similarity, particularly on the D-Y-15K dataset, where many aligned entities have identical names. 2) These methods, however, encounter scalability challenges due to their reliance on name similarity. As the size of the KG grows, the number of similar entities increases, making it difficult to maintain precision. This is evident from our experiments on EN-FR-100K and EN-DE-100K, where precision dropped to 49% and recall to 65%, a significant decrease compared to the 15K-size datasets, supporting our analysis. 3) PARIS achieves precise results by handling noisy data through probabilistic reasoning, although its recall is lower than LLM4EA's. 4) LLM4EA, with its active selection and label refinement techniques, consistently delivers robust and accurate performance across all datasets.NeurIPS Paper Checklist 


Decision: The paper proposes a way to use LLM for Entity Alignment tasks (LLM2EA). It introduced an active learning policy to help reduce the annotation space, which is a unique challenge to vanilla LLMs in EA tasks. It also adds an unsupervised label refiner to efficiently collect pseudo-labels. Experiments showed clear improvement over other methods, including the additional ones suggested during rebuttal.

A main concern about the paper is around novelty (Reviewer SZjY), that it's similar to the core idea of previous methods like BootEA. The authors provided new evaluation data to show that LLM2EA has significantly better results than BootEA. AC acknowledges the concern of SZjY, however given the delta in experiment metrics and the differences explained by the authors, the delta seems non-trivial.

Reviews: review: paper_summary: paper_summary: The paper proposes an active learning/weak supervision based approach for knowledge base alignment (aligning entities across KGs). The paper explores an LLM labeler for generating entity alignment labels but explores active selection of source nodes labeled by the LLM, a label refiner which refines the LLM annotations based on the structural consistency of the KGs (nodes connected to aligned nodes should be aligned), and finally trains a entity alignment model on the gathered data. The paper compares to a range of baselines and presents several ablations to indicate the efficacy of the proposed approach.
strength_weakness: strength_weakness: - The papers writing is hard to follow and could benefit from reduction in notation, addition of intuition for modeling choices, and clearer distinguishing of its own contributions wrt prior work.
questions: questions: NA
limitations: limitations: NA
paper_summary: paper_summary: This paper tackles the challenge of entity alignment (EA) in merging knowledge graphs (KGs) by leveraging Large Language Models (LLMs) to automate annotations, addressing the costly and impractical reliance on human-generated labels despite difficulties like large annotation space and noisy labels. They propose LLM4EA, a unified framework designed to harness LLMs effectively for EA tasks. Key contribution include a novel active learning policy that reduces the annotation space by prioritizing the most valuable entities based on the overall inter-KG and intra-KG structure, and an unsupervised label refiner that enhances label accuracy through probabilistic reasoning. The framework iteratively optimizes its policy using feedback from a base EA model. Experimental results on four benchmark datasets highlight the framework's effectiveness, robustness, and efficiency, showcasing its potential as a significant advancement in the field of entity alignment.
strength_weakness: strength_weakness: - The authors do not consider any open-source LLMs such as Llama2/3. For example, Llama3 8b/70b may have better performance in EA tasks compared to GPT-3.5.
- The authors did not report the actual API costs for the experiments. For the baselines, what budgets were used to annotate the dataset to train these models? Are they the same as those used in your iterative framework?
- Figure 1: Replacing the human icon with a robot for the LLM annotator may be better.
questions: questions: Please see the weakness.
limitations: limitations: This paper has one limitation section.
paper_summary: paper_summary: This paper proposes a new setting that uses LLM to generate entity alignment training pairs, then use the generated pairs to train a matching model for entity alignment between two KGs. The proposed method is evaluated on the OpenEA dataset and achieves better performance than baseline methods on the setting.
strength_weakness: strength_weakness: 1. The setting is impractical. 
Is LLM really necessary for generating training pairs of entity alignment? if you already know the names of entities in two KGs, you can just use string matching / semantic similarity to generate training pairs. It produces much more accurate training pairs than LLM with "a fixed budget". I don't see the point of using LLM for generating training pairs of entity alignment. For the mono-lingual datasets, simply string matching can already achieve 100% accuracy, and for the cross-lingual datasets, lots of papers using semantic similarity have proven its effectiveness (https://arxiv.org/abs/2210.10436, https://aclanthology.org/2022.acl-long.405/, https://www.ijcai.org/proceedings/2020/439, https://dl.acm.org/doi/abs/10.1145/3404835.3462870, https://arxiv.org/abs/2203.01044, https://aclanthology.org/2021.emnlp-main.226/). 


2. Line 237 "We have chosen "V2" because it more closely resembles existing KGs". This statement is not true. In V2's generation process, they first randomly delete entities with low degrees, which results in a denser graph. This is not the case for existing real-world KGs, which are usually sparse. In their original paper, they said that the V2 benchmark is "more similar to existing datasets" like DBP15k, these datasets are not real-world KGs, they are synthetic datasets. Thus, the statement is misleading and should be corrected.

3. Following the above point, the proposed method is evaluated on the OpenEA V2 dataset, which is twice denser than real-world KGs. The performance on the OpenEA V2 dataset may not be representative of the performance on real-world KGs. This raises the question of the generalization of the proposed method to real-world KGs.


4. Baselines are old, see point 1 for more details.

5. The setting can actually be seen as a special case of the setting in https://dl.acm.org/doi/10.1145/3394486.3403268. The difference is the noise's source, in this paper, the noise comes from LLM, in the other paper, the noise is manually added. Mitigating noise from the training set/textual label is not new, they can be found in point 1's references.

6. As far as I know, the DBpedia, Wikidata, and YAGO datasets are all from the same domain, which gives them identity entity names. Take D_Y_15K_V2 for example, if you calculate the edit distance between the entity names in these datasets, you will find that the same entity in different datasets has exactly 0 edit distance. How exactly is Table 7 obtained? Table 7 shows the performance of semantic similarity/string matching is a lot worse than the proposed method and the F1 can be as low as 2% in some cases. This is not true, the F1 of semantic similarity/string matching should be 100% in the monolingual case.  The results in Table 7 are not reliable and should be corrected. I suggest the authors to check the correctness of the dataset and the code implementation.

Overall, this paper contains interesting but impractical new settings, false statements, and unreliable results. I recommend rejection.
questions: questions: See above
limitations: limitations: A limitations section is provided in the paper
paper_summary: paper_summary: The paper proposes LLM4EA for annotating entity alignment pairs using an LLM. It introduces an active learning policy and an unsupervised label refiner to efficiently collect pseudo-labels. Experiments on OpenEA benchmarks demonstrate the strong performance of LLM4EA.
strength_weakness: strength_weakness: The algorithm in this paper somewhat echoes that of BootEA, which limits its novelty. While earlier iterative or bootstrapping algorithms generated pseudo-labels using cosine similarity or other metrics, this paper introduces the use of an LLM to select pseudo-labels. Beyond this aspect, the procedure closely resembles existing methods.

The declaration in Line 237 is incorrect; "V1" is the dataset that resembles real-world KGs, and "V2" is the easier version.

Table 1 is not clear. Is LLM4EA the only method evaluated that considers pseudo-labels generated by an LLM? If so, why are the performances of the other methods significantly lower than those reported in the OpenEA paper?

Utilizing LLMs to annotate labels carries a risk of data leakage, as many entity name pairs in the OpenEA datasets are identical. This flaw was also noted by the creators of OpenEA.
If the authors account for the entity name as a feature, they should also benchmark LLM4EA against approaches that incorporate textual information, for example, MultiKE.
questions: questions: Please see Weaknesses.
limitations: limitations: N/A

Comments: title: Response to reviewer SZjY
Response to reviewer SZjY (2)
Response to reviewer SZjY (1)
Response to Reviewer n1nd
Responses to Reviewer  n1nd
Response to answer remaining concerns
To Authors
comment: Dear Reviewer SZjY,

Thank you for acknowledging our previous explanations and for raising the rating. We are genuinely grateful for your comments, which have helped us address these concerns.

We would like to take this opportunity to answer the remaining concern (e.g. novelty), and clarify the distinctions between our work and the methods you mentioned that also enable unsupervised EA:

1.  **Scalable pseudo-label generation.** While the multi-modal EA models you referenced generate pseudo-labels using feature similarities (e.g., names, images) and enhance them through bootstrapping, LLM4EA focuses on text features. In low-resource scenarios where only text attributes are available, relying solely on text embedding matching can lead to many false negatives. For example, in OpenEA D-W-15K V1 (without names), we found that using BERT-generated word embeddings results in low precision, as shown below. Precision drops further with larger KGs like D-W-100K V1 due to increased text similarity in larger datasets.

    | Emb-match on OpenEA V1 (w/o name) | Hit@1 | Hit@20 | MRR   |
    | --------------------------------- | ----- | ------ | ----- |
    | D-W-15K                           | 0.125 | 0.237  | 0.158 |
    | D-W-100K                          | 0.047 | 0.107  | 0.068 |

    In contrast, LLM4EA employs a recall-then-annotate strategy, leveraging the semantic understanding and reasoning capabilities of LLMs to annotate from the top-k candidates identified by embedding matching. This approach achieves significantly higher precision: **0.86** on D-W-15K and **0.82** on D-W-100K.

2.  **Technically advanced label refinement.** While our pseudo-labels are more precise than those from feature matching, they still require refinement before model training begins. Our unsupervised label refiner effectively handles this and is applicable to all kinds KGs. The methods you mentioned could benefit from incorporating our technique. Notably, while recent models like EASY [1] also offer unsupervised label refinement, their design is less effective because they 1) only consider one-hop structures, whereas LLM4EA's label refiner leverages higher-order structures through logical deduction, and 2) overlook relational properties within KGs, which LLM4EA addresses..

3.  **Active selection strategy.** LLM4EA also integrates an active selection strategy to tackle the unique challenges of LLM-based pseudo-label generation, particularly when annotation is costly and budgets are limited. This module optimizes utility of the annotation budget.

We hope this explanation clarifies the unique contributions of LLM4EA and why it stands out in unsupervised EA settings.

We also appreciate the listed methods for enhancing the comprehensiveness of the related work discussion, and we will incorporate these references in our draft revision.


[1] Make it easy: An effective end-to-end entity alignment framework. SIGIR, 2021
Hi, thank you very much for your detailed explanations to my questions. The authors may highlight too much on the so-called label-free setting. In fact, there are many existing methods that also have the unsupervised experiments [1, 2], in which they also leverage the similarity scores of text and vision information to produce the initial training labels. Then, they use the bootstrapping algorithm to update the training labels, which is analogous to this paper from my point of view.

I still tend to rejection due to the novelty, but I understand it's difficult to conduct new experiments at this stage. Thus, I would like to raise my score from 3 to 4.

[1] Multi-modal Contrastive Representation Learning for Entity Alignment. COLING, 2022.

[2] MEAformer: Multi-modal Entity Alignment Transformer for Meta Modality Hybrid. MM, 2023.
Following the above answers, below are answers for the rest questions:

**2.2 LLM is only applied in generating $\mathcal{L}_a$ and does not affect the bootstrapping process of bootEA**

**Q5.** Methods like BootEA have their own iterative process to refine their pseudo-labels. This is also why I think the proposed method lacks novelty. The authors just replaced their decision function with an LLM.

**Answers:**

To clarify, we first denote the bootstrapped pseudo-labels in bootEA as $\mathcal{L}_b$, to distinct from LLM-annotated labels $\mathcal{L}_a$.

- We respectfully point out that, when we use $\mathcal{L}_a$ as the initial training labels for bootEA, we don't change the bootstrapping process of bootEA. Therefore, when running baselines, **the generation of refinement of $\mathcal{L}_b$ is the default process and does not involve the LLM**. 
- As we discussed in lines 265-268 in the draft, the pseudo-label generation and refinement of bootEA relies on the embeddings **trained on a set of labels**, as a result, **the refinement process can only be applied to $\mathcal{L}_b$, and cannot be applied to $\mathcal{L}_a$** as there is no trained embeddings at the first iteration.  
- In contrast, although LLM4EA works iteratively, this process is not bootstrapping like BootEA. Its iterative process is designed to dynamically adjust the source entity selection policy. If we remove the active selection strategy, $\mathcal{L}_a$ is generated at once for LLM4EA, as for baselines. **In this case, we can still refine the label accuracy of $\mathcal{L}_a$ while bootEA cannot**, as our probabilistic-reasoning-based label refiner is **unsupervised** that only exploit the structural compatibilities among $\mathcal{L}_a$ to refine labels, without relying on ground truth labels or embeddings trained on them.

**2.3 Annotation when without name features by exploiting textual attributes**

**Q6.** How can "LLMs generate effective labels without name information, which justifies the 2nd claim"?

**Q7.** If the string or word does not exist, how do you filter out the less likely counterparts?

**Q8.** If the name feature is unavailable, how can you represent these triplets?

**Answers:**

When name information is not available, we leverage the associated attributes to represent each entity, these attributes are used for counterpart filtering and target entity identification. Specifically, we

- First employ a python regular expression to remove the meaningless attributes as most of the attributes are meaningless and do not contain semantic information; 
- Then we concatenate these attributes and employ a bert model to get the word embeddings, based on these embeddings we can recall the top-20 similar entities; 
- Finally we adjust the prompt, and describe each entity with its associated attributes,  and apply LLM to identify the target for each source entity from its top-20 candidates.

For more details of how to leverage attributes for filtering and target entity identification, we kindly refer 1st section of the response to reviewer n1nd in 10 Aug 2024, 18:33. 

Thank you again for the time and efforts you invested in participating in the discussion. Your comments are invaluable for helping us improve the quality of the draft and enable us to clarify the confusions.
We sincerely thank you for engaging in this discussion and allowing us to address any concerns. Below we first restate our setting and workflow in detail to clarify any confusion about our setting, then answer each of your questions.

# 1. Settings

**1.1 All experiments are under the label-free setting without ground truth labels for training**

Our work is motivated to explore label-free entity alignment, aiming to train EA models using **only LLM-annotated pseudo-labels**. All experiments, including evaluations of both LLM4EA and baseline methods, are conducted **without ground truth labels for training.** This setting is specifically designed to test whether all methods effectively achieve label-free EA. The baselines assess the effectiveness of directly training existing EA models on these noisy pseudo-labels, whereas LLM4EA is a framework designed to mitigate noise and optimize budget allocation for effective learning of the integrated base EA model. 

**1.2 LLM4EA works in 5-steps**

LLM4EA operates in a five-step process for each iteration:

Step1. Select important source entities

Step2. Recall top-k candidate counterparts for each source entity by string match or word embedding matching

Step3. Use an LLM to identify the target entity from the top-k candidates for each selected source entity.

Step4. Refine the pseudo-labels by probabilistic reasoning

Step5. Train the EA model

We respectfully point out that, although LLM4EA is iterative, this process is not bootstrapping like BootEA. Instead, this iterative manner is introduced to dynamically adjust the source entity selection (step1) policy to maximize the utility of a fixed annotation budget. If the budget is $\mathcal{B}$ and the iteration number is 5, then LLM4EA selects and annotates $\mathcal{B}/5$ source entities at each iteration. **If we remove the active selection module in LLM4EA, the LLM generates the seed alignments at once as training data and has no iterations, as in baselines**. 

# 2. Answers to the questions

We will first list the questions for clarity and then provide corresponding answers, based on the detailed settings outlined above.

**2.1 Label ratio and the experimental setting**

**Q1.** why you chose a smaller training label set and why your new experiments still do not follow the standard setting (i.e., 0.2|E|).? 

**Q2.** Were your results based on this setting(5-fold cross validation)?

**Q3.** The pseudo-label setting for baselines is also unfair. 

**Q4.** Why do the baselines have to use the pseudo-labels generated by the LLM for training?

**Answers: ** 

- **We did not follow the 5-fold setting of OpenEA because we are under label-free setting.** We undertand the OpenEA dataset by default contains $0.2|\mathcal{E}|$ **ground truth** labels for training,  which is designed for **supervised/semi-supervised setting**. As stated in setting 1.1, our experiments evaluate **label-free** EA with LLMs, the only input to the baselines and LLM4EA is the LLM-annotated pseudo-labels (denoted as $\mathcal{L}_a$ ). The training labels we referred to in the previous response is actually $\mathcal{L}_a$, rather than the ground truth labels. This clarification of experimental setting also answers **Q4**.

- **Label ratio is relevant to the annotation budget.** The input to both the baselines and LLM4EA is denoted as $\mathcal{L}_a$, which is annotated with a budget of $\mathcal{B}=0.1|\mathcal{E}|$. In practice, the size of the pseudo-labels $|\mathcal{L}_a|$ is less than or equal to $0.1|\mathcal{E}|$ because some queries result in negative outputs (i.e., no matched target is found within the top-k), and thus no label is generated. The label size $|\mathcal{L}_a|$ scales linearly with the annotation budget $\mathcal{B}$. More pseudo-labels can be obtained by increasing this budget. We intentionally did not use a larger default budget to demonstrate how LLM4EA and the baselines perform under challenging cost-constrained settings. If more labels are required, the budget can simply be increased to improve performance, as shown in Figure 2 of our draft.
- **Fair comparison by same input.** As discussed above, both baselines and the LLM4EA use the same input (same annotation budget to the LLMs to get $\mathcal{L}_a$, and no ground truth labels).
Thank you for your detailed response. However, I am still confused and curious about why you chose a smaller training label set and why your new experiments still do not follow the standard setting (i.e., 0.2|E|). The OpenEA datasets have a default setting of 0.2 because it is convenient for 5-fold cross-validation. Were your results based on this setting?

The pseudo-label setting for baselines is also unfair. Why do the baselines have to use the pseudo-labels generated by the LLM for training? Methods like BootEA have their own iterative process to refine their pseudo-labels. This is also why I think the proposed method lacks novelty. The authors just replaced their decision function with an LLM.

The usage of the name feature is still unclear. How can "LLMs generate effective labels without name information, which justifies the 2nd claim"? In Lines 139-142, the authors claim that the annotation filtering is based on string matching score or word embeddings (this also justifies that your method also generates pseudo-labels based on similarity scores grounded on embeddings). If the string or word does not exist, how do you filter out the less likely counterparts?

Then, in Lines 147-148, the authors state that the prompts include the name and relational triplets. If the name feature is unavailable, how can you represent these triplets?
Dear Reviewer n1nd,

We are delighted that our work has been acknowledged by you following these discussions. We sincerely thank you once again for the time and effort you invested in reviewing our work and engaging in the discussion. Your professional comments are invaluable for improving our work, and your active participation has enabled us to clarify any confusions. We sincerely appreciate your contribution.
Thank you for your response. Based on the new experiments and discussions provided by the authors, I have adjusted the score. I would appreciate it if these updates could be incorporated into the next version of the paper.
Thank you for your prompt reply and detailed questions. Below are our responses:

**1. Labels for DBP1M and statistics**

The labels for both LightEA and LLM4EA(LightEA) were annotated by LLMs, with a precision of approximately 0.861 for $DBP1M_{EN-DE}$ and 0.830 for $DBP1M_{EN-FR}$. During our experiments with LLM4EA(LightEA), these precision rates were improved to 0.94 and 0.91, respectively.

**2. Compromised performance comes from reduced entity dimension**. 

During our experiments, we found that LightEA could only run DBP1M on a **GPU** with an entity dimension of `ent_dim=64`. Running with higher dimensions, such as `ent_dim=256`, led to out-of-memory errors, despite claims in the original paper that `ent_dim=256` was feasible. We successfully ran $DBP1M_{EN-DE}$ with `ent_dim=256` on a **CPU**, with results as follows:

| Model           | hit@1 | hit@10 | Mrr   |
| --------------- | ----- | ------ | ----- |
| LightEA         | 0.245 | 0.336  | 0.293 |
| LLM4EA(LightEA) | 0.272 | 0.394  | 0.314 |

Running these experiments on a CPU took approximately two days, therefore we did not further run it on $DBP1M_{EN-FR}$ due to limited time. Based on the results above, we can see

-   **The annotation percentage still scale to large datasets**. The results with dimension 256 are already quite approximate to the results in the LightEA paper although we only annotate 10% of the nodes.

-   **The compromised performance in previous results was mainly due to the reduced entity dimension**. The choice of entity dimension does not affect our claim that "LLM4EA can enhance LightEA," as our experimental settings ensure a fair comparison. We will clarify this subtle point in the revised paper and include the results on $DBP1M_{EN-FR}$ with `ent_dim=256`.


**3. LLM4EA handle similar names by recall-then-annotate strategy.**

 As detailed in **1.2** in our previous response, LLM4EA first performs counterpart filtering to ensure recall rate, then identifies with the semantic understanding and reasoning ability of LLM4EA. 

For the counterpart filtering process, the recall rate (in top-20) of $DBP1M_{EN-FR}$ and $DBP1M_{EN-DE}$ is 0.791 and 0.834. This recall rates show that the current string distance-based filtering method works well for our task, therefore we didn't incorporate more intricate filtering methods. When more complicated scenarios are present, we can also benefit from more sophisticated filter such as blocking, scaling our framework to such scenarios. We appreciate your comments and suggestions that extend the discussion of possible challenges in practice.

**4. We will provide the detailed prompt in the paper**

Thank you for this suggestion. We will include the detailed prompts in the appendix of the revised paper.

We sincerely thank you again for the time and effort you invested in reviewing our response. Your comments are invaluable for improving our work and enable us to clarify any confusions.
Thank you for your response. I have carefully read your response, and have the following questions: 

Is the label for DBP1M also from LLM? The performance of LightEA is pretty different compared with reported in the original paper. I assume it is the same 'noisy label' from LLM. Could you please confirm this and provide LLM label statistics as in 1.1? 

In experiment 3.1 LLM4EA has a hit@1 of 0.04~0.1, and is much lower than the simple BERT solution. Could this mean a 10% LLM annoation is not enough for larger datasets, and the annoation percentage may also be scaled with the dataset size? Does the cost analysis in 2.1 consider this?

Larger dataset could result in more similar entity names, as shown in the response. This is intuitive. How LLM4EA handles this issue? If Levenshtein distance is used for filtering, won't it be worse for larger datasets?
 Could you provide the recall of the filtering step?
 Have the authors tried more complex blocking methods in entity resolution to improve the performance?

Could you detail the prompt template used for both the name experiment and the ID experiment?  The prompt template is crucial for reproducibility, and it is important to provide it in the paper, at least in the appendix.
Thank you for your prompt reply and support, we anwer your remaining conerns one by one below.

# 1. Concerns about ID leakage

Below we attach the detailed experimental setting and results to answer the concern.

**1.1 Experimental setting**
- **ID random reassignment for eliminating name bias**. When masking entity names with IDs, we randomly reasign new IDs (rather than the original IDs extracted from wikidata dump file) to the entities of D-W-15K-V1. 
- **Attribute-based prompting**. Since the entity names are not available, we describe each entity by its associated attributes in the prompt. Noteworthy that most attributes don't contain semantic information, we use a python regular expression to filter out meaningless attributes. 

**1.2 Experimental results**

Entities are annotated in two steps.

-   Counterpart selection

Using the attributes, we first employ a BERT to generate embedding for each entity, then get the top-20 counterparts by semantic matching. The recall (hit@k) of this process is:

|Hit@1|Hit@20|MRR|
|-|-|-|
|0.125|0.237|0.158|

-   Target identification

Given a source entity and its top counterparts, an LLM determines if an aligned target entity exists in these candidates. If the LLM finds no match, the query is discarded. Otherwise, it predicts a positive label (true or false positive). The results below are based on 1500 queries.

| Abandoned | True positive | False positive |
| - | - | - |
| 1150 | 301 | 49 |

# 2. Comparison with BERT model in terms of scalability

 Below we compare LLM4EA and Bert models in terms of cost scalability and performance scalability.

**2.1 Cost scalability**

-   **LLM4EA's costs scale linearly with KG size.** The costs of LLM4EA mainly come from its query to LLMs. This cost scales linearly with the KG size. In our experiments, the average token cost for each entity is around 1100. Thus, each experiment on 15k dataset costs 1100x(0.1x15000)x0.5/10^6 =0.825 dollars, and for each experiment on 100k, it costs 5.5 dollars, under the pricing scheme of gpt-3.5-turbo-0125.
-   **Querying LLMs can be accelerated by parallel or batch query**.  Acceleration can be achieved by parallel query,  or by querying OpenAI's batch API. Noteworthy that the LLMs response speed is growing rapidly and we can benefit from these advances.

**2.2 Performance scalability**

Given the hardware demands and need for pre-aligned pairs in finetuning, an alternative is to use BERT for embedding matching without finetuning. In previous emb-match experiments, BERT performs well on small datasets with names, but **the following experiments show its precision decreases as KG size increases**. 

|DBP1M |Precision|Recall|F1|
|-|-|-|-|
|$DBP_{EN-DE}$|0.492|0.679|0.571|
|$DBP_{EN-FR}$|0.490|0.654|0.560|

|OpenEA V1 (w/o name)|Hit@1|Hit@20|MRR|
|-|-|-|-|
|D-W-15K|0.125|0.237|0.158|
|D-W-100K|0.047|0.107|0.068|

- **Bert is less accurate on large KGs**. The DBP1M dataset contains name information, while BERT model shows decreased precision. We investigate and identify that **this precision decline is mainly due to the increased number of similar names as the KG size grows**. And as expected, when name information is not available in D-W dataset (second table above), the precision also decreases. 

- **LLMs generate more precise labels**. Bert model can help recall the possible counterparts but fail to generate effective labels, employing a LLM can annotate more precise labels from these recalled counterparts, as discussed and shown by experiments in **1.2**. 

# 3. Comparison with related work

**3.1 Comparison with LightEA**.

|results on $DBP_{EN-DE}$|hit@1|Hit@10|mrr|
|-|-|-|-|
|LightEA  | 0.055 |0.089 |0.067|
|LLM4EA(LightEA)|0.099|0.152 |0.117|

|results on $DBP_{EN-FR}$|hit@1|Hit@10|mrr|
|-|-|-|-|
|LightEA|0.034|0.066|0.045|
|LLM4EA(LightEA)|0.044|0.086|0.059|

- **LightEA is efficient.** LightEA performs EA with notable efficiency, scalable to DBP1M. 
- **LightEA can be enhanced by LLM4EA and in return improve scalability of LLM4EA.** We respectfully point out that, LLM4EA is a general framework and can incorporate any EA model as its base model to perform effective learning. In return, LLM4EA stands to benefit from advancements in efficient base EA models.

**Comparison with EASY**.

- **EASY only consider one-hop structure while LLM4EA leverage higher-order structures.** EASY generates confident pseudo-labels by selecting entity pairs with high (one-hot) neighborhood similarities. In contrast, LLM4EA incorporates iterative reasoning that **implicitly performs multi-hop reasoning** through logical deduction. Realworld KGs can be sparse and contain many long-tail entities that have no aligned neighbors.
- **EASY neglects relational properties while LLM4EA does**. Statistical properties of relations, such as functionalities, are crucial in quantifying the contributions of neighbors. EASY simply relying on neighbor counts and overlooks these properties.
Thanks for your responses. Your answers address most of my concerns.
I think my rating is reasonable and fair. So I maintain my scores.
Thank you for your response and your effort to address my concerns. I appreciate your time and effort. I have raised my score to 4. This is because some parts of my concerns aren't fully addressed. Regarding the motivation, I hope you can address these in further responses:

1.
The ID experiment is interesting. Please provide more detailed settings for this experiment. For example, how do you ensure that the IDs are not memorized by the LLMs? Does the accuracy come from the IDs already being memorized by the LLMs as part of the knowledge base? If so, how can we ensure that the LLMs can identify IDs that are not memorized? Wouldn't this memorization lead to more bias than name-bias issues? 
If we want to use such systems in applications where the resources are so limited that even names are not available, how can we ensure that the LLMs can still identify the IDs? 
Could you provide a more detailed experiment on this? For example, reassigning the IDs to the entities in the knowledge base and seeing if the LLMs can still identify the IDs. I assume you may need to design specific prompts, for example, showing the neighborhood IDs, to explore the reasoning ability beyond memorization
1.
Scalability to larger KGs. Do you have experimental results on larger KGs such as DBP1M? Using an API to query may eliminate the need for local machines, but the API is still costly and there are rate limits. Do you have a cost analysis of using the API compared to deploying a BERT model locally? I would assume that the BERT solution is far more cost-effective and scalable, while still maintaining decent accuracy.

I would advise the authors to compare the recent SOTAs such as LightEA (https://arxiv.org/pdf/2210.10436), both in terms of accuracy and scalability. Some other works like EASY (https://dl.acm.org/doi/abs/10.1145/3404835.3462870) also have some kind of error correction mechanism. It would be interesting to discuss how your work is different from these works.