Scaling Active Search using Linear Similarity Functions

TL;DR

This paper enhances the scalability of Active Search algorithms by leveraging linear similarity functions, enabling efficient processing of large datasets while maintaining competitive performance.

Contribution

It introduces modifications to an existing graph-based Active Search algorithm that significantly reduce computational complexity using linear kernels.

Findings

The modified algorithm scales as O(nr + r^2) per iteration.

The approach is competitive with existing semi-supervised methods.

The method performs well under certain data conditions.

Abstract

Active Search has become an increasingly useful tool in information retrieval problems where the goal is to discover as many target elements as possible using only limited label queries. With the advent of big data, there is a growing emphasis on the scalability of such techniques to handle very large and very complex datasets. In this paper, we consider the problem of Active Search where we are given a similarity function between data points. We look at an algorithm introduced by Wang et al. [2013] for Active Search over graphs and propose crucial modifications which allow it to scale significantly. Their approach selects points by minimizing an energy function over the graph induced by the similarity function on the data. Our modifications require the similarity function to be a dot-product between feature vectors of data points, equivalent to having a linear kernel for the adjacency matrix. With this, we are able to scale tremendously: for $n$ data points, the original algorithm runs in $O(n^2)$ time per iteration while ours runs in only $O(nr + r^2)$ given $r$-dimensional features. We also describe a simple alternate approach using a weighted-neighbor predictor which also scales well. In our experiments, we show that our method is competitive with existing semi-supervised approaches. We also briefly discuss conditions under which our algorithm performs well.

Figures

Tables

Table 1. Table 1: This table shows mean recall ± plus-or-minus \pm standard deviation at the middle and last iteration for each algorithm and dataset.

	CoverType		MNIST		Adult
	250	500	200	400	100	200
LAS	198.7 $\pm$ 32.0	377.8 $\pm$ 55.7	199.5 $\pm$ 1.0	386.4 $\pm$ 4.9	53.7 $\pm$ 11.7	116.7 $\pm$ 13.3
WNAS	188.8 $\pm$ 21.5	375.7 $\pm$ 37.9	193.7 $\pm$ 3.0	379.8 $\pm$ 7.2	46.1 $\pm$ 16.3	99.4 $\pm$ 26.4
AGR	27.2 $\pm$ 11.2	43.5 $\pm$ 11.8	192.8 $\pm$ 3.1	380.1 $\pm$ 4.0	23.1 $\pm$ 18.5	57.1 $\pm$ 39.2

Table 2. Table 2: This table shows the average positives in the top 100 unlabeled points from the f 𝑓 f -values of LAS and WNAS.

Dataset (pos%)	LAS	WNAS
Covertype (0.47%)	4.19	1.66
MNIST (1.00%)	94.25	60.68
Adult (5.00%)	27.25	17.29

Equations

$$E(f)=\frac{1}{2}\sum _{i,j}\mathcal{K}(x_i,x_j)(f(x_i)-f(x_j){)}^2$$

$$\begin{gathered} E(f)=\sum _{i\in \mathcal{L}}(y_i-f_i{)}^2{D}_{ii}+ \\ \lambda \left(w_0\sum _{i\in \mathcal{U}}(f_i-\pi {)}^2{D}_{ii}+\sum _{i,j}(f_i-f_j{)}^2{A}_{ij}\right) \end{gathered}$$

$$f^{\ast }=(I-B{D}^{-1}A{)}^{-1}(I-B)y^{\prime },$$

$$B=\left[\begin{array}{cc}\frac{\lambda }{1+\lambda }{I}_{\mathcal{L}}& 0\\ 0& \frac{1}{1+w_0}{I}_{\mathcal{U}}\end{array}\right],y^{\prime }=\left[\begin{array}{c}{y}_{\mathcal{L}}\\ \pi \end{array}\right]$$

$$I{M}_i=f_i\sum _{j\in \{U\backslash i\}}(f_j^{+}-f_j)$$

$$f=(I-R{X}^{T}X{)}^{-1}q$$

$$R=B{D}^{-1},q=(I-B)y^{\prime }$$

$$f=q+R{X}^T{K}^{-1}Xq$$

$$K=I-XR{X}^T$$

$$R^{+}=R-\gamma e_i{e}_i^T$$

$$(K^{+}{)}^{-1}=K^{-1}-\frac{\gamma (K^{-1}{x}_i)(K^{-1}{x}_i{)}^T}{1+\gamma x_i^T{K}^{-1}{x}_i}$$

$$f^{+}=q^{+}+R^{+}{X}^T(K^{+}{)}^{-1}X{q}^{+}$$

$$f_i=\frac{{\sum }_{j\in \mathcal{L}}{y}_i\cdot \mathcal{K}(x_i,x_j)}{{\sum }_{j\in \mathcal{L}}|\mathcal{K}(x_i,x_j)|}$$

$$\mathcal{K}(X_{\mathcal{U}},x_i)=X_{\mathcal{U}}^{\mathrm{T}}{x}_i$$

$$f=(D+P-A{)}^{-1}P{y}^{\prime }\text{ where }P=\left[\begin{array}{cc}\frac{1}{\lambda }{I}_{\mathcal{L}}& 0\\ 0& w_0{I}_{\mathcal{U}}\end{array}\right]D$$

$$f-\pi 1=M^{-1}P{y}^{\prime }-\pi 1=M^{-1}P(y^{\prime }-\pi 1)$$

$$M^{-1}=\left[\begin{array}{cc}{\tilde{M}}_{11}& {\tilde{M}}_{12}\\ {\tilde{M}}_{21}& {\tilde{M}}_{22}\end{array}\right]$$

$$f-\pi 1=v_P+v_N$$

