a ^g@s0ddlmZesdevr&ddlmZnddlZz ddlZWne yTddlZYn0ddZ dd Z d d Z d d Z GdddeZGdddeZeeejZGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeZ e!e Gd d!d!eZ"e#e"Gd"d#d#eZ$e%e$Gd$d%d%eZ&e'e&Gd&d'd'eZ(e)e(Gd(d)d)eZ*e+e*Gd*d+d+eZ,e-e,Gd,d-d-eZ.e/e.Gd.d/d/eZ0e1e0Gd0d1d1eZ2e3e2Gd2d3d3eZ4e5e4Gd4d5d5eZ6e7e6Gd6d7d7eZ8e9e8Gd8d9d9eZ:e;e:Gd:d;d;eZd>d?Z?Gd@dAdAeZ@eAe@dBdCZBdDdEZCdFdGZDdHdIZEdJdKZFGdLdMdMeZGeHeGejIZIGdNdOdOeZJeKeJdPdQZLdRdSZMdTdUZNdVdWZOdXdYZPdZd[ZQd\d]ZRd^d_ZSddadbZTdcddZUdedfZVdgdhZWdidjZXdkdlZYdmdnZZdodpZ[dqdrZ\dsdtZ]dudvZ^dwdxZ_dydzZ`d{d|Zad}d~ZbddZcddZdddZedddZfddZgddZhddZiddZjddZkddZldddZmddZnddZoddZpddZqGdddeZresereIjtZtGdddeZueveuGdddeZwexewddZyddZzddZ{ddZ|ddZ}ddZ~dddZddZddZddZddZddZddZddZddÄZddńZddDŽZddɄZdd˄Zdd̈́ZddτZddфZddӄZddՄZddׄZdddلZdddۄZddd݄Zddd߄ZddZddZddZGdddeZeeGdddeZeeddZddZddZddZddZddZddZddZddZddZdddZddZddZddZddZejZejZejZejZejZejZejZejZejZejZejZdd ZejZejZejZejZGd d d eZeeGd d d eZeeGdddeZeeGdddeZee¡GdddeZeeġGdddeZeeơGdddeƃZeeȡGdddeȃZeeʡGdddeȃZee̡GdddẽZeeΡGdddeZeeСGd d!d!eZeeҡGd"d#d#eЃZeeԡGd$d%d%eԃZee֡Gd&d'd'eЃZeeءGd(d)d)eZeeڡGd*d+d+e؃Zeeܡd,d-Zސdd.d/Zߐd0d1Zd2d3ZGd4d5d5eZeeGd6d7d7eZeeGd8d9d9eZeeGd:d;d;eZeeGd<d=d=eZeeGd>d?d?eZeeGd@dAdAeZeeGdBdCdCeZeeGdDdEdEeZeedFdGZdHdIZGdJdKdKeZeedLdMZGdNdOdOeZeedPdQZGdRdSdSeZeedTdUZGdVdWdWeZeedXdYZGdZd[d[eZeeGd\d]d]eZeeGd^d_d_eZeeGd`dadaeZe eGdbdcdceZ e e GdddedeeZ e e GdfdgdgeZeeGdhdidieZeeGdjdkdkeZeeGdldmdmeZeeGdndodoeZeeGdpdqdqeZeeGdrdsdseZeeGdtdudueZeeGdvdwdweZeeGdxdydyeZ e!e Gdzd{d{eZ"e#e"Gd|d}d}eZ$e%e$Gd~ddeZ&e'e&GdddeZ(e)e(GdddeZ*e+e*GdddeZ,e-e,GdddeZ.e/e.GdddeZ0e1e0GdddeZ2e3e2Gddde2Z4e5e4GdddeƃZ6e7e6GdddeZ8e9e8GdddeZ:e;e:Gddde:Ze?e>Gddde8Z@eAe@GdddeƃZBeCeBGdddeZDeEeDGdddeZFeGeFGdddeZHeIeHGdddeHZJeKeJGdddeƃZLeMeLGdddeLZNeOeNGdddeLZPeQePGdddeLZReSeRGdddeLZTeUeTGdddeZVeWeVGdddeZXeYeXGdddeVZZe[eZGdddeVZ\e]e\GdddeZ^e_e^GdddeZ`eae`Gddde^ZbecebGddde`ZdeeedGddde^ZfegefGddde`ZheiehGddÄdÐe^ZjekejGdĐdńdŐe`ZlemeldƐdDŽZndȐdɄZodʐd˄ZpGd̐d̈́deZqereqGdΐdτdeZsetesGdАdфdѐesZueveuGdҐdӄdӐesZwexewGdԐdՄdՐewZyezeyGd֐dׄdאewZ{e|e{GdؐdلdِewZ}e~e}GdڐdۄdېewZeeGdܐd݄dݐewZeeGdސd߄deZeeGdddesZeeddZddZddZGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeeZeeGdddeZeeGdddeZeeddZddZddZddZddZddZGdddeZeeddZdd Zdd d Zdd d ZddZdddZGdddeZeeGdddeƃZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGd d!d!eZeeGd"d#d#eZeeGd$d%d%eZeeGd&d'd'eZeeGd(d)d)eZeedd*d+Zd,d-Zd.d/Zdd0d1ZGd2d3d3eZeŐeġGd4d5d5eăZeǐeơGd6d7d7eăZeɐeȡGd8d9d9eăZeːeʡGd:d;d;eăZe͐e̡Gd<d=d=eăZeϐeΡd>d?ZАd@dAZGdBdCdCeZeӐeҡGdDdEdEeZeՐeԡGdFdGdGeZeאe֡GdHdIdIeZeِeءGdJdKdKe؃ZeېeڡGdLdMdMeZeݐeܡGdNdOdOe܃ZeߐeޡdPdQZGdRdSdSeZeeGdTdUdUeZeeGdVdWdWeZeeGdXdYdYeZeeGdZd[d[eZeeGd\d]d]eZeeGd^d_d_eZeeGd`dadaesZeeGdbdcdceZeeGdddedeeZeeGdfdgdgeZeeGdhdidieZeeGdjdkdkeeZeeGdldmdmeZeeGdndodoeZeeGdpdqdqeƃZeeGdrdsdseZeeGdtdudueZeedvdwZGdxdydyeZeeGdzd{d{eZe eGd|d}d}eƃZ e e Gd~ddeZ e e GdddeZeeGddde ZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGddde ZeeGdddeZeeGdddeZeeGdddeZ e!e GdddeZ"e#e"GdddeZ$e%e$GdddeZ&e'e&GdddeZ(e)e(Gddde&Z*e+e*Gddde*Z,e-e,Gddde*Z.e/e.Gddde*Z0e1e0Gddde*Z2e3e2GdddeZ4e5e4Gddde&Z6e7e6dddZ8dddZ9dddZ:ddZ;ddZe=Gddde=Z?e@e?Gddde=ZAeBeAGdddeZCeDeCGddde=ZEeFeEGddde=ZGeHeGGddde=ZIeJeIGddÄdeZKeLeKGdĐdńdŐe=ZMeNeMGdƐdDŽdeZOePeOGdȐdɄdɐe=ZQeReQGdʐd˄dːeOZSeTeSGd̐d̈́d͐eQZUeVeUGdΐdτdϐeSeZWeXeWGdАdфdѐeOZYeZeYGdҐdӄdӐeQZ[e\e[GdԐdՄdeZ]e^e]Gd֐dׄdeZ_e`e_GdؐdلdeZaebeaGdڐdۄdېeaZcedecGdܐd݄dݐeaZeefeeGdސd߄deZgehegGdddeZiejeiGdddeZkelekGdddeZmenemGdddeZoepeoGdddeoZqereqGdddeZsetesGdddeZueveuGdddeƃZwexewGdddewZyezeyGdddeZ{e|e{GdddeZ}e~e}GdddeZeeGddde}ZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdd d eZeeGd d d eZeeGd d d eZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGdddeZeeGddde=ZeeGdddeZeeGdddeZeeejZejZejZejZejZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Zdd<d=Zd>d?ZGd@dAdAeZeeeIjZeIjZeIjZeIjZeIjÐZeIjĐZeIjŐZŐdBdCZƐdDdEZGdFdGdGeZeɐeȡGdHdIdIeȃZeːeʡGdJdKdKeȃZe͐e̡GdLdMdMeZeϐeΡGdNdOdOeZeѐeСGdPdQdQeZeӐeҡGdRdSdSeZeՐeԡdTdUZ֐dVdWZGdXdYdYeZeِeءGdZd[d[e`ZeېeڡGd\d]d]e^ZeݐeܡGd^d_d_eZeߐeޡGd`dadaeZeeGdbdcdceZeeGdddedeeZeeGdfdgdgeZeedhdiZdjdkZGdldmdmeZeeGdndodoeZeeGdpdqdqeZeedrdsZdtduZdvdwZdxdyZGdzd{d{eZeed|d}Zd~dZddZGdddeZeeddZddZddZddZddZddZddZddZdS() version_info.) _swigfaissNcCsBzd|j}Wntjy*d}Yn0d|jj|jj|fS)Nz proxy of z <%s.%s; %s >)this__repr__ __builtin__ Exception __class__ __module____name__)selfZstrthisr]/var/www/html/cobodadashboardai.evdpl.com/venv/lib/python3.9/site-packages/faiss/swigfaiss.py _swig_reprs  rcsfdd}|S)Ncsh|dkr|||nN|dkr,|j|n8t||rXttt||trX|||n td|dS)Nrthisownz(You cannot add instance attributes to %s)rownhasattr isinstancegetattrtypepropertyAttributeError)rnamevaluesetrrset_instance_attrszE_swig_setattr_nondynamic_instance_variable..set_instance_attrr)rrrrr*_swig_setattr_nondynamic_instance_variables rcsfdd}|S)Ncs8t||r(tt||ts(|||n td|dS)Nz%You cannot add class attributes to %s)rrrrr)clsrrrrrset_class_attr)sz?_swig_setattr_nondynamic_class_variable..set_class_attrr)rr!rrr'_swig_setattr_nondynamic_class_variable(s r"csfdd}|S)zlClass decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclasscs|j|j|jSN)r __bases____dict__copy)r  metaclassrrwrapper3sz$_swig_add_metaclass..wrapperr)r(r)rr'r_swig_add_metaclass1s r*c@seZdZdZeejZdS)_SwigNonDynamicMetazKMeta class to enforce nondynamic attributes (no new attributes) for a classN)r r __qualname____doc__r"r __setattr__rrrrr+8sr+c@seZdZeddddddZddZeZej Z dd Z d,d d Z d-d dZ ddZddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+S).SwigPyIteratorcCs |jSr#rrxrrr>zSwigPyIterator.cCs |j|Sr#r0r2vrrrr3>r4The membership flagdoccOs tddSNz*No constructor defined - class is abstractrrargskwargsrrr__init__@szSwigPyIterator.__init__cCs t|Sr#)rZSwigPyIterator_valuerrrrrEszSwigPyIterator.valuercCs t||Sr#)rZSwigPyIterator_incrrnrrrincrHszSwigPyIterator.incrcCs t||Sr#)rZSwigPyIterator_decrrArrrdecrKszSwigPyIterator.decrcCs t||Sr#)rZSwigPyIterator_distancerr2rrrdistanceNszSwigPyIterator.distancecCs t||Sr#)rZSwigPyIterator_equalrErrrequalQszSwigPyIterator.equalcCs t|Sr#)rZSwigPyIterator_copyr@rrrr&TszSwigPyIterator.copycCs t|Sr#)rZSwigPyIterator_nextr@rrrnextWszSwigPyIterator.nextcCs t|Sr#)rZSwigPyIterator___next__r@rrr__next__ZszSwigPyIterator.__next__cCs t|Sr#)rZSwigPyIterator_previousr@rrrprevious]szSwigPyIterator.previouscCs t||Sr#)rZSwigPyIterator_advancerArrradvance`szSwigPyIterator.advancecCs t||Sr#)rZSwigPyIterator___eq__rErrr__eq__cszSwigPyIterator.__eq__cCs t||Sr#)rZSwigPyIterator___ne__rErrr__ne__fszSwigPyIterator.__ne__cCs t||Sr#)rZSwigPyIterator___iadd__rArrr__iadd__iszSwigPyIterator.__iadd__cCs t||Sr#)rZSwigPyIterator___isub__rArrr__isub__lszSwigPyIterator.__isub__cCs t||Sr#)rZSwigPyIterator___add__rArrr__add__oszSwigPyIterator.__add__cGstj|g|RSr#)rZSwigPyIterator___sub__rr=rrr__sub__rszSwigPyIterator.__sub__cCs|Sr#rr@rrr__iter__tszSwigPyIterator.__iter__N)r)r)r r r,rrr?rrrZdelete_SwigPyIterator__swig_destroy__rrCrDrFrGr&rHrIrJrKrLrMrNrOrPrRrSrrrrr/=s*  r/c@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) Float32VectorcCs |jSr#r0r1rrrr3{r4zFloat32Vector.cCs |j|Sr#r0r5rrrr3{r4r7r8cCst|tdSr#)rZFloat32Vector_swiginitZnew_Float32Vectorr@rrrr?~szFloat32Vector.__init__cCs t||Sr#)rZFloat32Vector_push_backrarg2rrr push_backszFloat32Vector.push_backcCs t|Sr#)rZFloat32Vector_clearr@rrrclearszFloat32Vector.clearcCs t|Sr#)rZFloat32Vector_datar@rrrdataszFloat32Vector.datacCs t|Sr#)rZFloat32Vector_sizer@rrrsizeszFloat32Vector.sizecCs t||Sr#)rZFloat32Vector_atrArrratszFloat32Vector.atcCs t||Sr#)rZFloat32Vector_resizerArrrresizeszFloat32Vector.resizecCs t||Sr#)rZFloat32Vector_swaprotherrrrswapszFloat32Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_Float32VectorrTrrrrrUzsrUc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) Float64VectorcCs |jSr#r0r1rrrr3r4zFloat64Vector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZFloat64Vector_swiginitZnew_Float64Vectorr@rrrr?szFloat64Vector.__init__cCs t||Sr#)rZFloat64Vector_push_backrVrrrrXszFloat64Vector.push_backcCs t|Sr#)rZFloat64Vector_clearr@rrrrYszFloat64Vector.clearcCs t|Sr#)rZFloat64Vector_datar@rrrrZszFloat64Vector.datacCs t|Sr#)rZFloat64Vector_sizer@rrrr[szFloat64Vector.sizecCs t||Sr#)rZFloat64Vector_atrArrrr\szFloat64Vector.atcCs t||Sr#)rZFloat64Vector_resizerArrrr]szFloat64Vector.resizecCs t||Sr#)rZFloat64Vector_swapr^rrrr`szFloat64Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_Float64VectorrTrrrrrasrac@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) Int8VectorcCs |jSr#r0r1rrrr3r4zInt8Vector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZInt8Vector_swiginitZnew_Int8Vectorr@rrrr?szInt8Vector.__init__cCs t||Sr#)rZInt8Vector_push_backrVrrrrXszInt8Vector.push_backcCs t|Sr#)rZInt8Vector_clearr@rrrrYszInt8Vector.clearcCs t|Sr#)rZInt8Vector_datar@rrrrZszInt8Vector.datacCs t|Sr#)rZInt8Vector_sizer@rrrr[szInt8Vector.sizecCs t||Sr#)rZ Int8Vector_atrArrrr\sz Int8Vector.atcCs t||Sr#)rZInt8Vector_resizerArrrr]szInt8Vector.resizecCs t||Sr#)rZInt8Vector_swapr^rrrr`szInt8Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_Int8VectorrTrrrrrbsrbc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) Int16VectorcCs |jSr#r0r1rrrr3r4zInt16Vector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZInt16Vector_swiginitZnew_Int16Vectorr@rrrr?szInt16Vector.__init__cCs t||Sr#)rZInt16Vector_push_backrVrrrrXszInt16Vector.push_backcCs t|Sr#)rZInt16Vector_clearr@rrrrYszInt16Vector.clearcCs t|Sr#)rZInt16Vector_datar@rrrrZszInt16Vector.datacCs t|Sr#)rZInt16Vector_sizer@rrrr[szInt16Vector.sizecCs t||Sr#)rZInt16Vector_atrArrrr\szInt16Vector.atcCs t||Sr#)rZInt16Vector_resizerArrrr]szInt16Vector.resizecCs t||Sr#)rZInt16Vector_swapr^rrrr`szInt16Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_Int16VectorrTrrrrrcsrcc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) Int32VectorcCs |jSr#r0r1rrrr3r4zInt32Vector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZInt32Vector_swiginitZnew_Int32Vectorr@rrrr?szInt32Vector.__init__cCs t||Sr#)rZInt32Vector_push_backrVrrrrXszInt32Vector.push_backcCs t|Sr#)rZInt32Vector_clearr@rrrrYszInt32Vector.clearcCs t|Sr#)rZInt32Vector_datar@rrrrZszInt32Vector.datacCs t|Sr#)rZInt32Vector_sizer@rrrr[szInt32Vector.sizecCs t||Sr#)rZInt32Vector_atrArrrr\ szInt32Vector.atcCs t||Sr#)rZInt32Vector_resizerArrrr] szInt32Vector.resizecCs t||Sr#)rZInt32Vector_swapr^rrrr`szInt32Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_Int32VectorrTrrrrrdsrdc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) Int64VectorcCs |jSr#r0r1rrrr3r4zInt64Vector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZInt64Vector_swiginitZnew_Int64Vectorr@rrrr?szInt64Vector.__init__cCs t||Sr#)rZInt64Vector_push_backrVrrrrXszInt64Vector.push_backcCs t|Sr#)rZInt64Vector_clearr@rrrrYszInt64Vector.clearcCs t|Sr#)rZInt64Vector_datar@rrrrZ"szInt64Vector.datacCs t|Sr#)rZInt64Vector_sizer@rrrr[%szInt64Vector.sizecCs t||Sr#)rZInt64Vector_atrArrrr\(szInt64Vector.atcCs t||Sr#)rZInt64Vector_resizerArrrr]+szInt64Vector.resizecCs t||Sr#)rZInt64Vector_swapr^rrrr`.szInt64Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_Int64VectorrTrrrrresrec@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) UInt8VectorcCs |jSr#r0r1rrrr35r4zUInt8Vector.cCs |j|Sr#r0r5rrrr35r4r7r8cCst|tdSr#)rZUInt8Vector_swiginitZnew_UInt8Vectorr@rrrr?8szUInt8Vector.__init__cCs t||Sr#)rZUInt8Vector_push_backrVrrrrX;szUInt8Vector.push_backcCs t|Sr#)rZUInt8Vector_clearr@rrrrY>szUInt8Vector.clearcCs t|Sr#)rZUInt8Vector_datar@rrrrZAszUInt8Vector.datacCs t|Sr#)rZUInt8Vector_sizer@rrrr[DszUInt8Vector.sizecCs t||Sr#)rZUInt8Vector_atrArrrr\GszUInt8Vector.atcCs t||Sr#)rZUInt8Vector_resizerArrrr]JszUInt8Vector.resizecCs t||Sr#)rZUInt8Vector_swapr^rrrr`MszUInt8Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_UInt8VectorrTrrrrrf4srfc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) UInt16VectorcCs |jSr#r0r1rrrr3Tr4zUInt16Vector.cCs |j|Sr#r0r5rrrr3Tr4r7r8cCst|tdSr#)rZUInt16Vector_swiginitZnew_UInt16Vectorr@rrrr?WszUInt16Vector.__init__cCs t||Sr#)rZUInt16Vector_push_backrVrrrrXZszUInt16Vector.push_backcCs t|Sr#)rZUInt16Vector_clearr@rrrrY]szUInt16Vector.clearcCs t|Sr#)rZUInt16Vector_datar@rrrrZ`szUInt16Vector.datacCs t|Sr#)rZUInt16Vector_sizer@rrrr[cszUInt16Vector.sizecCs t||Sr#)rZUInt16Vector_atrArrrr\fszUInt16Vector.atcCs t||Sr#)rZUInt16Vector_resizerArrrr]iszUInt16Vector.resizecCs t||Sr#)rZUInt16Vector_swapr^rrrr`lszUInt16Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_UInt16VectorrTrrrrrgSsrgc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) UInt32VectorcCs |jSr#r0r1rrrr3sr4zUInt32Vector.cCs |j|Sr#r0r5rrrr3sr4r7r8cCst|tdSr#)rZUInt32Vector_swiginitZnew_UInt32Vectorr@rrrr?vszUInt32Vector.__init__cCs t||Sr#)rZUInt32Vector_push_backrVrrrrXyszUInt32Vector.push_backcCs t|Sr#)rZUInt32Vector_clearr@rrrrY|szUInt32Vector.clearcCs t|Sr#)rZUInt32Vector_datar@rrrrZszUInt32Vector.datacCs t|Sr#)rZUInt32Vector_sizer@rrrr[szUInt32Vector.sizecCs t||Sr#)rZUInt32Vector_atrArrrr\szUInt32Vector.atcCs t||Sr#)rZUInt32Vector_resizerArrrr]szUInt32Vector.resizecCs t||Sr#)rZUInt32Vector_swapr^rrrr`szUInt32Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_UInt32VectorrTrrrrrhrsrhc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) UInt64VectorcCs |jSr#r0r1rrrr3r4zUInt64Vector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZUInt64Vector_swiginitZnew_UInt64Vectorr@rrrr?szUInt64Vector.__init__cCs t||Sr#)rZUInt64Vector_push_backrVrrrrXszUInt64Vector.push_backcCs t|Sr#)rZUInt64Vector_clearr@rrrrYszUInt64Vector.clearcCs t|Sr#)rZUInt64Vector_datar@rrrrZszUInt64Vector.datacCs t|Sr#)rZUInt64Vector_sizer@rrrr[szUInt64Vector.sizecCs t||Sr#)rZUInt64Vector_atrArrrr\szUInt64Vector.atcCs t||Sr#)rZUInt64Vector_resizerArrrr]szUInt64Vector.resizecCs t||Sr#)rZUInt64Vector_swapr^rrrr`szUInt64Vector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_UInt64VectorrTrrrrrisric@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)Float32VectorVectorcCs |jSr#r0r1rrrr3r4zFloat32VectorVector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZFloat32VectorVector_swiginitZnew_Float32VectorVectorr@rrrr?szFloat32VectorVector.__init__cCs t||Sr#)rZFloat32VectorVector_push_backrVrrrrXszFloat32VectorVector.push_backcCs t|Sr#)rZFloat32VectorVector_clearr@rrrrYszFloat32VectorVector.clearcCs t|Sr#)rZFloat32VectorVector_datar@rrrrZszFloat32VectorVector.datacCs t|Sr#)rZFloat32VectorVector_sizer@rrrr[szFloat32VectorVector.sizecCs t||Sr#)rZFloat32VectorVector_atrArrrr\szFloat32VectorVector.atcCs t||Sr#)rZFloat32VectorVector_resizerArrrr]szFloat32VectorVector.resizecCs t||Sr#)rZFloat32VectorVector_swapr^rrrr`szFloat32VectorVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_Float32VectorVectorrTrrrrrjsrjc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)UInt8VectorVectorcCs |jSr#r0r1rrrr3r4zUInt8VectorVector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZUInt8VectorVector_swiginitZnew_UInt8VectorVectorr@rrrr?szUInt8VectorVector.__init__cCs t||Sr#)rZUInt8VectorVector_push_backrVrrrrXszUInt8VectorVector.push_backcCs t|Sr#)rZUInt8VectorVector_clearr@rrrrYszUInt8VectorVector.clearcCs t|Sr#)rZUInt8VectorVector_datar@rrrrZszUInt8VectorVector.datacCs t|Sr#)rZUInt8VectorVector_sizer@rrrr[szUInt8VectorVector.sizecCs t||Sr#)rZUInt8VectorVector_atrArrrr\szUInt8VectorVector.atcCs t||Sr#)rZUInt8VectorVector_resizerArrrr]szUInt8VectorVector.resizecCs t||Sr#)rZUInt8VectorVector_swapr^rrrr`szUInt8VectorVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_UInt8VectorVectorrTrrrrrksrkc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)Int32VectorVectorcCs |jSr#r0r1rrrr3r4zInt32VectorVector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZInt32VectorVector_swiginitZnew_Int32VectorVectorr@rrrr?szInt32VectorVector.__init__cCs t||Sr#)rZInt32VectorVector_push_backrVrrrrXszInt32VectorVector.push_backcCs t|Sr#)rZInt32VectorVector_clearr@rrrrYszInt32VectorVector.clearcCs t|Sr#)rZInt32VectorVector_datar@rrrrZszInt32VectorVector.datacCs t|Sr#)rZInt32VectorVector_sizer@rrrr[szInt32VectorVector.sizecCs t||Sr#)rZInt32VectorVector_atrArrrr\szInt32VectorVector.atcCs t||Sr#)rZInt32VectorVector_resizerArrrr]szInt32VectorVector.resizecCs t||Sr#)rZInt32VectorVector_swapr^rrrr`szInt32VectorVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_Int32VectorVectorrTrrrrrlsrlc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)Int64VectorVectorcCs |jSr#r0r1rrrr3r4zInt64VectorVector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZInt64VectorVector_swiginitZnew_Int64VectorVectorr@rrrr?szInt64VectorVector.__init__cCs t||Sr#)rZInt64VectorVector_push_backrVrrrrXszInt64VectorVector.push_backcCs t|Sr#)rZInt64VectorVector_clearr@rrrrYszInt64VectorVector.clearcCs t|Sr#)rZInt64VectorVector_datar@rrrrZszInt64VectorVector.datacCs t|Sr#)rZInt64VectorVector_sizer@rrrr[szInt64VectorVector.sizecCs t||Sr#)rZInt64VectorVector_atrArrrr\ szInt64VectorVector.atcCs t||Sr#)rZInt64VectorVector_resizerArrrr]#szInt64VectorVector.resizecCs t||Sr#)rZInt64VectorVector_swapr^rrrr`&szInt64VectorVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_Int64VectorVectorrTrrrrrm srmc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)VectorTransformVectorcCs |jSr#r0r1rrrr3-r4zVectorTransformVector.cCs |j|Sr#r0r5rrrr3-r4r7r8cCst|tdSr#)rZVectorTransformVector_swiginitZnew_VectorTransformVectorr@rrrr?0szVectorTransformVector.__init__cCs t||Sr#)rZVectorTransformVector_push_backrVrrrrX3szVectorTransformVector.push_backcCs t|Sr#)rZVectorTransformVector_clearr@rrrrY6szVectorTransformVector.clearcCs t|Sr#)rZVectorTransformVector_datar@rrrrZ9szVectorTransformVector.datacCs t|Sr#)rZVectorTransformVector_sizer@rrrr[<szVectorTransformVector.sizecCs t||Sr#)rZVectorTransformVector_atrArrrr\?szVectorTransformVector.atcCs t||Sr#)rZVectorTransformVector_resizerArrrr]BszVectorTransformVector.resizecCs t||Sr#)rZVectorTransformVector_swapr^rrrr`EszVectorTransformVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_VectorTransformVectorrTrrrrrn,srnc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)OperatingPointVectorcCs |jSr#r0r1rrrr3Lr4zOperatingPointVector.cCs |j|Sr#r0r5rrrr3Lr4r7r8cCst|tdSr#)rZOperatingPointVector_swiginitZnew_OperatingPointVectorr@rrrr?OszOperatingPointVector.__init__cCs t||Sr#)rZOperatingPointVector_push_backrVrrrrXRszOperatingPointVector.push_backcCs t|Sr#)rZOperatingPointVector_clearr@rrrrYUszOperatingPointVector.clearcCs t|Sr#)rZOperatingPointVector_datar@rrrrZXszOperatingPointVector.datacCs t|Sr#)rZOperatingPointVector_sizer@rrrr[[szOperatingPointVector.sizecCs t||Sr#)rZOperatingPointVector_atrArrrr\^szOperatingPointVector.atcCs t||Sr#)rZOperatingPointVector_resizerArrrr]aszOperatingPointVector.resizecCs t||Sr#)rZOperatingPointVector_swapr^rrrr`dszOperatingPointVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_OperatingPointVectorrTrrrrroKsroc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)InvertedListsPtrVectorcCs |jSr#r0r1rrrr3kr4zInvertedListsPtrVector.cCs |j|Sr#r0r5rrrr3kr4r7r8cCst|tdSr#)rZInvertedListsPtrVector_swiginitZnew_InvertedListsPtrVectorr@rrrr?nszInvertedListsPtrVector.__init__cCs t||Sr#)rZ InvertedListsPtrVector_push_backrVrrrrXqsz InvertedListsPtrVector.push_backcCs t|Sr#)rZInvertedListsPtrVector_clearr@rrrrYtszInvertedListsPtrVector.clearcCs t|Sr#)rZInvertedListsPtrVector_datar@rrrrZwszInvertedListsPtrVector.datacCs t|Sr#)rZInvertedListsPtrVector_sizer@rrrr[zszInvertedListsPtrVector.sizecCs t||Sr#)rZInvertedListsPtrVector_atrArrrr\}szInvertedListsPtrVector.atcCs t||Sr#)rZInvertedListsPtrVector_resizerArrrr]szInvertedListsPtrVector.resizecCs t||Sr#)rZInvertedListsPtrVector_swapr^rrrr`szInvertedListsPtrVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_InvertedListsPtrVectorrTrrrrrpjsrpc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS) RepeatVectorcCs |jSr#r0r1rrrr3r4zRepeatVector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZRepeatVector_swiginitZnew_RepeatVectorr@rrrr?szRepeatVector.__init__cCs t||Sr#)rZRepeatVector_push_backrVrrrrXszRepeatVector.push_backcCs t|Sr#)rZRepeatVector_clearr@rrrrYszRepeatVector.clearcCs t|Sr#)rZRepeatVector_datar@rrrrZszRepeatVector.datacCs t|Sr#)rZRepeatVector_sizer@rrrr[szRepeatVector.sizecCs t||Sr#)rZRepeatVector_atrArrrr\szRepeatVector.atcCs t||Sr#)rZRepeatVector_resizerArrrr]szRepeatVector.resizecCs t||Sr#)rZRepeatVector_swapr^rrrr`szRepeatVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_RepeatVectorrTrrrrrqsrqc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)ClusteringIterationStatsVectorcCs |jSr#r0r1rrrr3r4z'ClusteringIterationStatsVector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZ'ClusteringIterationStatsVector_swiginitZ"new_ClusteringIterationStatsVectorr@rrrr?sz'ClusteringIterationStatsVector.__init__cCs t||Sr#)rZ(ClusteringIterationStatsVector_push_backrVrrrrXsz(ClusteringIterationStatsVector.push_backcCs t|Sr#)rZ$ClusteringIterationStatsVector_clearr@rrrrYsz$ClusteringIterationStatsVector.clearcCs t|Sr#)rZ#ClusteringIterationStatsVector_datar@rrrrZsz#ClusteringIterationStatsVector.datacCs t|Sr#)rZ#ClusteringIterationStatsVector_sizer@rrrr[sz#ClusteringIterationStatsVector.sizecCs t||Sr#)rZ!ClusteringIterationStatsVector_atrArrrr\sz!ClusteringIterationStatsVector.atcCs t||Sr#)rZ%ClusteringIterationStatsVector_resizerArrrr]sz%ClusteringIterationStatsVector.resizecCs t||Sr#)rZ#ClusteringIterationStatsVector_swapr^rrrr`sz#ClusteringIterationStatsVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZ%delete_ClusteringIterationStatsVectorrTrrrrrrsrrc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)ParameterRangeVectorcCs |jSr#r0r1rrrr3r4zParameterRangeVector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZParameterRangeVector_swiginitZnew_ParameterRangeVectorr@rrrr?szParameterRangeVector.__init__cCs t||Sr#)rZParameterRangeVector_push_backrVrrrrXszParameterRangeVector.push_backcCs t|Sr#)rZParameterRangeVector_clearr@rrrrYszParameterRangeVector.clearcCs t|Sr#)rZParameterRangeVector_datar@rrrrZszParameterRangeVector.datacCs t|Sr#)rZParameterRangeVector_sizer@rrrr[szParameterRangeVector.sizecCs t||Sr#)rZParameterRangeVector_atrArrrr\szParameterRangeVector.atcCs t||Sr#)rZParameterRangeVector_resizerArrrr]szParameterRangeVector.resizecCs t||Sr#)rZParameterRangeVector_swapr^rrrr`szParameterRangeVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_ParameterRangeVectorrTrrrrrssrsc@sleZdZeddddddZeZddZdd Zd d Z d d Z ddZ ddZ ddZ ddZejZdS)OnDiskOneListVectorcCs |jSr#r0r1rrrr3r4zOnDiskOneListVector.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZOnDiskOneListVector_swiginitZnew_OnDiskOneListVectorr@rrrr?szOnDiskOneListVector.__init__cCs t||Sr#)rZOnDiskOneListVector_push_backrVrrrrXszOnDiskOneListVector.push_backcCs t|Sr#)rZOnDiskOneListVector_clearr@rrrrYszOnDiskOneListVector.clearcCs t|Sr#)rZOnDiskOneListVector_datar@rrrrZszOnDiskOneListVector.datacCs t|Sr#)rZOnDiskOneListVector_sizer@rrrr[szOnDiskOneListVector.sizecCs t||Sr#)rZOnDiskOneListVector_atrArrrr\szOnDiskOneListVector.atcCs t||Sr#)rZOnDiskOneListVector_resizerArrrr]szOnDiskOneListVector.resizecCs t||Sr#)rZOnDiskOneListVector_swapr^rrrr`szOnDiskOneListVector.swapN)r r r,rrrrr?rXrYrZr[r\r]r`rZdelete_OnDiskOneListVectorrTrrrrrtsrtcCst|||||S)z low level SIMD histogramming functions 8-bin histogram of (x - min) >> shift values outside the range are ignored. the data table should be aligned on 32 bytes )rsimd_histogram_8rZrBminshifthistrrrrusrucCst|||||S)z same for 16-bin histogram)rsimd_histogram_16rvrrrrzsrzc@sXeZdZeddddddZeZeejej Z eej ej Z ddZdd ZejZd S) PartitionStatscCs |jSr#r0r1rrrr3r4zPartitionStats.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZPartitionStats_swiginitZnew_PartitionStatsr@rrrr?szPartitionStats.__init__cCs t|Sr#)rZPartitionStats_resetr@rrrresetszPartitionStats.resetN)r r r,rrrrrZ!PartitionStats_bissect_cycles_getZ!PartitionStats_bissect_cycles_setZbissect_cyclesZ"PartitionStats_compress_cycles_getZ"PartitionStats_compress_cycles_setZcompress_cyclesr?r|Zdelete_PartitionStatsrTrrrrr{sr{cCs t||Sr#)r bitvec_print)bdrrrr}!sr}cCst||||Sr#)r fvecs2bitvecs)r2r~rrBrrrr$srcCst||||Sr#)r bitvecs2fvecs)r~r2rrBrrrr'srcCst|||Sr#)r fvec2bitvec)r2r~rrrrr*srcCst||||||S)z0 Shuffle the bits from b(i, j) := a(i, order[j]))rbitvec_shuffle)rBdadborderar~rrrr-src@sfeZdZeddddddZeZeejej Z eej ej Z eejejZddZdd ZejZd S) BitstringWritercCs |jSr#r0r1rrrr31r4zBitstringWriter.cCs |j|Sr#r0r5rrrr31r4r7r8cCst|t||dSr#)rZBitstringWriter_swiginitZnew_BitstringWriterrcode code_sizerrrr?7szBitstringWriter.__init__cCst|||Sr#)rZBitstringWriter_write)rr2nbitrrrwrite:szBitstringWriter.writeN)r r r,rrrrrZBitstringWriter_code_getZBitstringWriter_code_setrZBitstringWriter_code_size_getZBitstringWriter_code_size_setrZBitstringWriter_i_getZBitstringWriter_i_setir?rZdelete_BitstringWriterrTrrrrr0src@sfeZdZeddddddZeZeejej Z eej ej Z eejejZddZdd ZejZd S) BitstringReadercCs |jSr#r0r1rrrr3Cr4zBitstringReader.cCs |j|Sr#r0r5rrrr3Cr4r7r8cCst|t||dSr#)rZBitstringReader_swiginitZnew_BitstringReaderrrrrr?IszBitstringReader.__init__cCs t||Sr#)rZBitstringReader_read)rrrrrreadLszBitstringReader.readN)r r r,rrrrrZBitstringReader_code_getZBitstringReader_code_setrZBitstringReader_code_size_getZBitstringReader_code_size_setrZBitstringReader_i_getZBitstringReader_i_setrr?rZdelete_BitstringReaderrTrrrrrBsrcCst||||||S)ax Compute a set of Hamming distances between na and nb binary vectors :type a: uint8_t :param a: size na * nbytespercode :type b: uint8_t :param b: size nb * nbytespercode :type nbytespercode: int :param nbytespercode: should be multiple of 8 :type dis: int :param dis: output distances, size na * nb )rhammings)rr~nanbZ nbytespercodedisrrrrSs rcGs tj|S)a Return the k smallest Hamming distances for a set of binary query vectors, using a max heap. :type a: uint8_t :param a: queries, size ha->nh * ncodes :type b: uint8_t :param b: database, size nb * ncodes :type nb: int :param nb: number of database vectors :type ncodes: int :param ncodes: size of the binary codes (bytes) :type ordered: int :param ordered: if != 0: order the results by decreasing distance (may be bottleneck for k/n > 0.01) :type approx_topk_mode: int, optional :param approx_topk_mode: allows to use approximate top-k facilities to speedup heap )rhammings_knn_hcr=rrrrbsrcCst||||||Sr#)r hammings_knn)harr~rncodesorderedrrrrwsrc Cst||||||||S)a Return the k smallest Hamming distances for a set of binary query vectors, using counting max. :type a: uint8_t :param a: queries, size na * ncodes :type b: uint8_t :param b: database, size nb * ncodes :type na: int :param na: number of query vectors :type nb: int :param nb: number of database vectors :type k: int :param k: number of vectors/distances to return :type ncodes: int :param ncodes: size of the binary codes (bytes) :type distances: int :param distances: output distances from each query vector to its k nearest neighbors :type labels: int :param labels: output ids of the k nearest neighbors to each query vector )rhammings_knn_mc)rr~rrkr distanceslabelsrrrrzsrc Cst|||||||S)zD same as hammings_knn except we are doing a range search with radius)rhamming_range_search)rr~rrradiusrresultrrrrsrc Cst|||||||Sr#)rhamming_count_thres)bs1bs2n1n2htrnptrrrrrsrc Cst||||||||Sr#)rmatch_hamming_thres)rrrrrridxrrrrrsrcCst|||||Sr#)rcrosshamming_count_thres)ZdbsrBrrrrrrrsrTcCst||||||S)z_ generalized Hamming distances (= count number of code bytes that are the same) )rgeneralized_hammings_knn_hc)rrr~rrrrrrrsrcGs tj|S)a *Overload 1:* Pack a set of n codes of size M * nbit :type n: int :param n: number of codes to pack :type M: int :param M: number of elementary codes per code :type nbit: int :param nbit: number of bits per elementary code :type unpacked: int :param unpacked: input unpacked codes, size (n, M) :type packed: uint8_t :param packed: output packed codes, size (n, code_size) :type code_size: int :param code_size: should be >= ceil(M * nbit / 8) | *Overload 2:* Pack a set of n codes of variable sizes :param nbit: number of bits per entry (size M) )rpack_bitstringsrrrrrsrcGs tj|S)a *Overload 1:* Unpack a set of n codes of size M * nbit :type n: int :param n: number of codes to pack :type M: int :param M: number of elementary codes per code :type nbit: int :param nbit: number of bits per elementary code :type unpacked: int :param unpacked: input unpacked codes, size (n, M) :type packed: uint8_t :param packed: output packed codes, size (n, code_size) :type code_size: int :param code_size: should be >= ceil(M * nbit / 8) | *Overload 2:* Unpack a set of n codes of variable sizes :param nbit: number of bits per entry (size M) )runpack_bitstringsrrrrrsrcCs t|Sr#)r popcount32r1rrrrsrcCs t|Sr#)r popcount64r1rrrrsrcCstSr#)r get_num_gpusrrrrrsrcCstSr#)rgpu_profiler_startrrrrrsrcCstSr#)rgpu_profiler_stoprrrrrsrcCstSr#)rgpu_sync_all_devicesrrrrrsrcCstS)z get compile options)rget_compile_optionsrrrrrsrcCstSr#)r get_versionrrrrrsrcCstS)z& ms elapsed since some arbitrary epoch)r getmillisecsrrrrrsrcCstS)z get current RSS usage in kB)rget_mem_usage_kbrrrrrsrcCstSr#)r get_cyclesrrrrrsrcCst|||||Sr#)r reflection)ur2rBrnurrrrsrcCst|||S)z compute the Q of the QR decomposition for m > n :type a: float :param a: size n * m: input matrix and output Q )r matrix_qr)mrBrrrrrsrcCst|||S)zF distances are supposed to be sorted. Sorts indices with same distance)rranklist_handle_ties)rrrrrrr srcCst||||S)z count the number of common elements between v1 and v2 algorithm = sorting + bissection to avoid double-counting duplicates )rranklist_intersection_size)Zk1Zv1Zk2Zv2rrrrsrc Cst||||||||S)a merge a result table into another one :type I0: int :param I0:, D0 first result table, size (n, k) :type I1: int :param I1:, D1 second result table, size (n, k) :type keep_min: boolean, optional :param keep_min: if true, keep min values, otherwise keep max :type translation: int, optional :param translation: add this value to all I1's indexes :rtype: int :return: nb of values that were taken from the second table )rmerge_result_table_with)rBrZI0ZD0ZI1ZD1Zkeep_min translationrrrrsrcGs tj|S)z *Overload 1:* a balanced assignment has a IF of 1, a completely unbalanced assignment has an IF = k. | *Overload 2:* same, takes a histogram as input )rimbalance_factorrrrrr's rcCst||||S)z compute histogram on v)r ivec_hist)rBr6Zvmaxryrrrr4srcCst||||S)z Compute histogram of bits on a code array :type codes: uint8_t :param codes: size(n, nbits / 8) :type hist: int :param hist: size(nbits): nb of 1s in the array of codes )r bincode_hist)rBnbitscodesryrrrr8s rcCs t||Sz compute a checksum on a table.)r ivec_checksumrBrrrrrCsrcCs t||Sr)r bvec_checksumrrrrrGsrcCst||||S)a compute checksums for the rows of a matrix :type n: int :param n: number of rows :type d: int :param d: size per row :type a: uint8_t :param a: matrix to handle, size n * d :type cs: int :param cs: output checksums, size n )rbvecs_checksum)rBrrcsrrrrKs rFcCst||||||S)a random subsamples a set of vectors if there are too many of them :type d: int :param d: dimension of the vectors :type n: int :param n: on input: nb of input vectors, output: nb of output vectors :type nmax: int :param nmax: max nb of vectors to keep :type x: float :param x: input array, size *n-by-d :type seed: int, optional :param seed: random seed to use for sampling :rtype: float :return: x or an array allocated with new [] with *n vectors )rfvecs_maybe_subsample)rrBZnmaxr2verboseseedrrrrZsrcCst|||S)a> Convert binary vector to +1/-1 valued float vector. :type d: int :param d: dimension of the vector (multiple of 8) :type x_in: uint8_t :param x_in: input binary vector (uint8_t table of size d / 8) :type x_out: float :param x_out: output float vector (float table of size d) )rbinary_to_realrx_inZx_outrrrrms rcCst|||S)ae Convert float vector to binary vector. Components > 0 are converted to 1, others to 0. :type d: int :param d: dimension of the vector (multiple of 8) :type x_in: float :param x_in: input float vector (float table of size d) :type x_out: uint8_t :param x_out: output binary vector (uint8_t table of size d / 8) )rreal_to_binaryrrrrrzs rcCs t||S)z A reasonable hashing function)r hash_bytes)bytesrBrrrrsrcCstS)z+ Whether OpenMP annotations were respected.)r check_openmprrrrrsrc@sXeZdZeddddddZeZeejej Z eej ej Z ddZdd ZejZd S) CodeSetcCs |jSr#r0r1rrrr3r4zCodeSet.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|t|dSr#)rZCodeSet_swiginitZ new_CodeSetrrrrrr?szCodeSet.__init__cCst||||Sr#)rZCodeSet_insert)rrBrZinsertedrrrinsertszCodeSet.insertN)r r r,rrrrrZ CodeSet_d_getZ CodeSet_d_setrZ CodeSet_s_getZ CodeSet_s_setsr?rZdelete_CodeSetrTrrrrrsrc@s eZdZdZeddddddZeZeej ej Z eej ej ddZeejejddZeejejd dZd d Zeejejd dZeejejd dZeejejddZeejej ddZ!eej"ej#ddZ$eej%ej&ddZ'eej(ej)ddZ*ddZ+ddZ,ej-Z.dS)CombinerRangeKNNfloatw This class is used to combine range and knn search results in contrib.exhaustive_search.range_search_gpu cCs |jSr#r0r1rrrr3r4zCombinerRangeKNNfloat.cCs |j|Sr#r0r5rrrr3r4r7r8 nb of queries, number of neighbors for the knn search part range search radiusc Cst|t||||dSz+ whether to keep max values instead of min.N)rZCombinerRangeKNNfloat_swiginitZnew_CombinerRangeKNNfloatrnqrr2keep_maxrrrr?szCombinerRangeKNNfloat.__init__ Knn search results size nq * kR size nq * k optional: range search results (ignored if mask is NULL) . mask for where knn results are valid, size nq size nrange + 1 size lim_remain[nrange]cCs t||Sz size nq + 1)rZ#CombinerRangeKNNfloat_compute_sizesrL_resrrr compute_sizessz#CombinerRangeKNNfloat.compute_sizescCst|||Szu Phase 2: caller allocates D_res and I_res (size L_res[nq]) Phase 3: fill in D_res and I_res )rZ"CombinerRangeKNNfloat_write_resultrZD_resZI_resrrr write_resultsz"CombinerRangeKNNfloat.write_resultN)/r r r,r-rrrrrZCombinerRangeKNNfloat_nq_getZCombinerRangeKNNfloat_nq_setrZCombinerRangeKNNfloat_k_getZCombinerRangeKNNfloat_k_setrZCombinerRangeKNNfloat_r2_getZCombinerRangeKNNfloat_r2_setrZ"CombinerRangeKNNfloat_keep_max_getZ"CombinerRangeKNNfloat_keep_max_setrr?ZCombinerRangeKNNfloat_I_getZCombinerRangeKNNfloat_I_setIZCombinerRangeKNNfloat_D_getZCombinerRangeKNNfloat_D_setDZCombinerRangeKNNfloat_mask_getZCombinerRangeKNNfloat_mask_setmaskZ$CombinerRangeKNNfloat_lim_remain_getZ$CombinerRangeKNNfloat_lim_remain_set lim_remainZ"CombinerRangeKNNfloat_D_remain_getZ"CombinerRangeKNNfloat_D_remain_setD_remainZ"CombinerRangeKNNfloat_I_remain_getZ"CombinerRangeKNNfloat_I_remain_setI_remainZCombinerRangeKNNfloat_L_res_getZCombinerRangeKNNfloat_L_res_setrrrZdelete_CombinerRangeKNNfloatrTrrrrrs$rc@s eZdZdZeddddddZeZeej ej Z eej ej ddZeejejddZeejejd dZd d Zeejejd dZeejejd dZeejejddZeejej ddZ!eej"ej#ddZ$eej%ej&ddZ'eej(ej)ddZ*ddZ+ddZ,ej-Z.dS)CombinerRangeKNNint16rcCs |jSr#r0r1rrrr3r4zCombinerRangeKNNint16.cCs |j|Sr#r0r5rrrr3r4r7r8rrrc Cst|t||||dSr)rZCombinerRangeKNNint16_swiginitZnew_CombinerRangeKNNint16rrrrr?szCombinerRangeKNNint16.__init__rrrrrrcCs t||Sr)rZ#CombinerRangeKNNint16_compute_sizesrrrrrsz#CombinerRangeKNNint16.compute_sizescCst|||Sr)rZ"CombinerRangeKNNint16_write_resultrrrrrsz"CombinerRangeKNNint16.write_resultN)/r r r,r-rrrrrZCombinerRangeKNNint16_nq_getZCombinerRangeKNNint16_nq_setrZCombinerRangeKNNint16_k_getZCombinerRangeKNNint16_k_setrZCombinerRangeKNNint16_r2_getZCombinerRangeKNNint16_r2_setrZ"CombinerRangeKNNint16_keep_max_getZ"CombinerRangeKNNint16_keep_max_setrr?ZCombinerRangeKNNint16_I_getZCombinerRangeKNNint16_I_setrZCombinerRangeKNNint16_D_getZCombinerRangeKNNint16_D_setrZCombinerRangeKNNint16_mask_getZCombinerRangeKNNint16_mask_setrZ$CombinerRangeKNNint16_lim_remain_getZ$CombinerRangeKNNint16_lim_remain_setrZ"CombinerRangeKNNint16_D_remain_getZ"CombinerRangeKNNint16_D_remain_setrZ"CombinerRangeKNNint16_I_remain_getZ"CombinerRangeKNNint16_I_remain_setrZCombinerRangeKNNint16_L_res_getZCombinerRangeKNNint16_L_res_setrrrZdelete_CombinerRangeKNNint16rTrrrrrs$rcCst|||S)z( Squared L2 distance between two vectors)r fvec_L2sqrr2yrrrrrsrcCst|||S)z inner product)rfvec_inner_productrrrrrsrcCst|||S)z L1 distance)rfvec_L1rrrrrsrcCst|||S)z infinity distance)r fvec_Linfrrrrrsrc Cst|||||||||| S)zy Special version of inner product that computes 4 distances between x and yi, which is performance oriented. )rfvec_inner_product_batch_4 r2Zy0y1y2Zy3rdis0dis1dis2dis3rrrrsrc Cst|||||||||| S)zq Special version of L2sqr that computes 4 distances between x and yi, which is performance oriented. )rfvec_L2sqr_batch_4rrrrr  sr c Cst||||||||| S)a Compute pairwise distances between sets of vectors :type d: int :param d: dimension of the vectors :type nq: int :param nq: nb of query vectors :type nb: int :param nb: nb of database vectors :type xq: float :param xq: query vectors (size nq * d) :type xb: float :param xb: database vectors (size nb * d) :type dis: float :param dis: output distances (size nq * nb) :param ldq,ldb:, ldd strides for the matrices )rpairwise_L2sqr) rrxqrxbrldqldblddrrrr sr cCst|||||Sr#)rfvec_inner_products_ny)ipr2rrnyrrrr%srcCst|||||Sr#)r fvec_L2sqr_ny)rr2rrrrrrr(src Cst|||||||Sr#)rfvec_L2sqr_ny_transposed)rr2ry_sqlenrd_offsetrrrrr+srcCst|||||Sr#)rfvec_L2sqr_ny_nearest)distances_tmp_bufferr2rrrrrrr.src Cst|||||||Sr#)r"fvec_L2sqr_ny_nearest_y_transposed)rr2rrrrrrrrr1srcCs t||S)z squared norm of a vector)rfvec_norm_L2sqr)r2rrrrr4srcCst||||S)z compute the L2 norms for a set of vectors :type norms: float :param norms: output norms, size nx :type x: float :param x: set of vectors, size nx * d )r fvec_norms_L2normsr2rnxrrrr8s rcCst||||S)z2 same as fvec_norms_L2, but computes squared norms)rfvec_norms_L2sqrrrrrr Csr cCst|||Sr#)rfvec_renorm_L2)rrr2rrrr!Gsr!cCst|||||Sr#)rinner_product_to_L2sqr)rZnr1Znr2rrrrrr"Jsr"cGs tj|S)a *Overload 1:* compute c := a + b for vectors c and a can overlap, c and b can overlap :type a: float :param a: size d :type b: float :param b: size d :type c: float :param c: size d | *Overload 2:* compute c := a + b for a, c vectors and b a scalar c and a can overlap :type a: float :param a: size d :type c: float :param c: size d )rfvec_addrrrrr#Msr#cCst||||S)z compute c := a - b for vectors c and a can overlap, c and b can overlap :type a: float :param a: size d :type b: float :param b: size d :type c: float :param c: size d )rfvec_sub)rrr~crrrr$is r$c Cst|||||||S)a compute the inner product between x and a subset y of ny vectors defined by ids ip(i, j) = inner_product(x(i, :), y(ids(i, j), :)) :type ip: float :param ip: output array, size nx * ny :type x: float :param x: first-term vector, size nx * d :type y: float :param y: second-term vector, size (max(ids) + 1) * d :type ids: int :param ids: ids to sample from y, size nx * ny )rfvec_inner_products_by_idx)rr2ridsrrrrrrr&xsr&c Cst|||||||S)a compute the squared L2 distances between x and a subset y of ny vectors defined by ids dis(i, j) = inner_product(x(i, :), y(ids(i, j), :)) :type dis: float :param dis: output array, size nx * ny :type x: float :param x: first-term vector, size nx * d :type y: float :param y: second-term vector, size (max(ids) + 1) * d :type ids: int :param ids: ids to sample from y, size nx * ny )rfvec_L2sqr_by_idx)rr2rr'rrrrrrr(sr(c Cst|||||||S)a2 compute dis[j] = L2sqr(x[ix[j]], y[iy[j]]) forall j=0..n-1 :type x: float :param x: size (max(ix) + 1, d) :type y: float :param y: size (max(iy) + 1, d) :type ix: int :param ix: size n :type iy: int :param iy: size n :type dis: float :param dis: size n )rpairwise_indexed_L2sqrrrBr2ZixrZiyrrrrr)sr)c Cst|||||||S)a: compute dis[j] = inner_product(x[ix[j]], y[iy[j]]) forall j=0..n-1 :type x: float :param x: size (max(ix) + 1, d) :type y: float :param y: size (max(iy) + 1, d) :type ix: int :param ix: size n :type iy: int :param iy: size n :type dis: float :param dis: size n )rpairwise_indexed_inner_productr*rrrr+sr+cGs tj|S)a *Overload 1:* Return the k nearest neighbors of each of the nx vectors x among the ny vector y, w.r.t to max inner product. :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type res: :py:class:`float_minheap_array_t` :param res: result heap structure, which also provides k. Sorted on output | *Overload 2:* Return the k nearest neighbors of each of the nx vectors x among the ny vector y, for the inner product metric. :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k | *Overload 3:* Return the k nearest neighbors of each of the nx vectors x among the ny vector y, for the inner product metric. :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k )rknn_inner_productrrrrr,s+r,cGs tj|S)aS *Overload 1:* Return the k nearest neighbors of each of the nx vectors x among the ny vector y, for the L2 distance :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type res: :py:class:`float_maxheap_array_t` :param res: result heap strcture, which also provides k. Sorted on output :type y_norm2: float, optional :param y_norm2: (optional) norms for the y vectors (nullptr or size ny) :type sel: :py:class:`IDSelector`, optional :param sel: search in this subset of vectors | *Overload 2:* Return the k nearest neighbors of each of the nx vectors x among the ny vector y, for the L2 distance :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k :type y_norm2: float, optional :param y_norm2: (optional) norms for the y vectors (nullptr or size ny) :type sel: :py:class:`IDSelector`, optional :param sel: search in this subset of vectors | *Overload 3:* Return the k nearest neighbors of each of the nx vectors x among the ny vector y, for the L2 distance :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k :type y_norm2: float, optional :param y_norm2: (optional) norms for the y vectors (nullptr or size ny) :param sel: search in this subset of vectors | *Overload 4:* Return the k nearest neighbors of each of the nx vectors x among the ny vector y, for the L2 distance :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type distances: float :param distances: output distances, size nq * k :type indexes: int :param indexes: output vector ids, size nq * k :param y_norm2: (optional) norms for the y vectors (nullptr or size ny) :param sel: search in this subset of vectors )r knn_L2sqrrrrrr-sFr-c Cst|||||||||| | S)a= Find the max inner product neighbors for nx queries in a set of ny vectors indexed by ids. May be useful for re-ranking a pre-selected vector list :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size (max(ids) + 1) * d :type ids: int :param ids: subset of database vectors to consider, size (nx, nsubset) :param res: result structure :type ld_ids: int, optional :param ld_ids: stride for the ids array. -1: use nsubset, 0: all queries process the same subset )rknn_inner_products_by_idx) r2rsubsetrrrnsubsetrvalsr'Zld_idsrrrr.3sr.c Cst|||||||||| | S)aC Find the nearest neighbors for nx queries in a set of ny vectors indexed by ids. May be useful for re-ranking a pre-selected vector list :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size (max(ids) + 1) * d :type subset: int :param subset: subset of database vectors to consider, size (nx, nsubset) :param res: rIDesult structure :type ld_subset: int, optional :param ld_subset: stride for the subset array. -1: use nsubset, 0: all queries process the same subset )rknn_L2sqr_by_idx) r2rr/rrrr0rr1r'Z ld_subsetrrrr2Esr2c Cst||||||||S)a Return the k nearest neighbors of each of the nx vectors x among the ny vector y, w.r.t to max inner product :type x: float :param x: query vectors, size nx * d :type y: float :param y: database vectors, size ny * d :type radius: float :param radius: search radius around the x vectors :type result: :py:class:`RangeSearchResult` :param result: result structure )rrange_search_L2sqrr2rrrrrrselrrrr3Wsr3c Cst||||||||S)z< same as range_search_L2sqr for the inner product similarity)rrange_search_inner_productr4rrrr6gsr6c Cst|||||||S)z specialized function for PQ2)rcompute_PQ_dis_tables_dsub2)rksub centroidsrr2Zis_inner_product dis_tablesrrrr7ksr7cCst|||||S)z compute c := a + bf * b for a, b and c tables :type n: int :param n: size of the tables :type a: float :param a: size n :type b: float :param b: size n :type c: float :param c: result table, size n )r fvec_maddrBrbfr~r%rrrr;os r;cCst|||||S)z same as fvec_madd, also return index of the min of the result table :rtype: int :return: index of the min of table c )rfvec_madd_and_argminr<rrrr>~sr>c@sheZdZdZeddddddZeZeej ej Z ddZ d d Z d d Zd dZdddZejZdS)RandomGeneratorz< random generator that can be used in multithreaded contextscCs |jSr#r0r1rrrr3r4zRandomGenerator.cCs |j|Sr#r0r5rrrr3r4r7r8cCs t|Sz random int64_t)rZRandomGenerator_rand_int64r@rrr rand_int64szRandomGenerator.rand_int64cGstj|g|RSz *Overload 1:* random positive integer | *Overload 2:* generate random integer between 0 and max-1 )rZRandomGenerator_rand_intrQrrrrand_ints zRandomGenerator.rand_intcCs t|Sz between 0 and 1)rZRandomGenerator_rand_floatr@rrr rand_floatszRandomGenerator.rand_floatcCs t|Sr#)rZRandomGenerator_rand_doubler@rrr rand_doubleszRandomGenerator.rand_doublercCst|t|dSr#)rZRandomGenerator_swiginitZnew_RandomGeneratorrrrrrr?szRandomGenerator.__init__N)r)r r r,r-rrrrrZRandomGenerator_mt_getZRandomGenerator_mt_setmtrArCrErFr?Zdelete_RandomGeneratorrTrrrrr?s  r?c@speZdZdZeddddddZeZeej ej Z ddZ d d Z d d Zd dZdddZddZejZdS)SplitMix64RandomGeneratorzu fast random generator that cannot be used in multithreaded contexts. based on https://prng.di.unimi.it/ cCs |jSr#r0r1rrrr3r4z"SplitMix64RandomGenerator.cCs |j|Sr#r0r5rrrr3r4r7r8cCs t|Sr@)rZ$SplitMix64RandomGenerator_rand_int64r@rrrrAsz$SplitMix64RandomGenerator.rand_int64cGstj|g|RSrB)rZ"SplitMix64RandomGenerator_rand_intrQrrrrCs z"SplitMix64RandomGenerator.rand_intcCs t|SrD)rZ$SplitMix64RandomGenerator_rand_floatr@rrrrEsz$SplitMix64RandomGenerator.rand_floatcCs t|Sr#)rZ%SplitMix64RandomGenerator_rand_doubler@rrrrFsz%SplitMix64RandomGenerator.rand_doublercCst|t|dSr#)rZ"SplitMix64RandomGenerator_swiginitZnew_SplitMix64RandomGeneratorrGrrrr?sz"SplitMix64RandomGenerator.__init__cCs t|Sr#)rZSplitMix64RandomGenerator_nextr@rrrrHszSplitMix64RandomGenerator.nextN)r)r r r,r-rrrrrZ#SplitMix64RandomGenerator_state_getZ#SplitMix64RandomGenerator_state_setstaterArCrErFr?rHZ delete_SplitMix64RandomGeneratorrTrrrrrIs  rIcCst|||Sr#)r float_randr2rBrrrrrKsrKcCst|||Sr#)r float_randnrLrrrrMsrMcCst|||Sr#)r int64_randrLrrrrNsrNcCst|||Sr#)r byte_randrLrrrrOsrOcCst||||Sr#)rint64_rand_max)r2rBmaxrrrrrPsrPcCst|||Sr#)r rand_permpermrBrrrrrRsrRcCst|||Sr#)rrand_perm_splitmix64rSrrrrUsrUcCst||||Sr#)rrand_smooth_vectors)rBrr2rrrrrVsrVcCst|||S)a) Indirect sort of a floating-point array :type n: int :param n: size of the array :type vals: float :param vals: array to sort, size n :type perm: int :param perm: output: permutation of [0..n-1], st. vals[perm[i + 1]] >= vals[perm[i]] )r fvec_argsortrBr1rTrrrrWs rWcCst|||S)z# Same as fvec_argsort, parallelized)rfvec_argsort_parallelrXrrrrYsrYcCst||||||S)a Bucket sort of a list of values :type vals: int :param vals: values to sort, size nval, max value nbucket - 1 :type lims: int :param lims: output limits of buckets, size nbucket + 1 :type perm: int :param perm: output buckets, the elements of bucket i are in perm[lims[i]:lims[i + 1]] :type nt: int, optional :param nt: number of threads (0 = pure sequential code) )r bucket_sort)Znvalr1ZnbucketlimsrTntrrrrZsrZcGs tj|S)a_ *Overload 1:* in-place bucket sort (with attention to memory=>int32) on input the values are in a nrow * col matrix we want to store the row numbers in the output. :type vals: int :param vals: positive values to sort, size nrow * ncol, max value nbucket - 1 :type lims: int :param lims: output limits of buckets, size nbucket + 1 :type nt: int, optional :param nt: number of threads (0 = pure sequential code) | *Overload 2:* same with int64 elements | *Overload 3:* same with int64 elements )rmatrix_bucket_sort_inplacerrrrr]sr]cCs t||S)a Hashtable implementation for int64 -> int64 with external storage implemented for fast batch add and lookup. tab is of size 2 * (1 << log2_capacity) n is the number of elements to add or search adding several values in a same batch: an arbitrary one gets added in different batches: the newer batch overwrites. raises an exception if capacity is exhausted. )rhashtable_int64_to_int64_init) log2_capacitytabrrrr^)s r^cCst|||||Sr#)rhashtable_int64_to_int64_addr_r`rBkeysr1rrrra7sracCst|||||Sr#)rhashtable_int64_to_int64_lookuprbrrrrd:srdcCs t|S)z this function is used to distinguish between min and max indexes since we need to support similarity and dis-similarity metrics in a flexible way )ris_similarity_metric) metric_typerrrreTsrec@sJeZdZdZeddddddZeZeej ej ddZ ej Z dd Zd S) SearchParametersz Parent class for the optional search paramenters. Sub-classes with additional search parameters should inherit this class. Ownership of the object fields is always to the caller. cCs |jSr#r0r1rrrr3fr4zSearchParameters.cCs |j|Sr#r0r5rrrr3fr4r7r8z> if non-null, only these IDs will be considered during search.cCst|tdSr#)rZSearchParameters_swiginitZnew_SearchParametersr@rrrr?kszSearchParameters.__init__N)r r r,r-rrrrrZSearchParameters_sel_getZSearchParameters_sel_setr5Zdelete_SearchParametersrTr?rrrrrg^s rgc@sVeZdZdZeddddddZddZeZee j e j d dZ ee j e jd dZee je jd dZee je jd dZee je jd dZee je jddZe jZddZddZddZ dddZ#ddZ$dd Z%d!d"Z&d#d$Z'd%d&Z(d?d'd(Z)d)d*Z*d+d,Z+d-d.Z,d/d0Z-d1d2Z.d3d4Z/d@d6d7Z0d8d9Z1d:d;Z2dS)AIndexz Abstract structure for an index, supports adding vectors and searching them. All vectors provided at add or search time are 32-bit float arrays, although the internal representation may vary. cCs |jSr#r0r1rrrr3yr4zIndex.cCs |j|Sr#r0r5rrrr3yr4r7r8cOs tddSr:r;r<rrrr?{szIndex.__init__ vector dimension total nb of indexed vectors verbosity levelzX set if the Index does not require training, or if training is done already * type of metric this index uses for searchz argument of the metric typecCst|||S)z Perform training on a representative set of vectors :type n: int :param n: nb of training vectors :type x: float :param x: training vecors, size n * d )rZ Index_trainrrBr2rrrtrains z Index.traincCst|||S)a{ Add n vectors of dimension d to the index. Vectors are implicitly assigned labels ntotal .. ntotal + n - 1 This function slices the input vectors in chunks smaller than blocksize_add and calls add_core. :type n: int :param n: number of vectors :type x: float :param x: input matrix, size n * d )rZ Index_addrmrrradds z Index.addcCst||||S)a Same as add, but stores xids instead of sequential ids. The default implementation fails with an assertion, as it is not supported by all indexes. :type n: int :param n: number of vectors :type x: float :param x: input vectors, size n * d :type xids: int :param xids: if non-null, ids to store for the vectors (size n) )rZIndex_add_with_idsrrBr2xidsrrr add_with_idsszIndex.add_with_idsNc Cst|||||||S)a\ query n vectors of dimension d to the index. return at most k vectors. If there are not enough results for a query, the result array is padded with -1s. :type n: int :param n: number of vectors :type x: float :param x: input vectors to search, size n * d :type k: int :param k: number of extracted vectors :type distances: float :param distances: output pairwise distances, size n*k :type labels: int :param labels: output labels of the NNs, size n*k )rZ Index_searchrrBr2rrrparamsrrrsearchsz Index.searchcCst||||||S)a query n vectors of dimension d to the index. return all vectors with distance < radius. Note that many indexes do not implement the range_search (only the k-NN search is mandatory). :type n: int :param n: number of vectors :type x: float :param x: input vectors to search, size n * d :type radius: float :param radius: search radius :type result: :py:class:`RangeSearchResult` :param result: result table )rZIndex_range_searchrrBr2rrrtrrr range_searchszIndex.range_searchrcCst|||||S)a return the indexes of the k vectors closest to the query x. This function is identical as search but only return labels of neighbors. :type n: int :param n: number of vectors :type x: float :param x: input vectors to search, size n * d :type labels: int :param labels: output labels of the NNs, size n*k :type k: int, optional :param k: number of nearest neighbours )rZ Index_assignrrBr2rrrrrassignsz Index.assigncCs t|S)z( removes all elements from the database.)rZ Index_resetr@rrrr|sz Index.resetcCs t||S)z| removes IDs from the index. Not supported by all indexes. Returns the number of elements removed. )rZIndex_remove_idsrr5rrr remove_idsszIndex.remove_idscCst|||S)a7 Reconstruct a stored vector (or an approximation if lossy coding) this function may not be defined for some indexes :type key: int :param key: id of the vector to reconstruct :type recons: float :param recons: reconstucted vector (size d) )rZIndex_reconstructrkeyreconsrrr reconstructs zIndex.reconstructcCst||||S)a Reconstruct several stored vectors (or an approximation if lossy coding) this function may not be defined for some indexes :type n: int :param n: number of vectors to reconstruct :type keys: int :param keys: ids of the vectors to reconstruct (size n) :type recons: float :param recons: reconstucted vector (size n * d) )rZIndex_reconstruct_batch)rrBrcr~rrrreconstruct_batchs zIndex.reconstruct_batchcCst||||S)a} Reconstruct vectors i0 to i0 + ni - 1 this function may not be defined for some indexes :type i0: int :param i0: index of the first vector in the sequence :type ni: int :param ni: number of vectors in the sequence :type recons: float :param recons: reconstucted vector (size ni * d) )rZIndex_reconstruct_nri0nir~rrr reconstruct_ns zIndex.reconstruct_nc Cst||||||||S)a Similar to search, but also reconstructs the stored vectors (or an approximation in the case of lossy coding) for the search results. If there are not enough results for a query, the resulting arrays is padded with -1s. :type n: int :param n: number of vectors :type x: float :param x: input vectors to search, size n * d :type k: int :param k: number of extracted vectors :type distances: float :param distances: output pairwise distances, size n*k :type labels: int :param labels: output labels of the NNs, size n*k :type recons: float :param recons: reconstructed vectors size (n, k, d) )rZIndex_search_and_reconstructrrBr2rrrr~rtrrrsearch_and_reconstructszIndex.search_and_reconstructcCst||||S)aK Computes a residual vector after indexing encoding. The residual vector is the difference between a vector and the reconstruction that can be decoded from its representation in the index. The residual can be used for multiple-stage indexing methods, like IndexIVF's methods. :type x: float :param x: input vector, size d :type residual: float :param residual: output residual vector, size d :type key: int :param key: encoded index, as returned by search and assign )rZIndex_compute_residual)rr2Zresidualr}rrrcompute_residual5szIndex.compute_residualcCst|||||S)a Computes a residual vector after indexing encoding (batch form). Equivalent to calling compute_residual for each vector. The residual vector is the difference between a vector and the reconstruction that can be decoded from its representation in the index. The residual can be used for multiple-stage indexing methods, like IndexIVF's methods. :type n: int :param n: number of vectors :type xs: float :param xs: input vectors, size (n x d) :type residuals: float :param residuals: output residual vectors, size (n x d) :type keys: int :param keys: encoded index, as returned by search and assign )rZIndex_compute_residual_n)rrBZxs residualsrcrrrcompute_residual_nGszIndex.compute_residual_ncCs t|S)z Get a DistanceComputer (defined in AuxIndexStructures) object for this kind of index. DistanceComputer is implemented for indexes that support random access of their vectors. )rZIndex_get_distance_computerr@rrrget_distance_computer\szIndex.get_distance_computercCs t|Sz$ size of the produced codes in bytes)rZIndex_sa_code_sizer@rrr sa_code_sizefszIndex.sa_code_sizecCst||||S)a encode a set of vectors :type n: int :param n: number of vectors :type x: float :param x: input vectors, size n * d :type bytes: uint8_t :param bytes: output encoded vectors, size n * sa_code_size() )rZIndex_sa_encoderrBr2rrrr sa_encodejs zIndex.sa_encodecCst||||S)a decode a set of vectors :type n: int :param n: number of vectors :type bytes: uint8_t :param bytes: input encoded vectors, size n * sa_code_size() :type x: float :param x: output vectors, size n * d )rZIndex_sa_decoderrBrr2rrr sa_decodews zIndex.sa_decodercCst|||Sz moves the entries from another dataset to self. On output, other is empty. add_id is added to all moved ids (for sequential ids, this would be this->ntotal) )rZIndex_merge_fromr otherIndexadd_idrrr merge_fromszIndex.merge_fromcCs t||Sz check that the two indexes are compatible (ie, they are trained in the same way and have the same parameters). Otherwise throw. )rZ Index_check_compatible_for_mergerrrrrcheck_compatible_for_mergesz Index.check_compatible_for_mergecCst||||Sz Add vectors that are computed with the standalone codec :type codes: uint8_t :param codes: codes to add size n * sa_code_size() :type xids: int :param xids: corresponding ids, size n )rZIndex_add_sa_codesrrBrrqrrr add_sa_codess zIndex.add_sa_codes)N)N)r)N)r)3r r r,r-rrr?rrrZ Index_d_getZ Index_d_setrZIndex_ntotal_getZIndex_ntotal_setntotalZIndex_verbose_getZIndex_verbose_setrZIndex_is_trained_getZIndex_is_trained_set is_trainedZIndex_metric_type_getZIndex_metric_type_setrfZIndex_metric_arg_getZIndex_metric_arg_set metric_argZ delete_IndexrTrnrorrrurwryr|r{rrrrrrrrrrrrrrrrrrhps@         rhc@sTeZdZeddddddZddZeZdd Zd d Z d d Z ddZ e j ZdS)DistanceComputercCs |jSr#r0r1rrrr3r4zDistanceComputer.cCs |j|Sr#r0r5rrrr3r4r7r8cOs tddSr:r;r<rrrr?szDistanceComputer.__init__cCs t||S)zv called before computing distances. Pointer x should remain valid while operator () is called )rZDistanceComputer_set_queryrErrr set_queryszDistanceComputer.set_querycCs t||Sz. compute distance of vector i to current query)rZDistanceComputer___call__rrrrr__call__szDistanceComputer.__call__c Cst||||||||| S)z compute distances of current query to 4 stored vectors. certain DistanceComputer implementations may benefit heavily from this. )rZ"DistanceComputer_distances_batch_4 rZidx0Zidx1Zidx2Zidx3rrrrrrrdistances_batch_4sz"DistanceComputer.distances_batch_4cCst|||Sz, compute distance between two stored vectors)rZDistanceComputer_symmetric_disrrjrrr symmetric_disszDistanceComputer.symmetric_disN)r r r,rrr?rrrrrrrZdelete_DistanceComputerrTrrrrrsrc@sfeZdZeddddddZeZeejej ddZ ddZ d d Z d d Z d dZddZejZdS)NegativeDistanceComputercCs |jSr#r0r1rrrr3r4z!NegativeDistanceComputer.cCs |j|Sr#r0r5rrrr3r4r7r8z owned by thiscCst|t|dSr#)rZ!NegativeDistanceComputer_swiginitZnew_NegativeDistanceComputer)rbasedisrrrr?sz!NegativeDistanceComputer.__init__cCs t||Sr#)rZ"NegativeDistanceComputer_set_queryrErrrrsz"NegativeDistanceComputer.set_querycCs t||Sr)rZ!NegativeDistanceComputer___call__rrrrrsz!NegativeDistanceComputer.__call__c Cst||||||||| Sr#)rZ*NegativeDistanceComputer_distances_batch_4rrrrrsz*NegativeDistanceComputer.distances_batch_4cCst|||Sr)rZ&NegativeDistanceComputer_symmetric_disrrrrrsz&NegativeDistanceComputer.symmetric_disN)r r r,rrrrrZ$NegativeDistanceComputer_basedis_getZ$NegativeDistanceComputer_basedis_setrr?rrrrZdelete_NegativeDistanceComputerrTrrrrrsrc@s`eZdZeddddddZddZeZeej ej Z eej ej Zdd Zd d ZejZd S) FlatCodesDistanceComputercCs |jSr#r0r1rrrr3r4z"FlatCodesDistanceComputer.cCs |j|Sr#r0r5rrrr3r4r7r8cOs tddSr:r;r<rrrr?sz"FlatCodesDistanceComputer.__init__cCs t||Sr#)rZ"FlatCodesDistanceComputer___call__rrrrrsz"FlatCodesDistanceComputer.__call__cCs t||S)z7 compute distance of current query to an encoded vector)rZ*FlatCodesDistanceComputer_distance_to_coderrrrrdistance_to_codesz*FlatCodesDistanceComputer.distance_to_codeN)r r r,rrr?rrrZ#FlatCodesDistanceComputer_codes_getZ#FlatCodesDistanceComputer_codes_setrZ'FlatCodesDistanceComputer_code_size_getZ'FlatCodesDistanceComputer_code_size_setrrrZ delete_FlatCodesDistanceComputerrTrrrrrsrc@seZdZdZeddddddZeZeej ej Z eej ej ddZdd Zd d Zd d ZddZddZddZddZddZddZd*ddZd+ddZdd Zd!d"Zd,d$d%Zd&d'Zd(d)ZejZ dS)-IndexFlatCodeszr Index that encodes all vectors as fixed-size codes (size code_size). Storage is in the codes vector cCs |jSr#r0r1rrrr3r4zIndexFlatCodes.cCs |j|Sr#r0r5rrrr3r4r7r8z) encoded dataset, size ntotal * code_sizecGst|tj|dSr#)rZIndexFlatCodes_swiginitZnew_IndexFlatCodesrQrrrr?szIndexFlatCodes.__init__cCst|||S)z default add uses sa_encode)rZIndexFlatCodes_addrmrrrroszIndexFlatCodes.addcCs t|Sr#)rZIndexFlatCodes_resetr@rrrr| szIndexFlatCodes.resetcCst||||Sr#)rZIndexFlatCodes_reconstruct_nrrrrr szIndexFlatCodes.reconstruct_ncCst|||Sr#)rZIndexFlatCodes_reconstructr|rrrr szIndexFlatCodes.reconstructcCs t|Sr#)rZIndexFlatCodes_sa_code_sizer@rrrr szIndexFlatCodes.sa_code_sizecCs t||S)z remove some ids. NB that because of the structure of the index, the semantics of this operation are different from the usual ones: the new ids are shifted )rZIndexFlatCodes_remove_idsrzrrrr{ szIndexFlatCodes.remove_idscCs t|S)z a FlatCodesDistanceComputer offers a distance_to_code method The default implementation explicitly decodes the vector with sa_decode. )rZ,IndexFlatCodes_get_FlatCodesDistanceComputerr@rrrget_FlatCodesDistanceComputer sz,IndexFlatCodes.get_FlatCodesDistanceComputercCs t|Sr#)rZ$IndexFlatCodes_get_distance_computerr@rrrr sz$IndexFlatCodes.get_distance_computerNc Cst|||||||S)z Search implemented by decoding)rZIndexFlatCodes_searchrsrrrru szIndexFlatCodes.searchcCst||||||Sr#)rZIndexFlatCodes_range_searchrvrrrrw$ szIndexFlatCodes.range_searchcCs t|Sr#)rZIndexFlatCodes_get_CodePackerr@rrrget_CodePacker' szIndexFlatCodes.get_CodePackercCs t||Sr#)rZ)IndexFlatCodes_check_compatible_for_mergerrrrr* sz)IndexFlatCodes.check_compatible_for_mergercCst|||Sr#)rZIndexFlatCodes_merge_fromrrrrr- szIndexFlatCodes.merge_fromcCst||||Sr#)rZIndexFlatCodes_add_sa_codesrprrrr0 szIndexFlatCodes.add_sa_codescCs t||Sr#)rZIndexFlatCodes_permute_entriesrrTrrrpermute_entries3 szIndexFlatCodes.permute_entries)N)N)r)!r r r,r-rrrrrZIndexFlatCodes_code_size_getZIndexFlatCodes_code_size_setrZIndexFlatCodes_codes_getZIndexFlatCodes_codes_setrr?ror|rrrr{rrrurwrrrrrZdelete_IndexFlatCodesrTrrrrrs,   rc@s|eZdZdZeddddddZeZddd Zdd d Z d d Z ddZ ddZ ddZ ddZddZddZejZdS) IndexFlatzB Index that stores the full vectors and performs exhaustive searchcCs |jSr#r0r1rrrr3< r4zIndexFlat.cCs |j|Sr#r0r5rrrr3< r4r7r8Nc Cst|||||||Sr#)rZIndexFlat_searchrsrrrru? szIndexFlat.searchcCst||||||Sr#)rZIndexFlat_range_searchrvrrrrwB szIndexFlat.range_searchcCst|||Sr#)rZIndexFlat_reconstructr|rrrrE szIndexFlat.reconstructcCst||||||S)a compute distance with a subset of vectors :type x: float :param x: query vectors, size n * d :type labels: int :param labels: indices of the vectors that should be compared for each query vector, size n * k :type distances: float :param distances: corresponding output distances, size n * k )rZ!IndexFlat_compute_distance_subset)rrBr2rrrrrrcompute_distance_subsetH s z!IndexFlat.compute_distance_subsetcGstj|g|RSr#)rZIndexFlat_get_xbrQrrrget_xbW szIndexFlat.get_xbcGst|tj|dSr#)rZIndexFlat_swiginitZ new_IndexFlatrQrrrr?Z szIndexFlat.__init__cCs t|Sr#)rZ'IndexFlat_get_FlatCodesDistanceComputerr@rrrr] sz'IndexFlat.get_FlatCodesDistanceComputercCst||||Sr#)rZIndexFlat_sa_encoderrrrr` szIndexFlat.sa_encodecCst||||Sr#)rZIndexFlat_sa_decoderrrrrc szIndexFlat.sa_decode)N)N)r r r,r-rrrrrurwrrrr?rrrrZdelete_IndexFlatrTrrrrr9 s  rc@s4eZdZeddddddZeZddZej Z dS) IndexFlatIPcCs |jSr#r0r1rrrr3j r4zIndexFlatIP.cCs |j|Sr#r0r5rrrr3j r4r7r8cGst|tj|dSr#)rZIndexFlatIP_swiginitZnew_IndexFlatIPrQrrrr?m szIndexFlatIP.__init__N) r r r,rrrrr?rZdelete_IndexFlatIPrTrrrrri src@sZeZdZeddddddZeZeejej Z ddZ dd Z d d Z d d ZejZdS) IndexFlatL2cCs |jSr#r0r1rrrr3t r4zIndexFlatL2.cCs |j|Sr#r0r5rrrr3t r4r7r8cGst|tj|dSr#)rZIndexFlatL2_swiginitZnew_IndexFlatL2rQrrrr?x szIndexFlatL2.__init__cCs t|Sr#)rZ)IndexFlatL2_get_FlatCodesDistanceComputerr@rrrr{ sz)IndexFlatL2.get_FlatCodesDistanceComputercCs t|Sr#)rZIndexFlatL2_sync_l2normsr@rrr sync_l2norms~ szIndexFlatL2.sync_l2normscCs t|Sr#)rZIndexFlatL2_clear_l2normsr@rrr clear_l2norms szIndexFlatL2.clear_l2normsN)r r r,rrrrrZIndexFlatL2_cached_l2norms_getZIndexFlatL2_cached_l2norms_setZcached_l2normsr?rrrZdelete_IndexFlatL2rTrrrrrs src@seZdZdZeddddddZeZeej ej ddZ eej ej ddZdd d Zd d ZddZddZdddZejZdS) IndexFlat1Dz$ optimized version for 1D "vectors".cCs |jSr#r0r1rrrr3 r4zIndexFlat1D.cCs |j|Sr#r0r5rrrr3 r4r7r8z) is the permutation updated continuously?z sorted database indicesTcCst|t|dSr#)rZIndexFlat1D_swiginitZnew_IndexFlat1D)rcontinuous_updaterrrr? szIndexFlat1D.__init__cCs t|S)zg if not continuous_update, call this between the last add and the first search )rZIndexFlat1D_update_permutationr@rrrupdate_permutation szIndexFlat1D.update_permutationcCst|||Sr#)rZIndexFlat1D_addrmrrrro szIndexFlat1D.addcCs t|Sr#)rZIndexFlat1D_resetr@rrrr| szIndexFlat1D.resetNc Cst|||||||S)z+ Warn: the distances returned are L1 not L2)rZIndexFlat1D_searchrsrrrru szIndexFlat1D.search)T)N)r r r,r-rrrrrZ!IndexFlat1D_continuous_update_getZ!IndexFlat1D_continuous_update_setrZIndexFlat1D_perm_getZIndexFlat1D_perm_setrTr?rror|ruZdelete_IndexFlat1DrTrrrrr s  rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZ eej!ej"ddZ#eej$ej%ddZ&eej'ej(ddZ)eej*ej+ddZ,eej-ej.ddZ/ddZ0ej1Z2dS)ClusteringParameterszn Class for the clustering parameters. Can be passed to the constructor of the Clustering object. cCs |jSr#r0r1rrrr3 r4zClusteringParameters.cCs |j|Sr#r0r5rrrr3 r4r7r8z number of clustering iterationsz[ redo clustering this many times and keep the clusters with the best objective zg whether to normalize centroids after each iteration (useful for inner product clustering) z= round centroids coordinates to integer after each iteration?z% re-train index after each iteration?zd Use the subset of centroids provided as input and do not change them during iterations z If fewer than this number of training vectors per centroid are provided, writes a warning. Note that fewer than 1 point per centroid raises an exception. zC to limit size of dataset, otherwise the training set is subsampledz seed for the random number generator. negative values lead to seeding an internal rng with std::high_resolution_clock. zB when the training set is encoded, batch size of the codec decoderz+ whether to check for NaNs in an input dataz Whether to use splitmix64-based random number generator for subsampling, which is faster, but may pick duplicate points. cCst|tdSr#)rZClusteringParameters_swiginitZnew_ClusteringParametersr@rrrr? szClusteringParameters.__init__N)3r r r,r-rrrrrZClusteringParameters_niter_getZClusteringParameters_niter_setniterZClusteringParameters_nredo_getZClusteringParameters_nredo_setZnredoZ ClusteringParameters_verbose_getZ ClusteringParameters_verbose_setrZ"ClusteringParameters_spherical_getZ"ClusteringParameters_spherical_setZ sphericalZ&ClusteringParameters_int_centroids_getZ&ClusteringParameters_int_centroids_setZ int_centroidsZ%ClusteringParameters_update_index_getZ%ClusteringParameters_update_index_setZ update_indexZ)ClusteringParameters_frozen_centroids_getZ)ClusteringParameters_frozen_centroids_setZfrozen_centroidsZ0ClusteringParameters_min_points_per_centroid_getZ0ClusteringParameters_min_points_per_centroid_setZmin_points_per_centroidZ0ClusteringParameters_max_points_per_centroid_getZ0ClusteringParameters_max_points_per_centroid_setZmax_points_per_centroidZClusteringParameters_seed_getZClusteringParameters_seed_setrZ*ClusteringParameters_decode_block_size_getZ*ClusteringParameters_decode_block_size_setZdecode_block_sizeZ2ClusteringParameters_check_input_data_for_NaNs_getZ2ClusteringParameters_check_input_data_for_NaNs_setZcheck_input_data_for_NaNsZ/ClusteringParameters_use_faster_subsampling_getZ/ClusteringParameters_use_faster_subsampling_setZuse_faster_subsamplingr?Zdelete_ClusteringParametersrTrrrrr s$rc@seZdZeddddddZeZeejej ddZ eej ej ddZ eejejddZeejejd dZeejejd dZd d ZejZd S)ClusteringIterationStatscCs |jSr#r0r1rrrr3 r4z!ClusteringIterationStats.cCs |j|Sr#r0r5rrrr3 r4r7r8z6 objective values (sum of distances reported by index)z seconds for iterationz seconds for just searchz imbalance factor of iterationz number of cluster splitscCst|tdSr#)rZ!ClusteringIterationStats_swiginitZnew_ClusteringIterationStatsr@rrrr? sz!ClusteringIterationStats.__init__N)r r r,rrrrrZ ClusteringIterationStats_obj_getZ ClusteringIterationStats_obj_setobjZ!ClusteringIterationStats_time_getZ!ClusteringIterationStats_time_settimeZ(ClusteringIterationStats_time_search_getZ(ClusteringIterationStats_time_search_setZ time_searchZ-ClusteringIterationStats_imbalance_factor_getZ-ClusteringIterationStats_imbalance_factor_setrZ#ClusteringIterationStats_nsplit_getZ#ClusteringIterationStats_nsplit_setZnsplitr?Zdelete_ClusteringIterationStatsrTrrrrr src@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d ZdddZdddZddZejZd S) Clusteringa K-means clustering based on assignment - centroid update iterations The clustering is based on an Index object that assigns training points to the centroids. Therefore, at each iteration the centroids are added to the index. On output, the centoids table is set to the latest version of the centroids and they are also added to the index. If the centroids table it is not empty on input, it is also used for initialization. cCs |jSr#r0r1rrrr3 r4zClustering.cCs |j|Sr#r0r5rrrr3 r4r7r8 dimension of the vectors nb of centroidszp centroids (k * d) if centroids are set on input to train, they will be used as initialization ' stats at every iteration of clusteringcGst|tj|dSr#)rZClustering_swiginitZnew_ClusteringrQrrrr? szClustering.__init__NcCst|||||S)aH run k-means training :type x: float :param x: training vectors, size n * d :type index: :py:class:`Index` :param index: index used for assignment :type x_weights: float, optional :param x_weights: weight associated to each vector: NULL or size n )rZClustering_train)rrBr2indexZ x_weightsrrrrn s zClustering.traincCst||||||S)aB run with encoded vectors win addition to train()'s parameters takes a codec as parameter to decode the input vectors. :type codec: :py:class:`Index` :param codec: codec used to decode the vectors (nullptr = vectors are in fact floats) )rZClustering_train_encoded)rrrcodecrweightsrrr train_encoded s zClustering.train_encodedcCs t|S)z Post-process the centroids after each centroid update. includes optional L2 normalization and nearest integer rounding )rZ!Clustering_post_process_centroidsr@rrrpost_process_centroids sz!Clustering.post_process_centroids)N)N)r r r,r-rrrrrZClustering_d_getZClustering_d_setrZClustering_k_getZClustering_k_setrZClustering_centroids_getZClustering_centroids_setr9ZClustering_iteration_stats_getZClustering_iteration_stats_setiteration_statsr?rnrrZdelete_ClusteringrTrrrrr s  rc@s@eZdZdZeddddddZeZddZd d Z e j Z d S) Clustering1Dzw Exact 1D clustering algorithm Since it does not use an index, it does not overload the train() function cCs |jSr#r0r1rrrr3, r4zClustering1D.cCs |j|Sr#r0r5rrrr3, r4r7r8cGst|tj|dSr#)rZClustering1D_swiginitZnew_Clustering1DrQrrrr?/ szClustering1D.__init__cCst|||Sr#)rZClustering1D_train_exactrmrrr train_exact2 szClustering1D.train_exactN) r r r,r-rrrrr?rrZdelete_Clustering1DrTrrrrr% s rc@sXeZdZeddddddZeZeejej ddZ eej ej ddZ dd ZejZd S) "ProgressiveDimClusteringParameterscCs |jSr#r0r1rrrr39 r4z+ProgressiveDimClusteringParameters.cCs |j|Sr#r0r5rrrr39 r4r7r8z number of incremental stepsz apply PCA on inputcCst|tdSr#)rZ+ProgressiveDimClusteringParameters_swiginitZ&new_ProgressiveDimClusteringParametersr@rrrr?> sz+ProgressiveDimClusteringParameters.__init__N)r r r,rrrrrZcCs |j|Sr#r0r5rrrr3G r4r7r8cCs t||S)z ownership transferred to caller)rZ#ProgressiveDimIndexFactory___call__)rdimrrrrJ sz#ProgressiveDimIndexFactory.__call__cCst|tdSr#)rZ#ProgressiveDimIndexFactory_swiginitZnew_ProgressiveDimIndexFactoryr@rrrr?O sz#ProgressiveDimIndexFactory.__init__N) r r r,r-rrrrrrZ!delete_ProgressiveDimIndexFactoryrTr?rrrrrD s rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d Zd dZejZdS)ProgressiveDimClusteringa K-means clustering with progressive dimensions used The clustering first happens in dim 1, then with exponentially increasing dimension until d (I steps). This is typically applied after a PCA transformation (optional). Reference: "Improved Residual Vector Quantization for High-dimensional Approximate Nearest Neighbor Search" Shicong Liu, Hongtao Lu, Junru Shao, AAAI'15 https://arxiv.org/abs/1509.05195 cCs |jSr#r0r1rrrr3d r4z!ProgressiveDimClustering.cCs |j|Sr#r0r5rrrr3d r4r7r8rrz centroids (k * d)rcGst|tj|dSr#)rZ!ProgressiveDimClustering_swiginitZnew_ProgressiveDimClusteringrQrrrr?k sz!ProgressiveDimClustering.__init__cCst||||Sr#)rZProgressiveDimClustering_train)rrBr2factoryrrrrnn szProgressiveDimClustering.trainN)r r r,r-rrrrrZProgressiveDimClustering_d_getZProgressiveDimClustering_d_setrZProgressiveDimClustering_k_getZProgressiveDimClustering_k_setrZ&ProgressiveDimClustering_centroids_getZ&ProgressiveDimClustering_centroids_setr9Z,ProgressiveDimClustering_iteration_stats_getZ,ProgressiveDimClustering_iteration_stats_setrr?rnZdelete_ProgressiveDimClusteringrTrrrrrT srcCst|||||S)a simplified interface :type d: int :param d: dimension of the data :type n: int :param n: nb of training vectors :type k: int :param k: nb of output centroids :type x: float :param x: training set (size n * d) :type centroids: float :param centroids: output centroids (size k * d) :rtype: float :return: final quantization error )rkmeans_clustering)rrBrr2r9rrrru src Cst|||||||||| | Sr#)rpairwise_extra_distances) rrr rr rHrrrrrrrrr src Cst|||||||||| Sr#)rknn_extra_metrics) r2rrrrrHrrrZindexesrrrr srcCst|||||S)zm get a DistanceComputer that refers to this type of distance and indexes a flat array of size nb )rget_extra_distance_computer)rrHrrr rrrr src@steZdZdZeddddddZddZeZee j e j d dZ ee j e jd dZd d Zd dZddZe jZdS) Quantizerz( General interface for quantizer objectscCs |jSr#r0r1rrrr3 r4zQuantizer.cCs |j|Sr#r0r5rrrr3 r4r7r8cOs tddSr:r;r<rrrr? szQuantizer.__init__z size of the input vectorsz bytes per indexed vectorcCst|||S)zs Train the quantizer :type x: float :param x: training vectors, size n * d )rZQuantizer_trainrmrrrrn szQuantizer.traincCst||||S)z Quantize a set of vectors :type x: float :param x: input vectors, size n * d :type codes: uint8_t :param codes: output codes, size n * code_size )rZQuantizer_compute_codesrr2rrBrrr compute_codes s zQuantizer.compute_codescCst||||S)z Decode a set of vectors :param codes: input codes, size n * code_size :type x: float :param x: output vectors, size n * d )rZQuantizer_decoderrr2rBrrrdecode szQuantizer.decodeN)r r r,r-rrr?rrrZQuantizer_d_getZQuantizer_d_setrZQuantizer_code_size_getZQuantizer_code_size_setrrnrrZdelete_QuantizerrTrrrrr s   rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZejZejZejZejZej Z!eej"ej#Z$eej%ej&d dZ'eej(ej)d dZ*eej+ej,ddZ-eej.ej/ddZ0eej1ej2ddZ3ddZ4ddZ5ddZ6ddZ7ddZ8ddZ9ddZ:dd Z;d!d"Zd'd(Z?d)d*Z@d+d,ZAdd5d6ZHd7d8ZId9d:ZJejKZLd;S)?ProductQuantizerz Product Quantizer. PQ is trained using k-means, minimizing the L2 distance to centroids. PQ supports L2 and Inner Product search, however the quantization error is biased towards L2 distance. cCs |jSr#r0r1rrrr3 r4zProductQuantizer.cCs |j|Sr#r0r5rrrr3 r4r7r8z number of subquantizersz& number of bits per quantization indexz! dimensionality of each subvectorz* number of centroids for each subquantizer verbose during training?z" parameters used during clusteringzR if non-NULL, use this index for assignment (should be of size d / M) zK Centroid table, size M * ksub * dsub. Layout: (M, ksub, dsub) zV Transposed centroid table, size M * ksub * dsub. Layout: (dsub, M, ksub) zK Squared lengths of centroids, size M * ksub Layout: (M, ksub) cCst|||S)z1 return the centroids associated with subvector m)rZProductQuantizer_get_centroids)rrrrrr get_centroids szProductQuantizer.get_centroidscCst|||Sr#)rZProductQuantizer_trainrmrrrrn szProductQuantizer.traincGst|tj|dSr#)rZProductQuantizer_swiginitZnew_ProductQuantizerrQrrrr? szProductQuantizer.__init__cCs t|S)z9 compute derived values when d, M and nbits have been set)rZ#ProductQuantizer_set_derived_valuesr@rrrset_derived_values sz#ProductQuantizer.set_derived_valuescCst|||S)z( Define the centroids for subquantizer m)rZProductQuantizer_set_params)rr9rrrr set_params szProductQuantizer.set_paramscCst|||S)z/ Quantize one vector with the product quantizer)rZProductQuantizer_compute_code)rr2rrrr compute_code szProductQuantizer.compute_codecCst||||S)z) same as compute_code for several vectors)rZProductQuantizer_compute_codesrrrrr szProductQuantizer.compute_codescCst||||S)zn speed up code assignment using assign_index (non-const because the index is changed) )rZ0ProductQuantizer_compute_codes_with_assign_indexrrrrcompute_codes_with_assign_index sz0ProductQuantizer.compute_codes_with_assign_indexcGstj|g|RSr#)rZProductQuantizer_decoderQrrrr szProductQuantizer.decodecCst|||S)z| If we happen to have the distance tables precomputed, this is more efficient to compute the codes. )rZ1ProductQuantizer_compute_code_from_distance_table)rr`rrrr compute_code_from_distance_table sz1ProductQuantizer.compute_code_from_distance_tablecCst|||S)a Compute distance table for one vector. The distance table for x = [x_0 x_1 .. x_(M-1)] is a M * ksub matrix that contains dis_table (m, j) = || x_m - c_(m, j)||^2 for m = 0..M-1 and j = 0 .. ksub - 1 where c_(m, j) is the centroid no j of sub-quantizer m. :type x: float :param x: input vector size d :type dis_table: float :param dis_table: output table, size M * ksub )rZ'ProductQuantizer_compute_distance_tablerr2Z dis_tablerrrcompute_distance_table sz'ProductQuantizer.compute_distance_tablecCst|||Sr#)rZ)ProductQuantizer_compute_inner_prod_tablerrrrcompute_inner_prod_table) sz)ProductQuantizer.compute_inner_prod_tablecCst||||S)a compute distance table for several vectors :type nx: int :param nx: nb of input vectors :type x: float :param x: input vector size nx * d :param dis_table: output table, size nx * M * ksub )rZ(ProductQuantizer_compute_distance_tablesrrr2r:rrrcompute_distance_tables, s z(ProductQuantizer.compute_distance_tablescCst||||Sr#)rZ*ProductQuantizer_compute_inner_prod_tablesrrrrcompute_inner_prod_tables7 sz*ProductQuantizer.compute_inner_prod_tablesTc Cst|||||||S)aS perform a search (L2 distance) :type x: float :param x: query vectors, size nx * d :type nx: int :param nx: nb of queries :type codes: uint8_t :param codes: database codes, size ncodes * code_size :type ncodes: int :param ncodes: nb of nb vectors :type res: :py:class:`float_maxheap_array_t` :param res: heap array to store results (nh == nx) :type init_finalize_heap: boolean, optional :param init_finalize_heap: initialize heap (input) and sort (output)? )rZProductQuantizer_searchrr2rrrresinit_finalize_heaprrrru: szProductQuantizer.searchc Cst|||||||S)z2 same as search, but with inner product similarity)rZProductQuantizer_search_iprrrr search_ipL szProductQuantizer.search_ipz Symmetric Distance TablecCs t|Sr#)rZ"ProductQuantizer_compute_sdc_tabler@rrrcompute_sdc_tableQ sz"ProductQuantizer.compute_sdc_tablec Cst|||||||Sr#)rZProductQuantizer_search_sdc)rZqcodesrZbcodesrrrrrr search_sdcT szProductQuantizer.search_sdccCs t|S)z Sync transposed centroids with regular centroids. This call is needed if centroids were edited directly. )rZ*ProductQuantizer_sync_transposed_centroidsr@rrrsync_transposed_centroidsW sz*ProductQuantizer.sync_transposed_centroidscCs t|S)z= Clear transposed centroids table so ones are no longer used.)rZ+ProductQuantizer_clear_transposed_centroidsr@rrrclear_transposed_centroids^ sz+ProductQuantizer.clear_transposed_centroidsN)T)T)T)Mr r r,r-rrrrrZProductQuantizer_M_getZProductQuantizer_M_setMZProductQuantizer_nbits_getZProductQuantizer_nbits_setrZProductQuantizer_dsub_getZProductQuantizer_dsub_setZdsubZProductQuantizer_ksub_getZProductQuantizer_ksub_setr8ZProductQuantizer_verbose_getZProductQuantizer_verbose_setrZProductQuantizer_Train_default Train_defaultZ ProductQuantizer_Train_hot_startZTrain_hot_startZProductQuantizer_Train_sharedZ Train_sharedZ ProductQuantizer_Train_hypercubeZTrain_hypercubeZ$ProductQuantizer_Train_hypercube_pcaZTrain_hypercube_pcaZProductQuantizer_train_type_getZProductQuantizer_train_type_set train_typeZProductQuantizer_cp_getZProductQuantizer_cp_setcpZ!ProductQuantizer_assign_index_getZ!ProductQuantizer_assign_index_setZ assign_indexZProductQuantizer_centroids_getZProductQuantizer_centroids_setr9Z)ProductQuantizer_transposed_centroids_getZ)ProductQuantizer_transposed_centroids_setZtransposed_centroidsZ)ProductQuantizer_centroids_sq_lengths_getZ)ProductQuantizer_centroids_sq_lengths_setZcentroids_sq_lengthsrrnr?rrrrrrrrrrrrurZProductQuantizer_sdc_table_getZProductQuantizer_sdc_table_setZ sdc_tablerrrrZdelete_ProductQuantizerrTrrrrr sR    rc@szeZdZeddddddZeZeejej ddZ eej ej Z eejddZeejejZdd d Zd d ZejZd S)PQEncoderGenericcCs |jSr#r0r1rrrr3f r4zPQEncoderGeneric.cCs |j|Sr#r0r5rrrr3f r4r7r8z code for this vectorz& number of bits per subquantizer indexrcCst|t|||dSr#)rZPQEncoderGeneric_swiginitZnew_PQEncoderGeneric)rrroffsetrrrr?m szPQEncoderGeneric.__init__cCs t||Sr#)rZPQEncoderGeneric_encoderErrrencodep szPQEncoderGeneric.encodeN)r)r r r,rrrrrZPQEncoderGeneric_code_getZPQEncoderGeneric_code_setrZPQEncoderGeneric_offset_getZPQEncoderGeneric_offset_setrZPQEncoderGeneric_nbits_getrZPQEncoderGeneric_reg_getZPQEncoderGeneric_reg_setregr?rZdelete_PQEncoderGenericrTrrrrre s rc@sJeZdZeddddddZeZeejej Z ddZ dd Z ej Zd S) PQEncoder8cCs |jSr#r0r1rrrr3w r4zPQEncoder8.cCs |j|Sr#r0r5rrrr3w r4r7r8cCst|t||dSr#)rZPQEncoder8_swiginitZnew_PQEncoder8rrrrrrr?{ szPQEncoder8.__init__cCs t||Sr#)rZPQEncoder8_encoderErrrr~ szPQEncoder8.encodeN)r r r,rrrrrZPQEncoder8_code_getZPQEncoder8_code_setrr?rZdelete_PQEncoder8rTrrrrrv s rc@sJeZdZeddddddZeZeejej Z ddZ dd Z ej Zd S) PQEncoder16cCs |jSr#r0r1rrrr3 r4zPQEncoder16.cCs |j|Sr#r0r5rrrr3 r4r7r8cCst|t||dSr#)rZPQEncoder16_swiginitZnew_PQEncoder16rrrrr? szPQEncoder16.__init__cCs t||Sr#)rZPQEncoder16_encoderErrrr szPQEncoder16.encodeN)r r r,rrrrrZPQEncoder16_code_getZPQEncoder16_code_setrr?rZdelete_PQEncoder16rTrrrrr s rc@szeZdZeddddddZeZeejej Z eej ej Z eejZeejZeejejZddZdd ZejZd S) PQDecoderGenericcCs |jSr#r0r1rrrr3 r4zPQDecoderGeneric.cCs |j|Sr#r0r5rrrr3 r4r7r8cCst|t||dSr#)rZPQDecoderGeneric_swiginitZnew_PQDecoderGenericrrrrr? szPQDecoderGeneric.__init__cCs t|Sr#)rZPQDecoderGeneric_decoder@rrrr szPQDecoderGeneric.decodeN)r r r,rrrrrZPQDecoderGeneric_code_getZPQDecoderGeneric_code_setrZPQDecoderGeneric_offset_getZPQDecoderGeneric_offset_setrZPQDecoderGeneric_nbits_getrZPQDecoderGeneric_mask_getrZPQDecoderGeneric_reg_getZPQDecoderGeneric_reg_setrr?rZdelete_PQDecoderGenericrTrrrrr s  rc@sPeZdZeddddddZeZejZ eej ej Z ddZ dd ZejZd S) PQDecoder8cCs |jSr#r0r1rrrr3 r4zPQDecoder8.cCs |j|Sr#r0r5rrrr3 r4r7r8cCst|t||dSr#)rZPQDecoder8_swiginitZnew_PQDecoder8rrrrr? szPQDecoder8.__init__cCs t|Sr#)rZPQDecoder8_decoder@rrrr szPQDecoder8.decodeN)r r r,rrrrrZPQDecoder8_nbitsrZPQDecoder8_code_getZPQDecoder8_code_setrr?rZdelete_PQDecoder8rTrrrrr src@sPeZdZeddddddZeZejZ eej ej Z ddZ dd ZejZd S) PQDecoder16cCs |jSr#r0r1rrrr3 r4zPQDecoder16.cCs |j|Sr#r0r5rrrr3 r4r7r8cCst|t||dSr#)rZPQDecoder16_swiginitZnew_PQDecoder16rrrrr? szPQDecoder16.__init__cCs t|Sr#)rZPQDecoder16_decoder@rrrr szPQDecoder16.decodeN)r r r,rrrrrZPQDecoder16_nbitsrZPQDecoder16_code_getZPQDecoder16_code_setrr?rZdelete_PQDecoder16rTrrrrr src@s<eZdZdZeddddddZddZeZee j e j d dZ ee j e jd dZee je jd dZee je jd dZee je jd dZee je jddZee je jddZee je j ddZ!ee j"e j#ddZ$ee j%e j&ddZ'ee j(e j)ddZ*ee j+e j,ddZ-ddZ.ee j/e j0ddZ1ee j2e j3ddZ4ee j5e j6ddZ7ddZ8ddZ9ddZ:e j;Ze j?Z@e jAZBe jCZDe jEZFe jGZHe jIZJe jKZLe jMZNd d!ZOd"d#ZPd$d%ZQd=d'd(ZRd>d*d+ZSd,d-ZTd?d.d/ZUee jVe jWd0dZXee jYe jZd1dZ[ee j\e j]Z^d2d3Z_d@d5d6Z`d7d8Zad9d:Zbd;d<Zce jdZed&S)AAdditiveQuantizerz Abstract structure for additive quantizers Different from the product quantizer in which the decoded vector is the concatenation of M sub-vectors, additive quantizers sum M sub-vectors to get the decoded vector. cCs |jSr#r0r1rrrr3 r4zAdditiveQuantizer.cCs |j|Sr#r0r5rrrr3 r4r7r8cOs tddSr:r;r<rrrr? szAdditiveQuantizer.__init__z number of codebooksz bits for each stepz codebooksz codebook #1 is stored in rows codebook_offsets[i]:codebook_offsets[i+1] in the codebooks table of size total_codebook_size by d z' total number of bits (indexes + norms)z bits allocated for the normsz size of the codebook in vectorsz' are all nbits = 8 (use faster decoder)rz is trained or notzt auxiliary data for ST_norm_lsq2x4 and ST_norm_rq2x4 store norms of codebook entries for 4-bit fastscan z store and search normscCs t|Sr#)rZ)AdditiveQuantizer_compute_codebook_tablesr@rrrcompute_codebook_tables sz)AdditiveQuantizer.compute_codebook_tablesz9 norms of all codebook entries (size total_codebook_size)z dot products of all codebook entries with the previous codebooks size sum(codebook_offsets[m] * 2^nbits[m], m=0..M-1) z norms and distance matrixes with beam search can get large, so use this to control for the amount of memory that can be allocated cCs t||S)z" encode a norm into norm_bits bits)rZAdditiveQuantizer_encode_norm)rnormrrr encode_norm szAdditiveQuantizer.encode_normcCs t||S)z/ encode norm by non-uniform scalar quantization)rZAdditiveQuantizer_encode_qcintrErrr encode_qcint szAdditiveQuantizer.encode_qcintcCs t||S)z/ decode norm by non-uniform scalar quantization)rZAdditiveQuantizer_decode_qcintrr%rrr decode_qcint szAdditiveQuantizer.decode_qcintcCs t|S)z Train the norm quantizer)rZ$AdditiveQuantizer_set_derived_valuesr@rrrr sz$AdditiveQuantizer.set_derived_valuescCst|||Sr#)rZAdditiveQuantizer_train_norm)rrBrrrr train_norm szAdditiveQuantizer.train_normcCst||||Sr#)rZAdditiveQuantizer_compute_codesrrrrr szAdditiveQuantizer.compute_codesNcCst|||||Sa7 Encode a set of vectors :type x: float :param x: vectors to encode, size n * d :type codes: uint8_t :param codes: output codes, size n * code_size :type centroids: float, optional :param centroids: centroids to be added to x, size n * d )rZ-AdditiveQuantizer_compute_codes_add_centroidsrr2rrBr9rrrcompute_codes_add_centroids s z-AdditiveQuantizer.compute_codes_add_centroidsr c Cst|||||||S)an pack a series of code to bit-compact format :type codes: int :param codes: codes to be packed, size n * code_size :type packed_codes: uint8_t :param packed_codes: output bit-compact codes :type ld_codes: int, optional :param ld_codes: leading dimension of codes :type norms: float, optional :param norms: norms of the vectors (size n). Will be computed if needed but not provided :type centroids: float, optional :param centroids: centroids to be added to x, size n * d )rZAdditiveQuantizer_pack_codes)rrBrZ packed_codesld_codesrr9rrr pack_codes- szAdditiveQuantizer.pack_codescCst||||Sz Decode a set of vectors :type codes: uint8_t :param codes: codes to decode, size n * code_size :type x: float :param x: output vectors, size n * d )rZAdditiveQuantizer_decoderrr2rBrrrr? s zAdditiveQuantizer.decodecCst|||||Sz Decode a set of vectors in non-packed format :type codes: int :param codes: codes to decode, size n * ld_codes :type x: float :param x: output vectors, size n * d )rZ!AdditiveQuantizer_decode_unpackedrrr2rBr rrrdecode_unpackedJ s z!AdditiveQuantizer.decode_unpackedz$ Also determines what's in the codesz" min/max for quantization of normscCst|||S)z. decoding function for a code in a 64-bit word)rZAdditiveQuantizer_decode_64bitrmrrr decode_64bitX szAdditiveQuantizer.decode_64bit?cCst||||||S)a Compute inner-product look-up tables. Used in the centroid search functions. :type xq: float :param xq: query vector, size (n, d) :type LUT: float :param LUT: look-up table, size (n, total_codebook_size) :type alpha: float, optional :param alpha: compute alpha * inner-product :type ld_lut: int, optional :param ld_lut: leading dimension of LUT )rZAdditiveQuantizer_compute_LUTrrBr LUTalphaZld_lutrrr compute_LUT\ szAdditiveQuantizer.compute_LUTcCst||||||S)z exact IP search)rZ-AdditiveQuantizer_knn_centroids_inner_product)rrBr rrrrrrknn_centroids_inner_productl sz-AdditiveQuantizer.knn_centroids_inner_productcCs t||S)z For L2 search we need the L2 norms of the centroids :type norms: float :param norms: output norms table, size total_codebook_size )rZ(AdditiveQuantizer_compute_centroid_normsrrrrrcompute_centroid_normsp sz(AdditiveQuantizer.compute_centroid_normsc Cst|||||||S)z( Exact L2 search, with precomputed norms)rZ"AdditiveQuantizer_knn_centroids_L2)rrBr rrrcentroid_normsrrrknn_centroids_L2y sz"AdditiveQuantizer.knn_centroids_L2)N)r NN)r )rr )fr r r,r-rrr?rrrZAdditiveQuantizer_M_getZAdditiveQuantizer_M_setrZAdditiveQuantizer_nbits_getZAdditiveQuantizer_nbits_setrZAdditiveQuantizer_codebooks_getZAdditiveQuantizer_codebooks_setZ codebooksZ&AdditiveQuantizer_codebook_offsets_getZ&AdditiveQuantizer_codebook_offsets_setZcodebook_offsetsZAdditiveQuantizer_tot_bits_getZAdditiveQuantizer_tot_bits_setZtot_bitsZAdditiveQuantizer_norm_bits_getZAdditiveQuantizer_norm_bits_setZ norm_bitsZ)AdditiveQuantizer_total_codebook_size_getZ)AdditiveQuantizer_total_codebook_size_setZtotal_codebook_sizeZAdditiveQuantizer_only_8bit_getZAdditiveQuantizer_only_8bit_setZ only_8bitZAdditiveQuantizer_verbose_getZAdditiveQuantizer_verbose_setrZ AdditiveQuantizer_is_trained_getZ AdditiveQuantizer_is_trained_setrZAdditiveQuantizer_norm_tabs_getZAdditiveQuantizer_norm_tabs_setZ norm_tabsZAdditiveQuantizer_qnorm_getZAdditiveQuantizer_qnorm_setZqnormrZ$AdditiveQuantizer_centroid_norms_getZ$AdditiveQuantizer_centroid_norms_setrZ-AdditiveQuantizer_codebook_cross_products_getZ-AdditiveQuantizer_codebook_cross_products_setZcodebook_cross_productsZ'AdditiveQuantizer_max_mem_distances_getZ'AdditiveQuantizer_max_mem_distances_setZmax_mem_distancesrrrZAdditiveQuantizer_ST_decompressZ ST_decompressZAdditiveQuantizer_ST_LUT_nonormZ ST_LUT_nonormZ"AdditiveQuantizer_ST_norm_from_LUTZST_norm_from_LUTZAdditiveQuantizer_ST_norm_floatZ ST_norm_floatZAdditiveQuantizer_ST_norm_qint8Z ST_norm_qint8ZAdditiveQuantizer_ST_norm_qint4Z ST_norm_qint4Z AdditiveQuantizer_ST_norm_cqint8ZST_norm_cqint8Z AdditiveQuantizer_ST_norm_cqint4ZST_norm_cqint4Z AdditiveQuantizer_ST_norm_lsq2x4ZST_norm_lsq2x4ZAdditiveQuantizer_ST_norm_rq2x4Z ST_norm_rq2x4rrrr r rrZ!AdditiveQuantizer_search_type_getZ!AdditiveQuantizer_search_type_set search_typeZAdditiveQuantizer_norm_min_getZAdditiveQuantizer_norm_min_setZnorm_minZAdditiveQuantizer_norm_max_getZAdditiveQuantizer_norm_max_setZnorm_maxrrrrrZdelete_AdditiveQuantizerrTrrrrr sb    rcGs tj|S)a Encode a residual by sampling from a centroid table. This is a single encoding step the residual quantizer. It allows low-level access to the encoding function, exposed mainly for unit tests. :type n: int :param n: number of vectors to handle :type residuals: float :param residuals: vectors to encode, size (n, beam_size, d) :type cent: float :param cent: centroids, size (K, d) :type beam_size: int :param beam_size: input beam size :type m: int :param m: size of the codes for the previous encoding steps :type codes: int :param codes: code array for the previous steps of the beam (n, beam_size, m) :type new_beam_size: int :param new_beam_size: output beam size (should be <= K * beam_size) :type new_codes: int :param new_codes: output codes, size (n, new_beam_size, m + 1) :type new_residuals: float :param new_residuals: output residuals, size (n, new_beam_size, d) :type new_distances: float :param new_distances: output distances, size (n, new_beam_size) :type assign_index: :py:class:`Index`, optional :param assign_index: if non-NULL, will be used to perform assignment )rbeam_search_encode_steprrrrr s rcGs tj|S)a Encode a set of vectors using their dot products with the codebooks :type K: int :param K: number of vectors in the codebook :type n: int :param n: nb of vectors to encode :type beam_size: int :param beam_size: input beam size :type codebook_cross_norms: float :param codebook_cross_norms: inner product of this codebook with the m previously encoded codebooks :type codebook_offsets: int :param codebook_offsets: offsets into codebook_cross_norms for each previous codebook :type query_cp: float :param query_cp: dot products of query vectors with ??? :type cent_norms_i: float :param cent_norms_i: norms of centroids )rbeam_search_encode_step_tabrrrrr  sr c@szeZdZeddddddZeZeejej Z eej ej Z eejejZeejejZeejejZddZejZdS) RefineBeamMemoryPoolcCs |jSr#r0r1rrrr3 r4zRefineBeamMemoryPool.cCs |j|Sr#r0r5rrrr3 r4r7r8cCst|tdSr#)rZRefineBeamMemoryPool_swiginitZnew_RefineBeamMemoryPoolr@rrrr? szRefineBeamMemoryPool.__init__N)r r r,rrrrrZ"RefineBeamMemoryPool_new_codes_getZ"RefineBeamMemoryPool_new_codes_set new_codesZ&RefineBeamMemoryPool_new_residuals_getZ&RefineBeamMemoryPool_new_residuals_set new_residualsZ"RefineBeamMemoryPool_residuals_getZ"RefineBeamMemoryPool_residuals_setrZRefineBeamMemoryPool_codes_getZRefineBeamMemoryPool_codes_setrZ"RefineBeamMemoryPool_distances_getZ"RefineBeamMemoryPool_distances_setrr?Zdelete_RefineBeamMemoryPoolrTrrrrr! sr!c Cst||||||||| Sr#)rrefine_beam_mp) rqrB beam_sizer2 out_beam_size out_codesZ out_residuals out_distancespoolrrrr$ sr$c@sleZdZeddddddZeZeejej Z eej ej Z eejejZeejejZddZejZdS) RefineBeamLUTMemoryPoolcCs |jSr#r0r1rrrr3 r4z RefineBeamLUTMemoryPool.cCs |j|Sr#r0r5rrrr3 r4r7r8cCst|tdSr#)rZ RefineBeamLUTMemoryPool_swiginitZnew_RefineBeamLUTMemoryPoolr@rrrr? sz RefineBeamLUTMemoryPool.__init__N)r r r,rrrrrZ%RefineBeamLUTMemoryPool_new_codes_getZ%RefineBeamLUTMemoryPool_new_codes_setr"Z)RefineBeamLUTMemoryPool_new_distances_getZ)RefineBeamLUTMemoryPool_new_distances_set new_distancesZ!RefineBeamLUTMemoryPool_codes_getZ!RefineBeamLUTMemoryPool_codes_setrZ%RefineBeamLUTMemoryPool_distances_getZ%RefineBeamLUTMemoryPool_distances_setrr?Zdelete_RefineBeamLUTMemoryPoolrTrrrrr+ sr+c Cst||||||||Sr#)rrefine_beam_LUT_mp)r%rB query_normsquery_cpr'r(r)r*rrrr- sr-c@szeZdZeddddddZeZeejej Z eej ej Z eejejZeejejZeejejZddZejZdS) &ComputeCodesAddCentroidsLUT0MemoryPoolcCs |jSr#r0r1rrrr3 r4z/ComputeCodesAddCentroidsLUT0MemoryPool.cCs |j|Sr#r0r5rrrr3 r4r7r8cCst|tdSr#)rZ/ComputeCodesAddCentroidsLUT0MemoryPool_swiginitZ*new_ComputeCodesAddCentroidsLUT0MemoryPoolr@rrrr? sz/ComputeCodesAddCentroidsLUT0MemoryPool.__init__N)r r r,rrrrrZ0ComputeCodesAddCentroidsLUT0MemoryPool_codes_getZ0ComputeCodesAddCentroidsLUT0MemoryPool_codes_setrZ0ComputeCodesAddCentroidsLUT0MemoryPool_norms_getZ0ComputeCodesAddCentroidsLUT0MemoryPool_norms_setrZ4ComputeCodesAddCentroidsLUT0MemoryPool_distances_getZ4ComputeCodesAddCentroidsLUT0MemoryPool_distances_setrZ4ComputeCodesAddCentroidsLUT0MemoryPool_residuals_getZ4ComputeCodesAddCentroidsLUT0MemoryPool_residuals_setrZ;ComputeCodesAddCentroidsLUT0MemoryPool_refine_beam_pool_getZ;ComputeCodesAddCentroidsLUT0MemoryPool_refine_beam_pool_setZrefine_beam_poolr?Z-delete_ComputeCodesAddCentroidsLUT0MemoryPoolrTrrrrr0 sr0cCst||||||Sr#)r#compute_codes_add_centroids_mp_lut0r%r2Z codes_outrBr9r*rrrr1 sr1c@seZdZeddddddZeZeejej Z eej ej Z eejejZeejejZeejejZeejejZddZejZdS) &ComputeCodesAddCentroidsLUT1MemoryPoolcCs |jSr#r0r1rrrr3 r4z/ComputeCodesAddCentroidsLUT1MemoryPool.cCs |j|Sr#r0r5rrrr3 r4r7r8cCst|tdSr#)rZ/ComputeCodesAddCentroidsLUT1MemoryPool_swiginitZ*new_ComputeCodesAddCentroidsLUT1MemoryPoolr@rrrr? sz/ComputeCodesAddCentroidsLUT1MemoryPool.__init__N)r r r,rrrrrZ0ComputeCodesAddCentroidsLUT1MemoryPool_codes_getZ0ComputeCodesAddCentroidsLUT1MemoryPool_codes_setrZ4ComputeCodesAddCentroidsLUT1MemoryPool_distances_getZ4ComputeCodesAddCentroidsLUT1MemoryPool_distances_setrZ6ComputeCodesAddCentroidsLUT1MemoryPool_query_norms_getZ6ComputeCodesAddCentroidsLUT1MemoryPool_query_norms_setr.Z3ComputeCodesAddCentroidsLUT1MemoryPool_query_cp_getZ3ComputeCodesAddCentroidsLUT1MemoryPool_query_cp_setr/Z4ComputeCodesAddCentroidsLUT1MemoryPool_residuals_getZ4ComputeCodesAddCentroidsLUT1MemoryPool_residuals_setrZ?ComputeCodesAddCentroidsLUT1MemoryPool_refine_beam_lut_pool_getZ?ComputeCodesAddCentroidsLUT1MemoryPool_refine_beam_lut_pool_setZrefine_beam_lut_poolr?Z-delete_ComputeCodesAddCentroidsLUT1MemoryPoolrTrrrrr3 sr3cCst||||||Sr#)r#compute_codes_add_centroids_mp_lut1r2rrrr4 sr4c@seZdZdZeddddddZeZeej ej ddZ ej Z ejZejZeejejddZejZejZeejejd dZeejejd dZeejej d dZ!eej"ej#d dZ$eej%ej&d dZ'ddZ(ddZ)d!ddZ*ddZ+d"ddZ,d#ddZ-d$ddZ.d%dd Z/ej0Z1dS)&ResidualQuantizera Residual quantizer with variable number of bits per sub-quantizer The residual centroids are stored in a big cumulative centroid table. The codes are represented either as a non-compact table of size (n, M) or as the compact output (n, code_size). cCs |jSr#r0r1rrrr3 r4zResidualQuantizer.cCs |j|Sr#r0r5rrrr3 r4r7r8z% Binary or of the Train_* flags belowz. number of iterations for codebook refinement.z- beam size used for training and for encodingz use LUT for beam searchza Currently used mode of approximate min-k computations. Default value is EXACT_TOPK. z clustering parametersz+ if non-NULL, use this index for assignmentcGst|tj|dSr#)rZResidualQuantizer_swiginitZnew_ResidualQuantizerrQrrrr?' szResidualQuantizer.__init__cCst|||S)z Train the residual quantizer)rZResidualQuantizer_trainrmrrrrn* szResidualQuantizer.trainrcCst|||S)z< Copy the M codebook levels from other, starting from skip_M)rZ!ResidualQuantizer_initialize_from)rr_Zskip_Mrrrinitialize_from. sz!ResidualQuantizer.initialize_fromcCst|||S)a Encode the vectors and compute codebook that minimizes the quantization error on these codes :type x: float :param x: training vectors, size n * d :type n: int :param n: nb of training vectors, n >= total_codebook_size :rtype: float :return: returns quantization error for the new codebook with old codes )rZ%ResidualQuantizer_retrain_AQ_codebookrmrrrretrain_AQ_codebook2 s z%ResidualQuantizer.retrain_AQ_codebookNcCst|||||Sr )rZ-ResidualQuantizer_compute_codes_add_centroidsr rrrr A s z-ResidualQuantizer.compute_codes_add_centroidsc Cst||||||||S)a lower-level encode function :type n: int :param n: number of vectors to handle :type residuals: float :param residuals: vectors to encode, size (n, beam_size, d) :type beam_size: int :param beam_size: input beam size :type new_beam_size: int :param new_beam_size: output beam size (should be <= K * beam_size) :type new_codes: int :param new_codes: output codes, size (n, new_beam_size, m + 1) :type new_residuals: float, optional :param new_residuals: output residuals, size (n, new_beam_size, d) :type new_distances: float, optional :param new_distances: output distances, size (n, new_beam_size) )rZResidualQuantizer_refine_beam)rrBr&r new_beam_sizer"r#r,rrr refine_beamN szResidualQuantizer.refine_beamc Cst|||||||Sr#)rZ!ResidualQuantizer_refine_beam_LUT)rrBr.r/r8r"r,rrrrefine_beam_LUTc sz!ResidualQuantizer.refine_beam_LUTr cCs t||S)z Beam search can consume a lot of memory. This function estimates the amount of mem used by refine_beam to adjust the batch size :type beam_size: int, optional :param beam_size: if != -1, override the beam size )rZ"ResidualQuantizer_memory_per_point)rr&rrrmemory_per_pointf sz"ResidualQuantizer.memory_per_point)r)N)NN)N)r )2r r r,r-rrrrrZ ResidualQuantizer_train_type_getZ ResidualQuantizer_train_type_setrZResidualQuantizer_Train_defaultrZ'ResidualQuantizer_Train_progressive_dimZTrain_progressive_dimZ'ResidualQuantizer_Train_refine_codebookZTrain_refine_codebookZ+ResidualQuantizer_niter_codebook_refine_getZ+ResidualQuantizer_niter_codebook_refine_setZniter_codebook_refineZ ResidualQuantizer_Train_top_beamZTrain_top_beamZ&ResidualQuantizer_Skip_codebook_tablesZSkip_codebook_tablesZ#ResidualQuantizer_max_beam_size_getZ#ResidualQuantizer_max_beam_size_setZ max_beam_sizeZ"ResidualQuantizer_use_beam_LUT_getZ"ResidualQuantizer_use_beam_LUT_setZ use_beam_LUTZ&ResidualQuantizer_approx_topk_mode_getZ&ResidualQuantizer_approx_topk_mode_setapprox_topk_modeZResidualQuantizer_cp_getZResidualQuantizer_cp_setrZ*ResidualQuantizer_assign_index_factory_getZ*ResidualQuantizer_assign_index_factory_setZassign_index_factoryr?rnr6r7r r9r:r;Zdelete_ResidualQuantizerrTrrrrr5 s0    r5c@sdeZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZeejejddZ eej!ej"ddZ#eej$ej%ddZ&eej'ej(Z)eej*ej+Z,ddZ-ej.Z/ddZ0d*ddZ1ddZ2ddZ3ddZ4ddZ5d d!Z6d"d#Z7d$d%Z8d&d'Z9d+d(d)Z:dS),LocalSearchQuantizeraK Implementation of LSQ/LSQ++ described in the following two papers: Revisiting additive quantization Julieta Martinez, et al. ECCV 2016 LSQ++: Lower running time and higher recall in multi-codebook quantization Julieta Martinez, et al. ECCV 2018 This implementation is mostly translated from the Julia implementations by Julieta Martinez: (https://github.com/una-dinosauria/local-search-quantization, https://github.com/una-dinosauria/Rayuela.jl) The trained codes are stored in `codebooks` which is called `centroids` in PQ and RQ. cCs |jSr#r0r1rrrr3 r4zLocalSearchQuantizer.cCs |j|Sr#r0r5rrrr3 r4r7r8z number of codes per codebookz! number of iterations in trainingz' iterations of local search in encodingz' iterations of local search in trainingz number of iterations in icmz temperature factorz regularization factorz" nb of vectors to encode at a timez seed for random generatorzo number of perturbation in each code if non-NULL, use this encoder to encode (owned by the object) cGst|tj|dSr#)rZLocalSearchQuantizer_swiginitZnew_LocalSearchQuantizerrQrrrr? szLocalSearchQuantizer.__init__cCst|||Sr#)rZLocalSearchQuantizer_trainrmrrrrn szLocalSearchQuantizer.trainNcCst|||||S)au Encode a set of vectors :type x: float :param x: vectors to encode, size n * d :type codes: uint8_t :param codes: output codes, size n * code_size :type n: int :param n: number of vectors :type centroids: float, optional :param centroids: centroids to be added to x, size n * d )rZ0LocalSearchQuantizer_compute_codes_add_centroidsr rrrr  s z0LocalSearchQuantizer.compute_codes_add_centroidscCst||||S)a Update codebooks given encodings :type x: float :param x: training vectors, size n * d :type codes: int :param codes: encoded training vectors, size n * M :type n: int :param n: number of vectors )rZ%LocalSearchQuantizer_update_codebooksrrrrupdate_codebooks s z%LocalSearchQuantizer.update_codebookscCst||||||S)a Encode vectors given codebooks using iterative conditional mode (icm). :type codes: int :param codes: output codes, size n * M :type x: float :param x: vectors to encode, size n * d :type n: int :param n: number of vectors :type ils_iters: int :param ils_iters: number of iterations of iterative local search )rZLocalSearchQuantizer_icm_encode)rrr2rB ils_itersgenrrr icm_encode s zLocalSearchQuantizer.icm_encodec Cst||||||||Sr#)rZ$LocalSearchQuantizer_icm_encode_impl)rrr2unariesr@rBr?rrrricm_encode_impl sz$LocalSearchQuantizer.icm_encode_implcCst||||||Sr#)rZ$LocalSearchQuantizer_icm_encode_step)rrrBbinariesrBZn_itersrrricm_encode_step sz$LocalSearchQuantizer.icm_encode_stepcCst||||S)z Add some perturbation to codes :type codes: int :param codes: codes to be perturbed, size n * M :type n: int :param n: number of vectors )rZ"LocalSearchQuantizer_perturb_codes)rrrBr@rrr perturb_codes s z"LocalSearchQuantizer.perturb_codescCst||||S)a Add some perturbation to codebooks :type T: float :param T: temperature of simulated annealing :type stddev: std::vector< float > :param stddev: standard derivations of each dimension in training data )rZ&LocalSearchQuantizer_perturb_codebooks)rTZstddevr@rrrperturb_codebooks s z&LocalSearchQuantizer.perturb_codebookscCs t||S)z Compute binary terms :type binaries: float :param binaries: binary terms, size M * M * K * K )rZ)LocalSearchQuantizer_compute_binary_terms)rrDrrrcompute_binary_terms sz)LocalSearchQuantizer.compute_binary_termscCst||||S)a Compute unary terms :type n: int :param n: number of vectors :type x: float :param x: vectors to encode, size n * d :type unaries: float :param unaries: unary terms, size n * M * K )rZ(LocalSearchQuantizer_compute_unary_terms)rr2rBrBrrrcompute_unary_terms s z(LocalSearchQuantizer.compute_unary_termscCst|||||S)a Helper function to compute reconstruction error :type codes: int :param codes: encoded codes, size n * M :type x: float :param x: vectors to encode, size n * d :type n: int :param n: number of vectors :type objs: float, optional :param objs: if it is not null, store reconstruction error of each vector into it, size n )rZLocalSearchQuantizer_evaluate)rrr2rBZobjsrrrevaluate szLocalSearchQuantizer.evaluate)N)N);r r r,r-rrrrrZLocalSearchQuantizer_K_getZLocalSearchQuantizer_K_setKZ$LocalSearchQuantizer_train_iters_getZ$LocalSearchQuantizer_train_iters_setZ train_itersZ)LocalSearchQuantizer_encode_ils_iters_getZ)LocalSearchQuantizer_encode_ils_iters_setZencode_ils_itersZ(LocalSearchQuantizer_train_ils_iters_getZ(LocalSearchQuantizer_train_ils_iters_setZtrain_ils_itersZ"LocalSearchQuantizer_icm_iters_getZ"LocalSearchQuantizer_icm_iters_setZ icm_itersZLocalSearchQuantizer_p_getZLocalSearchQuantizer_p_setpZLocalSearchQuantizer_lambd_getZLocalSearchQuantizer_lambd_setlambdZ#LocalSearchQuantizer_chunk_size_getZ#LocalSearchQuantizer_chunk_size_set chunk_sizeZ$LocalSearchQuantizer_random_seed_getZ$LocalSearchQuantizer_random_seed_set random_seedZLocalSearchQuantizer_nperts_getZLocalSearchQuantizer_nperts_setZnpertsZ,LocalSearchQuantizer_icm_encoder_factory_getZ,LocalSearchQuantizer_icm_encoder_factory_setZicm_encoder_factoryZ5LocalSearchQuantizer_update_codebooks_with_double_getZ5LocalSearchQuantizer_update_codebooks_with_double_setZupdate_codebooks_with_doubler?Zdelete_LocalSearchQuantizerrTrnr r>rArCrErFrHrIrJrKrrrrr=s s8      r=c@sneZdZeddddddZeZeejej Z eej ej Z eejejZddZejZdd Zd d Zd S) IcmEncodercCs |jSr#r0r1rrrr3r4zIcmEncoder.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|t|dSr#)rZIcmEncoder_swiginitZnew_IcmEncoderrlsqrrrr?szIcmEncoder.__init__cCs t|Sr#)rZIcmEncoder_set_binary_termr@rrrset_binary_termszIcmEncoder.set_binary_termcCst||||||S)a Encode vectors given codebooks :type codes: int :param codes: output codes, size n * M :type x: float :param x: vectors to encode, size n * d :type gen: std::mt19937 :param gen: random generator :type n: int :param n: number of vectors :type ils_iters: int :param ils_iters: number of iterations of iterative local search )rZIcmEncoder_encode)rrr2r@rBr?rrrrszIcmEncoder.encodeN)r r r,rrrrrZIcmEncoder_binaries_getZIcmEncoder_binaries_setrDZIcmEncoder_verbose_getZIcmEncoder_verbose_setrZIcmEncoder_lsq_getZIcmEncoder_lsq_setrSr?Zdelete_IcmEncoderrTrTrrrrrrQsrQc@s<eZdZeddddddZeZddZej Z dd Z d S) IcmEncoderFactorycCs |jSr#r0r1rrrr30r4zIcmEncoderFactory.cCs |j|Sr#r0r5rrrr30r4r7r8cCs t||Sr#)rZIcmEncoderFactory_getrRrrrget3szIcmEncoderFactory.getcCst|tdSr#)rZIcmEncoderFactory_swiginitZnew_IcmEncoderFactoryr@rrrr?7szIcmEncoderFactory.__init__N) r r r,rrrrrVrZdelete_IcmEncoderFactoryrTr?rrrrrU/s rUc@s^eZdZdZeddddddZeZeej ej Z ddZ d d Z d d Zd dZejZdS)LSQTimerz] A helper struct to count consuming time during training. It is NOT thread-safe. cCs |jSr#r0r1rrrr3Br4zLSQTimer.cCs |j|Sr#r0r5rrrr3Br4r7r8cCst|tdSr#)rZLSQTimer_swiginitZ new_LSQTimerr@rrrr?FszLSQTimer.__init__cCs t||Sr#)rZ LSQTimer_getrrrrrrVIsz LSQTimer.getcCst|||Sr#)rZ LSQTimer_add)rrdeltarrrroLsz LSQTimer.addcCs t|Sr#)rZLSQTimer_resetr@rrrr|OszLSQTimer.resetN)r r r,r-rrrrrZLSQTimer_t_getZLSQTimer_t_settr?rVror|Zdelete_LSQTimerrTrrrrrW<srWc@steZdZeddddddZeZeejej Z eej ej Z eejejZeejejZddZdd ZejZd S) LSQTimerScopecCs |jSr#r0r1rrrr3Vr4zLSQTimerScope.cCs |j|Sr#r0r5rrrr3Vr4r7r8cCst|t||dSr#)rZLSQTimerScope_swiginitZnew_LSQTimerScope)rtimerrrrrr?]szLSQTimerScope.__init__cCs t|Sr#)rZLSQTimerScope_finishr@rrrfinish`szLSQTimerScope.finishN)r r r,rrrrrZLSQTimerScope_t0_getZLSQTimerScope_t0_sett0ZLSQTimerScope_timer_getZLSQTimerScope_timer_setr\ZLSQTimerScope_name_getZLSQTimerScope_name_setrZLSQTimerScope_finished_getZLSQTimerScope_finished_setfinishedr?r]Zdelete_LSQTimerScoperTrrrrr[Usr[c@seZdZdZeddddddZeZeej ej ddZ eej ej Zdd ZejZd d Zd d ZddZdddZdddZdddZddZd ddZdS)!ProductAdditiveQuantizera Product Additive Quantizers The product additive quantizer is a variant of AQ and PQ. It first splits the vector space into multiple orthogonal sub-spaces just like PQ does. And then it quantizes each sub-space by an independent additive quantizer. cCs |jSr#r0r1rrrr3pr4z!ProductAdditiveQuantizer.cCs |j|Sr#r0r5rrrr3pr4r7r8z- number of sub-vectors we split a vector intocGst|tj|dSr#)rZ!ProductAdditiveQuantizer_swiginitZnew_ProductAdditiveQuantizerrQrrrr?usz!ProductAdditiveQuantizer.__init__cCst||||Sr#)rZProductAdditiveQuantizer_init)rrZaqsrrrrinityszProductAdditiveQuantizer.initcCs t||S)z% Train the product additive quantizer)rZ%ProductAdditiveQuantizer_subquantizer)rrrrr subquantizer|sz%ProductAdditiveQuantizer.subquantizercCst|||Sr#)rZProductAdditiveQuantizer_trainrmrrrrnszProductAdditiveQuantizer.trainNcCst|||||Sr )rZ4ProductAdditiveQuantizer_compute_codes_add_centroidsr rrrr s z4ProductAdditiveQuantizer.compute_codes_add_centroidscCst|||||Sr#)rZ/ProductAdditiveQuantizer_compute_unpacked_codesr rrrcompute_unpacked_codessz/ProductAdditiveQuantizer.compute_unpacked_codesr cCst|||||Sr)rZ(ProductAdditiveQuantizer_decode_unpackedrrrrrs z(ProductAdditiveQuantizer.decode_unpackedcCst||||Sr)rZProductAdditiveQuantizer_decoderrrrrs zProductAdditiveQuantizer.decodercCst||||||S)a Compute inner-product look-up tables. Used in the search functions. :type xq: float :param xq: query vector, size (n, d) :type LUT: float :param LUT: look-up table, size (n, total_codebook_size) :type alpha: float, optional :param alpha: compute alpha * inner-product :type ld_lut: int, optional :param ld_lut: leading dimension of LUT )rZ$ProductAdditiveQuantizer_compute_LUTrrrrrs z$ProductAdditiveQuantizer.compute_LUT)N)N)r )rr )r r r,r-rrrrrZ$ProductAdditiveQuantizer_nsplits_getZ$ProductAdditiveQuantizer_nsplits_setZnsplitsZ'ProductAdditiveQuantizer_quantizers_getZ'ProductAdditiveQuantizer_quantizers_setZ quantizersr?Zdelete_ProductAdditiveQuantizerrTrarbrnr rcrrrrrrrr`fs    r`c@s8eZdZdZeddddddZeZddZe j Z d S) ProductLocalSearchQuantizerz Product Local Search QuantizercCs |jSr#r0r1rrrr3r4z$ProductLocalSearchQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZ$ProductLocalSearchQuantizer_swiginitZnew_ProductLocalSearchQuantizerrQrrrr?sz$ProductLocalSearchQuantizer.__init__N) r r r,r-rrrrr?rZ"delete_ProductLocalSearchQuantizerrTrrrrrds rdc@s8eZdZdZeddddddZeZddZe j Z d S) ProductResidualQuantizerz Product Residual QuantizercCs |jSr#r0r1rrrr3r4z!ProductResidualQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZ!ProductResidualQuantizer_swiginitZnew_ProductResidualQuantizerrQrrrr?sz!ProductResidualQuantizer.__init__N) r r r,r-rrrrr?rZdelete_ProductResidualQuantizerrTrrrrres rec@seZdZdZeddddddZddZeZee j e j Z ee j e jZee je jZd d Zd d Zd dZddZe jZdS) CodePackera, Packing consists in combining a fixed number of codes of constant size (code_size) into a block of data where they may (or may not) be interleaved for efficient consumption by distance computation kernels. This exists for the "fast_scan" indexes on CPU and for some GPU kernels. cCs |jSr#r0r1rrrr3r4zCodePacker.cCs |j|Sr#r0r5rrrr3r4r7r8cOs tddSr:r;r<rrrr?szCodePacker.__init__cCst||||Sr#)rZCodePacker_pack_1r flat_coderblockrrrpack_1szCodePacker.pack_1cCst||||Sr#)rZCodePacker_unpack_1rrirrhrrrunpack_1szCodePacker.unpack_1cCst|||Sr#)rZCodePacker_pack_allr flat_codesrirrrpack_allszCodePacker.pack_allcCst|||Sr#)rZCodePacker_unpack_allrrirnrrr unpack_allszCodePacker.unpack_allN)r r r,r-rrr?rrrZCodePacker_code_size_getZCodePacker_code_size_setrZCodePacker_nvec_getZCodePacker_nvec_setZnvecZCodePacker_block_size_getZCodePacker_block_size_set block_sizerjrlrorqZdelete_CodePackerrTrrrrrfsrfc@sXeZdZdZeddddddZeZddZd d Z d d Z d dZ ddZ e jZdS)CodePackerFlatz6 Trivial code packer where codes are stored one by onecCs |jSr#r0r1rrrr3r4zCodePackerFlat.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|t|dSr#)rZCodePackerFlat_swiginitZnew_CodePackerFlat)rrrrrr?szCodePackerFlat.__init__cCst||||Sr#)rZCodePackerFlat_pack_1rgrrrrjszCodePackerFlat.pack_1cCst||||Sr#)rZCodePackerFlat_unpack_1rkrrrrlszCodePackerFlat.unpack_1cCst|||Sr#)rZCodePackerFlat_pack_allrmrrrroszCodePackerFlat.pack_allcCst|||Sr#)rZCodePackerFlat_unpack_allrprrrrqszCodePackerFlat.unpack_allN)r r r,r-rrrrr?rjrlrorqrZdelete_CodePackerFlatrTrrrrrssrsc@seZdZdZeddddddZddZeZee j e j Z ee j e jd dZee je jd dZd d Zd dZddZddZddZe jZdS)VectorTransformz/ Any transformation applied on a set of vectorscCs |jSr#r0r1rrrr3 r4zVectorTransform.cCs |j|Sr#r0r5rrrr3 r4r7r8cOs tddSr:r;r<rrrr?szVectorTransform.__init__zinput dimensionzb set if the VectorTransform does not require training, or if training is done already cCst|||S)z Perform training on a representative set of vectors. Does nothing by default. :type n: int :param n: nb of training vectors :type x: float :param x: training vecors, size n * d )rZVectorTransform_trainrmrrrrns zVectorTransform.traincCst|||S)a+ apply the transformation and return the result in an allocated pointer :type n: int :param n: number of vectors to transform :type x: float :param x: input vectors, size n * d_in :rtype: float :return: output vectors, size n * d_out )rZVectorTransform_applyrmrrrapply%s zVectorTransform.applycCst||||S)a, apply the transformation and return the result in a provided matrix :type n: int :param n: number of vectors to transform :type x: float :param x: input vectors, size n * d_in :type xt: float :param xt: output vectors, size n * d_out )rZVectorTransform_apply_noallocrrBr2xtrrr apply_noalloc1s zVectorTransform.apply_noalloccCst||||S)zi reverse transformation. May not be implemented or may return approximate result )rZ!VectorTransform_reverse_transformrrBrwr2rrrreverse_transform=sz!VectorTransform.reverse_transformcCs t||Sr#)rZVectorTransform_check_identicalr^rrrcheck_identicalDszVectorTransform.check_identicalN)r r r,r-rrr?rrrZVectorTransform_d_in_getZVectorTransform_d_in_setd_inZVectorTransform_d_out_getZVectorTransform_d_out_setd_outZVectorTransform_is_trained_getZVectorTransform_is_trained_setrrnrurxrzr{Zdelete_VectorTransformrTrrrrrt s   rtc@seZdZdZeddddddZeZeej ej Z eej ej ddZeejejddZeejejd dZdd d ZddZddZddZddZeejejZddZddZejZ dS)LinearTransformz\ Generic linear transformation, with bias term applied on output y = A * x + b cCs |jSr#r0r1rrrr3Pr4zLinearTransform.cCs |j|Sr#r0r5rrrr3Pr4r7r8zh whether to use the bias term check if matrix A is orthonormal (enables reverse_transform) z) Transformation matrix, size d_out * d_inz bias vector, size d_outrFcCst|t|||dS)z1 both d_in > d_out and d_out < d_in are supportedN)rZLinearTransform_swiginitZnew_LinearTransform)rr|r} have_biasrrrr?ZszLinearTransform.__init__cCst||||S)z+ same as apply, but result is pre-allocated)rZLinearTransform_apply_noallocrvrrrrx^szLinearTransform.apply_noalloccCst||||S)zc compute x = A^T * (x - b) is reverse transform if A has orthonormal lines )rZ#LinearTransform_transform_transpose)rrBrr2rrrtransform_transposebsz#LinearTransform.transform_transposecCst||||S)z works only if is_orthonormal)rZ!LinearTransform_reverse_transformryrrrrzisz!LinearTransform.reverse_transformcCs t|S)z/ compute A^T * A to set the is_orthonormal flag)rZ"LinearTransform_set_is_orthonormalr@rrrset_is_orthonormalmsz"LinearTransform.set_is_orthonormalcCst|||||Sr#)rZ LinearTransform_print_if_verbose)rrmatrBrrrrprint_if_verbosersz LinearTransform.print_if_verbosecCs t||Sr#)rZLinearTransform_check_identicalr^rrrr{uszLinearTransform.check_identicalN)rrF)!r r r,r-rrrrrZLinearTransform_have_bias_getZLinearTransform_have_bias_setrZ"LinearTransform_is_orthonormal_getZ"LinearTransform_is_orthonormal_setZis_orthonormalZLinearTransform_A_getZLinearTransform_A_setAZLinearTransform_b_getZLinearTransform_b_setr~r?rxrrzrZLinearTransform_verbose_getZLinearTransform_verbose_setrrr{Zdelete_LinearTransformrTrrrrr~Js  r~c@sHeZdZdZeddddddZeZddZd d Z d d Z e j Z d S)RandomRotationMatrixz! Randomly rotate a set of vectorscCs |jSr#r0r1rrrr3~r4zRandomRotationMatrix.cCs |j|Sr#r0r5rrrr3~r4r7r8cCs t||S)z, must be called before the transform is used)rZRandomRotationMatrix_initrGrrrraszRandomRotationMatrix.initcCst|||Sr#)rZRandomRotationMatrix_trainrmrrrrnszRandomRotationMatrix.traincGst|tj|dSr#)rZRandomRotationMatrix_swiginitZnew_RandomRotationMatrixrQrrrr?szRandomRotationMatrix.__init__N)r r r,r-rrrrrarnr?rZdelete_RandomRotationMatrixrTrrrrr{src@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZeejejddZ dddZ!ddZ"ddZ#ddZ$ej%Z&dS) PCAMatrixzx Applies a principal component analysis on a set of vectors, with optionally whitening and random rotation. cCs |jSr#r0r1rrrr3r4zPCAMatrix.cCs |j|Sr#r0r5rrrr3r4r7r8z after transformation the components are multiplied by eigenvalues^eigen_power =0: no whitening =-0.5: full whitening zA value added to eigenvalues to avoid division by 0 when whiteningz random rotation after PCAz/ ratio between # training vectors and dimensionz8 try to distribute output eigenvectors in this many binsz Mean, size d_inz= eigenvalues of covariance matrix (= squared singular values)z PCA matrix, size d_in * d_inrFc Cst|t||||dSr#)rZPCAMatrix_swiginitZ new_PCAMatrix)rr|r} eigen_powerrandom_rotationrrrr?szPCAMatrix.__init__cCst|||S)zo train on n vectors. If n < d_in then the eigenvector matrix will be completed with 0s )rZPCAMatrix_trainrmrrrrnszPCAMatrix.traincCs t||S)z copy pre-trained PCA matrix)rZPCAMatrix_copy_fromr^rrr copy_fromszPCAMatrix.copy_fromcCs t|S)z7 called after mean, PCAMat and eigenvalues are computed)rZPCAMatrix_prepare_Abr@rrr prepare_AbszPCAMatrix.prepare_AbN)rrrF)'r r r,r-rrrrrZPCAMatrix_eigen_power_getZPCAMatrix_eigen_power_setrZPCAMatrix_epsilon_getZPCAMatrix_epsilon_setepsilonZPCAMatrix_random_rotation_getZPCAMatrix_random_rotation_setrZPCAMatrix_max_points_per_d_getZPCAMatrix_max_points_per_d_setZmax_points_per_dZPCAMatrix_balanced_bins_getZPCAMatrix_balanced_bins_setZ balanced_binsZPCAMatrix_mean_getZPCAMatrix_mean_setmeanZPCAMatrix_eigenvalues_getZPCAMatrix_eigenvalues_setZ eigenvaluesZPCAMatrix_PCAMat_getZPCAMatrix_PCAMat_setZPCAMatr?rnrrZdelete_PCAMatrixrTrrrrrs  rc@sleZdZdZeddddddZeZeej ej Z eej ej ZeejejZd dd Zd d ZejZd S) ITQMatrixz ITQ implementation from Iterative quantization: A procrustean approach to learning binary codes for large-scale image retrieval, Yunchao Gong, Svetlana Lazebnik, Albert Gordo, Florent Perronnin, PAMI'12. cCs |jSr#r0r1rrrr3r4zITQMatrix.cCs |j|Sr#r0r5rrrr3r4r7r8rcCst|t|dSr#)rZITQMatrix_swiginitZ new_ITQMatrixrrrrr?szITQMatrix.__init__cCst|||Sr#)rZITQMatrix_trainrmrrrrnszITQMatrix.trainN)r)r r r,r-rrrrrZITQMatrix_max_iter_getZITQMatrix_max_iter_setZmax_iterZITQMatrix_seed_getZITQMatrix_seed_setrZITQMatrix_init_rotation_getZITQMatrix_init_rotation_setZ init_rotationr?rnZdelete_ITQMatrixrTrrrrrs  rc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejddZeejejZdd d Zd d ZddZddZejZdS) ITQTransformzH The full ITQ transform, including normalizations and PCA transformationcCs |jSr#r0r1rrrr3r4zITQTransform.cCs |j|Sr#r0r5rrrr3r4r7r8z" max training points per dimensionrFcCst|t|||dSr#)rZITQTransform_swiginitZnew_ITQTransform)rr|r}do_pcarrrr?szITQTransform.__init__cCst|||Sr#)rZITQTransform_trainrmrrrrnszITQTransform.traincCst||||Sr#)rZITQTransform_apply_noallocrvrrrrxszITQTransform.apply_noalloccCs t||Sr#)rZITQTransform_check_identicalr^rrrr{szITQTransform.check_identicalN)rrF)r r r,r-rrrrrZITQTransform_mean_getZITQTransform_mean_setrZITQTransform_do_pca_getZITQTransform_do_pca_setrZITQTransform_itq_getZITQTransform_itq_setZitqZ"ITQTransform_max_train_per_dim_getZ"ITQTransform_max_train_per_dim_setZmax_train_per_dimZITQTransform_pca_then_itq_getZITQTransform_pca_then_itq_setZ pca_then_itqr?rnrxr{Zdelete_ITQTransformrTrrrrrs rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejZeejejd dZdddZddZej Z!dS) OPQMatrixa\ Applies a rotation to align the dimensions with a PQ to minimize the reconstruction error. Can be used before an IndexPQ or an IndexIVFPQ. The method is the non-parametric version described in: "Optimized Product Quantization for Approximate Nearest Neighbor Search" Tiezheng Ge, Kaiming He, Qifa Ke, Jian Sun, CVPR'13 cCs |jSr#r0r1rrrr3r4zOPQMatrix.cCs |j|Sr#r0r5rrrr3r4r7r8z nb of subquantizersz$ Number of outer training iterationsz) Number of training iterations for the PQz$ same, for the first outer iterationz0 if there are too many training points, resamplezk if non-NULL, use this product quantizer for training should be constructed with (d_out, M, _) rrr cCst|t|||dS)z. if d2 != -1, output vectors of this dimensionN)rZOPQMatrix_swiginitZ new_OPQMatrix)rrrZd2rrrr?szOPQMatrix.__init__cCst|||Sr#)rZOPQMatrix_trainrmrrrrn szOPQMatrix.trainN)rrr )"r r r,r-rrrrrZOPQMatrix_M_getZOPQMatrix_M_setrZOPQMatrix_niter_getZOPQMatrix_niter_setrZOPQMatrix_niter_pq_getZOPQMatrix_niter_pq_setZniter_pqZOPQMatrix_niter_pq_0_getZOPQMatrix_niter_pq_0_setZ niter_pq_0ZOPQMatrix_max_train_points_getZOPQMatrix_max_train_points_setmax_train_pointsZOPQMatrix_verbose_getZOPQMatrix_verbose_setrZOPQMatrix_pq_getZOPQMatrix_pq_setpqr?rnZdelete_OPQMatrixrTrrrrrs  rc@sbeZdZdZeddddddZeZeej ej ddZ dd Z d d Z d d ZddZejZdS)RemapDimensionsTransformz remap dimensions for intput vectors, possibly inserting 0s strictly speaking this is also a linear transform but we don't want to compute it with matrix multiplies cCs |jSr#r0r1rrrr3r4z!RemapDimensionsTransform.cCs |j|Sr#r0r5rrrr3r4r7r8zR map from output dimension to input, size d_out -1 -> set output to 0 cCst||||Sr#)rZ&RemapDimensionsTransform_apply_noallocrvrrrrxsz&RemapDimensionsTransform.apply_noalloccCst||||S)zA reverse transform correct only when the mapping is a permutation)rZ*RemapDimensionsTransform_reverse_transformryrrrrz sz*RemapDimensionsTransform.reverse_transformcGst|tj|dSr#)rZ!RemapDimensionsTransform_swiginitZnew_RemapDimensionsTransformrQrrrr?$sz!RemapDimensionsTransform.__init__cCs t||Sr#)rZ(RemapDimensionsTransform_check_identicalr^rrrr{'sz(RemapDimensionsTransform.check_identicalN)r r r,r-rrrrrZ RemapDimensionsTransform_map_getZ RemapDimensionsTransform_map_setmaprxrzr?r{Zdelete_RemapDimensionsTransformrTrrrrrsrc@s^eZdZdZeddddddZeZeej ej Z ddZ d d Z d d Zd dZejZdS)NormalizationTransformz per-vector normalizationcCs |jSr#r0r1rrrr30r4zNormalizationTransform.cCs |j|Sr#r0r5rrrr30r4r7r8cGst|tj|dSr#)rZNormalizationTransform_swiginitZnew_NormalizationTransformrQrrrr?4szNormalizationTransform.__init__cCst||||Sr#)rZ$NormalizationTransform_apply_noallocrvrrrrx7sz$NormalizationTransform.apply_noalloccCst||||S)z0 Identity transform since norm is not revertible)rZ(NormalizationTransform_reverse_transformryrrrrz:sz(NormalizationTransform.reverse_transformcCs t||Sr#)rZ&NormalizationTransform_check_identicalr^rrrr{>sz&NormalizationTransform.check_identicalN)r r r,r-rrrrrZNormalizationTransform_norm_getZNormalizationTransform_norm_setrr?rxrzr{Zdelete_NormalizationTransformrTrrrrr-src@sleZdZdZeddddddZeZeej ej ddZ dd d Z d d Z d dZddZddZejZdS)CenteringTransformz6 Subtract the mean of each component from the vectors.cCs |jSr#r0r1rrrr3Gr4zCenteringTransform.cCs |j|Sr#r0r5rrrr3Gr4r7r8z Mean, size d_in = d_outrcCst|t|dSr#)rZCenteringTransform_swiginitZnew_CenteringTransformrrrrr?KszCenteringTransform.__init__cCst|||S)z train on n vectors.)rZCenteringTransform_trainrmrrrrnNszCenteringTransform.traincCst||||S)z subtract the mean)rZ CenteringTransform_apply_noallocrvrrrrxRsz CenteringTransform.apply_noalloccCst||||S)z add the mean)rZ$CenteringTransform_reverse_transformryrrrrzVsz$CenteringTransform.reverse_transformcCs t||Sr#)rZ"CenteringTransform_check_identicalr^rrrr{Zsz"CenteringTransform.check_identicalN)r)r r r,r-rrrrrZCenteringTransform_mean_getZCenteringTransform_mean_setrr?rnrxrzr{Zdelete_CenteringTransformrTrrrrrDs rc@sBeZdZeddddddZeZeejej Z ddZ ej Z dS) SearchParametersPreTransformcCs |jSr#r0r1rrrr3ar4z%SearchParametersPreTransform.cCs |j|Sr#r0r5rrrr3ar4r7r8cCst|tdSr#)rZ%SearchParametersPreTransform_swiginitZ new_SearchParametersPreTransformr@rrrr?esz%SearchParametersPreTransform.__init__N)r r r,rrrrrZ-SearchParametersPreTransform_index_params_getZ-SearchParametersPreTransform_index_params_setZ index_paramsr?Z#delete_SearchParametersPreTransformrTrrrrr`s rc@s eZdZdZeddddddZeZeej ej Z eej ej ddZeejejddZd d Zd d Zd dZddZddZddZddZd3ddZd4ddZddZddZd5d d!Zd"d#Zd$d%Zd&d'Z d(d)Z!d*d+Z"d,d-Z#d6d/d0Z$d1d2Z%ej&Z'dS)7IndexPreTransformzo Index that applies a LinearTransform transform on vectors before handing them over to a sub-index cCs |jSr#r0r1rrrr3qr4zIndexPreTransform.cCs |j|Sr#r0r5rrrr3qr4r7r8zchain of transforms the sub-indexcGst|tj|dS)z *Overload 1:* whether pointers are deleted in destructor | *Overload 2:* ltrans is the last transform before the index N)rZIndexPreTransform_swiginitZnew_IndexPreTransformrQrrrr?ws zIndexPreTransform.__init__cCs t||Sr#)rZ#IndexPreTransform_prepend_transform)rZltransrrrprepend_transformsz#IndexPreTransform.prepend_transformcCst|||Sr#)rZIndexPreTransform_trainrmrrrrnszIndexPreTransform.traincCst|||Sr#)rZIndexPreTransform_addrmrrrroszIndexPreTransform.addcCst||||Sr#)rZIndexPreTransform_add_with_idsrprrrrrszIndexPreTransform.add_with_idscCs t|Sr#)rZIndexPreTransform_resetr@rrrr|szIndexPreTransform.resetcCs t||S)z: removes IDs from the index. Not supported by all indexes.)rZIndexPreTransform_remove_idsrzrrrr{szIndexPreTransform.remove_idsNc Cst|||||||Sr#)rZIndexPreTransform_searchrsrrrruszIndexPreTransform.searchcCst||||||Sr#)rZIndexPreTransform_range_searchrvrrrrwszIndexPreTransform.range_searchcCst|||Sr#)rZIndexPreTransform_reconstructr|rrrrszIndexPreTransform.reconstructcCst||||Sr#)rZIndexPreTransform_reconstruct_nrrrrrszIndexPreTransform.reconstruct_nc Cst||||||||Sr#)rZ(IndexPreTransform_search_and_reconstructrrrrrsz(IndexPreTransform.search_and_reconstructcCst|||S)z apply the transforms in the chain. The returned float * may be equal to x, otherwise it should be deallocated. )rZIndexPreTransform_apply_chainrmrrr apply_chainszIndexPreTransform.apply_chaincCst||||S)z Reverse the transforms in the chain. May not be implemented for all transforms in the chain or may return approximate results. )rZIndexPreTransform_reverse_chainryrrr reverse_chainszIndexPreTransform.reverse_chaincCs t|Sr#)rZ'IndexPreTransform_get_distance_computerr@rrrrsz'IndexPreTransform.get_distance_computercCs t|Sr#)rZIndexPreTransform_sa_code_sizer@rrrrszIndexPreTransform.sa_code_sizecCst||||Sr#)rZIndexPreTransform_sa_encoderrrrrszIndexPreTransform.sa_encodecCst||||Sr#)rZIndexPreTransform_sa_decoderrrrrszIndexPreTransform.sa_decodercCst|||Sr#)rZIndexPreTransform_merge_fromrrrrrszIndexPreTransform.merge_fromcCs t||Sr#)rZ,IndexPreTransform_check_compatible_for_mergerrrrrsz,IndexPreTransform.check_compatible_for_merge)N)N)N)r)(r r r,r-rrrrrZIndexPreTransform_chain_getZIndexPreTransform_chain_setchainZIndexPreTransform_index_getZIndexPreTransform_index_setrZ IndexPreTransform_own_fields_getZ IndexPreTransform_own_fields_set own_fieldsr?rrnrorrr|r{rurwrrrrrrrrrrrZdelete_IndexPreTransformrTrrrrrks6     rc@sPeZdZeddddddZeZeejej Z eej ej Z ejZddZdS) IndexRefineSearchParameterscCs |jSr#r0r1rrrr3r4z$IndexRefineSearchParameters.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZ$IndexRefineSearchParameters_swiginitZnew_IndexRefineSearchParametersr@rrrr?sz$IndexRefineSearchParameters.__init__N)r r r,rrrrrZ(IndexRefineSearchParameters_k_factor_getZ(IndexRefineSearchParameters_k_factor_setk_factorZ1IndexRefineSearchParameters_base_index_params_getZ1IndexRefineSearchParameters_base_index_params_setZbase_index_paramsZ"delete_IndexRefineSearchParametersrTr?rrrrrs rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZd d ZddZddZddZd!ddZd"ddZddZddZddZ dd Z!ej"Z#dS)# IndexRefinez Index that queries in a base_index (a fast one) and refines the results with an exact search, hopefully improving the results. cCs |jSr#r0r1rrrr3r4zIndexRefine.cCs |j|Sr#r0r5rrrr3r4r7r8z? faster index to pre-select the vectors that should be filteredz refinement indexz& should the base index be deallocated?z same with the refinement indexzk factor between k requested in search and the k requested from the base_index (should be >= 1) cGst|tj|dSr#)rZIndexRefine_swiginitZnew_IndexRefinerQrrrr?szIndexRefine.__init__cCst|||Sr#)rZIndexRefine_trainrmrrrrnszIndexRefine.traincCst|||Sr#)rZIndexRefine_addrmrrrroszIndexRefine.addcCs t|Sr#)rZIndexRefine_resetr@rrrr|szIndexRefine.resetNc Cst|||||||Sr#)rZIndexRefine_searchrsrrrruszIndexRefine.searchcCst||||||Sr#)rZIndexRefine_range_searchrvrrrrwszIndexRefine.range_searchcCst|||Sr#)rZIndexRefine_reconstructr|rrrrszIndexRefine.reconstructcCs t|Sr#)rZIndexRefine_sa_code_sizer@rrrrszIndexRefine.sa_code_sizecCst||||Sr#)rZIndexRefine_sa_encoderrrrrszIndexRefine.sa_encodecCst||||S)zk The sa_decode decodes from the index_refine, which is assumed to be more accurate )rZIndexRefine_sa_decoderrrrrszIndexRefine.sa_decode)N)N)$r r r,r-rrrrrZIndexRefine_base_index_getZIndexRefine_base_index_setZ base_indexZIndexRefine_refine_index_getZIndexRefine_refine_index_setZ refine_indexZIndexRefine_own_fields_getZIndexRefine_own_fields_setrZ IndexRefine_own_refine_index_getZ IndexRefine_own_refine_index_setZown_refine_indexZIndexRefine_k_factor_getZIndexRefine_k_factor_setrr?rnror|rurwrrrrZdelete_IndexRefinerTrrrrrs&  rc@sBeZdZdZeddddddZeZddZd d d Z e j Z d S) IndexRefineFlatz Version where the refinement index is an IndexFlat. It has one additional constructor that takes a table of elements to add to the flat refinement index cCs |jSr#r0r1rrrr3r4zIndexRefineFlat.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexRefineFlat_swiginitZnew_IndexRefineFlatrQrrrr?szIndexRefineFlat.__init__Nc Cst|||||||Sr#)rZIndexRefineFlat_searchrsrrrruszIndexRefineFlat.search)N) r r r,r-rrrrr?rurZdelete_IndexRefineFlatrTrrrrr s  rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZd d ZddZdddZddZejZddZddZddZ dS)IndexLSHz? The sign of each vector component is put in a binary signaturecCs |jSr#r0r1rrrr3 r4zIndexLSH.cCs |j|Sr#r0r5rrrr3 r4r7r8z nb of bits per vectorz, whether to apply a random rotation to inputz% whether we train thresholds or use 0z optional random rotationz thresholds to compare withcCst|||S)aP Preprocesses and resizes the input to the size required to binarize the data :type x: float :param x: input vectors, size n * d :rtype: float :return: output vectors, size n * bits. May be the same pointer as x, otherwise it should be deleted by the caller )rZIndexLSH_apply_preprocessrmrrrapply_preprocess(s zIndexLSH.apply_preprocesscCst|||Sr#)rZIndexLSH_trainrmrrrrn5szIndexLSH.trainNc Cst|||||||Sr#)rZIndexLSH_searchrsrrrru8szIndexLSH.searchcCs t||S)zh transfer the thresholds to a pre-processing stage (and unset train_thresholds) )rZIndexLSH_transfer_thresholds)rvtrrrtransfer_thresholds;szIndexLSH.transfer_thresholdscGst|tj|dSr#)rZIndexLSH_swiginitZ new_IndexLSHrQrrrr?CszIndexLSH.__init__cCst||||Sr#)rZIndexLSH_sa_encoderrrrrFszIndexLSH.sa_encodecCst||||Sr#)rZIndexLSH_sa_decoderrrrrIszIndexLSH.sa_decode)N)!r r r,r-rrrrrZIndexLSH_nbits_getZIndexLSH_nbits_setrZIndexLSH_rotate_data_getZIndexLSH_rotate_data_setZ rotate_dataZIndexLSH_train_thresholds_getZIndexLSH_train_thresholds_setZtrain_thresholdsZIndexLSH_rrot_getZIndexLSH_rrot_setZrrotZIndexLSH_thresholds_getZIndexLSH_thresholds_setZ thresholdsrrnrurZdelete_IndexLSHrTr?rrrrrrrs   rc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZeejejZeejejZeejejZeejejZ ddZ!ej"Z#d S) SimulatedAnnealingParametersz3 parameters used for the simulated annealing methodcCs |jSr#r0r1rrrr3Qr4z%SimulatedAnnealingParameters.cCs |j|Sr#r0r5rrrr3Qr4r7r8cCst|tdSr#)rZ%SimulatedAnnealingParameters_swiginitZ new_SimulatedAnnealingParametersr@rrrr?\sz%SimulatedAnnealingParameters.__init__N)$r r r,r-rrrrrZ1SimulatedAnnealingParameters_init_temperature_getZ1SimulatedAnnealingParameters_init_temperature_setZinit_temperatureZ2SimulatedAnnealingParameters_temperature_decay_getZ2SimulatedAnnealingParameters_temperature_decay_setZtemperature_decayZ'SimulatedAnnealingParameters_n_iter_getZ'SimulatedAnnealingParameters_n_iter_setZn_iterZ'SimulatedAnnealingParameters_n_redo_getZ'SimulatedAnnealingParameters_n_redo_setZn_redoZ%SimulatedAnnealingParameters_seed_getZ%SimulatedAnnealingParameters_seed_setrZ(SimulatedAnnealingParameters_verbose_getZ(SimulatedAnnealingParameters_verbose_setrZ/SimulatedAnnealingParameters_only_bit_flips_getZ/SimulatedAnnealingParameters_only_bit_flips_setZonly_bit_flipsZ,SimulatedAnnealingParameters_init_random_getZ,SimulatedAnnealingParameters_init_random_setZ init_randomr?Z#delete_SimulatedAnnealingParametersrTrrrrrNsrc@sVeZdZdZeddddddZddZeZee j e j Z d d Z d d Ze jZd S)PermutationObjectivez% abstract class for the loss functioncCs |jSr#r0r1rrrr3er4zPermutationObjective.cCs |j|Sr#r0r5rrrr3er4r7r8cOs tddSr:r;r<rrrr?gszPermutationObjective.__init__cCs t||Sr#)rZ!PermutationObjective_compute_costrrrr compute_costlsz!PermutationObjective.compute_costcCst||||Sr#)rZ PermutationObjective_cost_updaterrTiwZjwrrr cost_updateosz PermutationObjective.cost_updateN)r r r,r-rrr?rrrZPermutationObjective_n_getZPermutationObjective_n_setrBrrZdelete_PermutationObjectiverTrrrrrbsrc@seZdZeddddddZeZeejej Z e ddZ dd Z eejejd dZeejejd dZeejejd dZd dZddZddZddZe ddZddZejZdS)ReproduceDistancesObjectivecCs |jSr#r0r1rrrr3vr4z$ReproduceDistancesObjective.cCs |j|Sr#r0r5rrrr3vr4r7r8cCs t|Sr#)rZReproduceDistancesObjective_sqrr1rrrsqrzszReproduceDistancesObjective.sqrcCs t||Sr#)rZ&ReproduceDistancesObjective_dis_weightrErrr dis_weight~sz&ReproduceDistancesObjective.dis_weightz& "real" corrected distances (size n^2)z wanted distances (size n^2)z% weights for each distance (size n^2)cCst|||Sr#)rZ*ReproduceDistancesObjective_get_source_disrrrrget_source_dissz*ReproduceDistancesObjective.get_source_discCs t||Sr#)rZ(ReproduceDistancesObjective_compute_costrrrrrsz(ReproduceDistancesObjective.compute_costcCst||||Sr#)rZ'ReproduceDistancesObjective_cost_updaterrrrrsz'ReproduceDistancesObjective.cost_updatec Cst|t||||dSr#)rZ$ReproduceDistancesObjective_swiginitZnew_ReproduceDistancesObjective)rrB source_dis_inZ target_dis_indis_weight_factorrrrr?sz$ReproduceDistancesObjective.__init__cCst||||Sr#)rZ.ReproduceDistancesObjective_compute_mean_stdev)r`rZmean_outZ stddev_outrrrcompute_mean_stdevsz.ReproduceDistancesObjective.compute_mean_stdevcCs t||Sr#)rZ1ReproduceDistancesObjective_set_affine_target_dis)rrrrrset_affine_target_dissz1ReproduceDistancesObjective.set_affine_target_disN)r r r,rrrrrZ1ReproduceDistancesObjective_dis_weight_factor_getZ1ReproduceDistancesObjective_dis_weight_factor_setr staticmethodrrZ*ReproduceDistancesObjective_source_dis_getZ*ReproduceDistancesObjective_source_dis_setZ source_disZ*ReproduceDistancesObjective_target_dis_getZ*ReproduceDistancesObjective_target_dis_setZ target_disZ'ReproduceDistancesObjective_weights_getZ'ReproduceDistancesObjective_weights_setrrrrr?rrZ"delete_ReproduceDistancesObjectiverTrrrrrus"  rc@seZdZdZeddddddZeZeej ej Z eej ej ddZeejejZdd ZeejejZeejejd dZd d Zd dZejZdS)SimulatedAnnealingOptimizerz= Simulated annealing optimization algorithm for permutations.cCs |jSr#r0r1rrrr3r4z$SimulatedAnnealingOptimizer.cCs |j|Sr#r0r5rrrr3r4r7r8z size of the permutationcCst|t||dS)z! logs values of the cost functionN)rZ$SimulatedAnnealingOptimizer_swiginitZnew_SimulatedAnnealingOptimizer)rrrMrrrr?sz$SimulatedAnnealingOptimizer.__init__z& remember initial cost of optimizationcCs t||Sr#)rZ$SimulatedAnnealingOptimizer_optimizerrrroptimizesz$SimulatedAnnealingOptimizer.optimizecCs t||Sr#)rZ,SimulatedAnnealingOptimizer_run_optimization)rZ best_permrrrrun_optimizationsz,SimulatedAnnealingOptimizer.run_optimizationN)r r r,r-rrrrrZ#SimulatedAnnealingOptimizer_obj_getZ#SimulatedAnnealingOptimizer_obj_setrZ!SimulatedAnnealingOptimizer_n_getZ!SimulatedAnnealingOptimizer_n_setrBZ'SimulatedAnnealingOptimizer_logfile_getZ'SimulatedAnnealingOptimizer_logfile_setZlogfiler?Z#SimulatedAnnealingOptimizer_rnd_getZ#SimulatedAnnealingOptimizer_rnd_setZrndZ)SimulatedAnnealingOptimizer_init_cost_getZ)SimulatedAnnealingOptimizer_init_cost_setZ init_costrrZ"delete_SimulatedAnnealingOptimizerrTrrrrrsrc@seZdZdZeddddddZeZej Z ej Z ej ZeejejZeejejddZeejejddZeejejd dZeejejZd d Zd d ZddZ ddZ!ddZ"ej#Z$dS)PolysemousTrainingz5 optimizes the order of indices in a ProductQuantizercCs |jSr#r0r1rrrr3r4zPolysemousTraining.cCs |j|Sr#r0r5rrrr3r4r7r8z use 1/4 of the training points for the optimization, with max. ntrain_permutation. If ntrain_permutation == 0: train on centroids z( decay of exp that weights distance losszA refuse to train if it would require more than that amount of RAMcCst|tdSr#)rZPolysemousTraining_swiginitZnew_PolysemousTrainingr@rrrr?szPolysemousTraining.__init__cCst||||S)z reorder the centroids so that the Hamming distance becomes a good approximation of the SDC distance (called by train) )rZ*PolysemousTraining_optimize_pq_for_hammingrrrBr2rrroptimize_pq_for_hammingsz*PolysemousTraining.optimize_pq_for_hammingcCst||||Sz" called by optimize_pq_for_hamming)rZ#PolysemousTraining_optimize_rankingrrrroptimize_rankingsz#PolysemousTraining.optimize_rankingcCs t||Sr)rZ/PolysemousTraining_optimize_reproduce_distancesrrrrroptimize_reproduce_distancessz/PolysemousTraining.optimize_reproduce_distancescCs t||S)z& make sure we don't blow up the memory)rZ*PolysemousTraining_memory_usage_per_threadrrrrmemory_usage_per_threadsz*PolysemousTraining.memory_usage_per_threadN)%r r r,r-rrrrrZPolysemousTraining_OT_NoneZOT_NoneZ/PolysemousTraining_OT_ReproduceDistances_affineZOT_ReproduceDistances_affineZ+PolysemousTraining_OT_Ranking_weighted_diffZOT_Ranking_weighted_diffZ(PolysemousTraining_optimization_type_getZ(PolysemousTraining_optimization_type_setZoptimization_typeZ)PolysemousTraining_ntrain_permutation_getZ)PolysemousTraining_ntrain_permutation_setZntrain_permutationZ(PolysemousTraining_dis_weight_factor_getZ(PolysemousTraining_dis_weight_factor_setrZ!PolysemousTraining_max_memory_getZ!PolysemousTraining_max_memory_setZ max_memoryZ"PolysemousTraining_log_pattern_getZ"PolysemousTraining_log_pattern_setZ log_patternr?rrrrZdelete_PolysemousTrainingrTrrrrrs"rc@seZdZdZeddddddZeZeej ej ddZ dd Z d d Z dd dZddZddZddZeejejddZeejejddZejZejZejZejZej Z!ej"Z#eej$ej%Z&eej'ej(Z)eej*ej+ddZ,ddZ-ddZ.ddZ/ej0Z1d S)IndexPQz_ Index based on a product quantizer. Stored vectors are approximated by PQ codes. cCs |jSr#r0r1rrrr3r4zIndexPQ.cCs |j|Sr#r0r5rrrr3r4r7r8z1 The product quantizer used to encode the vectorscGst|tj|dSr#)rZIndexPQ_swiginitZ new_IndexPQrQrrrr?szIndexPQ.__init__cCst|||Sr#)rZ IndexPQ_trainrmrrrrnsz IndexPQ.trainNc Cst|||||||Sr#)rZIndexPQ_searchrsrrrruszIndexPQ.searchcCst||||Sr#)rZIndexPQ_sa_encoderrrrrszIndexPQ.sa_encodecCst||||Sr#)rZIndexPQ_sa_decoderrrrrszIndexPQ.sa_decodecCs t|Sr#)rZ%IndexPQ_get_FlatCodesDistanceComputerr@rrrrsz%IndexPQ.get_FlatCodesDistanceComputerz false = standard PQz, parameters used for the polysemous trainingz$ Hamming threshold used for polysemyc Cst||||||||Sr#)rZIndexPQ_search_core_polysemous)rrBr2rrr polysemous_htZgeneralized_hammingrrrsearch_core_polysemousszIndexPQ.search_core_polysemouscCst||||||S)a prepare query for a polysemous search, but instead of computing the result, just get the histogram of Hamming distances. May be computed on a provided dataset if xb != NULL :type dist_histogram: int :param dist_histogram: (M * nbits + 1) )rZ"IndexPQ_hamming_distance_histogram)rrBr2rr Zdist_histogramrrrhamming_distance_histogramsz"IndexPQ.hamming_distance_histogramcCst||||S)a compute pairwise distances between queries and database :type n: int :param n: nb of query vectors :type x: float :param x: query vector, size n * d :type dis: int :param dis: output distances, size n * ntotal )rZIndexPQ_hamming_distance_table)rrBr2rrrrhamming_distance_tables zIndexPQ.hamming_distance_table)N)2r r r,r-rrrrrZIndexPQ_pq_getZIndexPQ_pq_setrr?rnrurrrZ"IndexPQ_do_polysemous_training_getZ"IndexPQ_do_polysemous_training_setdo_polysemous_trainingZIndexPQ_polysemous_training_getZIndexPQ_polysemous_training_setpolysemous_trainingZ IndexPQ_ST_PQZST_PQZ IndexPQ_ST_HEZST_HEZIndexPQ_ST_generalized_HEZST_generalized_HEZIndexPQ_ST_SDCZST_SDCZIndexPQ_ST_polysemousZ ST_polysemousZ IndexPQ_ST_polysemous_generalizeZST_polysemous_generalizeZIndexPQ_search_type_getZIndexPQ_search_type_setrZIndexPQ_encode_signs_getZIndexPQ_encode_signs_setZ encode_signsZIndexPQ_polysemous_ht_getZIndexPQ_polysemous_ht_setrrrrZdelete_IndexPQrTrrrrrs2   rc@sTeZdZdZeddddddZeZeej ej Z eej ej ZddZejZd S) SearchParametersPQz* override search parameters from the classcCs |jSr#r0r1rrrr3/r4zSearchParametersPQ.cCs |j|Sr#r0r5rrrr3/r4r7r8cCst|tdSr#)rZSearchParametersPQ_swiginitZnew_SearchParametersPQr@rrrr?4szSearchParametersPQ.__init__N)r r r,r-rrrrrZ"SearchParametersPQ_search_type_getZ"SearchParametersPQ_search_type_setrZ$SearchParametersPQ_polysemous_ht_getZ$SearchParametersPQ_polysemous_ht_setrr?Zdelete_SearchParametersPQrTrrrrr,src@sjeZdZdZeddddddZeZeej ej Z eej ej ZeejejZddZd d ZejZd S) IndexPQStatszs statistics are robust to internal threading, but not if IndexPQ::search is called by multiple threads cCs |jSr#r0r1rrrr3@r4zIndexPQStats.cCs |j|Sr#r0r5rrrr3@r4r7r8cCst|tdSr#)rZIndexPQStats_swiginitZnew_IndexPQStatsr@rrrr?FszIndexPQStats.__init__cCs t|Sr#)rZIndexPQStats_resetr@rrrr|IszIndexPQStats.resetN)r r r,r-rrrrrZIndexPQStats_nq_getZIndexPQStats_nq_setrZIndexPQStats_ncode_getZIndexPQStats_ncode_setncodeZIndexPQStats_n_hamming_pass_getZIndexPQStats_n_hamming_pass_setn_hamming_passr?r|Zdelete_IndexPQStatsrTrrrrr:src@speZdZdZeddddddZeZeej ej Z ddZ dd d Z d d ZddZddZddZejZd S)MultiIndexQuantizerze Quantizer where centroids are virtual: they are the Cartesian product of sub-centroids. cCs |jSr#r0r1rrrr3Ur4zMultiIndexQuantizer.cCs |j|Sr#r0r5rrrr3Ur4r7r8cCst|||Sr#)rZMultiIndexQuantizer_trainrmrrrrnYszMultiIndexQuantizer.trainNc Cst|||||||Sr#)rZMultiIndexQuantizer_searchrsrrrru\szMultiIndexQuantizer.searchcCst|||S)z$ add and reset will crash at runtime)rZMultiIndexQuantizer_addrmrrrro_szMultiIndexQuantizer.addcCs t|Sr#)rZMultiIndexQuantizer_resetr@rrrr|cszMultiIndexQuantizer.resetcGst|tj|dSr#)rZMultiIndexQuantizer_swiginitZnew_MultiIndexQuantizerrQrrrr?fszMultiIndexQuantizer.__init__cCst|||Sr#)rZMultiIndexQuantizer_reconstructr|rrrriszMultiIndexQuantizer.reconstruct)N)r r r,r-rrrrrZMultiIndexQuantizer_pq_getZMultiIndexQuantizer_pq_setrrnruror|r?rZdelete_MultiIndexQuantizerrTrrrrrOs rc@sjeZdZdZeddddddZeZeej ej ddZ eej ej Zdd Zd d Zdd dZejZd S)MultiIndexQuantizer2zH MultiIndexQuantizer where the PQ assignmnet is performed by sub-indexescCs |jSr#r0r1rrrr3rr4zMultiIndexQuantizer2.cCs |j|Sr#r0r5rrrr3rr4r7r8z M Indexes on d / M dimensionscGst|tj|dSr#)rZMultiIndexQuantizer2_swiginitZnew_MultiIndexQuantizer2rQrrrr?wszMultiIndexQuantizer2.__init__cCst|||Sr#)rZMultiIndexQuantizer2_trainrmrrrrnzszMultiIndexQuantizer2.trainNc Cst|||||||Sr#)rZMultiIndexQuantizer2_searchrsrrrru}szMultiIndexQuantizer2.search)N)r r r,r-rrrrrZ'MultiIndexQuantizer2_assign_indexes_getZ'MultiIndexQuantizer2_assign_indexes_setZassign_indexesZ#MultiIndexQuantizer2_own_fields_getZ#MultiIndexQuantizer2_own_fields_setrr?rnruZdelete_MultiIndexQuantizer2rTrrrrros rc@sheZdZdZeddddddZeZeej ej Z ddZ dd d Z d d ZddZddZejZd S)IndexAdditiveQuantizerzL Abstract class for additive quantizers. The search functions are in common.cCs |jSr#r0r1rrrr3r4zIndexAdditiveQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexAdditiveQuantizer_swiginitZnew_IndexAdditiveQuantizerrQrrrr?szIndexAdditiveQuantizer.__init__Nc Cst|||||||Sr#)rZIndexAdditiveQuantizer_searchrsrrrruszIndexAdditiveQuantizer.searchcCst||||Sr#)rZ IndexAdditiveQuantizer_sa_encoderrrrrsz IndexAdditiveQuantizer.sa_encodecCst||||Sr#)rZ IndexAdditiveQuantizer_sa_decoderrrrrsz IndexAdditiveQuantizer.sa_decodecCs t|Sr#)rZ4IndexAdditiveQuantizer_get_FlatCodesDistanceComputerr@rrrrsz4IndexAdditiveQuantizer.get_FlatCodesDistanceComputer)N)r r r,r-rrrrrZIndexAdditiveQuantizer_aq_getZIndexAdditiveQuantizer_aq_setaqr?rurrrZdelete_IndexAdditiveQuantizerrTrrrrrs rc@sReZdZdZeddddddZeZeej ej ddZ dd Z d d Z ejZd S) IndexResidualQuantizer Index based on a residual quantizer. Stored vectors are approximated by residual quantization codes. Can also be used as a codec cCs |jSr#r0r1rrrr3r4zIndexResidualQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r82 The residual quantizer used to encode the vectorscGst|tj|dSr#)rZIndexResidualQuantizer_swiginitZnew_IndexResidualQuantizerrQrrrr?szIndexResidualQuantizer.__init__cCst|||Sr#)rZIndexResidualQuantizer_trainrmrrrrnszIndexResidualQuantizer.trainN)r r r,r-rrrrrZIndexResidualQuantizer_rq_getZIndexResidualQuantizer_rq_setr%r?rnZdelete_IndexResidualQuantizerrTrrrrrsrc@sJeZdZeddddddZeZeejej Z ddZ dd Z ej Zd S) IndexLocalSearchQuantizercCs |jSr#r0r1rrrr3r4z"IndexLocalSearchQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZ"IndexLocalSearchQuantizer_swiginitZnew_IndexLocalSearchQuantizerrQrrrr?sz"IndexLocalSearchQuantizer.__init__cCst|||Sr#)rZIndexLocalSearchQuantizer_trainrmrrrrnszIndexLocalSearchQuantizer.trainN)r r r,rrrrrZ!IndexLocalSearchQuantizer_lsq_getZ!IndexLocalSearchQuantizer_lsq_setrSr?rnZ delete_IndexLocalSearchQuantizerrTrrrrrs rc@sReZdZdZeddddddZeZeej ej ddZ dd Z d d Z ejZd S) IndexProductResidualQuantizerz- Index based on a product residual quantizer.cCs |jSr#r0r1rrrr3r4z&IndexProductResidualQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8: The product residual quantizer used to encode the vectorscGst|tj|dSr#)rZ&IndexProductResidualQuantizer_swiginitZ!new_IndexProductResidualQuantizerrQrrrr?sz&IndexProductResidualQuantizer.__init__cCst|||Sr#)rZ#IndexProductResidualQuantizer_trainrmrrrrnsz#IndexProductResidualQuantizer.trainN)r r r,r-rrrrrZ%IndexProductResidualQuantizer_prq_getZ%IndexProductResidualQuantizer_prq_setprqr?rnZ$delete_IndexProductResidualQuantizerrTrrrrrsrc@sReZdZdZeddddddZeZeej ej ddZ dd Z d d Z ejZd S) IndexProductLocalSearchQuantizerz1 Index based on a product local search quantizer.cCs |jSr#r0r1rrrr3r4z)IndexProductLocalSearchQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8> The product local search quantizer used to encode the vectorscGst|tj|dSr#)rZ)IndexProductLocalSearchQuantizer_swiginitZ$new_IndexProductLocalSearchQuantizerrQrrrr?sz)IndexProductLocalSearchQuantizer.__init__cCst|||Sr#)rZ&IndexProductLocalSearchQuantizer_trainrmrrrrnsz&IndexProductLocalSearchQuantizer.trainN)r r r,r-rrrrrZ)IndexProductLocalSearchQuantizer_plsq_getZ)IndexProductLocalSearchQuantizer_plsq_setplsqr?rnZ'delete_IndexProductLocalSearchQuantizerrTrrrrrsrc@seZdZdZeddddddZeZeej ej Z ddZ eej ejd dZd d Zdd dZddZddZddZejZd S)AdditiveCoarseQuantizerz A "virtual" index where the elements are the residual quantizer centroids. Intended for use as a coarse quantizer in an IndexIVF. cCs |jSr#r0r1rrrr3r4z AdditiveCoarseQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZ AdditiveCoarseQuantizer_swiginitZnew_AdditiveCoarseQuantizerrQrrrr?sz AdditiveCoarseQuantizer.__init__z* norms of centroids, useful for knn-searchcCst|||Sz N/A)rZAdditiveCoarseQuantizer_addrmrrrroszAdditiveCoarseQuantizer.addNc Cst|||||||Sr#)rZAdditiveCoarseQuantizer_searchrsrrrruszAdditiveCoarseQuantizer.searchcCst|||Sr#)rZ#AdditiveCoarseQuantizer_reconstructr|rrrrsz#AdditiveCoarseQuantizer.reconstructcCst|||Sr#)rZAdditiveCoarseQuantizer_trainrmrrrrnszAdditiveCoarseQuantizer.traincCs t|Sr)rZAdditiveCoarseQuantizer_resetr@rrrr|szAdditiveCoarseQuantizer.reset)N)r r r,r-rrrrrZAdditiveCoarseQuantizer_aq_getZAdditiveCoarseQuantizer_aq_setrr?Z*AdditiveCoarseQuantizer_centroid_norms_getZ*AdditiveCoarseQuantizer_centroid_norms_setrrorurrnr|Zdelete_AdditiveCoarseQuantizerrTrrrrrs rc@sBeZdZeddddddZeZeejej Z ej Z ddZ dS) 'SearchParametersResidualCoarseQuantizercCs |jSr#r0r1rrrr3r4z0SearchParametersResidualCoarseQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZ0SearchParametersResidualCoarseQuantizer_swiginitZ+new_SearchParametersResidualCoarseQuantizerr@rrrr?sz0SearchParametersResidualCoarseQuantizer.__init__N)r r r,rrrrrZ7SearchParametersResidualCoarseQuantizer_beam_factor_getZ7SearchParametersResidualCoarseQuantizer_beam_factor_set beam_factorZ.delete_SearchParametersResidualCoarseQuantizerrTr?rrrrrs rc@sveZdZdZeddddddZeZeej ej ddZ eej ej ddZd d Zdd d ZddZddZejZd S)ResidualCoarseQuantizerz The ResidualCoarseQuantizer is a bit specialized compared to the default AdditiveCoarseQuantizer because it can use a beam search at search time (slow but may be useful for very large vocabularies) cCs |jSr#r0r1rrrr3r4z ResidualCoarseQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8rze factor between the beam size and the search k if negative, use exact search-to-centroid cCs t||S)z$ computes centroid norms if required)rZ'ResidualCoarseQuantizer_set_beam_factor)rZnew_beam_factorrrrset_beam_factorsz'ResidualCoarseQuantizer.set_beam_factorNc Cst|||||||Sr#)rZResidualCoarseQuantizer_searchrsrrrruszResidualCoarseQuantizer.searchcCs t||S)z Copy the M first codebook levels from other. Useful to crop a ResidualQuantizer to its first M quantizers. )rZ'ResidualCoarseQuantizer_initialize_fromr^rrrr6"sz'ResidualCoarseQuantizer.initialize_fromcGst|tj|dSr#)rZ ResidualCoarseQuantizer_swiginitZnew_ResidualCoarseQuantizerrQrrrr?)sz ResidualCoarseQuantizer.__init__)N)r r r,r-rrrrrZResidualCoarseQuantizer_rq_getZResidualCoarseQuantizer_rq_setr%Z'ResidualCoarseQuantizer_beam_factor_getZ'ResidualCoarseQuantizer_beam_factor_setrrrur6r?Zdelete_ResidualCoarseQuantizerrTrrrrr s rc@sFeZdZeddddddZeZeejej ddZ ddZ ej Z d S) LocalSearchCoarseQuantizercCs |jSr#r0r1rrrr30r4z#LocalSearchCoarseQuantizer.cCs |j|Sr#r0r5rrrr30r4r7r8rcGst|tj|dSr#)rZ#LocalSearchCoarseQuantizer_swiginitZnew_LocalSearchCoarseQuantizerrQrrrr?4sz#LocalSearchCoarseQuantizer.__init__N)r r r,rrrrrZ"LocalSearchCoarseQuantizer_lsq_getZ"LocalSearchCoarseQuantizer_lsq_setrSr?Z!delete_LocalSearchCoarseQuantizerrTrrrrr/s rc@sReZdZeddddddZddZeZeej ej Z dd Z d d Z ejZd S) IOReadercCs |jSr#r0r1rrrr3;r4zIOReader.cCs |j|Sr#r0r5rrrr3;r4r7r8cOs tddSr:r;r<rrrr?=szIOReader.__init__cCst||||Sr#)rZIOReader___call__rptrr[nitemsrrrrBszIOReader.__call__cCs t|Sr#)rZIOReader_filedescriptorr@rrrfiledescriptorEszIOReader.filedescriptorN)r r r,rrr?rrrZIOReader_name_getZIOReader_name_setrrrZdelete_IOReaderrTrrrrr:src@sReZdZeddddddZddZeZeej ej Z dd Z d d Z ejZd S) IOWritercCs |jSr#r0r1rrrr3Lr4zIOWriter.cCs |j|Sr#r0r5rrrr3Lr4r7r8cOs tddSr:r;r<rrrr?NszIOWriter.__init__cCst||||Sr#)rZIOWriter___call__rrrrrSszIOWriter.__call__cCs t|Sr#)rZIOWriter_filedescriptorr@rrrrVszIOWriter.filedescriptorN)r r r,rrr?rrrZIOWriter_name_getZIOWriter_name_setrrrZdelete_IOWriterrTrrrrrKsrc@sXeZdZeddddddZeZeejej Z eej ej Z ddZdd ZejZd S) VectorIOReadercCs |jSr#r0r1rrrr3]r4zVectorIOReader.cCs |j|Sr#r0r5rrrr3]r4r7r8cCst||||Sr#)rZVectorIOReader___call__rrrrrbszVectorIOReader.__call__cCst|tdSr#)rZVectorIOReader_swiginitZnew_VectorIOReaderr@rrrr?eszVectorIOReader.__init__N)r r r,rrrrrZVectorIOReader_data_getZVectorIOReader_data_setrZZVectorIOReader_rp_getZVectorIOReader_rp_setrprr?Zdelete_VectorIOReaderrTrrrrr\src@sJeZdZeddddddZeZeejej Z ddZ dd Z ej Zd S) VectorIOWritercCs |jSr#r0r1rrrr3lr4zVectorIOWriter.cCs |j|Sr#r0r5rrrr3lr4r7r8cCst||||Sr#)rZVectorIOWriter___call__rrrrrpszVectorIOWriter.__call__cCst|tdSr#)rZVectorIOWriter_swiginitZnew_VectorIOWriterr@rrrr?sszVectorIOWriter.__init__N)r r r,rrrrrZVectorIOWriter_data_getZVectorIOWriter_data_setrZrr?Zdelete_VectorIOWriterrTrrrrrks rc@s`eZdZeddddddZeZeejej Z eej ej Z ddZejZdd Zd d Zd S) FileIOReadercCs |jSr#r0r1rrrr3zr4zFileIOReader.cCs |j|Sr#r0r5rrrr3zr4r7r8cGst|tj|dSr#)rZFileIOReader_swiginitZnew_FileIOReaderrQrrrr?szFileIOReader.__init__cCst||||Sr#)rZFileIOReader___call__rrrrrszFileIOReader.__call__cCs t|Sr#)rZFileIOReader_filedescriptorr@rrrrszFileIOReader.filedescriptorN)r r r,rrrrrZFileIOReader_f_getZFileIOReader_f_setfZFileIOReader_need_close_getZFileIOReader_need_close_set need_closer?Zdelete_FileIOReaderrTrrrrrrrysrc@s`eZdZeddddddZeZeejej Z eej ej Z ddZejZdd Zd d Zd S) FileIOWritercCs |jSr#r0r1rrrr3r4zFileIOWriter.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZFileIOWriter_swiginitZnew_FileIOWriterrQrrrr?szFileIOWriter.__init__cCst||||Sr#)rZFileIOWriter___call__rrrrrszFileIOWriter.__call__cCs t|Sr#)rZFileIOWriter_filedescriptorr@rrrrszFileIOWriter.filedescriptorN)r r r,rrrrrZFileIOWriter_f_getZFileIOWriter_f_setrZFileIOWriter_need_close_getZFileIOWriter_need_close_setrr?Zdelete_FileIOWriterrTrrrrrrrsrc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejddZeejejddZeejejd dZeejejZeejejZd d Zd d Zej Z!dS)BufferedIOReaderzB wraps an ioreader to make buffered reads to avoid too small readscCs |jSr#r0r1rrrr3r4zBufferedIOReader.cCs |j|Sr#r0r5rrrr3r4r7r8z offset in input streamz# number of bytes returned to callerz' range of available bytes in the buffercGst|tj|dS)z :type bsz: int, optional :param bsz: buffer size (bytes). Reads will be done by batched of this size N)rZBufferedIOReader_swiginitZnew_BufferedIOReaderrQrrrr?szBufferedIOReader.__init__cCst||||Sr#)rZBufferedIOReader___call__rrrrrszBufferedIOReader.__call__N)"r r r,r-rrrrrZBufferedIOReader_reader_getZBufferedIOReader_reader_setreaderZBufferedIOReader_bsz_getZBufferedIOReader_bsz_setbszZBufferedIOReader_ofs_getZBufferedIOReader_ofs_setofsZBufferedIOReader_ofs2_getZBufferedIOReader_ofs2_setofs2ZBufferedIOReader_b0_getZBufferedIOReader_b0_setb0ZBufferedIOReader_b1_getZBufferedIOReader_b1_setb1ZBufferedIOReader_buffer_getZBufferedIOReader_buffer_setbufferr?rZdelete_BufferedIOReaderrTrrrrrsrc@seZdZeddddddZeZeejej Z eej ej Z eejejZeejejddZeejejddZeejejZdd Zd d ZejZd S) BufferedIOWritercCs |jSr#r0r1rrrr3r4zBufferedIOWriter.cCs |j|Sr#r0r5rrrr3r4r7r8z% number of bytes received from callerz amount of data in buffercGst|tj|dSr#)rZBufferedIOWriter_swiginitZnew_BufferedIOWriterrQrrrr?szBufferedIOWriter.__init__cCst||||Sr#)rZBufferedIOWriter___call__rrrrrszBufferedIOWriter.__call__N)r r r,rrrrrZBufferedIOWriter_writer_getZBufferedIOWriter_writer_setwriterZBufferedIOWriter_bsz_getZBufferedIOWriter_bsz_setrZBufferedIOWriter_ofs_getZBufferedIOWriter_ofs_setrZBufferedIOWriter_ofs2_getZBufferedIOWriter_ofs2_setrZBufferedIOWriter_b0_getZBufferedIOWriter_b0_setrZBufferedIOWriter_buffer_getZBufferedIOWriter_buffer_setrr?rZdelete_BufferedIOWriterrTrrrrrsrcGs tj|Sr#)rfourccrrrrrsrcGs tj|Sr#)r fourcc_invrrrrrsrcCs t|Sr#)rfourcc_inv_printabler1rrrrsrc@sPeZdZdZeddddddZddZeZe j Z d d Z d d Z d dZdS)InvertedListsIteratorz_ Definition of inverted lists + a few common classes that implement the interface. cCs |jSr#r0r1rrrr3r4zInvertedListsIterator.cCs |j|Sr#r0r5rrrr3r4r7r8cOs tddSr:r;r<rrrr?szInvertedListsIterator.__init__cCs t|Sr#)rZ"InvertedListsIterator_is_availabler@rrr is_availablesz"InvertedListsIterator.is_availablecCs t|Sr#)rZInvertedListsIterator_nextr@rrrrHszInvertedListsIterator.nextcCs t|Sr#)rZ&InvertedListsIterator_get_id_and_codesr@rrrget_id_and_codessz&InvertedListsIterator.get_id_and_codesN)r r r,r-rrr?rrrZdelete_InvertedListsIteratorrTrrHrrrrrrsrc@s@eZdZdZeddddddZddZeZee j e j d dZ ee j e jd dZee je jd dZe jZe jZd d ZddZddZddZddZddZddZddZd7ddZd8dd Z d9d!d"Z!d#d$Z"d%d&Z#d'd(Z$d)d*Z%d+d,Z&d-d.Z'e j(Z)e j*Z+e j,Z-e j.Z/e j0Z1d/d0Z2d1d2Z3d3d4Z4d5d6Z5dS): InvertedListsz Table of inverted lists multithreading rules: - concurrent read accesses are allowed - concurrent update accesses are allowed - for resize and add_entries, only concurrent access to different lists are allowed cCs |jSr#r0r1rrrr3r4zInvertedLists.cCs |j|Sr#r0r5rrrr3r4r7r8cOs tddSr:r;r<rrrr?szInvertedLists.__init__ number of possible key values code size per vector in bytesz8 request to use iterator rather than get_codes / get_idscCs t||S)z get the size of a list)rZInvertedLists_list_sizerlist_norrr list_sizeszInvertedLists.list_sizecCs t||S)z get the codes for an inverted list must be released by release_codes :rtype: uint8_t :return: codes size list_size * code_size )rZInvertedLists_get_codesrrrr get_codes szInvertedLists.get_codescCs t||S)z get the ids for an inverted list must be released by release_ids :rtype: int :return: ids size list_size )rZInvertedLists_get_idsrrrrget_idsszInvertedLists.get_idscCst|||S)zC release codes returned by get_codes (default implementation is nop)rZInvertedLists_release_codesrrrrrr release_codesszInvertedLists.release_codescCst|||S)z release ids returned by get_ids)rZInvertedLists_release_idsrrr'rrr release_ids!szInvertedLists.release_idscCst|||S)zN :rtype: int :return: a single id in an inverted list )rZInvertedLists_get_single_idrrrrrr get_single_id%szInvertedLists.get_single_idcCst|||S)z :rtype: uint8_t :return: a single code in an inverted list (should be deallocated with release_codes) )rZInvertedLists_get_single_coder rrrget_single_code,szInvertedLists.get_single_codecCst|||S)zs prepare the following lists (default does nothing) a list can be -1 hence the signed long )rZInvertedLists_prefetch_listsrlist_nosnlistrrrprefetch_lists4szInvertedLists.prefetch_listsNcCst|||S)z check if the list is empty)rZInvertedLists_is_emptyrrinverted_list_contextrrris_empty;szInvertedLists.is_emptycCst|||S)z) get iterable for lists that use_iterator)rZInvertedLists_get_iteratorrrrr get_iterator?szInvertedLists.get_iteratorcCst|||||S)z" add one entry to an inverted list)rZInvertedLists_add_entry)rrZtheidrrrrr add_entryCszInvertedLists.add_entrycCst|||||Sr#)rZInvertedLists_add_entriesrrn_entryr'rrrr add_entriesGszInvertedLists.add_entriescCst|||||Sr#)rZInvertedLists_update_entry)rrridrrrr update_entryJszInvertedLists.update_entrycCst||||||Sr#)rZInvertedLists_update_entriesrrrrr'rrrrupdate_entriesMszInvertedLists.update_entriescCst|||Sr#)rZInvertedLists_resizerrnew_sizerrrr]PszInvertedLists.resizecCs t|Sr#)rZInvertedLists_resetr@rrrr|SszInvertedLists.resetcCst|||S)z- move all entries from oivf (empty on output))rZInvertedLists_merge_from)rZoivfrrrrrVszInvertedLists.merge_fromcCst|||||S)z copy a subset of the entries index to the other index :rtype: int :return: number of entries copied )rZInvertedLists_copy_subset_torr_Z subset_typeZa1Za2rrrcopy_subset_to_szInvertedLists.copy_subset_tocCs t|S)z& 1= perfectly balanced, >1: imbalanced)rZInvertedLists_imbalance_factorr@rrrrgszInvertedLists.imbalance_factorcCs t|S)z, display some stats about the inverted lists)rZInvertedLists_print_statsr@rrr print_statskszInvertedLists.print_statscCs t|S)z sum up list sizes)rZInvertedLists_compute_ntotalr@rrrcompute_ntotaloszInvertedLists.compute_ntotal)N)N)N)6r r r,r-rrr?rrrZInvertedLists_nlist_getZInvertedLists_nlist_setrZInvertedLists_code_size_getZInvertedLists_code_size_setrZInvertedLists_use_iterator_getZInvertedLists_use_iterator_setZ use_iteratorZdelete_InvertedListsrTZInvertedLists_INVALID_CODE_SIZEZINVALID_CODE_SIZErrrrr r r rrrrrrrr]r|rZ"InvertedLists_SUBSET_TYPE_ID_RANGEZSUBSET_TYPE_ID_RANGEZ InvertedLists_SUBSET_TYPE_ID_MODZSUBSET_TYPE_ID_MODZ'InvertedLists_SUBSET_TYPE_ELEMENT_RANGEZSUBSET_TYPE_ELEMENT_RANGEZ*InvertedLists_SUBSET_TYPE_INVLIST_FRACTIONZSUBSET_TYPE_INVLIST_FRACTIONZ!InvertedLists_SUBSET_TYPE_INVLISTZSUBSET_TYPE_INVLISTr rr!r"rrrrrsF      rc@seZdZdZeddddddZeZeej ej Z eej ej ddZdd Zd d Zd d ZddZddZddZddZddZdddZejZdS)ArrayInvertedListsz> simple (default) implementation as an array of inverted listscCs |jSr#r0r1rrrr3xr4zArrayInvertedLists.cCs |j|Sr#r0r5rrrr3xr4r7r8z Inverted lists for indexescCst|t||dSr#)rZArrayInvertedLists_swiginitZnew_ArrayInvertedLists)rrrrrrr?}szArrayInvertedLists.__init__cCs t||Sr#)rZArrayInvertedLists_list_sizerrrrrszArrayInvertedLists.list_sizecCs t||Sr#)rZArrayInvertedLists_get_codesrrrrrszArrayInvertedLists.get_codescCs t||Sr#)rZArrayInvertedLists_get_idsrrrrrszArrayInvertedLists.get_idscCst|||||Sr#)rZArrayInvertedLists_add_entriesrrrrrszArrayInvertedLists.add_entriescCst||||||Sr#)rZ!ArrayInvertedLists_update_entriesrrrrrsz!ArrayInvertedLists.update_entriescCst|||Sr#)rZArrayInvertedLists_resizerrrrr]szArrayInvertedLists.resizecCs t||S)z6 permute the inverted lists, map maps new_id to old_id)rZ#ArrayInvertedLists_permute_invlistsrrrrrpermute_invlistssz#ArrayInvertedLists.permute_invlistsNcCst|||Sr#)rZArrayInvertedLists_is_emptyrrrrrszArrayInvertedLists.is_empty)N)r r r,r-rrrrrZArrayInvertedLists_codes_getZArrayInvertedLists_codes_setrZArrayInvertedLists_ids_getZArrayInvertedLists_ids_setr'r?rrrrrr]r%rZdelete_ArrayInvertedListsrTrrrrr#us r#c@sPeZdZdZeddddddZddZeZd d Z d d Z d dZ e j ZdS)ReadOnlyInvertedListsz+ invlists that fail for all write functionscCs |jSr#r0r1rrrr3r4zReadOnlyInvertedLists.cCs |j|Sr#r0r5rrrr3r4r7r8cOs tddSr:r;r<rrrr?szReadOnlyInvertedLists.__init__cCst|||||Sr#)rZ!ReadOnlyInvertedLists_add_entriesrrrrrsz!ReadOnlyInvertedLists.add_entriescCst||||||Sr#)rZ$ReadOnlyInvertedLists_update_entriesrrrrrsz$ReadOnlyInvertedLists.update_entriescCst|||Sr#)rZReadOnlyInvertedLists_resizerrrrr]szReadOnlyInvertedLists.resizeN)r r r,r-rrr?rrrrr]rZdelete_ReadOnlyInvertedListsrTrrrrr&sr&c@seZdZdZeddddddZeZeej ej Z ddZ d d Z d d Zd dZddZddZddZddZddZejZdS)HStackInvertedListsz# Horizontal stack of inverted listscCs |jSr#r0r1rrrr3r4zHStackInvertedLists.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|t||dSz1 build InvertedLists by concatenating nil of themN)rZHStackInvertedLists_swiginitZnew_HStackInvertedListsrnililsrrrr?szHStackInvertedLists.__init__cCs t||Sr#)rZHStackInvertedLists_list_sizerrrrrszHStackInvertedLists.list_sizecCs t||Sr#)rZHStackInvertedLists_get_codesrrrrrszHStackInvertedLists.get_codescCs t||Sr#)rZHStackInvertedLists_get_idsrrrrrszHStackInvertedLists.get_idscCst|||Sr#)rZ"HStackInvertedLists_prefetch_listsr rrrrsz"HStackInvertedLists.prefetch_listscCst|||Sr#)rZ!HStackInvertedLists_release_codesrrrrrsz!HStackInvertedLists.release_codescCst|||Sr#)rZHStackInvertedLists_release_idsrrrrr szHStackInvertedLists.release_idscCst|||Sr#)rZ!HStackInvertedLists_get_single_idr rrrr sz!HStackInvertedLists.get_single_idcCst|||Sr#)rZ#HStackInvertedLists_get_single_coder rrrr sz#HStackInvertedLists.get_single_codeN)r r r,r-rrrrrZHStackInvertedLists_ils_getZHStackInvertedLists_ils_setr+r?rrrrrr r r Zdelete_HStackInvertedListsrTrrrrr'sr'c@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZddZd d Zd d Zd dZddZddZddZddZddZejZdS)SliceInvertedListsz3 vertical slice of indexes in another InvertedListscCs |jSr#r0r1rrrr3r4zSliceInvertedLists.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|t|||dSr#)rZSliceInvertedLists_swiginitZnew_SliceInvertedLists)rilri1rrrr?szSliceInvertedLists.__init__cCs t||Sr#)rZSliceInvertedLists_list_sizerrrrrszSliceInvertedLists.list_sizecCs t||Sr#)rZSliceInvertedLists_get_codesrrrrrszSliceInvertedLists.get_codescCs t||Sr#)rZSliceInvertedLists_get_idsrrrrrszSliceInvertedLists.get_idscCst|||Sr#)rZ SliceInvertedLists_release_codesrrrrrsz SliceInvertedLists.release_codescCst|||Sr#)rZSliceInvertedLists_release_idsrrrrr szSliceInvertedLists.release_idscCst|||Sr#)rZ SliceInvertedLists_get_single_idr rrrr sz SliceInvertedLists.get_single_idcCst|||Sr#)rZ"SliceInvertedLists_get_single_coder rrrr sz"SliceInvertedLists.get_single_codecCst|||Sr#)rZ!SliceInvertedLists_prefetch_listsr rrrrsz!SliceInvertedLists.prefetch_listsN)r r r,r-rrrrrZSliceInvertedLists_il_getZSliceInvertedLists_il_setr-ZSliceInvertedLists_i0_getZSliceInvertedLists_i0_setrZSliceInvertedLists_i1_getZSliceInvertedLists_i1_setr.r?rrrrr r r rZdelete_SliceInvertedListsrTrrrrr,s r,c@seZdZeddddddZeZeejej Z eej ej Z ddZdd Zd d Zd d ZddZddZddZddZddZejZdS)VStackInvertedListscCs |jSr#r0r1rrrr3r4zVStackInvertedLists.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|t||dSr()rZVStackInvertedLists_swiginitZnew_VStackInvertedListsr)rrrr?szVStackInvertedLists.__init__cCs t||Sr#)rZVStackInvertedLists_list_sizerrrrrszVStackInvertedLists.list_sizecCs t||Sr#)rZVStackInvertedLists_get_codesrrrrr szVStackInvertedLists.get_codescCs t||Sr#)rZVStackInvertedLists_get_idsrrrrrszVStackInvertedLists.get_idscCst|||Sr#)rZ!VStackInvertedLists_release_codesrrrrrsz!VStackInvertedLists.release_codescCst|||Sr#)rZVStackInvertedLists_release_idsrrrrr szVStackInvertedLists.release_idscCst|||Sr#)rZ!VStackInvertedLists_get_single_idr rrrr sz!VStackInvertedLists.get_single_idcCst|||Sr#)rZ#VStackInvertedLists_get_single_coder rrrr sz#VStackInvertedLists.get_single_codecCst|||Sr#)rZ"VStackInvertedLists_prefetch_listsr rrrrsz"VStackInvertedLists.prefetch_listsN)r r r,rrrrrZVStackInvertedLists_ils_getZVStackInvertedLists_ils_setr+ZVStackInvertedLists_cumsz_getZVStackInvertedLists_cumsz_setZcumszr?rrrrr r r rZdelete_VStackInvertedListsrTrrrrr/sr/c@seZdZdZeddddddZeZeej ej Z eej ej ZddZd d Zd d Zd dZddZddZddZddZddZejZdS)MaskedInvertedListsz use the first inverted lists if they are non-empty otherwise use the second This is useful if il1 has a few inverted lists that are too long, and that il0 has replacement lists for those, with empty lists for the others. cCs |jSr#r0r1rrrr3,r4zMaskedInvertedLists.cCs |j|Sr#r0r5rrrr3,r4r7r8cCst|t||dSr#)rZMaskedInvertedLists_swiginitZnew_MaskedInvertedLists)ril0il1rrrr?1szMaskedInvertedLists.__init__cCs t||Sr#)rZMaskedInvertedLists_list_sizerrrrr4szMaskedInvertedLists.list_sizecCs t||Sr#)rZMaskedInvertedLists_get_codesrrrrr7szMaskedInvertedLists.get_codescCs t||Sr#)rZMaskedInvertedLists_get_idsrrrrr:szMaskedInvertedLists.get_idscCst|||Sr#)rZ!MaskedInvertedLists_release_codesrrrrr=sz!MaskedInvertedLists.release_codescCst|||Sr#)rZMaskedInvertedLists_release_idsrrrrr @szMaskedInvertedLists.release_idscCst|||Sr#)rZ!MaskedInvertedLists_get_single_idr rrrr Csz!MaskedInvertedLists.get_single_idcCst|||Sr#)rZ#MaskedInvertedLists_get_single_coder rrrr Fsz#MaskedInvertedLists.get_single_codecCst|||Sr#)rZ"MaskedInvertedLists_prefetch_listsr rrrrIsz"MaskedInvertedLists.prefetch_listsN)r r r,r-rrrrrZMaskedInvertedLists_il0_getZMaskedInvertedLists_il0_setr1ZMaskedInvertedLists_il1_getZMaskedInvertedLists_il1_setr2r?rrrrr r r rZdelete_MaskedInvertedListsrTrrrrr0#sr0c@seZdZdZeddddddZeZeej ej Z eej ej ZddZd d Zd d Zd dZddZddZddZddZddZejZdS)StopWordsInvertedListszr if the inverted list in il is smaller than maxsize then return it, otherwise return an empty invlist cCs |jSr#r0r1rrrr3Ur4zStopWordsInvertedLists.cCs |j|Sr#r0r5rrrr3Ur4r7r8cCst|t||dSr#)rZStopWordsInvertedLists_swiginitZnew_StopWordsInvertedLists)rr-maxsizerrrr?ZszStopWordsInvertedLists.__init__cCs t||Sr#)rZ StopWordsInvertedLists_list_sizerrrrr]sz StopWordsInvertedLists.list_sizecCs t||Sr#)rZ StopWordsInvertedLists_get_codesrrrrr`sz StopWordsInvertedLists.get_codescCs t||Sr#)rZStopWordsInvertedLists_get_idsrrrrrcszStopWordsInvertedLists.get_idscCst|||Sr#)rZ$StopWordsInvertedLists_release_codesrrrrrfsz$StopWordsInvertedLists.release_codescCst|||Sr#)rZ"StopWordsInvertedLists_release_idsrrrrr isz"StopWordsInvertedLists.release_idscCst|||Sr#)rZ$StopWordsInvertedLists_get_single_idr rrrr lsz$StopWordsInvertedLists.get_single_idcCst|||Sr#)rZ&StopWordsInvertedLists_get_single_coder rrrr osz&StopWordsInvertedLists.get_single_codecCst|||Sr#)rZ%StopWordsInvertedLists_prefetch_listsr rrrrrsz%StopWordsInvertedLists.prefetch_listsN)r r r,r-rrrrrZStopWordsInvertedLists_il0_getZStopWordsInvertedLists_il0_setr1Z"StopWordsInvertedLists_maxsize_getZ"StopWordsInvertedLists_maxsize_setr4r?rrrrr r r rZdelete_StopWordsInvertedListsrTrrrrr3Osr3c@seZdZdZeddddddZddZeZee j d dZ ee j d dZ d d Zd dZddZe jZeddZeddZeddZeddZdS)InvertedListsIOHooka Callbacks to handle other types of InvertedList objects. The callbacks should be registered with add_callback before calling read_index or read_InvertedLists. The callbacks for OnDiskInvertedLists are registrered by default. The invlist type is identified by: - the key (a fourcc) at read time - the class name (as given by typeid.name) at write time cCs |jSr#r0r1rrrr3r4zInvertedListsIOHook.cCs |j|Sr#r0r5rrrr3r4r7r8cOs tddSr:r;r<rrrr?szInvertedListsIOHook.__init__z string version of the fourccz typeid.namecCst|||S)z7 write the index to the IOWriter (including the fourcc))rZInvertedListsIOHook_write)rr+rrrrrszInvertedListsIOHook.writecCst|||S)z3 called when the fourcc matches this class's fourcc)rZInvertedListsIOHook_read)rrio_flagsrrrrszInvertedListsIOHook.readcCst||||||S)a read from a ArrayInvertedLists into this invertedlist type. For this to work, the callback has to be enabled and the io_flag has to be set to IO_FLAG_SKIP_IVF_DATA | (16 upper bits of the fourcc) (default implementation fails) )rZ+InvertedListsIOHook_read_ArrayInvertedLists)rrr6rrsizesrrrread_ArrayInvertedListssz+InvertedListsIOHook.read_ArrayInvertedListscCs t|Sr#)rZ InvertedListsIOHook_add_callbackarg1rrr add_callbacksz InvertedListsIOHook.add_callbackcCstSr#)rZ#InvertedListsIOHook_print_callbacksrrrrprint_callbackssz#InvertedListsIOHook.print_callbackscCs t|Sr#)rZInvertedListsIOHook_lookup)hrrrlookupszInvertedListsIOHook.lookupcCs t|Sr#)rZ$InvertedListsIOHook_lookup_classname) classnamerrrlookup_classnamesz$InvertedListsIOHook.lookup_classnameN)r r r,r-rrr?rrrZInvertedListsIOHook_key_getr}Z!InvertedListsIOHook_classname_getr?rrr8Zdelete_InvertedListsIOHookrTrr;r<r>r@rrrrr5xs$     r5c@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZeejejZddZd d Zd d Zd dZddZddZddZddZej Z!dS)BlockInvertedListsaZ Inverted Lists that are organized by blocks. Different from the regular inverted lists, the codes are organized by blocks of size block_size bytes that reprsent a set of n_per_block. Therefore, code allocations are always rounded up to block_size bytes. The codes are also aligned on 32-byte boundaries for use with SIMD. To avoid misinterpretations, the code_size is set to (size_t)(-1), even if arguably the amount of memory consumed by code is block_size / n_per_block. The writing functions add_entries and update_entries operate on block-aligned data. cCs |jSr#r0r1rrrr3r4zBlockInvertedLists.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZBlockInvertedLists_swiginitZnew_BlockInvertedListsrQrrrr?szBlockInvertedLists.__init__cCs t||Sr#)rZBlockInvertedLists_list_sizerrrrrszBlockInvertedLists.list_sizecCs t||Sr#)rZBlockInvertedLists_get_codesrrrrrszBlockInvertedLists.get_codescCs t||Sr#)rZBlockInvertedLists_get_idsrrrrrszBlockInvertedLists.get_idscCs t||S)z" remove ids from the InvertedLists)rZBlockInvertedLists_remove_idsrzrrrr{szBlockInvertedLists.remove_idscCst|||||Sr#)rZBlockInvertedLists_add_entriesrrrrrszBlockInvertedLists.add_entriescCst||||||Sz not implemented)rZ!BlockInvertedLists_update_entriesrrrrrsz!BlockInvertedLists.update_entriescCst|||Sr#)rZBlockInvertedLists_resizerrrrr]szBlockInvertedLists.resizeN)"r r r,r-rrrrrZ"BlockInvertedLists_n_per_block_getZ"BlockInvertedLists_n_per_block_setZ n_per_blockZ!BlockInvertedLists_block_size_getZ!BlockInvertedLists_block_size_setrrZBlockInvertedLists_packer_getZBlockInvertedLists_packer_setpackerZBlockInvertedLists_codes_getZBlockInvertedLists_codes_setrZBlockInvertedLists_ids_getZBlockInvertedLists_ids_setr'r?rrrr{rrr]Zdelete_BlockInvertedListsrTrrrrrAs"rAcCs t||Sr#)rlo_build)Zlist_idrrrrrDsrDcCs t|Sr#)r lo_listnolorrrrEsrEcCs t|Sr#)r lo_offsetrFrrrrHsrHc@seZdZdZeddddddZeZej Z ej Z ej ZeejejZeejejddZeejejZdd Zd d Zd d ZddZddZddZddZddZddZ ej!Z"dS) DirectMapz8Direct map: a way to map back from ids to inverted listscCs |jSr#r0r1rrrr3r4zDirectMap.cCs |j|Sr#r0r5rrrr3r4r7r8zF map for direct access to the elements. Map ids to LO-encoded entries.cCst|tdSr#)rZDirectMap_swiginitZ new_DirectMapr@rrrr?szDirectMap.__init__cCst||||S)z set type and initialize)rZDirectMap_set_type)rnew_typeinvlistsrrrrset_typeszDirectMap.set_typecCs t||S)z get an entry)rZ DirectMap_getrrrrrrVsz DirectMap.getcCs t|S)z for quick checks)rZ DirectMap_nor@rrrnosz DirectMap.nocCs t||S)zT update the direct_map throw if Array and ids is not NULL )rZDirectMap_check_can_add)rr'rrr check_can_add szDirectMap.check_can_addcCst||||S)z non thread-safe version)rZDirectMap_add_single_id)rrrrrrr add_single_idszDirectMap.add_single_idcCs t|S)z remove all entries)rZDirectMap_clearr@rrrrYszDirectMap.clearcCst|||S)z operations on inverted lists that require translation with a DirectMap remove ids from the InvertedLists, possibly using the direct map )rZDirectMap_remove_ids)rr5rKrrrr{szDirectMap.remove_idscCst||||||S)z% update entries, using the direct map)rZDirectMap_update_codes)rrKrBr'rrrrr update_codes#szDirectMap.update_codesN)#r r r,r-rrrrrZDirectMap_NoMapZNoMapZDirectMap_ArrayZArrayZDirectMap_HashtableZ HashtableZDirectMap_type_getZDirectMap_type_setrZDirectMap_array_getZDirectMap_array_setarrayZDirectMap_hashtable_getZDirectMap_hashtable_setZ hashtabler?rLrVrNrOrPrYr{rQZdelete_DirectMaprTrrrrrIs&rIc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZeejejZeejejZddZd d ZejZd S) DirectMapAddz+ Thread-safe way of updating the direct_mapcCs |jSr#r0r1rrrr3-r4zDirectMapAdd.cCs |j|Sr#r0r5rrrr3-r4r7r8cCst|t|||dSr#)rZDirectMapAdd_swiginitZnew_DirectMapAdd)r direct_maprBrqrrrr?6szDirectMapAdd.__init__cCst||||S)z5 add vector i (with id xids[i]) at list_no and offset)rZDirectMapAdd_add)rrrrrrrro9szDirectMapAdd.addN)r r r,r-rrrrrZDirectMapAdd_direct_map_getZDirectMapAdd_direct_map_setrTZDirectMapAdd_type_getZDirectMapAdd_type_setrZDirectMapAdd_ntotal_getZDirectMapAdd_ntotal_setrZDirectMapAdd_n_getZDirectMapAdd_n_setrBZDirectMapAdd_xids_getZDirectMapAdd_xids_setrqZDirectMapAdd_all_ofs_getZDirectMapAdd_all_ofs_setZall_ofsr?roZdelete_DirectMapAddrTrrrrrS*srSc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZd dZddZddZddZddZej Z!dS)Level1Quantizerz Encapsulates a quantizer object for the IndexIVF The class isolates the fields that are independent of the storage of the lists (especially training) cCs |jSr#r0r1rrrr3Hr4zLevel1Quantizer.cCs |j|Sr#r0r5rrrr3Hr4r7r8. quantizer that maps vectors to inverted listsz number of inverted listsz = 0: use the quantizer as index in a kmeans training = 1: just pass on the training set to the train() of the quantizer = 2: kmeans training on a flat index + add the centroids to the quantizer " whether object owns the quantizer& to override default clustering params) to override index used during clusteringcCst|||||S)zF Trains the quantizer and calls train_residual to train sub-quantizers)rZLevel1Quantizer_train_q1)rrBr2rrfrrrtrain_q1UszLevel1Quantizer.train_q1cCs t|S)z7 compute the number of bytes required to store list ids)rZ Level1Quantizer_coarse_code_sizer@rrrcoarse_code_sizeYsz Level1Quantizer.coarse_code_sizecCst|||Sr#)rZLevel1Quantizer_encode_listno)rrrrrr encode_listno]szLevel1Quantizer.encode_listnocCs t||Sr#)rZLevel1Quantizer_decode_listnorrrr decode_listno`szLevel1Quantizer.decode_listnocGst|tj|dSr#)rZLevel1Quantizer_swiginitZnew_Level1QuantizerrQrrrr?cszLevel1Quantizer.__init__N)"r r r,r-rrrrrZLevel1Quantizer_quantizer_getZLevel1Quantizer_quantizer_set quantizerZLevel1Quantizer_nlist_getZLevel1Quantizer_nlist_setrZ*Level1Quantizer_quantizer_trains_alone_getZ*Level1Quantizer_quantizer_trains_alone_setZquantizer_trains_aloneZLevel1Quantizer_own_fields_getZLevel1Quantizer_own_fields_setrZLevel1Quantizer_cp_getZLevel1Quantizer_cp_setrZ$Level1Quantizer_clustering_index_getZ$Level1Quantizer_clustering_index_setclustering_indexrZr[r\r]r?Zdelete_Level1QuantizerrTrrrrrU@srUc@sxeZdZeddddddZeZeejej ddZ eej ej ddZ eejejZeejejddZejZd d Zd S) SearchParametersIVFcCs |jSr#r0r1rrrr3jr4zSearchParametersIVF.cCs |j|Sr#r0r5rrrr3jr4r7r8 number of probes at query time' max nb of codes to visit to do a queryz( context object to pass to InvertedListscCst|tdSr#)rZSearchParametersIVF_swiginitZnew_SearchParametersIVFr@rrrr?rszSearchParametersIVF.__init__N)r r r,rrrrrZSearchParametersIVF_nprobe_getZSearchParametersIVF_nprobe_setnprobeZ!SearchParametersIVF_max_codes_getZ!SearchParametersIVF_max_codes_set max_codesZ(SearchParametersIVF_quantizer_params_getZ(SearchParametersIVF_quantizer_params_setZquantizer_paramsZ-SearchParametersIVF_inverted_list_context_getZ-SearchParametersIVF_inverted_list_context_setrZdelete_SearchParametersIVFrTr?rrrrr`isr`c@sleZdZeddddddZddZeZeej ej ddZ eej ej d dZdd d ZdddZejZd S)IndexIVFInterfacecCs |jSr#r0r1rrrr3xr4zIndexIVFInterface.cCs |j|Sr#r0r5rrrr3xr4r7r8cOs tddSr:r;r<rrrr?zszIndexIVFInterface.__init__rarbNc Cst|||||||||| | S)a search a set of vectors, that are pre-quantized by the IVF quantizer. Fill in the corresponding heaps with the query results. The default implementation uses InvertedListScanners to do the search. :type n: int :param n: nb of vectors to query :type x: float :param x: query vectors, size nx * d :type assign: int :param assign: coarse quantization indices, size nx * nprobe :type centroid_dis: float :param centroid_dis: distances to coarse centroids, size nx * nprobe :param distance: output distances, size n * k :type labels: int :param labels: output labels, size n * k :type store_pairs: boolean :param store_pairs: store inv list index + inv list offset instead in upper/lower 32 bit of result, instead of ids (used for reranking). :type params: :py:class:`IVFSearchParameters`, optional :param params: used to override the object's search parameters :type stats: :py:class:`IndexIVFStats`, optional :param stats: search stats to be updated (can be null) )rZ$IndexIVFInterface_search_preassigned rrBr2rry centroid_disrr store_pairsrtstatsrrrsearch_preassignedsz$IndexIVFInterface.search_preassignedFc Cst|||||||||| S)aZ Range search a set of vectors, that are pre-quantized by the IVF quantizer. Fill in the RangeSearchResults results. The default implementation uses InvertedListScanners to do the search. :param n: nb of vectors to query :type x: float :param x: query vectors, size nx * d :param assign: coarse quantization indices, size nx * nprobe :param centroid_dis: distances to coarse centroids, size nx * nprobe :type result: :py:class:`RangeSearchResult` :param result: Output results :type store_pairs: boolean, optional :param store_pairs: store inv list index + inv list offset instead in upper/lower 32 bit of result, instead of ids (used for reranking). :type params: :py:class:`IVFSearchParameters`, optional :param params: used to override the object's search parameters :type stats: :py:class:`IndexIVFStats`, optional :param stats: search stats to be updated (can be null) )rZ*IndexIVFInterface_range_search_preassigned rrr2rrc coarse_disrrhrtrirrrrange_search_preassignedsz*IndexIVFInterface.range_search_preassigned)NN)FNN)r r r,rrr?rrrZIndexIVFInterface_nprobe_getZIndexIVFInterface_nprobe_setrcZIndexIVFInterface_max_codes_getZIndexIVFInterface_max_codes_setrdrjrmZdelete_IndexIVFInterfacerTrrrrrews  rec@seZdZdZeddddddZddZeZee j e j d dZ ee j e jZee je jd dZee je jd dZee jZee je jd dZee je jd dZddZddZddZ ddZ!dQddZ"dRddZ#ddZ$ddZ%d d!Z&dSd"d#Z'dTd$d%Z(dUd&d'Z)dVd(d)Z*dWd*d+Z+d,d-Z,d.d/Z-d0d1Z.dXd2d3Z/dYd4d5Z0d6d7Z1d8d9Z2d:d;Z3dd?Z5d@dAZ6e j7Z8dBdCZ9dDdEZ:dZdGdHZ;dIdJZdOdPZ?dS)\IndexIVFa Index based on a inverted file (IVF) In the inverted file, the quantizer (an Index instance) provides a quantization index for each vector to be added. The quantization index maps to a list (aka inverted list or posting list), where the id of the vector is stored. The inverted list object is required only after trainng. If none is set externally, an ArrayInvertedLists is used automatically. At search time, the vector to be searched is also quantized, and only the list corresponding to the quantization index is searched. This speeds up the search by making it non-exhaustive. This can be relaxed using multi-probe search: a few (nprobe) quantization indices are selected and several inverted lists are visited. Sub-classes implement a post-filtering of the index that refines the distance estimation from the query to databse vectors. cCs |jSr#r0r1rrrr3r4zIndexIVF.cCs |j|Sr#r0r5rrrr3r4r7r8cOs tddSr:r;r<rrrr?szIndexIVF.__init__ Access to the actual datara] Parallel mode determines how queries are parallelized with OpenMP 0 (default): split over queries 1: parallelize over inverted lists 2: parallelize over both 3: split over queries with a finer granularity PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to prevent the heap to be initialized and finalized z\ optional map that maps back ids to invlist entries. This enables reconstruct() zX do the codes in the invlists encode the vectors relative to the centroids? cCs t|Sr#)rZIndexIVF_resetr@rrrr|szIndexIVF.resetcCst|||S)zE Trains the quantizer and calls train_encoder to train sub-quantizers)rZIndexIVF_trainrmrrrrnszIndexIVF.traincCst|||S)z! Calls add_with_ids with NULL ids)rZ IndexIVF_addrmrrrrosz IndexIVF.addcCst||||S)z1 default implementation that calls encode_vectors)rZIndexIVF_add_with_idsrprrrrrszIndexIVF.add_with_idsNcCst||||||S)aE Implementation of vector addition where the vector assignments are predefined. The default implementation hands over the code extraction to encode_vectors. :type precomputed_idx: int :param precomputed_idx: quantization indices for the input vectors (size n) )rZIndexIVF_add_corerrBr2rqprecomputed_idxrrrradd_cores zIndexIVF.add_coreFcCst||||||S)a1 Encodes a set of vectors as they would appear in the inverted lists :type list_nos: int :param list_nos: inverted list ids as returned by the quantizer (size n). -1s are ignored. :type codes: uint8_t :param codes: output codes, size n * code_size :type include_listno: boolean, optional :param include_listno: include the list ids in the code (in this case add ceil(log8(nlist)) to the code size) )rZIndexIVF_encode_vectorsrrBr2rrinclude_listnorrrencode_vectors szIndexIVF.encode_vectorscCst||||Sr)rZIndexIVF_add_sa_codesrrrrrs zIndexIVF.add_sa_codescCst||||S)z Train the encoder for the vectors. If by_residual then it is called with residuals and corresponding assign array, otherwise x is the raw training vectors and assign=nullptr )rZIndexIVF_train_encoderrrBr2ryrrr train_encoder%szIndexIVF.train_encodercCs t|S)zh can be redefined by subclasses to indicate how many training vectors they need )rZ"IndexIVF_train_encoder_num_vectorsr@rrrtrain_encoder_num_vectors.sz"IndexIVF.train_encoder_num_vectorsc Cst|||||||||| | Sr#)rZIndexIVF_search_preassignedrfrrrrj5szIndexIVF.search_preassignedc Cst|||||||||| Sr#)rZ!IndexIVF_range_search_preassignedrkrrrrm8sz!IndexIVF.range_search_preassignedc Cst|||||||Sz/ assign the vectors, then call search_preassign)rZIndexIVF_searchrsrrrru;szIndexIVF.searchcCst||||||Sr#)rZIndexIVF_range_searchrvrrrrw?szIndexIVF.range_searchcCst|||S)z Get a scanner for this index (store_pairs means ignore labels) The default search implementation uses this to compute the distances )rZ IndexIVF_get_InvertedListScannerrrhr5rrrget_InvertedListScannerBsz IndexIVF.get_InvertedListScannercCst|||S)zI reconstruct a vector. Works only if maintain_direct_map is set to 1 or 2)rZIndexIVF_reconstructr|rrrrJszIndexIVF.reconstructcCst||||S)a= Update a subset of vectors. The index must have a direct_map :type nv: int :param nv: nb of vectors to update :type idx: int :param idx: vector indices to update, size nv :type v: float :param v: vectors of new values, size nv*d )rZIndexIVF_update_vectorsrnvrr6rrrupdate_vectorsNs zIndexIVF.update_vectorscCst||||S)a Reconstruct a subset of the indexed vectors. Overrides default implementation to bypass reconstruct() which requires direct_map to be maintained. :type i0: int :param i0: first vector to reconstruct :type ni: int :param ni: nb of vectors to reconstruct :type recons: float :param recons: output array of reconstructed vectors, size ni * d )rZIndexIVF_reconstruct_nrrrrr]szIndexIVF.reconstruct_nc Cst||||||||S)a Similar to search, but also reconstructs the stored vectors (or an approximation in the case of lossy coding) for the search results. Overrides default implementation to avoid having to maintain direct_map and instead fetch the code offsets through the `store_pairs` flag in search_preassigned(). :type recons: float :param recons: reconstructed vectors size (n, k, d) )rZIndexIVF_search_and_reconstructrrrrrms zIndexIVF.search_and_reconstructc Cst||||||||| S)a Similar to search, but also returns the codes corresponding to the stored vectors for the search results. :param codes: codes (n, k, code_size) :type include_listno: boolean, optional :param include_listno: include the list ids in the code (in this case add ceil(log8(nlist)) to the code size) )rZ IndexIVF_search_and_return_codes) rrBr2rrrr~rtrtrrrsearch_and_return_codes{s z IndexIVF.search_and_return_codescCst||||Sa1 Reconstruct a vector given the location in terms of (inv list index + inv list offset) instead of the id. Useful for reconstructing when the direct_map is not maintained and the inv list offset is computed by search_preassigned() with `store_pairs` set. )rZ IndexIVF_reconstruct_from_offsetrrrr~rrrreconstruct_from_offsets z IndexIVF.reconstruct_from_offsetcCs t||Sz Dataset manipulation functions)rZIndexIVF_remove_idsrzrrrr{szIndexIVF.remove_idscCs t||Sr#)rZ#IndexIVF_check_compatible_for_mergerrrrrsz#IndexIVF.check_compatible_for_mergecCst|||Sr#)rZIndexIVF_merge_fromrrrrrszIndexIVF.merge_fromcCs t|Sr#)rZIndexIVF_get_CodePackerr@rrrrszIndexIVF.get_CodePackercCst|||||S)z copy a subset of the entries index to the other index see Invlists::copy_subset_to for the meaning of subset_type )rZIndexIVF_copy_subset_torrrrr szIndexIVF.copy_subset_tocCs t||Sr#)rZIndexIVF_get_list_sizerrrr get_list_sizeszIndexIVF.get_list_sizecCs t|S)z are the ids sorted?)rZIndexIVF_check_ids_sortedr@rrrcheck_ids_sortedszIndexIVF.check_ids_sortedTcCs t||Sz initialize a direct map :type new_maintain_direct_map: boolean, optional :param new_maintain_direct_map: if true, create a direct map, else clear it )rZIndexIVF_make_direct_maprZnew_maintain_direct_maprrrmake_direct_mapszIndexIVF.make_direct_mapcCs t||Sr#)rZIndexIVF_set_direct_map_typerrrrrset_direct_map_typeszIndexIVF.set_direct_map_typecCst|||S)zC replace the inverted lists, old one is deallocated if own_invlists)rZIndexIVF_replace_invlistsrr-rrrrreplace_invlistsszIndexIVF.replace_invlistscCs t|Sr#)rZIndexIVF_sa_code_sizer@rrrrszIndexIVF.sa_code_sizecCst||||S)a encode a set of vectors sa_encode will call encode_vectors with include_listno=true :type n: int :param n: nb of vectors to encode :type x: float :param x: the vectors to encode :type bytes: uint8_t :param bytes: output array for the codes :rtype: void :return: nb of bytes written to codes )rZIndexIVF_sa_encoderrrrrs zIndexIVF.sa_encode)N)F)NN)FNN)N)N)FN)N)FN)T)F)@r r r,r-rrr?rrrZIndexIVF_invlists_getZIndexIVF_invlists_setrKZIndexIVF_own_invlists_getZIndexIVF_own_invlists_set own_invlistsZIndexIVF_code_size_getZIndexIVF_code_size_setrZIndexIVF_parallel_mode_getZIndexIVF_parallel_mode_setZ parallel_modeZ'IndexIVF_PARALLEL_MODE_NO_HEAP_INIT_getZPARALLEL_MODE_NO_HEAP_INITZIndexIVF_direct_map_getZIndexIVF_direct_map_setrTZIndexIVF_by_residual_getZIndexIVF_by_residual_set by_residualr|rnrorrrrrurrwrxrjrmrurwr{rr~rrrrr{rrrr Zdelete_IndexIVFrTrrrrrrrrrrrrnsX              rnc@seZdZdZeddddddZddZeZee j e j d dZ ee j e jd dZee je jd dZee je jd dZee je jd dZddZddZddZddZddZddZddZe j Z!dS)InvertedListScannerz Object that handles a query. The inverted lists to scan are provided externally. The object has a lot of state, but distance_to_code and scan_codes can be called in multiple threads cCs |jSr#r0r1rrrr3r4zInvertedListScanner.cCs |j|Sr#r0r5rrrr3r4r7r8cOs tddSr:r;r<rrrr?szInvertedListScanner.__init__z remember current listz keep maximum instead of minimumz/ store positions in invlists rather than labelsz search in this subset of idsz- used in default implementation of scan_codescCs t||Sz" from now on we handle this query.)rZInvertedListScanner_set_queryrZ query_vectorrrrrszInvertedListScanner.set_querycCst|||Sz- following codes come from this inverted list)rZInvertedListScanner_set_listrrrlrrrset_listszInvertedListScanner.set_listcCs t||Sz( compute a single query-to-code distance)rZ$InvertedListScanner_distance_to_coderrrrrsz$InvertedListScanner.distance_to_codec Cst|||||||S)a scan a set of codes, compute distances to current query and update heap of results if necessary. Default implementation calls distance_to_code. :type n: int :param n: number of codes to scan :type codes: uint8_t :param codes: codes to scan (n * code_size) :type ids: int :param ids: corresponding ids (ignored if store_pairs) :type distances: float :param distances: heap distances (size k) :type labels: int :param labels: heap labels (size k) :type k: int :param k: heap size :rtype: int :return: number of heap updates performed )rZInvertedListScanner_scan_codesrrBrr'rrrrrr scan_codesszInvertedListScanner.scan_codescCst||||||Sr#)rZ!InvertedListScanner_iterate_codes)riteratorrrrrrrr iterate_codes sz!InvertedListScanner.iterate_codescCst||||||S)z scan a set of codes, compute distances to current query and update results if distances are below radius (default implementation fails) )rZ$InvertedListScanner_scan_codes_rangerrBrr'rrrrrscan_codes_range sz$InvertedListScanner.scan_codes_rangecCst|||||Sr#)rZ'InvertedListScanner_iterate_codes_range)rrrrrrrriterate_codes_rangesz'InvertedListScanner.iterate_codes_rangeN)"r r r,r-rrr?rrrZInvertedListScanner_list_no_getZInvertedListScanner_list_no_setrZ InvertedListScanner_keep_max_getZ InvertedListScanner_keep_max_setrZ#InvertedListScanner_store_pairs_getZ#InvertedListScanner_store_pairs_setrhZInvertedListScanner_sel_getZInvertedListScanner_sel_setr5Z!InvertedListScanner_code_size_getZ!InvertedListScanner_code_size_setrrrrrrrrZdelete_InvertedListScannerrTrrrrrs" rc@seZdZeddddddZeZeejej Z eej ej Z eejejZeejejZeejejZeejejZddZdd Zd d ZejZd S) IndexIVFStatscCs |jSr#r0r1rrrr3r4zIndexIVFStats.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZIndexIVFStats_swiginitZnew_IndexIVFStatsr@rrrr?&szIndexIVFStats.__init__cCs t|Sr#)rZIndexIVFStats_resetr@rrrr|)szIndexIVFStats.resetcCs t||Sr#)rZIndexIVFStats_addr^rrrro,szIndexIVFStats.addN)r r r,rrrrrZIndexIVFStats_nq_getZIndexIVFStats_nq_setrZIndexIVFStats_nlist_getZIndexIVFStats_nlist_setrZIndexIVFStats_ndis_getZIndexIVFStats_ndis_setndisZIndexIVFStats_nheap_updates_getZIndexIVFStats_nheap_updates_setZ nheap_updatesZ#IndexIVFStats_quantization_time_getZ#IndexIVFStats_quantization_time_setZquantization_timeZIndexIVFStats_search_time_getZIndexIVFStats_search_time_setZ search_timer?r|roZdelete_IndexIVFStatsrTrrrrrsrcCs t||S)zn check if two indexes have the same parameters and are trained in the same way, otherwise throw. )rr)index1index2rrrr3srcGs tj|Sr#)rextract_index_ivfrrrrr:srcGs tj|Sr#)rtry_extract_index_ivfrrrrr=srcCst|||S)z Merge index1 into index0. Works on IndexIVF's and IndexIVF's embedded in a IndexPreTransform. On output, the index1 is empty. :type shift_ids: boolean :param shift_ids:: translate the ids from index1 to index0->prev_ntotal )r merge_into)Zindex0r shift_idsrrrr@srcCst||||Sr#)rsearch_centroid)rr2rBZ centroid_idsrrrrJsrc Cst||||||||Sr#)rsearch_and_return_centroids)rrBZxinrrrZquery_centroid_idsZresult_centroid_idsrrrrMsrc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZd d ZddZejZdS)SlidingIndexWindowz A set of IndexIVFs concatenated together in a FIFO fashion. at each "step", the oldest index slice is removed and a new index is added. cCs |jSr#r0r1rrrr3Ur4zSlidingIndexWindow.cCs |j|Sr#r0r5rrrr3Ur4r7r8z. common index that contains the sliding windowz InvertedLists of indexz$ number of slices currently in indexz same as index->nlistz$ cumulative list sizes at each slicecCst|t|dS)z, index should be initially empty and trainedN)rZSlidingIndexWindow_swiginitZnew_SlidingIndexWindowrrrrrr?]szSlidingIndexWindow.__init__cCst|||S)a$ Add one index to the current index and remove the oldest one. :type sub_index: :py:class:`Index` :param sub_index: slice to swap in (can be NULL) :type remove_oldest: boolean :param remove_oldest: if true, remove the oldest slices )rZSlidingIndexWindow_step)rZ sub_indexZ remove_oldestrrrstepas zSlidingIndexWindow.stepN)r r r,r-rrrrrZSlidingIndexWindow_index_getZSlidingIndexWindow_index_setrZSlidingIndexWindow_ils_getZSlidingIndexWindow_ils_setr+ZSlidingIndexWindow_n_slice_getZSlidingIndexWindow_n_slice_setZn_sliceZSlidingIndexWindow_nlist_getZSlidingIndexWindow_nlist_setrZSlidingIndexWindow_sizes_getZSlidingIndexWindow_sizes_setr7r?rZdelete_SlidingIndexWindowrTrrrrrOs rcCst|||S)z( Get a subset of inverted lists [i0, i1))rget_invlist_range)rrr.rrrrpsrcCst||||S)z Set a subset of inverted lists)rset_invlist_range)rrr.srcrrrrtsrc Cst||||||||| S)a search an IndexIVF, possibly embedded in an IndexPreTransform with given parameters. This is a way to set the nprobe and get statdistics in a thread-safe way. Optionally returns (if non-nullptr): - nb_dis: number of distances computed - ms_per_stage: [0]: preprocessing time [1]: coarse quantization, [2]: list scanning )rsearch_with_parameters) rrBr2rrrrtnb_dis ms_per_stagerrrrxs rc Cst||||||||S)z4 same as search_with_parameters but for range search)rrange_search_with_parameters)rrBr2rrrtrrrrrrsrcCs t||S)z Build an IndexIVFResidualQuantizer from an ResidualQuantizer, using the nlevel first components as coarse quantizer and the rest as codes in invlists )rivf_residual_from_quantizer)r:ZnlevelrrrrsrcCst||||S)a add from codes. NB that the norm component is not used, so the code_size can be provided. :type ivfrq: :py:class:`IndexIVFResidualQuantizer` :param ivfrq: index to populate with the codes :type codes: uint8_t :param codes: codes to add, size (ncode, code_size) :type code_size: int, optional :param code_size: override the ivfrq's code_size, useful if the norm encoding is different )r ivf_residual_add_from_flat_codes)Zivfrqrrrrrrrs rc@seZdZdZeddddddZeZej Z ej Z ej ZejZejZejZejZejZejZeejejZejZej Z!ej"Z#ej$Z%eej&ej'Z(eej)ej*Z+eej,ej-ddZ.eej/ej0ddZ1d d Z2d d Z3d dZ4ddZ5ddZ6ddZ7ddZ8dddZ9ej:Z;dS)ScalarQuantizerz The uniform quantizer has a range [vmin, vmax]. The range can be the same for all dimensions (uniform) or specific per dimension (default). cCs |jSr#r0r1rrrr3r4zScalarQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8z bits per scalar codez% trained values (including the range)cGst|tj|dSr#)rZScalarQuantizer_swiginitZnew_ScalarQuantizerrQrrrr?szScalarQuantizer.__init__cCs t|S)z- updates internal values based on qtype and d)rZ!ScalarQuantizer_set_derived_sizesr@rrrset_derived_sizessz!ScalarQuantizer.set_derived_sizescCst|||Sr#)rZScalarQuantizer_trainrmrrrrnszScalarQuantizer.traincCst||||S)z Encode a set of vectors :type x: float :param x: vectors to encode, size n * d :type codes: uint8_t :param codes: output codes, size n * code_size )rZScalarQuantizer_compute_codesrrrrrs zScalarQuantizer.compute_codescCst||||S)z Decode a set of vectors :param codes: codes to decode, size n * code_size :type x: float :param x: output vectors, size n * d )rZScalarQuantizer_decoderrrrrszScalarQuantizer.decodecCs t|Sr#)rZ ScalarQuantizer_select_quantizerr@rrrselect_quantizersz ScalarQuantizer.select_quantizercGstj|g|RSr#)rZ%ScalarQuantizer_get_distance_computerrQrrrrsz%ScalarQuantizer.get_distance_computerFcCst||||||Sr#)rZ*ScalarQuantizer_select_InvertedListScanner)rrHr^rhr5rrrrselect_InvertedListScannersz*ScalarQuantizer.select_InvertedListScannerN)F)cCs |j|Sr#r0r5rrrr3r4r7r8z Used to encode the vectorscGst|tj|dSr#)rZIndexScalarQuantizer_swiginitZnew_IndexScalarQuantizerrQrrrr?szIndexScalarQuantizer.__init__cCst|||Sr#)rZIndexScalarQuantizer_trainrmrrrrnszIndexScalarQuantizer.trainNc Cst|||||||Sr#)rZIndexScalarQuantizer_searchrsrrrruszIndexScalarQuantizer.searchcCs t|Sr#)rZ2IndexScalarQuantizer_get_FlatCodesDistanceComputerr@rrrrsz2IndexScalarQuantizer.get_FlatCodesDistanceComputercCst||||Sr#)rZIndexScalarQuantizer_sa_encoderrrrrszIndexScalarQuantizer.sa_encodecCst||||Sr#)rZIndexScalarQuantizer_sa_decoderrrrr szIndexScalarQuantizer.sa_decode)N)r r r,r-rrrrrZIndexScalarQuantizer_sq_getZIndexScalarQuantizer_sq_setsqr?rnrurrrZdelete_IndexScalarQuantizerrTrrrrrs rc@seZdZdZeddddddZeZeej ej Z ddZ d d Z d d ZdddZdddZddZddZddZejZdS)IndexIVFScalarQuantizerz An IVF implementation where the components of the residuals are encoded with a scalar quantizer. All distance computations are asymmetric, so the encoded vectors are decoded and approximate distances are computed. cCs |jSr#r0r1rrrr3r4z IndexIVFScalarQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZ IndexIVFScalarQuantizer_swiginitZnew_IndexIVFScalarQuantizerrQrrrr?sz IndexIVFScalarQuantizer.__init__cCst||||Sr#)rZ%IndexIVFScalarQuantizer_train_encoderrvrrrrwsz%IndexIVFScalarQuantizer.train_encodercCs t|Sr#)rZ1IndexIVFScalarQuantizer_train_encoder_num_vectorsr@rrrrx!sz1IndexIVFScalarQuantizer.train_encoder_num_vectorsFcCst||||||Sr#)rZ&IndexIVFScalarQuantizer_encode_vectorsrrBr2rrZinclude_listnosrrrru$sz&IndexIVFScalarQuantizer.encode_vectorsNcCst||||||Sr#)rZ IndexIVFScalarQuantizer_add_corerprrrrr'sz IndexIVFScalarQuantizer.add_corecCst|||Sr#)rZ/IndexIVFScalarQuantizer_get_InvertedListScannerrzrrrr{*sz/IndexIVFScalarQuantizer.get_InvertedListScannercCst||||Sr#)rZ/IndexIVFScalarQuantizer_reconstruct_from_offsetrrrrr-sz/IndexIVFScalarQuantizer.reconstruct_from_offsetcCst||||Sr#)rZ!IndexIVFScalarQuantizer_sa_decoderrrrr0sz!IndexIVFScalarQuantizer.sa_decode)F)N)r r r,r-rrrrrZIndexIVFScalarQuantizer_sq_getZIndexIVFScalarQuantizer_sq_setrr?rwrxrurrr{rrZdelete_IndexIVFScalarQuantizerrTrrrrrs  rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZejZejZejZejZeejejZeej ej!d dZ"d d Z#ddZ$dddZ%ddZ&ddZ'ej(Z)dS)IndexIVFSpectralHasha Inverted list that stores binary codes of size nbit. Before the binary conversion, the dimension of the vectors is transformed from dim d into dim nbit by vt (a random rotation by default). Each coordinate is subtracted from a value determined by threshold_type, and split into intervals of size period. Half of the interval is a 0 bit, the other half a 1. cCs |jSr#r0r1rrrr3Ar4zIndexIVFSpectralHash.cCs |j|Sr#r0r5rrrr3Ar4r7r8z" transformation from d to nbit dimz own the vtz# nb of bits of the binary signaturez interval size for 0s and 1szH Trained threshold. size nlist * nbit or 0 if Thresh_global cGst|tj|dSr#)rZIndexIVFSpectralHash_swiginitZnew_IndexIVFSpectralHashrQrrrr?UszIndexIVFSpectralHash.__init__cCst||||Sr#)rZ"IndexIVFSpectralHash_train_encoderrvrrrrwXsz"IndexIVFSpectralHash.train_encoderFcCst||||||Sr#)rZ#IndexIVFSpectralHash_encode_vectorsrrrrru[sz#IndexIVFSpectralHash.encode_vectorscCst|||Sr#)rZ,IndexIVFSpectralHash_get_InvertedListScannerrzrrrr{^sz,IndexIVFSpectralHash.get_InvertedListScannercGstj|g|RS)a *Overload 1:* replace the vector transform for an empty (and possibly untrained) index | *Overload 2:* convenience function to get the VT from an index constucted by an index_factory (should end in "LSH") | *Overload 3:* convenience function to get the VT from an index constucted by an index_factory (should end in "LSH") )rZIndexIVFSpectralHash_replace_vtrQrrr replace_vtaszIndexIVFSpectralHash.replace_vtN)F)*r r r,r-rrrrrZIndexIVFSpectralHash_vt_getZIndexIVFSpectralHash_vt_setrZ#IndexIVFSpectralHash_own_fields_getZ#IndexIVFSpectralHash_own_fields_setrZIndexIVFSpectralHash_nbit_getZIndexIVFSpectralHash_nbit_setrZIndexIVFSpectralHash_period_getZIndexIVFSpectralHash_period_setZperiodZ"IndexIVFSpectralHash_Thresh_globalZ Thresh_globalZ$IndexIVFSpectralHash_Thresh_centroidZThresh_centroidZ)IndexIVFSpectralHash_Thresh_centroid_halfZThresh_centroid_halfZ"IndexIVFSpectralHash_Thresh_medianZ Thresh_medianZ'IndexIVFSpectralHash_threshold_type_getZ'IndexIVFSpectralHash_threshold_type_setZthreshold_typeZ IndexIVFSpectralHash_trained_getZ IndexIVFSpectralHash_trained_setrr?rwrur{rZdelete_IndexIVFSpectralHashrTrrrrr6s&  rc@seZdZdZeddddddZeZeej ej Z eej ej ZddZd d Zd d ZdddZddZddZddZejZdS)IndexIVFAdditiveQuantizerz] Abstract class for IVF additive quantizers. The search functions are in common. cCs |jSr#r0r1rrrr3}r4z"IndexIVFAdditiveQuantizer.cCs |j|Sr#r0r5rrrr3}r4r7r8cGst|tj|dSr#)rZ"IndexIVFAdditiveQuantizer_swiginitZnew_IndexIVFAdditiveQuantizerrQrrrr?sz"IndexIVFAdditiveQuantizer.__init__cCst||||Sr#)rZ'IndexIVFAdditiveQuantizer_train_encoderrvrrrrwsz'IndexIVFAdditiveQuantizer.train_encodercCs t|Sr#)rZ3IndexIVFAdditiveQuantizer_train_encoder_num_vectorsr@rrrrxsz3IndexIVFAdditiveQuantizer.train_encoder_num_vectorsFcCst||||||Sr#)rZ(IndexIVFAdditiveQuantizer_encode_vectorsrrrrrusz(IndexIVFAdditiveQuantizer.encode_vectorscCst|||Sr#)rZ1IndexIVFAdditiveQuantizer_get_InvertedListScannerrzrrrr{sz1IndexIVFAdditiveQuantizer.get_InvertedListScannercCst||||Sr#)rZ#IndexIVFAdditiveQuantizer_sa_decoderrBrr2rrrrsz#IndexIVFAdditiveQuantizer.sa_decodecCst||||Sr#)rZ1IndexIVFAdditiveQuantizer_reconstruct_from_offsetrrrrrsz1IndexIVFAdditiveQuantizer.reconstruct_from_offsetN)F)r r r,r-rrrrrZ IndexIVFAdditiveQuantizer_aq_getZ IndexIVFAdditiveQuantizer_aq_setrZ3IndexIVFAdditiveQuantizer_use_precomputed_table_getZ3IndexIVFAdditiveQuantizer_use_precomputed_table_setuse_precomputed_tabler?rwrxrur{rrZ delete_IndexIVFAdditiveQuantizerrTrrrrrws rc@sJeZdZdZeddddddZeZeej ej ddZ dd Z ej Zd S) IndexIVFResidualQuantizerv IndexIVF based on a residual quantizer. Stored vectors are approximated by residual quantization codes. cCs |jSr#r0r1rrrr3r4z"IndexIVFResidualQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8rcGst|tj|dSr#)rZ"IndexIVFResidualQuantizer_swiginitZnew_IndexIVFResidualQuantizerrQrrrr?sz"IndexIVFResidualQuantizer.__init__N)r r r,r-rrrrrZ IndexIVFResidualQuantizer_rq_getZ IndexIVFResidualQuantizer_rq_setr%r?Z delete_IndexIVFResidualQuantizerrTrrrrrs rc@sJeZdZdZeddddddZeZeej ej ddZ dd Z ej Zd S) IndexIVFLocalSearchQuantizerrcCs |jSr#r0r1rrrr3r4z%IndexIVFLocalSearchQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8z- The LSQ quantizer used to encode the vectorscGst|tj|dSr#)rZ%IndexIVFLocalSearchQuantizer_swiginitZ new_IndexIVFLocalSearchQuantizerrQrrrr?sz%IndexIVFLocalSearchQuantizer.__init__N)r r r,r-rrrrrZ$IndexIVFLocalSearchQuantizer_lsq_getZ$IndexIVFLocalSearchQuantizer_lsq_setrSr?Z#delete_IndexIVFLocalSearchQuantizerrTrrrrrs rc@sJeZdZdZeddddddZeZeej ej ddZ dd Z ej Zd S) IndexIVFProductResidualQuantizerz IndexIVF based on a product residual quantizer. Stored vectors are approximated by product residual quantization codes. cCs |jSr#r0r1rrrr3r4z)IndexIVFProductResidualQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8rcGst|tj|dSr#)rZ)IndexIVFProductResidualQuantizer_swiginitZ$new_IndexIVFProductResidualQuantizerrQrrrr?sz)IndexIVFProductResidualQuantizer.__init__N)r r r,r-rrrrrZ(IndexIVFProductResidualQuantizer_prq_getZ(IndexIVFProductResidualQuantizer_prq_setrr?Z'delete_IndexIVFProductResidualQuantizerrTrrrrrs rc@sJeZdZdZeddddddZeZeej ej ddZ dd Z ej Zd S) #IndexIVFProductLocalSearchQuantizerz IndexIVF based on a product local search quantizer. Stored vectors are approximated by product local search quantization codes. cCs |jSr#r0r1rrrr3r4z,IndexIVFProductLocalSearchQuantizer.cCs |j|Sr#r0r5rrrr3r4r7r8rcGst|tj|dSr#)rZ,IndexIVFProductLocalSearchQuantizer_swiginitZ'new_IndexIVFProductLocalSearchQuantizerrQrrrr?sz,IndexIVFProductLocalSearchQuantizer.__init__N)r r r,r-rrrrrZ,IndexIVFProductLocalSearchQuantizer_plsq_getZ,IndexIVFProductLocalSearchQuantizer_plsq_setrr?Z*delete_IndexIVFProductLocalSearchQuantizerrTrrrrrs rc@s^eZdZeddddddZeZeejej Z eej ej Z eejejZejZddZdS) SearchParametersHNSWcCs |jSr#r0r1rrrr3r4zSearchParametersHNSW.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZSearchParametersHNSW_swiginitZnew_SearchParametersHNSWr@rrrr?szSearchParametersHNSW.__init__N)r r r,rrrrrZ!SearchParametersHNSW_efSearch_getZ!SearchParametersHNSW_efSearch_setefSearchZ0SearchParametersHNSW_check_relative_distance_getZ0SearchParametersHNSW_check_relative_distance_setcheck_relative_distanceZ&SearchParametersHNSW_bounded_queue_getZ&SearchParametersHNSW_bounded_queue_setZ bounded_queueZdelete_SearchParametersHNSWrTr?rrrrrsrc@seZdZeddddddZeZeejej ddZ eej ej ddZ eejejddZeejejd dZeejejd dZeejejd dZeejejZeejejd dZeej ej!d dZ"eej#ej$ddZ%eej&ej'ddZ(eej)ej*ddZ+ddZ,ddZ-ddZ.ddZ/ddZ0d8ddZ1ddZ2d d!Z3d9d#d$Z4d:d%d&Z5d;d(d)Z6dd4d5Z=d6d7Z>ej?Z@d'S)?HNSWcCs |jSr#r0r1rrrr3r4z HNSW.cCs |j|Sr#r0r5rrrr3r4r7r8z- assignment probability to each layer (sum=1)zf number of neighbors stored per layer (cumulative), should not be changed after first add z5 level of each vector (base level = 1), size = ntotalzf offsets[i] is the offset in the neighbors array where vector i is stored size ntotal + 1 z neighbors[offsets[i]:offsets[i+1]] is the list of neighbors of vector i for all levels. this is where all storage goes. zW entry point in the search structure (one of the points with maximum level z maximum levelz& expansion factor at construction timez expansion factor at search timezW during search: do we check whether the next best distance is good enough? z% use bounded queue during explorationcCst|||S)z initialize the assign_probas and cum_nneighbor_per_level to have 2*M links on level 0 and M links on levels > 0 )rZHNSW_set_default_probas)rrZ levelMultrrrset_default_probasszHNSW.set_default_probascCst|||S)z< set nb of neighbors for this level (before adding anything))rZHNSW_set_nb_neighbors)rZlevel_norBrrrset_nb_neighbors szHNSW.set_nb_neighborscCs t||S)z nb of neighbors for this level)rZHNSW_nb_neighborsrlayer_norrr nb_neighborsszHNSW.nb_neighborscCs t||S)z0 cumumlative nb up to (and excluding) this level)rZHNSW_cum_nb_neighborsrrrrcum_nb_neighborsszHNSW.cum_nb_neighborscCst|||||S)zA range of entries in the neighbors table of vertex no at layer_no)rZHNSW_neighbor_range)rrNrbeginendrrrneighbor_rangeszHNSW.neighbor_range cCst|t|dS)z* only mandatory parameter: nb of neighborsN)rZ HNSW_swiginitZnew_HNSW)rrrrrr?sz HNSW.__init__cCs t|S)z$ pick a random level for a new point)rZHNSW_random_levelr@rrr random_level!szHNSW.random_levelcCs t||S)z0 add n random levels to table (for debugging...))rZHNSW_fill_with_random_linksrArrrfill_with_random_links%szHNSW.fill_with_random_linksFc Cst||||||||| Sr#)rZHNSW_add_links_starting_from) rptdispt_idnearest d_nearestlevellocksrkeep_max_size_level0rrradd_links_starting_from)szHNSW.add_links_starting_fromc Cst|||||||S)zk add point pt_id on all levels <= pt_level and build the link structure for them. )rZHNSW_add_with_locks)rrZpt_levelrrrrrrradd_with_locks,szHNSW.add_with_locksNcCst|||||S)z, search interface for 1 point, single thread)rZ HNSW_search)rqdisrrrtrrrru3sz HNSW.searchc Cst|||||||||| S)z+ search only in level 0 from a given vertex)rZHNSW_search_level_0) rrrrcZ nearest_i nearest_drZ search_statsrrtrrrsearch_level_07szHNSW.search_level_0cCs t|Sr#)rZ HNSW_resetr@rrrr|;sz HNSW.resetcCs t||Sr#)rZHNSW_clear_neighbor_tablesrrrrrclear_neighbor_tables>szHNSW.clear_neighbor_tablescCs t||Sr#)rZHNSW_print_neighbor_statsrrrrprint_neighbor_statsAszHNSW.print_neighbor_statscCst|||Sr#)rZHNSW_prepare_level_tab)rrBZ preset_levelsrrrprepare_level_tabDszHNSW.prepare_level_tabcCst|||||Sr#)rZHNSW_shrink_neighbor_list)rinputoutputmax_sizerrrrshrink_neighbor_listGszHNSW.shrink_neighbor_listcCs t||Sr#)rZHNSW_permute_entriesr$rrrrKszHNSW.permute_entries)r)F)F)N)N)F)F)Ar r r,rrrrrZHNSW_assign_probas_getZHNSW_assign_probas_setZ assign_probasZ HNSW_cum_nneighbor_per_level_getZ HNSW_cum_nneighbor_per_level_setZcum_nneighbor_per_levelZHNSW_levels_getZHNSW_levels_setZlevelsZHNSW_offsets_getZHNSW_offsets_setoffsetsZHNSW_neighbors_getZHNSW_neighbors_set neighborsZHNSW_entry_point_getZHNSW_entry_point_set entry_pointZ HNSW_rng_getZ HNSW_rng_setrngZHNSW_max_level_getZHNSW_max_level_setZ max_levelZHNSW_efConstruction_getZHNSW_efConstruction_setZefConstructionZHNSW_efSearch_getZHNSW_efSearch_setrZ HNSW_check_relative_distance_getZ HNSW_check_relative_distance_setrZHNSW_search_bounded_queue_getZHNSW_search_bounded_queue_setZsearch_bounded_queuerrrrrr?rrrrrurr|rrrrrrZ delete_HNSWrTrrrrrsD       rc@seZdZeddddddZeZeejej Z eej ej ddZ eejejddZeejejddZd d Zd d Zd dZejZdS) HNSWStatscCs |jSr#r0r1rrrr3Rr4zHNSWStats.cCs |j|Sr#r0r5rrrr3Rr4r7r8z number of vectors searchedz< number of queries for which the candidate list is exhaustedz number of distances computedcCs t|S)z- number of hops aka number of edges traversed)rZHNSWStats_resetr@rrrr|YszHNSWStats.resetcCs t||Sr#)rZHNSWStats_combiner^rrrcombine]szHNSWStats.combinecCst|tdSr#)rZHNSWStats_swiginitZ new_HNSWStatsr@rrrr?`szHNSWStats.__init__N)r r r,rrrrrZHNSWStats_n1_getZHNSWStats_n1_setrZHNSWStats_n2_getZHNSWStats_n2_setrZHNSWStats_ndis_getZHNSWStats_ndis_setrZHNSWStats_nhops_getZHNSWStats_nhops_setZnhopsr|rr?Zdelete_HNSWStatsrTrrrrrQsrc Cst||||||||| Sr#)rsearch_from_candidates) hnswrr candidatesrrirZnres_inrtrrrrgsrcCst|||||Sr#)rgreedy_update_nearest)rrrrrrrrrjsrcCst||||||Sr#)rsearch_from_candidate_unbounded)rnoderZefrrirrrrmsrc Cst||||||||Sr#)rsearch_neighbors_to_add)rrresultsrZ d_entry_pointrrZreference_versionrrrrpsrc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZeejejZddZejZd d Zd d Zd'ddZd(ddZddZddZ ddZ!d)ddZ"ddZ#ddZ$dd Z%d!d"Z&d#d$Z'd%d&Z(d S)* IndexHNSWe The HNSW index is a normal random-access index with a HNSW link structure built on top cCs |jSr#r0r1rrrr3xr4zIndexHNSW.cCs |j|Sr#r0r5rrrr3xr4r7r8cGst|tj|dSr#)rZIndexHNSW_swiginitZ new_IndexHNSWrQrrrr?szIndexHNSW.__init__cCst|||Sr#)rZ IndexHNSW_addrmrrrrosz IndexHNSW.addcCst|||Sz Trains the storage if needed)rZIndexHNSW_trainrmrrrrnszIndexHNSW.trainNc Cst|||||||Sz entry point for search)rZIndexHNSW_searchrsrrrruszIndexHNSW.searchcCst||||||Sr#)rZIndexHNSW_range_searchrvrrrrwszIndexHNSW.range_searchcCst|||Sr#)rZIndexHNSW_reconstructr|rrrrszIndexHNSW.reconstructcCs t|Sr#)rZIndexHNSW_resetr@rrrr|szIndexHNSW.resetcCs t||Sr#)rZ"IndexHNSW_shrink_level_0_neighborsrr[rrrshrink_level_0_neighborssz"IndexHNSW.shrink_level_0_neighborsrc Cst|||||||||| | S)a Perform search only on level 0, given the starting points for each vertex. :type search_type: int, optional :param search_type: 1:perform one search per nprobe, 2: enqueue all entry points )rZIndexHNSW_search_level_0) rrBr2rrrrrrcrrtrrrrs zIndexHNSW.search_level_0cCst||||Sz alternative graph building)rZ$IndexHNSW_init_level_0_from_knngraph)rrrrrrrinit_level_0_from_knngraphsz$IndexHNSW.init_level_0_from_knngraphcCst||||Sr)rZ(IndexHNSW_init_level_0_from_entry_points)rZnptZpointsZnearestsrrrinit_level_0_from_entry_pointssz(IndexHNSW.init_level_0_from_entry_pointscCs t|Sr#)rZIndexHNSW_reorder_linksr@rrr reorder_linksszIndexHNSW.reorder_linkscCs t|Sr#)rZIndexHNSW_link_singletonsr@rrrlink_singletonsszIndexHNSW.link_singletonscCs t||Sr#)rZIndexHNSW_permute_entriesrrrrrszIndexHNSW.permute_entriescCs t|Sr#)rZIndexHNSW_get_distance_computerr@rrrrszIndexHNSW.get_distance_computer)N)N)rrN))r r r,r-rrrrrZIndexHNSW_hnsw_getZIndexHNSW_hnsw_setrZIndexHNSW_own_fields_getZIndexHNSW_own_fields_setrZIndexHNSW_storage_getZIndexHNSW_storage_setstorageZIndexHNSW_init_level0_getZIndexHNSW_init_level0_setZ init_level0Z"IndexHNSW_keep_max_size_level0_getZ"IndexHNSW_keep_max_size_level0_setrr?Zdelete_IndexHNSWrTrornrurwrr|rrrrrrrrrrrrrrs0   rc@s8eZdZdZeddddddZeZddZe j Z d S) IndexHNSWFlatz_ Flat index topped with with a HNSW structure to access elements more efficiently. cCs |jSr#r0r1rrrr3r4zIndexHNSWFlat.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexHNSWFlat_swiginitZnew_IndexHNSWFlatrQrrrr?szIndexHNSWFlat.__init__N) r r r,r-rrrrr?rZdelete_IndexHNSWFlatrTrrrrrs rc@s@eZdZdZeddddddZeZddZd d Z e j Z d S) IndexHNSWPQz] PQ index topped with with a HNSW structure to access elements more efficiently. cCs |jSr#r0r1rrrr3r4zIndexHNSWPQ.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexHNSWPQ_swiginitZnew_IndexHNSWPQrQrrrr?szIndexHNSWPQ.__init__cCst|||Sr#)rZIndexHNSWPQ_trainrmrrrrnszIndexHNSWPQ.trainN) r r r,r-rrrrr?rnrZdelete_IndexHNSWPQrTrrrrrs rc@s8eZdZdZeddddddZeZddZe j Z d S) IndexHNSWSQz] SQ index topped with with a HNSW structure to access elements more efficiently. cCs |jSr#r0r1rrrr3r4zIndexHNSWSQ.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexHNSWSQ_swiginitZnew_IndexHNSWSQrQrrrr?szIndexHNSWSQ.__init__N) r r r,r-rrrrr?rZdelete_IndexHNSWSQrTrrrrrs rc@sJeZdZdZeddddddZeZddZd d Z dd d Z e j Z d S)IndexHNSW2Levelz/ 2-level code structure with fast random accesscCs |jSr#r0r1rrrr3r4zIndexHNSW2Level.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexHNSW2Level_swiginitZnew_IndexHNSW2LevelrQrrrr?szIndexHNSW2Level.__init__cCs t|Sr#)rZIndexHNSW2Level_flip_to_ivfr@rrr flip_to_ivfszIndexHNSW2Level.flip_to_ivfNc Cst|||||||Sr)rZIndexHNSW2Level_searchrsrrrruszIndexHNSW2Level.search)N)r r r,r-rrrrr?r rurZdelete_IndexHNSW2LevelrTrrrrrs rc@sjeZdZeddddddZeZddZeej ej ddZ eej ej d dZd d Zdd dZejZd S)IndexHNSWCagracCs |jSr#r0r1rrrr3r4zIndexHNSWCagra.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexHNSWCagra_swiginitZnew_IndexHNSWCagrarQrrrr?szIndexHNSWCagra.__init__a When set to true, the index is immutable. This option is used to copy the knn graph from GpuIndexCagra to the base level of IndexHNSWCagra without adding upper levels. Doing so enables to search the HNSW index, but removes the ability to add vectors. z When `base_level_only` is set to `True`, the search function searches only the base level knn graph of the HNSW index. This parameter selects the entry point by randomly selecting some points and using the best one. cCst|||Sr#)rZIndexHNSWCagra_addrmrrrroszIndexHNSWCagra.addNc Cst|||||||Sr)rZIndexHNSWCagra_searchrsrrrruszIndexHNSWCagra.search)N)r r r,rrrrr?rZ"IndexHNSWCagra_base_level_only_getZ"IndexHNSWCagra_base_level_only_setZbase_level_onlyZ4IndexHNSWCagra_num_base_level_search_entrypoints_getZ4IndexHNSWCagra_num_base_level_search_entrypoints_setZ!num_base_level_search_entrypointsroruZdelete_IndexHNSWCagrarTrrrrr s r cCst||||S)ab SMAWK algorithm. Find the row minima of a monotone matrix. Expose this for testing. :type nrows: int :param nrows: number of rows :type ncols: int :param ncols: number of columns :type x: float :param x: input matrix, size (nrows, ncols) :type argmins: int :param argmins: argmin of each row )rsmawk)ZnrowsZncolsr2Zargminsrrrr sr cCst||||S)u} Exact 1D K-Means by dynamic programming From "Fast Exact k-Means, k-Medians and Bregman Divergence Clustering in 1D" Allan Grønlund, Kasper Green Larsen, Alexander Mathiasen, Jesper Sindahl Nielsen, Stefan Schneider, Mingzhou Song, ArXiV'17 Section 2.2 https://arxiv.org/abs/1701.07204 :type x: float :param x: input 1D array :type n: int :param n: input array length :type nclusters: int :param nclusters: number of clusters :type centroids: float :param centroids: output centroids, size nclusters :rtype: float :return: imbalancce factor )rkmeans1d)r2rBZ nclustersr9rrrr /sr c@sfeZdZeddddddZeZeejej Z eej ej Z eejejZddZdd ZejZd S) NeighborcCs |jSr#r0r1rrrr3Hr4zNeighbor.cCs |j|Sr#r0r5rrrr3Hr4r7r8cGst|tj|dSr#)rZNeighbor_swiginitZ new_NeighborrQrrrr?NszNeighbor.__init__cCs t||Sr#)rZNeighbor___lt__r^rrr__lt__QszNeighbor.__lt__N)r r r,rrrrrZNeighbor_id_getZNeighbor_id_setrZNeighbor_distance_getZNeighbor_distance_setrFZNeighbor_flag_getZNeighbor_flag_setflagr?rZdelete_NeighborrTrrrrr Gsr c@seZdZeddddddZeZeejej Z eej ej Z eejejZeejejZeejejZeejejZddZdd ZejZd S) NhoodcCs |jSr#r0r1rrrr3Xr4zNhood.cCs |j|Sr#r0r5rrrr3Xr4r7r8cGst|tj|dSr#)rZNhood_swiginitZ new_NhoodrQrrrr?aszNhood.__init__cCst|||Sr#)rZ Nhood_insert)rrdistrrrrdsz Nhood.insertN)r r r,rrrrrZNhood_pool_getZNhood_pool_setr*Z Nhood_M_getZ Nhood_M_setrZNhood_nn_old_getZNhood_nn_old_setZnn_oldZNhood_nn_new_getZNhood_nn_new_setZnn_newZNhood_rnn_old_getZNhood_rnn_old_setZrnn_oldZNhood_rnn_new_getZNhood_rnn_new_setZrnn_newr?rZ delete_NhoodrTrrrrrWsrc@s$eZdZeddddddZeZddZej Z dd Z d d Z d d Z ddZddZddZddZddZddZeejejZeejejZeejejZeejejZeej ej!Z"eej#ej$Z%eej&ej'Z(eej)ej*Z+eej,ej-Z.eej/ej0Z1eej2ej3Z4eej5ej6Z7dS) NNDescentcCs |jSr#r0r1rrrr3kr4zNNDescent.cCs |j|Sr#r0r5rrrr3kr4r7r8cCst|t||dSr#)rZNNDescent_swiginitZ new_NNDescent)rrrLrrrr?nszNNDescent.__init__cCst||||Sr#)rZNNDescent_build)rrrBrrrrbuildrszNNDescent.buildcCst||||||Sr#)rZNNDescent_search)rrZtopkindicesdistsrrrrruuszNNDescent.searchcCs t|Sr#)rZNNDescent_resetr@rrrr|xszNNDescent.resetcCs t||S)z" Initialize the KNN graph randomly)rZNNDescent_init_graphrrrrr init_graph{szNNDescent.init_graphcCst|||S)z Perform NNDescent algorithm)rZNNDescent_nndescent)rrrrrr nndescentszNNDescent.nndescentcCs t||S)z Perform local join on each node)rZNNDescent_joinrrrrjoinszNNDescent.joincCs t|S)z> Sample new neighbors for each node to peform local join later)rZNNDescent_updater@rrrupdateszNNDescent.updatecCst|||||S)zF Sample a small number of points to evaluate the quality of KNNG built)rZNNDescent_generate_eval_set)rrr%r6Nrrrgenerate_eval_setszNNDescent.generate_eval_setcCst|||S)z# Evaluate the quality of KNNG built)rZNNDescent_eval_recall)rZ ctrl_pointsZ acc_eval_setrrr eval_recallszNNDescent.eval_recallN)8r r r,rrrrr?rZdelete_NNDescentrTrrur|rrrrrrZNNDescent_has_built_getZNNDescent_has_built_setZ has_builtZNNDescent_S_getZNNDescent_S_setSZNNDescent_R_getZNNDescent_R_setRZNNDescent_iter_getZNNDescent_iter_setiterZNNDescent_search_L_getZNNDescent_search_L_setsearch_LZNNDescent_random_seed_getZNNDescent_random_seed_setrPZNNDescent_K_getZNNDescent_K_setrLZNNDescent_d_getZNNDescent_d_setrZNNDescent_L_getZNNDescent_L_setLZNNDescent_ntotal_getZNNDescent_ntotal_setrZNNDescent_graph_getZNNDescent_graph_setgraphZNNDescent_final_graph_getZNNDescent_final_graph_set final_graphrrrrrjs2rc@seZdZdZeddddddZeZeej ej ddZ eej ej ZeejejZdd ZejZd d Zd d ZdddZddZddZdS)IndexNNDescentzp The NNDescent index is a normal random-access index with an NNDescent link structure built on top cCs |jSr#r0r1rrrr3r4zIndexNNDescent.cCs |j|Sr#r0r5rrrr3r4r7r8z Faiss results are 64-bitcGst|tj|dSr#)rZIndexNNDescent_swiginitZnew_IndexNNDescentrQrrrr?szIndexNNDescent.__init__cCst|||Sr#)rZIndexNNDescent_addrmrrrroszIndexNNDescent.addcCst|||Sr)rZIndexNNDescent_trainrmrrrrnszIndexNNDescent.trainNc Cst|||||||Sr)rZIndexNNDescent_searchrsrrrruszIndexNNDescent.searchcCst|||Sr#)rZIndexNNDescent_reconstructr|rrrrszIndexNNDescent.reconstructcCs t|Sr#)rZIndexNNDescent_resetr@rrrr|szIndexNNDescent.reset)N)r r r,r-rrrrrZIndexNNDescent_nndescent_getZIndexNNDescent_nndescent_setrZIndexNNDescent_own_fields_getZIndexNNDescent_own_fields_setrZIndexNNDescent_storage_getZIndexNNDescent_storage_setrr?Zdelete_IndexNNDescentrTrornrurr|rrrrr%s r%c@s8eZdZdZeddddddZeZddZe j Z d S) IndexNNDescentFlatzd Flat index topped with with a NNDescent structure to access elements more efficiently. cCs |jSr#r0r1rrrr3r4zIndexNNDescentFlat.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexNNDescentFlat_swiginitZnew_IndexNNDescentFlatrQrrrr?szIndexNNDescentFlat.__init__N) r r r,r-rrrrr?rZdelete_IndexNNDescentFlatrTrrrrr&s r&c@sdeZdZdZeddddddZeZddd Zdd d Z d dZ ddZ ddZ ddZ ejZdS) IndexIVFFlatz Inverted file with stored vectors. Here the inverted file pre-selects the vectors to be searched, but they are not otherwise encoded, the code array just contains the raw float entries. cCs |jSr#r0r1rrrr3r4zIndexIVFFlat.cCs |j|Sr#r0r5rrrr3r4r7r8NcCst||||||Sr#)rZIndexIVFFlat_add_corerprrrrrszIndexIVFFlat.add_coreFcCst||||||Sr#)rZIndexIVFFlat_encode_vectorsrrrrruszIndexIVFFlat.encode_vectorscCst|||Sr#)rZ$IndexIVFFlat_get_InvertedListScannerrzrrrr{sz$IndexIVFFlat.get_InvertedListScannercCst||||Sr#)rZ$IndexIVFFlat_reconstruct_from_offsetrrrrrsz$IndexIVFFlat.reconstruct_from_offsetcCst||||Sr#)rZIndexIVFFlat_sa_decoderrrrrszIndexIVFFlat.sa_decodecGst|tj|dSr#)rZIndexIVFFlat_swiginitZnew_IndexIVFFlatrQrrrr?szIndexIVFFlat.__init__)N)F)r r r,r-rrrrrrrur{rrr?rZdelete_IndexIVFFlatrTrrrrr's  r'c@seZdZeddddddZeZeejej ddZ ddZ d d Z dd d Z ddZdddZddZddZddZejZd S)IndexIVFFlatDedupcCs |jSr#r0r1rrrr3r4zIndexIVFFlatDedup.cCs |j|Sr#r0r5rrrr3r4r7r8z Maps ids stored in the index to the ids of vectors that are the same. When a vector is unique, it does not appear in the instances map cCst|||S)z also dedups the training set)rZIndexIVFFlatDedup_trainrmrrrrnszIndexIVFFlatDedup.traincCst||||S)z& implemented for all IndexIVF* classes)rZIndexIVFFlatDedup_add_with_idsrprrrrrszIndexIVFFlatDedup.add_with_idsNc Cst|||||||||| | Sr#)rZ$IndexIVFFlatDedup_search_preassignedrfrrrrjsz$IndexIVFFlatDedup.search_preassignedcCs t||Sr#)rZIndexIVFFlatDedup_remove_idsrzrrrr{szIndexIVFFlatDedup.remove_idscCst||||||SrB)rZIndexIVFFlatDedup_range_searchrvrrrrw szIndexIVFFlatDedup.range_searchcCst||||SrB)rZ IndexIVFFlatDedup_update_vectorsr|rrrr~ sz IndexIVFFlatDedup.update_vectorscCst||||SrB)rZ)IndexIVFFlatDedup_reconstruct_from_offsetrrrrrsz)IndexIVFFlatDedup.reconstruct_from_offsetcGst|tj|dSr#)rZIndexIVFFlatDedup_swiginitZnew_IndexIVFFlatDeduprQrrrr?szIndexIVFFlatDedup.__init__)NN)N)r r r,rrrrrZIndexIVFFlatDedup_instances_getZIndexIVFFlatDedup_instances_setZ instancesrnrrrjr{rwr~rr?Zdelete_IndexIVFFlatDeduprTrrrrr(s  r(cCs t|Sr#)rstorage_distance_computer)rrrrr)sr)c@s8eZdZeddddddZeZeejej ddZ eej ej ddZ eejejddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZeej ej!ddZ"d+ddZ#ddZ$ddZ%ddZ&ddZ'ddZ(ddZ)ddZ*d d!Z+d"d#Z,d$d%Z-d&d'Z.d(d)Z/ej0Z1d*S),NSGcCs |jSr#r0r1rrrr3r4z NSG.cCs |j|Sr#r0r5rrrr3r4r7r8z nb of nodes nb of neighbors per nodez/ length of the search path at construction timez) candidate pool size at construction timez length of the search pathz enterpointz NSG graph structurez NSG is built or notz random generatorrcCst|t|dSr#)rZ NSG_swiginitZnew_NSG)rrrrrr?+sz NSG.__init__cCst|||||Sr#)rZ NSG_build)rrrB knn_graphrrrrr.sz NSG.buildcCs t|Sr#)rZ NSG_resetr@rrrr|1sz NSG.resetcCst||||||Sr#)rZ NSG_search)rrrrrrrrrru4sz NSG.searchcCst|||Sr#)rZNSG_init_graph)rrr,rrrr7szNSG.init_graphcCst|||||Sr#)rZNSG_add_reverse_links)rqrrr#rrradd_reverse_links:szNSG.add_reverse_linksc Cst|||||||Sr#)rZNSG_sync_prune)rr-r*rrr,r#rrr sync_prune=szNSG.sync_prunecCst|||||Sr#)rZNSG_link)rrr,r#rrrrlink@szNSG.linkcCst|||Sr#)rZ NSG_tree_grow)rrdegreesrrr tree_growCsz NSG.tree_growcCst||||Sr#)rZNSG_dfs)rrrootZcntrrrdfsFszNSG.dfscCst|||||Sr#)rZNSG_attach_unlinked)rrrZvt2r1rrrattach_unlinkedIszNSG.attach_unlinkedcCs t|Sr#)rZNSG_check_graphr@rrr check_graphLszNSG.check_graphcCs t|Sr#)rZNSG_get_final_graphr@rrrget_final_graphOszNSG.get_final_graphN)r)2r r r,rrrrrZNSG_ntotal_getZNSG_ntotal_setrZ NSG_R_getZ NSG_R_setrZ NSG_L_getZ NSG_L_setr"Z NSG_C_getZ NSG_C_setCZNSG_search_L_getZNSG_search_L_setr!ZNSG_enterpoint_getZNSG_enterpoint_setZ enterpointZNSG_final_graph_getZNSG_final_graph_setr$ZNSG_is_built_getZNSG_is_built_setis_builtZ NSG_rng_getZ NSG_rng_setrr?rr|rurr.r/r0r2r4r5r6r7Z delete_NSGrTrrrrr*s2 r*c@seZdZeddddddZeZeejej ddZ eej ej ddZ eejejddZeejejd dZd d ZejZd d ZddZdS) NSG_Graph_intcCs |jSr#r0r1rrrr3Vr4zNSG_Graph_int.cCs |j|Sr#r0r5rrrr3Vr4r7r8z, the flattened adjacency matrix, size N-by-Kr+z total nb of nodesz+ the underlying data owned by itself or notcGst|tj|dSr#)rZNSG_Graph_int_swiginitZnew_NSG_Graph_intrQrrrr?]szNSG_Graph_int.__init__cGstj|g|RSr#)rZNSG_Graph_int_atrQrrrr\aszNSG_Graph_int.atcCst|||Sr#)rZNSG_Graph_int_get_neighbors)rrrrrr get_neighborsdszNSG_Graph_int.get_neighborsN)r r r,rrrrrZNSG_Graph_int_data_getZNSG_Graph_int_data_setrZZNSG_Graph_int_K_getZNSG_Graph_int_K_setrLZNSG_Graph_int_N_getZNSG_Graph_int_N_setrZNSG_Graph_int_own_fields_getZNSG_Graph_int_own_fields_setrr?Zdelete_NSG_Graph_intrTr\r;rrrrr:Usr:c@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejZeejejd dZeejejd dZeejejd dZeejejd dZeejejZ eej!ej"Z#eej$ej%Z&d dZ'ej(Z)ddZ*ddZ+ddZ,dddZ-ddZ.ddZ/ddZ0dS)IndexNSGzc The NSG index is a normal random-access index with a NSG link structure built on top cCs |jSr#r0r1rrrr3or4zIndexNSG.cCs |j|Sr#r0r5rrrr3or4r7r8z the link structurez the sequential storagez the index is built or notz K of KNN graph for buildingzx indicate how to build a knn graph - 0: build NSG with brute force search - 1: build NSG with NNDescent z parameters for nndescentcGst|tj|dSr#)rZIndexNSG_swiginitZ new_IndexNSGrQrrrr?szIndexNSG.__init__cCst|||||Sr#)rZIndexNSG_build)rrBr2r,GKrrrrszIndexNSG.buildcCst|||Sr#)rZ IndexNSG_addrmrrrrosz IndexNSG.addcCst|||Sr)rZIndexNSG_trainrmrrrrnszIndexNSG.trainNc Cst|||||||Sr)rZIndexNSG_searchrsrrrruszIndexNSG.searchcCst|||Sr#)rZIndexNSG_reconstructr|rrrrszIndexNSG.reconstructcCs t|Sr#)rZIndexNSG_resetr@rrrr|szIndexNSG.resetcCst||||Sr#)rZIndexNSG_check_knn_graph)rr,rBrLrrrcheck_knn_graphszIndexNSG.check_knn_graph)N)1r r r,r-rrrrrZIndexNSG_nsg_getZIndexNSG_nsg_setZnsgZIndexNSG_own_fields_getZIndexNSG_own_fields_setrZIndexNSG_storage_getZIndexNSG_storage_setrZIndexNSG_is_built_getZIndexNSG_is_built_setr9ZIndexNSG_GK_getZIndexNSG_GK_setr=ZIndexNSG_build_type_getZIndexNSG_build_type_setZ build_typeZIndexNSG_nndescent_S_getZIndexNSG_nndescent_S_setZ nndescent_SZIndexNSG_nndescent_R_getZIndexNSG_nndescent_R_setZ nndescent_RZIndexNSG_nndescent_L_getZIndexNSG_nndescent_L_setZ nndescent_LZIndexNSG_nndescent_iter_getZIndexNSG_nndescent_iter_setZnndescent_iterr?Zdelete_IndexNSGrTrrornrurr|r>rrrrr<is, r<c@s8eZdZdZeddddddZeZddZe j Z d S) IndexNSGFlatz^ Flat index topped with with a NSG structure to access elements more efficiently. cCs |jSr#r0r1rrrr3r4zIndexNSGFlat.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexNSGFlat_swiginitZnew_IndexNSGFlatrQrrrr?szIndexNSGFlat.__init__N) r r r,r-rrrrr?rZdelete_IndexNSGFlatrTrrrrr?s r?c@s@eZdZdZeddddddZeZddZd d Z e j Z d S) IndexNSGPQz\ PQ index topped with with a NSG structure to access elements more efficiently. cCs |jSr#r0r1rrrr3r4zIndexNSGPQ.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexNSGPQ_swiginitZnew_IndexNSGPQrQrrrr?szIndexNSGPQ.__init__cCst|||Sr#)rZIndexNSGPQ_trainrmrrrrnszIndexNSGPQ.trainN) r r r,r-rrrrr?rnrZdelete_IndexNSGPQrTrrrrr@s r@c@s8eZdZdZeddddddZeZddZe j Z d S) IndexNSGSQz\ SQ index topped with with a NSG structure to access elements more efficiently. cCs |jSr#r0r1rrrr3r4zIndexNSGSQ.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZIndexNSGSQ_swiginitZnew_IndexNSGSQrQrrrr?szIndexNSGSQ.__init__N) r r r,r-rrrrr?rZdelete_IndexNSGSQrTrrrrrAs rAc@s^eZdZeddddddZeZeejej Z eej ej Z eejejZddZejZdS) OnDiskOneListcCs |jSr#r0r1rrrr3r4zOnDiskOneList.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZOnDiskOneList_swiginitZnew_OnDiskOneListr@rrrr?szOnDiskOneList.__init__N)r r r,rrrrrZOnDiskOneList_size_getZOnDiskOneList_size_setr[ZOnDiskOneList_capacity_getZOnDiskOneList_capacity_setcapacityZOnDiskOneList_offset_getZOnDiskOneList_offset_setrr?Zdelete_OnDiskOneListrTrrrrrBsrBc@s:eZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZeejejZeejejZddZd d Zd d Zd dZddZddZ d+ddZ!d,ddZ"ddZ#ddZ$ej%Z&eej'ej(Z)eej*ej+Z,eej-ej.Z/ddZ0ddZ1d d!Z2d"d#Z3d$d%Z4d&d'Z5d(d)Z6d*S)-OnDiskInvertedListsa. On-disk storage of inverted lists. The data is stored in a mmapped chunk of memory (base pointer ptr, size totsize). Each list is a range of memory that contains (object List) that contains: - uint8_t codes[capacity * code_size] - followed by idx_t ids[capacity] in each of the arrays, the size <= capacity first elements are used, the rest is not initialized. Addition and resize are supported by: - roundind up the capacity of the lists to a power of two - maintaining a list of empty slots, sorted by size. - resizing the mmapped block is adjusted as needed. An OnDiskInvertedLists is compact if the size == capacity for all lists and there are no available slots. Addition to the invlists is slow. For incremental add it is better to use a default ArrayInvertedLists object and convert it to an OnDisk with merge_from. When it is known that a set of lists will be accessed, it is useful to call prefetch_lists, that launches a set of threads to read the lists in parallel. cCs |jSr#r0r1rrrr3r4zOnDiskInvertedLists.cCs |j|Sr#r0r5rrrr3r4r7r8cCs t||Sr#)rZOnDiskInvertedLists_list_sizerrrrrszOnDiskInvertedLists.list_sizecCs t||Sr#)rZOnDiskInvertedLists_get_codesrrrrrszOnDiskInvertedLists.get_codescCs t||Sr#)rZOnDiskInvertedLists_get_idsrrrrrszOnDiskInvertedLists.get_idscCst|||||Sr#)rZOnDiskInvertedLists_add_entriesrrrrr szOnDiskInvertedLists.add_entriescCst||||||Sr#)rZ"OnDiskInvertedLists_update_entriesrrrrrsz"OnDiskInvertedLists.update_entriescCst|||Sr#)rZOnDiskInvertedLists_resizerrrrr]szOnDiskInvertedLists.resizeFcCst|||||Sr#)rZ'OnDiskInvertedLists_merge_from_multiple)rr+Zn_ilrrrrrmerge_from_multiplesz'OnDiskInvertedLists.merge_from_multiplecCst|||S)z( same as merge_from for a single invlist)rZ OnDiskInvertedLists_merge_from_1)rr-rrrr merge_from_1sz OnDiskInvertedLists.merge_from_1cCst|||S)zI restrict the inverted lists to l0:l1 without touching the mmapped region)rZ!OnDiskInvertedLists_crop_invlists)rZl0l1rrr crop_invlistssz!OnDiskInvertedLists.crop_invlistscCst|||Sr#)rZ"OnDiskInvertedLists_prefetch_listsr rrrrsz"OnDiskInvertedLists.prefetch_listscCs t|Sr#)rZOnDiskInvertedLists_do_mmapr@rrrdo_mmap&szOnDiskInvertedLists.do_mmapcCs t||Sr#)rZ"OnDiskInvertedLists_update_totsize)rZ new_totsizerrrupdate_totsize)sz"OnDiskInvertedLists.update_totsizecCst|||Sr#)rZ!OnDiskInvertedLists_resize_lockedrrrr resize_locked,sz!OnDiskInvertedLists.resize_lockedcCs t||Sr#)rZ!OnDiskInvertedLists_allocate_slot)rrCrrr allocate_slot/sz!OnDiskInvertedLists.allocate_slotcCst|||Sr#)rZOnDiskInvertedLists_free_slot)rrrCrrr free_slot2szOnDiskInvertedLists.free_slotcCs t||S)z2 override all list sizes and make a packed storage)rZ'OnDiskInvertedLists_set_all_lists_sizes)rr7rrrset_all_lists_sizes5sz'OnDiskInvertedLists.set_all_lists_sizescGst|tj|dSr#)rZOnDiskInvertedLists_swiginitZnew_OnDiskInvertedListsrQrrrr?9szOnDiskInvertedLists.__init__N)FF)F)7r r r,r-rrrrrZOnDiskInvertedLists_lists_getZOnDiskInvertedLists_lists_setlistsZOnDiskInvertedLists_slots_getZOnDiskInvertedLists_slots_setslotsZ OnDiskInvertedLists_filename_getZ OnDiskInvertedLists_filename_setfilenameZOnDiskInvertedLists_totsize_getZOnDiskInvertedLists_totsize_setZtotsizeZOnDiskInvertedLists_ptr_getZOnDiskInvertedLists_ptr_setrZ!OnDiskInvertedLists_read_only_getZ!OnDiskInvertedLists_read_only_setZ read_onlyrrrrrr]rErFrHrZdelete_OnDiskInvertedListsrTZOnDiskInvertedLists_locks_getZOnDiskInvertedLists_locks_setrZOnDiskInvertedLists_pf_getZOnDiskInvertedLists_pf_setpfZ(OnDiskInvertedLists_prefetch_nthread_getZ(OnDiskInvertedLists_prefetch_nthread_setZprefetch_nthreadrIrJrKrLrMrNr?rrrrrDs<  rDc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejddZdd Zd d Zd d ZejZdS)ZnSphereSearcha  returns the nearest vertex in the sphere to a query. Returns only the coordinates, not an id. Algorithm: all points are derived from a one atom vector up to a permutation and sign changes. The search function finds the most appropriate atom and transformation. cCs |jSr#r0r1rrrr3Hr4zZnSphereSearch.cCs |j|Sr#r0r5rrrr3Hr4r7r8z size dim * ntatomcCst|t||dSr#)rZZnSphereSearch_swiginitZnew_ZnSphereSearchrrrrrrr?OszZnSphereSearch.__init__cGstj|g|RS)a *Overload 1:* find nearest centroid. x does not need to be normalized | *Overload 2:* full call. Requires externally-allocated temp space | *Overload 3:* full call. Requires externally-allocated temp space )rZZnSphereSearch_searchrQrrrruRszZnSphereSearch.searchcCst|||||Sr#)rZZnSphereSearch_search_multi)rrBr2Zc_outZdp_outrrr search_multicszZnSphereSearch.search_multiN)r r r,r-rrrrrZZnSphereSearch_dimS_getZZnSphereSearch_dimS_setZdimSZZnSphereSearch_r2_getZZnSphereSearch_r2_setrZZnSphereSearch_natom_getZZnSphereSearch_natom_setZnatomZZnSphereSearch_voc_getZZnSphereSearch_voc_setZvocr?rurUZdelete_ZnSphereSearchrTrrrrrS>s rSc@s|eZdZeddddddZddZeZeej ej ddZ eej ej Zd d Zd d Zd dZddZddZejZdS)EnumeratedVectorscCs |jSr#r0r1rrrr3jr4zEnumeratedVectors.cCs |j|Sr#r0r5rrrr3jr4r7r8cOs tddSr:r;r<rrrr?lszEnumeratedVectors.__init__z size of the collectioncCs t||S)z" encode a vector from a collection)rZEnumeratedVectors_encoderErrrrrszEnumeratedVectors.encodecCst|||S)z decode it)rZEnumeratedVectors_decoderrr%rrrrvszEnumeratedVectors.decodecCst||||Sr#)rZEnumeratedVectors_encode_multi)rncr%rrrr encode_multizszEnumeratedVectors.encode_multicCst||||Sr#)rZEnumeratedVectors_decode_multi)rrXrr%rrr decode_multi}szEnumeratedVectors.decode_multic Cst|||||||Sr#)rZEnumeratedVectors_find_nn)rrBrrr rrrrrfind_nnszEnumeratedVectors.find_nnN)r r r,rrr?rrrZEnumeratedVectors_nv_getZEnumeratedVectors_nv_setr}ZEnumeratedVectors_dim_getZEnumeratedVectors_dim_setrrrrYrZr[Zdelete_EnumeratedVectorsrTrrrrrVisrVc@sPeZdZeddddddZeZeejej Z eej ej Z ddZejZdS) RepeatcCs |jSr#r0r1rrrr3r4zRepeat.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|tdSr#)rZRepeat_swiginitZ new_Repeatr@rrrr?szRepeat.__init__N)r r r,rrrrrZRepeat_val_getZRepeat_val_setvalZ Repeat_n_getZ Repeat_n_setrBr?Z delete_RepeatrTrrrrr\s r\c@sneZdZdZeddddddZeZeej ej Z eej ej Zdd d Zd d Zd dZddZejZdS)Repeatsz Repeats: used to encode a vector that has n occurrences of val. Encodes the signs and permutation of the vector. Useful for atoms. cCs |jSr#r0r1rrrr3r4zRepeats.cCs |j|Sr#r0r5rrrr3r4r7r8rNcCst|t||dSr#)rZRepeats_swiginitZ new_Repeats)rrr%rrrr?szRepeats.__init__cCs t|Sr#)rZ Repeats_countr@rrrcountsz Repeats.countcCs t||Sr#)rZRepeats_encoderrrrrszRepeats.encodecCst|||Sr#)rZRepeats_decoderWrrrrszRepeats.decode)rN)r r r,r-rrrrrZRepeats_dim_getZRepeats_dim_setrZRepeats_repeats_getZRepeats_repeats_setZrepeatsr?r_rrZdelete_RepeatsrTrrrrr^s r^c@szeZdZdZeddddddZeZeej ej Z eej ej ZeejejZddZd d Zd d Zd dZejZdS) ZnSphereCodecz codec that can return ids for the encoded vectors uses the ZnSphereSearch to encode the vector by encoding the permutation and signs. Depends on ZnSphereSearch because it uses the atom numbers cCs |jSr#r0r1rrrr3r4zZnSphereCodec.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|t||dSr#)rZZnSphereCodec_swiginitZnew_ZnSphereCodecrTrrrr?szZnSphereCodec.__init__cCs t||Sr#)rZZnSphereCodec_search_and_encoderErrrsearch_and_encodeszZnSphereCodec.search_and_encodecCst|||Sr#)rZZnSphereCodec_decoderWrrrrszZnSphereCodec.decodecCs t||S)z/ takes vectors that do not need to be centroids)rZZnSphereCodec_encoderErrrrszZnSphereCodec.encodeN)r r r,r-rrrrrZZnSphereCodec_code_segments_getZZnSphereCodec_code_segments_setZ code_segmentsZZnSphereCodec_nv_getZZnSphereCodec_nv_setr}ZZnSphereCodec_code_size_getZZnSphereCodec_code_size_setrr?rarrZdelete_ZnSphereCodecrTrrrrr`sr`c@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZddZd d Zd d Zd dZeejejZeejejZeejejZeejej Z!ddZ"ddZ#ddZ$ej%Z&dS)ZnSphereCodecRecz recursive sphere codec Uses a recursive decomposition on the dimensions to encode centroids found by the ZnSphereSearch. The codes are *not* compatible with the ones of ZnSpehreCodec cCs |jSr#r0r1rrrr3r4zZnSphereCodecRec.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|t||dSr#)rZZnSphereCodecRec_swiginitZnew_ZnSphereCodecRecrTrrrr?szZnSphereCodecRec.__init__cCs t||Sr#)rZ ZnSphereCodecRec_encode_centroidrrrrencode_centroidsz ZnSphereCodecRec.encode_centroidcCst|||Sr#)rZZnSphereCodecRec_decoderWrrrrszZnSphereCodecRec.decodecCs t||S)z[ vectors need to be centroids (does not work on arbitrary vectors) )rZZnSphereCodecRec_encoderErrrrszZnSphereCodecRec.encodecCst|||Sr#)rZZnSphereCodecRec_get_nv)rldr2arrrget_nvszZnSphereCodecRec.get_nvcCst||||Sr#)rZZnSphereCodecRec_get_nv_cum)rrdr2trerrr get_nv_cumszZnSphereCodecRec.get_nv_cumcCst|||||Sr#)rZZnSphereCodecRec_set_nv_cum)rrdrgrer6rrr set_nv_cumszZnSphereCodecRec.set_nv_cumN)'r r r,r-rrrrrZZnSphereCodecRec_r2_getZZnSphereCodecRec_r2_setrZZnSphereCodecRec_log2_dim_getZZnSphereCodecRec_log2_dim_setZlog2_dimZZnSphereCodecRec_code_size_getZZnSphereCodecRec_code_size_setrr?rcrrZZnSphereCodecRec_all_nv_getZZnSphereCodecRec_all_nv_setZall_nvZZnSphereCodecRec_all_nv_cum_getZZnSphereCodecRec_all_nv_cum_setZ all_nv_cumZ$ZnSphereCodecRec_decode_cache_ld_getZ$ZnSphereCodecRec_decode_cache_ld_setZdecode_cache_ldZ!ZnSphereCodecRec_decode_cache_getZ!ZnSphereCodecRec_decode_cache_setZ decode_cacherfrhriZdelete_ZnSphereCodecRecrTrrrrrbs$rbc@sdeZdZdZeddddddZeZeej ej Z eej ej ZddZd d Zd d ZejZd S)ZnSphereCodecAltzg Codec that uses the recursive codec if dim is a power of 2 and the regular one otherwise cCs |jSr#r0r1rrrr3r4zZnSphereCodecAlt.cCs |j|Sr#r0r5rrrr3r4r7r8cCst|t||dSr#)rZZnSphereCodecAlt_swiginitZnew_ZnSphereCodecAltrTrrrr?szZnSphereCodecAlt.__init__cCs t||Sr#)rZZnSphereCodecAlt_encoderErrrr szZnSphereCodecAlt.encodecCst|||Sr#)rZZnSphereCodecAlt_decoderWrrrr szZnSphereCodecAlt.decodeN)r r r,r-rrrrrZZnSphereCodecAlt_use_rec_getZZnSphereCodecAlt_use_rec_setZuse_recZZnSphereCodecAlt_znc_rec_getZZnSphereCodecAlt_znc_rec_setZznc_recr?rrZdelete_ZnSphereCodecAltrTrrrrrjsrjc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejZeejejd dZd d ZddZddZddZddZej Z!dS) IndexLatticezC Index that encodes a vector with a series of Zn lattice quantizerscCs |jSr#r0r1rrrr3r4zIndexLattice.cCs |j|Sr#r0r5rrrr3r4r7r8z number of sub-vectorsz dimension of sub-vectorsz the lattice quantizerz0 nb bits used to encode the scale, per subvectorz5 mins and maxes of the vector norms, per subquantizerc Cst|t||||dSr#)rZIndexLattice_swiginitZnew_IndexLattice)rrnsq scale_nbitrrrrr?szIndexLattice.__init__cCst|||Sr#)rZIndexLattice_trainrmrrrrn!szIndexLattice.traincCs t|Sr#)rZIndexLattice_sa_code_sizer@rrrr$szIndexLattice.sa_code_sizecCst||||Sr#)rZIndexLattice_sa_encoderrrrr'szIndexLattice.sa_encodecCst||||Sr#)rZIndexLattice_sa_decoderrrrr*szIndexLattice.sa_decodeN)"r r r,r-rrrrrZIndexLattice_nsq_getZIndexLattice_nsq_setrlZIndexLattice_dsq_getZIndexLattice_dsq_setZdsqZ IndexLattice_zn_sphere_codec_getZ IndexLattice_zn_sphere_codec_setZzn_sphere_codecZIndexLattice_scale_nbit_getZIndexLattice_scale_nbit_setrmZIndexLattice_lattice_nbit_getZIndexLattice_lattice_nbit_setZ lattice_nbitZIndexLattice_trained_getZIndexLattice_trained_setrr?rnrrrZdelete_IndexLatticerTrrrrrksrkc@sXeZdZeddddddZeZeejej ddZ eej ej ddZ dd ZejZd S) IVFPQSearchParameterscCs |jSr#r0r1rrrr31r4zIVFPQSearchParameters.cCs |j|Sr#r0r5rrrr31r4r7r8% use table computation or on-the-fly?( Hamming thresh for polysemous filteringcCst|tdSr#)rZIVFPQSearchParameters_swiginitZnew_IVFPQSearchParametersr@rrrr?6szIVFPQSearchParameters.__init__N)r r r,rrrrrZ.IVFPQSearchParameters_scan_table_threshold_getZ.IVFPQSearchParameters_scan_table_threshold_setscan_table_thresholdZ'IVFPQSearchParameters_polysemous_ht_getZ'IVFPQSearchParameters_polysemous_ht_setrr?Zdelete_IVFPQSearchParametersrTrrrrrn0s rnc@s&eZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZd,ddZddZd-ddZ d.ddZ!ddZ"ddZ#ddZ$ddZ%d d!Z&d/d"d#Z'd$d%Z(d&d'Z)d(d)Z*d*d+Z+ej,Z-dS)0 IndexIVFPQzz Inverted file with Product Quantizer encoding. Each residual vector is encoded as a product quantizer code. cCs |jSr#r0r1rrrr3Br4zIndexIVFPQ.cCs |j|Sr#r0r5rrrr3Br4r7r8 produces the codesz% reorder PQ centroids after training?z if NULL, use defaultrorpz Precompute table that speed up query preprocessing at some memory cost (used only for by_residual with L2 metric) zA if use_precompute_table size nlist * pq.M * pq.ksub FcCst||||||Sr#)rZIndexIVFPQ_encode_vectorsrrrrruRszIndexIVFPQ.encode_vectorscCst||||Sr#)rZIndexIVFPQ_sa_decoderrrrrUszIndexIVFPQ.sa_decodeNcCst||||||Sr#)rZIndexIVFPQ_add_corerprrrrrXszIndexIVFPQ.add_corec Cst|||||||S)z same as add_core, also: - output 2nd level residuals if residuals_2 != NULL - accepts precomputed_idx = nullptr )rZIndexIVFPQ_add_core_o)rrBr2rqZ residuals_2rqrrrr add_core_o[szIndexIVFPQ.add_core_ocCst||||S)z trains the product quantizer)rZIndexIVFPQ_train_encoderrvrrrrwcszIndexIVFPQ.train_encodercCs t|Sr#)rZ$IndexIVFPQ_train_encoder_num_vectorsr@rrrrxgsz$IndexIVFPQ.train_encoder_num_vectorscCst||||Sr#)rZ"IndexIVFPQ_reconstruct_from_offsetrrrrrjsz"IndexIVFPQ.reconstruct_from_offsetcCst|||S)a Find exact duplicates in the dataset. the duplicates are returned in pre-allocated arrays (see the max sizes). :type lims: int :param lims: limits between groups of duplicates (max size ntotal / 2 + 1) :type ids: int :param ids: ids[lims[i]] : ids[lims[i+1]-1] is a group of duplicates (max size ntotal) :rtype: int :return: n number of groups found )rZIndexIVFPQ_find_duplicates)rr'r[rrrfind_duplicatesmszIndexIVFPQ.find_duplicatescCst||||Sr#)rZIndexIVFPQ_encode)rr}r2rrrrrszIndexIVFPQ.encodecCst||||||S)a Encode multiple vectors :type n: int :param n: nb vectors to encode :type keys: int :param keys: posting list ids for those vectors (size n) :type x: float :param x: vectors (size n * d) :type codes: uint8_t :param codes: output codes (size n * code_size) :type compute_keys: boolean, optional :param compute_keys: if false, assume keys are precomputed, otherwise compute them )rZIndexIVFPQ_encode_multiple)rrBrcr2rZ compute_keysrrrencode_multipleszIndexIVFPQ.encode_multiplecCst|||||S)z inverse of encode_multiple)rZIndexIVFPQ_decode_multiple)rrBrcZxcodesr2rrrdecode_multipleszIndexIVFPQ.decode_multiplecCst|||Sr#)rZ"IndexIVFPQ_get_InvertedListScannerrzrrrr{sz"IndexIVFPQ.get_InvertedListScannercCs t|S)z build precomputed table)rZIndexIVFPQ_precompute_tabler@rrrprecompute_tableszIndexIVFPQ.precompute_tablecGst|tj|dSr#)rZIndexIVFPQ_swiginitZnew_IndexIVFPQrQrrrr?szIndexIVFPQ.__init__)F)N)NN)F).r r r,r-rrrrrZIndexIVFPQ_pq_getZIndexIVFPQ_pq_setrZ%IndexIVFPQ_do_polysemous_training_getZ%IndexIVFPQ_do_polysemous_training_setrZ"IndexIVFPQ_polysemous_training_getZ"IndexIVFPQ_polysemous_training_setrZ#IndexIVFPQ_scan_table_threshold_getZ#IndexIVFPQ_scan_table_threshold_setrqZIndexIVFPQ_polysemous_ht_getZIndexIVFPQ_polysemous_ht_setrZ$IndexIVFPQ_use_precomputed_table_getZ$IndexIVFPQ_use_precomputed_table_setrZ IndexIVFPQ_precomputed_table_getZ IndexIVFPQ_precomputed_table_setprecomputed_tablerurrrrtrwrxrrurrvrwr{rxr?Zdelete_IndexIVFPQrTrrrrrr<s2    rrcCst||||||S)ap Pre-compute distance tables for IVFPQ with by-residual and METRIC_L2 :type use_precomputed_table: int :param use_precomputed_table: (I/O) =-1: force disable =0: decide heuristically (default: use tables only if they are < precomputed_tables_max_bytes), set use_precomputed_table on output =1: tables that work for all quantizers (size 256 * nlist * M) =2: specific version for MultiIndexQuantizer (much more compact) :type precomputed_table: faiss::AlignedTable< float,32 > :param precomputed_table: precomputed table to initialize )r"initialize_IVFPQ_precomputed_table)rr^rryrrrrrrzsrzc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejZeejejd dZd d Zd d ZejZdS)IndexIVFPQStatsz statistics are robust to internal threading, but not if IndexIVFPQ::search_preassigned is called by multiple threads cCs |jSr#r0r1rrrr3r4zIndexIVFPQStats.cCs |j|Sr#r0r5rrrr3r4r7r8z nb of refines (IVFPQR)z5 nb of passed Hamming distance tests (for polysemous)z only for IVFPQRcCst|tdSr#)rZIndexIVFPQStats_swiginitZnew_IndexIVFPQStatsr@rrrr?szIndexIVFPQStats.__init__cCs t|Sr#)rZIndexIVFPQStats_resetr@rrrr|szIndexIVFPQStats.resetN)r r r,r-rrrrrZIndexIVFPQStats_nrefine_getZIndexIVFPQStats_nrefine_setZnrefineZ"IndexIVFPQStats_n_hamming_pass_getZ"IndexIVFPQStats_n_hamming_pass_setrZ!IndexIVFPQStats_search_cycles_getZ!IndexIVFPQStats_search_cycles_setZ search_cyclesZ!IndexIVFPQStats_refine_cycles_getZ!IndexIVFPQStats_refine_cycles_setZ refine_cyclesr?r|Zdelete_IndexIVFPQStatsrTrrrrr{sr{c@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZd d Zd d ZddZddZddZdddZddZddZd ddZddZejZdS)! IndexIVFPQRz0 Index with an additional level of PQ refinementcCs |jSr#r0r1rrrr3r4zIndexIVFPQR.cCs |j|Sr#r0r5rrrr3r4r7r8z 3rd level quantizerz corresponding codeszH factor between k requested in search and the k requested from the IVFPQcCs t|Sr#)rZIndexIVFPQR_resetr@rrrr|szIndexIVFPQR.resetcCs t||Sr#)rZIndexIVFPQR_remove_idsrzrrrr{szIndexIVFPQR.remove_idscCst||||S)z" trains the two product quantizers)rZIndexIVFPQR_train_encoderrvrrrrwszIndexIVFPQR.train_encodercCs t|Sr#)rZ%IndexIVFPQR_train_encoder_num_vectorsr@rrrrxsz%IndexIVFPQR.train_encoder_num_vectorscCst||||Sr#)rZIndexIVFPQR_add_with_idsrprrrrrszIndexIVFPQR.add_with_idsNcCst||||||S)zB same as add_with_ids, but optionally use the precomputed list ids)rZIndexIVFPQR_add_corerprrrrrszIndexIVFPQR.add_corecCst||||Sr#)rZ#IndexIVFPQR_reconstruct_from_offsetrrrrrsz#IndexIVFPQR.reconstruct_from_offsetcCst|||Sr#)rZIndexIVFPQR_merge_fromrrrrrszIndexIVFPQR.merge_fromc Cst|||||||||| | Sr#)rZIndexIVFPQR_search_preassignedrfrrrrjszIndexIVFPQR.search_preassignedcGst|tj|dSr#)rZIndexIVFPQR_swiginitZnew_IndexIVFPQRrQrrrr?szIndexIVFPQR.__init__)N)NN)r r r,r-rrrrrZIndexIVFPQR_refine_pq_getZIndexIVFPQR_refine_pq_setZ refine_pqZIndexIVFPQR_refine_codes_getZIndexIVFPQR_refine_codes_setZ refine_codesZIndexIVFPQR_k_factor_getZIndexIVFPQR_k_factor_setrr|r{rwrxrrrrrrrjr?Zdelete_IndexIVFPQRrTrrrrr|s"  r|c@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d ZejZd dZdddZddZddZddZddZdS) Index2Layerz Same as an IndexIVFPQ without the inverted lists: codes are stored sequentially The class is mainly inteded to store encoded vectors that can be accessed randomly, the search function is not implemented. cCs |jSr#r0r1rrrr3r4zIndex2Layer.cCs |j|Sr#r0r5rrrr3r4r7r8z first level quantizerz& second level quantizer is always a PQz< size of the code for the first level (ceil(log8(q1.nlist)))z& size of the code for the second levelcGst|tj|dSr#)rZIndex2Layer_swiginitZnew_Index2LayerrQrrrr?szIndex2Layer.__init__cCst|||Sr#)rZIndex2Layer_trainrmrrrrn szIndex2Layer.trainNc Cst|||||||SrB)rZIndex2Layer_searchrsrrrruszIndex2Layer.searchcCs t|Sr#)rZ!Index2Layer_get_distance_computerr@rrrrsz!Index2Layer.get_distance_computercCs t||S)z* transfer the flat codes to an IVFPQ index)rZIndex2Layer_transfer_to_IVFPQr^rrrtransfer_to_IVFPQszIndex2Layer.transfer_to_IVFPQcCst||||Sr#)rZIndex2Layer_sa_encoderrrrrszIndex2Layer.sa_encodecCst||||Sr#)rZIndex2Layer_sa_decoderrrrrszIndex2Layer.sa_decode)N)r r r,r-rrrrrZIndex2Layer_q1_getZIndex2Layer_q1_setq1ZIndex2Layer_pq_getZIndex2Layer_pq_setrZIndex2Layer_code_size_1_getZIndex2Layer_code_size_1_setZ code_size_1ZIndex2Layer_code_size_2_getZIndex2Layer_code_size_2_setZ code_size_2r?Zdelete_Index2LayerrTrnrurr~rrrrrrr}s r}c@sTeZdZdZeddddddZddZeZee j e j Z ee j e jZee je jZee je jZee je jZee je jZee je jZee je j Z!ee j"e j#Z$ee j%e j&Z'ee j(e j)Z*ee j+e j,Z-d d Z.d d Z/d'ddZ0ddZ1ddZ2ddZ3ddZ4ddZ5ddZ6ddZ7d(dd Z8d!d"Z9d#d$Z:d%d&Z;e jcCs |j|Sr#r0r5rrrr31r4r7r8cOs tddSr:r;r<rrrr?3szIndexFastScan.__init__cCst||||||Sr#)rZIndexFastScan_init_fastscan)rrrrmetricbbsrrr init_fastscanCszIndexFastScan.init_fastscancCs t|Sr#)rZIndexFastScan_resetr@rrrr|FszIndexFastScan.resetNc Cst|||||||Sr#)rZIndexFastScan_searchrsrrrruIszIndexFastScan.searchcCst|||Sr#)rZIndexFastScan_addrmrrrroLszIndexFastScan.addcCst||||Sr#)rZIndexFastScan_compute_codesrrrBr2rrrrOszIndexFastScan.compute_codescCst||||Sr#)rZIndexFastScan_compute_float_LUTrlutrBr2rrrcompute_float_LUTRszIndexFastScan.compute_float_LUTcCst|||||Sr#)rZ#IndexFastScan_compute_quantized_LUT)rrBr2r normalizersrrrcompute_quantized_LUTUsz#IndexFastScan.compute_quantized_LUTcCst|||Sr#)rZIndexFastScan_reconstructr|rrrrXszIndexFastScan.reconstructcCs t||Sr#)rZIndexFastScan_remove_idsrzrrrr{[szIndexFastScan.remove_idscCs t|Sr#)rZIndexFastScan_get_CodePackerr@rrrr^szIndexFastScan.get_CodePackerrcCst|||Sr#)rZIndexFastScan_merge_fromrrrrraszIndexFastScan.merge_fromcCs t||Sr#)rZ(IndexFastScan_check_compatible_for_mergerrrrrdsz(IndexFastScan.check_compatible_for_mergecCs t|S)z9 standalone codes interface (but the codes are flattened))rZIndexFastScan_sa_code_sizer@rrrrgszIndexFastScan.sa_code_sizecCst||||Sr#)rZIndexFastScan_sa_encoderrrrrkszIndexFastScan.sa_encode)N)r)>r r r,r-rrr?rrrZIndexFastScan_implem_getZIndexFastScan_implem_setimplemZIndexFastScan_skip_getZIndexFastScan_skip_setskipZIndexFastScan_bbs_getZIndexFastScan_bbs_setrZIndexFastScan_qbs_getZIndexFastScan_qbs_setqbsZIndexFastScan_M_getZIndexFastScan_M_setrZIndexFastScan_nbits_getZIndexFastScan_nbits_setrZIndexFastScan_ksub_getZIndexFastScan_ksub_setr8ZIndexFastScan_code_size_getZIndexFastScan_code_size_setrZIndexFastScan_ntotal2_getZIndexFastScan_ntotal2_setZntotal2ZIndexFastScan_M2_getZIndexFastScan_M2_setM2ZIndexFastScan_codes_getZIndexFastScan_codes_setrZIndexFastScan_orig_codes_getZIndexFastScan_orig_codes_setZ orig_codesrr|rurorrrrr{rrrrrZdelete_IndexFastScanrTrrrrr!s>  rc@steZdZeddddddZeZeejej Z eej ej Z eejejZeejejZddZdd ZejZd S) FastScanStatscCs |jSr#r0r1rrrr3rr4zFastScanStats.cCs |j|Sr#r0r5rrrr3rr4r7r8cCst|tdSr#)rZFastScanStats_swiginitZnew_FastScanStatsr@rrrr?yszFastScanStats.__init__cCs t|Sr#)rZFastScanStats_resetr@rrrr||szFastScanStats.resetN)r r r,rrrrrZFastScanStats_t0_getZFastScanStats_t0_setr^ZFastScanStats_t1_getZFastScanStats_t1_sett1ZFastScanStats_t2_getZFastScanStats_t2_sett2ZFastScanStats_t3_getZFastScanStats_t3_sett3r?r|Zdelete_FastScanStatsrTrrrrrqsrc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZddZejZd d Zd d Zd dZddZddZdddZddZdS)IndexAdditiveQuantizerFastScana Fast scan version of IndexAQ. Works for 4-bit AQ for now. The codes are not stored sequentially but grouped in blocks of size bbs. This makes it possible to compute distances quickly with SIMD instructions. Implementations: 12: blocked loop with internal loop on Q with qbs 13: same with reservoir accumulator to store results 14: no qbs with heap accumulator 15: no qbs with reservoir accumulator cCs |jSr#r0r1rrrr3r4z'IndexAdditiveQuantizerFastScan.cCs |j|Sr#r0r5rrrr3r4r7r8cGstj|g|RSr#)rZ#IndexAdditiveQuantizerFastScan_initrQrrrrasz#IndexAdditiveQuantizerFastScan.initcGst|tj|dS)z *Overload 1:* build from an existing IndexAQ | *Overload 2:* build from an existing IndexAQ N)rZ'IndexAdditiveQuantizerFastScan_swiginitZ"new_IndexAdditiveQuantizerFastScanrQrrrr?s z'IndexAdditiveQuantizerFastScan.__init__cCst|||Sr#)rZ$IndexAdditiveQuantizerFastScan_trainrmrrrrnsz$IndexAdditiveQuantizerFastScan.traincCst|||Sr#)rZ2IndexAdditiveQuantizerFastScan_estimate_norm_scalermrrrestimate_norm_scalesz2IndexAdditiveQuantizerFastScan.estimate_norm_scalecCst||||Sr#)rZ,IndexAdditiveQuantizerFastScan_compute_codesrrrrrsz,IndexAdditiveQuantizerFastScan.compute_codescCst||||Sr#)rZ0IndexAdditiveQuantizerFastScan_compute_float_LUTrrrrrsz0IndexAdditiveQuantizerFastScan.compute_float_LUTNc Cst|||||||Sr#)rZ%IndexAdditiveQuantizerFastScan_searchrsrrrrusz%IndexAdditiveQuantizerFastScan.searchcCst||||S)a Decode a set of vectors. NOTE: The codes in the IndexAdditiveQuantizerFastScan object are non- contiguous. But this method requires a contiguous representation. :type n: int :param n: number of vectors :type bytes: uint8_t :param bytes: input encoded vectors, size n * code_size :type x: float :param x: output vectors, size n * d )rZ(IndexAdditiveQuantizerFastScan_sa_decoderrrrrsz(IndexAdditiveQuantizerFastScan.sa_decode)N)r r r,r-rrrrrZ%IndexAdditiveQuantizerFastScan_aq_getZ%IndexAdditiveQuantizerFastScan_aq_setrZ/IndexAdditiveQuantizerFastScan_rescale_norm_getZ/IndexAdditiveQuantizerFastScan_rescale_norm_set rescale_normZ-IndexAdditiveQuantizerFastScan_norm_scale_getZ-IndexAdditiveQuantizerFastScan_norm_scale_set norm_scaleZ3IndexAdditiveQuantizerFastScan_max_train_points_getZ3IndexAdditiveQuantizerFastScan_max_train_points_setrraZ%delete_IndexAdditiveQuantizerFastScanrTr?rnrrrrurrrrrrs    rc@sJeZdZdZeddddddZeZeej ej ddZ dd Z ej Zd S) IndexResidualQuantizerFastScanrcCs |jSr#r0r1rrrr3r4z'IndexResidualQuantizerFastScan.cCs |j|Sr#r0r5rrrr3r4r7r8rcGst|tj|dSr#)rZ'IndexResidualQuantizerFastScan_swiginitZ"new_IndexResidualQuantizerFastScanrQrrrr?sz'IndexResidualQuantizerFastScan.__init__N)r r r,r-rrrrrZ%IndexResidualQuantizerFastScan_rq_getZ%IndexResidualQuantizerFastScan_rq_setr%r?Z%delete_IndexResidualQuantizerFastScanrTrrrrrs rc@sFeZdZdZeddddddZeZeej ej Z ddZ ej Zd S) !IndexLocalSearchQuantizerFastScanz Index based on a local search quantizer. Stored vectors are approximated by local search quantization codes. Can also be used as a codec cCs |jSr#r0r1rrrr3r4z*IndexLocalSearchQuantizerFastScan.cCs |j|Sr#r0r5rrrr3r4r7r8cGst|tj|dSr#)rZ*IndexLocalSearchQuantizerFastScan_swiginitZ%new_IndexLocalSearchQuantizerFastScanrQrrrr?sz*IndexLocalSearchQuantizerFastScan.__init__N)r r r,r-rrrrrZ)IndexLocalSearchQuantizerFastScan_lsq_getZ)IndexLocalSearchQuantizerFastScan_lsq_setrSr?Z(delete_IndexLocalSearchQuantizerFastScanrTrrrrrs rc@sJeZdZdZeddddddZeZeej ej ddZ dd Z ej Zd S) %IndexProductResidualQuantizerFastScanz Index based on a product residual quantizer. Stored vectors are approximated by product residual quantization codes. Can also be used as a codec cCs |jSr#r0r1rrrr3r4z.IndexProductResidualQuantizerFastScan.cCs |j|Sr#r0r5rrrr3r4r7r8rcGst|tj|dSr#)rZ.IndexProductResidualQuantizerFastScan_swiginitZ)new_IndexProductResidualQuantizerFastScanrQrrrr?sz.IndexProductResidualQuantizerFastScan.__init__N)r r r,r-rrrrrZ-IndexProductResidualQuantizerFastScan_prq_getZ-IndexProductResidualQuantizerFastScan_prq_setrr?Z,delete_IndexProductResidualQuantizerFastScanrTrrrrrs rc@sJeZdZdZeddddddZeZeej ej ddZ dd Z ej Zd S) (IndexProductLocalSearchQuantizerFastScanz Index based on a product local search quantizer. Stored vectors are approximated by product local search quantization codes. Can also be used as a codec cCs |jSr#r0r1rrrr3 r4z1IndexProductLocalSearchQuantizerFastScan.cCs |j|Sr#r0r5rrrr3 r4r7r8rcGst|tj|dSr#)rZ1IndexProductLocalSearchQuantizerFastScan_swiginitZ,new_IndexProductLocalSearchQuantizerFastScanrQrrrr? sz1IndexProductLocalSearchQuantizerFastScan.__init__N)r r r,r-rrrrrZ1IndexProductLocalSearchQuantizerFastScan_plsq_getZ1IndexProductLocalSearchQuantizerFastScan_plsq_setrr?Z/delete_IndexProductLocalSearchQuantizerFastScanrTrrrrrs rc@sfeZdZdZeddddddZeZeej ej Z ddZ d d Z d d Zd dZddZejZdS)IndexPQFastScana Fast scan version of IndexPQ. Works for 4-bit PQ for now. The codes are not stored sequentially but grouped in blocks of size bbs. This makes it possible to compute distances quickly with SIMD instructions. Implementations: 12: blocked loop with internal loop on Q with qbs 13: same with reservoir accumulator to store results 14: no qbs with heap accumulator 15: no qbs with reservoir accumulator cCs |jSr#r0r1rrrr3 r4zIndexPQFastScan.cCs |j|Sr#r0r5rrrr3 r4r7r8cGst|tj|dS)z *Overload 1:* build from an existing IndexPQ | *Overload 2:* build from an existing IndexPQ N)rZIndexPQFastScan_swiginitZnew_IndexPQFastScanrQrrrr? s zIndexPQFastScan.__init__cCst|||Sr#)rZIndexPQFastScan_trainrmrrrrn* szIndexPQFastScan.traincCst||||Sr#)rZIndexPQFastScan_compute_codesrrrrr- szIndexPQFastScan.compute_codescCst||||Sr#)rZ!IndexPQFastScan_compute_float_LUTrrrrr0 sz!IndexPQFastScan.compute_float_LUTcCst||||Sr#)rZIndexPQFastScan_sa_decoderrrrr3 szIndexPQFastScan.sa_decodeN)r r r,r-rrrrrZIndexPQFastScan_pq_getZIndexPQFastScan_pq_setrr?rnrrrZdelete_IndexPQFastScanrTrrrrr s  rc@s4eZdZeddddddZeZddZej Z dS) simd16uint16cCs |jSr#r0r1rrrr3: r4zsimd16uint16.cCs |j|Sr#r0r5rrrr3: r4r7r8cCst|tdSr#)rZsimd16uint16_swiginitZnew_simd16uint16r@rrrr?= szsimd16uint16.__init__N) r r r,rrrrr?rZdelete_simd16uint16rTrrrrr9 src@sreZdZdZeddddddZddZeZee j e j Z ee j e jZee je jZd d Zd d Ze jZd S)SIMDResultHandlerzA This file contains callbacks for kernels that compute distances.cCs |jSr#r0r1rrrr3F r4zSIMDResultHandler.cCs |j|Sr#r0r5rrrr3F r4r7r8cOs tddSr:r;r<rrrr?H szSIMDResultHandler.__init__cCst|||||S)z called when 32 distances are computed and provided in two simd16uint16. (q, b) indicate which entry it is in the block. )rZSIMDResultHandler_handlerr-r~Zd0Zd1rrrhandleO szSIMDResultHandler.handlecCst|||S)z* set the sub-matrix that is being computed)rZ"SIMDResultHandler_set_block_origin)rrj0rrrset_block_originV sz"SIMDResultHandler.set_block_originN)r r r,r-rrr?rrrZSIMDResultHandler_is_CMax_getZSIMDResultHandler_is_CMax_setZis_CMaxZ SIMDResultHandler_sizeof_ids_getZ SIMDResultHandler_sizeof_ids_setZ sizeof_idsZ!SIMDResultHandler_with_fields_getZ!SIMDResultHandler_with_fields_setZ with_fieldsrrZdelete_SIMDResultHandlerrTrrrrrC src@seZdZeddddddZddZeZeej ej Z eej ej ZeejejddZeejejZeejejZeejejZd d Zd d ZejZd S)SIMDResultHandlerToFloatcCs |jSr#r0r1rrrr3^ r4z!SIMDResultHandlerToFloat.cCs |j|Sr#r0r5rrrr3^ r4r7r8cOs tddSr:r;r<rrrr?` sz!SIMDResultHandlerToFloat.__init__zE these fields are used mainly for the IVF variants (with_id_map=true)cCs t||Sr#)rZSIMDResultHandlerToFloat_beginrrrrrj szSIMDResultHandlerToFloat.begincCs t|Sr#)rZSIMDResultHandlerToFloat_endr@rrrrm szSIMDResultHandlerToFloat.endN)r r r,rrr?rrrZSIMDResultHandlerToFloat_nq_getZSIMDResultHandlerToFloat_nq_setrZ#SIMDResultHandlerToFloat_ntotal_getZ#SIMDResultHandlerToFloat_ntotal_setrZ#SIMDResultHandlerToFloat_id_map_getZ#SIMDResultHandlerToFloat_id_map_setid_mapZ"SIMDResultHandlerToFloat_q_map_getZ"SIMDResultHandlerToFloat_q_map_setZq_mapZ"SIMDResultHandlerToFloat_dbias_getZ"SIMDResultHandlerToFloat_dbias_setZdbiasZ(SIMDResultHandlerToFloat_normalizers_getZ(SIMDResultHandlerToFloat_normalizers_setrrrZdelete_SIMDResultHandlerToFloatrTrrrrr] src@sVeZdZdZeddddddZeZeej ej Z ddZ d d Z ejZd d Zd S)DummyResultHandlerzx Dummy structure that just computes a chqecksum on results (to avoid the computation to be optimized away) cCs |jSr#r0r1rrrr3y r4zDummyResultHandler.cCs |j|Sr#r0r5rrrr3y r4r7r8cCst|||||Sr#)rZDummyResultHandler_handlerrrrr} szDummyResultHandler.handlecCst|||Sr#)rZ#DummyResultHandler_set_block_origin)rrWZarg3rrrr sz#DummyResultHandler.set_block_origincCst|tdSr#)rZDummyResultHandler_swiginitZnew_DummyResultHandlerr@rrrr? szDummyResultHandler.__init__N)r r r,r-rrrrrZDummyResultHandler_cs_getZDummyResultHandler_cs_setrrrZdelete_DummyResultHandlerrTr?rrrrrs src@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZddZd d Zd d ZejZd S)StoreResultHandlerzg memorize results in a nq-by-nb matrix. j0 is the current upper-left block of the matrix cCs |jSr#r0r1rrrr3 r4zStoreResultHandler.cCs |j|Sr#r0r5rrrr3 r4r7r8cCst|t||dSr#)rZStoreResultHandler_swiginitZnew_StoreResultHandler)rrZrdrrrr? szStoreResultHandler.__init__cCst|||||Sr#)rZStoreResultHandler_handlerrrrr szStoreResultHandler.handlecCst|||Sr#)rZ#StoreResultHandler_set_block_origin)rZi0_inZj0_inrrrr sz#StoreResultHandler.set_block_originN)r r r,r-rrrrrZStoreResultHandler_data_getZStoreResultHandler_data_setrZZStoreResultHandler_ld_getZStoreResultHandler_ld_setrdZStoreResultHandler_i0_getZStoreResultHandler_i0_setrZStoreResultHandler_j0_getZStoreResultHandler_j0_setrr?rrZdelete_StoreResultHandlerrTrrrrr src@sveZdZdZeddddddZddZeZee j e j Z ee j e jZee je jZee je jZee je jZee je jZee je jZee je j Z!ee j"e j#Z$ee j%e j&Z'd d Z(d d Z)e j*Z+ee j,e j-d dZ.ddZ/ddZ0ddZ1ddZ2d/ddZ3d0ddZ4d1ddZ5d2ddZ6d3dd Z7d4d!d"Z8d5d#d$Z9d6d%d&Z:d'd(Z;d)d*ZdS)7IndexIVFFastScana Fast scan version of IVFPQ and IVFAQ. Works for 4-bit PQ/AQ for now. The codes in the inverted lists are not stored sequentially but grouped in blocks of size bbs. This makes it possible to very quickly compute distances with SIMD instructions. Implementations (implem): 0: auto-select implementation (default) 1: orig's search, re-implemented 2: orig's search, re-ordered by invlist 10: optimizer int16 search, collect results in heap, no qbs 11: idem, collect results in reservoir 12: optimizer int16 search, collect results in heap, uses qbs 13: idem, collect results in reservoir 14: internally multithreaded implem over nq * nprobe 15: same with reservoir For range search, only 10 and 12 are supported. add 100 to the implem to force single-thread scanning (the coarse quantizer may still use multiple threads). cCs |jSr#r0r1rrrr3 r4zIndexIVFFastScan.cCs |j|Sr#r0r5rrrr3 r4r7r8cOs tddSr:r;r<rrrr? szIndexIVFFastScan.__init__c Cst|||||||S)z called by implementations)rZIndexIVFFastScan_init_fastscan)rfine_quantizerrrrrrrrrr szIndexIVFFastScan.init_fastscancCs t|Sr#)rZ!IndexIVFFastScan_init_code_packerr@rrrinit_code_packer sz!IndexIVFFastScan.init_code_packerz& orig's inverted lists (for debugging)cCst||||Sr#)rZIndexIVFFastScan_add_with_idsrprrrrr szIndexIVFFastScan.add_with_idscCs t|Sr#)rZ#IndexIVFFastScan_lookup_table_is_3dr@rrrlookup_table_is_3d sz#IndexIVFFastScan.lookup_table_is_3dcCst||||||Sr#)rZIndexIVFFastScan_compute_LUTrrBr2cqr:biasesrrrr szIndexIVFFastScan.compute_LUTc Cst|||||||Sr#)rZ"IndexIVFFastScan_compute_LUT_uint8)rrBr2rr:rrrrrcompute_LUT_uint8 sz"IndexIVFFastScan.compute_LUT_uint8Nc Cst|||||||Sr#)rZIndexIVFFastScan_searchrsrrrru szIndexIVFFastScan.searchc Cst|||||||||| | Sr#)rZ#IndexIVFFastScan_search_preassignedrfrrrrj sz#IndexIVFFastScan.search_preassignedcCst||||||Sr#)rZIndexIVFFastScan_range_searchrvrrrrw szIndexIVFFastScan.range_searchc Cst||||||||| Sr#)rZ'IndexIVFFastScan_search_dispatch_implem) rrBr2rrrrscalerrtrrrsearch_dispatch_implem sz'IndexIVFFastScan.search_dispatch_implemc Cst||||||||Sr#)rZ-IndexIVFFastScan_range_search_dispatch_implem)rrBr2rZrresZcq_inrrtrrrrange_search_dispatch_implem sz-IndexIVFFastScan.range_search_dispatch_implemc Cst||||||||| Sr#)rZ!IndexIVFFastScan_search_implem_10 rrBr2handlerrZndis_outZ nlist_outrrtrrrsearch_implem_10 sz!IndexIVFFastScan.search_implem_10c Cst||||||||| Sr#)rZ!IndexIVFFastScan_search_implem_12rrrrsearch_implem_12 sz!IndexIVFFastScan.search_implem_12c Cst|||||||||| Sr#)rZ!IndexIVFFastScan_search_implem_14) rrBr2rrrrimplrrtrrrsearch_implem_14 sz!IndexIVFFastScan.search_implem_14cCst||||Sr#)rZ(IndexIVFFastScan_reconstruct_from_offsetrrrrr sz(IndexIVFFastScan.reconstruct_from_offsetcCs t|Sr#)rZIndexIVFFastScan_get_CodePackerr@rrrr szIndexIVFFastScan.get_CodePackercCs t|Sr#)rZ*IndexIVFFastScan_reconstruct_orig_invlistsr@rrrreconstruct_orig_invlists sz*IndexIVFFastScan.reconstruct_orig_invlistscCst||||S)a Decode a set of vectors. NOTE: The codes in the IndexFastScan object are non-contiguous. But this method requires a contiguous representation. :type n: int :param n: number of vectors :type bytes: uint8_t :param bytes: input encoded vectors, size n * code_size :type x: float :param x: output vectors, size n * d )rZIndexIVFFastScan_sa_decoderrrrr!szIndexIVFFastScan.sa_decode)N)NN)N)N)N)N)N)N)?r r r,r-rrr?rrrZIndexIVFFastScan_bbs_getZIndexIVFFastScan_bbs_setrZIndexIVFFastScan_M_getZIndexIVFFastScan_M_setrZIndexIVFFastScan_nbits_getZIndexIVFFastScan_nbits_setrZIndexIVFFastScan_ksub_getZIndexIVFFastScan_ksub_setr8ZIndexIVFFastScan_M2_getZIndexIVFFastScan_M2_setrZIndexIVFFastScan_implem_getZIndexIVFFastScan_implem_setrZIndexIVFFastScan_skip_getZIndexIVFFastScan_skip_setrZIndexIVFFastScan_qbs_getZIndexIVFFastScan_qbs_setrZIndexIVFFastScan_qbs2_getZIndexIVFFastScan_qbs2_setZqbs2Z#IndexIVFFastScan_fine_quantizer_getZ#IndexIVFFastScan_fine_quantizer_setrrrZdelete_IndexIVFFastScanrTZ"IndexIVFFastScan_orig_invlists_getZ"IndexIVFFastScan_orig_invlists_setZ orig_invlistsrrrrrrurjrwrrrrrrrrrrrrrr sD        rc@seZdZeddddddZeZeejej Z eej ej Z eejejZeejejZeejejZeejejZeejejZeejejZeej ej!Z"ddZ#dd Z$d d Z%d d Z&ej'Z(dS)IVFFastScanStatscCs |jSr#r0r1rrrr3!r4zIVFFastScanStats.cCs |j|Sr#r0r5rrrr3!r4r7r8cCs t||Sr#)rZIVFFastScanStats_Mcy_atrrrrMcy_at !szIVFFastScanStats.Mcy_atcCs t||Sr#)rZ!IVFFastScanStats_Mcy_reservoir_atrrrrMcy_reservoir_at#!sz!IVFFastScanStats.Mcy_reservoir_atcCst|tdSr#)rZIVFFastScanStats_swiginitZnew_IVFFastScanStatsr@rrrr?&!szIVFFastScanStats.__init__cCs t|Sr#)rZIVFFastScanStats_resetr@rrrr|)!szIVFFastScanStats.resetN))r r r,rrrrrZIVFFastScanStats_times_getZIVFFastScanStats_times_settimesZ.IVFFastScanStats_t_compute_distance_tables_getZ.IVFFastScanStats_t_compute_distance_tables_setZt_compute_distance_tablesZIVFFastScanStats_t_round_getZIVFFastScanStats_t_round_setZt_roundZ IVFFastScanStats_t_copy_pack_getZ IVFFastScanStats_t_copy_pack_setZ t_copy_packZIVFFastScanStats_t_scan_getZIVFFastScanStats_t_scan_setZt_scanZIVFFastScanStats_t_to_flat_getZIVFFastScanStats_t_to_flat_setZ t_to_flatZ$IVFFastScanStats_reservoir_times_getZ$IVFFastScanStats_reservoir_times_setZreservoir_timesZ IVFFastScanStats_t_aq_encode_getZ IVFFastScanStats_t_aq_encode_setZ t_aq_encodeZ%IVFFastScanStats_t_aq_norm_encode_getZ%IVFFastScanStats_t_aq_norm_encode_setZt_aq_norm_encoderrr?r|Zdelete_IVFFastScanStatsrTrrrrr!s rc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZddZejZd d Zd d Zd dZddZdddZdddZddZddZdS)!IndexIVFAdditiveQuantizerFastScanas Fast scan version of IVFAQ. Works for 4-bit AQ for now. The codes in the inverted lists are not stored sequentially but grouped in blocks of size bbs. This makes it possible to very quickly compute distances with SIMD instructions. Implementations (implem): 0: auto-select implementation (default) 1: orig's search, re-implemented 2: orig's search, re-ordered by invlist 10: optimizer int16 search, collect results in heap, no qbs 11: idem, collect results in reservoir 12: optimizer int16 search, collect results in heap, uses qbs 13: idem, collect results in reservoir cCs |jSr#r0r1rrrr3A!r4z*IndexIVFAdditiveQuantizerFastScan.cCs |j|Sr#r0r5rrrr3A!r4r7r8cCst|||||Sr#)rZ&IndexIVFAdditiveQuantizerFastScan_init)rrrrrrrrraH!sz&IndexIVFAdditiveQuantizerFastScan.initcGst|tj|dSr#)rZ*IndexIVFAdditiveQuantizerFastScan_swiginitZ%new_IndexIVFAdditiveQuantizerFastScanrQrrrr?L!sz*IndexIVFAdditiveQuantizerFastScan.__init__cCst||||Sr#)rZ/IndexIVFAdditiveQuantizerFastScan_train_encoderrvrrrrwO!sz/IndexIVFAdditiveQuantizerFastScan.train_encodercCs t|Sr#)rZ;IndexIVFAdditiveQuantizerFastScan_train_encoder_num_vectorsr@rrrrxR!sz;IndexIVFAdditiveQuantizerFastScan.train_encoder_num_vectorscCst|||Sr#)rZ5IndexIVFAdditiveQuantizerFastScan_estimate_norm_scalermrrrrU!sz5IndexIVFAdditiveQuantizerFastScan.estimate_norm_scaleFcCst||||||S)zq same as the regular IVFAQ encoder. The codes are not reorganized by blocks a that point )rZ0IndexIVFAdditiveQuantizerFastScan_encode_vectorsrsrrrruX!sz0IndexIVFAdditiveQuantizerFastScan.encode_vectorsNc Cst|||||||Sr#)rZ(IndexIVFAdditiveQuantizerFastScan_searchrsrrrru_!sz(IndexIVFAdditiveQuantizerFastScan.searchcCs t|Sr#)rZ4IndexIVFAdditiveQuantizerFastScan_lookup_table_is_3dr@rrrrb!sz4IndexIVFAdditiveQuantizerFastScan.lookup_table_is_3dcCst||||||Sr#)rZ-IndexIVFAdditiveQuantizerFastScan_compute_LUTrrrrre!sz-IndexIVFAdditiveQuantizerFastScan.compute_LUT)F)N) r r r,r-rrrrrZ(IndexIVFAdditiveQuantizerFastScan_aq_getZ(IndexIVFAdditiveQuantizerFastScan_aq_setrZ2IndexIVFAdditiveQuantizerFastScan_rescale_norm_getZ2IndexIVFAdditiveQuantizerFastScan_rescale_norm_setrZ0IndexIVFAdditiveQuantizerFastScan_norm_scale_getZ0IndexIVFAdditiveQuantizerFastScan_norm_scale_setrZ6IndexIVFAdditiveQuantizerFastScan_max_train_points_getZ6IndexIVFAdditiveQuantizerFastScan_max_train_points_setrraZ(delete_IndexIVFAdditiveQuantizerFastScanrTr?rwrxrrururrrrrrr/!s"  rc@sBeZdZeddddddZeZeejej Z ddZ ej Z dS) $IndexIVFLocalSearchQuantizerFastScancCs |jSr#r0r1rrrr3k!r4z-IndexIVFLocalSearchQuantizerFastScan.cCs |j|Sr#r0r5rrrr3k!r4r7r8cGst|tj|dSr#)rZ-IndexIVFLocalSearchQuantizerFastScan_swiginitZ(new_IndexIVFLocalSearchQuantizerFastScanrQrrrr?o!sz-IndexIVFLocalSearchQuantizerFastScan.__init__N)r r r,rrrrrZ,IndexIVFLocalSearchQuantizerFastScan_lsq_getZ,IndexIVFLocalSearchQuantizerFastScan_lsq_setrSr?Z+delete_IndexIVFLocalSearchQuantizerFastScanrTrrrrrj!s rc@sBeZdZeddddddZeZeejej Z ddZ ej Z dS) !IndexIVFResidualQuantizerFastScancCs |jSr#r0r1rrrr3v!r4z*IndexIVFResidualQuantizerFastScan.cCs |j|Sr#r0r5rrrr3v!r4r7r8cGst|tj|dSr#)rZ*IndexIVFResidualQuantizerFastScan_swiginitZ%new_IndexIVFResidualQuantizerFastScanrQrrrr?z!sz*IndexIVFResidualQuantizerFastScan.__init__N)r r r,rrrrrZ(IndexIVFResidualQuantizerFastScan_rq_getZ(IndexIVFResidualQuantizerFastScan_rq_setr%r?Z(delete_IndexIVFResidualQuantizerFastScanrTrrrrru!s rc@sBeZdZeddddddZeZeejej Z ddZ ej Z dS) +IndexIVFProductLocalSearchQuantizerFastScancCs |jSr#r0r1rrrr3!r4z4IndexIVFProductLocalSearchQuantizerFastScan.cCs |j|Sr#r0r5rrrr3!r4r7r8cGst|tj|dSr#)rZ4IndexIVFProductLocalSearchQuantizerFastScan_swiginitZ/new_IndexIVFProductLocalSearchQuantizerFastScanrQrrrr?!sz4IndexIVFProductLocalSearchQuantizerFastScan.__init__N)r r r,rrrrrZ4IndexIVFProductLocalSearchQuantizerFastScan_plsq_getZ4IndexIVFProductLocalSearchQuantizerFastScan_plsq_setrr?Z2delete_IndexIVFProductLocalSearchQuantizerFastScanrTrrrrr!s rc@sBeZdZeddddddZeZeejej Z ddZ ej Z dS) (IndexIVFProductResidualQuantizerFastScancCs |jSr#r0r1rrrr3!r4z1IndexIVFProductResidualQuantizerFastScan.cCs |j|Sr#r0r5rrrr3!r4r7r8cGst|tj|dSr#)rZ1IndexIVFProductResidualQuantizerFastScan_swiginitZ,new_IndexIVFProductResidualQuantizerFastScanrQrrrr?!sz1IndexIVFProductResidualQuantizerFastScan.__init__N)r r r,rrrrrZ0IndexIVFProductResidualQuantizerFastScan_prq_getZ0IndexIVFProductResidualQuantizerFastScan_prq_setrr?Z/delete_IndexIVFProductResidualQuantizerFastScanrTrrrrr!s rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d Zd dZddZdddZddZejZdS)IndexIVFIndependentQuantizerz An IVF index with a quantizer that has a different input dimension from the payload size. The vectors to encode are obtained from the input vectors by a VectorTransform. cCs |jSr#r0r1rrrr3!r4z%IndexIVFIndependentQuantizer.cCs |j|Sr#r0r5rrrr3!r4r7r8z1 quantizer is fed directly with the input vectorsz- transform before the IVF vectors are appliedz) the IVF index, controls nlist and nprobez whether *this owns the 3 fieldscGst|tj|dSr#)rZ%IndexIVFIndependentQuantizer_swiginitZ new_IndexIVFIndependentQuantizerrQrrrr?!sz%IndexIVFIndependentQuantizer.__init__cCst|||Sr#)rZ"IndexIVFIndependentQuantizer_trainrmrrrrn!sz"IndexIVFIndependentQuantizer.traincCst|||Sr#)rZ IndexIVFIndependentQuantizer_addrmrrrro!sz IndexIVFIndependentQuantizer.addNc Cst|||||||Sr#)rZ#IndexIVFIndependentQuantizer_searchrsrrrru!sz#IndexIVFIndependentQuantizer.searchcCs t|Sr#)rZ"IndexIVFIndependentQuantizer_resetr@rrrr|!sz"IndexIVFIndependentQuantizer.reset)N)r r r,r-rrrrrZ*IndexIVFIndependentQuantizer_quantizer_getZ*IndexIVFIndependentQuantizer_quantizer_setr^Z#IndexIVFIndependentQuantizer_vt_getZ#IndexIVFIndependentQuantizer_vt_setrZ*IndexIVFIndependentQuantizer_index_ivf_getZ*IndexIVFIndependentQuantizer_index_ivf_setZ index_ivfZ+IndexIVFIndependentQuantizer_own_fields_getZ+IndexIVFIndependentQuantizer_own_fields_setrr?rnrorur|Z#delete_IndexIVFIndependentQuantizerrTrrrrr!s rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZd d Zd d ZddZddZdddZddZddZejZdS)IndexIVFPQFastScanas Fast scan version of IVFPQ. Works for 4-bit PQ for now. The codes in the inverted lists are not stored sequentially but grouped in blocks of size bbs. This makes it possible to very quickly compute distances with SIMD instructions. Implementations (implem): 0: auto-select implementation (default) 1: orig's search, re-implemented 2: orig's search, re-ordered by invlist 10: optimizer int16 search, collect results in heap, no qbs 11: idem, collect results in reservoir 12: optimizer int16 search, collect results in heap, uses qbs 13: idem, collect results in reservoir cCs |jSr#r0r1rrrr3!r4zIndexIVFPQFastScan.cCs |j|Sr#r0r5rrrr3!r4r7r8rsz precomputed tables managementz4 if use_precompute_table size (nlist, pq.M, pq.ksub)cGst|tj|dSr#)rZIndexIVFPQFastScan_swiginitZnew_IndexIVFPQFastScanrQrrrr?!szIndexIVFPQFastScan.__init__cCst||||Sr#)rZ IndexIVFPQFastScan_train_encoderrvrrrrw!sz IndexIVFPQFastScan.train_encodercCs t|Sr#)rZ,IndexIVFPQFastScan_train_encoder_num_vectorsr@rrrrx!sz,IndexIVFPQFastScan.train_encoder_num_vectorscCs t|S)zA build precomputed table, possibly updating use_precomputed_table)rZ#IndexIVFPQFastScan_precompute_tabler@rrrrx!sz#IndexIVFPQFastScan.precompute_tableFcCst||||||S)zq same as the regular IVFPQ encoder. The codes are not reorganized by blocks a that point )rZ!IndexIVFPQFastScan_encode_vectorsrsrrrru!sz!IndexIVFPQFastScan.encode_vectorscCs t|Sr#)rZ%IndexIVFPQFastScan_lookup_table_is_3dr@rrrr!sz%IndexIVFPQFastScan.lookup_table_is_3dcCst||||||Sr#)rZIndexIVFPQFastScan_compute_LUTrrrrr!szIndexIVFPQFastScan.compute_LUTN)F)r r r,r-rrrrrZIndexIVFPQFastScan_pq_getZIndexIVFPQFastScan_pq_setrZ,IndexIVFPQFastScan_use_precomputed_table_getZ,IndexIVFPQFastScan_use_precomputed_table_setrZ(IndexIVFPQFastScan_precomputed_table_getZ(IndexIVFPQFastScan_precomputed_table_setryr?rwrxrxrurrZdelete_IndexIVFPQFastScanrTrrrrr!s rcCst|||||S)a Functions to quantize PQ floating-point Look Up Tables (LUT) to uint8, and biases to uint16. The accumulation is supposed to take place in uint16. The quantization coefficients are float (a, b) such that original_value = quantized_value * a / b The hardest part of the quantization is with multiple LUTs that need to be added up together. In that case, coefficient a has to be chosen so that the sum fits in a uint16 accumulator. )rround_uint8_per_column)r`rBra_outb_outrrrr!s rcCst||||||Sr#)rround_uint8_per_column_multi)r`rrBrrrrrrr!src Cst|||||||||| | S)a) LUT quantization to uint8 and bias to uint16. (nprobe, M, ksub, lut_is_3d) determine the size of the the LUT LUT input: - 2D size (M, ksub): single matrix per probe (lut_is_3d=false) - 3D size (nprobe, M, ksub): separate LUT per probe (lut_is_3d=true) bias input: - nullptr: bias is 0 - size (nprobe): one bias per probe Output: - LUTq uint8 version of the LUT (M size is rounded up to M2) - biasq (or nullptr): uint16 version of the LUT - a, b: scalars to approximate the true distance )rquantize_LUT_and_bias) rcrr8Z lut_is_3drbiasLUTqrbiasqrrrrrr!src Cs t|||||||||| | | Sr#)raq_quantize_LUT_and_bias) rcrr8rrM_normrrrrrrrrrr"srcCst||||Sr#)raq_estimate_norm_scale)rr8rrrrrr"src@s.eZdZdZeddddddZddZeZee j e j d dZ ee j e jd dZee je jd dZee je jd dZee je jd dZee je jddZe jZddZddZddZ d2ddZ!d3ddZ"d4ddZ#ddZ$dd Z%d!d"Z&d#d$Z'd5d%d&Z(d'd(Z)d6d*d+Z*d,d-Z+d.d/Z,d0d1Z-dS)7 IndexBinaryz Abstract structure for a binary index. Supports adding vertices and searching them. All queries are symmetric because there is no distinction between codes and vectors. cCs |jSr#r0r1rrrr3"r4zIndexBinary.cCs |j|Sr#r0r5rrrr3"r4r7r8cOs tddSr:r;r<rrrr?!"szIndexBinary.__init__riz' number of bytes per vector ( = d / 8 )rjrkzX set if the Index does not require training, or if training is done already rlcCst|||S)z Perform training on a representative set of vectors. :type n: int :param n: nb of training vectors :type x: uint8_t :param x: training vecors, size n * d / 8 )rZIndexBinary_trainrmrrrrn/"s zIndexBinary.traincCst|||S)z Add n vectors of dimension d to the index. Vectors are implicitly assigned labels ntotal .. ntotal + n - 1 :type x: uint8_t :param x: input matrix, size n * d / 8 )rZIndexBinary_addrmrrrro:"szIndexBinary.addcCst||||S)a Same as add, but stores xids instead of sequential ids. The default implementation fails with an assertion, as it is not supported by all indexes. :type xids: int :param xids: if non-null, ids to store for the vectors (size n) )rZIndexBinary_add_with_idsrprrrrrD"s zIndexBinary.add_with_idsNc Cst|||||||S)a Query n vectors of dimension d to the index. return at most k vectors. If there are not enough results for a query, the result array is padded with -1s. :type x: uint8_t :param x: input vectors to search, size n * d / 8 :type labels: int :param labels: output labels of the NNs, size n*k :type distances: int :param distances: output pairwise distances, size n*k )rZIndexBinary_searchrsrrrruP"szIndexBinary.searchcCst||||||S)a Query n vectors of dimension d to the index. return all vectors with distance < radius. Note that many indexes do not implement the range_search (only the k-NN search is mandatory). The distances are converted to float to reuse the RangeSearchResult structure, but they are integer. By convention, only distances < radius (strict comparison) are returned, ie. radius = 0 does not return any result and 1 returns only exact same vectors. :type x: uint8_t :param x: input vectors to search, size n * d / 8 :type radius: int :param radius: search radius :type result: :py:class:`RangeSearchResult` :param result: result table )rZIndexBinary_range_searchrvrrrrw`"szIndexBinary.range_searchrcCst|||||S)a` Return the indexes of the k vectors closest to the query x. This function is identical to search but only returns labels of neighbors. :type x: uint8_t :param x: input vectors to search, size n * d / 8 :type labels: int :param labels: output labels of the NNs, size n*k )rZIndexBinary_assignrxrrrryu"s zIndexBinary.assigncCs t|S)z( Removes all elements from the database.)rZIndexBinary_resetr@rrrr|"szIndexBinary.resetcCs t||S)z: Removes IDs from the index. Not supported by all indexes.)rZIndexBinary_remove_idsrzrrrr{"szIndexBinary.remove_idscCst|||S)a Reconstruct a stored vector. This function may not be defined for some indexes. :type key: int :param key: id of the vector to reconstruct :type recons: uint8_t :param recons: reconstucted vector (size d / 8) )rZIndexBinary_reconstructr|rrrr"s zIndexBinary.reconstructcCst||||S)z Reconstruct vectors i0 to i0 + ni - 1. This function may not be defined for some indexes. :type recons: uint8_t :param recons: reconstucted vectors (size ni * d / 8) )rZIndexBinary_reconstruct_nrrrrr"szIndexBinary.reconstruct_nc Cst||||||||S)af Similar to search, but also reconstructs the stored vectors (or an approximation in the case of lossy coding) for the search results. If there are not enough results for a query, the resulting array is padded with -1s. :type recons: uint8_t :param recons: reconstructed vectors size (n, k, d) )rZ"IndexBinary_search_and_reconstructrrrrr"s z"IndexBinary.search_and_reconstructcCs t|S)z2 Display the actual class name and some more info.)rZIndexBinary_displayr@rrrdisplay"szIndexBinary.displayrcCst|||Sr)rZIndexBinary_merge_fromrrrrr"szIndexBinary.merge_fromcCs t||Sr)rZ&IndexBinary_check_compatible_for_mergerrrrr"sz&IndexBinary.check_compatible_for_mergecCs t|Sr)rZIndexBinary_sa_code_sizer@rrrr"szIndexBinary.sa_code_sizecCst||||S)z& Same as add_with_ids for IndexBinary.)rZIndexBinary_add_sa_codesrrrrr"szIndexBinary.add_sa_codes)N)N)r)N)r).r r r,r-rrr?rrrZIndexBinary_d_getZIndexBinary_d_setrZIndexBinary_code_size_getZIndexBinary_code_size_setrZIndexBinary_ntotal_getZIndexBinary_ntotal_setrZIndexBinary_verbose_getZIndexBinary_verbose_setrZIndexBinary_is_trained_getZIndexBinary_is_trained_setrZIndexBinary_metric_type_getZIndexBinary_metric_type_setrfZdelete_IndexBinaryrTrnrorrrurwryr|r{rrrrrrrrrrrrr"s6         rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejZeejejZd d Zd d ZdddZdddZddZddZddZejZd S)IndexBinaryFlatzC Index that stores the full vectors and performs exhaustive search.cCs |jSr#r0r1rrrr3"r4zIndexBinaryFlat.cCs |j|Sr#r0r5rrrr3"r4r7r8z& database vectors, size ntotal * d / 8t Select between using a heap or counting to select the k smallest values when scanning inverted lists. cCst|||Sr#)rZIndexBinaryFlat_addrmrrrro"szIndexBinaryFlat.addcCs t|Sr#)rZIndexBinaryFlat_resetr@rrrr|"szIndexBinaryFlat.resetNc Cst|||||||Sr#)rZIndexBinaryFlat_searchrsrrrru"szIndexBinaryFlat.searchcCst||||||Sr#)rZIndexBinaryFlat_range_searchrvrrrrw"szIndexBinaryFlat.range_searchcCst|||Sr#)rZIndexBinaryFlat_reconstructr|rrrr"szIndexBinaryFlat.reconstructcCs t||S)z Remove some ids. Note that because of the indexing structure, the semantics of this operation are different from the usual ones: the new ids are shifted. )rZIndexBinaryFlat_remove_idsrzrrrr{"szIndexBinaryFlat.remove_idscGst|tj|dSr#)rZIndexBinaryFlat_swiginitZnew_IndexBinaryFlatrQrrrr?"szIndexBinaryFlat.__init__)N)N)r r r,r-rrrrrZIndexBinaryFlat_xb_getZIndexBinaryFlat_xb_setr ZIndexBinaryFlat_use_heap_getZIndexBinaryFlat_use_heap_setuse_heapZ$IndexBinaryFlat_query_batch_size_getZ$IndexBinaryFlat_query_batch_size_setZquery_batch_sizeZ$IndexBinaryFlat_approx_topk_mode_getZ$IndexBinaryFlat_approx_topk_mode_setr<ror|rurwrr{r?Zdelete_IndexBinaryFlatrTrrrrr"s  rc@seZdZdZeddddddZeZeej ej ddZ eej ej ZeejejddZeejejd dZeejejd dZeejejd dZeejejd dZeejejd dZ eej!ej"ddZ#eej$ej%ddZ&eej'ej(ddZ)eej*ej+ddZ,ddZ-ej.Z/ddZ0ddZ1ddZ2ddZ3ddZ4dAdd Z5dBd"d#Z6dCd$d%Z7dDd&d'Z8d(d)Z9d*d+Z:d,d-Z;dEd.d/Zd4d5Z?d6d7Z@d8d9ZAdFd;d<ZBd=d>ZCdGd?d@ZDdS)HIndexBinaryIVFa_ Index based on a inverted file (IVF) In the inverted file, the quantizer (an IndexBinary instance) provides a quantization index for each vector to be added. The quantization index maps to a list (aka inverted list or posting list), where the id of the vector is stored. Otherwise the object is similar to the IndexIVF cCs |jSr#r0r1rrrr3#r4zIndexBinaryIVF.cCs |j|Sr#r0r5rrrr3#r4r7r8rorarbrz collect computations per batchz> map for direct access to the elements. Enables reconstruct().rVrrWrXrYcGst|tj|dSr#)rZIndexBinaryIVF_swiginitZnew_IndexBinaryIVFrQrrrr?#szIndexBinaryIVF.__init__cCs t|Sr#)rZIndexBinaryIVF_resetr@rrrr|#szIndexBinaryIVF.resetcCst|||S)z Trains the quantizer)rZIndexBinaryIVF_trainrmrrrrn#szIndexBinaryIVF.traincCst|||Sr#)rZIndexBinaryIVF_addrmrrrro#szIndexBinaryIVF.addcCst||||Sr#)rZIndexBinaryIVF_add_with_idsrprrrrr"#szIndexBinaryIVF.add_with_idscCst|||||S)z Implementation of vector addition where the vector assignments are predefined. :type precomputed_idx: int :param precomputed_idx: quantization indices for the input vectors (size n) )rZIndexBinaryIVF_add_core)rrBr2rqrqrrrrr%#s zIndexBinaryIVF.add_coreNc Cst|||||||||| S)aB Search a set of vectors, that are pre-quantized by the IVF quantizer. Fill in the corresponding heaps with the query results. search() calls this. :type n: int :param n: nb of vectors to query :type x: uint8_t :param x: query vectors, size nx * d :type assign: int :param assign: coarse quantization indices, size nx * nprobe :type centroid_dis: int :param centroid_dis: distances to coarse centroids, size nx * nprobe :param distance: output distances, size n * k :type labels: int :param labels: output labels, size n * k :type store_pairs: boolean :param store_pairs: store inv list index + inv list offset instead in upper/lower 32 bit of result, instead of ids (used for reranking). :type params: :py:class:`IVFSearchParameters`, optional :param params: used to override the object's search parameters )rZ!IndexBinaryIVF_search_preassigned) rrBr2rryrgrrrhrtrrrrj0#sz!IndexBinaryIVF.search_preassignedFcCs t||Sr#)rZ&IndexBinaryIVF_get_InvertedListScanner)rrhrrrr{L#sz&IndexBinaryIVF.get_InvertedListScannerc Cst|||||||Sry)rZIndexBinaryIVF_searchrsrrrruO#szIndexBinaryIVF.searchcCst||||||Sr#)rZIndexBinaryIVF_range_searchrvrrrrwS#szIndexBinaryIVF.range_searchc Cst|||||||Sr#)rZ'IndexBinaryIVF_range_search_preassigned)rrBr2rryrgrrrrrmV#sz'IndexBinaryIVF.range_search_preassignedcCst|||Sr#)rZIndexBinaryIVF_reconstructr|rrrrY#szIndexBinaryIVF.reconstructcCst||||S)a Reconstruct a subset of the indexed vectors. Overrides default implementation to bypass reconstruct() which requires direct_map to be maintained. :type i0: int :param i0: first vector to reconstruct :type ni: int :param ni: nb of vectors to reconstruct :type recons: uint8_t :param recons: output array of reconstructed vectors, size ni * d / 8 )rZIndexBinaryIVF_reconstruct_nrrrrr\#szIndexBinaryIVF.reconstruct_nc Cst||||||||S)a Similar to search, but also reconstructs the stored vectors (or an approximation in the case of lossy coding) for the search results. Overrides default implementation to avoid having to maintain direct_map and instead fetch the code offsets through the `store_pairs` flag in search_preassigned(). :type recons: uint8_t :param recons: reconstructed vectors size (n, k, d / 8) )rZ%IndexBinaryIVF_search_and_reconstructrrrrrl#s z%IndexBinaryIVF.search_and_reconstructcCst||||Sr)rZ&IndexBinaryIVF_reconstruct_from_offsetrrrrrz#s z&IndexBinaryIVF.reconstruct_from_offsetcCs t||Sr)rZIndexBinaryIVF_remove_idsrzrrrr{#szIndexBinaryIVF.remove_idscCst|||Sr#)rZIndexBinaryIVF_merge_from)rr_rrrrr#szIndexBinaryIVF.merge_fromcCs t||Sr#)rZ)IndexBinaryIVF_check_compatible_for_mergerrrrr#sz)IndexBinaryIVF.check_compatible_for_mergecCs t||Sr#)rZIndexBinaryIVF_get_list_sizerrrrr#szIndexBinaryIVF.get_list_sizeTcCs t||Sr)rZIndexBinaryIVF_make_direct_maprrrrr#szIndexBinaryIVF.make_direct_mapcCs t||Sr#)rZ"IndexBinaryIVF_set_direct_map_typerrrrr#sz"IndexBinaryIVF.set_direct_map_typecCst|||Sr#)rZIndexBinaryIVF_replace_invlistsrrrrr#szIndexBinaryIVF.replace_invlists)N)F)N)N)N)T)F)Er r r,r-rrrrrZIndexBinaryIVF_invlists_getZIndexBinaryIVF_invlists_setrKZIndexBinaryIVF_own_invlists_getZIndexBinaryIVF_own_invlists_setrZIndexBinaryIVF_nprobe_getZIndexBinaryIVF_nprobe_setrcZIndexBinaryIVF_max_codes_getZIndexBinaryIVF_max_codes_setrdZIndexBinaryIVF_use_heap_getZIndexBinaryIVF_use_heap_setrZ%IndexBinaryIVF_per_invlist_search_getZ%IndexBinaryIVF_per_invlist_search_setZper_invlist_searchZIndexBinaryIVF_direct_map_getZIndexBinaryIVF_direct_map_setrTZIndexBinaryIVF_quantizer_getZIndexBinaryIVF_quantizer_setr^ZIndexBinaryIVF_nlist_getZIndexBinaryIVF_nlist_setrZIndexBinaryIVF_own_fields_getZIndexBinaryIVF_own_fields_setrZIndexBinaryIVF_cp_getZIndexBinaryIVF_cp_setrZ#IndexBinaryIVF_clustering_index_getZ#IndexBinaryIVF_clustering_index_setr_r?Zdelete_IndexBinaryIVFrTr|rnrorrrrrjr{rurwrmrrrrr{rrrrrrrrrrr"sL        rc@s\eZdZeddddddZddZeZdd Zd d Z d d Z ddZ ddZ e jZdS)BinaryInvertedListScannercCs |jSr#r0r1rrrr3#r4z"BinaryInvertedListScanner.cCs |j|Sr#r0r5rrrr3#r4r7r8cOs tddSr:r;r<rrrr?#sz"BinaryInvertedListScanner.__init__cCs t||Sr)rZ#BinaryInvertedListScanner_set_queryrrrrr#sz#BinaryInvertedListScanner.set_querycCst|||Sr)rZ"BinaryInvertedListScanner_set_listrrrrr#sz"BinaryInvertedListScanner.set_listcCs t||Sr)rZ*BinaryInvertedListScanner_distance_to_coderrrrr#sz*BinaryInvertedListScanner.distance_to_codec Cst|||||||S)a@ compute the distances to codes. (distances, labels) should be organized as a min- or max-heap :type n: int :param n: number of codes to scan :type codes: uint8_t :param codes: codes to scan (n * code_size) :type ids: int :param ids: corresponding ids (ignored if store_pairs) :type distances: int :param distances: heap distances (size k) :type labels: int :param labels: heap labels (size k) :type k: int :param k: heap size )rZ$BinaryInvertedListScanner_scan_codesrrrrr#sz$BinaryInvertedListScanner.scan_codescCst||||||Sr#)rZ*BinaryInvertedListScanner_scan_codes_rangerrrrr#sz*BinaryInvertedListScanner.scan_codes_rangeN)r r r,rrr?rrrrrrrrZ delete_BinaryInvertedListScannerrTrrrrr#src@szeZdZdZeddddddZeZeej ej Z eej ej ddZdd ZejZd d Zd d ZdddZddZdS)IndexBinaryFromFloatz IndexBinary backed by a float Index. Supports adding vertices and searching them. All queries are symmetric because there is no distinction between codes and vectors. cCs |jSr#r0r1rrrr3#r4zIndexBinaryFromFloat.cCs |j|Sr#r0r5rrrr3#r4r7r8z' Whether object owns the index pointer.cGst|tj|dSr#)rZIndexBinaryFromFloat_swiginitZnew_IndexBinaryFromFloatrQrrrr?#szIndexBinaryFromFloat.__init__cCst|||Sr#)rZIndexBinaryFromFloat_addrmrrrro#szIndexBinaryFromFloat.addcCs t|Sr#)rZIndexBinaryFromFloat_resetr@rrrr|#szIndexBinaryFromFloat.resetNc Cst|||||||Sr#)rZIndexBinaryFromFloat_searchrsrrrru#szIndexBinaryFromFloat.searchcCst|||Sr#)rZIndexBinaryFromFloat_trainrmrrrrn#szIndexBinaryFromFloat.train)N)r r r,r-rrrrrZIndexBinaryFromFloat_index_getZIndexBinaryFromFloat_index_setrZ#IndexBinaryFromFloat_own_fields_getZ#IndexBinaryFromFloat_own_fields_setrr?Zdelete_IndexBinaryFromFloatrTror|rurnrrrrr#s  rc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZddZejZd d Zd d Zd dZdddZddZddZdS)IndexBinaryHNSWrcCs |jSr#r0r1rrrr3#r4zIndexBinaryHNSW.cCs |j|Sr#r0r5rrrr3#r4r7r8cGst|tj|dSr#)rZIndexBinaryHNSW_swiginitZnew_IndexBinaryHNSWrQrrrr?#szIndexBinaryHNSW.__init__cCs t|Sr#)rZ%IndexBinaryHNSW_get_distance_computerr@rrrr$sz%IndexBinaryHNSW.get_distance_computercCst|||Sr#)rZIndexBinaryHNSW_addrmrrrro$szIndexBinaryHNSW.addcCst|||Sr)rZIndexBinaryHNSW_trainrmrrrrn$szIndexBinaryHNSW.trainNc Cst|||||||Sr)rZIndexBinaryHNSW_searchrsrrrru $szIndexBinaryHNSW.searchcCst|||Sr#)rZIndexBinaryHNSW_reconstructr|rrrr$szIndexBinaryHNSW.reconstructcCs t|Sr#)rZIndexBinaryHNSW_resetr@rrrr|$szIndexBinaryHNSW.reset)N)r r r,r-rrrrrZIndexBinaryHNSW_hnsw_getZIndexBinaryHNSW_hnsw_setrZIndexBinaryHNSW_own_fields_getZIndexBinaryHNSW_own_fields_setrZIndexBinaryHNSW_storage_getZIndexBinaryHNSW_storage_setrr?Zdelete_IndexBinaryHNSWrTrrornrurr|rrrrr#s rc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZddZd d Zd d Zd dZdddZdddZddZddZejZdS)IndexBinaryHash+ just uses the b first bits as a hash valuecCs |jSr#r0r1rrrr3$r4zIndexBinaryHash.cCs |j|Sr#r0r5rrrr3$r4r7r8cGst|tj|dSr#)rZIndexBinaryHash_swiginitZnew_IndexBinaryHashrQrrrr?!$szIndexBinaryHash.__init__cCs t|Sr#)rZIndexBinaryHash_resetr@rrrr|$$szIndexBinaryHash.resetcCst|||Sr#)rZIndexBinaryHash_addrmrrrro'$szIndexBinaryHash.addcCst||||Sr#)rZIndexBinaryHash_add_with_idsrprrrrr*$szIndexBinaryHash.add_with_idsNcCst||||||Sr#)rZIndexBinaryHash_range_searchrvrrrrw-$szIndexBinaryHash.range_searchc Cst|||||||Sr#)rZIndexBinaryHash_searchrsrrrru0$szIndexBinaryHash.searchcCs t|Sr#)rZIndexBinaryHash_displayr@rrrr3$szIndexBinaryHash.displaycCs t|Sr#)rZIndexBinaryHash_hashtable_sizer@rrrhashtable_size6$szIndexBinaryHash.hashtable_size)N)N)r r r,r-rrrrrZIndexBinaryHash_invlists_getZIndexBinaryHash_invlists_setrKZIndexBinaryHash_b_getZIndexBinaryHash_b_setr~ZIndexBinaryHash_nflip_getZIndexBinaryHash_nflip_setnflipr?r|rorrrwrurrZdelete_IndexBinaryHashrTrrrrr$s  rc@steZdZeddddddZeZeejej Z eej ej Z eejejZeejejZddZdd ZejZd S) IndexBinaryHashStatscCs |jSr#r0r1rrrr3=$r4zIndexBinaryHashStats.cCs |j|Sr#r0r5rrrr3=$r4r7r8cCst|tdSr#)rZIndexBinaryHashStats_swiginitZnew_IndexBinaryHashStatsr@rrrr?D$szIndexBinaryHashStats.__init__cCs t|Sr#)rZIndexBinaryHashStats_resetr@rrrr|G$szIndexBinaryHashStats.resetN)r r r,rrrrrZIndexBinaryHashStats_nq_getZIndexBinaryHashStats_nq_setrZIndexBinaryHashStats_n0_getZIndexBinaryHashStats_n0_setn0ZIndexBinaryHashStats_nlist_getZIndexBinaryHashStats_nlist_setrZIndexBinaryHashStats_ndis_getZIndexBinaryHashStats_ndis_setrr?r|Zdelete_IndexBinaryHashStatsrTrrrrr<$src@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejddZeejejddZeejejd dZd d ZejZd d ZddZdddZ dddZ!ddZ"dS)IndexBinaryMultiHashrcCs |jSr#r0r1rrrr3P$r4zIndexBinaryMultiHash.cCs |j|Sr#r0r5rrrr3P$r4r7r8z nb of hash mapsz nb bits per hash mapz# nb bit flips to use at search timecGst|tj|dSr#)rZIndexBinaryMultiHash_swiginitZnew_IndexBinaryMultiHashrQrrrr?Y$szIndexBinaryMultiHash.__init__cCs t|Sr#)rZIndexBinaryMultiHash_resetr@rrrr|]$szIndexBinaryMultiHash.resetcCst|||Sr#)rZIndexBinaryMultiHash_addrmrrrro`$szIndexBinaryMultiHash.addNcCst||||||Sr#)rZ!IndexBinaryMultiHash_range_searchrvrrrrwc$sz!IndexBinaryMultiHash.range_searchc Cst|||||||Sr#)rZIndexBinaryMultiHash_searchrsrrrruf$szIndexBinaryMultiHash.searchcCs t|Sr#)rZ#IndexBinaryMultiHash_hashtable_sizer@rrrri$sz#IndexBinaryMultiHash.hashtable_size)N)N)#r r r,r-rrrrrZ IndexBinaryMultiHash_storage_getZ IndexBinaryMultiHash_storage_setrZ#IndexBinaryMultiHash_own_fields_getZ#IndexBinaryMultiHash_own_fields_setrZIndexBinaryMultiHash_maps_getZIndexBinaryMultiHash_maps_setmapsZIndexBinaryMultiHash_nhash_getZIndexBinaryMultiHash_nhash_setZnhashZIndexBinaryMultiHash_b_getZIndexBinaryMultiHash_b_setr~ZIndexBinaryMultiHash_nflip_getZIndexBinaryMultiHash_nflip_setrr?Zdelete_IndexBinaryMultiHashrTr|rorwrurrrrrrM$s   rc@szeZdZdZeddddddZddZeZe j Z d d Z d d Z d dZddZddZddZee je jddZdS)ThreadedIndexBaser A holder of indices in a collection of threads The interface to this class itself is not thread safe cCs |jSr#r0r1rrrr3t$r4zThreadedIndexBase.cCs |j|Sr#r0r5rrrr3t$r4r7r8cOs tddSr:r;r<rrrr?v$szThreadedIndexBase.__init__cCs t||Sa override an index that is managed by ourselves. WARNING: once an index is added, it becomes unsafe to touch it from any other thread than that on which is managing it, until we are shut down. Use runOnIndex to perform work on it instead. )rZThreadedIndexBase_addIndexrrrraddIndex{$szThreadedIndexBase.addIndexcCs t||Sz Remove an index that is managed by ourselves. This will flush all pending work on that index, and then shut down its managing thread, and will remove the index. )rZThreadedIndexBase_removeIndexrrrr removeIndex$szThreadedIndexBase.removeIndexcGstj|g|RSr#)rZThreadedIndexBase_runOnIndexrQrrr runOnIndex$szThreadedIndexBase.runOnIndexcCs t|SzL faiss::Index API All indices receive the same call )rZThreadedIndexBase_resetr@rrrr|$szThreadedIndexBase.resetcCs t|Sz" Returns the number of sub-indices)rZThreadedIndexBase_countr@rrrr_$szThreadedIndexBase.countcGstj|g|RSz *Overload 1:* Returns the i-th sub-index | *Overload 2:* Returns the i-th sub-index (const version) )rZThreadedIndexBase_atrQrrrr\$s zThreadedIndexBase.atE Whether or not we are responsible for deleting our contained indicesN)r r r,r-rrr?rrrZdelete_ThreadedIndexBaserTrrrr|r_r\Z!ThreadedIndexBase_own_indices_getZ!ThreadedIndexBase_own_indices_set own_indicesrrrrrn$s  rc@szeZdZdZeddddddZddZeZe j Z d d Z d d Z d dZddZddZddZee je jddZdS)ThreadedIndexBaseBinaryrcCs |jSr#r0r1rrrr3$r4z ThreadedIndexBaseBinary.cCs |j|Sr#r0r5rrrr3$r4r7r8cOs tddSr:r;r<rrrr?$sz ThreadedIndexBaseBinary.__init__cCs t||Sr)rZ ThreadedIndexBaseBinary_addIndexrrrrr$sz ThreadedIndexBaseBinary.addIndexcCs t||Sr)rZ#ThreadedIndexBaseBinary_removeIndexrrrrr$sz#ThreadedIndexBaseBinary.removeIndexcGstj|g|RSr#)rZ"ThreadedIndexBaseBinary_runOnIndexrQrrrr$sz"ThreadedIndexBaseBinary.runOnIndexcCs t|Sr)rZThreadedIndexBaseBinary_resetr@rrrr|$szThreadedIndexBaseBinary.resetcCs t|Sr)rZThreadedIndexBaseBinary_countr@rrrr_$szThreadedIndexBaseBinary.countcGstj|g|RSr)rZThreadedIndexBaseBinary_atrQrrrr\$s zThreadedIndexBaseBinary.atrN)r r r,r-rrr?rrrZdelete_ThreadedIndexBaseBinaryrTrrrr|r_r\Z'ThreadedIndexBaseBinary_own_indices_getZ'ThreadedIndexBaseBinary_own_indices_setrrrrrr$s  rc@seZdZdZeddddddZeZddZd d Z d d Z d dZ ddZ dddZ ddZeejejZddZejZdS) IndexShardscCs |j|Sr#r0r5rrrr3$r4r7r8cGst|tj|dSa7 *Overload 1:* The dimension that all sub-indices must share will be the dimension of the first sub-index added :type threaded: boolean, optional :param threaded: do we use one thread per sub_index or do queries sequentially? :type successive_ids: boolean, optional :param successive_ids: should we shift the returned ids by the size of each sub-index or return them as they are? | *Overload 2:* :type threaded: boolean, optional :param threaded: do we use one thread per sub_index or do queries sequentially? :type successive_ids: boolean, optional :param successive_ids: should we shift the returned ids by the size of each sub-index or return them as they are? | *Overload 3:* :type threaded: boolean, optional :param threaded: do we use one thread per sub_index or do queries sequentially? :param successive_ids: should we shift the returned ids by the size of each sub-index or return them as they are? | *Overload 4:* :param threaded: do we use one thread per sub_index or do queries sequentially? :param successive_ids: should we shift the returned ids by the size of each sub-index or return them as they are? | *Overload 5:* int version due to the implicit bool conversion ambiguity of int as dimension | *Overload 6:* int version due to the implicit bool conversion ambiguity of int as dimension | *Overload 7:* int version due to the implicit bool conversion ambiguity of int as dimension N)rZIndexShards_swiginitZnew_IndexShardsrQrrrr?$sBzIndexShards.__init__cCs t||Sz Alias for addIndex())rZIndexShards_add_shardrrrr add_shard.%szIndexShards.add_shardcCs t||Sz Alias for removeIndex())rZIndexShards_remove_shardrrrr remove_shard2%szIndexShards.remove_shardcCst|||Sz; supported only for sub-indices that implement add_with_ids)rZIndexShards_addrmrrrro6%szIndexShards.addcCst||||Sa> Cases (successive_ids, xids): - true, non-NULL ERROR: it makes no sense to pass in ids and request them to be shifted - true, NULL OK: but should be called only once (calls add() on sub-indexes). - false, non-NULL OK: will call add_with_ids with passed in xids distributed evenly over shards - false, NULL OK: will call add_with_ids on each sub-index, starting at ntotal )rZIndexShards_add_with_idsrprrrrr:%s zIndexShards.add_with_idsNc Cst|||||||Sr#)rZIndexShards_searchrsrrrruH%szIndexShards.searchcCst|||Sr#)rZIndexShards_trainrmrrrrnK%szIndexShards.traincCs t|Szd Synchronize the top-level index (IndexShards) with data in the sub-indices )rZIndexShards_syncWithSubIndexesr@rrrsyncWithSubIndexesO%szIndexShards.syncWithSubIndexes)N)r r r,r-rrrrr?rrrorrrurnrZIndexShards_successive_ids_getZIndexShards_successive_ids_setsuccessive_idsrZdelete_IndexShardsrTrrrrr$sD rc@seZdZdZeddddddZeZddZd d Z d d Z d dZ ddZ dddZ ddZeejejZddZejZdS)IndexBinaryShardsrcCs |jSr#r0r1rrrr3\%r4zIndexBinaryShards.cCs |j|Sr#r0r5rrrr3\%r4r7r8cGst|tj|dSr)rZIndexBinaryShards_swiginitZnew_IndexBinaryShardsrQrrrr?_%sBzIndexBinaryShards.__init__cCs t||Sr)rZIndexBinaryShards_add_shardrrrrr%szIndexBinaryShards.add_shardcCs t||Sr)rZIndexBinaryShards_remove_shardrrrrr%szIndexBinaryShards.remove_shardcCst|||Sr)rZIndexBinaryShards_addrmrrrro%szIndexBinaryShards.addcCst||||Sr)rZIndexBinaryShards_add_with_idsrprrrrr%s zIndexBinaryShards.add_with_idsNc Cst|||||||Sr#)rZIndexBinaryShards_searchrsrrrru%szIndexBinaryShards.searchcCst|||Sr#)rZIndexBinaryShards_trainrmrrrrn%szIndexBinaryShards.traincCs t|Sr)rZ$IndexBinaryShards_syncWithSubIndexesr@rrrr%sz$IndexBinaryShards.syncWithSubIndexes)N)r r r,r-rrrrr?rrrorrrurnrZ$IndexBinaryShards_successive_ids_getZ$IndexBinaryShards_successive_ids_setrrZdelete_IndexBinaryShardsrTrrrrrY%sD rc@s\eZdZdZeddddddZeZdd d Zd d Z d dZ ddZ dddZ e jZdS)IndexShardsIVFz IndexShards with a common coarse quantizer. All the indexes added should be IndexIVFInterface indexes so that the search_precomputed can be called. cCs |jSr#r0r1rrrr3%r4zIndexShardsIVF.cCs |j|Sr#r0r5rrrr3%r4r7r8FTc Cst|t||||dSr#)rZIndexShardsIVF_swiginitZnew_IndexShardsIVF)rr^rthreadedrrrrr?%szIndexShardsIVF.__init__cCs t||Sr#)rZIndexShardsIVF_addIndexrrrrr%szIndexShardsIVF.addIndexcCst||||Sr#)rZIndexShardsIVF_add_with_idsrprrrrr%szIndexShardsIVF.add_with_idscCst|||Sr#)rZIndexShardsIVF_trainrmrrrrn%szIndexShardsIVF.trainNc Cst|||||||Sr#)rZIndexShardsIVF_searchrsrrrru%szIndexShardsIVF.search)FT)N)r r r,r-rrrrr?rrrrnrurZdelete_IndexShardsIVFrTrrrrr%s  rc@sreZdZdZeddddddZeZddZd d Z d d Z d dZ ddZ dddZ ddZddZejZdS) IndexReplicas Takes individual faiss::Index instances, and splits queries for sending to each Index instance, and joins the results together when done. Each index is managed by a separate CPU thread. cCs |jSr#r0r1rrrr3%r4zIndexReplicas.cCs |j|Sr#r0r5rrrr3%r4r7r8cGst|tj|dSa *Overload 1:* The dimension that all sub-indices must share will be the dimension of the first sub-index added :type threaded: boolean, optional :param threaded: do we use one thread per sub-index or do queries sequentially? | *Overload 2:* :type d: int :param d: the dimension that all sub-indices must share :type threaded: boolean, optional :param threaded: do we use one thread per sub index or do queries sequentially? | *Overload 3:* :type d: int :param d: the dimension that all sub-indices must share :param threaded: do we use one thread per sub index or do queries sequentially? | *Overload 4:* int version due to the implicit bool conversion ambiguity of int as dimension | *Overload 5:* int version due to the implicit bool conversion ambiguity of int as dimension N)rZIndexReplicas_swiginitZnew_IndexReplicasrQrrrr?%s&zIndexReplicas.__init__cCs t||Sr)rZIndexReplicas_add_replicarrrr add_replica&szIndexReplicas.add_replicacCs t||Sr)rZIndexReplicas_remove_replicarrrrremove_replica &szIndexReplicas.remove_replicacCst|||Sr)rZIndexReplicas_trainrmrrrrn$&szIndexReplicas.traincCst|||Sr)rZIndexReplicas_addrmrrrro+&szIndexReplicas.addNc Cst|||||||Sz faiss::Index API Query is partitioned into a slice for each sub-index split by ceil(n / #indices) for our sub-indices )rZIndexReplicas_searchrsrrrru2&szIndexReplicas.searchcCst|||Sz" reconstructs from the first index)rZIndexReplicas_reconstructrrWr6rrrr:&szIndexReplicas.reconstructcCs t|Sr)rZ IndexReplicas_syncWithSubIndexesr@rrrr>&sz IndexReplicas.syncWithSubIndexes)N)r r r,r-rrrrr?rrrnrorurrrZdelete_IndexReplicasrTrrrrr%s( rc@sreZdZdZeddddddZeZddZd d Z d d Z d dZ ddZ dddZ ddZddZejZdS)IndexBinaryReplicasrcCs |jSr#r0r1rrrr3P&r4zIndexBinaryReplicas.cCs |j|Sr#r0r5rrrr3P&r4r7r8cGst|tj|dSr)rZIndexBinaryReplicas_swiginitZnew_IndexBinaryReplicasrQrrrr?S&s&zIndexBinaryReplicas.__init__cCs t||Sr)rZIndexBinaryReplicas_add_replicarrrrr{&szIndexBinaryReplicas.add_replicacCs t||Sr)rZ"IndexBinaryReplicas_remove_replicarrrrr&sz"IndexBinaryReplicas.remove_replicacCst|||Sr)rZIndexBinaryReplicas_trainrmrrrrn&szIndexBinaryReplicas.traincCst|||Sr)rZIndexBinaryReplicas_addrmrrrro&szIndexBinaryReplicas.addNc Cst|||||||Sr)rZIndexBinaryReplicas_searchrsrrrru&szIndexBinaryReplicas.searchcCst|||Sr)rZIndexBinaryReplicas_reconstructrrrrr&szIndexBinaryReplicas.reconstructcCs t|Sr)rZ&IndexBinaryReplicas_syncWithSubIndexesr@rrrr&sz&IndexBinaryReplicas.syncWithSubIndexes)N)r r r,r-rrrrr?rrrnrorurrrZdelete_IndexBinaryReplicasrTrrrrrH&s( rc@seZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZddd Zd d Zd d ZddZdddZddZddZejZdS)IndexSplitVectorsz splits input vectors in segments and assigns each segment to a sub-index used to distribute a MultiIndexQuantizer cCs |jSr#r0r1rrrr3&r4zIndexSplitVectors.cCs |j|Sr#r0r5rrrr3&r4r7r8FcCst|t||dS)z sum of dimensions seen so farN)rZIndexSplitVectors_swiginitZnew_IndexSplitVectors)rrrrrrr?&szIndexSplitVectors.__init__cCs t||Sr#)rZIndexSplitVectors_add_sub_indexrVrrr add_sub_index&szIndexSplitVectors.add_sub_indexcCs t|Sr#)rZ'IndexSplitVectors_sync_with_sub_indexesr@rrrsync_with_sub_indexes&sz'IndexSplitVectors.sync_with_sub_indexescCst|||Sr#)rZIndexSplitVectors_addrmrrrro&szIndexSplitVectors.addNc Cst|||||||Sr#)rZIndexSplitVectors_searchrsrrrru&szIndexSplitVectors.searchcCst|||Sr#)rZIndexSplitVectors_trainrmrrrrn&szIndexSplitVectors.traincCs t|Sr#)rZIndexSplitVectors_resetr@rrrr|&szIndexSplitVectors.reset)F)N)r r r,r-rrrrrZ IndexSplitVectors_own_fields_getZ IndexSplitVectors_own_fields_setrZIndexSplitVectors_threaded_getZIndexSplitVectors_threaded_setrZ!IndexSplitVectors_sub_indexes_getZ!IndexSplitVectors_sub_indexes_setZ sub_indexesZIndexSplitVectors_sum_d_getZIndexSplitVectors_sum_d_setZsum_dr?rrrorurnr|Zdelete_IndexSplitVectorsrTrrrrr&s  rc@sheZdZdZeddddddZeZeej ej Z ddZ d d Z dd d ZddZddZejZd S) IndexRandomzQ index that returns random results. used mainly for time benchmarks cCs |jSr#r0r1rrrr3&r4zIndexRandom.cCs |j|Sr#r0r5rrrr3&r4r7r8cGst|tj|dSr#)rZIndexRandom_swiginitZnew_IndexRandomrQrrrr?&szIndexRandom.__init__cCst|||Sr#)rZIndexRandom_addrmrrrro&szIndexRandom.addNc Cst|||||||Sr#)rZIndexRandom_searchrsrrrru&szIndexRandom.searchcCst|||Sr#)rZIndexRandom_reconstructr|rrrr&szIndexRandom.reconstructcCs t|Sr#)rZIndexRandom_resetr@rrrr|&szIndexRandom.reset)N)r r r,r-rrrrrZIndexRandom_seed_getZIndexRandom_seed_setrr?rorurr|Zdelete_IndexRandomrTrrrrr&s rc@s~eZdZdZeddddddZddZeZee j e j d dZ ee j e jd dZe jZd d ZdddZddZddZd S)IndexRowwiseMinMaxBasea Index wrapper that performs rowwise normalization to [0,1], preserving the coefficients. This is a vector codec index only. Basically, this index performs a rowwise scaling to [0,1] of every row in an input dataset before calling subindex::train() and subindex::sa_encode(). sa_encode() call stores the scaling coefficients (scaler and minv) in the very beginning of every output code. The format: [scaler][minv][subindex::sa_encode() output] The de-scaling in sa_decode() is done using: output_rescaled = scaler * output + minv An additional ::train_inplace() function is provided in order to do an inplace scaling before calling subindex::train() and, thus, avoiding the cloning of the input dataset, but modifying the input dataset because of the scaling and the scaling back. It is up to user to call this function instead of ::train() Derived classes provide different data types for scaling coefficients. Currently, versions with fp16 and fp32 scaling coefficients are available. fp16 version adds 4 extra bytes per encoded vector fp32 version adds 8 extra bytes per encoded vector Provides base functions for rowwise normalizing indices. cCs |jSr#r0r1rrrr3'r4zIndexRowwiseMinMaxBase.cCs |j|Sr#r0r5rrrr3'r4r7r8cOs tddSr:r;r<rrrr?'szIndexRowwiseMinMaxBase.__init__z sub-indexz: whether the subindex needs to be freed in the destructor.cCst|||Sr#)rZIndexRowwiseMinMaxBase_addrmrrrro 'szIndexRowwiseMinMaxBase.addNc Cst|||||||Sr#)rZIndexRowwiseMinMaxBase_searchrsrrrru'szIndexRowwiseMinMaxBase.searchcCs t|Sr#)rZIndexRowwiseMinMaxBase_resetr@rrrr|'szIndexRowwiseMinMaxBase.resetcCst|||Sr#)rZ$IndexRowwiseMinMaxBase_train_inplacermrrr train_inplace'sz$IndexRowwiseMinMaxBase.train_inplace)N)r r r,r-rrr?rrrZ IndexRowwiseMinMaxBase_index_getZ IndexRowwiseMinMaxBase_index_setrZ%IndexRowwiseMinMaxBase_own_fields_getZ%IndexRowwiseMinMaxBase_own_fields_setrZdelete_IndexRowwiseMinMaxBaserTrorur|rrrrrr&s rc@s`eZdZdZeddddddZeZddZd d Z d d Z d dZ ddZ ddZ ejZdS)IndexRowwiseMinMaxFP16z, Stores scaling coefficients as fp16 values.cCs |jSr#r0r1rrrr3'r4zIndexRowwiseMinMaxFP16.cCs |j|Sr#r0r5rrrr3'r4r7r8cGst|tj|dSr#)rZIndexRowwiseMinMaxFP16_swiginitZnew_IndexRowwiseMinMaxFP16rQrrrr? 'szIndexRowwiseMinMaxFP16.__init__cCst|||Sr#)rZIndexRowwiseMinMaxFP16_trainrmrrrrn#'szIndexRowwiseMinMaxFP16.traincCst|||Sr#)rZ$IndexRowwiseMinMaxFP16_train_inplacermrrrr&'sz$IndexRowwiseMinMaxFP16.train_inplacecCs t|Sr#)rZ#IndexRowwiseMinMaxFP16_sa_code_sizer@rrrr)'sz#IndexRowwiseMinMaxFP16.sa_code_sizecCst||||Sr#)rZ IndexRowwiseMinMaxFP16_sa_encoderrrrr,'sz IndexRowwiseMinMaxFP16.sa_encodecCst||||Sr#)rZ IndexRowwiseMinMaxFP16_sa_decoderrrrr/'sz IndexRowwiseMinMaxFP16.sa_decodeN)r r r,r-rrrrr?rnrrrrrZdelete_IndexRowwiseMinMaxFP16rTrrrrr 'sr c@s`eZdZdZeddddddZeZddZd d Z d d Z d dZ ddZ ddZ ejZdS)IndexRowwiseMinMaxz, Stores scaling coefficients as fp32 values.cCs |jSr#r0r1rrrr38'r4zIndexRowwiseMinMax.cCs |j|Sr#r0r5rrrr38'r4r7r8cGst|tj|dSr#)rZIndexRowwiseMinMax_swiginitZnew_IndexRowwiseMinMaxrQrrrr?;'szIndexRowwiseMinMax.__init__cCst|||Sr#)rZIndexRowwiseMinMax_trainrmrrrrn>'szIndexRowwiseMinMax.traincCst|||Sr#)rZ IndexRowwiseMinMax_train_inplacermrrrrA'sz IndexRowwiseMinMax.train_inplacecCs t|Sr#)rZIndexRowwiseMinMax_sa_code_sizer@rrrrD'szIndexRowwiseMinMax.sa_code_sizecCst||||Sr#)rZIndexRowwiseMinMax_sa_encoderrrrrG'szIndexRowwiseMinMax.sa_encodecCst||||Sr#)rZIndexRowwiseMinMax_sa_decoderrrrrJ'szIndexRowwiseMinMax.sa_decodeN)r r r,r-rrrrr?rnrrrrrZdelete_IndexRowwiseMinMaxrTrrrrr 5'sr c@szeZdZdZeddddddZeZeej ej Z eej ej ZeejejZeejejZd dd Zd d ZejZd S)Linearz! minimal translation of nn.LinearcCs |jSr#r0r1rrrr3S'r4zLinear.cCs |j|Sr#r0r5rrrr3S'r4r7r8TcCst|t|||dSr#)rZLinear_swiginitZ new_Linear)r in_features out_featuresrrrrr?Z'szLinear.__init__cCs t||Sr#)rZLinear___call__rErrrr]'szLinear.__call__N)T)r r r,r-rrrrrZLinear_in_features_getZLinear_in_features_setr ZLinear_out_features_getZLinear_out_features_setr ZLinear_weight_getZLinear_weight_setweightZLinear_bias_getZLinear_bias_setrr?rZ delete_LinearrTrrrrr P's r c@sreZdZdZeddddddZeZeej ej Z eej ej ZeejejZddZd d Zd d ZejZd S) Embeddingz$ minimal translation of nn.EmbeddingcCs |jSr#r0r1rrrr3f'r4zEmbedding.cCs |j|Sr#r0r5rrrr3f'r4r7r8cCst|t||dSr#)rZEmbedding_swiginitZ new_Embedding)rnum_embeddings embedding_dimrrrr?l'szEmbedding.__init__cCs t||Sr#)rZEmbedding___call__rVrrrro'szEmbedding.__call__cGstj|g|RSr#)rZEmbedding_datarQrrrrZr'szEmbedding.dataN)r r r,r-rrrrrZEmbedding_num_embeddings_getZEmbedding_num_embeddings_setrZEmbedding_embedding_dim_getZEmbedding_embedding_dim_setrZEmbedding_weight_getZEmbedding_weight_setrr?rrZZdelete_EmbeddingrTrrrrrc'src@s\eZdZdZeddddddZeZeej ej Z eej ej ZddZd d ZejZd S) FFNz Feed forward layer that expands to a hidden dimension, applies a ReLU non linearity and maps back to the orignal dimension cCs |jSr#r0r1rrrr3~'r4z FFN.cCs |j|Sr#r0r5rrrr3~'r4r7r8cCst|t||dSr#)rZ FFN_swiginitZnew_FFN)rrr=rrrr?'sz FFN.__init__cCs t||Sr#)rZ FFN___call__rErrrr'sz FFN.__call__N)r r r,r-rrrrrZFFN_linear1_getZFFN_linear1_setZlinear1ZFFN_linear2_getZFFN_linear2_setZlinear2r?rZ delete_FFNrTrrrrrx'src@seZdZeddddddZeZeejej ddZ eej ej Z eejejZeejejZddZeejejZeejejZeejejZd d Zdd d ZddZ ej!Z"d S) QINCoStepcCs |jSr#r0r1rrrr3'r4zQINCoStep.cCs |j|Sr#r0r5rrrr3'r4r7r8zG d: input dim, K: codebook size, L: # of residual blocks, h: hidden dimc Cst|t||||dSr#)rZQINCoStep_swiginitZ new_QINCoStep)rrrLr"r=rrrr?'szQINCoStep.__init__cCs t||Sr#)rZQINCoStep_get_residual_blockrrrrget_residual_block'szQINCoStep.get_residual_blockNcCst||||S)z encode a set of vectors x with intial estimate xhat. Optionally return the delta to be added to xhat to form the new xhat )rZQINCoStep_encode)rxhatr2rrrrr'szQINCoStep.encodecCst|||Sr#)rZQINCoStep_decode)rrrrrrr'szQINCoStep.decode)N)#r r r,rrrrrZQINCoStep_d_getZQINCoStep_d_setrZQINCoStep_K_getZQINCoStep_K_setrLZQINCoStep_L_getZQINCoStep_L_setr"ZQINCoStep_h_getZQINCoStep_h_setr=r?ZQINCoStep_codebook_getZQINCoStep_codebook_setZcodebookZQINCoStep_MLPconcat_getZQINCoStep_MLPconcat_setZ MLPconcatZQINCoStep_residual_blocks_getZQINCoStep_residual_blocks_setZresidual_blocksrrrZdelete_QINCoSteprTrrrrr's rc@s`eZdZeddddddZddZeZeej ej Z eej ej Zdd Zd d ZejZd S) NeuralNetCodeccCs |jSr#r0r1rrrr3'r4zNeuralNetCodec.cCs |j|Sr#r0r5rrrr3'r4r7r8cOs tddSr:r;r<rrrr?'szNeuralNetCodec.__init__cCs t||Sr#)rZNeuralNetCodec_decoderrrrrr'szNeuralNetCodec.decodecCs t||Sr#)rZNeuralNetCodec_encoderErrrr'szNeuralNetCodec.encodeN)r r r,rrr?rrrZNeuralNetCodec_d_getZNeuralNetCodec_d_setrZNeuralNetCodec_M_getZNeuralNetCodec_M_setrrrZdelete_NeuralNetCodecrTrrrrr'src@seZdZeddddddZeZeejej Z eej ej Z eejejZeejejZeejejZddZdd Zd d Zd d ZejZdS)QINCocCs |jSr#r0r1rrrr3'r4zQINCo.cCs |j|Sr#r0r5rrrr3'r4r7r8c Cst|t|||||dSr#)rZQINCo_swiginitZ new_QINCo)rrrLr"rr=rrrr?'szQINCo.__init__cCs t||Sr#)rZQINCo_get_steprrrrget_step'szQINCo.get_stepcCs t||Sr#)rZ QINCo_decoderrrrr'sz QINCo.decodecCs t||Sr#)rZ QINCo_encoderErrrr'sz QINCo.encodeN)r r r,rrrrrZ QINCo_K_getZ QINCo_K_setrLZ QINCo_L_getZ QINCo_L_setr"Z QINCo_h_getZ QINCo_h_setr=ZQINCo_codebook0_getZQINCo_codebook0_setZ codebook0ZQINCo_steps_getZQINCo_steps_setZstepsr?rrrZ delete_QINCorTrrrrr'src@sveZdZdZeddddddZeZeej ej Z eej ej Zddd Zd d Zd d ZddZddZejZdS)Tensor2D< Implements a few neural net layers, mainly to support QINCocCs |jSr#r0r1rrrr3'r4zTensor2D.cCs |j|Sr#r0r5rrrr3'r4r7r8NcCst|t|||dSr#)rZTensor2D_swiginitZ new_Tensor2DrrrrZrrrr?'szTensor2D.__init__cCs t||Sr#)rZTensor2D___iadd__rVrrrrN'szTensor2D.__iadd__cCs t||Sz% get column #j as a 1-column Tensor2D)rZTensor2D_columnrrrrrcolumn'szTensor2D.columncCs t|Sr#)rZTensor2D_numelr@rrrnumel'szTensor2D.numelcGstj|g|RSr#)rZ Tensor2D_datarQrrrrZ'sz Tensor2D.data)N)r r r,r-rrrrrZTensor2D_shape_getZTensor2D_shape_setshapeZTensor2D_v_getZTensor2D_v_setr6r?rNrr rZZdelete_Tensor2DrTrrrrr's rc@sveZdZdZeddddddZeZeej ej Z eej ej Zddd Zd d Zd d ZddZddZejZdS) Int32Tensor2DrcCs |jSr#r0r1rrrr3'r4zInt32Tensor2D.cCs |j|Sr#r0r5rrrr3'r4r7r8NcCst|t|||dSr#)rZInt32Tensor2D_swiginitZnew_Int32Tensor2Drrrrr?'szInt32Tensor2D.__init__cCs t||Sr#)rZInt32Tensor2D___iadd__rVrrrrN'szInt32Tensor2D.__iadd__cCs t||Sr)rZInt32Tensor2D_columnrrrrr'szInt32Tensor2D.columncCs t|Sr#)rZInt32Tensor2D_numelr@rrrr (szInt32Tensor2D.numelcGstj|g|RSr#)rZInt32Tensor2D_datarQrrrrZ(szInt32Tensor2D.data)N)r r r,r-rrrrrZInt32Tensor2D_shape_getZInt32Tensor2D_shape_setr!ZInt32Tensor2D_v_getZInt32Tensor2D_v_setr6r?rNrr rZZdelete_Int32Tensor2DrTrrrrr"'s r"c@sveZdZeddddddZeZeejej Z eej ej Z eejejZddZdd Zd d Zd d ZejZdS)IndexNeuralNetCodeccCs |jSr#r0r1rrrr3 (r4zIndexNeuralNetCodec.cCs |j|Sr#r0r5rrrr3 (r4r7r8cGst|tj|dSr#)rZIndexNeuralNetCodec_swiginitZnew_IndexNeuralNetCodecrQrrrr?(szIndexNeuralNetCodec.__init__cCst|||Sr#)rZIndexNeuralNetCodec_trainrmrrrrn(szIndexNeuralNetCodec.traincCst||||Sr#)rZIndexNeuralNetCodec_sa_encode)rrBr2rrrrr(szIndexNeuralNetCodec.sa_encodecCst||||Sr#)rZIndexNeuralNetCodec_sa_decoderrrrr(szIndexNeuralNetCodec.sa_decodeN)r r r,rrrrrZIndexNeuralNetCodec_net_getZIndexNeuralNetCodec_net_setnetZIndexNeuralNetCodec_M_getZIndexNeuralNetCodec_M_setrZIndexNeuralNetCodec_nbits_getZIndexNeuralNetCodec_nbits_setrr?rnrrZdelete_IndexNeuralNetCodecrTrrrrr# (sr#c@sBeZdZeddddddZeZeejej Z ddZ ej Z dS) IndexQINCocCs |jSr#r0r1rrrr3!(r4zIndexQINCo.cCs |j|Sr#r0r5rrrr3!(r4r7r8cGst|tj|dSr#)rZIndexQINCo_swiginitZnew_IndexQINCorQrrrr?%(szIndexQINCo.__init__N)r r r,rrrrrZIndexQINCo_qinco_getZIndexQINCo_qinco_setZqincor?Zdelete_IndexQINCorTrrrrr% (s r%c@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZdd dZddZejZdS)RangeSearchResulta  The objective is to have a simple result structure while minimizing the number of mem copies in the result. The method do_allocation can be overloaded to allocate the result tables in the matrix type of a scripting language like Lua or Python. cCs |jSr#r0r1rrrr33(r4zRangeSearchResult.cCs |j|Sr#r0r5rrrr33(r4r7r8rz size (nq + 1)z0 result for query i is labels[lims[i]:lims[i+1]]z% corresponding distances (not sorted)z size of the result buffers usedTcCst|t||dS)z1 lims must be allocated on input to range_search.N)rZRangeSearchResult_swiginitZnew_RangeSearchResult)rrZ alloc_limsrrrr?;(szRangeSearchResult.__init__cCs t|S)zd called when lims contains the nb of elements result entries for each query )rZRangeSearchResult_do_allocationr@rrr do_allocation?(szRangeSearchResult.do_allocationN)T)r r r,r-rrrrrZRangeSearchResult_nq_getZRangeSearchResult_nq_setrZRangeSearchResult_lims_getZRangeSearchResult_lims_setr[ZRangeSearchResult_labels_getZRangeSearchResult_labels_setrZRangeSearchResult_distances_getZRangeSearchResult_distances_setrZ!RangeSearchResult_buffer_size_getZ!RangeSearchResult_buffer_size_set buffer_sizer?r'Zdelete_RangeSearchResultrTrrrrr&+(s r&c@s~eZdZdZeddddddZeZeej ej Z eej ej ZeejejddZdd ZejZd d Zd d ZddZdS) BufferListzu List of temporary buffers used to store results before they are copied to the RangeSearchResult object. cCs |jSr#r0r1rrrr3O(r4zBufferList.cCs |j|Sr#r0r5rrrr3O(r4r7r8z" write pointer in the last buffer.cCst|t|dSr#)rZBufferList_swiginitZnew_BufferList)rr(rrrr?U(szBufferList.__init__cCs t|S)z create a new buffer)rZBufferList_append_bufferr@rrr append_bufferY(szBufferList.append_buffercCst|||S)z: add one result, possibly appending a new buffer if needed)rZBufferList_add)rrrrrrro](szBufferList.addcCst|||||S)zr copy elemnts ofs:ofs+n-1 seen as linear data in the buffers to tables dest_ids, dest_dis )rZBufferList_copy_range)rrrBZdest_idsZdest_disrrr copy_rangea(szBufferList.copy_rangeN)r r r,r-rrrrrZBufferList_buffer_size_getZBufferList_buffer_size_setr(ZBufferList_buffers_getZBufferList_buffers_setbuffersZBufferList_wp_getZBufferList_wp_setZwpr?Zdelete_BufferListrTr*ror+rrrrr)I(sr)c@sjeZdZdZeddddddZeZeej ej Z eej ej ZeejejZddZd d ZejZd S) RangeQueryResultz$ result structure for a single querycCs |jSr#r0r1rrrr3m(r4zRangeQueryResult.cCs |j|Sr#r0r5rrrr3m(r4r7r8cCst|||S)z1 called by search function to report a new result)rZRangeQueryResult_add)rrrrrrros(szRangeQueryResult.addcCst|tdSr#)rZRangeQueryResult_swiginitZnew_RangeQueryResultr@rrrr?w(szRangeQueryResult.__init__N)r r r,r-rrrrrZRangeQueryResult_qno_getZRangeQueryResult_qno_setqnoZRangeQueryResult_nres_getZRangeQueryResult_nres_setZnresZRangeQueryResult_pres_getZRangeQueryResult_pres_setZpresror?Zdelete_RangeQueryResultrTrrrrr-j(sr-c@seZdZdZeddddddZeZeej ej Z ddZ eej ejd dZd d Zd d ZddZdddZedddZejZdS)RangeSearchPartialResultz/ the entries in the buffers are split per querycCs |jSr#r0r1rrrr3(r4z!RangeSearchPartialResult.cCs |j|Sr#r0r5rrrr3(r4r7r8cCst|t|dS)z/ eventually the result will be stored in res_inN)rZ!RangeSearchPartialResult_swiginitZnew_RangeSearchPartialResult)rZres_inrrrr?(sz!RangeSearchPartialResult.__init__z% query ids + nb of results per query.cCs t||S)z begin a new result)rZ#RangeSearchPartialResult_new_result)rr.rrr new_result(sz#RangeSearchPartialResult.new_resultcCs t|Sr#)rZ!RangeSearchPartialResult_finalizer@rrrfinalize(sz!RangeSearchPartialResult.finalizecCs t|S)z, called by range_search before do_allocation)rZ!RangeSearchPartialResult_set_limsr@rrrset_lims(sz!RangeSearchPartialResult.set_limsFcCs t||S)z+ called by range_search after do_allocation)rZ$RangeSearchPartialResult_copy_result)r incrementalrrr copy_result(sz$RangeSearchPartialResult.copy_resultTcCs t||S)z{ merge a set of PartialResult's into one RangeSearchResult on output the partialresults are empty! )rZRangeSearchPartialResult_merge)Zpartial_resultsZ do_deleterrrmerge(szRangeSearchPartialResult.mergeN)F)T)r r r,r-rrrrrZ RangeSearchPartialResult_res_getZ RangeSearchPartialResult_res_setrr?Z$RangeSearchPartialResult_queries_getZ$RangeSearchPartialResult_queries_setZqueriesr0r1r2r4rr5Zdelete_RangeSearchPartialResultrTrrrrr/}(s  r/c@sleZdZeddddddZddZeZdd Ze j Z e d d Z e d d Ze ddZe ddZdS)InterruptCallbackcCs |jSr#r0r1rrrr3(r4zInterruptCallback.cCs |j|Sr#r0r5rrrr3(r4r7r8cOs tddSr:r;r<rrrr?(szInterruptCallback.__init__cCs t|Sr#)rZ InterruptCallback_want_interruptr@rrrwant_interrupt(sz InterruptCallback.want_interruptcCstSr#)rZ InterruptCallback_clear_instancerrrrclear_instance(sz InterruptCallback.clear_instancecCstS)z check if: - an interrupt callback is set - the callback returns true if this is the case, then throw an exception. Should not be called from multiple threads. )rZInterruptCallback_checkrrrrcheck(s zInterruptCallback.checkcCstS)z same as check() but return true if is interrupted instead of throwing. Can be called from multiple threads. )rZ InterruptCallback_is_interruptedrrrris_interrupted(sz InterruptCallback.is_interruptedcCs t|S)z assuming each iteration takes a certain number of flops, what is a reasonable interval to check for interrupts? )rZ!InterruptCallback_get_period_hint)Zflopsrrrget_period_hint(sz!InterruptCallback.get_period_hintN)r r r,rrr?rrr7rZdelete_InterruptCallbackrTrr8r9r:r;rrrrr6(s   r6c@sleZdZeddddddZeZeejej Z eej ej Z ddZdd Zed d Zd d ZejZdS)TimeoutCallbackcCs |jSr#r0r1rrrr3(r4zTimeoutCallback.cCs |j|Sr#r0r5rrrr3(r4r7r8cCs t|Sr#)rZTimeoutCallback_want_interruptr@rrrr7(szTimeoutCallback.want_interruptcCs t||Sr#)rZTimeoutCallback_set_timeout)rtimeout_in_secondsrrr set_timeout(szTimeoutCallback.set_timeoutcCs t|Sr#)rZTimeoutCallback_reset)r=rrrr|(szTimeoutCallback.resetcCst|tdSr#)rZTimeoutCallback_swiginitZnew_TimeoutCallbackr@rrrr?(szTimeoutCallback.__init__N)r r r,rrrrrZTimeoutCallback_start_getZTimeoutCallback_start_setstartZTimeoutCallback_timeout_getZTimeoutCallback_timeout_settimeoutr7r>rr|r?Zdelete_TimeoutCallbackrTrrrrr<(s r<c@sleZdZdZeddddddZeZeej ej Z eej ej ZddZd d Zd d Zd dZejZdS) VisitedTablez. set implementation optimized for fast access.cCs |jSr#r0r1rrrr3(r4zVisitedTable.cCs |j|Sr#r0r5rrrr3(r4r7r8cCst|t|dSr#)rZVisitedTable_swiginitZnew_VisitedTablerrrrr?(szVisitedTable.__init__cCs t||S)z set flag #no to true)rZVisitedTable_setrrNrrrr(szVisitedTable.setcCs t||S)z get flag #no)rZVisitedTable_getrBrrrrV(szVisitedTable.getcCs t|S)z reset all flags to false)rZVisitedTable_advancer@rrrrK(szVisitedTable.advanceN)r r r,r-rrrrrZVisitedTable_visited_getZVisitedTable_visited_setvisitedZVisitedTable_visno_getZVisitedTable_visno_setZvisnor?rrVrKZdelete_VisitedTablerTrrrrrA(srAc@s@eZdZdZeddddddZddZeZd d Z e j Z d S) IDSelectorz% Encapsulates a set of ids to handle.cCs |jSr#r0r1rrrr3)r4zIDSelector.cCs |j|Sr#r0r5rrrr3)r4r7r8cOs tddSr:r;r<rrrr?)szIDSelector.__init__cCs t||Sr#)rZIDSelector_is_memberrMrrr is_member)szIDSelector.is_memberN) r r r,r-rrr?rrrErZdelete_IDSelectorrTrrrrrD(s rDc@sxeZdZdZeddddddZeZeej ej Z eej ej ZeejejddZdd d Zd d Zd dZejZdS)IDSelectorRangez ids between [imin, imax)cCs |jSr#r0r1rrrr3)r4zIDSelectorRange.cCs |j|Sr#r0r5rrrr3)r4r7r8zb Assume that the ids to handle are sorted. In some cases this can speed up processing FcCst|t|||dSr#)rZIDSelectorRange_swiginitZnew_IDSelectorRange)riminimax assume_sortedrrrr?)szIDSelectorRange.__init__cCs t||Sr#)rZIDSelectorRange_is_memberrMrrrrE)szIDSelectorRange.is_membercCst|||||S)zg for sorted ids, find the range of list indices where the valid ids are stored )rZ&IDSelectorRange_find_sorted_ids_bounds)rrr'ZjminZjmaxrrrfind_sorted_ids_bounds )sz&IDSelectorRange.find_sorted_ids_boundsN)F)r r r,r-rrrrrZIDSelectorRange_imin_getZIDSelectorRange_imin_setrGZIDSelectorRange_imax_getZIDSelectorRange_imax_setrHZ!IDSelectorRange_assume_sorted_getZ!IDSelectorRange_assume_sorted_setrIr?rErJZdelete_IDSelectorRangerTrrrrrF)s rFc@s\eZdZdZeddddddZeZeej ej Z eej ej ZddZd d ZejZd S) IDSelectorArrayz Simple array of elements is_member calls are very inefficient, but some operations can use the ids directly. cCs |jSr#r0r1rrrr32)r4zIDSelectorArray.cCs |j|Sr#r0r5rrrr32)r4r7r8cCst|t||dS)a Construct with an array of ids to process :type n: int :param n: number of ids to store :type ids: int :param ids: elements to store. The pointer should remain valid during IDSelectorArray's lifetime N)rZIDSelectorArray_swiginitZnew_IDSelectorArray)rrBr'rrrr?7)s zIDSelectorArray.__init__cCs t||Sr#)rZIDSelectorArray_is_memberrMrrrrEC)szIDSelectorArray.is_memberN)r r r,r-rrrrrZIDSelectorArray_n_getZIDSelectorArray_n_setrBZIDSelectorArray_ids_getZIDSelectorArray_ids_setr'r?rEZdelete_IDSelectorArrayrTrrrrrK*)s rKc@s\eZdZdZeddddddZeZeej ej Z eej ej ZddZd d ZejZd S) IDSelectorBatcha Ids from a set. Repetitions of ids in the indices set passed to the constructor does not hurt performance. The hash function used for the bloom filter and GCC's implementation of unordered_set are just the least significant bits of the id. This works fine for random ids or ids in sequences but will produce many hash collisions if lsb's are always the same cCs |jSr#r0r1rrrr3V)r4zIDSelectorBatch.cCs |j|Sr#r0r5rrrr3V)r4r7r8cCst|t||dS)z Construct with an array of ids to process :type n: int :param n: number of ids to store :param ids: elements to store. The pointer can be released after construction N)rZIDSelectorBatch_swiginitZnew_IDSelectorBatch)rrBrrrrr?[)s zIDSelectorBatch.__init__cCs t||Sr#)rZIDSelectorBatch_is_memberrMrrrrEf)szIDSelectorBatch.is_memberN)r r r,r-rrrrrZIDSelectorBatch_nbits_getZIDSelectorBatch_nbits_setrZIDSelectorBatch_mask_getZIDSelectorBatch_mask_setrr?rEZdelete_IDSelectorBatchrTrrrrrLI)s  rLc@s\eZdZdZeddddddZeZeej ej Z eej ej ZddZd d ZejZd S) IDSelectorBitmapzB One bit per element. Constructed with a bitmap, size ceil(n / 8).cCs |jSr#r0r1rrrr3o)r4zIDSelectorBitmap.cCs |j|Sr#r0r5rrrr3o)r4r7r8cCst|t||dS)a Construct with a binary mask :type n: int :param n: size of the bitmap array :type bitmap: uint8_t :param bitmap: id will be selected iff id / 8 < n and bit number (i%8) of bitmap[floor(i / 8)] is 1. N)rZIDSelectorBitmap_swiginitZnew_IDSelectorBitmap)rrBbitmaprrrr?t)s zIDSelectorBitmap.__init__cCs t||Sr#)rZIDSelectorBitmap_is_memberrMrrrrE)szIDSelectorBitmap.is_memberN)r r r,r-rrrrrZIDSelectorBitmap_n_getZIDSelectorBitmap_n_setrBZIDSelectorBitmap_bitmap_getZIDSelectorBitmap_bitmap_setrNr?rEZdelete_IDSelectorBitmaprTrrrrrMl)s rMc@sNeZdZdZeddddddZeZeej ej Z ddZ d d Z ejZd S) IDSelectorNotz0 reverts the membership test of another selectorcCs |jSr#r0r1rrrr3)r4zIDSelectorNot.cCs |j|Sr#r0r5rrrr3)r4r7r8cCst|t|dSr#)rZIDSelectorNot_swiginitZnew_IDSelectorNotrzrrrr?)szIDSelectorNot.__init__cCs t||Sr#)rZIDSelectorNot_is_memberrMrrrrE)szIDSelectorNot.is_memberN)r r r,r-rrrrrZIDSelectorNot_sel_getZIDSelectorNot_sel_setr5r?rEZdelete_IDSelectorNotrTrrrrrO)srOc@s@eZdZdZeddddddZeZddZe j Z d d Z d S) IDSelectorAllz. selects all entries (useful for benchmarking)cCs |jSr#r0r1rrrr3)r4zIDSelectorAll.cCs |j|Sr#r0r5rrrr3)r4r7r8cCs t||Sr#)rZIDSelectorAll_is_memberrMrrrrE)szIDSelectorAll.is_membercCst|tdSr#)rZIDSelectorAll_swiginitZnew_IDSelectorAllr@rrrr?)szIDSelectorAll.__init__N) r r r,r-rrrrrErZdelete_IDSelectorAllrTr?rrrrrP)s rPc@s\eZdZdZeddddddZeZeej ej Z eej ej ZddZd d ZejZd S) IDSelectorAndz\ does an AND operation on the the two given IDSelector's is_membership results. cCs |jSr#r0r1rrrr3)r4zIDSelectorAnd.cCs |j|Sr#r0r5rrrr3)r4r7r8cCst|t||dSr#)rZIDSelectorAnd_swiginitZnew_IDSelectorAndrlhsrhsrrrr?)szIDSelectorAnd.__init__cCs t||Sr#)rZIDSelectorAnd_is_memberrMrrrrE)szIDSelectorAnd.is_memberN)r r r,r-rrrrrZIDSelectorAnd_lhs_getZIDSelectorAnd_lhs_setrSZIDSelectorAnd_rhs_getZIDSelectorAnd_rhs_setrTr?rEZdelete_IDSelectorAndrTrrrrrQ)srQc@s\eZdZdZeddddddZeZeej ej Z eej ej ZddZd d ZejZd S) IDSelectorOrz[ does an OR operation on the the two given IDSelector's is_membership results. cCs |jSr#r0r1rrrr3)r4zIDSelectorOr.cCs |j|Sr#r0r5rrrr3)r4r7r8cCst|t||dSr#)rZIDSelectorOr_swiginitZnew_IDSelectorOrrRrrrr?)szIDSelectorOr.__init__cCs t||Sr#)rZIDSelectorOr_is_memberrMrrrrE)szIDSelectorOr.is_memberN)r r r,r-rrrrrZIDSelectorOr_lhs_getZIDSelectorOr_lhs_setrSZIDSelectorOr_rhs_getZIDSelectorOr_rhs_setrTr?rEZdelete_IDSelectorOrrTrrrrrU)srUc@s\eZdZdZeddddddZeZeej ej Z eej ej ZddZd d ZejZd S) IDSelectorXOrz\ does an XOR operation on the the two given IDSelector's is_membership results. cCs |jSr#r0r1rrrr3)r4zIDSelectorXOr.cCs |j|Sr#r0r5rrrr3)r4r7r8cCst|t||dSr#)rZIDSelectorXOr_swiginitZnew_IDSelectorXOrrRrrrr?)szIDSelectorXOr.__init__cCs t||Sr#)rZIDSelectorXOr_is_memberrMrrrrE)szIDSelectorXOr.is_memberN)r r r,r-rrrrrZIDSelectorXOr_lhs_getZIDSelectorXOr_lhs_setrSZIDSelectorXOr_rhs_getZIDSelectorXOr_rhs_setrTr?rEZdelete_IDSelectorXOrrTrrrrrV)srVc@sTeZdZeddddddZeZeejZ eej ej Z ddZ dd ZejZd S) IDSelectorTranslatedcCs |jSr#r0r1rrrr3)r4zIDSelectorTranslated.cCs |j|Sr#r0r5rrrr3)r4r7r8cGst|tj|dSr#)rZIDSelectorTranslated_swiginitZnew_IDSelectorTranslatedrQrrrr?)szIDSelectorTranslated.__init__cCs t||Sr#)rZIDSelectorTranslated_is_memberrMrrrrE)szIDSelectorTranslated.is_memberN)r r r,rrrrrZIDSelectorTranslated_id_map_getrZIDSelectorTranslated_sel_getZIDSelectorTranslated_sel_setr5r?rEZdelete_IDSelectorTranslatedrTrrrrrW)s rWc@seZdZdZeddddddZeZeej ej Z eej ej ddZeejejddZd d Zd d Zd#ddZddZddZddZd$ddZd%ddZddZddZdd ZejZd!d"Zd S)& IndexIDMap, Index that translates search results to idscCs |jSr#r0r1rrrr3)r4zIndexIDMap.cCs |j|Sr#r0r5rrrr3)r4r7r8r)whether pointers are deleted in destructocCst||||Szi :type xids: int :param xids: if non-null, ids to store for the vectors (size n) )rZIndexIDMap_add_with_idsrprrrrr)szIndexIDMap.add_with_idscCst|||Sz! this will fail. Use add_with_ids)rZIndexIDMap_addrmrrrro*szIndexIDMap.addNc Cst|||||||Sr#)rZIndexIDMap_searchrsrrrru*szIndexIDMap.searchcCst|||Sr#)rZIndexIDMap_trainrmrrrrn*szIndexIDMap.traincCs t|Sr#)rZIndexIDMap_resetr@rrrr| *szIndexIDMap.resetcCs t||Sz remove ids adapted to IndexFlat)rZIndexIDMap_remove_idsrzrrrr{ *szIndexIDMap.remove_idscCst||||||Sr#)rZIndexIDMap_range_searchrvrrrrw*szIndexIDMap.range_searchrcCst|||Sr#)rZIndexIDMap_merge_fromrrrrr*szIndexIDMap.merge_fromcCs t||Sr#)rZ%IndexIDMap_check_compatible_for_mergerrrrr*sz%IndexIDMap.check_compatible_for_mergecCs t|Sr#)rZIndexIDMap_sa_code_sizer@rrrr*szIndexIDMap.sa_code_sizecCst||||Sr#)rZIndexIDMap_add_sa_codesrprrrr*szIndexIDMap.add_sa_codescGst|tj|dSr#)rZIndexIDMap_swiginitZnew_IndexIDMaprQrrrr?!*szIndexIDMap.__init__)N)N)r) r r r,r-rrrrrZIndexIDMap_index_getZIndexIDMap_index_setrZIndexIDMap_own_fields_getZIndexIDMap_own_fields_setrZIndexIDMap_id_map_getZIndexIDMap_id_map_setrrrrorurnr|r{rwrrrrZdelete_IndexIDMaprTr?rrrrrX)s&   rXc@seZdZdZeddddddZeZeej ej Z eej ej ddZeejejddZd d Zd d Zd#ddZddZddZddZd$ddZd%ddZddZddZdd ZejZd!d"Zd S)&IndexBinaryIDMaprYcCs |jSr#r0r1rrrr3)*r4zIndexBinaryIDMap.cCs |j|Sr#r0r5rrrr3)*r4r7r8rrZcCst||||Sr[)rZIndexBinaryIDMap_add_with_idsrprrrrr/*szIndexBinaryIDMap.add_with_idscCst|||Sr\)rZIndexBinaryIDMap_addrmrrrro6*szIndexBinaryIDMap.addNc Cst|||||||Sr#)rZIndexBinaryIDMap_searchrsrrrru:*szIndexBinaryIDMap.searchcCst|||Sr#)rZIndexBinaryIDMap_trainrmrrrrn=*szIndexBinaryIDMap.traincCs t|Sr#)rZIndexBinaryIDMap_resetr@rrrr|@*szIndexBinaryIDMap.resetcCs t||Sr])rZIndexBinaryIDMap_remove_idsrzrrrr{C*szIndexBinaryIDMap.remove_idscCst||||||Sr#)rZIndexBinaryIDMap_range_searchrvrrrrwG*szIndexBinaryIDMap.range_searchrcCst|||Sr#)rZIndexBinaryIDMap_merge_fromrrrrrJ*szIndexBinaryIDMap.merge_fromcCs t||Sr#)rZ+IndexBinaryIDMap_check_compatible_for_mergerrrrrM*sz+IndexBinaryIDMap.check_compatible_for_mergecCs t|Sr#)rZIndexBinaryIDMap_sa_code_sizer@rrrrP*szIndexBinaryIDMap.sa_code_sizecCst||||Sr#)rZIndexBinaryIDMap_add_sa_codesrprrrrS*szIndexBinaryIDMap.add_sa_codescGst|tj|dSr#)rZIndexBinaryIDMap_swiginitZnew_IndexBinaryIDMaprQrrrr?W*szIndexBinaryIDMap.__init__)N)N)r) r r r,r-rrrrrZIndexBinaryIDMap_index_getZIndexBinaryIDMap_index_setrZIndexBinaryIDMap_own_fields_getZIndexBinaryIDMap_own_fields_setrZIndexBinaryIDMap_id_map_getZIndexBinaryIDMap_id_map_setrrrrorurnr|r{rwrrrrZdelete_IndexBinaryIDMaprTr?rrrrr^&*s&   r^c@sxeZdZdZeddddddZeZeej ej Z ddZ d d Z d d Zd dZddZdddZejZddZdS) IndexIDMap2o same as IndexIDMap but also provides an efficient reconstruction implementation via a 2-way index cCs |jSr#r0r1rrrr3b*r4zIndexIDMap2.cCs |j|Sr#r0r5rrrr3b*r4r7r8cCs t|Sz make the rev_map from scratch)rZIndexIDMap2_construct_rev_mapr@rrrconstruct_rev_mapf*szIndexIDMap2.construct_rev_mapcCst||||Sr#)rZIndexIDMap2_add_with_idsrprrrrrj*szIndexIDMap2.add_with_idscCs t||Sr#)rZIndexIDMap2_remove_idsrzrrrr{m*szIndexIDMap2.remove_idscCst|||Sr#)rZIndexIDMap2_reconstructr|rrrrp*szIndexIDMap2.reconstructcCs t|Sz2 check that the rev_map and the id_map are in sync)rZIndexIDMap2_check_consistencyr@rrrcheck_consistencys*szIndexIDMap2.check_consistencyrcCst|||Sr#)rZIndexIDMap2_merge_fromrrrrrw*szIndexIDMap2.merge_fromcGst|tj|dSr#)rZIndexIDMap2_swiginitZnew_IndexIDMap2rQrrrr?{*szIndexIDMap2.__init__N)r)r r r,r-rrrrrZIndexIDMap2_rev_map_getZIndexIDMap2_rev_map_setrev_maprbrrr{rrdrZdelete_IndexIDMap2rTr?rrrrr_\*s r_c@sxeZdZdZeddddddZeZeej ej Z ddZ d d Z d d Zd dZddZdddZejZddZdS)IndexBinaryIDMap2r`cCs |jSr#r0r1rrrr3*r4zIndexBinaryIDMap2.cCs |j|Sr#r0r5rrrr3*r4r7r8cCs t|Sra)rZ#IndexBinaryIDMap2_construct_rev_mapr@rrrrb*sz#IndexBinaryIDMap2.construct_rev_mapcCst||||Sr#)rZIndexBinaryIDMap2_add_with_idsrprrrrr*szIndexBinaryIDMap2.add_with_idscCs t||Sr#)rZIndexBinaryIDMap2_remove_idsrzrrrr{*szIndexBinaryIDMap2.remove_idscCst|||Sr#)rZIndexBinaryIDMap2_reconstructr|rrrr*szIndexBinaryIDMap2.reconstructcCs t|Src)rZ#IndexBinaryIDMap2_check_consistencyr@rrrrd*sz#IndexBinaryIDMap2.check_consistencyrcCst|||Sr#)rZIndexBinaryIDMap2_merge_fromrrrrr*szIndexBinaryIDMap2.merge_fromcGst|tj|dSr#)rZIndexBinaryIDMap2_swiginitZnew_IndexBinaryIDMap2rQrrrr?*szIndexBinaryIDMap2.__init__N)r)r r r,r-rrrrrZIndexBinaryIDMap2_rev_map_getZIndexBinaryIDMap2_rev_map_setrerbrrr{rrdrZdelete_IndexBinaryIDMap2rTr?rrrrrf*s rfcCs t|Sr#)rdowncast_indexrrrrrg*srgcCs t|Sr#)rdowncast_VectorTransform)rrrrri*sricCs t|Sr#)rdowncast_IndexBinaryrhrrrrj*srjcCs t|Sr#)rdowncast_InvertedLists)r-rrrrk*srkcCs t|Sr#)rdowncast_AdditiveQuantizerrrrrrl*srlcCs t|Sr#)rdowncast_Quantizerrmrrrrn*srncGs tj|Sr#)r write_indexrrrrro*srocGs tj|Sr#)rwrite_index_binaryrrrrrp*srpcGs tj|Sr#)r read_indexrrrrrq*srqcGs tj|Sr#)rread_index_binaryrrrrrr*srrcGs tj|Sr#)rwrite_VectorTransformrrrrrs*srscGs tj|Sr#)rread_VectorTransformrrrrrt*srtcGs tj|Sr#)rread_ProductQuantizerrrrrru*srucGs tj|Sr#)rwrite_ProductQuantizerrrrrrv*srvcCs t||Sr#)rwrite_InvertedLists)r+rrrrrw*srwcCs t||Sr#)rread_InvertedLists)rr6rrrrx*srxcCs t|Sr#)r clone_indexr9rrrry*sryc@sPeZdZdZeddddddZeZddZd d Z d d Z e j Z d dZdS)Clonerz Cloner class, useful to override classes with other cloning functions. The cloning function above just calls Cloner::clone_Index. cCs |jSr#r0r1rrrr3*r4zCloner.cCs |j|Sr#r0r5rrrr3*r4r7r8cCs t||Sr#)rZCloner_clone_VectorTransformrVrrrclone_VectorTransform*szCloner.clone_VectorTransformcCs t||Sr#)rZCloner_clone_IndexrVrrr clone_Index*szCloner.clone_IndexcCs t||Sr#)rZCloner_clone_IndexIVFrVrrrclone_IndexIVF*szCloner.clone_IndexIVFcCst|tdSr#)rZCloner_swiginitZ new_Clonerr@rrrr?*szCloner.__init__N)r r r,r-rrrrr{r|r}rZ delete_ClonerrTr?rrrrrz*srzcCs t|Sr#)rclone_Quantizer)Zquantrrrr~*sr~cCs t|Sr#)rclone_binary_indexrhrrrr+src@seZdZdZeddddddZddZeZee j e j d dZ ee j e jd dZee je jd dZee je jd dZee je jd dZddZddZe jZdS)AutoTuneCriterionz] Evaluation criterion. Returns a performance measure in [0,1], higher is better. cCs |jSr#r0r1rrrr3 +r4zAutoTuneCriterion.cCs |j|Sr#r0r5rrrr3 +r4r7r8cOs tddSr:r;r<rrrr? +szAutoTuneCriterion.__init__z- nb of queries this criterion is evaluated onz( nb of NNs that the query should requestz, nb of GT NNs required to evaluate criterionz* Ground-truth distances (size nq * gt_nnn)z( Ground-truth indexes (size nq * gt_nnn)cCst||||S)z Intitializes the gt_D and gt_I vectors. Must be called before evaluating :type gt_D_in: float :param gt_D_in: size nq * gt_nnn :type gt_I_in: int :param gt_I_in: size nq * gt_nnn )rZ!AutoTuneCriterion_set_groundtruth)rgt_nnnZgt_D_inZgt_I_inrrrset_groundtruth+s z!AutoTuneCriterion.set_groundtruthcCst|||S)z Evaluate the criterion. :type D: float :param D: size nq * nnn :type I: int :param I: size nq * nnn :rtype: float :return: the criterion, between 0 and 1. Larger is better. )rZAutoTuneCriterion_evaluaterrrrrrrK+s zAutoTuneCriterion.evaluateN)r r r,r-rrr?rrrZAutoTuneCriterion_nq_getZAutoTuneCriterion_nq_setrZAutoTuneCriterion_nnn_getZAutoTuneCriterion_nnn_setZnnnZAutoTuneCriterion_gt_nnn_getZAutoTuneCriterion_gt_nnn_setrZAutoTuneCriterion_gt_D_getZAutoTuneCriterion_gt_D_setZgt_DZAutoTuneCriterion_gt_I_getZAutoTuneCriterion_gt_I_setZgt_IrrKZdelete_AutoTuneCriterionrTrrrrr+s  rc@sJeZdZeddddddZeZeejej Z ddZ dd Z ej Zd S) OneRecallAtRCriterioncCs |jSr#r0r1rrrr30+r4zOneRecallAtRCriterion.cCs |j|Sr#r0r5rrrr30+r4r7r8cCst|t||dSr#)rZOneRecallAtRCriterion_swiginitZnew_OneRecallAtRCriterionrrrrrrr?4+szOneRecallAtRCriterion.__init__cCst|||Sr#)rZOneRecallAtRCriterion_evaluaterrrrrK7+szOneRecallAtRCriterion.evaluateN)r r r,rrrrrZOneRecallAtRCriterion_R_getZOneRecallAtRCriterion_R_setrr?rKZdelete_OneRecallAtRCriterionrTrrrrr/+s rc@sJeZdZeddddddZeZeejej Z ddZ dd Z ej Zd S) IntersectionCriterioncCs |jSr#r0r1rrrr3>+r4zIntersectionCriterion.cCs |j|Sr#r0r5rrrr3>+r4r7r8cCst|t||dSr#)rZIntersectionCriterion_swiginitZnew_IntersectionCriterionrrrrr?B+szIntersectionCriterion.__init__cCst|||Sr#)rZIntersectionCriterion_evaluaterrrrrKE+szIntersectionCriterion.evaluateN)r r r,rrrrrZIntersectionCriterion_R_getZIntersectionCriterion_R_setrr?rKZdelete_IntersectionCriterionrTrrrrr=+s rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d ZejZd S)OperatingPointa< Maintains a list of experimental results. Each operating point is a (perf, t, key) triplet, where higher perf and lower t is better. The key field is an arbitrary identifier for the operating point. Includes primitives to extract the Pareto-optimal operating points in the (perf, t) space. cCs |jSr#r0r1rrrr3U+r4zOperatingPoint.cCs |j|Sr#r0r5rrrr3U+r4r7r8z, performance measure (output of a Criterion)z" corresponding execution time (ms)z key that identifies this op ptz integer identifiercCst|tdSr#)rZOperatingPoint_swiginitZnew_OperatingPointr@rrrr?\+szOperatingPoint.__init__N)r r r,r-rrrrrZOperatingPoint_perf_getZOperatingPoint_perf_setperfZOperatingPoint_t_getZOperatingPoint_t_setrZZOperatingPoint_key_getZOperatingPoint_key_setr}ZOperatingPoint_cno_getZOperatingPoint_cno_setcnor?Zdelete_OperatingPointrTrrrrrK+s rc@seZdZeddddddZeZeejej ddZ eej ej ddZ dd Zd d Zd d ZdddZddZdddZddZddZejZdS)OperatingPointscCs |jSr#r0r1rrrr3c+r4zOperatingPoints.cCs |j|Sr#r0r5rrrr3c+r4r7r8z all operating pointsz) optimal operating points, sorted by perfcCst|tdSr#)rZOperatingPoints_swiginitZnew_OperatingPointsr@rrrr?h+szOperatingPoints.__init__cGstj|g|RS)zC add operating points from other to this, with a prefix to the keys)rZOperatingPoints_merge_withrQrrr merge_withk+szOperatingPoints.merge_withcCs t|Sr#)rZOperatingPoints_clearr@rrrrYo+szOperatingPoints.clearrcCst|||||S)zA add a performance measure. Return whether it is an optimal point)rZOperatingPoints_add)rrrZr}rrrrror+szOperatingPoints.addcCs t||S)z8 get time required to obtain a given performance measure)rZOperatingPoints_t_for_perf)rrrrr t_for_perfv+szOperatingPoints.t_for_perfTcCs t||S)z easy-to-read output)rZOperatingPoints_display)rZ only_optimalrrrrz+szOperatingPoints.displaycCs t||S)z- output to a format easy to digest by gnuplot)rZOperatingPoints_all_to_gnuplotrfnamerrrall_to_gnuplot~+szOperatingPoints.all_to_gnuplotcCs t||Sr#)rZ"OperatingPoints_optimal_to_gnuplotrrrroptimal_to_gnuplot+sz"OperatingPoints.optimal_to_gnuplotN)r)T)r r r,rrrrrZOperatingPoints_all_pts_getZOperatingPoints_all_pts_setZall_ptsZOperatingPoints_optimal_pts_getZOperatingPoints_optimal_pts_setZ optimal_ptsr?rrYrorrrrZdelete_OperatingPointsrTrrrrrb+s  rc@sTeZdZdZeddddddZeZeej ej Z eej ej ZddZejZd S) ParameterRangezM possible values of a parameter, sorted from least to most expensive/accuratecCs |jSr#r0r1rrrr3+r4zParameterRange.cCs |j|Sr#r0r5rrrr3+r4r7r8cCst|tdSr#)rZParameterRange_swiginitZnew_ParameterRanger@rrrr?+szParameterRange.__init__N)r r r,r-rrrrrZParameterRange_name_getZParameterRange_name_setrZParameterRange_values_getZParameterRange_values_setvaluesr?Zdelete_ParameterRangerTrrrrr+src@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZeejejd dZeejejd dZd dZddZddZddZddZddZ ddZ!ddZ"ddZ#dd Z$d!d"Z%ej&Z'd#S)$ParameterSpacezL Uses a-priori knowledge on the Faiss indexes to extract tunable parameters.cCs |jSr#r0r1rrrr3+r4zParameterSpace.cCs |j|Sr#r0r5rrrr3+r4r7r8z all tunable parametersz verbosity during explorationzA nb of experiments during optimization (0 = try all combinations)z/ maximum number of queries to submit at a time.z_ use multithreading over batches (useful to benchmark independent single-searches) zm run tests several times until they reach at least this duration (to avoid jittering in MT mode) cCst|tdSr#)rZParameterSpace_swiginitZnew_ParameterSpacer@rrrr?+szParameterSpace.__init__cCs t|S)z. nb of combinations, = product of values sizes)rZParameterSpace_n_combinationsr@rrrn_combinations+szParameterSpace.n_combinationscCst|||S)z9 returns whether combinations c1 >= c2 in the tuple sense)rZParameterSpace_combination_ge)rc1c2rrrcombination_ge+szParameterSpace.combination_gecCs t||S)z- get string representation of the combination)rZParameterSpace_combination_name)rrrrrcombination_name+szParameterSpace.combination_namecCs t|S)z print a description on stdout)rZParameterSpace_displayr@rrrr+szParameterSpace.displaycCs t||S)z0 add a new parameter (or return it if it exists))rZParameterSpace_add_rangerXrrr add_range+szParameterSpace.add_rangecCs t||S)z4 initialize with reasonable parameters for the index)rZParameterSpace_initializerrrr initialize+szParameterSpace.initializecGstj|g|RS)z *Overload 1:* set a combination of parameters on an index | *Overload 2:* set a combination of parameters described by a string )rZ#ParameterSpace_set_index_parametersrQrrrset_index_parameters+s z#ParameterSpace.set_index_parameterscCst||||S)zB set one of the parameters, returns whether setting was successful)rZ"ParameterSpace_set_index_parameter)rrrr]rrrset_index_parameter+sz"ParameterSpace.set_index_parametercCst|||||S)z find an upper bound on the performance and a lower bound on t for configuration cno given another operating point op )rZParameterSpace_update_bounds)rropZupper_bound_perfZ lower_bound_trrr update_bounds+szParameterSpace.update_boundscCst||||||S)a explore operating points :type index: :py:class:`Index` :param index: index to run on :type xq: float :param xq: query vectors (size nq * index.d) :type crit: :py:class:`AutoTuneCriterion` :param crit: selection criterion :type ops: :py:class:`OperatingPoints` :param ops: resulting operating points )rZParameterSpace_explore)rrrr critopsrrrexplore+s zParameterSpace.exploreN)(r r r,r-rrrrrZ#ParameterSpace_parameter_ranges_getZ#ParameterSpace_parameter_ranges_setZparameter_rangesZParameterSpace_verbose_getZParameterSpace_verbose_setrZ ParameterSpace_n_experiments_getZ ParameterSpace_n_experiments_setZ n_experimentsZParameterSpace_batchsize_getZParameterSpace_batchsize_setZ batchsizeZ&ParameterSpace_thread_over_batches_getZ&ParameterSpace_thread_over_batches_setZthread_over_batchesZ$ParameterSpace_min_test_duration_getZ$ParameterSpace_min_test_duration_setZmin_test_durationr?rrrrrrrrrrZdelete_ParameterSpacerTrrrrr+s*  rcGs tj|S)z\ Build and index with the sequence of processing steps described in the string. )r index_factoryrrrrr+srcCs t||Sr#)rindex_binary_factory)r descriptionrrrr+src@seZdZdZeddddddZeZddZee j e j Z ee j e jZee je jZee je jZee je jZee je jZee je jZee je j Z!ee j"e j#Z$ee j%e j&Z'ee j(e j)Z*ee j+e j,Z-ee j.e j/Z0d d Z1e j2Z3d S) MatrixStatsz Reports some statistics on a dataset and comments on them. It is a class rather than a function so that all stats can also be accessed from code cCs |jSr#r0r1rrrr3+r4zMatrixStats.cCs |j|Sr#r0r5rrrr3+r4r7r8cCst|t|||dSr#)rZMatrixStats_swiginitZnew_MatrixStats)rrBrr2rrrr?,szMatrixStats.__init__cCs t||Sr#)rZMatrixStats_do_comment)rfmtrrr do_comment,szMatrixStats.do_commentN)4r r r,r-rrrrr?rZMatrixStats_comments_getZMatrixStats_comments_setcommentsZMatrixStats_n_getZMatrixStats_n_setrBZMatrixStats_d_getZMatrixStats_d_setrZMatrixStats_n_collision_getZMatrixStats_n_collision_setZ n_collisionZMatrixStats_n_valid_getZMatrixStats_n_valid_setZn_validZMatrixStats_n0_getZMatrixStats_n0_setrZMatrixStats_min_norm2_getZMatrixStats_min_norm2_setZ min_norm2ZMatrixStats_max_norm2_getZMatrixStats_max_norm2_setZ max_norm2ZMatrixStats_hash_value_getZMatrixStats_hash_value_set hash_valueZMatrixStats_per_dim_stats_getZMatrixStats_per_dim_stats_setZ per_dim_statsZMatrixStats_occurrences_getZMatrixStats_occurrences_set occurrencesZMatrixStats_buf_getZMatrixStats_buf_setbufZMatrixStats_nbuf_getZMatrixStats_nbuf_setZnbufrZdelete_MatrixStatsrTrrrrr+s&rc@sXeZdZeddddddZeZeejej Z eej ej Z ddZdd ZejZd S) PyCallbackIOWritercCs |jSr#r0r1rrrr3,r4zPyCallbackIOWriter.cCs |j|Sr#r0r5rrrr3,r4r7r8cGst|tj|dS)z Callback: Python function that takes a bytes object and returns the number of bytes successfully written. N)rZPyCallbackIOWriter_swiginitZnew_PyCallbackIOWriterrQrrrr?,szPyCallbackIOWriter.__init__cCst||||Sr#)rZPyCallbackIOWriter___call__rZptrvr[rrrrr#,szPyCallbackIOWriter.__call__N)r r r,rrrrrZPyCallbackIOWriter_callback_getZPyCallbackIOWriter_callback_setcallbackZPyCallbackIOWriter_bs_getZPyCallbackIOWriter_bs_setbsr?rZdelete_PyCallbackIOWriterrTrrrrr,src@sXeZdZeddddddZeZeejej Z eej ej Z ddZdd ZejZd S) PyCallbackIOReadercCs |jSr#r0r1rrrr3*,r4zPyCallbackIOReader.cCs |j|Sr#r0r5rrrr3*,r4r7r8cGst|tj|dS)zy Callback: Python function that takes a size and returns a bytes object with the resulting read N)rZPyCallbackIOReader_swiginitZnew_PyCallbackIOReaderrQrrrr?/,szPyCallbackIOReader.__init__cCst||||Sr#)rZPyCallbackIOReader___call__rrrrr6,szPyCallbackIOReader.__call__N)r r r,rrrrrZPyCallbackIOReader_callback_getZPyCallbackIOReader_callback_setrZPyCallbackIOReader_bs_getZPyCallbackIOReader_bs_setrr?rZdelete_PyCallbackIOReaderrTrrrrr),src@sJeZdZeddddddZeZeejej Z ddZ dd Z ej Zd S) PyCallbackIDSelectorcCs |jSr#r0r1rrrr3=,r4zPyCallbackIDSelector.cCs |j|Sr#r0r5rrrr3=,r4r7r8cCst|t|dSr#)rZPyCallbackIDSelector_swiginitZnew_PyCallbackIDSelector)rrrrrr?A,szPyCallbackIDSelector.__init__cCs t||Sr#)rZPyCallbackIDSelector_is_memberrMrrrrED,szPyCallbackIDSelector.is_memberN)r r r,rrrrrZ!PyCallbackIDSelector_callback_getZ!PyCallbackIDSelector_callback_setrr?rEZdelete_PyCallbackIDSelectorrTrrrrr<,s rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d Zd dZddZd ddZd!ddZd"ddZddZddZddZejZdS)#float_minheap_array_t a template structure for a set of [min|max]-heaps it is tailored so that the actual data of the heaps can just live in compact arrays. cCs |jSr#r0r1rrrr3Q,r4zfloat_minheap_array_t.cCs |j|Sr#r0r5rrrr3Q,r4r7r8 number of heaps allocated size per heap identifiers (size nh * k)0 values (distances or similarities), size nh * kcCs t||Sz% Return the list of values for a heap)rZfloat_minheap_array_t_get_valrr}rrrget_valX,szfloat_minheap_array_t.get_valcCs t||Sz Correspponding identifiers)rZfloat_minheap_array_t_get_idsrrrrr\,szfloat_minheap_array_t.get_idscCs t|Sz$ prepare all the heaps before adding)rZfloat_minheap_array_t_heapifyr@rrrheapify`,szfloat_minheap_array_t.heapifyrr cCst||||||Sa add nj elements to heaps i0:i0+ni, with sequential ids :type nj: int :param nj: nb of elements to add to each heap :type vin: float :param vin: elements to add, size ni * nj :type j0: int, optional :param j0: add this to the ids that are added :type i0: int, optional :param i0: first heap to update :type ni: int, optional :param ni: nb of elements to update (-1 = use nh) )rZfloat_minheap_array_t_addnrnjvinrrrrrraddnd,szfloat_minheap_array_t.addnNc Cst|||||||Sz same as addn :type id_in: int, optional :param id_in: ids of the elements to add, size ni * nj :type id_stride: int, optional :param id_stride: stride for id_in )rZ#float_minheap_array_t_addn_with_idsrrrid_in id_striderrrrr addn_with_idsu,s z#float_minheap_array_t.addn_with_idsc Cst|||||||Sa  same as addn_with_ids, but for just a subset of queries :type nsubset: int :param nsubset: number of query entries to update :type subset: int :param subset: indexes of queries to update, in 0..nh-1, size nsubset )rZ0float_minheap_array_t_addn_query_subset_with_idsrr0r/rrrrrrraddn_query_subset_with_ids,s z0float_minheap_array_t.addn_query_subset_with_idscCs t|Sz reorder all the heaps)rZfloat_minheap_array_t_reorderr@rrrreorder,szfloat_minheap_array_t.reordercCst|||SaC this is not really a heap function. It just finds the per-line extrema of each line of array D :type vals_out: float :param vals_out: extreme value of each line (size nh, or NULL) :type idx_out: int :param idx_out: index of extreme value (size nh or NULL) )rZ&float_minheap_array_t_per_line_extremarZvals_outZidx_outrrrper_line_extrema,s z&float_minheap_array_t.per_line_extremacCst|tdSr#)rZfloat_minheap_array_t_swiginitZnew_float_minheap_array_tr@rrrr?,szfloat_minheap_array_t.__init__)rrr )Nrrr )Nr) r r r,r-rrrrrZfloat_minheap_array_t_nh_getZfloat_minheap_array_t_nh_setnhZfloat_minheap_array_t_k_getZfloat_minheap_array_t_k_setrZfloat_minheap_array_t_ids_getZfloat_minheap_array_t_ids_setr'Zfloat_minheap_array_t_val_getZfloat_minheap_array_t_val_setr]rrrrrrrrr?Zdelete_float_minheap_array_trTrrrrrJ,s"   rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d Zd dZddZd ddZd!ddZd"ddZddZddZddZejZdS)#int_minheap_array_trcCs |jSr#r0r1rrrr3,r4zint_minheap_array_t.cCs |j|Sr#r0r5rrrr3,r4r7r8rrrrcCs t||Sr)rZint_minheap_array_t_get_valrrrrr,szint_minheap_array_t.get_valcCs t||Sr)rZint_minheap_array_t_get_idsrrrrr,szint_minheap_array_t.get_idscCs t|Sr)rZint_minheap_array_t_heapifyr@rrrr,szint_minheap_array_t.heapifyrr cCst||||||Sa add nj elements to heaps i0:i0+ni, with sequential ids :type nj: int :param nj: nb of elements to add to each heap :type vin: int :param vin: elements to add, size ni * nj :type j0: int, optional :param j0: add this to the ids that are added :type i0: int, optional :param i0: first heap to update :type ni: int, optional :param ni: nb of elements to update (-1 = use nh) )rZint_minheap_array_t_addnrrrrr,szint_minheap_array_t.addnNc Cst|||||||Sr)rZ!int_minheap_array_t_addn_with_idsrrrrr,s z!int_minheap_array_t.addn_with_idsc Cst|||||||Sr)rZ.int_minheap_array_t_addn_query_subset_with_idsrrrrr,s z.int_minheap_array_t.addn_query_subset_with_idscCs t|Sr)rZint_minheap_array_t_reorderr@rrrr,szint_minheap_array_t.reordercCst|||SaA this is not really a heap function. It just finds the per-line extrema of each line of array D :type vals_out: int :param vals_out: extreme value of each line (size nh, or NULL) :type idx_out: int :param idx_out: index of extreme value (size nh or NULL) )rZ$int_minheap_array_t_per_line_extremarrrrr,s z$int_minheap_array_t.per_line_extremacCst|tdSr#)rZint_minheap_array_t_swiginitZnew_int_minheap_array_tr@rrrr?,szint_minheap_array_t.__init__)rrr )Nrrr )Nr) r r r,r-rrrrrZint_minheap_array_t_nh_getZint_minheap_array_t_nh_setrZint_minheap_array_t_k_getZint_minheap_array_t_k_setrZint_minheap_array_t_ids_getZint_minheap_array_t_ids_setr'Zint_minheap_array_t_val_getZint_minheap_array_t_val_setr]rrrrrrrrr?Zdelete_int_minheap_array_trTrrrrr,s"   rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d Zd dZddZd ddZd!ddZd"ddZddZddZddZejZdS)#float_maxheap_array_trcCs |jSr#r0r1rrrr3,r4zfloat_maxheap_array_t.cCs |j|Sr#r0r5rrrr3,r4r7r8rrrrcCs t||Sr)rZfloat_maxheap_array_t_get_valrrrrr-szfloat_maxheap_array_t.get_valcCs t||Sr)rZfloat_maxheap_array_t_get_idsrrrrr-szfloat_maxheap_array_t.get_idscCs t|Sr)rZfloat_maxheap_array_t_heapifyr@rrrr -szfloat_maxheap_array_t.heapifyrr cCst||||||Sr)rZfloat_maxheap_array_t_addnrrrrr-szfloat_maxheap_array_t.addnNc Cst|||||||Sr)rZ#float_maxheap_array_t_addn_with_idsrrrrr!-s z#float_maxheap_array_t.addn_with_idsc Cst|||||||Sr)rZ0float_maxheap_array_t_addn_query_subset_with_idsrrrrr,-s z0float_maxheap_array_t.addn_query_subset_with_idscCs t|Sr)rZfloat_maxheap_array_t_reorderr@rrrr7-szfloat_maxheap_array_t.reordercCst|||Sr)rZ&float_maxheap_array_t_per_line_extremarrrrr;-s z&float_maxheap_array_t.per_line_extremacCst|tdSr#)rZfloat_maxheap_array_t_swiginitZnew_float_maxheap_array_tr@rrrr?F-szfloat_maxheap_array_t.__init__)rrr )Nrrr )Nr) r r r,r-rrrrrZfloat_maxheap_array_t_nh_getZfloat_maxheap_array_t_nh_setrZfloat_maxheap_array_t_k_getZfloat_maxheap_array_t_k_setrZfloat_maxheap_array_t_ids_getZfloat_maxheap_array_t_ids_setr'Zfloat_maxheap_array_t_val_getZfloat_maxheap_array_t_val_setr]rrrrrrrrr?Zdelete_float_maxheap_array_trTrrrrr,s"   rc@seZdZdZeddddddZeZeej ej ddZ eej ej ddZeejejd dZeejejd dZd d Zd dZddZd ddZd!ddZd"ddZddZddZddZejZdS)#int_maxheap_array_trcCs |jSr#r0r1rrrr3S-r4zint_maxheap_array_t.cCs |j|Sr#r0r5rrrr3S-r4r7r8rrrrcCs t||Sr)rZint_maxheap_array_t_get_valrrrrrZ-szint_maxheap_array_t.get_valcCs t||Sr)rZint_maxheap_array_t_get_idsrrrrr^-szint_maxheap_array_t.get_idscCs t|Sr)rZint_maxheap_array_t_heapifyr@rrrrb-szint_maxheap_array_t.heapifyrr cCst||||||Sr)rZint_maxheap_array_t_addnrrrrrf-szint_maxheap_array_t.addnNc Cst|||||||Sr)rZ!int_maxheap_array_t_addn_with_idsrrrrrw-s z!int_maxheap_array_t.addn_with_idsc Cst|||||||Sr)rZ.int_maxheap_array_t_addn_query_subset_with_idsrrrrr-s z.int_maxheap_array_t.addn_query_subset_with_idscCs t|Sr)rZint_maxheap_array_t_reorderr@rrrr-szint_maxheap_array_t.reordercCst|||Sr)rZ$int_maxheap_array_t_per_line_extremarrrrr-s z$int_maxheap_array_t.per_line_extremacCst|tdSr#)rZint_maxheap_array_t_swiginitZnew_int_maxheap_array_tr@rrrr?-szint_maxheap_array_t.__init__)rrr )Nrrr )Nr) r r r,r-rrrrrZint_maxheap_array_t_nh_getZint_maxheap_array_t_nh_setrZint_maxheap_array_t_k_getZint_maxheap_array_t_k_setrZint_maxheap_array_t_ids_getZint_maxheap_array_t_ids_setr'Zint_maxheap_array_t_val_getZint_maxheap_array_t_val_setr]rrrrrrrrr?Zdelete_int_maxheap_array_trTrrrrrL-s"   rcCst||||||Sz partitions the table into 0:q and q:n where all elements above q are >= all elements below q (for C = CMax, for CMin comparisons are reversed) Returns the partition threshold. The elements q:n are destroyed on output. )rCMin_float_partition_fuzzyr1r'rBZq_minZq_maxZq_outrrrr-srcCst||||||Sr)rCMax_float_partition_fuzzyrrrrr-src@seZdZeddddddZeZeejej Z eej ej Z eddZdd Zd d Zd d ZddZddZddZddZddZejZdS)AlignedTableUint8cCs |jSr#r0r1rrrr3-r4zAlignedTableUint8.cCs |j|Sr#r0r5rrrr3-r4r7r8cCs t|Sr#)rZ AlignedTableUint8_round_capacityrBrrrround_capacity-sz AlignedTableUint8.round_capacitycGst|tj|dSr#)rZAlignedTableUint8_swiginitZnew_AlignedTableUint8rQrrrr?-szAlignedTableUint8.__init__cCs t|Sr#)rZAlignedTableUint8_itemsizer@rrritemsize-szAlignedTableUint8.itemsizecCs t||Sr#)rZAlignedTableUint8_resizerArrrr]-szAlignedTableUint8.resizecCs t|Sr#)rZAlignedTableUint8_clearr@rrrrY-szAlignedTableUint8.clearcCs t|Sr#)rZAlignedTableUint8_sizer@rrrr[-szAlignedTableUint8.sizecCs t|Sr#)rZAlignedTableUint8_nbytesr@rrrnbytes-szAlignedTableUint8.nbytescGstj|g|RSr#)rZAlignedTableUint8_getrQrrrrV-szAlignedTableUint8.getcGstj|g|RSr#)rZAlignedTableUint8_datarQrrrrZ-szAlignedTableUint8.dataN)r r r,rrrrrZAlignedTableUint8_tab_getZAlignedTableUint8_tab_setr`ZAlignedTableUint8_numel_getZAlignedTableUint8_numel_setr rrr?rr]rYr[rrVrZZdelete_AlignedTableUint8rTrrrrr-s rc@seZdZeddddddZeZeejej Z eej ej Z eddZdd Zd d Zd d ZddZddZddZddZddZejZdS)AlignedTableUint16cCs |jSr#r0r1rrrr3-r4zAlignedTableUint16.cCs |j|Sr#r0r5rrrr3-r4r7r8cCs t|Sr#)rZ!AlignedTableUint16_round_capacityrrrrr-sz!AlignedTableUint16.round_capacitycGst|tj|dSr#)rZAlignedTableUint16_swiginitZnew_AlignedTableUint16rQrrrr?-szAlignedTableUint16.__init__cCs t|Sr#)rZAlignedTableUint16_itemsizer@rrrr-szAlignedTableUint16.itemsizecCs t||Sr#)rZAlignedTableUint16_resizerArrrr]-szAlignedTableUint16.resizecCs t|Sr#)rZAlignedTableUint16_clearr@rrrrY-szAlignedTableUint16.clearcCs t|Sr#)rZAlignedTableUint16_sizer@rrrr[-szAlignedTableUint16.sizecCs t|Sr#)rZAlignedTableUint16_nbytesr@rrrr-szAlignedTableUint16.nbytescGstj|g|RSr#)rZAlignedTableUint16_getrQrrrrV-szAlignedTableUint16.getcGstj|g|RSr#)rZAlignedTableUint16_datarQrrrrZ-szAlignedTableUint16.dataN)r r r,rrrrrZAlignedTableUint16_tab_getZAlignedTableUint16_tab_setr`ZAlignedTableUint16_numel_getZAlignedTableUint16_numel_setr rrr?rr]rYr[rrVrZZdelete_AlignedTableUint16rTrrrrr-s rc@seZdZeddddddZeZeejej Z eej ej Z eddZdd Zd d Zd d ZddZddZddZddZddZejZdS)AlignedTableFloat32cCs |jSr#r0r1rrrr3-r4zAlignedTableFloat32.cCs |j|Sr#r0r5rrrr3-r4r7r8cCs t|Sr#)rZ"AlignedTableFloat32_round_capacityrrrrr.sz"AlignedTableFloat32.round_capacitycGst|tj|dSr#)rZAlignedTableFloat32_swiginitZnew_AlignedTableFloat32rQrrrr?.szAlignedTableFloat32.__init__cCs t|Sr#)rZAlignedTableFloat32_itemsizer@rrrr .szAlignedTableFloat32.itemsizecCs t||Sr#)rZAlignedTableFloat32_resizerArrrr].szAlignedTableFloat32.resizecCs t|Sr#)rZAlignedTableFloat32_clearr@rrrrY.szAlignedTableFloat32.clearcCs t|Sr#)rZAlignedTableFloat32_sizer@rrrr[.szAlignedTableFloat32.sizecCs t|Sr#)rZAlignedTableFloat32_nbytesr@rrrr.szAlignedTableFloat32.nbytescGstj|g|RSr#)rZAlignedTableFloat32_getrQrrrrV.szAlignedTableFloat32.getcGstj|g|RSr#)rZAlignedTableFloat32_datarQrrrrZ.szAlignedTableFloat32.dataN)r r r,rrrrrZAlignedTableFloat32_tab_getZAlignedTableFloat32_tab_setr`ZAlignedTableFloat32_numel_getZAlignedTableFloat32_numel_setr rrr?rr]rYr[rrVrZZdelete_AlignedTableFloat32rTrrrrr-s rcGs tj|Sr#)rCMin_uint16_partition_fuzzyrrrrr$.srcGs tj|Sr#)rCMax_uint16_partition_fuzzyrrrrr'.srcGs tj|Sr#)rmerge_knn_results_CMinrrrrr*.srcGs tj|Sr#)rmerge_knn_results_CMaxrrrrr-.src@sZeZdZeddddddZeZeejej Z ddZ dd Z d d Z d d ZejZdS) MapLong2LongcCs |jSr#r0r1rrrr30.r4zMapLong2Long.cCs |j|Sr#r0r5rrrr30.r4r7r8cCst||||Sr#)rZMapLong2Long_addrrBrcr1rrrro4.szMapLong2Long.addcCs t||Sr#)rZMapLong2Long_searchrrrrru7.szMapLong2Long.searchcCst||||Sr#)rZMapLong2Long_search_multiplerrrrsearch_multiple:.szMapLong2Long.search_multiplecCst|tdSr#)rZMapLong2Long_swiginitZnew_MapLong2Longr@rrrr?=.szMapLong2Long.__init__N)r r r,rrrrrZMapLong2Long_map_getZMapLong2Long_map_setrrorurr?Zdelete_MapLong2LongrTrrrrr/.srcCs t|Sr#)romp_set_num_threads)Z num_threadsrrrrD.srcCstSr#)romp_get_max_threadsrrrrrG.srcCst|||Sr#)rmemcpy)destrrBrrrrJ.src@sHeZdZeddddddZeZddZedd Z d d Z e j Z d S) PythonInterruptCallbackcCs |jSr#r0r1rrrr3M.r4z PythonInterruptCallback.cCs |j|Sr#r0r5rrrr3M.r4r7r8cCs t|Sr#)rZ&PythonInterruptCallback_want_interruptr@rrrr7P.sz&PythonInterruptCallback.want_interruptcCstSr#)rZPythonInterruptCallback_resetrrrrr|S.szPythonInterruptCallback.resetcCst|tdSr#)rZ PythonInterruptCallback_swiginitZnew_PythonInterruptCallbackr@rrrr?W.sz PythonInterruptCallback.__init__N)r r r,rrrrr7rr|r?rZdelete_PythonInterruptCallbackrTrrrrrL.s rcCs t|Sr#)rswig_ptr)rrrrr^.srcGs tj|Sr#)r rev_swig_ptrrrrrra.srcCs t|Sr#)rcast_integer_to_uint8_ptrr1rrrrd.srcCs t|Sr#)rcast_integer_to_float_ptrr1rrrrg.srcCs t|Sr#)rcast_integer_to_idx_t_ptrr1rrrrj.srcCs t|Sr#)rcast_integer_to_int_ptrr1rrrrm.srcCs t|Sr#)rcast_integer_to_void_ptrr1rrrrp.srcCstSr#)r swig_versionrrrrrs.sr)T)Tr)Fr)r r r )r )r )N)N)r)r r r )NN)NN)r )rN)F)NN)NN)NN)r(sysrZ_swig_python_version_info __package__r rrbuiltinsr ImportErrorrrr"r*rr+objectr/ZSwigPyIterator_swigregisterZSHARED_PTR_DISOWNrUZFloat32Vector_swigregisterraZFloat64Vector_swigregisterrbZInt8Vector_swigregisterrcZInt16Vector_swigregisterrdZInt32Vector_swigregisterreZInt64Vector_swigregisterrfZUInt8Vector_swigregisterrgZUInt16Vector_swigregisterrhZUInt32Vector_swigregisterriZUInt64Vector_swigregisterrjZ Float32VectorVector_swigregisterrkZUInt8VectorVector_swigregisterrlZInt32VectorVector_swigregisterrmZInt64VectorVector_swigregisterrnZ"VectorTransformVector_swigregisterroZ!OperatingPointVector_swigregisterrpZ#InvertedListsPtrVector_swigregisterrqZRepeatVector_swigregisterrrZ+ClusteringIterationStatsVector_swigregisterrsZ!ParameterRangeVector_swigregisterrtZ OnDiskOneListVector_swigregisterrurzr{ZPartitionStats_swigregisterr}rrrrrZBitstringWriter_swigregisterZcvarrZBitstringReader_swigregisterrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrZCodeSet_swigregisterZhamdis_tab_ham_bytesrZ"CombinerRangeKNNfloat_swigregisterrZ"CombinerRangeKNNint16_swigregisterrrrrrr r rrrrrrrr r!r"r#r$r&r(r)r+r,r-r.r2r3r6r7r;r>r?ZRandomGenerator_swigregisterrIZ&SplitMix64RandomGenerator_swigregisterrKrMrNrOrPrRrUrVrWrYrZr]r^rardZMETRIC_INNER_PRODUCTZ METRIC_L2Z METRIC_L1Z METRIC_LinfZ METRIC_LpZMETRIC_CanberraZMETRIC_BrayCurtisZMETRIC_JensenShannonZMETRIC_JaccardZMETRIC_NaNEuclideanZMETRIC_ABS_INNER_PRODUCTreZFAISS_VERSION_MAJORZFAISS_VERSION_MINORZFAISS_VERSION_PATCHZVERSION_STRINGrgZSearchParameters_swigregisterrhZIndex_swigregisterrZDistanceComputer_swigregisterrZ%NegativeDistanceComputer_swigregisterrZ&FlatCodesDistanceComputer_swigregisterrZIndexFlatCodes_swigregisterrZIndexFlat_swigregisterrZIndexFlatIP_swigregisterrZIndexFlatL2_swigregisterrZIndexFlat1D_swigregisterrZ!ClusteringParameters_swigregisterrZ%ClusteringIterationStats_swigregisterrZClustering_swigregisterrZClustering1D_swigregisterrZ/ProgressiveDimClusteringParameters_swigregisterrZ'ProgressiveDimIndexFactory_swigregisterrZ%ProgressiveDimClustering_swigregisterrrrrrZQuantizer_swigregisterrZProductQuantizer_swigregisterrZPQEncoderGeneric_swigregisterrZPQEncoder8_swigregisterrZPQEncoder16_swigregisterrZPQDecoderGeneric_swigregisterrZPQDecoder8_swigregisterrZPQDecoder16_swigregisterrZAdditiveQuantizer_swigregisterrr r!Z!RefineBeamMemoryPool_swigregisterr$r+Z$RefineBeamLUTMemoryPool_swigregisterr-r0Z3ComputeCodesAddCentroidsLUT0MemoryPool_swigregisterr1r3Z3ComputeCodesAddCentroidsLUT1MemoryPool_swigregisterr4r5ZResidualQuantizer_swigregisterr=Z!LocalSearchQuantizer_swigregisterrQZIcmEncoder_swigregisterrUZIcmEncoderFactory_swigregisterrWZLSQTimer_swigregisterr[ZLSQTimerScope_swigregisterr`Z%ProductAdditiveQuantizer_swigregisterrdZ(ProductLocalSearchQuantizer_swigregisterreZ%ProductResidualQuantizer_swigregisterrfZCodePacker_swigregisterrsZCodePackerFlat_swigregisterrtZVectorTransform_swigregisterr~ZLinearTransform_swigregisterrZ!RandomRotationMatrix_swigregisterrZPCAMatrix_swigregisterrZITQMatrix_swigregisterrZITQTransform_swigregisterrZOPQMatrix_swigregisterrZ%RemapDimensionsTransform_swigregisterrZ#NormalizationTransform_swigregisterrZCenteringTransform_swigregisterrZ)SearchParametersPreTransform_swigregisterrZIndexPreTransform_swigregisterrZ(IndexRefineSearchParameters_swigregisterrZIndexRefine_swigregisterrZIndexRefineFlat_swigregisterrZIndexLSH_swigregisterrZ)SimulatedAnnealingParameters_swigregisterrZ!PermutationObjective_swigregisterrZ(ReproduceDistancesObjective_swigregisterrZ(SimulatedAnnealingOptimizer_swigregisterrZPolysemousTraining_swigregisterrZIndexPQ_swigregisterrZSearchParametersPQ_swigregisterrZIndexPQStats_swigregisterrZ MultiIndexQuantizer_swigregisterrZ!MultiIndexQuantizer2_swigregisterrZ#IndexAdditiveQuantizer_swigregisterrZ#IndexResidualQuantizer_swigregisterrZ&IndexLocalSearchQuantizer_swigregisterrZ*IndexProductResidualQuantizer_swigregisterrZ-IndexProductLocalSearchQuantizer_swigregisterrZ$AdditiveCoarseQuantizer_swigregisterrZ4SearchParametersResidualCoarseQuantizer_swigregisterrZ$ResidualCoarseQuantizer_swigregisterrZ'LocalSearchCoarseQuantizer_swigregisterrZIOReader_swigregisterrZIOWriter_swigregisterrZVectorIOReader_swigregisterrZVectorIOWriter_swigregisterrZFileIOReader_swigregisterrZFileIOWriter_swigregisterrZBufferedIOReader_swigregisterrZBufferedIOWriter_swigregisterrrrrZ"InvertedListsIterator_swigregisterrZInvertedLists_swigregisterr#ZArrayInvertedLists_swigregisterr&Z"ReadOnlyInvertedLists_swigregisterr'Z HStackInvertedLists_swigregisterr,ZSliceInvertedLists_swigregisterr/Z VStackInvertedLists_swigregisterr0Z MaskedInvertedLists_swigregisterr3Z#StopWordsInvertedLists_swigregisterr5Z InvertedListsIOHook_swigregisterrAZBlockInvertedLists_swigregisterrDrErHrIZDirectMap_swigregisterrSZDirectMapAdd_swigregisterrUZLevel1Quantizer_swigregisterr`Z SearchParametersIVF_swigregisterreZIndexIVFInterface_swigregisterrnZIndexIVF_swigregisterrZ InvertedListScanner_swigregisterrZIndexIVFStats_swigregisterrrrrrrrZSlidingIndexWindow_swigregisterrrrrrrrZScalarQuantizer_swigregisterrZ!IndexScalarQuantizer_swigregisterrZ$IndexIVFScalarQuantizer_swigregisterrZ!IndexIVFSpectralHash_swigregisterrZ&IndexIVFAdditiveQuantizer_swigregisterrZ&IndexIVFResidualQuantizer_swigregisterrZ)IndexIVFLocalSearchQuantizer_swigregisterrZ-IndexIVFProductResidualQuantizer_swigregisterrZ0IndexIVFProductLocalSearchQuantizer_swigregisterrZ!SearchParametersHNSW_swigregisterrZHNSW_swigregisterrZHNSWStats_swigregisterrrrrrZIndexHNSW_swigregisterrZIndexHNSWFlat_swigregisterrZIndexHNSWPQ_swigregisterrZIndexHNSWSQ_swigregisterrZIndexHNSW2Level_swigregisterr ZIndexHNSWCagra_swigregisterr r r ZNeighbor_swigregisterrZNhood_swigregisterrZNNDescent_swigregisterr%ZIndexNNDescent_swigregisterr&ZIndexNNDescentFlat_swigregisterr'ZIndexIVFFlat_swigregisterr(ZIndexIVFFlatDedup_swigregisterr)r*ZNSG_swigregisterr:ZNSG_Graph_int_swigregisterr<ZIndexNSG_swigregisterr?ZIndexNSGFlat_swigregisterr@ZIndexNSGPQ_swigregisterrAZIndexNSGSQ_swigregisterrBZOnDiskOneList_swigregisterrDZ OnDiskInvertedLists_swigregisterrSZZnSphereSearch_swigregisterrVZEnumeratedVectors_swigregisterr\ZRepeat_swigregisterr^ZRepeats_swigregisterr`ZZnSphereCodec_swigregisterrbZZnSphereCodecRec_swigregisterrjZZnSphereCodecAlt_swigregisterrkZIndexLattice_swigregisterrnZ"IVFPQSearchParameters_swigregisterrrZIndexIVFPQ_swigregisterrzr{ZIndexIVFPQStats_swigregisterr|ZIndexIVFPQR_swigregisterr}ZIndex2Layer_swigregisterrZIndexFastScan_swigregisterrZFastScanStats_swigregisterrZ+IndexAdditiveQuantizerFastScan_swigregisterrZ+IndexResidualQuantizerFastScan_swigregisterrZ.IndexLocalSearchQuantizerFastScan_swigregisterrZ2IndexProductResidualQuantizerFastScan_swigregisterrZ5IndexProductLocalSearchQuantizerFastScan_swigregisterrZIndexPQFastScan_swigregisterrZsimd16uint16_swigregisterrZSIMDResultHandler_swigregisterrZ%SIMDResultHandlerToFloat_swigregisterrZDummyResultHandler_swigregisterrZStoreResultHandler_swigregisterrZIndexIVFFastScan_swigregisterrZIVFFastScanStats_swigregisterrZ.IndexIVFAdditiveQuantizerFastScan_swigregisterrZ1IndexIVFLocalSearchQuantizerFastScan_swigregisterrZ.IndexIVFResidualQuantizerFastScan_swigregisterrZ8IndexIVFProductLocalSearchQuantizerFastScan_swigregisterrZ5IndexIVFProductResidualQuantizerFastScan_swigregisterrZ)IndexIVFIndependentQuantizer_swigregisterrZIndexIVFPQFastScan_swigregisterrrrrrrZIndexBinary_swigregisterrZIndexBinaryFlat_swigregisterrZIndexBinaryIVF_swigregisterrZ&BinaryInvertedListScanner_swigregisterrZ!IndexBinaryFromFloat_swigregisterrZIndexBinaryHNSW_swigregisterrZIndexBinaryHash_swigregisterrZ!IndexBinaryHashStats_swigregisterrZ!IndexBinaryMultiHash_swigregisterrZThreadedIndexBase_swigregisterrZ$ThreadedIndexBaseBinary_swigregisterrZIndexShards_swigregisterrZIndexBinaryShards_swigregisterrZIndexShardsIVF_swigregisterrZIndexReplicas_swigregisterrZ IndexBinaryReplicas_swigregisterrZIndexSplitVectors_swigregisterrZIndexRandom_swigregisterrZ#IndexRowwiseMinMaxBase_swigregisterr Z#IndexRowwiseMinMaxFP16_swigregisterr ZIndexRowwiseMinMax_swigregisterr ZLinear_swigregisterrZEmbedding_swigregisterrZFFN_swigregisterrZQINCoStep_swigregisterrZNeuralNetCodec_swigregisterrZQINCo_swigregisterrZTensor2D_swigregisterr"ZInt32Tensor2D_swigregisterr#Z IndexNeuralNetCodec_swigregisterr%ZIndexQINCo_swigregisterr&ZRangeSearchResult_swigregisterr)ZBufferList_swigregisterr-ZRangeQueryResult_swigregisterr/Z%RangeSearchPartialResult_swigregisterr6ZInterruptCallback_swigregisterr<ZTimeoutCallback_swigregisterrAZVisitedTable_swigregisterrDZIDSelector_swigregisterrFZIDSelectorRange_swigregisterrKZIDSelectorArray_swigregisterrLZIDSelectorBatch_swigregisterrMZIDSelectorBitmap_swigregisterrOZIDSelectorNot_swigregisterrPZIDSelectorAll_swigregisterrQZIDSelectorAnd_swigregisterrUZIDSelectorOr_swigregisterrVZIDSelectorXOr_swigregisterrWZ!IDSelectorTranslated_swigregisterrXZIndexIDMap_swigregisterr^ZIndexBinaryIDMap_swigregisterr_ZIndexIDMap2_swigregisterrfZIndexBinaryIDMap2_swigregisterZ EXACT_TOPKZAPPROX_TOPK_BUCKETS_B32_D2ZAPPROX_TOPK_BUCKETS_B8_D3ZAPPROX_TOPK_BUCKETS_B16_D2ZAPPROX_TOPK_BUCKETS_B8_D2rgrirjrkrlrnrorprqrrrsrtrurvrwrxryrzZCloner_swigregisterZIO_FLAG_SKIP_STORAGEZIO_FLAG_READ_ONLYZIO_FLAG_ONDISK_SAME_DIRZIO_FLAG_SKIP_IVF_DATAZIO_FLAG_SKIP_PRECOMPUTE_TABLEZIO_FLAG_PQ_SKIP_SDC_TABLEZ IO_FLAG_MMAPr~rrZAutoTuneCriterion_swigregisterrZ"OneRecallAtRCriterion_swigregisterrZ"IntersectionCriterion_swigregisterrZOperatingPoint_swigregisterrZOperatingPoints_swigregisterrZParameterRange_swigregisterrZParameterSpace_swigregisterrrrZMatrixStats_swigregisterrZPyCallbackIOWriter_swigregisterrZPyCallbackIOReader_swigregisterrZ!PyCallbackIDSelector_swigregisterrZ"float_minheap_array_t_swigregisterrZ int_minheap_array_t_swigregisterrZ"float_maxheap_array_t_swigregisterrZ int_maxheap_array_t_swigregisterrrrZAlignedTableUint8_swigregisterrZAlignedTableUint16_swigregisterrZ AlignedTableFloat32_swigregisterrrrrrZMapLong2Long_swigregisterrrrrZ$PythonInterruptCallback_swigregisterrrrrrrrrrrrrs      ;                                ( (   -H    # )        3    I /    /  ?        + %       >  "        q  S  ?0+  \ 50$/I  " "   &%&$+(949( CG S&@" iI6"(63 c* . h+)OE, o:    47)., %# ::tt^^%0  %+"55##            +  % T  UUUU $$$