ZeroER: Entity Resolution using Zero Labeled Examples

TL;DR

ZeroER is a novel entity resolution method that effectively matches records without labeled data by leveraging similarity distributions, outperforming existing unsupervised methods and rivaling supervised approaches.

Contribution

The paper introduces ZeroER, a zero-labeled example entity resolution algorithm using Gaussian Mixture Models, adaptive regularization, and transitivity integration for improved accuracy.

Findings

ZeroER outperforms existing unsupervised ER methods.

ZeroER achieves comparable results to supervised approaches.

The approach is validated on five benchmark datasets.

Abstract

Entity resolution (ER) refers to the problem of matching records in one or more relations that refer to the same real-world entity. While supervised machine learning (ML) approaches achieve the state-of-the-art results, they require a large amount of labeled examples that are expensive to obtain and often times infeasible. We investigate an important problem that vexes practitioners: is it possible to design an effective algorithm for ER that requires Zero labeled examples, yet can achieve performance comparable to supervised approaches? In this paper, we answer in the affirmative through our proposed approach dubbed ZeroER. Our approach is based on a simple observation -- the similarity vectors for matches should look different from that of unmatches. Operationalizing this insight requires a number of technical innovations. First, we propose a simple yet powerful generative model based on Gaussian Mixture Models for learning the match and unmatch distributions. Second, we propose an adaptive regularization technique customized for ER that ameliorates the issue of feature overfitting. Finally, we incorporate the transitivity property into the generative model in a novel way resulting in improved accuracy. On five benchmark ER datasets, we show that ZeroER greatly outperforms existing unsupervised approaches and achieves comparable performance to supervised approaches.

Tables

Table 1. Table 1. Cosine similarity between covariance matrix (first row) and correlation matrix (second row) using ground-truth matches and unmatches after feature grouping on five real-world datasets.

	FZ	DA	DS	AB	AG
cosine($S_M$,$S_U$)	0.76	0.69	0.74	0.92	0.73
cosine($R_M$,$R_U$)	0.97	0.94	0.98	0.99	0.99

Table 2. Table 2. Datasets characteristics, Ms and As denote matches and attributes

Dataset	#Tuples	#Ms	#As
FZ, Fodors-Zagat (uci, )	533 - 331	112	7
DA, DBLP-ACM (erhardws, )	2,616 - 2,294	2,224	4
DS, DBLP-Scholar (erhardws, )	2,616 - 64,263	5,347	4
AB, Abt-Buy (erhardws, )	1,082 - 1,093	1,098	3
AG, Amazon-Google products (erhardws, )	1,363 - 3,226	1,300	4

Table 3. Table 3. F-score for all methods.

		Unsupervised					Supervised				Active learning
	ZeroER	ECM	KM-RL	KM-SK	GMM	PP∗	RF	LR	MLP	DM	AL-RF
FZ	1	0.07	0.30	0.30	0.30	0.97	0.97	0.98	0.99	0.93	1
DA	0.96	0.09	0.95	0.27	0.26	0.87	0.98	0.96	0.97	0.97	0.99
DS	0.86	0.07	0.85	0.43	0.07	0.83	0.93	0.88	0.92	0.95	0.99
AB	0.52	0.01	0.01	0.02	0.02	0.29	0.46	0.18	0.32	0.63	0.44
AG	0.48	0.01	0.02	0.02	0.02	0.30	0.51	0.18	0.35	0.67	0.46
average	0.76	0.05	0.43	0.19	0.13	0.65	0.77	0.64	0.71	0.83	0.78

Table 4. Table 4. # labeled examples needed for supervised and active learning methods to match ZeroER’s F-score. Numbers with an asterisk denote all tuple pairs in a dataset since those methods are not able to match ZeroER’s performance.

	LR	RF	MLP	DM	AL-RF
FZ	${2915}^{\ast }$	${2915}^{\ast }$	${2915}^{\ast }$	2332	1572
DA	418	232	417	4647	26
DS	413	227	270	6768	33
AB	${162981}^{\ast }$	${162981}^{\ast }$	${162981}^{\ast }$	16865	${162981}^{\ast }$
AG	${358281}^{\ast }$	7589	${358281}^{\ast }$	17916	${358281}^{\ast }$

Table 5. Table 5. Ablation analysis for ZeroER .

	ZeroER	group+share corr $\to$ diag+share cov	adaptive reg $\to$ uniform reg	posterior constraint $\to$ post-processing
FZ	1	0.97	0.95	0.99
DA	0.96	0.96	0.36	0.97
DS	0.86	0.78	0.59	0.41
AB	0.52	0.08	0.07	0.45
AG	0.48	0.09	0.04	0.42
average	0.76	0.57	0.38	0.65

Equations

$$p(y=M|\text{x})$$

$$=\frac{{\pi }_M\times p(\text{x}|y=M)}{{\pi }_M\times p(\text{x}|y=M)+{\pi }_U\times p(\text{x}|y=U)}$$

$$L(\Theta )=$$

$$=$$

$${\gamma }_{i,M}^t=$$

$$=$$

$$\mathbb{E}\{L(\Theta )\}=$$

$$N_C=$$

$${\Sigma }_C=$$

$${\Sigma }_C={\Lambda }_C{R}_C{\Lambda }_C\text{vspace}-2mm$$

$${\Sigma }_M={\Lambda }_{M}R{\Lambda }_M\text{ and }{\Sigma }_U={\Lambda }_{U}R{\Lambda }_U\text{vspace}-2mm$$

$${\mathbb{E}}^{\prime }\{L(\Theta )\}=\mathbb{E}\{L(\Theta )\}-1/2\times \text{tr}(K(N_M{\Sigma }_M^{-1}+N_U{\Sigma }_U^{-1}))$$

$${\Sigma }_C=S_C+K\text{ where }C\in \{M,U\}\text{vspace}-2mm$$

$$\displaystyle BC_{j}=\text{exp}\bigg{[}$$

$$\displaystyle-\frac{1}{4}\frac{(\mu_{M}[j]-\mu_{U}[j])^{2}}{\Sigma_{M}[j,j]+\Sigma_{U}[j,j]}\bigg{]}$$

$$B{C}_j^{\prime }-B{C}_j={\kappa }^{\prime },\forall j\in [1,d]\text{vspace}-2mm$$

$${\gamma }_{1,2,M}\times {\gamma }_{1,3,M}\le {\gamma }_{2,3,M}\text{vspace}-2mm$$

$$Q=\{\mathbf{\gamma }|{\gamma }_{i,j,M}{\gamma }_{i,k,M}-{\gamma }_{j,k,M}\le 0\forall i,j,k\}\text{vspace}-1mm$$

$$F(\Theta ,\mathbf{\gamma })=$$

$${\mathbf{\gamma }}^t=\text{arg}\underset{\mathbf{\gamma }}{\max }F({\Theta }^{t-1},\mathbf{\gamma })\text{vspace}-1mm$$

$${\Theta }^t=\text{arg}\underset{\Theta }{\max }F(\Theta ,{\mathbf{\gamma }}^t)\text{vspace}-1mm$$

$${\mathbf{\gamma }}^t=\text{arg}\underset{\mathbf{\gamma }\in Q}{\max }F({\Theta }^{t-1},\mathbf{\gamma })\text{vspace}-1mm$$

$${\gamma }_{i,j,M}^{\prime }=\frac{{\gamma }_{j,k,M}}{{\gamma }_{i,k,M}},{\gamma }_{i,k,M}^{\prime }=\frac{{\gamma }_{j,k,M}}{{\gamma }_{i,j,M}},{\gamma }_{j,k,M}^{\prime }={\gamma }_{i,j,M}{\gamma }_{i,k,M}$$

$$Q^{\prime }=\{\mathbf{\gamma }|{\gamma }_{i,j,M}{\gamma }_{i,k,M}\le {\gamma }_{j,k,M},\text{where }{\gamma }_{i,j,M}\ge 0.5,{\gamma }_{i,k,M}\ge 0.5\}$$

$$L(\Theta ,{\Theta }_l,{\Theta }_r)=$$

$$+{\Sigma }_{i=N+1}^{N+N_l}$$

$$+{\Sigma }_{i=N+N_l+1}^{N+N_l+N_r}$$

$$L({\Theta }_l,{\Theta }_r,\Theta )=L({\Theta }_l)+L({\Theta }_r)+L(\Theta )\text{vspace}-2mm$$

$$F({\Theta }_l,{\mathbf{\gamma }}_l,{\Theta }_r,{\mathbf{\gamma }}_r,\Theta ,\mathbf{\gamma })=F({\Theta }_l,{\mathbf{\gamma }}_l)+F({\Theta }_r,{\mathbf{\gamma }}_r)+F(\Theta ,\mathbf{\gamma })$$

Full text

Our approach is based on a simple observation — the similarity vectors for matches should look different from that of unmatches. Operationalizing this insight requires a number of technical innovations. First, we propose a simple yet powerful generative model based on Gaussian Mixture Models for learning the match and unmatch distributions. Second, we propose an adaptive regularization technique customized for ER that ameliorates the issue of feature overfitting. Finally, we incorporate the transitivity property into the generative model in a novel way resulting in improved accuracy. On five benchmark ER datasets, we show that ZeroER greatly outperforms existing unsupervised approaches and achieves comparable performance to supervised approaches.