$$v_P=\left[(1-\pi )\left[\begin{array}{c}{\tilde{M}}_{11}{P}_P\\ 0\end{array}\right]u_P-\pi \left[\begin{array}{c}{\tilde{M}}_{12}{P}_N\\ 0\end{array}\right]u_N\right]$$

$$v_N=\left[(1-\pi )\left[\begin{array}{c}0\\ {\tilde{M}}_{21}{P}_P\end{array}\right]u_P-\pi \left[\begin{array}{c}0\\ {\tilde{M}}_{22}{P}_N\end{array}\right]u_N\right]$$

$$E(f)=\left[\begin{matrix}f_{\mathcal{L}}\\ f_{\mathcal{U}}\\ y_{\mathcal{L}}\\ \pi\end{matrix}\right]^{T}\left[\begin{array}[]{c|c}\widetilde{D}+\lambda(D-A)&-\widetilde{D}\\ \\ \hline\cr\\ -\widetilde{D}&0\end{array}\right]\left[\begin{matrix}f_{\mathcal{L}}\\ f_{\mathcal{U}}\\ y_{\mathcal{L}}\\ \pi\end{matrix}\right],$$

$$\tilde{D}=\left[\begin{array}{cc}{D}_{\mathcal{L}}& 0\\ 0& \lambda w_0{D}_{\mathcal{U}}\end{array}\right].$$

$${\nabla }_{f}E=(\tilde{D}+\lambda (D-A))f-\tilde{D}{y}^{\prime },$$

$$B=\left[\begin{array}{cc}\frac{\lambda }{1+\lambda }{I}_{\mathcal{L}}& 0\\ 0& \frac{1}{1+w_0}{I}_{\mathcal{U}}\end{array}\right].$$

$$(A+BC{)}^{-1}=A^{-1}-A^{-1}B(I+C{A}^{-1}B{)}^{-1}C{A}^{-1}.$$

$$(A+UCV{)}^{-1}=A^{-1}-A^{-1}U(C^{-1}+V{A}^{-1}U{)}^{-1}V{A}^{-1}.$$

$$f^{+}=q^{+}+R^{+}{X}^T(K^{+}{)}^{-1}X{q}^{+}.$$

$$I{M}_i=f_i\sum _{j\in \{U\backslash i\}}(f_j^{+}-f_j)$$

$$\Delta f(i):=f^{+}-f$$

$$\Delta F=\left[\begin{array}{c}\sum _{j\in \mathcal{U}}\Delta f_j(1)\\ ⋮\\ \sum _{j\in \mathcal{U}}\Delta f_j(n)\end{array}\right],\Delta \tilde{f}=\left[\begin{array}{c}\Delta f_1(1)\\ ⋮\\ \Delta f_n(n)\end{array}\right]$$

Full text

In this paper, we consider the problem of Active Search where we are given a similarity function between data points. We look at an algorithm introduced by Wang et al. Wang et al. (2013) known as Active Search on Graphs and propose crucial modifications which allow it to scale significantly. Their approach selects points by minimizing an energy function over the graph induced by the similarity function on the data. Our modifications require the similarity function to be a dot-product between feature vectors of data points, equivalent to having a linear kernel for the adjacency matrix. With this, we are able to scale tremendously: for $n$ data points, the original algorithm runs in $O(n^{2})$ time per iteration while ours runs in only $O(nr+r^{2})$ given $r$-dimensional features.

We also describe a simple alternate approach using a weighted-neighbor predictor which also scales well. In our experiments, we show that our method is competitive with existing semi-supervised approaches. We also briefly discuss conditions under which our algorithm performs well.

††Corresponding Author: Sibi Venkatesan (sibiv@cs.cmu.edu)††Published in Proceedings of IJCAI 2017.

1 Introduction

With rapid growth of the digital world, we are often faced with the task of quickly discovering and retrieving objects of interest from a large pool of data available to us. The task of finding specific pieces of information might require more sophisticated solutions than just key-word searches. Interactive approaches like Relevance Feedback can often be more effective, where an algorithm requests a user’s feedback on its results in order to improve. Active Search is an example of such an approach: it discovers targets by asking the user for information it considers useful. With user feedback, Active Search algorithms iteratively build a model of what constitutes relevant information. This carries two potential benefits in information retrieval problems: (1) these approaches need less labeled data and (2) they can focus on building a model of only the target class. The second point is useful for problems in which we are searching for the proverbial needle in a haystack. If there are relatively few targets, it is important to focus on modeling and identifying only those points. These approaches could be effective in real-world domains like product-recommendation and drug-discovery.

In this paper, we look at the problem of Active Search given a similarity function between data points. This function induces a graph over our data, with edge-weights as the similarities between points. We consider an existing approach of Active Search on Graphs by Wang et al. Wang et al. (2013) and make key modifications which allow us to scale substantially. While the original approach looks at purely graphical data, we consider data lying in a multi-dimensional feature space. The similarity function is taken to be some kernel over features vectors. The only requirement is it is finite dimensional with an explicit kernel space representation. In other words, the similarity function can explicitly be computed as the dot-product in this space.

The original algorithm requires $O(n^{3})$ pre-computation time, $O(n^{2})$ time per iteration and $O(n^{2})$ memory for $n$ data points. Ours only requires $O(nr^{2}+r^{3})$ pre-computation time, $O(nr+r^{2})$ time per iteration and $O(nr+r^{2})$ memory for $r$-dimensional feature vectors. While the original approach is not viable for datasets larger than around 20,000 points, our algorithm comfortably handles millions.

We also describe a simple approach using weighted neighbors which also scales to large datasets. This approach uses a Nadaraya-Watson-esque estimator to propagate labels, and runs in $O(nr)$ time for initialization and each iteration.

The contribution of this paper is the following: We present non-trivial modifications to an existing Active Search approach, scaling it multiple orders of magnitude. We describe a simple alternate which also scales well. We also touch upon when our algorithm will perform well.

