Transformation-based method for indexing high-dimensional data for nearest neighbour queries6834278Abstract We disclose a transformation-based method for indexing high-dimensional data to support similarity search. The method, iDistance, partitions the data into clusters either based on some clustering strategies or simple data space partitioning strategies. The data in each cluster can be described based on their similarity with respect to a reference point, and hence they can be transformed into a single dimensional space based on such relative similarity. This allows us to index the data points using a B.sup.+ -tree structure and perform similarity search using range search strategy. As such, the method is well suited for integration into existing DBMSs. We also study two data partitioning strategies, and several methods on selection of reference points. We conducted extensive experiments to evaluate iDistance, and our results demonstrate its effectiveness. Claims What is claimed is: Description 2 BACKGROUND OF THE INVENTION
dist(p.sub.1,p.sub.2) = dist(p.sub.2,p.sub.1)
.A-inverted.p.sub.1,p.sub.2 .di-elect cons. Points
dist(p.sub.1,p.sub.2) = 0 .A-inverted.p.sub.1 .di-elect cons.
Points
0 < dist(p.sub.1,p.sub.2) .ltoreq. d .A-inverted.p.sub.1,p.sub.2
.di-elect cons. Points;p.sub.1 .noteq. p.sub.2
dist(p.sub.1,p.sub.3) .ltoreq. dist(p.sub.1,p.sub.2) +
dist(p.sub.2,p.sub.3) .A-inverted.p.sub.1,p.sub.2,p.sub.3 .di-elect cons.
Points
The last formula defines the triangular inequality, and provides a condition for selecting candidates based on metric relationship. 5.1 iDistance iDistance comprises four steps. First, the high dimensional data is split into a set of partitions. This is done based on either some clustering strategies or simple data space partitioning strategies. Second, a reference point in each partition is identified. We note that the reference point need not be a data point. For a reference point, O.sub.i, its data space is defined by the points nearest and furthest to it. The maximum distance dist_max of the points in the partition to O.sub.i is the maximum radius of the partition sphere, while the minimum distance dist_min of the points in the partition to O.sub.i is the distance of the nearest point to O.sub.i. The region bounded by the spheres obtained from these two radii defines the effective data space that need to be searched. In the following discussion, we shall assume that the data space has been partitioned, and the reference point in each partition has been determined. These issues shall be discussed in the Section 5.3. Without loss of generality, let us suppose that we have m partitions, P.sub.0, P.sub.2, . . . , P.sub.m-1 and their corresponding reference points, O.sub.0, O.sub.2, O.sub.m-1. Third, all data points are represented in a single dimension space as follows. A data point p(x.sub.1, x.sub.2, . . . , x.sub.d), 0.ltoreq.x.sub.j.ltoreq.1, 1.ltoreq.j.ltoreq.d, has an index key, y, based on the distance from the nearest reference point O.sub.i as follows: y=i*c+dist(p, O.sub.i) where dist(O.sub.i, p) is a distance function returning the distance between O.sub.i and p, and c is some constant to stretch the data ranges. Essentially, c serves to partition the single dimension space into regions so that all points in partition P.sub.i will be mapped to the range [i*c, (i+1)*c). Thus, the value of c should be sufficiently large enough for the purpose. Fourth, the transformed points are indexed using any single dimensional index structure. We use the B.sup.+ -tree since it is available in all commercial DBMS. In our implementation of the B.sup.+ -tree, leaf nodes are linked to both the left and right siblings. This is to facilitate searching the neighboring nodes when the search region is gradually enlarged. Besides the B.sup.+ -tree, a small auxiliary data structure is required to store the m reference points and their respective nearest and furthest radii that define the data space. It is clear that iDistance is lossy in the sense that multiple data points in the high dimensional space may be mapped to the same value in the single dimensional space. For example, different points within a partition that are equidistant from the reference point have the same transformed value. However, as we shall see in the experimental study, iDistance can still lead to superior performance over linear scan and existing methods. 5.2 Similarity Search in iDistance Before we look at similarity search in iDistance, let us first look at how similarity search can be performed for metric-based indexing in the high-dimensional space. The similarity search algorithm (in high dimensional space) is based on the following observation: data points in a partition can be referenced via its reference point, O.sub.i, in terms of their proximity or distance to it. Formally, the inequality relationship between the reference point, data point and query point enables us to retrieve the required data correctly. Theorem 1 Let q be a query object, O.sub.i .epsilon. Points be a reference point for partition i, and p.sub.1 .epsilon. Points be a given data point in partition i. Moreover, let querydist(q) be the radius of the query sphere about q. If dist(p.sub.1,q).ltoreq.querydist(q) holds, then it follows that dist(O.sub.i,q)-querydist(q).ltoreq.dist(O.sub.i,p).ltoreq.dist(O.sub. i,q)+querydist(q). Proof Based on the definition of triangle inequality, we have dist(O.sub.i,q).ltoreq.dist(O.sub.i,p.sub.i)+dist(p.sub.i,q). Since dist(p.sub.i,q).ltoreq.querydist(q), therefore, dist(O.sub.i,q).ltoreq.dist(O.sub.i,p.sub.i)+querydist(q). And also, dist(O.sub.i,q)-querydist(q).ltoreq.dist(O.sub.i,p.sub.i)..quadrature. To search for the K nearest neighbors of q, the distance of the Kth nearest neighbor to q defines the minimum radius required for retrieving the complete answer set. Unfortunately, such a distance cannot be predetermined with 100% accuracy. Hence, an iterative approach that examines increasingly larger sphere in each iteration can be employed (see FIG. 2). The algorithm (in high-dimensional space) works as follows. Given a query point q, finding K nearest neighbors (NN) begins with a query sphere defined by a relatively small radius about q, querydist(q). All data spaces that intersect the query sphere have to be searched. Gradually, the search region is expanded till all the K nearest points are found and all the data subspaces that intersect with the current query space are checked. We note that starting the search query with a small initial radius keeps the search space as tight as possible, and hence minimizes unnecessary search (had a larger radius that contains all the K nearest points been used). FIG. 3 illustrates two data partitions referenced by O.sub.1 and O.sub.2 and the relationship between them and query q. We are now ready to look at the KNN algorithm for iDistance. Let us first look at the search regions. Let O.sub.i be the reference point of partition i, and dist_max.sub.i and dist_min.sub.i be the maximum and minimum distance between the points in partition i and O.sub.i respectively. Let q be a query point and querydist(q) be the radius of the sphere obtained about q. For iDistance, in conducting NN search, if dist(O.sub.i,q)-querydist(q).ltoreq.dist_max.sub.i, then partition i has to be searched for NN points. The range searching within an affected partition is [max(0, dist_min.sub.i),min(dist_max.sub.i, dist(O.sub.i,q)+querydist(q))]. FIG. 4 illustrates that for query point q.sub.1, only data set O.sub.1 needs to be searched, while for query point q.sub.2, both O.sub.2 and O.sub.3 have to be searched. From the figure, it is clear that all points along a fixed radius have the same value after transformation due to the lossy transformation of data points into distance with respect to the reference points. As such, the shaded regions are the areas that need to be checked. FIG. 5 summarizes the algorithm for KNN with iDistance method. Like its high-dimensional counterpart, it begins by searching a small "sphere", and incrementally enlarges the search space till all K nearest neighbors are found. The algorithm iDistanceKNN is highly abstracted. Before examining it, let us briefly discuss some of the important routines. Since both routines SearchInward and SearchOutward are similar, we shall only explain routine SearchInward. Given a leaf node, routine SearchInward examines the entries of the node to determine if they are among the K nearest neighbors, and updates the answers accordingly. We note that because iDistance is lossy, it is possible that points with the same values are actually not close to one another--some may be closer to q, while others are far from it. If the first element (or last element for SearchOutward) of the node is contained in the query sphere, then it is likely that its predecessor with respect to distance from the reference point (or successor for SearchOutward) may also be close to q. As such, the left (or right for SearchOutward) sibling is examined. In other words, SearchInward (SearchOutward) searches the space towards (away from) the reference point of the partition. The routine LocateLeaf is a typical B.sup.+ -tree traversal algorithm which locates a leaf node given a search value, and hence the detailed description of the algorithm is omitted. We are now ready to explain the search algorithm. Searching in iDistance begins by scanning the auxiliary structure to identify the reference points whose data space overlaps with the query region. The search starts with a small radius (querydist), and step by step, the radius is increased to form a bigger query sphere. For each enlargement, there are three main cases to consider. 1. The data space contains the query point, q. In this case, we want to traverse the data space sufficiently to determine the K nearest neighbors. This can be done by first locating the leaf node whereby q may be stored. (Recall that this node does not necessarily contain points whose distance are closest to q compared to its sibling nodes), and search inward or outward of the reference point accordingly. 2. The data space intersects the query sphere. In this case, we only need to search inward since the query point is outside the data space. 3. The data space does not intersect the query sphere. Here, we do not need to examine the data space. The search stops when the K nearest neighbors have been identified from the data subspaces that intersect with the current query sphere and when further enlargement of query sphere does not change the K nearest list. In other words, all points outside the subspaces intersecting with the query sphere will definitely be at a distance D from the query point such that D is greater than querydist. This occurs when the distance of the further object in the answer set, S, from query point q is less than or equal to the current search radius r. Therefore, the answers returned by iDistance are of 100% accuracy. We note that iDistance can provide approximate KNN answers quickly. In fact, at each iteration of algorithm iDistanceKNN, we have a set of K candidate NN points. These results can be returned to the users immediately and refined as more accurate answers are obtained in subsequent iterations. It is important to note that these K candidate NN points can be partitioned into two categories: those that we are certain to be in the answer set, and those that we have no such guarantee. The first category can be easily determined, since all those points with distance smaller than the current spherical radius of the query must be in the answer set. Users who can tolerate some amount of inaccuracy can obtain quick approximate answers and terminate the processing prematurely (as long as they are satisfied with the guarantee). Alternatively, max_r can be specified with appropriate value and used to terminate iDistanceKNN prematurely. Theorem 2 Algorithm iDistanceKNN terminates when the KNNs are found and the answer is correct. Proof Let q be the query point. Let sphere(q,r) be the spherical region bounded by q with a radius of r. Let P.sub.k denote the Kth nearest point in S, the answer set. We note that algorithm iDistanceKNN terminates when dist(p.sub.k,q).ltoreq.r. There are two scenarios during the search process: Case 1 Sphere(q,r) Contains all the Data Points in S Let p.sub.furthest =furthest(S,q). For all points p in S, such that dist(p,q)<dist(p.sub.furthest,q). Since p.sub.furthest is inside sphere(q,r), dist(p.sub.furthest,q).ltoreq.r. We note that it is not necessary to check sphere(q,r+.DELTA.r) since any point bounded by the region with radii r and (r+.DELTA.r) will be larger than the Kth nearest point found so far. Hence the answers are the Kth nearest. and the program stops. Case 2 S Contains a Point, u, Outside Sphere(q,r) This occurs when a point lies in the strip that need to be checked, and it happens to be the Kth nearest so far. dist(u,q)>r, and hence r has to be enlarged: r=r+.DELTA.r Suppose the enlarged search sphere encounters a point v in the newly enlarged region, dist(v,q)<r. If dist(v,q)<dist(u,q), then u will be replaced by o. o is the point furthest from q: p.sub.furthest =o; Now, since dist(o,q)<r, all the answers are the Kth nearest and the program stops. .quadrature. 5.3 Splitting the Data Space and Selection of Reference Points To support distance-based similarity search, we need to split the data space into partitions and for each partition, we need a representative point where all data points in that partition can be made reference to. The way the data space is split, and the choice of the reference points can affect performance. Here, we shall look at two partitioning methods, and their corresponding reference point selection heuristics. 5.3.1 Equal Partitioning of Data Space A straight forward approach to data space partitioning is to subdivide it into equal partition. In a d-dimensional space, we have 2d hyperplanes. The method we adopted is to partition the space into 2d pyramids with the centroid of the unit cube space as their tip, and each hyperplane forming the base of each pyramid. Now, we expect equi-partitioning to be effective if the data are uniformly distributed. We note that within one partition, the maximal distance to a hyperplane center, dist_max, can be as large as 0.5*√.sup.2 d-1. Each of the hyperspheres with radius dist_max overlaps with one another in unit cube space. We study the following possible reference points, where the actual data space of hyperspheres do not overlap: 1. Centroid of hyperplane, Closest Distance. The centroid of each hyperplane can be used as a reference point, and the partition associated with the point contains all points that are nearest to it. FIG. 6 shows an example in 2-d space. Here, O.sub.1, O.sub.2, O.sub.3 and O.sub.4 are the reference points, and point A is closest to O.sub.1 and so belongs to the partition associated with it (the shaded region). Moreover, as shown, the actual data space is disjoint though the hyperspheres overlap. 2. Centroid of hyperplane, Furthest Distance. The centroid of each hyperplane can be used as a reference point, and the partition associated with the point contains all points that are furthest from it. FIGS. 7A-7B show an example in 2-d space of the space partitioning by the method, and the reduction in query space respectively. As shown, the. affected area can be greatly reduced (as compared to the closest distance counterpart. 3. External point. Any point along the line formed by the centroid of a hyperplane and the centroid of the corresponding data space can also be used as a reference point. (We note that the other two reference points are actually special cases of this.) By external point, we refer to a reference point that falls out of the data space. This heuristics is expected to perform well when the affected area is quite large, especially when the data are uniformly distributed. We note that both closest and furthest distance can also be supported. FIGS. 8A-8B show an example of closest distance for 2-d space, and the reduction in query space respectively. Again, we observe that the affected space under external point is reduced (compared to using the centroid of the hyperplane). While the data space does not change, the index value of data points will change accordingly. Such characteristic can be used to avoid having too many points being mapped into the same indexed value, or appearing on the same ring. As such picking a good reference point is crucial, and a reference point can be used as a tuning factor for effective performance. 5.4 Cluster Based Partitioning As mentioned, equi-partitioning is expected to be effective only if the data are uniformly distributed. However, data points are often correlated. Even when no correlation exists in all dimensions, there are usually subsets of data that are locally correlated. In these cases, a more appropriate partitioning strategy would be to identify clusters from the data space. However, in high-dimensional data space, the distribution of data points is sparse, and hence clustering is not as straightforward as in low-dimensional databases. There are several existing clustering schemes in the literature such as BIRCH, CURE, and PROCLUS. While our metric based indexing is not dependent on the underlying clustering method, we expect the clustering strategy to have an influence on retrieval performance. In this paper, we adopt a sampling-based approach. The method comprises four steps. First, we obtain a sample of the database. Second, from the sample, we can obtain the statistics on the distribution of data in each dimension. Third, we select k.sub.i values from dimension i. These k.sub.i values are those values whose frequencies exceed a certain threshold value. We can then form .PI.k.sub.i centroids from these values. For example, in a 2-dimensional data set, we can pick 2 high frequency values, say 0.2 and 0.8, on one dimension, and 2 high frequency values, say 0.3 and 0.6, on another dimension. Based on this, we can predict the clusters could be around (0.2,0,3), (0.2,0.6), (0.8,0.3) or (0.8,0.6), which can be treated as the clusters' centroids. Fourth, we count the data that are nearest to each of the centroids; if there are certain number of data around a centroid, then we can estimate that there is a cluster there. We note that the third step of the algorithm is crucial since the number of clusters can have an impact on the search area and the number of traversals from the root to the leaf nodes. When the number of clusters is small, more points are likely to have similar distance to a given reference point. On the other hand, when the number of clusters is large, more data spaces, defined by spheres with respect to centroid of clusters, are likely to overlap, and incur additional traversal and searching. Our solution is simple: if the number of clusters is too many, we can merge whose centroids are closest; similarly, if the number of clusters is too few, we can split a large clusters into two smaller ones. We expect the number of clusters to be a tuning parameter, and may vary for different applications and domains. Once the clusters are obtained, we need to select the reference points. Again, we have several possible options when selecting reference points: 1. Centroid of cluster. The centroid of a cluster is a natural candidate as a reference point. FIG. 9 shows a 2-d example. Here, we have 2 clusters, one cluster has centroid O.sub.1 and another has centroid O.sub.2. 2. Edge of cluster. As shown in FIG. 9, when the centroid is used, both clusters have to be enlarged to include outlier points, leading to significant overlap in the data space. To minimize the overlap, we can select points on the edge of the hyperplanes as reference points. FIG. 10 is an example of 2-dimensional data space. There are two clusters and the edge points are O.sub.1 :(0,1) and O.sub.2 :(1,0). As shown, the overlap of the two partitions is smaller than that using cluster centroids as reference points. 5.5 A Performance Study To study the effectiveness of iDistance, we conducted an extensive performance study. As reference, we compare iDistance against linear scan (which has been shown to be effective for KNN queries in high dimensional data space) and an extended version of iMinMax(.theta.). iMinMax(.theta.) maps a high dimensional point to either the maximum or minimum value of the values among the various dimensions of the point, and a range query requires d subqueries. we extended iMinMax(.theta.) to support KNN queries, and to return approximate answers progressively. We note that iMinMax(.theta.) is designed for window queries, and the concept of distance/similarity is not built in. As such, because search is done based on a single dimension, there is no guarantee that any answer set obtained are the K closest neighbors until the entire data set is examined. We implemented iMinMax(.theta.) and the iDistance technique and their search algorithms in C, and used the B.sup.+ -tree as the single dimensional index structure. Each index page is 4 KB page. All the experiments are performed on a 300-MHz SUN Ultra 10 with 64 megabytes main memory, running SUN Solaris. We conducted many experiments using various data sets, with some deriving from LUV color histograms of 20,000 images. For the synthetic data sets, we generated 8, 16, 30-dimensional uniform data sets. The data size ranges from 100,000 to 500,000. For the clustered data sets, we used a clustering algorithm similar to BIRCH to generate the data sets. For each query, a d-dimensional point is used, and we issue five hundreds of such points, and take the average. The relative performance of the various schemes are similar for most of the experiments conducted. Here, we shall report some of the more interesting and representative results. 5.5.1 Effect of Search Radius In high-dimensional similarity search, the search around the neighborhood is required to find K nearest neighbors. Typically, a small search sphere is used and enlarged when the search condition cannot be met. Hence, it is important to study the effect of search radius on the proposed index methods. In this experiment, we used 8-dimensional, 16-dimensional and 30-dimensional, 100K tuple uniformly distributed data sets. We use only the (centroid,closest distance) combination in this experiment. FIG. 11-13 show the accuracy of KNN answers with respect to the search radius (querydist). By "accuracy", we refer to the quality of the answers obtained. For example, 50% accuracy for a K NN query means that 50% of the answers obtained so far are in the actual answer set. The results show that as radius increases, the accuracy improves and hits 100% at certain query distance. A query with smaller K requires less searching to retrieve the required answers. As the number of dimension increases, the radius required to obtain 100% also increases due to increase in possible distance between two points and sparsity of data space in higher-dimensional space. However, we should note that the seemingly large increase is not out of proportion with respect to the total possible dissimilarity. We also observe that iDistance is capable of generating lots of nearest neighbors with a small query radius. We shall show the effect of radius on other data distributions and various data partitioning schemes as we discuss other performance issues. In FIG. 14, we see the retrieval efficiency of iDistance for 10-NN queries. First, we note that we have stopped at radius around 0.5. This is because the algorithm is able to detect all the nearest neighbors once the radius reaches that length. As shown, iDistance can provide fast initial answers quickly (compared to linear scan). Moreover, iDistance can produce the complete answers much faster than linear scan for reasonable number of dimensions (i.e., 8 and 16). When the number of dimensions reaches 30, iDistance takes a longer time to produce the complete answers. This is expected since the data are uniformly distributed. However, because of its ability to produce approximate answers, iDistance is a promising strategy to adopt. 5.5.2 Effect of Reference Points on Equi-Partitioning Schemes In this experiment, we evaluate the efficiency of equi-partitioning-based iDistance schemes using one of the previous data sets. FIG. 15 shows the results for (centroid,closest) combination with three (external point, closest) schemes. Each of the external points is further away from the hyperplane centroid than the others. First, we note that the I/O cost increases with radius when doing KNN search. This is expected since a larger radius would mean increasing number of false hits and more data are examined. We also notice that it turns out that iDistance-based schemes are very efficient in producing fast first answers, as well as the complete answers. Moreover, we note that the further away the reference point from the hyperplane centroid, the better is the performance. This is because the data space that is required to be traversed is smaller in these cases as the point gets further away. For clustered data sets, we shall illustrate the effect of reference points in the next subsection. 5.5.3 Performance of Cluster-based Schemes In this experiment, we tested a data set with 100K data points of 20 and 50 clusters, and some of the clusters are overlapped with each other. To test the effect of the number of partitions on KNN, we merge some number of close clusters to form a larger partition. We use the edge near to the cluster as its reference point for the partition. Comparison is shown in FIG. 16 and FIG. 17. As with the other experiments, we notice that the complete answer set can be obtained with a reasonably small radius (see FIG. 16). We also notice that a smaller number of partitions performs better in returning the K points. This is probably due to the larger partition size for small number of partitions. The I/O results for 10-NN is shown in FIG. 17. The results show a slightly different trend. First, we see that the cluster-based scheme can obtain the complete set of answers in a short time. Second, we note that a smaller number of partitions incur higher I/O cost. This is reasonable since a smaller number of partitions would mean that each partition is larger, and the number of false drops being accessed is also higher. Finally, it is clear from the result that iDistance can not only provide fast initial answers, but can outperform linear scan by a wide margin. In this result, iDistance's number of I/Os is at most halve that of linear scan, and be as small as 20% that of linear scan. We also repeated the experiments for a larger data set of 500K points of 50 clusters using the edge of cluster strategy in selecting the reference points. FIG. 18 shows the searching radius required for locating K (K=1, 10, 20, 100) nearest neighbors when 50 partitions were used. The results show that searching radius does not increase (compared to small data set) in order to get good percentage of KNN. However, the data size does have great impact on the query cost. FIG. 19 shows the I/O cost for 10-NN queries and the speedup factor of 4 over linear scan when all ten NNs were retrieved. FIG. 20 and FIG. 21 show how the I/O cost is affected as the nearest neighbors are being returned. Here, a point (x, y) in the.graph means that x percent of the K nearest points are obtained after y number of I/Os. Here, we note that all the proposed schemes can produce 100% answers at a much lower cost than linear scan. In fact, the improvement can be as much as five times. The results in FIG. 20 also show that picking an edge point to the the reference point is generally better because it can reduce the amount of overlap. 5.5.4 CPU Time While linear scan incurs less seek time, linear scan of a feature file entails examination of each data point (feature) and calculation of distance between each data point and the query point. Further, due to the limited buffer size, the feature file may be scanned intermittenly. The above factors will have impact on the overall CPU time. FIG. 22 shows the CPU time of linear scan and iDistance for the same experiment as in FIG. 17. It is interesting to note that the performance in terms of CPU time approximately reflects the trend in page accesses. The results show that the best iDistance method achieves about a seven fold increase in speed. We omit iMinMax in our comparison as iMinMax has to search the whole index in order to ensure 100% accuracy, and its CPU time at that point is much higher than linear scan. Further optimization of B.sup.+ -trees that could benefit iDistance is possible. For example, since the leaf nodes of a B.sup.+ -tree are chained, they can be organized into contiguous blocks and each block, rather than a page, can be fetched at a time. However, this requires further study. 5.5.5 A Comparative Study In this study, we compare iDistance with iMinMax and linear scan. Our first experiment uses a 100K 30-dimensional uniform data set. The query is a 10-NN query. For iDistance, we use the (external point, furthest) scheme. FIG. 23 shows the result of the experiment. First, we note that both iMinMax and iDistance can produce quality approximate answers very quickly compared to linear scan. As shown, the I/O cost is lower than linear scan with up to 95% accuracy. However, because the data is uniformly distributed, to retrieve all the 10 NN takes a longer time than linear scan since all points are almost equidistant to one another. Second, we note that iMinMax and iDistance perform equally well. In another set of experiment, we use a 100K 30-dimensional clustered data set. The query is still a 10-NN query. Here, we study two version of cluster-based iDistance--one that uses the edge of the cluster as a reference point, and another that uses the centroid of the cluster. FIG. 24 summarizes the result. First, we observe that among the two cluster-based schemes, the one that employs the edge reference points performs best. This is because of the smaller overlaps in space of this scheme. Second, as in earlier experiments, we see that the cluster-based scheme can return initial approximate answer quickly, and can eventually produce the final answer set much faster than the linear scan. Third, we note that iMinMax can also produce approximate answers quickly. However, its performance starts to degenerate as the radius increases, as it attempts to search for exact K NNs. Unlike iDistance which terminates once the K nearest points are determined, iMinMax cannot terminate until the entire data set is examined. As such, to obtain the final answer set, iMinMax performs poorly. Finally, we see that the relative performance between iMinMax and iDistance for clustered data set is different from that of uniform data set. Here, iDistance outperforms iMinMax by a wide margin. This is because of the larger number of false drops produced by iMinMax.
|
Same subclass Same class Consider this |
||||||||||