entity resolution; entity matching; unsupervised learning

††journalyear: 2020††copyright: acmcopyright††conference: Proceedings of the 2020ACM SIGMOD International Conference on Management of Data; June 14–19,2020; Portland, OR, USA††booktitle: Proceedings of the 2020 ACM SIGMOD International Conference onManagement of Data (SIGMOD’20), June 14–19, 2020, Portland, OR, USA††price: 15.00††doi: 10.1145/3318464.3389743††isbn: 978-1-4503-6735-6/20/06††ccs: Information systems Entity resolution††ccs: Computing methodologies Unsupervised learning

1. Introduction

Entity resolution (ER) – also known as duplicate detection or record matching – refers to the problem of identifying tuples in one or more relations that refer to the same real world entity. For example, an e-commerce website would want to identify duplicate products (such as from different suppliers) so that they could all be listed in the same product page. ER has been extensively studied in many research communities, including databases, statistics, NLP, and data mining (e.g., see multiple surveys (DBLP:conf/sigmod/KoudasSS06, ; DBLP:journals/tkde/ElmagarmidIV07, ; DBLP:journals/pvldb/DongN09, ; DBLP:series/synthesis/2010Naumann, ; DBLP:journals/pvldb/GetoorM12, ; herzog2007data, )).

The standard approach for entity resolution is to use textual similarities between two tuples to determine if they are a match or unmatch (DBLP:journals/tkde/ElmagarmidIV07, ). Informally, in Figure 1(a)(b), the matching pair (fd1, zg2) is textually similar, while the non-matching pair (fd1, zg1) is not. Typically, a vector of similarity scores (aka, feature vector) is computed for a tuple pair by applying various similarity functions (such as edit distance, or jaccard similarity) on corresponding attributes. Multiple similarity scores can be used for a single attribute. Figure 1(c) shows a subset of the similarity scores computed by the open-source ER package Magellan(konda2016magellan, ). For example, the feature cos_qgm_3_qgm_3 represents the cosine similarity between 3-grams on the name attribute between a pair of tuples. Given the computed feature vectors, ER is typically formulated as a binary classification problem where a classifier is trained to determine whether a tuple pair is a match or an unmatch based on its similarity vector.

The Need for ZeroER. Supervised machine Learning (ML) approaches provide the state-of-the-art results for ER (deeper, ; anhaisigmod2018, ; kopcke2010evaluation, ; dong2018data, ). Powerful techniques such as deep learning have a voracious appetite for large amounts of labeled training data. For example, both DeepER (deeper, ) and DeepMatcher (anhaisigmod2018, ) require hundreds to thousands of labeled examples. Even non-deep learning based methods require hundreds of labeled examples (kopcke2010evaluation, ). It has been reported (dong2018data, ) that achieving F-measures of $\sim$99% with random forests can require up to 1.5M labels even for relatively clean datasets. Hence, generating large amounts of training data is a time consuming and challenging task even for domain experts.

Furthermore, organisations often have many relations to be de-duplicated (e.g., General Electric has 75 different procurement systems (stonebraker2018data, )), and generating labeled data becomes a huge issue. Due to this, there has been intense interest from the database community in self-service data preparation that requires limited efforts from domain scientists. Motivated by these considerations, we develop a ZeroER approach that can perform ER with comparable performance to supervised approaches, but with zero labeled examples.

Key Insights and Challenges. Designing a ZeroER approach that achieves competitive performance across different datasets is extremely challenging. We highlight three fundamental ideas that make this possible.

(1) Generative Modelling. Supervised approaches learn to tell apart matches and unmatches from the large amount of labeled training data. However, ZeroER does not have this useful information and has to design a mechanism to distinguish the matches from unmatches. ZeroER leverages a blindingly simple yet powerful observation: the similarity vectors (aka feature vectors) for matches should look different from the similarity vectors for unmatches.

We plot in Figure 2 the distribution of feature values for the fodors-zagats dataset, using ground-truth matches and unmatches. For ease of visualization, we only show the distribution along two feature dimensions. As we can see, the similarity values of these two features for the matches concentrate in the upper right corner, while the values for unmatches in the bottom left corner.

This observation inspires us to use generative modelling for the ER problem — the feature vector x of a match can be assumed to be generated according to one distribution (termed the M-Distribution), and the feature vector x of an unmatch can be assumed to be generated according to a different distribution (termed the U-Distribution).

If we can learn the probability density functions (PDFs) of two distributions, i.e. $p(\textbf{x}|y=M)$ and $p(\textbf{x}|y=U)$, and the prior probability of a tuple pair being a match $\pi_{M}=p(y=M)$, or a non-match $\pi_{U}=p(y=U)=1-\pi_{M}$, then determining whether a given tuple pair should be classified as match is equivalent to computing the posterior probability $p(y=M|\textbf{x})$ for its feature vector x using the Bayes rule:

[TABLE]

Accurately learning the prior $\pi_{M}$, the M-Distribution $p(\textbf{x}|y=M)$, and the U-Distribution $p(\textbf{x}|y=U)$ – with Zero labeled data – is the key to achieve high-quality predictions.

Let $\theta_{M}$ (resp. $\theta_{U}$) denote the parameters of the M-Distribution (resp. U-Distribution). Different choices of $\theta_{M}$ and $\theta_{U}$ correspond to different generative models. We choose to use Gaussian distributions for both the M- and the U-Distribution, as the Gaussian distribution is known to be the default distribution used in various areas to represent real-valued random variables with unknown distributions (lyon2013normal, ). In our case, the two distributions would be multi-dimensional Gaussian distributions parameterized by a mean vector and a co-variance matrix $\theta_{C}=\{\mu_{C},\Sigma_{C}\}$, where $C\in\{M,U\}$.

This reduces the generative model to the Gaussian Mixture Model (GMM) with two components, and all parameters $\{\pi_{M},\mu_{C},\Sigma_{C}\},C\in\{M,U\}$ can then be learned by maximizing the data likelihood via an expectation-maximization algorithm without any labeled data (dempster1977maximum, ). However, using the naive GMM as the generative model for ER produces inferior results, since it fails to recognize one important characteristic of the ER problem, namely, the number of matches is usually a tiny fraction of the total number of tuple pairs. The lack of matching pairs makes learning $\theta_{M}$ particularly difficult.

Example 1.1.

In the fodors-zagats dataset, we have 112 matches in the ground truth, and we have seven attributes. An out-of-box invocation of the open-source Magellan package (konda2016magellan, ) generated 68 features for those seven attributes, which means we have 2346 ($=68+68*67/2$) parameters in $\Sigma_{M}$. Using a small number of examples (e.g., 112) to estimate a large co-variance matrix (e.g., 2346 parameters) causes inaccurate estimates (Dempster1972Mar, ; Velasco, ).

In Section 3, we show how existing approaches to reduce the number of parameters in the naive GMM is not suitable for ER, and we will introduce ZeroER’s generative model that includes two novel and ER-specific adaptations to the naive GMM. Our generative model would only require $(4d+1)$ total number of parameters for a dataset with $d$-dimensional features.

(2) Feature Regularization. In supervised ML settings, overfitting is a well-known problem that causes an ML model to fit too closely or exactly to a particular set of data (usually the training set), and may therefore fail to fit additional data or predict future observations reliably well (usually the test set). As we were developing and testing generative models for ZeroER, we discovered a similar “overfitting” problem that causes the generative model to fit too closely or exactly to some particular features, such that other features play almost no role in making predictions.

Example 1.2.

For simplicity, let us illustrate the overfitting problem with two features in the fodors-zagats dataset. The first feature $f_{1}:city\_city\_exm$ represents whether the city attribute of a tuple pair is the same or not, and the second feature $f_{2}:phone\_phone\_jar$ represents the jaccard similarity between the phone attribute of a tuple pair. Figure 3 shows the frequency of tuple pairs taking different values of these two features using ground-truth matches and unmatches. As we can see, matches and unmatches may have the same or different city attribute; and matches usually have a much higher jaccard similarity on phone attribute than unmatches.

For ease of illustration, let us assume that $f_{1}$ and $f_{2}$ are independent (though the same overfitting occurs even if features are dependent). Therefore, the M-Distribution (similarly, the U-Distribution) can be written as $p(\textbf{x}|y=M)=p(\textbf{x}[f_{1}]|y=M)\times p(\textbf{x}[f_{2}]|y=M)$, i.e., we can fit the two features independently.

Fitting a GMM without labeled data on $f_{1}$ would give the following two components: the first component has a mean of 1.0 and a variance of 0, and the second component has a mean of 0.0 and a variance of 0, as $f_{1}$ has two clearly separated density regions. As we know matches generally have higher similarities than unmatches, we conclude that the first component corresponds to $p(\textbf{x}[f_{1}]|y=M)$, and the second component corresponds to $p(\textbf{x}[f_{1}]|y=U)$. Similarly, suppose fitting a GMM without labeled data on $f_{2}$ gives the following: $p(\textbf{x}[f_{2}]|y=M)$ has a mean of 0.9 and a variance of 0.1. $p(\textbf{x}[f_{2}]|y=U)$ has a mean of 0.6 and a variance of 0.2.