This paper is structured as follows. We describe the existing literature in Section 2. We formally state the problem of Active Search in Section 3. In Section 4, we describe the existing approach followed by our modifications. In Section 5, we discuss conditions for good performance. We describe our experiments and discuss results in Section 6. We conclude in Section 7, and mention related challenges and next steps.

2 Related Work

Over the past few years, there has been significant research done in semi-supervised active learning. Most of this research is driven towards learning good classifiers given a limited labeled data, as opposed to recovering target points.

Guillory et al. Guillory and Bilmes (2009) propose methods for selecting labeled vertex sets on a graph in order to predict the labels of other points. Cesa-Bianchi et al. Cesa-Bianchi et al. (2013) explore an active version of this where they consider the optimal placement of queries on a graph to make minimal mistakes on the unlabeled points.

Zhu et al. Zhu et al. (2003a) propose a method to perform semi-supervised learning on graphs. They formulate their problem in terms of a Gaussian random field on the graph, and efficiently compute the mean of the field which is characterized by a harmonic function. They extend this in Zhu et al. (2003b) to make it active: given the above graphical construction, they query points using a greedy selection scheme to minimize expected classification error. Zhu et al. Zhu and Lafferty (2005) describe a scalable method to perform inductive learning using harmonic mixtures, while preserving the benefits of graph-based semi-supervised learning.

There has also been some work on optimization-based approaches for semi-supervised classification. Melacci et al. Melacci and Belkin (2011) propose a method they call LapSVM, which builds an SVM classifier using the graphical structure of the data. Zhang et al. Zhang et al. (2009) describe the Prototype Vector Machine which solves a similar objective as above, by approximating it using “prototype” vectors which are representative points in the data. Liu et al. Liu et al. (2010) introduce an approach which also considers representative samples from the data called Anchors. They construct an “Anchor Graph”, and make predictions in the main graph based on weighted combinations of predictions on Anchors.

Ma et al. Ma et al. (2015) describe new algorithms which are related to the multi-armed bandit problem to perform Active Search on graphs. Their algorithms are based on the $\Sigma$-optimality selection criterion, which queries the point that minimizes the sum of the elements in the predictive covariance as described in Ma et al. (2013). Kushnir Kushnir (2014) also incorporate exploration vs. exploitation in their work on active transductive learning on graphs. They do this by considering random walks on a modified graph which combines the data distribution with their label hypothesis, allowing them to naturally switch from exploring to refinement.

There have also been Active Search approaches which focus on recall instead of classification. Garnett et al. Garnett et al. (2012) perform Active Search and Active Surveying using Bayesian Decision theory. Active Surveying seeks to query points to predict the prevalence of a given class.

Closely related to our work is that of Wang et al. Wang et al. (2013) where they perform Active Search on graphs. They select points by minimizing an energy function over the graph. They also emulate one-step look-ahead by a score reflecting the impact of labeling a point. Our work extends this with crucial modifications allowing us to scale to much larger data sets.

3 Problem Statement

We are given a finite set of $n$ points $X=\{x_{1},\ldots,x_{n}\}$, and their unknown labels $Y=\{y_{1},\ldots,y_{n}\}$ where $y_{i}\in\{0,1\}$. We are also given a similarity function $\mathcal{K}(\cdot,\cdot)$ between points. We consider the case where this function is linear over some explicit feature transformation $\phi$: $\mathcal{K}(x_{i},x_{j})=\phi(x_{i})^{T}\phi(x_{j})$. This is analogous to the explicit kernel-space representation of some finite-dimensional kernel. This induces a graph over the data: the edge weight between $x_{i}$ and $x_{j}$ is given by $\mathcal{K}(x_{i},x_{j})$.

Initially, we are given a small set of labeled points $\mathcal{L}_{0}$, while the remaining points are in the unlabeled set, $\mathcal{U}$. Every iteration, we query one point in $\mathcal{U}$ for its label and move it to the labeled set $\mathcal{L}$. The goal is to find as many positive points as possible after $T$ iterations, where $T$ is a fixed budget for labeling points.

4 Approach

4.1 Background: Active Search on Graphs [ASG]

We briefly describe the algorithm introduced by Wang et al. Wang et al. (2013). They interpret the data as a graph where the edge-weights between points is given by the similarity $\mathcal{K}$. Their method then uses a harmonic function $f$ to estimate the label of data points, inspired by the work done by Zhu et al. Zhu et al. (2003a). This is done by minimizing the energy:

[TABLE]

The function $f$ serves as the primary measure for querying a point to label. If $\mathcal{K}(\cdot,\cdot)$ is positive and semi-definite, the optimal solution $f^{*}$ can be interpreted intuitively through random walks on the graph: $f^{*}(x_{i})$ is the probability that a random walk starting at the point $x_{i}$ reaches a positively labeled point before a negatively labeled point. The following is a brief explanation: Here, for simplicity, we take $f^{*}$ to be the vector where $f^{*}_{i}:=f^{*}(x_{i})$. Setting the gradient of the energy to 0, we get at optimum $f^{*}=D^{-1}Af^{*}$ where $A$ and $D$ are the adjacency and diagonal degree matrices respectively. The rows of $D^{-1}A$ are exactly the transition probabilities from each node on the graph, and thus, the entire matrix can be interpreted as the transition matrix of the random walk. The interpretation of $f^{*}$ directly follows from this.

Wang et al. then describe a problem they call hub-blocking, where a negatively labeled point is the center of a hub structure connected to multiple positive but unlabeled points. Discovering another positive elsewhere in the graph will not help discover the positive unlabeled nodes in the hub, as they are blocked off by the negatively labeled hub center. To overcome this, they propose a soft-label model: every labeled point is now connected to a pseudo-node which holds the label instead. A random walk now terminates only when reaching the pseudo-node of a labeled point. A similar augmentation incorporates prior probabilities: a pseudo-node is attached to every unlabeled point and holds the prior probability of being positive. The transition probability from a point to its psuedo-node is constant across labeled or unlabeled points.

