精华内容
下载资源
问答
  • 近似最近邻搜索是一个基本问题,并且已经研究了几十年。 最近基于图的索引方法已经证明了它们的高效率,其主要思想是离线构造邻域图并从在线图的一些采样点开始执行贪婪搜索。 现有的大多数基于图的方法都集中于具有...
  • 最近邻检索的发展2.1 精确检索2.2 近似检索参考文献 1. 最近邻检索(Nearest Neighbor Search) 1.1 概述 最近邻检索就是根据数据的相似性,从数据库中寻找与目标数据最相似的项目。这种相似性通常会被量化到...

    1. 最近邻检索(Nearest Neighbor Search)

    1.1 概述

    最近邻检索就是根据数据的相似性,从数据库中寻找与目标数据最相似的项目。这种相似性通常会被量化到空间上数据之间的距离,可以认为数据在空间中的距离越近,则数据之间的相似性越高。

    k最近邻(K-Nearest Neighbor,K-NN)检索:当需要查找离目标数据最近的前k个数据项时。

    最近邻检索是线性复杂度的,不能满足对于大规模数据检索的时间性能要求。

    1.2 应用领域

    1. 起初应用于文档检索系统,最近邻检索作为具有查找相似性文档信息的方法;
    2. 随后在地理信息系统中,最近邻检索也被广泛应用于位置信息,空间数据关系的查询、分析与统计;
    3. 如今在图像检索、数据压缩、模式识别以及机器学习等领域都有非常重要的作用。
    4. 在图像处理与检索的研究中,基于内容的图像检索方法(CBIR)是目前的主流。

    这里的“内容”是指:图像中包含的主要对象的几何形状、颜色强度、表面纹理等外在特性,以及前景与后景的对比程度等整体特征。这里的“内容”是指图像中包含的主要对象的几何形状、颜色强度、表面纹理等外在特性,以及前景与后景的对比程度等整体特征。

    图像的描述方式:局部特征描述子(SIFT、SURF、BRIEF) ,全局特征描述子(GIST),特征频率直方图,纹理信息,显著性区域等。

    最近邻检索的引入将图像检索转化到特征向量空间,通过查找与目标特征向量距离最近的向量来获得相应图像之间的关系。 这种特征向量之间的距离通常被定义为欧几里得距离(Euclidean distance),即是空间中两点之间的直线距离。

    2. 最近邻检索的发展

    最近邻检索作为数据检索中使用最为广泛的技术一直以来都是国内外学者研究的热点。近些年,涌现出大量以最近邻检索或近似最近邻检索为基本思想的两类方法。一类是基于提升检索结构性能的方法,主要方法大多基于树形结构;另一类主要基于对数据本身的处理,包括哈希算法、矢量量化方法等。

    2.1 精确检索

    1. 背景:精确检索中数据维度一般较低,所以会采用穷举搜索,即在数据库中依次计算其中样本与所查询数据之间的距离,抽取出所计算出来的距离最小的样本即为所要查找的最近邻。当数据量非常大的时候,搜索效率急剧下降。

    2. 基于树结构的最近邻检索方法

      概述:由于实际数据会呈现出簇状的聚类形态,因此可以考虑对数据库中的样本数据构建数据索引,索引树就是最常见的方法。其基本思想是对搜索空间进行层次划分,再进行快速匹配。

      结论:当数据维度不太高(如d< 20),通常采用树型索引结构对数据进行分区以实现高效索引,如最经典的KD树算法 、R树、M树等等,它们的时间和空间复杂度都是以d为指数的指数级别的,在实际搜索时也取得了良好的效果。

    当d=1时,只要采用传统的二分查找法或者各类平衡树就能找到最近邻;
    当d=2时,将最近邻检索问题转化为求解查询点究竟落在哪个区域的Voronoi图问题,再通过二分查找树就能很好的解决。

    2.2 近似检索

    1. 背景:面对庞大的数据量以及数据库中高维的数据信息,现有的基于 NN 的检索方法无法获得理想的检索效果与可接受的检索时间。因此,研究人员开始关注近似最近邻检索(Approximate Nearest Neighbor,ANN)。

    2. 概述

      近似最近邻检索利用数据量增大后数据之间会形成簇状聚集分布的特性,通过对数据分析聚类的方法对数据库中的数据进行分类或编码,对于目标数据根据其数据特征预测其所属的数据类别,返回类别中的部分或全部作为检索结果。

      近似最近邻检索的核心思想:搜索可能是近邻的数据项而不再只局限于返回最可能的项目,在牺牲可接受范围内的精度的情况下提高检索效率。

    3. 分类
      一种是采用哈希散列的办法,另一种则是矢量量化。

      3.1 局部敏感哈希(LSH)
      核心思想:在高维空间相邻的数据经过哈希函数的映射投影转化到低维空间后,他们落入同一个吊桶的概率很大而不相邻的数据映射到同一个吊桶的概率则很小。在检索时将欧式空间的距离计算转化到汉明(Hamming)空间,并将全局检索转化为对映射到同一个吊桶中的数据进行检索,从而提高了检索速度。这种方法的主要难点在于如何寻找适合的哈希函数。

      3.2 矢量量化
      其代表是乘积量化(PQ)。它的主要思想是将特征向量进行正交分解,在分解后的低维正交子空间上进行量化,由于低维空间可以采用较小的码本进行编码,因此可以降低数据存储空间 。

      PQ方法采用基于查找表的非对称距离计算(Asymmetric Distance Computation,ADC)快速求取特征向量之间的距离,在压缩比相同的情况下,与采用汉明距离的二值编码方法,采用ADC的PQ方法的检索精度更高。

    参考文献

    最近邻检索的简单综述

    展开全文
  • 快速近似最近邻算法by Braden Riggs and George Williams (gwilliams@gsitechnology.com) Braden Riggs和George Williams(gwilliams@gsitechnology.com) Whether you are new to the field of data science or a ...

    快速近似最近邻算法

    by Braden Riggs and George Williams (gwilliams@gsitechnology.com)

    Braden Riggs和George Williams(gwilliams@gsitechnology.com)

    Whether you are new to the field of data science or a seasoned veteran, you have likely come into contact with the term, ‘nearest-neighbor search’, or, ‘similarity search’. In fact, if you have ever used a search engine, recommender, translation tool, or pretty much anything else on the internet then you have probably made use of some form of nearest-neighbor algorithm. These algorithms, the ones that permeate most modern software, solve a very simple yet incredibly common problem. Given a data point, what is the closest match from a large selection of data points, or rather what point is most like the given point? These problems are “nearest-neighbor” search problems and the solution is an Approximate Nearest Neighbor algorithm or ANN algorithm for short.

    无论您是数据科学领域的新手还是经验丰富的资深人士,您都可能接触过“最近邻居搜索”或“相似搜索”一词。 实际上,如果您曾经使用搜索引擎,推荐器,翻译工具或互联网上的几乎所有其他工具,那么您可能已经在使用某种形式的最近邻居算法。 这些算法已渗透到大多数现代软件中,解决了一个非常简单但难以置信的常见问题。 给定一个数据点,从大量数据点中选择最接近的匹配是什么 ,或者最像给定点的是哪个点? 这些问题是“最近邻居”搜索 问题和解决方案是简称为“ 近似最近邻居”算法或ANN算法。

    Approximate nearest-neighbor algorithms or ANN’s are a topic I have blogged about heavily, and with good reason. As we attempt to optimize and solve the nearest-neighbor challenge, ANN’s continue to be at the forefront of elegant and optimal solutions to these problems. Introductory Machine learning classes often include a segment about ANN’s older brother kNN, a conceptually simpler style of nearest-neighbor algorithm that is less efficient but easier to understand. If you aren’t familiar with kNN algorithms, they essentially work by classifying unseen points based on “k” number of nearby points, where the vicinity or distance of the nearby points are calculated by distance formulas such as euclidian distance.

    近似最近邻算法或ANN是我在博客上大量谈论的主题,并且有充分的理由。 在我们尝试优化和解决最邻近的挑战时,ANN始终站在解决这些问题的优雅且最优的解决方案的最前沿。 机器学习入门课程通常包括有关ANN的哥哥kNN的部分,kNN是概念上更简单的近邻算法样式,效率较低但更易于理解。 如果您不熟悉kNN算法,则它们实际上是通过基于“ k”个邻近点数对看不见的点进行分类来工作的,其中邻近点的邻近度或距离是通过诸如欧几里得距离之类的距离公式来计算的。

    ANN’s work similarly but with a few more techniques and strategies that ensure greater efficiency. I go into more depth about these techniques in an earlier blog here. In this blog, I describe an ANN as:

    ANN的工作与此类似,但是有更多的技术和策略可以确保更高的效率。 我在这里先前的博客中对这些技术进行了更深入的介绍。 在此博客中, 我将ANN描述为

    A faster classifier with a slight trade-off in accuracy, utilizing techniques such as locality sensitive hashing to better balance speed and precision.- Braden Riggs, How to Benchmark ANN Algorithms

    一种更快的分类器,在精度上会稍有取舍,利用诸如位置敏感的哈希值之类的技术来更好地平衡速度和精度。- Braden Riggs,如何对ANN算法进行基准测试

    The problem with utilizing the power of ANNs for your own projects is the sheer quantity of different implementations open to the public, each having their own benefits and disadvantages. With so many choices available how can you pick which is right for your project?

    在您自己的项目中使用ANN的功能所带来的问题是,向公众开放的不同实现的数量庞大,每个实现都有其自身的优缺点。 有这么多的选择,您如何选择最适合您的项目?

    Bernhardsson和ANN救援基准: (Bernhardsson and ANN-Benchmarks to the Rescue:)

    Image for post
    For this project, we need a little help from the experts. Photo by Tra Nguyen on Unsplash
    对于这个项目,我们需要专家的帮助。 Tra NguyenUnsplash拍摄的照片

    We have established that there are a range of ANN implementations available for use. However, we need a way of picking out the best of the best, the cream of the crop. This is where Aumüller, Bernhardsson, and Faithfull’s paper ANN-Benchmarks: A Benchmarking Tool for Approximate Nearest Neighbor Algorithms and its corresponding GitHub repository comes to our rescue.

    我们已经建立了一系列可供使用的ANN实现。 但是,我们需要一种方法来挑选最好的农作物。 这是Aumüller,Bernhardsson和Faithfull的论文ANN基准:近似最近邻算法的基准工具 并且其相应的GitHub存储库可为我们提供帮助。

    The project, which I have discussed in the past, is a great starting point for choosing the algorithm that is the best fit for your project. The paper uses some clever techniques to evaluate the performance of a number of ANN implementations on a selection of datasets. It has these ANN algorithms solve nearest-neighbor queries to determine the accuracy and efficiency of the algorithm at different parameter combinations. The algorithm uses these queries to locate the 10 nearest data points to the queried point and evaluates how close each point is to the true neighbor, which is a metric called Recall. This is then scaled against how quickly the algorithm was able to accomplish its goal, which it called Queries per Second. This metric provides a great reference for determining which algorithms may be most preferential for you and your project.

    我过去讨论过的项目是选择最适合您项目的算法的一个很好的起点。 本文使用一些巧妙的技术来评估多种ANN实施对所选数据集的性能。 它具有这些ANN算法来解决最近邻居查询,以确定算法在不同参数组合下的准确性和效率。 该算法使用这些查询来定位最接近查询点的10个数据点,并评估每个点与真正邻居的接近程度,这是一个称为“召回率”的度量。 然后,根据算法能够实现其目标的速度(称为“每秒查询”)进行缩放。 该指标为确定哪种算法可能最适合您和您的项目提供了很好的参考。

    Image for post
    Screenshot from an earlier blog where I recreated Bernhardsson’s results benchmarking ANN algorithms on the Gloce-25-angular NLP dataset. Read more here. Image by Author.
    我以前的博客中的屏幕快照,在该博客中我重新创建了Bernhardsson的结果,该结果对Gloce-25角NLP数据集的ANN算法进行了基准测试。 在这里 阅读更多 。 图片由作者提供。

    Part of conducting this experiment requires picking the algorithms we want to test, and the dataset we want to perform the queries on. Based off of the experiments I have conducted on my previous blogs, narrowing down the selection of algorithms wasn’t difficult. In Bernhardsson’s original project he includes 18 algorithms. Given the performance I had seen in my first blog, using the glove-25 angular natural language dataset, there are 9 algorithms worth considering for our benchmark experiment. This is because some algorithms perform so slowly and so poorly that they aren’t even worth considering in this experiment. The algorithms selected are:

    进行此实验的一部分需要选择我们要测试的算法,以及我们要对其执行查询的数据集。 根据我在以前的博客上进行的实验,缩小算法的选择范围并不困难。 在Bernhardsson的原始项目中,他包括18种算法。 鉴于我在第一个博客中看到的性能,使用了Gloves-25角度自然语言数据集,有9种算法值得我们进行基准测试。 这是因为某些算法的执行速度如此之慢且如此差,以至于在本实验中甚至都不值得考虑。 选择的算法是:

    • Annoy: Spotify's “Approximate Nearest Neighbors Oh Yeah” ANN implementation.

      烦恼: Spotify的 “哦,是,最近的邻居” ANN实现。

    • Faiss: The suite of algorithms Facebook uses for large dataset similarity search including Faiss-lsh, Faiss-hnsw, and Faiss-ivf.

      Faiss: Facebook用于大型数据集相似性搜索的算法套件,包括Faiss-lshFaiss-hnswFaiss-ivf

    • Flann: Fast Library for ANN.

      Flann: ANN的快速库。

    • HNSWlib: Hierarchical Navigable Small World graph ANN search library.

      HNSWlib:分层可导航小世界图ANN搜索库。

    • NGT-panng: Yahoo Japan’s Neighborhood Graph and Tree for Indexing High-dimensional Data.

      NGT-panng: Yahoo Japan的邻域图和树,用于索引高维数据。

    • Pynndescent: Python implementation of Nearest Neighbor Descent for k-neighbor-graph construction and ANN search.

      Pynndescent:用于k邻域图构建和ANN搜索的Nearest Neighbor Descent的Python实现。

    • SW-graph(nmslib): Small world graph ANN search as part of the non-metric space library.

      SW-graph(nmslib):小世界图ANN搜索,作为非度量空间库的一部分。

    In addition to the algorithms, it was important to pick a dataset that would help distinguish the optimal ANN implementations from the not so optimal ANN implementations. For this task, we chose 1% — or a 10 million vector slice — of the gargantuan Deep-1-billion dataset, a 96 dimension computer vision training dataset. This dataset is large enough for inefficiencies in the algorithms to be accentuated and provide a relevant challenge for each one. Because of the size of the dataset and the limited specification of our hardware, namely the 64GBs of memory, some algorithms were unable to fully run to an accuracy of 100%. To help account for this, and to ensure that background processes on our machine didn’t interfere with our results, each algorithm and all of the parameter combinations were run twice. By doubling the number of benchmarks conducted, we were able to average between the two runs, helping account for any interruptions on our hardware.

    除算法外,重要的是选择一个有助于区分最佳ANN实现与非最佳ANN实现的数据集。 为此,我们选择了庞大的Deep-billion数据集(96维计算机视觉训练数据集)的1%(即一千万个矢量切片)。 该数据集足够大,可以突出算法的低效率,并为每个算法带来相关挑战。 由于数据集的大小和我们硬件的有限规格(即64GB内存),某些算法无法完全运行到100%的精度。 为了解决这个问题,并确保我们机器上的后台进程不会干扰我们的结果,每种算法和所有参数组合都运行两次。 通过将执行的基准测试数量加倍,我们可以在两次运行之间求平均值,从而帮助解决硬件上的任何中断。

    This experiment took roughly 11 days to complete but yielded some helpful and insightful results.

    该实验大约花费了11天的时间,但得出了一些有益而有见地的结果。

    我们发现了什么? (What did we find?)

    After the exceptionally long runtime, the experiment completed with only three algorithms failing to fully reach an accuracy of 100%. These algorithms were Faiss-lsh, Flann, and NGT-panng. Despite these algorithms not reaching perfect accuracy, their results are useful and indicate where the algorithm may have been heading if we had experimented with more parameter combinations and didn't exceed memory usage on our hardware.

    经过异常长的运行时间后,该实验仅用三种算法就无法完全达到100%的精度。 这些算法是Faiss-lshFlannNGT-panng 。 尽管这些算法没有达到理想的精度,但是它们的结果还是有用的,它们表明如果我们尝试了更多的参数组合并且未超过硬件上的内存使用量,该算法可能会前进。

    Before showing off the results, let’s quickly discuss how we are presenting these results and what terminology you need to understand. On the y-axis, we have Queries per Second or QPS. QPS quantifies the number of nearest-neighbor searches that can be conducted in a second. This is sometimes referred to as the inverse ‘latency’ of the algorithm. More precisely QPS is a bandwidth measure and is inversely proportional to the latency. As the query time goes down, the bandwidth will increase. On the x-axis, we have Recall. In this case, Recall essentially represents the accuracy of the function. Because we are finding the 10 nearest-neighbors of a selected point, the Recall score takes the distances of the 10 nearest-neighbors our algorithms computed and compares them to the distance of the 10 true nearest-neighbors. If the algorithm selects the correct 10 points it will have a distance of zero from the true values and hence a Recall of 1. When using ANN algorithms we are constantly trying to maximize both of these metrics. However, they often improve at each other’s expense. When you speed up your algorithm, thereby improving latency, it becomes less accurate. On the other hand, when you prioritize its accuracy, thereby improving Recall, the algorithm slows down.

    在展示结果之前,让我们快速讨论一下我们如何呈现这些结果以及您需要了解哪些术语。 在y轴上,我们有每秒查询数或QPS。 QPS量化了每秒可以进行的最近邻居搜索的次数。 有时将其称为算法的逆“潜伏期”。 更准确地说,QPS是带宽量度,与延迟成反比。 随着查询时间的减少,带宽将增加。 在x轴上,我们有Recall 。 在这种情况下,调用实质上代表了函数的准确性。 由于我们正在查找选定点的10个最近邻居,因此Recall分数将采用我们的算法计算出的10个最近邻居的距离,并将它们与10个真实最近邻居的距离进行比较。 如果该算法选择了正确的10个点,则它与真实值的距离为零,因此召回率为1。使用ANN算法时,我们一直在不断尝试使这两个指标最大化。 但是,它们通常会以互相牺牲为代价而有所改善。 当您加快算法速度从而改善延迟时,它的准确性就会降低。 另一方面,当您优先考虑其准确性从而提高查全率时,该算法会变慢。

    Pictured below is the plot of Queries Performed per Second, over the Recall of the algorithm:

    下图是算法调用每秒执行查询的图:

    Image for post
    The effectiveness of each algorithm as evaluated by Queries per Second which is scaled logarithmically and Recall (accuracy). The further up and to the right the algorithm’s line is, the better said algorithm performed. Image by Author.
    通过每秒查询数评估的每种算法的有效性,该算法的对数和查全率(准确度)均按比例缩放。 该算法的行越靠右,则该算法执行得越好。 图片由作者提供。

    As evident by the graph above there were some clear winners and some clear losers. Focusing on the winners, we can see a few algorithms that really stand out, namely HNSWlib (yellow) and NGT-panng (red) both of which performed at a high accuracy and a high speed. Even though NGT never finished, the results do indicate it was performing exceptionally well prior to a memory-related failure.

    从上图可以明显看出,有一些明显的赢家和一些明显的输家。 着眼于获胜者,我们可以看到一些真正脱颖而出的算法,即HNSWlib(黄色)和NGT-panng(红色),它们均以高精度和高速执行。 尽管NGT从未完成,但结果确实表明它在与内存相关的故障之前表现出色。

    So given these results, we now know which algorithms to pick for our next project right?

    因此,鉴于这些结果,我们现在知道为下一个项目选择哪种算法对吗?

    Unfortunately, this graph doesn’t depict the full story when it comes to the efficiency and accuracy of these ANN implementations. Whilst HNSWlib and NGT-panng can perform quickly and accurately, that is only after they have been built. “Build time” refers to the length of time that is required for the algorithm to construct its index and begin querying neighbors. Depending on the implementation of the algorithm, build time can be a few minutes or a few hours. Graphed below is the average algorithm build time for our benchmark excluding Faiss-HNSW which took 1491 minutes to build (about 24 hours):

    不幸的是,当涉及到这些ANN实现的效率和准确性时,该图并没有完整描述。 虽然HNSWlib和NGT-panng可以快速而准确地执行,但这只是在它们构建之后。 “构建时间”是指算法构建其索引并开始查询邻居所需的时间长度。 根据算法的实现,构建时间可能是几分钟或几小时。 下图是我们的基准测试的平均算法构建时间, 不包括Faiss-HNSW,该过程花费了1491分钟的构建时间(约24小时)

    Image for post
    Average build time, in minutes, for each algorithm tested excluding Faiss-HNSW which took 24 hours to build. Note how some of the algorithms that ran quickly took longer to build. Image by Author.
    测试的每种算法的平均构建时间(以分钟为单位)(不包括Faiss-HNSW花费的24小时构建时间)。 请注意,快速运行的某些算法是如何花较长时间构建的。 图片由作者提供。

    As we can see the picture changes substantially when we account for the time spend “building” the algorithm’s indexes. This index is essentially a roadmap for the algorithm to follow on its journey to find the nearest-neighbor. It allows the algorithm to take shortcuts, accelerating the time taken to find a solution. Depending on the size of the dataset and how intricate and comprehensive this roadmap is, build-time can be between a matter of seconds and a number of days. Although accuracy is always a top priority, depending on the circumstances it may be advantageous to choose between algorithms that build quickly or algorithms that run quickly:

    正如我们看到的那样,当我们考虑“构建”算法索引所花费的时间时,情况会发生很大的变化。 该索引本质上是该算法在查找最近邻居的过程中要遵循的路线图。 它允许算法采用快捷方式,从而加快了找到解决方案的时间。 根据数据集的大小以及此路线图的复杂程度,构建时间可能在几秒钟到几天之间。 尽管准确性始终是头等大事,但根据具体情况,在快速构建的算法或快速运行的算法之间进行选择可能会比较有利:

    • Scenario #1: You have a dataset that updates regularly but isn’t queried often, such as a school’s student attendance record or a government’s record of birth certificates. In this case, you wouldn’t want an algorithm that builds slowly because each time more data is added to the set, the algorithm must rebuild it’s index to maintain a high accuracy. If your algorithm builds slowly this could waste valuable time and energy. Algorithms such as Faiss-IVF are perfect here because they build fast and are still very accurate.

      方案1:您有一个定期更新但不经常查询的数据集,例如学校的学生出勤记录或政府的出生证明记录。 在这种情况下,您不希望算法构建缓慢,因为每次将更多数据添加到集合中时,该算法必须重建其索引以保持较高的准确性。 如果算法构建缓慢,可能会浪费宝贵的时间和精力。 Faiss-IVF之类的算法在这里非常理想,因为它们构建速度很快并且仍然非常准确。

    • Scenario #2: You have a static dataset that doesn’t change often but is regularly queried, like a list of words in a dictionary. In this case, it is more preferential to use an algorithm that is able to perform more queries per second, at the expense of built time. This is because we aren’t adding new data regularly and hence don’t need to rebuild the index regularly. Algorithms such as HNSWlib or NGT-panng are perfect for this because they are accurate and fast, once the build is completed.

      场景2:您有一个静态数据集,该数据集不会经常更改,而是会定期查询,例如字典中的单词列表。 在这种情况下,更可取的是使用能够每秒执行更多查询的算法,但会浪费构建时间。 这是因为我们不会定期添加新数据,因此不需要定期重建索引。 HNSWlib或NGT-panng之类的算法非常适合此操作,因为一旦构建完成,它们便准确且快速。

    There is a third scenario worth mentioning. In my experiments attempting to benchmark ANN algorithms on larger and larger portions of the deep1b dataset, available memory started to become a major limiting factor. Hence, picking an algorithm with efficient use of memory can be a major advantage. In this case, I would highly recommend the Faiss suite of algorithms which have been engineered to perform under some of the most memory starved conditions.

    还有第三种情况值得一提。 在我的实验中,试图在Deep1b数据集的越来越大的部分上对ANN算法进行基准测试 ,可用内存开始成为主要的限制因素。 因此,选择一种有效利用内存的算法可能是一个主要优势。 在这种情况下,我强烈建议使用Faiss算法套件,这些套件经设计可在某些内存不足的情况下执行。

    Regardless of the scenario, we almost always want high accuracy. In our case accuracy, or recall, is evaluated based on the algorithm’s ability to correctly determine the 10 nearest-neighbors of a given point. Hence the algorithm’s performance could change if we consider its 100 nearest-neighbors or its single nearest-neighbor.

    无论哪种情况,我们几乎总是希望获得高精度。 在我们的情况下,根据算法正确确定给定点的10个最近邻居的能力来评估准确性或召回率。 因此,如果我们考虑它的100个最近邻居或单个最近邻居,算法的性能可能会改变。

    摘要: (The Summary:)

    Image for post
    What will you pick for your next project? Photo by Franck V. on Unsplash
    您将为下一个项目选择什么? Franck V.Unsplash上的照片

    Based on our findings from this benchmark experiment there are clear benefits to using some algorithms as opposed to others. The key to picking an optimal ANN algorithm is understanding what about the algorithm you want to prioritize and what engineering tradeoffs you are comfortable with. I recommend you prioritize what fits your circumstances, be that speed (QPS), accuracy (Recall), or pre-processing (Build time). It is worth noting algorithms that perform with less than 90% Recall aren’t worth discussing. This is because 90% is considered to be the minimum level of performance when conducting nearest-neighbor search. Anything less than 90% is underperforming and likely not useful.

    根据我们从基准测试中获得的发现,使用某些算法相对于其他算法具有明显的好处。 选择最佳ANN算法的关键是了解要确定优先级的算法是什么,以及需要进行哪些工程折衷。 我建议您优先考虑适合您的情况的速度,速度(QPS),准确性(调用)或预处理(构建时间)。 值得注意的是,执行调用率不到90%的算法不值得讨论。 这是因为在执行最近邻居搜索时,90%被认为是最低性能。 少于90%的广告效果不佳,可能没有用。

    With that said my recommendations are as follows:

    话虽如此,我的建议如下:

    • For projects where speed is a priority, our results suggest that algorithms such as HNSWlib and NGT-panng perform accurately with a greater number of queries per second than alternative choices.

      对于优先考虑速度的项目,我们的结果表明,与其他选择相比,诸如HNSWlibNGT-panng之类的算法每秒可以执行的查询数量更高, 从而能够准确执行。

    • For Projects where accuracy is a priority, our results suggest that algorithms such as Faiss-IVF and SW-graph prioritize higher Recall scores, whilst still performing quickly.

      对于以准确性为优先的项目,我们的结果表明,诸如Faiss-IVFSW-graph之类的算法会优先考虑较高的查全率,同时仍能快速执行。

    • For projects where pre-processing is a priority, our results suggest that algorithms such as Faiss-IVF and Annoy exhibit exceptionally fast build times whilst still balancing accuracy and speed.

      对于需要优先处理的项目,我们的结果表明,诸如Faiss-IVFAnnoy之类的算法显示出异常快的构建时间,同时仍然在准确性和速度之间取得了平衡。

    Considering the circumstances of our experiment, there are a variety of different scenarios where some algorithms may perform better than others. In our case, we have tried to perform in the most generic and common of circumstances. We used a large dataset with high, but not excessively high, dimensionality to help indicate how these algorithms may perform on sets with similar specifications. For some of these algorithms, more tweaking and experimentation may lead to marginal improvements in runtime and accuracy. However, given the scope of this project it would be excessive to attempt to accomplish this with each algorithm.

    考虑到我们的实验环境,在许多不同的情况下,某些算法的性能可能会优于其他算法。 在我们的案例中,我们试图在最普通和最常见的情况下执行。 我们使用了一个具有高(但不是过高)维的大型数据集,以帮助指示这些算法如何在具有相似规格的集合上执行。 对于其中一些算法,更多的调整和实验可能会导致运行时和准确性的轻微改善。 但是,鉴于该项目的范围,尝试使用每种算法来完成此任务将是多余的。

    If you are interested in learning more about Bernhardsson’s project I recommend reading some of my other blogs on the topic. If you are interested in looking at the full CSV file of results from this benchmark, it is available on my GitHub here.

    如果您有兴趣了解有关Bernhardsson项目的更多信息,我建议您阅读其他一些有关该主题的博客。 如果您有兴趣查看此基准测试结果的完整CSV文件,请在我的GitHub上此处获取

    未来的工作: (Future Work:)

    Whilst this is a good starting point for picking ANN algorithms there are still a number of alternative conditions to consider. Going forward I would like to explore how batch performance impacts our results and whether different algorithms perform better when batching is included. Additionally, I suspect that some algorithms will perform better when querying for different numbers of nearest-neighbors. In this project, we chose 10 nearest neighbors, however, our results could shift when querying for 100 neighbors or just the top 1 nearest-neighbor.

    虽然这是选择ANN算法的一个很好的起点,但仍然需要考虑许多替代条件。 展望未来,我想探讨批处理性能如何影响我们的结果以及包括批处理时不同的算法是否表现更好。 另外,我怀疑在查询不同数量的最近邻居时某些算法的性能会更好。 在此项目中,我们选择了10个最近的邻居,但是,当查询100个邻居或仅搜索前1个最近的邻居时,结果可能会发生变化。

    附录: (Appendix:)

    1. Computer specifications: 1U GPU Server 1 2 Intel CD8067303535601 Xeon® Gold 5115 2 3 Kingston KSM26RD8/16HAI 16GB 2666MHz DDR4 ECC Reg CL19 DIMM 2Rx8 Hynix A IDT 4 4 Intel SSDSC2KG960G801 S4610 960GB 2.5" SSD.

      计算机规格: 1U GPU服务器1 2 Intel CD8067303535601Xeon®Gold 5115 2 3 Kingston KSM26RD8 / 16HAI 16GB 2666MHz DDR4 ECC Reg CL19 DIMM 2Rx8 Hynix A IDT 4 4 Intel SSDSC2KG960G801 S4610 960GB 2.5“ SSD。

    2. Link to How to Benchmark ANN Algorithms: https://medium.com/gsi-technology/how-to-benchmark-ann-algorithms-a9f1cef6be08

      链接到如何对ANN算法进行基准测试: https : //medium.com/gsi-technology/how-to-benchmark-ann-algorithms-a9f1cef6be08

    3. Link to ANN Benchmarks: A Data Scientist’s Journey to Billion Scale Performance: https://medium.com/gsi-technology/ann-benchmarks-a-data-scientists-journey-to-billion-scale-performance-db191f043a27

      链接到ANN基准:数据科学家的十亿规模绩效之旅: https : //medium.com/gsi-technology/ann-benchmarks-a-data-scientists-journey-to-billion-scale-performance-db191f043a27

    4. Link to CSV file that includes benchmark results: https://github.com/Briggs599/Deep1b-benchmark-results

      链接到包含基准测试结果的CSV文件: https : //github.com/Briggs599/Deep1b-benchmark-results

    资料来源: (Sources:)

    1. Aumüller, Martin, Erik Bernhardsson, and Alexander Faithfull. “ANN-benchmarks: A benchmarking tool for approximate nearest neighbor algorithms.” International Conference on Similarity Search and Applications. Springer, Cham, 2017.

      Aumüller,Martin,Erik Bernhardsson和Alexander Faithfull。 “ ANN基准:用于近似最近邻算法的基准测试工具。” 国际相似性搜索及其应用会议 。 湛,施普林格,2017

    2. Deep billion-scale indexing. (n.d.). Retrieved July 21, 2020, from http://sites.skoltech.ru/compvision/noimi/

      十亿规模的深索引。 (nd)。 于2020年7月21日从http://sites.skoltech.ru/compvision/noimi/检索

    3. Liu, Ting, et al. “An investigation of practical approximate nearest neighbor algorithms.” Advances in neural information processing systems. 2005.

      刘婷,等。 “研究实用的近似最近邻算法。” 神经信息处理系统的研究进展 。 2005。

    翻译自: https://medium.com/gsi-technology/a-data-scientists-guide-to-picking-an-optimal-approximate-nearest-neighbor-algorithm-6f91d3055115

    快速近似最近邻算法

    展开全文
  • Ann, Approximate Nearest Neighbor的缩写,就是近似最近邻搜索。 在机器学习领域,语义检索,图像识别,推荐系统等方向常涉及到的一个问题是:给定一个向量X=[x1,x2,x3...xn],需要从海量的向量库中找到最相似的前...

    Ann, Approximate Nearest Neighbor的缩写,就是近似最近邻搜索。

    在机器学习领域,语义检索,图像识别,推荐系统等方向常涉及到的一个问题是:给定一个向量X=[x1,x2,x3...xn],需要从海量的向量库中找到最相似的前K个向量。通常这些向量的维度很高,对于在线服务用传统的方法查找是非常耗时的,容易使得时延上成为瓶颈,因此业界通用的方式就是将最相似的查找转换成Ann问题

    这样查找返回的前K个向量并不一定是最相似的K个向量,衡量Ann算法好不好的一个依据是召回,每次Ann请求返回的K个结果与使用暴力查找的K个结果去比较,如果完全一致,说明是最好的。因为省了搜索时间却没有影响效果。

    目前的Ann算法有基于图(hnswlib )的,基于树(pysparnn)的,基于哈希(NearPy这个库)等,并且有很多关于Ann算法的实现,开源的很多,如annoy, faiss,nmslib, falconn,FLANN等。

    更详细的一些测试在这个网站有数据 http://ann-benchmarks.com。作者比较了不同的距离度量方式及在不同数据集的效果。

    基于图的算法(hnsw)其实在评测上看起来是最好的, 但是其耗费比较多内存,树的方法在维度大时会变成暴力搜索,其它方法也有不同的特点。

    我测试过的,一分为两类:稀疏向量和非稀疏向量

    首先:稀疏向量是指维度比较多,而且向量的很多元素是0,啁密向量指零元素较少,向量的维度也就几十到几百。

    如果上万维的一般是稀疏向量(一万个词语词库句子搜索),这样的PySpann最好。

    其次是周密向量,那么faiss应该内存和速度比较均衡 。

     

    pysparnn安装比较简单,下载源码python setup.py install

    faiss的安装如下:

    1 sudo apt-get install libopenblas-dev liblapack3 python-numpy python-dev
    2 apt-get install libblas-dev libatlas-dev liblapack-dev

    swig install
    git clone https://github.com/swig/swig.git

    cd swig
    sudo apt-get install automake
    ./autogen.sh
    ./configure
    sudo apt-get install bison flex
    make
    sudo make install

     

    这样的算法成千上百,对此进行评测https://github.com/erikbern/ann-benchmarks

    评测数据集如下

    Dataset Dimensions Train size Test size Neighbors Distance Download
    DEEP1B 96 9,990,000 10,000 100 Angular HDF5 (3.6GB)
    Fashion-MNIST 784 60,000 10,000 100 Euclidean HDF5 (217MB)
    GIST 960 1,000,000 1,000 100 Euclidean HDF5 (3.6GB)
    GloVe 25 1,183,514 10,000 100 Angular HDF5 (121MB)
    GloVe 50 1,183,514 10,000 100 Angular HDF5 (235MB)
    GloVe 100 1,183,514 10,000 100 Angular HDF5 (463MB)
    GloVe 200 1,183,514 10,000 100 Angular HDF5 (918MB)
    Kosarak 27983 74,962 500 100 Jaccard HDF5 (2.0GB)
    MNIST 784 60,000 10,000 100 Euclidean HDF5 (217MB)
    NYTimes 256 290,000 10,000 100 Angular HDF5 (301MB)
    SIFT 128 1,000,000 10,000 100 Euclidean HDF5 (501MB)

    评估的实现

    • Annoy Spotify自家的C++库(提供Python绑定)。Annoy最突出的特性是支持使用静态索引文件,这意味着不同进程可以共享索引
    • FLANN 加拿大英属哥伦比亚大学出品的C++库,提供C、MATLAB、Python、Ruby绑定。
    • scikit-learn 知名的Python机器学习库scikit-learn提供了LSHForestKDTreeBallTree实现。
    • PANNS 纯Python实现。已“退休”,作者建议使用MRPT。
    • NearPy 纯Python实现。基于局部敏感哈希(Locality-sensitive hashing,简称LSH,一种降维方法)。
    • KGraph C++库,提供Python绑定。基于图(graph)算法。
    • NMSLIB (Non-Metric Space Library) C++库,提供Python绑定,并且支持通过Java或其他任何支持Apache Thrift协议的语言查询。提供了SWGraph、HNSW、BallTree、MPLSH实现。
    • hnswlib(NMSLIB项目的一部分) 相比当前NMSLIB版本,hnswlib内存占用更少。
    • RPForest 纯Python实现。主要特性是不需要在模型中储存所有索引的向量。
    • FAISS Facebook出品的C++库,提供可选的GPU支持(基于CUDA)和Python绑定。包含支持搜寻任意大小向量的算法(甚至包括可能无法在RAM中容纳的向量)。
    • DolphinnPy 纯Python实现。基于超平面局部敏感哈希算法。
    • Datasketch 纯Python实现。基于MinHash局部敏感哈希算法。
    • PyNNDescent 纯Python实现。基于k-近邻图构造(k-neighbor-graph construction)。
    • MRPT C++库,提供Python绑定。基于稀疏随机投影(sparse random projection)和投票(voting)。
    • NGT: C++库,提供了Python、Go绑定。提供了PANNG实现。
    展开全文
  • 搜索最近邻是很多计算机技术中的关键步骤,快速搜索近似最近邻
  • 近似最近邻搜索算法

    2021-04-22 15:20:40
    是通过贪心算法遍历图,找出当前数据集中的最近邻点(局部最小值),以此作为插入并构建生成层状网络图,通过在下一层中不断寻找最近邻点插入构建,从而完成对特征向量集的维度分层、数据压缩、索引生成。...

    定义:

    采用分而治之思想,将原始数据通过映射方法划分到不同的向量空间,针对大规模的搜索任务,通过映射函数在向量相似的空间进行遍历查询。

    常用的几种算法:

    基于图的索引量化法:HNSW
    基于树:Annoy
    基于哈希:SLH

    HNSW(Hierarchical Navigable Small World)

    是通过贪心算法遍历图,找出当前数据集中的最近邻点(局部最小值),以此作为插入并构建生成层状网络图,通过在下一层中不断寻找最近邻点插入构建,从而完成对特征向量集的维度分层、数据压缩、索引生成。检索时,采用自上而下的搜索方式,即从最顶层开始粗略搜索,然后逐步向下层搜索,直到最底层精确搜索。
    在这里插入图片描述
    根据Benchmark上的ANN算法的测试,HNSW算法在查询速度和精度上优于其他算法,但是占用内存大。
    在这里插入图片描述

    HNSW代码

    import hnswlib
    import time
    import os
    import psutil
    def get_ann(length,dimen):
        start_time = time.time()
        pid = os.getpid()
        pp = psutil.Process(pid)
        info_start = pp.memory_full_info().uss/1024/1024
        #向量维度
        dim = dimen
        num_elements = length
        data = X
        data_labels = np.arange(num_elements)
        # 声明索引
        p = hnswlib.Index(space = 'l2', dim = dim) # hnswlib支持的距离有L2距离,向量内积以及cosine相似度
        # 初始化index
        p.init_index(max_elements = num_elements, ef_construction = 100, M = 16)
        # ef: 动态检索链表的大小。ef必须设置的比检索最近邻的个数K大。ef取值范围为k到集合大小之间的任意值。
        p.set_ef(50) 
        p.set_num_threads(4)#cpu多线程并行计算时所占用的线程数
        
        #构建items
        p.add_items(X, data_labels)
        index_path = 'data.bin'
        p.save_index(index_path)
        global labels, distances
        labels, distances = p.knn_query(data, k = 10)
        
        info_end=pp.memory_full_info().uss/1024/1024
        print('用时:%.2f s' % (time.time()-start_time))
        print('运行占内存'+str(info_end-info_start)+'MB')
    get_ann(X.shape[0],X.shape[1])  

    Annoy

    基本思路:
    给定一个查询向量,在一个庞大的向量集合中,找到与查询向量最相似的k个目标向量。工作原理:采用随机投影树,对所有的数据进行划分,将每次搜索与计算的点的数目减小到一个可接受的范围,然后建立多个随机投影树构成随机投影森林,将森林的综合结果作为最终结果。
    如何构建随机森林:
    随机选取一个向量,该向量经过原点,垂直于该向量的直线将平面内的点划分为两个部分,这两个部分的点分别划分给左子树和右子树。用数学语言是说,计算各个点与垂直向量的点积,若点积大于零的点划分到左子树,点积小于零的点划分到右子树。
    优点:
    索引小、内存占用小

    Annoy代码

    from annoy import AnnoyIndex
    import time
    import os
    import psutil
    # from guppy3 import hpy
    def get_nn(length,dimen):
        start_time = time.time()#开始时间
        pid = os.getpid()
        p = psutil.Process(pid)
    #     根据pid找到进程,进而找到占用的内存值
        info_start = p.memory_full_info().uss/1024/1024
        
        f = dimen#X的维度
        t = AnnoyIndex(f,'angular')#返回可读写的新索引,用于存储f维度向量
        for i in range(length):
            v = X[i]
            t.add_item(i,v)#构建 n_trees 的森林。查询时,树越多,精度越高。在调用build后,无法再添加任何向量。
        t.build(10)
        t.save('ann.ann')#将索引保存
        u = AnnoyIndex(f,'angular')
        u.load('ann.ann')
        global nn_list
        nn_list = []
        for i in range(length):
            nn_list.append(u.get_nns_by_item(i,10))#返回第i 个item的n个最近邻的item
            
     
        info_end=p.memory_full_info().uss/1024/1024
        print('用时:%s秒' % (time.time()-start_time))
        print('运行占内存'+str(info_end-info_start)+'MB')
        
        return nn_list
        
    get_nn(len(X),X.shape[1])
    展开全文
  • PyNNDescent 一个Python近似最近邻实现
  • 参考链接 干货 | 一文读懂 ANN 一文尽览近似最近邻搜索中的...最近邻检索(NN)和近似最近邻(ANN)检索 Facebook深度学习应用 | 最近邻搜索算法 速度数百倍之差,有人断言KNN面临淘汰,更快更强的ANN将取而代之 ...
  • 这种称为最近邻下降 (NN-descent) 的方法允许更快速地计算 K-最近邻,代价是返回值可能不是 100% 正确(使其成为“近似”邻居搜索)。 NN-descent 的返回结果通常以 99% 的准确率与准确答案匹配。 NN-descent 算法...
  • 目录 一、随机投影森林-一种近似最近邻方法(ANN) 1.随机投影森林介绍 2、LSHForest/sklearn 二、Kd-Tree的最近邻查找
  • EFANNA: 超快近似最近邻(ANN)搜索C 算法库
  • pgANN - 使用PostgreSQL作为后端进行近似最近邻(ANN)搜索
  • Annoy是高维空间求近似最近邻的一个开源库。 Annoy构建一棵二叉树,查询时间为O(logn)。 Annoy通过随机挑选两个点,并使用垂直于这个点的等距离超平面将集合划分为两部分。 如图所示,图中灰色线是连接两个点,超...
  • 针对现有图像盲取证方法在多重镜像篡改检测效果较差的问题,提出一种基于近似最近邻(ANN)搜索的图像篡改检测方法。提取图像的BRISK(Binary Robust Invariant Scalable Keypoints)特征描述子,获得图像的二值特征向量。...
  • 来自 微软研究院AI头条   编者按:最近邻搜索算法能够帮助人们在海量数据中快速搜索到...基于量化的近似最近邻搜索方法则通过聚类把向量集聚成若干类,每类里面的向量用对应的类中心来近似。 我们每个人每天都...
  • hdidx, 高维数据的近似最近邻( 神经网络) 搜索 HDIdx: 索引高维度数据 什么是 HDIdx?HDIdx 是一个 python 包,用于近似最近邻( 神经网络) 搜索。 最近邻( NN ) 搜索在高维空间中是非常困难的,因为维度维度的灾难性...
  • 局部敏感哈希(LSH)是一种解决近似最近邻问题的流行算法,被证明是解决NNS的一种有效方法。高维和大规模数据库中的问题。 在p稳定LSH方案的基础上,提出了一种基于p稳定LSH的改进算法,称为基于随机性的局部敏感...
  • 针对高维数据近似最近邻查询,在过滤-验证框架下提出了一种基于学习的数据相关的c-近似最近邻查询算法.证明了数据经过随机投影之后,满足语义哈希技术所需的熵最大化准则.把经过随机投影的二进制数据作为数据的类标号,...
  • 利用Hilbert曲线的降维特性,该文提出基于Hilbert曲线近似k-最近邻查询算法AKNN,分析近似k-最近邻的误差。实验结果表明算法在执行时间上优于线性扫描和基于R树最短优先查询算法,近似解的质量较好。
  • OpenCV实现快速近似最近邻(FLANN)

    千次阅读 2020-01-14 21:40:18
    高维数据的快速最近邻算法FLANN FLANN特征匹配
  • 最近邻问题(NN) 将次数看成向量,然后我们就可以比对向量的距离(欧式距离,余弦距离)。数据中会有一些异常点,这些异常点会导致结果的不稳定。 这种思想非常的不稳定,因为他只基于一个样本来做最后类别的判定。 K...
  • KNN(二)--近似最近邻算法ANN

    万次阅读 2016-07-21 21:16:31
    高维数据的快速最近邻算法FLANN 1. 简介  在计算机视觉和机器学习中,对于一个高维特征,找到训练数据中的最近邻计算代价是昂贵的。对于高维特征,目前来说最有效的方法是 the randomized k-d forest和the
  • 针对高维特征向量存在的最近邻匹配正确率低的问题, 提出了一种基于SURF和快速近似最近邻搜索的图像匹配算法。首先用Fast-Hessian 检测子进行特征点检测, 并生成SURF特征描述向量; 然后通过快速近似最近邻搜索算法...
  • 近似最近邻搜索方法FLANN简介

    万次阅读 2015-09-23 16:50:46
    AR/VR群:244751474 ,欢迎加入,进行项目讨论! ---------------------------------------------...我们可以用下面的方式定义最近邻搜索(NNS)问题:在一个度量空间X给定一组点P=p1,p2,…,pn,这些点必须通过以下方
  • 正在进行中的Java实现分层可导航小世界图(HNSW)算法进行近似最近邻搜索。
  • ✏️ 作者介绍:周充,格像科技后端工程师需求背景根据格像科技公司的业务需求,我们需要搭建一个近似最近邻(Approximate Nearest Neighbor,即 ANN)搜...
  • 数据挖掘——近似最近邻算法ANN之LSH简介LSH算法LSH之相似网页查找——Simhash 简介 局部敏感哈希(Locality Sensitive Hashing,LSH)主要是为了处理高维度数据的查询和匹配等操作。 关于这个算法,综合多个前辈的...
  • 最近在看最邻近算法的HNSW论文,这里对里面的几个算法的伪码进行下分析记录。如果想看源码先明白伪码才能更好理解源码。 算法1 插入 INSERT(hnsw, q, M, Mmax, efConstruction, mL) /*** hnsw 表示输出的hnsw图...
  • SRS - 具有微小索引的高维欧几里德空间中的快速近似最近邻搜索 SRS-Mem 是一个 C++ 程序,用于在主存中的高维欧几里德空间中执行近似最近邻搜索。 当前的实现改编自我们的。 主要的修改是使用内存中的多维索引(而...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 425
精华内容 170
关键字:

最近邻近似