If we use the above learned distributions to make predictions, a feature vector x with $x[f_{1}]=1.0$ will be surely predicted as a match, regardless of the value of $x[f_{2}]$. This is because $p(\textbf{x}[f_{1}]|y=M)$ will have an infinite density when $x[f_{1}]=1.0$ due to its 0 variance. Therefore, $p(\textbf{x}|y=M)$ will be infinity, which gives $p(y=M|\textbf{x})=1.0$ using Section 1. Similarly, a feature vector x with $x[f_{1}]=0$ will be surely predicted as a unmatch, regardless of the value of $x[f_{2}]$.

The GMM will predict matches or unmatches solely based on $f_{1}$, and $f_{2}$ plays no role. This is problematic, as we know in the ground truth (see Figure 3), there are matches with $x[f_{1}]=0$ and unmatches with $x[f_{1}]=1$ . If the model took into account $f_{2}$ properly, then we may be able to prevent these erroneous predictions.

While the above example shows an extreme case where one feature entirely dictates the prediction, in practice, we see many features with extremely small variance that essentially dominate the computation, leaving other features to have little impact on the prediction. Note that this feature overfitting problem is caused by degenerate features, so it happens regardless of the amount of data.

Our observed feature overfitting in the extreme case, where one feature entirely dictates the prediction, is similar to the known singularity problem in pattern recognition where the determinant of a covariance matrix is zero (bishop2006pattern, ). A common solution to address the singularity problem is to add a small constant value to the diagonal entries of the covariance matrix (gmm_sklearn, ). While this avoids having infinite values in the computation, it does not address our overfitting problem and certain features may still dominate the prediction.

In Section 3.2, we propose an ER-specific adaptive regularization strategy that regularizes each feature differently, depending on the overlap between the M- and U-Distribution in each feature. Our proposed regularization strategy ensures that every feature can contribute to making predictions.

(3) Incorporating Transitivity. ER exhibits the transitivity property: if both $(t_{1},t_{2})$ and $(t_{1},t_{3})$ are matches, then $(t_{2},t_{3})$ is also a match. Intuitively, incorporating transitivity into the generative model should increase its performance, since it provides additional information.

Example 1.3.

In Figure 1, both (fd1,zg2) and (fd3, zg2) have high similarity, so a model tends to classify both as matches. In the ground truth, (fd1,zg2) is indeed a true match, while (fd3, zg2) is a false positive. We can see that fd1 and zg2 are the same cafe in a hotel, while fd3 is the dining room in that hotel. Without such domain knowledge, it is very difficult for a model to recognize that (fd3, zg2) is not a match.

However, this false positive can be detected using transitivity. Classifying (fd1,zg2) and (fd3, zg2) as matches will make (fd1, fd3) a match too through transitivity. If we know the fodors table is duplicate free (as we show later, we can leverage transitivity without assuming either input table to be duplicate free), then (fd1, fd3) cannot be a match. This means that one of (fd1,zg2) and (fd3, zg2) has to be a false positive. Since (fd1,zg2) is more similar than (fd3, zg2), it will be easy for a model to conclude that (fd3, zg2) is not a match.

The supervised approaches make predictions on each unlabeled tuple pair independently and can only address transitivity violations as a postprocessing step. In contrast, we incorporate transitivity in the model learning process, which gives a significant boost in model performance. Intuitively, transitivity serves as constraints on the labeling possibilities of all tuple pairs. Solving the “constrained optimization” problem is highly non-trivial as it is a non-convex problem with quadratic number of constraints with respect to the number of tuple pairs.

In Section 4, we introduce a novel way of incorporating transitivity in the generative model, and propose optimizations to solve it with minimal additional computation cost.

Contributions. We propose ZeroER for entity resolution using zero labeled examples with the following features:

• (1) Unsupervised: ZeroER requires minimal human input. Users only need to provide two input tables $L$ and $R$, similarity measures used to create the feature matrix, and optionally a blocking function — ZeroER is then able to determine matches and non-matches automatically with zero labeled training data.
• (2) High Quality: As ZeroER includes several innovations that exploit ER-specific properties, it produces high-quality results across several distinct domains. Specifically, we show that ZeroER i) greatly outperforms unsupervised baseline methods; and ii) achieves comparable results against supervised and active learning methods, but saves substantial human labeling efforts.
• (3) Efficient: We design an efficient iterative expectation-maximization based algorithm for learning the parameters of M- and U-distributions. We ensure that materializing our insights, including feature regularization and incorporating transitivity, do not come at the expense of computational performance.

2. Preliminaries

We formally define entity resolution in Section 2.1 and describe the generative modelling idea for ER and how to train a generative model in Section 2.2.

2.1. Entity Resolution Problem Definition

An entity is a distinct real-world object such as a customer, an organization, a publication etc. We are given two relations $T$ and $T^{\prime}$ with attributes $\{A_{1},A_{2},\ldots,A_{m}\}$. The entity resolution (ER) problem (DBLP:journals/tkde/ElmagarmidIV07, ) seeks to identify all pairs of tuples $(t,t^{\prime})$, where $t\in T,t^{\prime}\in T^{\prime}$, that refer to same real-world entity. A pair of tuples is said to be a match (denoted as M) (resp. unmatch (denoted as U) ) when they refer to the same (resp. different) real-world entity. When $T=T^{\prime}$, this is also known as data deduplication; and when $T\neq T^{\prime}$, this is also known as record linkage. Figure 1 provides an illustration where we wish to identify which pairs of records from Fodors and Zagat refer to the same restaurants.

To reduce the quadratic number of tuple pairs an ER problem has ($|T|\times|T^{\prime}|$), a blocking function ${\mathcal{B}}$ typically is used to filter out those tuple pairs that are highly unlikely to be matches (e.g., tuple pairs with different values in the state attribute will be not be compared), and obtain a candidate set $C_{s}\subseteq T\times T^{\prime}$ that is usually much smaller. Designing an effective blocking strategy is an orthogonal research problem, and many prior work has been dedicated to this (whang2009entity, ; papadakis2013meta, ; papadakis2016comparative, ). The blocking function ${\mathcal{B}}$ is an optional input to our system, and $C_{s}=T\times T^{\prime}$ if no blocking is provided.

To determine the M or U label for every tuple pair, one needs to generate similarity vectors (aka feature vectors) for every tuple pair in $C_{s}$ by applying a set of similarity functions ${\mathcal{F}}$. Given an ER task, typically, ${\mathcal{F}}$ is either provided by domain experts, or generated according to some default feature engineering strategy implemented in ER packages. ZeroER can work with any ${\mathcal{F}}$. Figure 1(c) shows a sample of features generated by the open-source Magellan package(konda2016magellan, ).

Formal Problem Definition. Given two relations $T$ and $T^{\prime}$, a set of similarity functions ${\mathcal{F}}$ for this dataset, and an optional blocking function ${\mathcal{B}}$, the goal of ZeroER is to assign a binary label $y\in\{M,U\}$ for every pair in $T\times T^{\prime}$ without any labeled data.

We apply ${\mathcal{B}}$ (if available) to obtain a set of $N$ tuple pairs $C_{s}\subseteq T\times T^{\prime}$, and then apply ${\mathcal{F}}$ to obtain a feature vector $\textbf{x}=(x^{1},x^{2},\ldots,x^{d})$ for every tuple pair in $C_{s}$. We use $y$ to denote the unknown label for every feature vector x.

2.2. Generative Modelling for ER

As discussed, we propose to solve the ER problem using generative modelling in the absence of labeled examples. Specifically, we consider the features and label $(\textbf{x},y)$ of a tuple pair to be generated as follows:

1. (1)

Generate the value for $y$ (M or U) based on the Bernoulli distribution parameterized by $\pi_{M}$. Intuitively, the process tosses a coin that comes heads with probability $\pi_{M}$. If it comes heads, it chooses $y=M$, else $y=U$. 2. (2)

Generate the feature vector $\bf{x}$ from the selected distribution. For example, if $y=M$, then x is sampled according to the M-Distribution $p(\textbf{x}|y=M)$, parameterized by $\theta_{M}$; else x is sampled according to the U-Distribution $p(\textbf{x}|y=U)$, parameterized by $\theta_{U}$.

The generative model is governed by its set of parameters $\Theta=\{\theta_{M},\theta_{U},\pi_{M}\}$. If we can learn $\Theta$, then we can classify any tuple pair based on its similarity vector x. Specifically, the classification problem is to determine whether $p(y=M|\textbf{x})>0.5$. In supervised learning, a functional mapping between the feature space and label space is learned using labeled examples, which directly gives $p(y=M|\textbf{x})$. In ZeroER, instead of learning $p(y=M|\textbf{x})$ directly, we aim to learn the prior probability $p(y=M)$, the M-Distribution $p(\textbf{x}|y=M)$, and the U-Distribution $p(\textbf{x}|y=U)$, which we can use to compute $p(y=M|\textbf{x})$ via  Section 1.

Learning Parameters of Generative Model. Given $N=|C_{s}|$ tuple pairs $(\textbf{x}_{i},y_{i})$, $i\in[1,N]$, where $\textbf{x}_{i}$ is observed and $y_{i}$ is unknown, a common way to estimate $\Theta$ is by maximizing the log data likelihood function (the log is taken for computational convenience):

[TABLE]