The following is the resulting energy function over $f$:

[TABLE]

where $A_{ij}=\mathcal{K}(x_{i},x_{j})$, $D_{ii}=\sum_{j}\mathcal{K}(x_{i},x_{j})$, and the regularizing constants $\lambda$ and $w_{0}$ depend on transition probabilities into pseudo-nodes. Explicitly, if $\eta$ and $\nu$ are transition probabilities into labeled and unlabeled pseudo-nodes respectively, then $\lambda=\frac{1-\eta}{\eta}$ and $w_{0}=\nu$. The minimizer of the energy function can be solved by setting the gradient to 0. We assume, without loss of generality, that the labeled and unlabeled indices are grouped together. The minimizer is111Derived in the Appendix.:

[TABLE]

[TABLE]

This solution can also be obtained by performing label propagation in the augmented graph. For simplicity of notation, $f^{*}$ will simply be denoted by $f$ moving forward.

To pick points for label queries, ASG uses a heuristic called the Impact Factor which looks at the change of $f$ values if a given unlabeled point was labeled as positive.

[TABLE]

The final selection criterion is $\arg\max_{i}f_{i}+\alpha IM_{i}$. With this, ASG iteratively queries labels and updates $f$ and $\mathit{IM}$. ASG has an $O(n^{3})$ time initialization and $O(n^{2})$ time per-iteration.

4.2 Linearized Active Search [LAS]

Here, we describe our algorithm. We now require feature vectors for our points. The similarity function is then assumed to be be linear in these features (or some explicit transformation of them). This requirement is often not too restrictive; in fact, some popular kernels can be approximated using a linear embedding into some feature space. For example, the RBF kernel can be approximated by Random Fourier Features Rahimi and Recht (2007). For simplicity, let $x_{i}$ itself represent the feature vector. The similarity between two points is then $\mathcal{K}(x_{i},x_{j})=x_{i}^{T}x_{j}$.

Here is the algorithm at a glance. At a high level, LAS is the same as ASG:

• •

Initialization: Initialize with starting label set $L_{0}$. Pre-compute relevant quantities which can be updated.

• •

In each iteration: Request the next label with a selection criterion based on $f$ and $\mathit{IM}$. Update all relevant quantities given this label.

Note: As mentioned before, ASG requires purely graphical data as input, i.e. the graph adjacency matrix. LAS works with a different class of data, which lives in some multi-dimensional feature space. A graph is induced over the data by the similarity function. If the input to ASG and LAS is the same, the results will be identical. By “the same”, we mean the adjacency matrix for ASG is the same as the one of the induced graph for LAS. In this case, $f,IM$ and the point queried will be identical at every iteration.

The pseudo-code is given in Algorithm 1. We now discuss how a linear similarity function helps us update $f$ efficiently.

4.2.1 Initialization

The adjacency matrix is $A=X^{T}X$ where $X=[x_{1}\ldots x_{n}]$, with $n$ points and $r$ features. Then, $D=diag(X^{T}X\mathbb{1})$. This gives us:

[TABLE]

[TABLE]

Using the matrix inversion lemma, we get222Derived in the Appendix.:

[TABLE]

[TABLE]

This converts an $O(n^{3})$ time matrix inverse in ASG into the $O(r^{3})$ time inverse of $K$. For large datasets, we can expect $r\ll n$. Below, we show that we only need to invert $K$ once; its inverse can be efficiently updated every iteration.

The initialization runs in $O(nr^{2}+r^{3})$ time for computing $K^{-1}$ and $O(nr^{2})$ for computing $f$. Next, we describe our efficient updates to $K$ and $f$ given a new label.

4.2.2 Updates to $f$ on receiving a new label

We have $K^{-1}=(I-XRX^{T})^{-1}$ at the previous iteration. Only one element in $R$ changes each iteration. Take superscript + to mean the updated value of a variable. We have:

[TABLE]

where $\gamma=-\left(\frac{\lambda}{1+\lambda}-\frac{1}{1+w0}\right)D_{ii}^{-1}$ and $e_{i}$ is the $i^{th}$ standard basis vector. Using the matrix inversion lemma:

[TABLE]

Only one element in $q$ changes: $q^{+}_{i}=y_{i}\dfrac{1}{1+\lambda}$. Thus, the update to $f$ can be calculated as333Updates derived in the Appendix.:

[TABLE]

This takes $O(r^{2}+rn)$ time per-iteration as it just involves cascading matrix-vector multiplications.

4.2.3 Impact Factor

LAS also includes appropriate modifications for the initialization and updates of the Impact Factor which adhere to the improved running time. We do not describe these here as they are much more involved than those above, while not being fundamentally complicated.444Derived in the Appendix. We also slightly changed the Impact Factor from ASG: we scaled $\mathit{IM}$ so that it has the same mean as the $f$ vector. This allows us to tune $\alpha$ without worrying about the magnitude of values in $\mathit{IM}$, which varies based on the dataset.

4.3 Weighted Neighbor Active Search [WNAS]

Here, we briefly describe a simple and intuitive alternate approach for query selection which also scales well with large amounts of data. This approach is similar to the Nadaraya-Watson kernel regressor:

[TABLE]

The updates for $f$ for this approach are simple. We keep track of the numerator and denominator individually for each unlabeled point. Each time we get a new labeled point $x_{i}$, we can compute its similarity to all other unlabeled points efficiently as the following vector:

[TABLE]

