SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Ainesh Bakshi MIT ainesh@mit.edu
Piotr Indyk  
MIT  
indyk@mit.edu
Rajesh Jayaram  
Google Research  
rkjayaram@gmail.com
Sandeep Silwal MIT silwal@mit.edu
Erik Waingarten
University of Pennsylvania ewaingar@seas.upenn.edu
For any two point sets  $A, B \subset \mathbb{R}^d$  of size up to  $n$ , the Chamfer distance from  $A$  to  $B$  is defined as  $\mathrm{CH}(A, B) = \sum_{a \in A} \min_{b \in B} d_X(a, b)$ , where  $d_X$  is the underlying distance measure (e.g., the Euclidean or Manhattan distance). The Chamfer distance is a popular measure of dissimilarity between point clouds, used in many machine learning, computer vision, and graphics applications, and admits a straightforward  $\mathcal{O}(dn^2)$ -time brute force algorithm. Further, the Chamfer distance is often used as a proxy for the more computationally demanding Earth-Mover (Optimal Transport) Distance. However, the quadratic dependence on  $n$  in the running time makes the naive approach intractable for large datasets.
We overcome this bottleneck and present the first  $(1 + \varepsilon)$ -approximate algorithm for estimating the Chamfer distance with a near-linear running time. Specifically, our algorithm runs in time  $\mathcal{O}\bigl (nd\log (n) / \varepsilon^2\bigr)$  and is implementable. Our experiments demonstrate that it is both accurate and fast on large high-dimensional datasets. We believe that our algorithm will open new avenues for analyzing large high-dimensional point clouds. We also give evidence that if the goal is to report a  $(1 + \varepsilon)$ -approximate mapping from  $A$  to  $B$  (as opposed to just its value), then any sub-quadratic time algorithm is unlikely to exist.
For any two point sets  $A, B \subset \mathbb{R}^d$  of sizes up to  $n$ , the Chamfer distance from  $A$  to  $B$  is defined as
$$
\mathrm {C H} (A, B) = \sum_ {a \in A} \min  _ {b \in B} d _ {X} (a, b)
$$
where  $d_{X}$  is the underlying distance measure, such as the Euclidean or Manhattan distance. The Chamfer distance, and its weighted generalization called Relaxed Earth Mover Distance [16, 7], are popular measures of dissimilarity between point clouds. They are widely used in machine learning (e.g., [16, 23]), computer vision (e.g., [8, 22, 12, 15]) and computer graphics [17]. Subroutines for computing Chamfer distances are available in popular libraries, such as Tensorflow [3], Pytorch [2] and PDAL [1]. In many of those applications (e.g., [16]) Chamfer distance is used as a faster proxy for the more computationally demanding Earth-Mover (Optimal Transport) Distance.
This is the definition adopted, e.g., in [8]. Some other papers, e.g., [12], replace each distance term  $d_X(a,b)$  with its square, e.g., instead of  $\| a - b\| _2$  they use  $\| a - b\| _2^2$ . In this paper we focus on the first definition, as it emphasizes the connection to Earth Mover Distance and its relaxed weighted version in [16, 7].
Despite the popularity of Chamfer distance, the naive algorithm for computing it has quadratic  $\mathcal{O}(n^2)$  running time, which makes it difficult to use for large datasets. Faster approximate algorithms can be obtained by performing  $n$  exact or approximate nearest neighbor queries, one for each point in  $A$ . By utilizing the state of the art approximate nearest neighbor algorithms, this leads to  $(1 + \varepsilon)$ -approximate estimators with running times of  $\mathcal{O}\big(n(1 / \varepsilon)^{\mathcal{O}(d)}\log n\big)$  in low dimensions [6] or roughly  $\mathcal{O}\Big(dn^{1 + \frac{1}{2(1 + \varepsilon)^2 - 1}}\Big)$  in high dimensions [5]. Alas, the first bound suffers from exponential dependence on the dimension, while the second bound is significantly subquadratic only for relatively large approximation factors.
In this paper we overcome this bottleneck and present the first  $(1 + \varepsilon)$ -approximate algorithm for estimating Chamfer distance that has a near-linear running time, both in theory and in practice. Concretely, our contributions are as follows:
- When the underlying metric  $d_X$  is defined by the  $\ell_1$  or  $\ell_2$  norm, we give an algorithm that runs in time  $\mathcal{O}\bigl (nd\log (n) / \varepsilon^2\bigr)$  and estimates the Chamfer distance up to  $1\pm \varepsilon$  with  $99\%$  probability (see Theorem 2.1). In general, our algorithm works for any metric  $d_X$  supported by Locality-Sensitive Hash functions (see Definition 2.2), with the algorithm running time depending on the parameters of those functions. Importantly, the algorithm is quite easy to implement, see Figures 1 and 2.
- For the more general problem of reporting a mapping  $g: A \to B$  whose cost  $\sum_{a \in A} d_X(a, g(a))$  is within a factor of  $1 + \varepsilon$  from  $\mathsf{CH}(A, B)$ , we show that, under a popular complexity-theoretic conjecture, an algorithm with a running time analogous to that of our estimation algorithm does not exist, even when  $d_X(a, b) = \|a - b\|_1$ . Specifically, under a Hitting Set Conjecture [24], any such algorithm must run in time  $\Omega(n^{2-\delta})$  for any constant  $\delta > 0$ , even when the dimension  $d = \Theta(\log^2 n)$  and  $\varepsilon = \frac{\Theta(1)}{d}$ . (In contrast, our estimation algorithm runs in near-linear time for such parameters). This demonstrates that, for the Chamfer distance, estimation is significantly easier than reporting.
- We experimentally evaluate our algorithm on real and synthetic data sets. Our experiments demonstrate the effectiveness of our algorithm for both low and high dimensional datasets and across different dataset scales. Overall, it is much faster ( $>5\mathbf{x}$ ) than brute force (even accelerated with KD-trees) and both faster and more sample efficient ( $5-10\mathbf{x}$ ) than simple uniform sampling. We demonstrate the scalability of our method by running it on billion-scale Big-ANN-Benchmarks datasets [21], where it runs up to  $50\mathbf{x}$  faster than optimized brute force. In addition, our method is robust to different datasets: while uniform sampling performs reasonably well for some datasets in our experiments, it performs poorly on datasets where the distances from points in  $A$  to their neighbors in  $B$  vary significantly. In such cases, our algorithm is able to adapt its importance sampling probabilities appropriately and obtain significant improvements over uniform sampling.
2 Algorithm and Analysis
In this section, we establish our main result for estimating Chamfer distance:
Theorem 2.1 (Estimating Chamfer Distance in Nearly Linear Time). Given as input two datasets  $A, B \subset \mathbb{R}^d$  such that  $|A|, |B| \leqslant n$ , and an accuracy parameter  $0 < \varepsilon < 1$ , Chamfer-Estimate runs in time  $O\left(nd\log(n)/\varepsilon^2\right)$  and outputs an estimator  $\eta$  such that with probability at least  $99/100$ ,
$$
(1 - \varepsilon) \mathrm {C H} (A, B) \leqslant \eta \leqslant (1 + \varepsilon) \mathrm {C H} (A, B),
$$
when the underlying metric is Euclidean  $(\ell_2)$  or Manhattan  $(\ell_1)$  distance.
For ease of exposition, we make the simplifying assumption that the underlying metric is Manhattan distance, i.e.  $d_X(a,b) = \| a - b\| _1$ . Our algorithm still succeeds whenever the underlying metric admits a locality-sensitive hash function (the corresponding analogue of Definition 2.2).
Definition 2.2 (Hashing at every scale). There exists a fixed constant  $c_{1} > 0$  and a parameterized family  $\mathcal{H}(r)$  of functions from  $X$  to some universe  $U$  such that for all  $r > 0$ , and for every  $x, y \in X$
1. Close points collide frequently:
$$
\mathop{\Pr}\limits_{\boldsymbol {h}\sim \mathcal{H}(r)}[ \boldsymbol {h}(\boldsymbol {x})\neq \boldsymbol {h}(\boldsymbol {y})]\leqslant \frac{\| \boldsymbol{x} - \boldsymbol{y}\|_{1}}{r},
$$
Subroutine Chamfer-Estimate(A,B,T)
Input: Two subsets  $A, B \subset \mathbb{R}^d$  of size at most  $n$ , and a parameter  $T \in \mathbb{N}$ .
Output: A number  $\eta \in \mathbb{R}_{\geqslant 0}$
1. Execute the algorithm CrudeNN(A, B), and let the output be a set of positive real numbers  $\{D_a\}_{a \in A}$  which always satisfy  $D_a \geqslant \min_{b \in B} \|a - b\|_1$ . Let  $D := \sum_{a \in A} D_a$ .
2. Construct the probability distribution  $\mathcal{D}$ , supported on the set  $A$ , which satisfies that for every  $a \in A$ ,
$$
\underset {\boldsymbol {x} \sim \mathcal {D}} {\operatorname * {P r}} [ \boldsymbol {x} = a ] := \frac {\boldsymbol {D} _ {a}}{\boldsymbol {D}}.
$$
3. For  $\ell \in [T]$ , sample  $\pmb{x}_{\ell} \sim \mathcal{D}$  and spend  $\mathcal{O}(|B|d)$  time to compute
$$
\boldsymbol {\eta} _ {\ell} := \frac {D}{D _ {\boldsymbol {x} _ {\ell}}} \cdot \min  _ {b \in B} \| \boldsymbol {x} _ {\ell} - b \| _ {1}.
$$
4. Output
$$
\boldsymbol {\eta} := \frac {1}{T} \sum_ {\ell = 1} ^ {T} \boldsymbol {\eta} _ {\ell}.
$$
Figure 1: The Chamfer-Estimate Algorithm.
2. Far points collide infrequently:
$$
\mathop{\bf P r}\limits_{\boldsymbol {h}\sim \mathcal{H}(r)}\left[\boldsymbol {h}(\boldsymbol {x}) = \boldsymbol {h}(\boldsymbol {y})\right]\leqslant \exp \left(-c_{1}\cdot \frac{\| \boldsymbol{x} - \boldsymbol{y}\|_{1}}{r}\right).
$$
Uniform vs Importance Sampling. A natural algorithm for estimating  $\mathrm{CH}(A,B)$  proceeds by uniform sampling: sample an  $a\in A$  uniformly at random and explicitly compute  $\min_{b\in B}\| a - b\| _1$ . In general, we can compute the estimator  $\hat{z}$  for  $\mathrm{CH}(A,B)$  by averaging over  $s$  uniformly chosen samples, resulting in runtime  $\mathcal{O}(nds)$ . It is easy to see that the resulting estimator is un-biased, i.e.  $\mathbf{E}[\hat{z}] = \mathrm{CH}(A,B)$ . However, if a small constant fraction of elements in  $A$  contribute significantly to  $\mathrm{CH}(A,B)$ , then  $s = \Omega (n)$  samples could be necessary to obtain, say, a  $1\%$  relative error estimate with constant probability. Since each sample requires a linear scan to find the nearest neighbor, this would result in a quadratic runtime.
While such an approach has good empirical performance for well-behaved datasets, it does not work for data sets where the distribution of the distances from points in  $A$  to their nearest neighbors in  $B$  is skewed. Further, it is computationally prohibitive to verify the quality of the approximation given by uniform sampling. Towards proving Theorem 2.1, it is paramount to obtain an algorithm that works regardless of the structure of the input dataset.
A more nuanced approach is to perform importance sampling where we sample  $a \in A$  with probability proportional to its contribution to  $\mathsf{CH}(A, B)$ . In particular, if we had access to a distribution,  $D_{a}$ , over elements  $a \in A$  such that,  $\min_{b \in B} \| a - b \|_1 \leqslant D_{a} \leqslant \lambda \min_{b \in B} \| a - b \|_1$ , for some parameter  $\lambda > 1$ , then sampling  $O(\lambda)$  samples results in an estimator  $\hat{z}$  that is within  $1\%$  relative error to the true answer with probability at least  $99\%$ . Formally, we consider the estimator defined in Algorithm 1, where we assume access to CrudeNN(A, B), a sub-routine which receives as input  $A$  and  $B$  and outputs estimates  $D_{a} \in \mathbb{R}_{\geqslant 0}$  for each  $a \in A$  which is guaranteed to be an upper bound for  $\min_{b \in B} \| a - b \|_1$ . Based on the values  $\{D_{a}\}_{a \in A}$  we construct an importance sampling distribution  $\mathcal{D}$  supported on  $A$ . As a result, we obtain the following lemma:
Lemma 2.3 (Variance Bounds for Chamfer Estimate). Let  $n, d \in \mathbb{N}$  and suppose  $A, B$  are two subsets of  $\mathbb{R}^d$  of size at most  $n$ . For any  $T \in \mathbb{N}$ , the output  $\pmb{\eta}$  of Chamfer-Estimate  $(A, B, T)$  satisfies
$$
\mathbf {E} [ \boldsymbol {\eta} ] = \mathrm {C H} (A, B),
$$
$$
\operatorname {V a r} [ \eta ] \leqslant \frac {1}{T} \cdot \mathrm {C H} (A, B) ^ {2} \left(\frac {D}{\mathrm {C H} (A , B)} - 1\right),
$$
for  $D$  from Line 1 in Figure 1. The expectations and variance are over the randomness in the samples of Line 3 of Chamfer-Estimate(A, B, T). In particular,
$$
\Pr \left[ | \boldsymbol {\eta} - \mathrm {C H} (A, B) | \geqslant \varepsilon \cdot \mathrm {C H} (A, B) \right] \leqslant \frac {1}{\varepsilon^ {2} \cdot T} \left(\frac {\boldsymbol {D}}{\mathrm {C H} (A , B)} - 1\right).
$$
The proof follows from a standard analysis of importance sampling and is deferred to Appendix A. Observe, if  $D \leqslant \lambda \mathsf{CH}(A,B)$ , it suffices to sample  $T = O\left(\lambda /\varepsilon^2\right)$  points in  $A$ , leading to a running time of  $O\big(nd\lambda /\varepsilon^2\big)$ .
Subroutine CrudeNN(A,B)
Input: Two subsets  $A, B$  of a metric space  $(X, \| \cdot \|_1)$  of size at most  $n$  such that all non-zero distances between any point in  $A$  and any point in  $B$  is between 1 and  $\mathrm{poly}(n / \varepsilon)$ . We assume access to a locality-sensitive hash family at every scale  $\mathcal{H}(r)$  for any  $r \geqslant 0$  satisfying conditions of Definition 2.2. (We show in Appendix A that, for  $\ell_1$  and  $\ell_2$ , the desired hash families exist, and that distances between 1 and  $\mathrm{poly}(n / \varepsilon)$  is without loss of generality).
Output: A list of numbers  $\{D_a\}_{a \in A}$  where  $D_a \geqslant \min_{b \in B} \|a - b\|_1$ .
1. We instantiate  $L = \mathcal{O}(\log (n / \varepsilon))$  and for  $i\in \{0,\dots ,L\}$ , we let  $r_i = 2^i$ .
2. For each  $i\in \{0,\ldots ,L\}$  sample a hash function  $\pmb {h}_i\colon \bar{X}\to U$  from  $\pmb {h}_i\sim \mathcal{H}(\pmb {r}_i)$
3. For each  $a \in A$ , find the smallest  $i \in \{0, \dots, L\}$  for which there exists a point  $b \in B$  with  $h_i(a) = h_i(b)$ , and set  $D_a = \|a - b\|_1$ .
- The above may be done by first hashing each point  $b \in B$  and  $i \in \{0, \dots, L\}$  according to  $h_i(b)$ . Then, for each  $a \in A$ , we iterate through  $i \in \{0, \dots, L\}$  while hashing  $a$  according to  $h_i(a)$  until the first  $b \in B$  with  $h_i(a) = h_i(b)$  is found.
Figure 2: The CrudeNN Algorithm.
Obtaining importance sampling probabilities. It remains to show how to implement the CrudeNN(A,B) subroutine to obtain the distribution over elements in  $A$  which is a reasonable over-estimator of the true probabilities. A natural first step is to consider performing an  $\mathcal{O}(\log n)$ -approximate nearest neighbor search (NNS): for every  $a' \in A$ , find  $b' \in B$  satisfying  $\|a' - b'\|_1 / \min_{b \in B} \|a' - b\|_1 = \mathcal{O}(\log n)$ . This leads to the desired guarantees on  $\{D_a\}_{a \in A}$ . Unfortunately, the state of the art algorithms for  $\mathcal{O}(\log n)$ -approximate NNS, even under the  $\ell_1$  norm, possess extraneous poly( $\log n$ ) factors in the runtime, resulting in a significantly higher running time. These factors are even higher for the  $\ell_2$  norm. Therefore, instead of performing a direct reduction to approximate NNS, we open up the approximate NNS black-box and give a simple algorithm which directly satisfies our desired guarantees on  $\{D_a\}_{a \in A}$ .
To begin with, we assume that the aspect ratio of all pair-wise distances is bounded by a fixed polynomial,  $\mathrm{poly}(n / \varepsilon)$  (we defer the reduction from an arbitrary input to one with polynomially bounded aspect ratio to Lemma A.3). We proceed via computing  $\mathcal{O}(\log (n / \varepsilon))$  different (randomized) partitions of the dataset  $A\cup B$ . The  $i$ -th partition, for  $1\leqslant i\leqslant \mathcal{O}(\log (n / \varepsilon))$ , can be written as  $A\cup B = \cup_{j}\mathcal{P}_{j}^{i}$  and approximately satisfies the property that points in  $A\cup B$  that are at distance at most  $2^{i}$  will be in the same partition  $\mathcal{P}_j^i$  with sufficiently large probability. To obtain these components, we use a family of locality-sensitive hash functions, whose formal properties are given in Definition 2.2. Intuitively, these hash functions guarantee that:
1. For each  $a' \in A$ , its true nearest neighbor  $b' \in B$  falls into the same component as  $a'$  in the  $i_0$ -th partition, where  $2^{i_0} = \Theta(\|a' - b'\|_1)^2$ , and
2. Every other extraneous  $b \neq b'$  is not in the same component as  $a'$  for each  $i < i_0$ .
It is easy to check that any hash function that satisfies the aforementioned guarantees yields a valid set of distances  $\{D_a\}_{a \in A}$  as follows: for every  $a' \in A$ , find the smallest  $i_0$  for which there exists a  $b' \in B$  in the same component as  $a'$  in the  $i_0$ -th partition. Then set  $D_{a'} = \|a' - b'\|_1$ . Intuitively, the  $b'$  we find for any fixed  $a'$  in this procedure will have distance that is at least the closest neighbor in  $B$  and with good probability, it won't be too much larger. A caveat here is that we cannot show the
2Recall we assumed all distances are between 1 and  $\mathrm{poly}(n)$  resulting in only  $\mathcal{O}(\log n)$  different partitions
above guarantee holds for  $2^{i_0} = \Theta (\| a' - b'\| _1)$ . Instead, we obtain the slightly weaker guarantee that, in the expectation, the partition  $b^{\prime}$  lands in is a  $\mathcal{O}(\log n)$ -approximation to the minimum distance, i.e.  $2^{i_0} = \Theta (\log n\cdot \| a' - b'\| _1)$ . Therefore, after running CrudeNN(A,B), setting  $\lambda = \log n$  suffices for our  $\mathcal{O}\bigl (nd\log (n) / \varepsilon^2\bigr)$  time algorithm. We formalize this argument in the following lemma:
Lemma 2.4 (Oversampling with bounded Aspect Ratio). Let  $(X, d_X)$  be a metric space with a locality-sensitive hash family at every scale (see Definition 2.2). Consider two subsets  $A, B \subset X$  of size at most  $n$  and any  $\varepsilon \in (0,1)$  satisfying
$$
1\leqslant \min_{\substack{a\in A,b\in B\\ a\neq b}}d_{X}(a,b)\leqslant \max_{a\in A,b\in B}d_{X}(a,b)\leqslant \operatorname {poly}(n / \varepsilon).
$$
Algorithm 2, CrudeNN(A, B), outputs a list of (random) positive numbers  $\{D_a\}_{a \in A}$  which satisfy the following two guarantees:
- With probability 1, every  $a \in A$  satisfies  $\pmb{D}_a \geqslant \min_{b \in B} d_X(a, b)$ .
- For every  $a \in A$ ,  $\mathbf{E}[D_a] \leqslant \mathcal{O}(\log n) \cdot \min_{b \in B} d_X(a, b)$ .
Further, Algorithm 2, runs in time  $\mathcal{O}(dn\log (n / \varepsilon))$  time, assuming that each function used in the algorithm can be evaluated in  $\mathcal{O}(d)$  time.
Proof Sketch for Theorem 2.1. Given the lemmas above, it is straightforward to complete the proof of Theorem 2.1. First, we reduce to the setting where the aspect ratio is  $\mathrm{poly}(n / \varepsilon)$  (see Lemma A.3 for a formal reduction). We then invoke Lemma 2.4 and apply Markov's inequality to obtain a set of distances  $D_{a}$  such that with probability at least  $99 / 100$ , for each  $a \in A$ ,  $\min_{b \in B} \|a - b\|_1 \leqslant D_a$  and  $\sum_{a \in A} D_a \leqslant \mathcal{O}(\log(n)) \operatorname{CH}(A, B)$ . We then invoke Lemma 2.3 and set the number of samples,  $T = \mathcal{O}(\log(n) / \varepsilon^2)$ . The running time of our algorithm is then given by the time of CrudeNN(A, B), which is  $O(nd\log(n / \varepsilon))$ , and the time needed to evaluate the estimator in Lemma 2.3, requiring  $\mathcal{O}(nd\log(n) / \varepsilon^2)$  time. Refer to Section A for the full proof.
Other Related Works We note that importance sampling is a popular technique used for speeding up geometric algorithms. For example, [14] uses it to obtain a fast  $c$ -approximate algorithm for computing Earth Mover Distance (EMD) in two (or any constant) dimensions, for some constant  $c > 2$ . However, the application and implementation of importance sampling in that paper is quite different from ours. In [14], the space containing all input points is subdivided into regions, and the total EMD value is represented as a sum of EMDs restricted to point-sets in each region (plus an additional representing the "global" EMD). The EMD cost in each region is then approximated quickly by embedding EMD into  $\ell_1$  using a randomly shifted quadtree with logarithmic distortion; these estimations define the sampling probabilities.
In contrast, in our paper, the value of the Chamfer distance is exactly equal to the sum of distances from each point to its nearest neighbor, so there is no decomposition involved. Instead, we approximate each distance to nearest neighbor using a randomized hierarchical decomposition; for the case of the  $\ell_1$  norm, each level of the decomposition partitions the space into rectangular boxes, as in quadtrees. Crucially, however, to ensure that the running time of our algorithm is within the stated bounds, we cannot use a standard randomly shifted quadtree where each level is shifted by the same random vector (as in [14]). This is because shifting all levels by the same amount only ensures that the expected distortion between a fixed pair of points is logarithmic; to ensure that the distance to the nearest neighbor is distorted by  $O(\log n)$ , we would need to use  $O(\log n)$  independent quadtrees and apply the union bound. Instead, we use independent random partitions at each level, and show (Lemma 2.4) that this suffices to bound the expected distortion of the distance to the nearest neighbor, without incurring any additional factors. This makes it possible to obtain the running time as stated.
There are other works on quickly computing EMD and related distances. For example, the algorithm of [4] runs in time that is linear in the number of distances, i.e. it runs in  $\Omega(n^2)$  time and gets a  $1 + \varepsilon$  approximation to EMD. This means that their approach requires a runtime quadratic in the size of the dataset  $n$ . In contrast, Chamfer distance admits a trivial time  $O(n^2)$  algorithm and our main contribution is to provide a nearly linear  $O(n\log(n)/\varepsilon^2)$  algorithm to get  $(1 + \varepsilon)$ -approximation to Chamfer distance.
We perform an empirical evaluation of our Chamfer distance estimation algorithm.
Summary of Results Our experiments demonstrate the effectiveness of our algorithm for both low and high dimensional datasets and across different dataset sizes. Overall, it is much faster than brute force (even accelerated with KD-trees). Further, our algorithm is both faster and more sample-efficient than uniform sampling. It is also robust to different datasets: while uniform sampling performs well for most datasets in our experiments, it performs poorly on datasets where the distances from points in  $A$  to their neighbors in  $B$  vary significantly. In such cases, our algorithm is able to adapt its importance sampling probabilities appropriately and obtain significant improvements over uniform sampling.
Dataset	|A|, |B|	d	Experiment	Metric	Reference
ShapeNet	~8·103, ~8·103	3	Small Scale	l1	[10]
Text Embeddings	2.5·103, 1.8·103	300	Small Scale	l1	[16]
Gaussian Points	5·104, 5·104	2	Outliers	l1	-
DEEP1B	104, 109	96	Large Scale	l2	[9]
Microsoft-Turing	105, 109	100	Large Scale	l2	[21]
Table 1: Summary of our datasets. For ShapeNet, the value of  $|A|$  and  $|B|$  is averaged across different point clouds in the dataset.
We use three different experimental setups, small scale, outlier, and large scale. They are designed to 'stress test' our algorithm, and relevant baselines, under vastly different parameter regimes. The datasets we use are summarized in Table 1. For all experiments, we introduce uniform sampling as a competitive baseline for estimating the Chamfer distance, as well as (accelerated) brute force computation. All results are averaged across  $20+$  trials and 1 standard deviation error bars are shown when relevant.