where $\mathbbm{1}_{.}$ is the identity function that evaluates to 1 if the condition is true and 0 otherwise; and $p(\textbf{x}_{i}|\theta_{C})$ is short for $p(\textbf{x}_{i}|y_{i}=C)$ parameterized by $\theta_{C}$.

Since $y_{i}$ is unknown, Section 2.2 cannot be optimized directly. The EM algorithm is the canonical algorithm to use in the case of unobserved variables (dempster1977maximum, ). Each iteration of the EM algorithm consists of two steps: an Expectation (E)-step and a Maximization (M)-step. Intuitively, the E-step determines what is the (soft) class assignment $y_{i}$ for every tuple pair based on the parameter estimates from last iteration $\Theta^{t-1}$. In other words, E-step computes the posterior probability $\gamma_{i,M}=p(y_{i}=M|\textbf{x}_{i},\Theta^{t-1})$. The M-step takes the new soft class assignments and re-estimates all parameters $\Theta^{t}$. Formally, the two steps are as follows:

1. (1)

E Step. Given the parameter estimates from the previous iteration $\Theta^{t-1}$, compute the posterior probabilities:

[TABLE] 2. (2)

**M Step.**Given the new soft class assignments as defined by $\gamma_{i,M}^{t}$, re-estimate $\Theta$ by maximizing the following expected log likelihood function:

[TABLE]

In other words, $\Theta^{t}=\text{arg}\max_{\Theta}\mathbb{E}\{L(\Theta)\}$.

GMM for ER. The generative model becomes the Gaussian Mixture Model (GMM) with two mixture components when choose the M and U distribution ($p(\textbf{x}|y=M)$ and $p(\textbf{x}|y=U)$) to be Gaussian. Gaussian distribution often serves as an effective default distribution for numerical random variables whose distributions are not known (lyon2013normal, ). Furthermore, there exist closed-form solutions for estimating the parameters of a Gaussian distribution given a set of data points. Under GMM, the parameters for M-distribution and U-distribution are $\theta_{C}=\{\mu_{C},\Sigma_{C}\}$, where $C\in\{M,U\}$, $\mu_{C}$ is the mean vector, and $\Sigma_{C}$ is the covariance matrix.

The EM algorithm can now be instantiated with the Gaussian PDF $p(\textbf{x}_{i}|\theta_{C})=\frac{1}{(2\pi)^{d/2}}\frac{1}{\text{det}(\Sigma_{C})^{1/2}}\exp\{-\frac{1}{2}(\textbf{x}_{i}-\mu_{C})^{T}\Sigma_{C}^{-1}(\textbf{x}_{i}-\mu_{C})\}$. The E-step can be directly calculated. The M-step has a closed-form solution (bishop2006pattern, ) as follows:

[TABLE]

where $C\in\{M,U\}$. In other words, $\mu_{C}$ and $\Sigma_{C}$ are assigned to be the weighted sample mean $\bar{\textbf{x}}_{C}$ and weighted sample covariance $S_{C}$ respectively in the M-step.

3. The ZeroER Generative Model

GMM as the generative model for ER described in Section 2 is a promising start. However, as we shall show, blindly applying it for ER produces sub-optimal results. The key issue is that GMM is not adapted to handle properties unique to ER, which we address next.

3.1. Data Deficiency

In a typical ER dataset, the number of matches is dramatically less than the number of unmatches by many orders of magnitude. This impacts the accuracy of parameter estimation for the generative model. Specifically, the number of parameters to be learned for the covariance matrix $\Sigma_{M}$ is ${d\choose 2}$ under GMM. Recall from Section 1 that for many datasets such as Fodors-Zagat, the value of ${d\choose 2}$ can even be higher than the number of matches, which would lead to an inferior estimate of $\Sigma_{M}$. Specifically, this would cause a large systematic distortion on the eigenstructure of $\Sigma_{M}$ (Dempster1972Mar, ; Velasco, ), and hence affecting the accuracy of the M-Distribution.

The existing approaches. Existing approaches for tackling data deficiency makes simplifying assumptions to reduce the number of parameters. As provided in the well-known sklearn package (gmm_sklearn, ), the two most common approaches are (1) assuming feature independence,i.e. $\Sigma_{M}$( and also $\Sigma_{U}$) is diagonal (non-diagonal entries are 0). (2) assuming the covariance matrix can be shared across all components, i.e. $\Sigma_{M}=\Sigma_{U}$. While these two approaches reduce the number of parameters significantly, as we shall show next and also in experiments, they are unsuitable for ER. We propose two ER-specific ways to reduce the number of parameters next.

Feature grouping. Naively assuming feature independence ignores the ER feature engineering process where multiple features may be created for each aligned attribute. Clearly, each of these features are dependent on each other. Consider Figure 4(a) that shows the heat map of the correlation matrix of all features for ground-truth matches from the Fodors Zagats dataset (the heat map for unmatches is similar). We can clearly see that some blocks have higher values while other values are closer to 0. Not surprisingly, each block corresponds to the set of features generated by the same attribute. This suggests a natural modification to naive GMM: (1) features generated from the same attribute are dependent; and (2) * features generated by different attributes are independent*.

Conceptually, the covariance matrix $\Sigma_{C}$ is now a block diagonal matrix where each block corresponds to the covariance matrix of the features obtained from the same attribute, as shown in Figure 4(b), where $C\in\{M,U\}$ and $\Sigma_{C}^{g}$ is the covariance matrix for features of the $g$-th attribute. This results in a dramatically reduced number of parameters.

Correlation sharing. The traditional approach for parameter sharing in GMM is to assume that covariance values are the same for both M and U distributions,i.e. $\Sigma_{M}=\Sigma_{U}$. To empirically verify if this can be used in ER, for every dataset, we calculate the sample covariance matrix for matches $S_{M}$ and unmatches $S_{U}$ using the ground-truth, and we calculate the cosine similarity between $S_{M}$ and $S_{U}$ by flattening both matrices to vectors. If $\Sigma_{M}=\Sigma_{U}$, one would expect cosine($S_{M}$,$S_{U}$) is close to 1. As shown in the first row in Table 1, cosine($S_{M}$,$S_{U}$) deviates a lot from 1, which suggests that $\Sigma_{M}=\Sigma_{U}$ is not a valid assumption for ER.

Instead of naively sharing the entire covariance matrix (like prior approaches), we decompose the covariance matrix and then share only the part that is consistent over M and U. Specifically, we decompose $\Sigma_{C}$ where $C\in\{M,U\}$ based on the well-known relationship between covariance and Pearson correlation of two random variables $A$ and $B$: $\text{correlation}(A,B)=\frac{\text{covariance}(A,B)}{\sigma_{A}\sigma_{B}}$, where $\sigma_{A}$ and $\sigma_{B}$ are the standard deviation of $A$ and $B$, respectively. Correlation can be seen as a normalized measure of covariance – while $\text{covariance}(A,B)\in[-\infty,\infty]$, $\text{correlation}(A,B)\in[-1,1]$. We decompose $\Sigma_{C}$ ($C\in\{M,U\}$) as follows:

[TABLE]

where $\Lambda_{C}$ is a diagonal matrix with $\Lambda_{C}[j,j]$ represents the standard deviation of feature $j$ in class $C$, and $R_{C}$ is the Pearson correlation matrix of pairs of features in class $C$.

Our key observation is that, in the ER context, the Pearson correlation matrices $R_{M}$ and $R_{U}$ should be very similar. This is because features in a same group are obtained by applying different similarity functions on the same attribute, so the Pearson correlation between two features reflects the correlation of their corresponding similarity functions on the same attribute, regardless of matches or unmatches.

To verify our intuition, we compute the cosine similarity between $R_{M}$ and $R_{U}$ using ground-truth matches and unmatches. As shown in the second row in Table 1, $cosine(R_{M},R_{U})$ is close to 1 consistently across all datasets. This ER specific property allows to rewrite Equation 6 as:

[TABLE]

where $R$ is the shared correlation matrix. Since $R$ is the same for both classes, we can estimate it using the entire dataset in a preprocessing step and completely eliminate it from the set of parameters $\Theta$.

Parameters in the ZeroER generative model. After feature grouping and correlation sharing, the generative model for ZeroER is parameterized by $\Theta=\{\pi_{M},\Lambda_{M},\Lambda_{U},\mu_{M},\mu_{U}\}$, where $\Lambda_{M}$ (resp. $\Lambda_{U}$) is a diagonal matrix and $\Lambda_{M}[j,j]$ (resp. $\Lambda_{U}[j,j]$) is the standard deviation of the $j$th feature of class M (resp. class U). Therefore, we have a total number of $4d+1$ parameters, a significant reduction from $d^{2}+3d+1$ parameters of the naive GMM.

3.2. Feature Regularization

Another unique challenge of ER is that many features can have extremely small variance and can dominate the computation, effectively rendering other features to have little impact on the predictions. In the extreme case, as shown in Example 1.2, a feature with 0 variance in any component $C\in\{M,U\}$ will make $\det(\Sigma_{C})=0$ (determinant of the covariance matrix), and that feature will solely determine the prediction, known as the singularity problem (bishop2006pattern, ).