We can then update the numerator and denominator of all unlabeled points directly from this vector. The numerators would be updated by adding $y_{i}\mathcal{K}(X_{\mathcal{U}},x_{i})$ and the denominators would be updated by adding $|\mathcal{K}(X_{\mathcal{U}},x_{i})|$. These computations require $O(nr)$ time for initialization and iteration.

5 Analysis of Active Search

5.1 Good Similarity Functions for Active Search

How do we know if our similarity function is “good” for our problem, i.e., under what conditions will it give us a high recall rate for a given dataset? Not all similarity functions are suited to a given problem, even if they provide non-trivial information. For example, consider a similarity function which, given two animals, outputs 1 if they share the same number of legs and 0 otherwise. This similarity function will be useful to distinguish human beings from cats but not cats from dogs. But the similarity function itself is not useless.

Assume that the similarity function only takes non-negative values. This allows us to interpret them as unnormalized probabilities. $f$ can be written as555Derived in the Appendix.:

[TABLE]

Let: $M=D+P-A$. Given $M\mathbb{1}=(D-A)\mathbb{1}+P\mathbb{1}=P\mathbb{1}$, we get:

[TABLE]

M has the same sparsity structure as A, as all its off-diagonal elements are the negative of those in A. Since $M$ is a diagonally dominant symmetric matrix with non-positive off-diagonal entries, it is a Stieltjes matrix. This means that its inverse is symmetric and non-negative. Grouping indices by their class without loss of generality, we have $M^{-1}$ as

[TABLE]

This gives us:

[TABLE]

[TABLE]

[TABLE]

where $u_{P}$ and $u_{N}$ are indicator vectors of whether the points are labeled or not, for the positive and negative points respectively. We only need to look at labeled points since for any unlabeled point $x_{i}$, $(y_{i}^{\prime}-\pi)=0$. Here, $\pi$ can be interpreted as a parameter instead of the constant prior, measuring “importance” of labels: if $\pi$ is low, then we consider each received positive label as very informative and vice-versa.

Equation 7 says that if the elements in $\widetilde{M}_{12}=\widetilde{M}_{21}^{T}$ are small, then $f$ will better reflect the labels of points. But when are these off-diagonal elements small? We can show that if the cross-class similarities, or off-diagonal blocks of A, are low in a matrix-norm sense, then the same is true in $M^{-1}$:

Lemma 5.1

Let $A=A_{1}+A_{2}$ where $A_{1}$ is the block diagonal component of the similarity matrix and $A_{2}$ is the pure cross-similarity component.

If $||A_{2}||_{1}<\epsilon$, then $||\widetilde{M}_{12}||_{1}<\left(\dfrac{1}{c\cdot d_{min}}\right)^{2}\epsilon$ where $c=\min\{\frac{1}{\lambda},w_{0}\}$ and $d_{min}$ is the minimum degree in the graph.666Proved in the Appendix.

Intuitively, a bound on $||\widetilde{M}_{12}||_{1}$ bounds the between-class similarity. Lemma 5.1 then tells us that if our similarity respects the underlying label distribution, then the computed $f$ will do the same. This only gives us information within a given iteration of Active Search; it does not directly give bounds on errors when querying the highest node in $f$ every iteration. But it is a step towards understanding the relationship between the similarity function and the performance.

5.2 Comparison of ASG/LAS and WNAS

ASG (or equivalently LAS) and WNAS often have similar performance on recalling positive points. This is because, locally around the labeled points, both approaches propagate labels in a similar manner. The label confidences assigned by WNAS can also be interpreted as one step of a random-walk as follows. For each unlabeled point, consider the graph containing it, along with all labeled points. Its $f$ score is equivalent to the probability that a random walk starting from that point transitions into a positive in one step.

However, while WNAS makes use of local structure of the graph around the labeled points, it does not effectively use the global connectivity structure of the graph. The relevance of this can be seen in the swiss-roll dataset in Figure 1; where the inner blue roll is positive and the outer red roll is negative. The predictions of WNAS and ASG are similar around the labeled points, but very different away from them. The usefulness of WNAS’ $f$ score diminishes rapidly moving away from the label set, unlike for ASG.

Another note is that computing an equivalent Impact Factor for WNAS requires $O(n^{2})$ computation, since we need to compute the similarity between every pair of unlabeled points. This makes the Impact Factor computation infeasible for large datasets, unlike LAS as discussed before.

6 Experiments

We performed experiments on the following datasets: the CoverType and Adult datasets from the UCI Machine Learning Repository and MNIST.

The Covertype dataset contains multi-class data for different forest cover types. There are around 581,000 points with 54-dimensional features. We take the class with the lowest prevalence of $0.47\%$ as positive. The data is unit normalized across features and a bias feature is appended to give 55 in total. Then, we project these onto a 550-dimensional space using Random Fourier Features Rahimi and Recht (2007) to approximate an RBF Kernel.

The Adult dataset consists of census data with the task of predicting whether a person makes over $50k a year or not. It contains 14 features which are categorical or continuous. The continuous features are made categorical by discretization. Each feature is converted into a one-hot representation with$m$binary features for$m$categories. The features are then unit normalized. The positives are those making more than$50k a year. We modified the dataset size to make the target prevalence 5%. The final dataset has a 39,000 points.

For the MNIST dataset, we combine the training, validation and testing sets into one. The 28x28 pixel images give us 784 features which are then unit normalized. We take the positive class to be the digit 1, and modified its prevalence to be 1%. The final dataset has around 63,500 points.

We compare LAS and WNAS to Anchor Graph Regularization with Local Anchor Embedding [AGR] as described in Liu et al. (2010)777This was re-implemented in Python for our experiments.. Their approach creates a proxy graph called the Anchor Graph which approximates the larger dataset; the labels given to points are then a weighted combination of the labels of the anchor points. Since this is a semi-supervised classification approach, we retrain it every iteration with all the data and known labels. We then use the confidence values for each unlabeled point to be positive as the $f$ value. This algorithm requires anchors to be computed beforehand. For this, we generated k-means over the transformed data points, with $k=500$ for each dataset.

