PUER : Boosting Few-shot Positive-Unlabeled Entity Resolution with Reinforcement Learning (2025)

Abstract: Entity resolution is a fundamental problem in data management that aims to identify all duplicate entries within collections of multi-attribute tuples. Most existing works focus on supervised learning, relying on large amounts of high-quality labeled data, including both positive and negative tuple pairs that are meticulously prepared. However, in reality, the manual annotation process is labor-intensive; in particular, selecting high-quality negative data for labeling is both important and challenging. In this paper, we propose an end-to-end ER solution, PUER, to address low-resource entity resolution (ER) by leveraging Large Language Models (LLMs) in a Positive-Unlabeled (PU) learning setting, where only a small number of positively labeled examples, e.g., 50, and unlabeled data are provided. Unlike directly fine-tuning LLMs in a supervised manner, we solve the entity matching task using reinforcement learning and propose a self-adaptive reward function in the process of RL. To enhance performance, we design an iterative workflow based on the co-training mechanism that fully utilizes entity blocking component to assist the entity matching. This workflow aims to improve the robustness and quality of pseudo-labels so that the performance of entity matching improves. Comprehensive experimental results on various benchmark datasets demonstrate the superiority of PUER. Full version and code are available.

## introduction entity resolution (er) aims to identifying all tuple pairs from two relational tables that refer to the same entities, making it a key components of data cleaning with the goal of deduplicating records in datasets. traditionally, the er task consists of two components, entity blocking (eb) and entity matching (em). entity blocking efficiently retrieves potentially matched tuple pairs, while entity matching verifies whether these tuple pairs refer to the same entities. traditionally, the entity resolution has been extensively studied and most of solutions reply on a sufficient number of annotated tuple pairs to achieve good performance. however manual annotation is costly, as demonstrated by methods like ditto @xcite and deepmatcher @xcite . to address it, a few existing em approaches focus on unsupervised learning, semisupervised learning and active learning. for instance, tdmatch @xcite is an unsupervised er approach based on graph creation and random walk, while only relying on the data distribution cannot have very high accuracy due to the extreme class imbalance. promptem @xcite generates pseudo-labels for low-resource er in the semi-supervised learning. while it partially alleviates the annotation cost, selecting and labeling high-quality positive and negative tuple pairs from large datasets remains challenging. active learning approaches, e.g., @xcite , select ambiguous tuple pairs for user labeling, but this also incurs significant manual annotation costs. in this work, we focus on the few-shot positive-unlabeled (pu) learning, where only a small number of labeled positive tuple pairs are provided along with two relational tables. to the best of our knowledge, we are the first to explore the er task in the few-shot pu learning context. entity resolution, which typically replies on both positive and negative training data, is particularly relevant to few-shot pu learning @xcite . in practice, only users who detect duplicate issues in their datasets often invest resources to find and integrate these duplicates, so that these detected duplicates instances are treated as labeled positive data. negative tuple pairs are generally not provided. additionally, in a search engine scenario, users might ask a question and receive multiple semantically identical re-sponses @xcite . these responses are considered positive data. while negative tuple pairs can be relatively easy to collect, acquiring high-quality negative pairs in large-scale datasets is non-trivial and requires manual annotation and verification, presenting a challenge for annotators @xcite . building on these observations, we investigate the er task within the framework of few-shot pu learning to address these challenges effectively with minimal labelling cost, while aligning with human preference. however, existing er methods based on pretrained language models (e.g., roberta) primarily learn distribution and decision boundaries from large sets of annotated samples. this approach results in inefficiencies in labeled data utilization, placing these methods at a disadvantage in fewshot scenarios. furthermore, they lack the capability to generalize well, and cannot achieve highperformance em tasks based solely on a limited number of positive sample annotations. recently, as the advanced performance of large language models (llms), they have been explored in the entity matching task. jellyfish @xcite addresses various data pre-processing tasks, including entity matching, by leveraging llms in the instruction-tuning and reasoning manner. table-gpt @xcite employs and fine-tunes online gpt-3.5 on various data pre-processing tasks. considering the data privacy concerns, we focus on using local llms that are open-sourced and can be fine-tuned in local environments. motivated by the above considerations, we explore the er problem within the framework of fewshot pu learning by harnessing the capabilities of local llms. our objective is to fully utilize entity blocking to assist the entity matching process and to develop an llm-based model that can efficiently and effectively retrieve all matched tuple pairs from limited labeled data. unlike traditional methods that treat entity matching purely as a binary classification task, our approach is the first to formulate entity matching as a reinforcement learning problem while simultaneously fine-tuning the model using both supervised fine-tuning (sft) and reinforcement learning. furthermore, to integrate entity blocking with entity matching, we introduce an iterative workflow that progressively generates high-quality pseudo-labels, facilitating mutual learning among these components. our contributions are as follows: ## related work we classify er into entity blocking and matching. entity blocking. we classify entity blocking as (1) rules, e.g., handcrafted rules @xcite @xcite , and learned rules @xcite @xcite , (2) traditional ml, e.g., @xcite , and (3) deep learning, e.g., @xcite @xcite @xcite , which retrieve potentially matched tuple pairs from large-scale datasets. ## preliminaries in this section, we first present the er problem, and then introduce the entity blocking and matching. ## rl-based entity matching as discussed above, the entity matching task is formulated as two sub-tasks, matcher f m em and selector f s em . in this section, we focus on how to fine-tune the selector to make policies from a list of candidate tuples. here we assume that f s em is fine-tuned using a (pseudo-)labeled training dataset d s @xmath0, c s (t), l t )}, where l t is the label of the pivotal tuple t. the process of generating d s train will be discussed in section 5. ## an er workflow in this section, we present an er workflow to train the entity matching models f em with the assistance of an entity blocking model f rag . the workflow takes as input two relational tables, r l and r r , and a set p of positive tuple pairs. as shown in figure 2 , the workflow consists of three main steps: data enrichment, entity blocking, and entity matching. step 1: data enrichment. enriching tuples in r l and r r with additional attributes, denoted as b, is a common and effective method. due to the uncertainty @xcite inherent in llms, we observe that the values of b imputed for a tuple can vary depending on its paired tuples (w.r.t. context). for each tuple @xmath1, we generate |s t | tuple pairs, i.e., p @xmath2, s 1 ), . . . , (t, s |st| )}, where s @xmath3. given each pair (t, s i ) ∈ p t , we query the llm to impute the values of b as a @xmath4, s i ), b, pt enr ). due to llm uncertainty, the imputed values a 1 , . . . , a |pt| may differ across pairs. to leverage these variations, we enumerate all imputations and augment each tuple pair with multiple enriched versions. step 2: entity blocking. after data enrichment, we enrich the positive set p into an augmented set p enr . we then fine-tune our entity blocking model f rag using contrastive learning with a randomly sampled negative set, following the approach in @xcite . the final output of this step is the fine-tuned f rag . ## experimental results in this section, we empirically evaluated our method, puer using benchmark datasets on (1) the effectiveness and efficiency of entity matching, (2) the ablation study, and (3) a comparative analysis with online llms, particular comem @xcite with gpt-4o-mini. more experimental results are provided in the supplemental material. experimental settings. we start with our settings. ## conclusion in this paper, we propose, puer, an end-to-end er solution for few-shot pu learning. we adopt the reinforcement learning method to solve the entity matching task, and design a self-adaptive reward function. furthermore, we introduce an iterative training workflow that fully utilizes the entity blocking model to assist the entity matching via a co-training mechanism. finally comprehensive experiments across 11 benchmarks demonstrate the superior performance of puer.