Existing Approach: Uniform Regularization. The traditional approach for addressing the singularity problem is to add a small constant $\kappa$ to the diagonal entries of $\Sigma_{C}$, i.e., the variance of every feature. This is known formally as the uniform/Tikhonov regularization (Duchi_2008, ; Honorio2013Jul, ), in which each feature is regularized uniformly. This approach is widely used including in the popular sklearn package (gmm_sklearn, ). While this uniform regularization avoids the singularity problem, i.e., having one feature dictating the predictions, it still does not address the overfitting problem, i.e. some features have much more influence than others. In addition, a constant $\kappa$ that works for one feature might be unsuitable for another.

Example 3.1.

Consider two features $f_{1}$ in Figure 5(a1) and $f_{2}$ in Figure 5(a2) that suffer from the overfitting problem. A $\kappa$ is chosen to appropriately regularize $f_{1}$ is shown in Figure 5(b1). The two distributions are now well separated, do not have extremely small variances and $f_{1}$ could be used for making predictions. However, applying the same $\kappa$ to $f_{2}$ results in Figure 5(b2), which is clearly an inferior fit. There is too much overlap between the M-distribution and the U-distribution after regularization. This undermines the model’s ability to distinguish matches and unmatches.

Our Solution: Adaptive Regularization. Before giving our solution, we first examine how uniform regularization works in principle. Regularization can be seen as adding an “punishing” term to the objective function. Formally, the uniform regularization modifies the expected data likelihood objective function in the M-Step (c.f. Equation 4) as:

[TABLE]

where $K=\kappa I$ is a diagonal matrix acting as regularization parameter; $\text{tr}()$ denotes the trace operation on a matrix – the sum of all diagonal elements of the matrix; $N_{M}$ and $N_{U}$ ensure the regularization term is “normalized” to the amount of data $N$. Without it, the first term will dominate when $N$ is large. Intuitively, this regularization term punishes the variances of M and U being small.

To maximize Equation 8, the optimal values of $\mu_{C}$ and $\pi_{C}$ are still given by Equation 5 but the optimal $\Sigma_{C}$ is now:

[TABLE]

In other words, designing a regularization strategy is essentially about designing the diagonal regularization matrix $K$. In uniform regularization, $K$ is chosen to be $K=\kappa I$, so Equation 9 adds a number $\kappa$ on every diagonal entry of the covariance matrix. As shown in Example 3.1, using a too large $\kappa$ for feature $f_{2}$ causes much overlap of the M and U distributions, rendering $f_{2}$ ineffective in making predictions.

A good regularization needs to meet two goals: (1) the relative influences of dominating features are decreased, so that all features can have a chance to contribute to making predictions; and (2) the more influential features before regularization should still be more influential after regularization, so as not to decrease the model’s predictive capabilities. Intuitively, the influence of a feature can be measured by the overlap between its M-Distribution and U-Distribution — the smaller the overlap, the more influential a feature is. We propose to design a diagonal regularization matrix $K=diag(\kappa_{1},\kappa_{2},\ldots,\kappa_{d})$ such that all features have the same amount of overlap increase, which would achieve the above two goals. To see this, consider a hypothetical scenario where features $f_{3}$ and $f_{4}$ have overlaps of $0.001$ and $0.3$, respectively, before regularization, so $f_{3}$ is dominating $f_{4}$ in making predictions. After we add the same overlap, say 0.2, $f_{3}$ and $f_{4}$ now have overlaps of $0.201$ and $0.5$, respectively. Clearly, $f_{3}$ is still more influential than $f_{4}$, but the relative influences of $f_{3}$ is decreased significantly (e.g., $\frac{0.3}{0.001}\gg\frac{0.5}{0.201}$).

Specifically, we use Bhattacharyya coefficient (BC) to measure the overlap, as it is a widely accepted measure of the overlap of two distribution and offers a tight upper-bound to Bayes error (bhattacharyya, ), the error rate of a optimal classifier on examples generated by the two distributions. The Bhattacharyya coefficient of the M and U distribution on the $j$th feature dimension is as follows (bay_coeff, ):

[TABLE]

Let $BC_{j}$ denote the BC coefficient of feature $j$ before regularization, and $BC_{j}^{\prime}$ denote the BC coefficient of feature $j$ after regularization, i.e. after adding $\kappa_{j}$ to the variance of feature $j$ ($\Sigma_{C}[j,j],C\in\{M,U\}$). For every feature $j$, we would like to design $\kappa_{j}$ such that $BC_{j}^{\prime}-BC_{j}$ is the same for all features. Let $k^{\prime}\in[0,1]$ be the regularization parameter that denotes the constant amount of increase of BC in all features. Then we can compute $k_{j}$ by solving the following equation:

[TABLE]

Equation 11 has only one unknown variable $k_{j}$ and can be solved efficiently with the newton raphson method (Weisstein2019Oct, ).

Example 3.2.

Continuing with the previous example on regularizing $f_{1}$ and $f_{2}$. Using our adaptive regularization strategy, $f_{1}$ is fitted in Figure 5(c1) and $f_{2}$ is fitted in Figure 5(c2). As we can see, both features are now well separated and well spread out to avoid the overfitting problem.

3.3. ZeroER Algorithm So Far

We now present the algorithm of ZeroER without transitivity in Algorithm 1. As we can see, the updates to the parameters $\Theta$ happen in the M-Step (Lines 1 to 1), and the E-Step re-estimates the posterior probability of every tuple pair (Line 1). EM algorithm requires an initialization of posterior probabilities $\gamma_{i,C}$ (Line 1). To do this, we first use a min-max scaler to normalize every feature into $[0,1]$. We set $\gamma_{i,M}=1$ (hence $\gamma_{i,U}=0$) if $||\textbf{x}_{i}||>\epsilon$; otherwise, $\gamma_{i,M}=0$. We choose 0.5 as the default value for $\epsilon$, and show experimentally that ZeroER is robust to the choice of $\epsilon$.

The EM algorithm also requires a termination condition (Line 1). The EM iteration is terminated when the difference of Equation 4 between two consecutive iterations is less than a threshold ($10^{-5}$). We also set a limit the number of EM iterations to 200, a common practice also used in popular ML packages such as sklearn (gmm_sklearn, ). When EM is terminated due to the limit of the maximum number of iterations (instead of likelihood convergence), we average the likelihood results from the latest 20 iterations.

4. Incorporating Transitivity

Transitivity constraint stipulates that if tuple pairs $(t_{1},t_{2})$ and $(t_{1},t_{3})$ are matches, then $(t_{2},t_{3})$ must be a match (DBLP:journals/pvldb/GetoorM12, ). While one can enforce transitivity as a postprocessing step, incorporating transitivity into the ER algorithm achieves better performance, as we will verify empirically.

4.1. Transitivity as Posterior Constraint

Let $\gamma_{i,j,M}$ denote the posterior probability of a tuple pair $(t_{i},t_{j})$ being a match, namely $\gamma_{i,j,M}=P(y_{i,j}=M|\textbf{x}_{i,j})$. Note that when we write $\gamma_{i,j,M}$, the two subscripts $i,j$ are used to denote a tuple pair $(t_{i},t_{j})$; and when we write $\gamma_{i,M}$ (as used in previous sections), the one subscript $i$ is used to denote the $i^{th}$ tuple pair.

Consider three tuple pairs $(t_{1},t_{2})$, $(t_{1},t_{3})$, and $(t_{2},t_{3})$. Transitivity property (DBLP:journals/pvldb/GetoorM12, ) states that if both $(t_{1},t_{2})$ and $(t_{1},t_{3})$ are matches, then $(t_{2},t_{3})$ must be match. However, it is possible that $(t_{2},t_{3})$ is a match, but not both of $(t_{1},t_{2})$ and $(t_{1},t_{3})$. We capture this observation as a probabilistic inequality that needs to be satisfied:

[TABLE]

Equation 12 secures the transitivity property. Consider a deterministic scenario that $(t_{1},t_{2})$ and $(t_{1},t_{3})$ are known to be matches so that $\gamma_{1,2,M}=\gamma_{1,3,M}=1$. By Equation 12 we have $\gamma_{2,3,M}\geq 1$, so $(t_{2},t_{3})$ must also be a match. Now consider a probabilistic scenario that $\gamma_{1,2,M}=0.7$ and $\gamma_{1,3,M}=0.6$, which means in $70\%$ of the cases $(t_{1},t_{2})$ is a match and in $60\%$ of the cases $(t_{1},t_{3})$ is a match. Transitivity occurs when $(t_{1},t_{2})$ and $(t_{1},t_{3})$ are both matches which is $70\%\times 60\%=42\%$ of the cases. Therefore, $(t_{2},t_{3})$ has at least $42\%$ chances of being a match due to transitivity, as captured by Equation 12.

Let $\bm{\gamma}$ denote the vector of posterior probabilities of being a match for all tuple pairs in $T\times T^{\prime}$. For each trio of tuples $t_{i},t_{j},t_{k}$, we can define the probabilistic constraint from Equation 12. The set of all such constraints define a feasibility set for $\bm{\gamma}$:

[TABLE]