Our main experiment measured recall (number of positives found) over a fixed number of iterations for each dataset. For each dataset, 10 runs were performed starting with one randomly chosen positive as initialization. For LAS, we took $\alpha$ (the coefficient for the Impact Factor) to be the best from empirical evaluations. This was $10^{-6}$ for CoverType and Adult, and 0 for MNIST. $\pi$ was taken as the true positives prevalence.

We also carried out smaller experiments over each dataset where we studied the predictive performance of LAS vs. WNAS immediately after initialization. Here, we randomly sampled 100 pairs of one positive and one negative point to initialize. Then, we reported the number of positives in the top 100 unlabeled points according to their $f$-values. These 100 pairs did not include “bad” initializations, where neither approach found any positives.

Note: We did not compare our approach vs. purely graph based methods as in the Wang et al. (2013) Since our results are identical to ASG given the “same” data as described before, we only considered data with feature vectors.

6.1 Results

Figure 2 shows plots of the recall per iteration of LAS, WNAS and AGR for the different datasets. Table 1 shows mean recall and standard deviation of these experiments in the mid and final iteration. LAS and WNAS both have good performance in all three experiments. The CoverType dataset has high variance in estimates, likely because the data has many scattered positives which are not very informative during initialization. The algorithms would then take longer to discover the remaining positives. The MNIST data-set showed particularly good performance across the different approaches; all three approaches have near ideal recall. This is likely because the targets are tightly clustered together in the feature-space. The performance of AGR in the CoverType, though much better than random choice, is poorer than the other approaches. This is because AGR incurs significant overhead in the initialization of the algorithm. Computing k-means, followed by the weights and the reduced Laplacian of the Anchor Graph takes a few hours for CoverType. Furthermore, any change in the feature function used between the data points requires recomputation of the Anchor Graph. Due to this, we only used 500 Anchors even though it is a larger data-set. This poorer approximation of the data likely led to worse performance.

Table 2 shows the comparison between LAS and WNAS given a single positive and negative point for initialization. As expected from our discussion in Section 5.2, LAS generalizes better with the unlabeled data.

Note: We also conducted similar experiments on much larger datasets from the UCI Repository: the HIGGS dataset (5.5 million points) and the SUSY dataset (2.5 million points). We have not reported these results. These experiments were not any more informative than those above; they just served as a demonstration of scale.

7 Conclusion and Future Work

In this paper, we proposed an algorithm to perform Active Search given a linear similarity function between data points. Through experiments, we demonstrate the scalability of our algorithm as compared to the original approach by Wang et al. (2013), as well as good recall on different datasets.

We also described an alternate, simple approach using a weighted neighbor estimator of labels. This approach also scales well to large datasets, but is not as generalizable given very little labeled information. It does perform comparably with our main approach in the recall problem.

7.1 Future Work

We require a “good” similarity function, or equivalently a good featurization, for our approach to perform well. A next step would be to learn a featurization simultaneously while performing Active Search. The challenge here is effective regularization with very little labeled data at the beginning.

We have also not dealt with natural graphs in this paper, because of the restriction on our similarity function. But we know that every iteration of Active Search just uses label propagation to compute $f$. There exist methods, such as Fujiwara and Irie (2014), to perform efficient label propagation on large sparse graphs. Incorporating this into our approach along with appropriate Impact Factor computation would allow us to scale on natural graph datasets.

Acknowledgments

Work partially supported by DARPA (FA8750-12-2-0324, FA8750-14-2-0244) and NSF (1320347).

Appendix A Algorithm Derivations

A.1 Derivation of minimizer of E($f$)

We can rewrite the energy function using matrices as given below. The subscripts $\mathcal{L}$ and $\mathcal{U}$ represents portions of various quantities as belonging to the set of labeled and unlabeled points respectively. Here, without loss of generality, we have rearranged the $f$-vector to group the labeled and unlabeled points. This re-arrangement will hold throughout this appendix.

[TABLE]

where

[TABLE]

Let $Q=\left[\begin{matrix}I_{\mathcal{L}}&0\\ 0&\lambda w_{0}I_{\mathcal{U}}\end{matrix}\right]$. Then, $\widetilde{D}=DQ$.

Notice that the energy function is convex in $f$, since the Hessian is diagonally dominant and symmetric. The gradient of the above expression w.r.t. $f$ is:

[TABLE]

where $y^{\prime}=\left[\begin{matrix}y_{\mathcal{L}}\\ \pi\end{matrix}\right]$. Setting this to 0, we get the global minimizer:

[TABLE]

The last line can be readily verified given

[TABLE]

A.2 Derivation of Initialization step

We have that $f=(I-RX^{T}X)^{-1}q$. The Kailath variant of the matrix inverse lemma gives:

[TABLE]

Using this, we have:

[TABLE]

A.3 Derivation of Updates

We have $K^{-1}=(I-XRX^{T})^{-1}$ from last iteration. Further, only one element in $R$ changes:

$R^{+}=R-\gamma e_{i}e_{i}^{T}$, where $\gamma=-\left(\frac{\lambda}{1+\lambda}-\frac{1}{1+w0}\right)D_{ii}^{-1}$. Expanding $K^{+}$, we get:

[TABLE]

Here, we use Woodbury’s Matrix inversion formula:

[TABLE]

From this, we have:

[TABLE]

Given that only one element in $q$ changes each iteration: $q^{+}_{i}=y_{i}\dfrac{1}{1+\lambda}$, our updated $f$ becomes

[TABLE]