Recall from Section 2.2, the objective function of the generative model is data likelihood function $L(\Theta)$ parameterized by $\Theta$, which is maximized via an EM algorithm. The posterior probabilities $\bm{\gamma}$ are computed based on $\Theta$ via Bayes rule (c.f. Section 1). On the surface, it seems very difficult to incorporate $Q$ in the learning process, namely, finding the best $\Theta$ that maximizes $L(\Theta)$, while ensuring the posterior probabilities $\bm{\gamma}$ computed based on $\Theta$ satisfies $Q$.

Incorporating Posterior Constraints in EM. Fortunately, this conundrum could be solved by using the free energy view of the EM algorithm. In this view, the EM algorithm is seen to optimize a different objective function, the free energy function, that treats both $\Theta$ and $\bm{\gamma}$ as its parameters. Previously, free energy based approach was proposed to develop the incremental and sparse variants of the EM algorithm (neal1998view, ). We adopt this approach as it allows us incorporate the transitivity constraints directly into the optimization process. The free energy function $F(\Theta,\bm{\gamma)}$ (neal1998view, ; jordan2004introduction, ) is defined as:

[TABLE]

It turns out $F(\Theta,\bm{\gamma})$ can be optimized the exact same way as $L(\Theta)$ using the same EM algorithm, with a different view of the E-Step and the M-Step (neal1998view, ). Specifically, the E-Step is now seen as maximizing $F(\Theta,\bm{\gamma})$ with respect to $\bm{\gamma}$ given $\Theta^{t-1}$ estimated from the previous iteration:

[TABLE]

and the M-Step is now seen as maximizing $F(\Theta,\bm{\gamma})$ with respect to $\Theta$ given $\bm{\gamma}^{t-1}$ estimated from the previous iteration:

[TABLE]

Once we adopt this free energy view of EM, the constraints in Equation 13 can be incorporated by adapting the E-step as a constrained optimization problem, namely:

[TABLE]

Lemma 4.1.

The constrained maximization problem in Equation 17 is a non-convex optimization problem.

We leave the full proof of Lemma 4.1 to the full technical report (tech_report, ). Typically, heuristic methods such as projected gradient descent and alternating minimization are used to obtain an approximate solution for the non-convex optimization (jain2017non, ; tuy1988global, ). Unfortunately, these methods involve an additional expensive iterative process at every E-step drastically increasing the overall running time. We introduce a much more efficient solution next.

4.2. Solving the Constrained Problem

Let $\bm{\gamma}^{*}$ be the optimal solution for the unconstrained optimization problem in Equation 15, which is given by Equation 3. Let $\bm{\gamma}^{**}$ be the unknown optimal solution for the constrained optimization problem in Equation 17. If $\bm{\gamma}^{*}$ already satisfies $Q$, then obviously $\bm{\gamma}^{**}=\bm{\gamma}^{*}$; otherwise, we need an efficient way of computing $\bm{\gamma}^{**}$. Though the optimization problem in Equation 17 is non-convex (due to non-convex constraints $Q$), the objective function $F(\Theta,\bm{\gamma})$ is convex with respect to $\bm{\gamma}$. Therefore, we know that the solution $\bm{\gamma}^{**}$ has to be on the boundary of $Q$ (boyd2004convex, ). Figure 6 shows different solutions in 2D, where $\bm{\gamma}^{*}$ is outside of $Q$ and $\bm{\gamma}^{**}$ is on $Q$.

As discussed, finding the exact $\bm{\gamma}^{**}$ is expensive. However, it is possible to approximate $\bm{\gamma}^{**}$ by $\bm{\gamma}^{\prime}$ on the boundary of $Q$ that can be found much more efficiently. Our intuition is that the closer the approximate solution $\bm{\gamma}^{\prime}$ is to the known optimal solution $\bm{\gamma}^{*}$ of the unconstrained problem, the better the approximation is.

The operation of finding $\bm{\gamma}^{\prime}$ based on its distance with $\bm{\gamma}^{*}$ is known as projection (jain2017non, ). Since there are many different ways to measure the ”closeness” between $\bm{\gamma}^{\prime}$ and $\bm{\gamma}^{*}$, there are many different ways of doing the projection. We propose an efficient way of projection that requires minimum changes on $\bm{\gamma}^{*}$, and at the same time, tries to maximize $F(\Theta,\bm{\gamma})$.

Handling one constraint. Consider a single constraint in $Q$: $\gamma_{i,j,M}\times\gamma_{i,k,M}\leq\gamma_{j,k,M}$. When the inequality is violated, one can adjust one of the three probabilities to make it hold: decrease $\gamma_{j,k,M}$, increase $\gamma_{i,j,M}$ or increase $\gamma_{i,k,M}$ so that $\gamma_{i,j,M}\times\gamma_{i,k,M}=\gamma_{j,k,M}$. In Figure 6, these adjustments correspond to projecting $\bm{\gamma}^{*}$ on the boundary of $Q$ along the axises to be the green or blue points. Formally, the three ways of projection along the three axis are:

[TABLE]

Therefore, given the optimal solution $\bm{\gamma}^{*}$ to Equation 15 that does not satisfy the one constraint in $Q$, we obtain three possible approximate solutions by updating each one of the three posterior probabilities as in Equation 18, and we pick the one that has the maximal $F(\Theta,\bm{\gamma})$.

Handling multiple constraints. Now we consider multiple constraints $Q=\{g_{1},g_{2},...\}$. A natural approach is to do the projection in Equation 18 for each of the constraints. However, a probability $\gamma_{i,j,M}$ might get involved in several constraints. For example, $\gamma_{i,j,M}$ is involved in two constraints $\{g_{1},g_{2}\}$, specifically the following two cases can happen:

1. The projection by Equation 18 in constraint $g_{1}$ has increased/decreased $\gamma_{i,j,M}$ to $\gamma_{i,j,M}^{\prime}$, and the projection in the current constraint $g_{2}$ requires $\gamma_{i,j,M}^{\prime}$ to be decreased/increased, which would make $g_{1}$ unsatisfied. In this case, we adopt a greedy approach: When the best projection axis in Equation 18 causes conflicts with a previous constraint, we project along the second best axis. If it causes conflicts again we project along the third axis and if conflicts happen again we perform no projection on this constraint.
2. Constraint $g_{1}$ increased/decreased $\gamma_{i,j,M}$ to $\gamma_{i,j,M}^{\prime}$. After adjusting $\gamma_{i,j,M}$ to be $\gamma_{i,j,M}^{\prime}$, constraint $g_{2}$ also becomes satisfied. Or, constraint $g_{2}$ requires $\gamma_{i,j,M}^{\prime}$ to be increased/decreased further. In this case, we just increase/decrease $\gamma_{i,j,M}^{\prime}$ further.

Furthermore, there are two cases when a probability $\gamma_{i,j,M}$ involved in the constraints doesn’t exist in the posterior vector $\bm{\gamma}^{*}$. First, the corresponding tuple pair $(t_{i},t_{j})$ was excluded by blocking; in this case, we assume $\gamma_{i,j,M}=0$. Second, $\gamma_{i,j,M}$ is not in $\bm{\gamma}^{*}$ when $t_{i}$ and $t_{j}$ are from the same table, as $C_{s}$ only contains cross-table tuples pairs. This is not a problem when $T=T^{\prime}$ because $(t_{i},t_{j})$ is a cross-table tuple pair at the same time. We handle the case when $T\neq T^{\prime}$ in Section 4.3.

Reducing the number of constraints. The efficiency of our approach is reliant on the number of constraints that are checked in each iteration, which is cubic w.r.t. the number of tuples. However, it is possible to prune most of these constraints. Specifically, transitivity property is only useful for tuple pairs that are predicted to be matches. Since the number of matches are orders of magnitude smaller than unmatches, the number of constraints also reduce significantly. Specifically, we only need to consider the following reduced set of constraints:

[TABLE]

4.3. Transitivity Across Two Tables

Incorporating transitivity in the general scenario when $T\neq T^{\prime}$ is more involved. In Equation 12, the three involved tuple pairs are $(t_{1},t_{2})$, $(t_{1},t_{3})$, and $(t_{2},t_{3})$; two of the three tuples $t_{1},t_{2},t_{3}$ must come from the same table, and the third tuple must come from the other table. Without loss of generality, let us assume $t_{2},t_{3}$ are from the same table. Using one generative model for $T\times T^{\prime}$ discussed before only gives the values of $\gamma_{1,2,M}$ and $\gamma_{1,3,M}$ but not $\gamma_{2,3,M}$. If we know both $T$ and $T^{\prime}$ are duplicate-free, we can set $\gamma_{2,3,M}=0$; however, we make no such assumption in this work.

One simple way to be able to compute the posterior probabilities of tuple pairs in the same table is to use the same generative model parameterized by $\Theta$, and include in the data likelihood function $L(\Theta)$ (Section 2.2) not only the $N$ tuple pairs in $T\times T^{\prime}$, but also the $N_{l}$ tuple pairs in $T\times T$ and the $N_{r}$ tuple pairs in $T^{\prime}\times T^{\prime}$. However, this approach produces inferior results primarily because the distribution of similarities vectors for tuple pairs in $T\times T^{\prime}$ is quite different from those in $T\times T$ or in $T^{\prime}\times T^{\prime}$. For example, as shown in Figure 1, the phone area code is separated by “/” in the fodors table while by “-” in the zagats table, and city name “los angeles” is written with full name in fodors while in zagats it is abbreviated as “la”.

Given the above observation, we propose to use a generative model with three sets of parameters: the original set $\Theta$ for capturing similarity vectors of tuple pairs in $T\times T^{\prime}$, and two new sets $\Theta_{l}$ and $\Theta_{r}$ for capturing similarity vectors of tuple pairs in $T\times T$ and $T^{\prime}\times T^{\prime}$, respectively. The new data likelihood function becomes:

[TABLE]

Section 4.3 is essentially the sum of Section 2.2 with three different set of parameters:

[TABLE]

Similarly, we can view the data likelihood function as the new free energy function that treats $\bm{\gamma}_{l}$, $\bm{\gamma}_{r}$, and $\bm{\gamma}$ as parameters:

[TABLE]

where $F(\Theta_{l},\bm{\gamma}_{l})$, $F(\Theta_{r},\bm{\gamma}_{r})$ and $F(\Theta,\bm{\gamma})$ are the three free energy functions for the three types of similarity vectors.

Note that we still have one generative model with three sets of parameters, instead of three independent generative models, as the three sets of parameters are linked by transitivity constraints. Algorithm 2 describes the final ZeroER procedure incorporating transitivity. As we can see, the majority of the procedure is about running the corresponding part in Algorithm 1 three times for $T\times T^{\prime}$, $T\times T$, and $T^{\prime}\times T^{\prime}$, including the initialization, the M-Step, and the updating posterior probabilities part of the E-Step. The only major change is in Line 2 that resolves transitivity violations once we have updated posterior probabilities using the method described in Section 4.2.

5. Experiments

We conduct an extensive set of experiments to evaluate the efficacy of ZeroER along three dimensions:

• •

Feasibility and Performance of ZeroER (Section 5.2) Is it possible for an unsupervised method to achieve performance comparable to supervised ML algorithms? How does it compare with existing unsupervised methods?

• •

Ablation Analysis (Section 5.3). How does our innovations (generative modelling, feature regularization, and incorporating transitivity) in ZeroER contribute to its accuracy?

• •

Sensitivity Analysis (Section 5.4). Is ZeroER sensitive to the size of the dataset, the regularization hyperparameter, its initialization, the set of features used, and the strength of the blocking function used?

5.1. Experimental Setup

Hardware and Platform. All our experiments were performed on a machine with a 2.20GHz Intel Xeon(R) Gold 5120 CPU, a Tesla K80 GPU and with 96GB 2666MHz RAM.

Datasets. We focus on the ER task of structured datasets. We conducted extensive experiments on five structured datasets from three diverse domains including publication, e-commerce and restaurants. Table 2 provides statistics of these datasets. All are popular benchmark datasets extensively used in prior ER work.

Algorithms Evaluated. We compare ZeroER against 4 supervised methods (1-4) and 5 unsupervised methods (5-9), and 1 active learning method (10). The ten algorithms are:

1. (1)

Logistic Regression (LR): This is a typical linear classifier. We use 5-fold cross validation to tune the $\ell_{2}$ regularization parameter. 2. (2)

Random Forest (RF): This is a typical tree-based classifier. The number of trees is set as 100 and the minimum number of samples required to be at a leaf node is tuned by a 5-fold cross validation to avoid overfitting. 3. (3)

Multi-layer Perceptron (MLP): This is a typical deep learning classifier. We use two hidden layers with 50 and 10 hidden units and tuned $\ell_{2}$ regularization parameter by 5-fold cross validation. 4. (4)

DeepMatcher (DM): DeepMatcher (anhaisigmod2018, ) with hybrid attribute summarization is the state-of-the-art deep learning method for entity resolution. We use the open-source implementation (anhaidgroup2019Dec, ) from the authors. Hyperparameters are tuned by grid search and a validation set is used to select the best model snapshot among all epochs to prevent overfitting (anhaisigmod2018, ). 5. (5)

K-Means (KM-SK): This baseline applies the K-Means algorithm from Scikit-Learn with $K=2$. If the features vectors for matches and unmatches are very different, then this method would provide good results. 6. (6)

K-Means (KM-RL): This is an improved baseline from (RecordLinkageGH, ) that is calibrated for two-cluster ER task. Traditional K-Means often fails when the sizes of two clusters are very uneven (KMeansIssues, ) which is often the case in ER. This algorithm tackles the class imbalance through class weighting so that matches get a higher weight than unmatches. 7. (7)

GMM: This applies the naive Gaussian Mixture Model from scikit-learn with $2$ components. 8. (8)

ECM: The Fellegi-Sunter (FS) model (fellegi1969theory, ) is a seminal approach for probabilistic unsupervised ER that uses binary features and assumes feature independence. We used an improved implementation from (RecordLinkageGH, ; de2015probabilistic, ) that provides better results than the initial FS model. This approach implements a expectation conditional maximization algorithm that relaxes the simplistic feature independence assumption from FS. 9. (9)

PPjoin: This is a similarity-join method that employs filtering techniques to improve computational efficiency (xiao2011efficient, ). Since PPJoin is a single-attribute joining algorithm, we apply PPJoin by concatenating all attributes. PPJoin implemented and evaluated (xiao2011efficient, ) optimized version of two similarity functions (Jaccard and Cosine). PPjoin also requires a threshold to be set. For each dataset, we search the threshold from 0 to 1 by a step size of 0.2 and try both similarity function and report the best result (denoted by PP∗). 10. (10)

Active learning based Random forest (AL-RF): We use the implementation from modAL (modAL2018, ) and use the default query strategy (uncertainty sampling).

Setups for Various Algorithms. In this work, we treat feature engineering as a black-box, the default set of features for each dataset is generated by Magellan (konda2016magellan, ), which are used by all methods except DM that uses embedding features and PPjoin that uses its few supported similarity functions. Under the hood, Magellan infers a type for each aligned attribute, and applies a set of pre-defined similarity functions for each type to generate features. All possible attribute types and the similarity functions considered for each attribute type can be found at (py_em_doc, ). We also design a default blocking strategy for each dataset based on its most informative features (e.g., title) using locality sensitive hashing; the same blocking is again employed by all compared methods. For all methods that need a seed, the reported results are the average results of ten runs. We will conduct sensitivity analysis using different features and blocking strategies in Section 5.4.

We use the sklearn (scikit-learn, ) implementation for LR, RF, and MLP. We randomly split each dataset to training and test set by 50%-50%. Note that using 50% of the data as training data is very generous as in practice the amount of labeled data available is much smaller. The match entries in the training set are over-sampled as is typically done in training supervised ML methods in the presence of class imbalance. For DM, we hold out $\frac{1}{3}$ of the training set as validation set. For all unsupervised methods, we use the whole dataset for fitting without train-test split. For active learning, it starts with 10 random examples and queries one example at every learning iteration and is terminated once it has queried 50% of the matches or 50% of all examples; We evaluate the performance on the remaining examples. By default, we set the feature regularization parameter $\kappa^{\prime}$ for ZeroER to $1\%$; we set the initialization threshold $\epsilon$ to be $0.5$; We evaluate the sensitivity of ZeroER to these parameters in Section 5.4.

Performance Measures. We used F-score as the performance measure as ER is a task with unbalanced labels.

5.2. ZeroER Performance

Overall comparison. Table 3 reports the results.

• •

ZeroER vs unsupervised methods: As we can see, though ZeroER builds upon GMM, ZeroER significantly outperforms GMM. ECM is simply not competitive as it binarizes all features and uses Bernoulli mixture model, which loses information. Out of the two K-Means clustering algorithms (KM-RL and KM-SK), KM-RL is obviously better as it addresses the cluster imbalance problem observed in ER tasks. ZeroER is on average $11\%$ better than PP∗(PPjoin with the best configuration obtained using the ground-truth) on every dataset. Note that in practice it is not possible to arrive at the best configuration for PPJoin without sufficient labeled data. We also observed that the performance of PPjoin is very sensitive to the threshold, and its F-score can decrease by as large as $0.67$ with a $0.2$ change in the threshold. Overall, ZeroER greatly outperforms all five unsupervised methods due to the ER-specific innovations.

• •

ZeroER vs supervised methods: The performance of ZeroER is comparable to those supervised methods. This is really impressive as they use the same set of features; while supervised methods have 50% of all data as training, ZeroER is completely unsupervised. DM shows better results on AB and AG because these two datasets contain large strings. However, as shown in Table 4, DM requires more than ten thousand labels to achieve this performance.

• •

ZeroER vs active learning: Active learning is able to even outperform supervised learning. This is because we give active learning the same labeling budget as supervised learning (50% of labeled data), and active learning is able to judiciously select which 50% data to use. In practice, though, active learning budget tends to be much lower. ZeroER is much worse than active learning on DS, because ZeroER relies on a hypothesis that may be satisfied to different degrees on different datasets. The hypothesis is that the matches and unmatches can be divided into two clusters under gaussian distributions.

Overall running time comparison. Figure 7 shows that the running time of ZeroER is comparable to other methods. Active learning and DM are typically 10 to 100 times slower than other methods. Active learning will be even slower in practice because we only reported machine time and human time should also be considered in practice. The relative running time of ZeroER varies across datasets. This is because the running time of ZeroER is affected by the number of matches (Equation 19) and the time for solving the regularization parameter (Equation 11) and these two vary across different datasets. Note the reported time in Figure 7 is for matching only, and does not include the time for blocking and feature generation.