Each step in this process only involves $O(r^{2}+rn)$ operations. Thus, this is the overall run-time per iteration.

A.4 Representation of $f$

Here, we show how we can write $f$ as:  $f=M^{-1}Py^{\prime}$

where $P=\left[\begin{matrix}\dfrac{1}{\lambda}I_{\mathcal{L}}&0\\ 0&w_{0}I_{\mathcal{U}}\end{matrix}\right]D$,    $M=D+P-A$

and $y^{\prime}$ is, as before, the vector with true labels for labeled points and $\pi$ otherwise. From the derivation for the initialization, we can rearrange the terms and move some constants around as follows:

[TABLE]

A.5 Derivation of Impact factor

The impact factor is defined to be the following:

[TABLE]

where $f_{j}^{+}$ is the new score for $x_{j}$ after $x_{i}$ is labeled by the user. It is the change in $f$ over all unlabeled points, conditioned on the labeling $x_{i}$ as positive. Here is a brief description of this computation, followed by the detailed derivation.

In order to compute this, we look at the change in $f$ given a positive label.

We write $f=M^{-1}Py^{\prime}$ as shown in A.4. We can now reason about the change vector of $f$ given that unlabeled point $x_{i}$ is a positive:

[TABLE]

The following quantities can be computed directly from these change vectors.

[TABLE]

The $i^{th}$ element of the above vectors is computed assuming that $x_{i}$ has a positive label. But, we still take $x_{i}$ to be in $\mathcal{U}$ for the computation of $\Delta F$ because it simplifies computation, and can be corrected for. Further, only unlabeled entries matter in the computation, since the Impact Factor only depends on $\mathcal{U}$.

The Impact Factor can be written as follows, where $\circ$ denotes the element-wise product:

[TABLE]

We subtract $\Delta\widetilde{f}$ to correct for including $x_{i}$ in $\mathcal{U}$ in previous computations. We can shown that each term, and hence the whole Impact Factor, can be computed in $O(nr+r^{2})$ time per iteration. The detailed steps follow below.

From A.4, we have that $f=M^{-1}Py^{\prime}$. With this, we can write two equations:

[TABLE]

[TABLE]

where $\Delta P=P^{+}-P$. If we label point $x_{i}$ as positive, subtracting the second equation from the first, we get:

[TABLE]

with the $i^{th}$ standard basis vector $e_{i}$. The last equality is true for the following reasons. Since we labeled point $x_{i}$, we have $y^{\prime}_{i}=\pi$ and $y^{\prime+}_{i}=y_{i}$ and for all $j\neq i$, $y^{\prime+}_{j}=y^{\prime}_{j}$. Secondly, $\Delta P$ is 0 for every entry other than the $i^{th}$ diagonal entry, since only that element changes in $P$. This tells us that when we label point $x_{i}$, we have:

[TABLE]

Substituting $y_{i}=1$ for the Impact Factor and using the notation $\delta P=P_{i,i}^{+}-P_{i,i}$, we get:

[TABLE]

Using this, we can compute the two quantities of interest we defined before:

[TABLE]

Let $\Delta F_{i}:=\sum\limits_{j\in\mathcal{U}}\Delta f_{j}(i)$ where the label of $x_{i}$ is taken as 1. As mentioned before, $x_{i}$ is still included in $\mathcal{U}$.

Computing $\Delta\widetilde{f}$: In equation 9, we first solve for $f_{i}^{+}$ and subtract out $f_{i}$. This gives us the $i^{th}$ element of $\Delta f(i)$ as:

[TABLE]

Computing $\Delta F$: Notice that $\Delta F_{i}=\Delta f(i)^{T}u$ where $u$ is the indicator vector where $u_{i}=1$ if $x_{i}$ is unlabeled and 0 otherwise. Using $(M^{-1}_{.,i})^{T}=M^{-1}_{i,.}$ since $M^{-1}$ is symmetric, equation 9 gives us:

[TABLE]

Now, note that $P_{i,i}^{+}=\dfrac{1}{\lambda}D_{i,i}$, since this denotes $P$ after $x_{i}$ is labeled. And, $P_{i,i}=w_{0}D_{i,i}$ since $x_{i}$ is unlabeled at the start of this iteration. $P_{i,i}$ and $P_{i,i}^{+}$ do not depend on the label itself, just on whether $x_{i}$ is labeled or not. With this, we can define new vectors which are the stacked versions of $P_{i,i}$ and $P_{i,i}^{+}$:

[TABLE]

These vectors only are relevant in the indices of the unlabeled points. Now, stacking equation 11 for all $i$, we get:

[TABLE]

If we are able to compute $\Delta\widetilde{f}$, $M^{-1}$ and $M^{-1}u$ efficiently, then $\Delta F$ can be computed efficiently as it is just a constant number of point-wise $O(n)$ operations. Further, the Impact is also readily computed as:

[TABLE]

As noted before, we need to account for considering not removing $x_{i}$ from $\mathcal{U}$ while computing each component of $\Delta F$. Thus, we have to subtract $\Delta\widetilde{f}$ before computing the final Impact Factor.

In the following sections, we will discuss how to compute $\Delta\widetilde{f}$, $M^{-1}$ and $M^{-1}u$ efficiently.

A.5.1 Rewriting $M^{-1}$

We first show that $M^{-1}=(I-BD^{-1}A)^{-1}BD^{-1}$. Here, $B$ is the same as in section A.1. We know that $P=SD$ where

[TABLE]

Then, we have:

[TABLE]

The last step comes from the fact that $B^{-1}=I+S$. For our problem, $A=X^{T}X$. Using the same steps as in Section A.2:

[TABLE]

where $R=BD^{-1}$ and $K=(I-XRX^{T})$. The individual matrices in the above expression are already being computed in updates for $f$.