Labeling effort saved. We further investigate how much labeled data does the supervised and active learning methods need to match the performance of ZeroER. Table 4 shows the labeling efforts saved is quite substantial. Active learning in general is able to reduce the labeled examples required compared with supervised learning, though it requires human involvement as the algorithm runs. Though, DM achieves the best average performance, it requires thousands of labels. On easy datasets (FZ, DA and DS), DM can require up to 30 times more labels than traditional supervised methods.

5.3. Ablation Analysis.

We next perform a series of experiments to understand the contributions of different components of ZeroER and how do they compare with existing solutions to address the same problem. Results are summarized in Table 5. The right-most three columns are the results of replacing each of the three ZeroER innovations (for data deficiency, feature regularization and transitivity) to the naive ones respectively.

Handling data deficiency. Our method of handling data deficiency (feature grouping and sharing correlation matrix) works better than existing commonly used approaches (assuming feature independence and sharing covariance matrix) on four datasets (FZ, DS, AB and AG).

Feature regularization. We compare our adaptive regularization to uniform regularization. Since there is no magic constant that works for all features in uniform regularization (c.f. Example 3.1), we use the default regularization constant provided in the sklearn package (gmm_sklearn, ). ZeroER adaptive regularization is significantly better than uniform regularization on all datasets.

Incorporating Transitivity. We compare incorporating transitivity in a post-processing step with ZeroER’s approach of modelling it as constraints in the learning process. To make postprocessing possible, we need to assume that the left and right table are duplicate free and the matching probability of any tuple pair in the same table to be 0, i.e., $\gamma_{2,3,M}=0$ in Equation 12, and we designate the one tuple pair out of the two cross-table tuple pairs with a higher posterior probability ($\max(\gamma_{1,2,M},\gamma_{1,3,M})$) as the match. Our way of incorporating transitivity as constraints on posterior probabilities significantly produces better results on all datasets. The difference is particularly huge on the DS dataset, as the left and right tables on the DS dataset are actually not duplicate-free. ZeroER makes no such assumption.

5.4. Sensitivity Analysis

We show how ZeroER is robust to various hyperparameter settings, features used, and the blocking methods used.

Sensitivity to regularization hyperparameter. We vary the regularization parameter $\kappa^{\prime}$ to understand how it affects the results. The Bhattacharyya coefficient is in [0,1], so the regularization parameter has to be in [0,1]. When $\kappa^{\prime}=1$, the standard deviation of M and U distributions is infinity and the two distribution becomes identical. Therefore, from 0 to $10\%$ of the maximum BC value, i.e. [0,0.1], is a reasonable region for $\kappa^{\prime}$. As shown in Figure 8(a), the performance of ZeroER is fairly robust for $\kappa^{\prime}$ in [0,0.1]. Note that $\kappa^{\prime}=0$ means there is no feature regularization. As $\kappa^{\prime}$ increases, F1 score first increases (regularization helps), then becomes relatively stable for a period, and finally gradually decreases (too strong of a regularization). Regardless, $\kappa^{\prime}=0.01$ is a good and safe default choice that works well for all datasets.

Sensitivity to initialization. As shown in Figure 8(b), ZeroER is robust to initialization threshold $\epsilon$ with no changes on quality for all datasets. When $\epsilon$ = 0 or 1, (which should not be used as initialization parameter value), no data is assigned to M or U class so that EM fails to recognize two clusters.

Sensitivity & Scalability to unlabeled training data size. We demonstrate that ZeroER can produce excellent results even when trained on a subset of dataset. Specifically, we vary the amount of data (without labels) used to fit ZeroER and evaluate how it impacts ZeroER’s performance on the reminder of data. As shown in Figure 9(a), F1 score increases as the amount of unlabeled training data increases. Figure 9(a) also shows that ZeroER already gives good F1 score with only about 10% training data, which can save about 90% training time. By varying the training data size, we can also demonstrate the scalability of ZeroER. Figure 9(b) shows the running time per EM iteration is roughly linear to the amount of training data. This means ZeroER is scalable.

Sensitivity to blocking. Though we consider blocking to be orthogonal to us, we vary the aggressiveness of blocking by changing the overlapping size used in the locality sensitive hashing blocking scheme. A more aggressive blocking setting will generate less tuple pairs, but potentially at the risk of missing matches. We vary the overlapping size from the minimum value (least aggressive) that still allows the algorithm to finish within a preset time limit to the maximum value that results in zero tuple pairs. As shown in Figure 10(a), both ZeroER and RF are robust to blocking. Overall, ZeroER is comparable to RF and is better than random forest on FZ and AB regardless of the overlapping size. By increasing the overlapping size, some of the difficult examples would be excluded in blocking. Dataset AB is affected more dramatically, as it has more difficult examples excluded by blocking.

Sensitivity to features. We vary the amount (%) of features by sampling from the features generated by Magellan to see if the comparison between ZeroER and supervised methods is sensitive to the feature set used. As shown in Figure 10(b) The performance of ZeroER is robust to different (%) of features on most datasets except AG. Though on AG, both ZeroER and RF have degraded results.

6. Related Work

Entity resolution is one of the fundamental and challenging problems in data curation. A good overview of ER can be found in surveys such as (DBLP:conf/sigmod/KoudasSS06, ; DBLP:journals/tkde/ElmagarmidIV07, ; DBLP:journals/pvldb/DongN09, ; DBLP:series/synthesis/2010Naumann, ; DBLP:journals/pvldb/GetoorM12, ; herzog2007data, ; maggi2008survey, ) and tutorials (DBLP:journals/pvldb/GetoorM12, ). Previous work on ER can be broadly divided into three branches depending on how they relate to this paper: (1) identifying useful similarity functions; (2) tackling the efficiency challenges of ER; and (3) designing an algorithm to predict matches/unmatches.

A variety of similarity functions have been used for ER (DBLP:journals/tkde/ElmagarmidIV07, ), including generic ones such as edit distance, jaccard distance, and cosine similarity, as well as some domain specific ones such as Jaro distance for people names (JaroDistance, ). A comparison of different similarity functions can be found in (chandel2007benchmarking, ). ER work usually either assumes that feature engineering for an ER dataset is done by a human, or employs a default set of similarity functions. ZeroER can work with any similarity functions, and by default, uses features generated by the open-source ER package Magellan (konda2016magellan, ).

A second branch of work aims at reducing the quadratic complexity of an ER task. Some of these algorithms are specific to a similarity function, such as edit distance (gravano2001approximate, ) or jaccard distance (arasu2006efficient, ; hadjieleftheriou2008fast, ). Chaudhuri et al (chaudhuri2006primitive, ) provides an efficient similarity join operator that can work with multiple similarity functions. Another main direction, called blocking, aims to avoid comparing tuples pairs that are unlikely to be matches, leveraging techniques such as locality sensitive hashing (papadakis2016comparative, ; papadakis2013meta, ). ZeroER is orthogonal to this line of research, and takes an optional blocking function as input.

The third line of related work concerns with designing an algorithm to predict matches. Supervised ML approaches provide state-of-the-art results for ER. However they require substantial amount of training data in the form of matches and unmatches  (deeper, ; anhaisigmod2018, ; kopcke2010evaluation, ; dong2018data, ). This process is often time consuming, cumbersome and error prone. Popular approaches include binary classifiers such as Naive Bayes (Winkler99thestate, ), decision tree (DBLP:conf/vldb/ChaudhuriCGK07, ) and SVM (DBLP:conf/kdd/BilenkoM03, ). Active learning based techniques have also been proposed to reduce the amount of labeled examples (SarawagiB02, ; DBLP:dblp_conf/sigmod/ArasuGK10, ). We have compared with three representative and best-performing supervised ML models as well as an active learning based approach, and showed that ZeroER achieves comparable results with zero labeled examples. General-purpose clustering algorithms (e.g., K-Means and GMM) can be used to perform ER in an unsupervised way. As we have shown, they usually produce much inferior results. The Fellegi-Sunter (FS) model (fellegi1969theory, ) is generally regarded as the seminal work in probabilistic unsupervised ER, and was famously used for deduplicating the Census data that uses binary features and assumes feature independence (Winkler99thestate, ). Since then, specific adaptations to the FS model has been explored for specific domains, such as US homicides (sadinle2013generalized, ), traffic crashes (cryer2001investigation, ), and hospitalizations (clark2004practical, ). ZeroER can be seen as a generalization of FS model that includes three major innovations (a reduced set of parameters, feature regularization, and incorporating transitivity), which together produces a much more performant unsupervised approach that works across datasets in different domains.

7. Conclusion and Future Work

In this paper, we proposed ZeroER, an effective and efficient solution for solving entity resolution with Zero labeled examples. ZeroER provides excellent results across multiple datasets and is competitive with supervised ML approaches. This superior performance is achieved by a collection of novel techniques including generative modeling, adaptive feature regularization and incorporating transitivity. ZeroER dramatically reduces the labeling effort of domain scientists in ER tasks. We hope that ZeroER will play a vital role in the increasingly popular area of self-service data preparation. Currently, ZeroER treats feature engineering as a black box and uses features generated by Magellan. Designing automatic feature engineering solution for ER in general is an interesting future work.