A.5.2 Computing $\Delta F$ given $\Delta\widetilde{f}$

We have

[TABLE]

Given $\Delta\widetilde{f}$, we can compute $\left[\vec{L}-\pi\vec{U}-(\vec{L}-\vec{U})\circ(f+\Delta\widetilde{f})\right]$ in $O(n)$ time as it consists of only element-wise sums and multiplications. Further, $M^{-1}u$ can be computed as follows.

• •

$z=Ru$ changes only one element each iteration. It can be initialized once and can be updated.

• •

$(I+RX^{T}K^{-1}X)z$ can then be computed in $O(rn)$ time by cascading the matrix-vector multiplication in.

These operations take $O(rn)$ time per iteration.

A.5.3 Computing $\Delta\widetilde{f}$ via updates

We have

[TABLE]

where each element is given by equation 10. This can be written as:

[TABLE]

where $N=diag\left(\mathbb{1}+(\vec{L}-\vec{U})\circ diag(M^{-1})\right)$. We compute $diag(M^{-1})$ as follows:

[TABLE]

Thus,

[TABLE]

From this, we see that we just need to store and update $J=diag(X^{T}K^{-1}X)$ every iteration. Here’s how we can do this:

• •

We initialize $j_{i}=x_{i}^{T}K^{-1}x_{i}$ and $J=\left[\begin{matrix}j_{1}\\ \vdots\\ j_{n}\end{matrix}\right]$ at the start. This computation takes $O(nr^{2})$ time once we have $K$.

• •

Then, as we update $K$, we also update $J$. Here, $i$ is the index of the point to be labeled and $t$ is the index of $J$ being modified.

[TABLE]

Therefore,

[TABLE]

where $c=\dfrac{\gamma}{1+\gamma x_{i}^{T}K^{-1}x_{i}}$ is already computed in the updates to $f$. Since $(K^{-1}x_{i})$ is also computed while updating $f$, updating each element $j_{t}$ only takes $O(r)$ time because it consists of only a dot product and a constant number of scalar operations.

Thus, updating the entire $J$ vector only takes $O(nr)$ per iteration. Once we have $J$, we can compute $diag(M^{-1})$ in $O(n)$ time through element-wise operations.

Finally, after computing $diag(M^{-1})$, we can compute $\Delta\widetilde{f}$ in $O(n)$ time every iteration, again using only element-wise sums and products.

A.5.4 Putting it all together

We showed that in computing both $\Delta F$ and $\Delta\widetilde{f}$, we need only $O(nr^{2})$ initialization time and $O(nr+r^{2})$ time per iteration of the algorithm. Then, putting them together to get the Impact Factor takes only $O(n)$ time. This is the same as what is needed to compute the initialization and updates for $f$.

In this way, the Impact Factor computation also scales with the other computations performed in the algorithm.

Appendix B Proofs

B.1 Proof of Lemma 4.1

The adjacency matrix $A$ is assumed to only have positive values.

Lemma 4.1

Let $A=A_{1}+A_{2}$ where $A_{1}$ is the block diagonal component of the similarity matrix and $A_{2}$ is the pure cross-similarity component.

*If $||A_{2}||_{1}<\epsilon$, then $||\widetilde{M}_{12}||_{1}<\left(\dfrac{1}{c\cdot d_{min}}\right)^{2}\epsilon$ where $c=\min\{\frac{1}{\lambda},w_{0}\}$ and $d_{min}$ is the minimum degree in the graph.

Proof: We want to show that if $A$ is “close” to block diagonal, then $M^{-1}$ is close to block diagonal. We have that:

[TABLE]

where $M_{1}=D+P-A_{1}$ is block diagonal. Using Woodbury’s Matrix Inversion lemma, we have:

[TABLE]

Thus, $M^{-1}-M_{1}^{-1}=M_{1}^{-1}A_{2}(M_{1}-A_{2})^{-1}$ where we have that $M_{1}^{-1}$ is block diagonal. Taking the 1-norm of this, we have from sub-multiplicity of induced matrix norms:

[TABLE]

Here, we use a result by Varah varah which is as follows:

For a diagonal dominant $n\times n$ matrix $J$,

[TABLE]

where $\Delta_{i}(J)$, is the $i^{\rm th}$ diagonal dominance defined by

[TABLE]

For $M=D+P-A$, we have $\Delta_{i}(M)=P_{ii}$ as the contribution of $D-A$ to $\Delta_{i}(M)$ is 0. The minimum value of $\Delta_{i}(M)$ is then lower bounded by $c\cdot d_{min}$. Further, since $A_{2}$ only introduces off diagonal elements to $M=M_{1}-A_{2}$, we have that $\Delta_{i}(M_{1})\geq\Delta_{i}(M)$ for all $i$. Thus, the minimum value for $\Delta_{i}(M_{1})$ is also lower bounded by $c\cdot d_{min}$. This means that:

[TABLE]

Since $M^{-1}$ and $M_{1}^{-1}$ are symmetric, we have that

[TABLE]

as the 1-norm is the maximum absolute row-sum and the $\infty$-norm is the maximum absolute column sum.

This finally gives us:

[TABLE]

If we write $M^{-1}=N_{1}+N_{2}$ where $N_{1}$ is the block diagonal component of $M^{-1}$ and $N_{2}$ is the off block diagonal component, we have that:

[TABLE]

Further, we have that $||N_{2}||_{1}<||(N_{1}-M_{1}^{-1})+N_{2}||_{1}$ since we are just introducing numbers where $N_{2}$ is 0. This can only increase the absolute row-sums. With this, we have that

[TABLE]

Since $N_{2}$ is the block diagonal component of $M^{-1}$, it is exactly the following as defined in Section 5.1:

[TABLE]

This gives us that

[TABLE]

$\hfill\blacksquare$