mirror of
https://github.com/facebookresearch/faiss.git
synced 2025-06-03 21:54:02 +08:00
250a3d3f18
various bugfixes from github issues kmean with some frozen centroids GPU better tiling for large flat datasets default AVX for vector ops
3326 lines
209 KiB
Python
3326 lines
209 KiB
Python
# This file was automatically generated by SWIG (http://www.swig.org).
|
|
# Version 3.0.1
|
|
#
|
|
# Do not make changes to this file unless you know what you are doing--modify
|
|
# the SWIG interface file instead.
|
|
|
|
|
|
|
|
|
|
|
|
from sys import version_info
|
|
if version_info >= (2,6,0):
|
|
def swig_import_helper():
|
|
from os.path import dirname
|
|
import imp
|
|
fp = None
|
|
try:
|
|
fp, pathname, description = imp.find_module('_swigfaiss_gpu', [dirname(__file__)])
|
|
except ImportError:
|
|
import _swigfaiss_gpu
|
|
return _swigfaiss_gpu
|
|
if fp is not None:
|
|
try:
|
|
_mod = imp.load_module('_swigfaiss_gpu', fp, pathname, description)
|
|
finally:
|
|
fp.close()
|
|
return _mod
|
|
_swigfaiss_gpu = swig_import_helper()
|
|
del swig_import_helper
|
|
else:
|
|
import _swigfaiss_gpu
|
|
del version_info
|
|
try:
|
|
_swig_property = property
|
|
except NameError:
|
|
pass # Python < 2.2 doesn't have 'property'.
|
|
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
|
|
if (name == "thisown"): return self.this.own(value)
|
|
if (name == "this"):
|
|
if type(value).__name__ == 'SwigPyObject':
|
|
self.__dict__[name] = value
|
|
return
|
|
method = class_type.__swig_setmethods__.get(name,None)
|
|
if method: return method(self,value)
|
|
if (not static):
|
|
self.__dict__[name] = value
|
|
else:
|
|
raise AttributeError("You cannot add attributes to %s" % self)
|
|
|
|
def _swig_setattr(self,class_type,name,value):
|
|
return _swig_setattr_nondynamic(self,class_type,name,value,0)
|
|
|
|
def _swig_getattr(self,class_type,name):
|
|
if (name == "thisown"): return self.this.own()
|
|
method = class_type.__swig_getmethods__.get(name,None)
|
|
if method: return method(self)
|
|
raise AttributeError(name)
|
|
|
|
def _swig_repr(self):
|
|
try: strthis = "proxy of " + self.this.__repr__()
|
|
except: strthis = ""
|
|
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
|
|
|
|
try:
|
|
_object = object
|
|
_newclass = 1
|
|
except AttributeError:
|
|
class _object : pass
|
|
_newclass = 0
|
|
|
|
|
|
class FloatVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_FloatVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.FloatVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.FloatVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.FloatVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.FloatVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.FloatVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.FloatVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_FloatVector
|
|
__del__ = lambda self : None;
|
|
FloatVector_swigregister = _swigfaiss_gpu.FloatVector_swigregister
|
|
FloatVector_swigregister(FloatVector)
|
|
|
|
class DoubleVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_DoubleVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.DoubleVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.DoubleVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.DoubleVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.DoubleVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.DoubleVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.DoubleVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_DoubleVector
|
|
__del__ = lambda self : None;
|
|
DoubleVector_swigregister = _swigfaiss_gpu.DoubleVector_swigregister
|
|
DoubleVector_swigregister(DoubleVector)
|
|
|
|
class ByteVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ByteVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ByteVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_ByteVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.ByteVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.ByteVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.ByteVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.ByteVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.ByteVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.ByteVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_ByteVector
|
|
__del__ = lambda self : None;
|
|
ByteVector_swigregister = _swigfaiss_gpu.ByteVector_swigregister
|
|
ByteVector_swigregister(ByteVector)
|
|
|
|
class Uint64Vector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Uint64Vector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Uint64Vector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_Uint64Vector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.Uint64Vector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.Uint64Vector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.Uint64Vector_data(self)
|
|
def size(self): return _swigfaiss_gpu.Uint64Vector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.Uint64Vector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.Uint64Vector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_Uint64Vector
|
|
__del__ = lambda self : None;
|
|
Uint64Vector_swigregister = _swigfaiss_gpu.Uint64Vector_swigregister
|
|
Uint64Vector_swigregister(Uint64Vector)
|
|
|
|
class LongVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, LongVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, LongVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_LongVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.LongVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.LongVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.LongVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.LongVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.LongVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.LongVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_LongVector
|
|
__del__ = lambda self : None;
|
|
LongVector_swigregister = _swigfaiss_gpu.LongVector_swigregister
|
|
LongVector_swigregister(LongVector)
|
|
|
|
class IntVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_IntVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.IntVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.IntVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.IntVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.IntVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.IntVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.IntVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IntVector
|
|
__del__ = lambda self : None;
|
|
IntVector_swigregister = _swigfaiss_gpu.IntVector_swigregister
|
|
IntVector_swigregister(IntVector)
|
|
|
|
class VectorTransformVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, VectorTransformVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, VectorTransformVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_VectorTransformVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.VectorTransformVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.VectorTransformVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.VectorTransformVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.VectorTransformVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.VectorTransformVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.VectorTransformVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_VectorTransformVector
|
|
__del__ = lambda self : None;
|
|
VectorTransformVector_swigregister = _swigfaiss_gpu.VectorTransformVector_swigregister
|
|
VectorTransformVector_swigregister(VectorTransformVector)
|
|
|
|
class OperatingPointVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, OperatingPointVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, OperatingPointVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_OperatingPointVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.OperatingPointVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.OperatingPointVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.OperatingPointVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.OperatingPointVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.OperatingPointVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.OperatingPointVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_OperatingPointVector
|
|
__del__ = lambda self : None;
|
|
OperatingPointVector_swigregister = _swigfaiss_gpu.OperatingPointVector_swigregister
|
|
OperatingPointVector_swigregister(OperatingPointVector)
|
|
|
|
class FloatVectorVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, FloatVectorVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, FloatVectorVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_FloatVectorVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.FloatVectorVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.FloatVectorVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.FloatVectorVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.FloatVectorVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.FloatVectorVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.FloatVectorVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_FloatVectorVector
|
|
__del__ = lambda self : None;
|
|
FloatVectorVector_swigregister = _swigfaiss_gpu.FloatVectorVector_swigregister
|
|
FloatVectorVector_swigregister(FloatVectorVector)
|
|
|
|
class ByteVectorVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ByteVectorVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ByteVectorVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_ByteVectorVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.ByteVectorVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.ByteVectorVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.ByteVectorVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.ByteVectorVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.ByteVectorVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.ByteVectorVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_ByteVectorVector
|
|
__del__ = lambda self : None;
|
|
ByteVectorVector_swigregister = _swigfaiss_gpu.ByteVectorVector_swigregister
|
|
ByteVectorVector_swigregister(ByteVectorVector)
|
|
|
|
class LongVectorVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, LongVectorVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, LongVectorVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_LongVectorVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.LongVectorVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.LongVectorVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.LongVectorVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.LongVectorVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.LongVectorVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.LongVectorVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_LongVectorVector
|
|
__del__ = lambda self : None;
|
|
LongVectorVector_swigregister = _swigfaiss_gpu.LongVectorVector_swigregister
|
|
LongVectorVector_swigregister(LongVectorVector)
|
|
|
|
class GpuResourcesVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuResourcesVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuResourcesVector, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_GpuResourcesVector()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _swigfaiss_gpu.GpuResourcesVector_push_back(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.GpuResourcesVector_clear(self)
|
|
def data(self): return _swigfaiss_gpu.GpuResourcesVector_data(self)
|
|
def size(self): return _swigfaiss_gpu.GpuResourcesVector_size(self)
|
|
def at(self, *args): return _swigfaiss_gpu.GpuResourcesVector_at(self, *args)
|
|
def resize(self, *args): return _swigfaiss_gpu.GpuResourcesVector_resize(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuResourcesVector
|
|
__del__ = lambda self : None;
|
|
GpuResourcesVector_swigregister = _swigfaiss_gpu.GpuResourcesVector_swigregister
|
|
GpuResourcesVector_swigregister(GpuResourcesVector)
|
|
|
|
|
|
def popcount64(*args):
|
|
return _swigfaiss_gpu.popcount64(*args)
|
|
popcount64 = _swigfaiss_gpu.popcount64
|
|
|
|
def hammings(*args):
|
|
return _swigfaiss_gpu.hammings(*args)
|
|
hammings = _swigfaiss_gpu.hammings
|
|
|
|
def bitvec_print(*args):
|
|
return _swigfaiss_gpu.bitvec_print(*args)
|
|
bitvec_print = _swigfaiss_gpu.bitvec_print
|
|
|
|
def fvecs2bitvecs(*args):
|
|
return _swigfaiss_gpu.fvecs2bitvecs(*args)
|
|
fvecs2bitvecs = _swigfaiss_gpu.fvecs2bitvecs
|
|
|
|
def fvec2bitvec(*args):
|
|
return _swigfaiss_gpu.fvec2bitvec(*args)
|
|
fvec2bitvec = _swigfaiss_gpu.fvec2bitvec
|
|
|
|
def hammings_knn(*args):
|
|
return _swigfaiss_gpu.hammings_knn(*args)
|
|
hammings_knn = _swigfaiss_gpu.hammings_knn
|
|
|
|
def hammings_knn_core(*args):
|
|
return _swigfaiss_gpu.hammings_knn_core(*args)
|
|
hammings_knn_core = _swigfaiss_gpu.hammings_knn_core
|
|
|
|
def hamming_count_thres(*args):
|
|
return _swigfaiss_gpu.hamming_count_thres(*args)
|
|
hamming_count_thres = _swigfaiss_gpu.hamming_count_thres
|
|
|
|
def match_hamming_thres(*args):
|
|
return _swigfaiss_gpu.match_hamming_thres(*args)
|
|
match_hamming_thres = _swigfaiss_gpu.match_hamming_thres
|
|
|
|
def crosshamming_count_thres(*args):
|
|
return _swigfaiss_gpu.crosshamming_count_thres(*args)
|
|
crosshamming_count_thres = _swigfaiss_gpu.crosshamming_count_thres
|
|
class HammingComputer4(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HammingComputer4, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HammingComputer4, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a0"] = _swigfaiss_gpu.HammingComputer4_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss_gpu.HammingComputer4_a0_get
|
|
if _newclass:a0 = _swig_property(_swigfaiss_gpu.HammingComputer4_a0_get, _swigfaiss_gpu.HammingComputer4_a0_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_HammingComputer4(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.HammingComputer4_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_HammingComputer4
|
|
__del__ = lambda self : None;
|
|
HammingComputer4_swigregister = _swigfaiss_gpu.HammingComputer4_swigregister
|
|
HammingComputer4_swigregister(HammingComputer4)
|
|
|
|
class HammingComputer8(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HammingComputer8, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HammingComputer8, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a0"] = _swigfaiss_gpu.HammingComputer8_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss_gpu.HammingComputer8_a0_get
|
|
if _newclass:a0 = _swig_property(_swigfaiss_gpu.HammingComputer8_a0_get, _swigfaiss_gpu.HammingComputer8_a0_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_HammingComputer8(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.HammingComputer8_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_HammingComputer8
|
|
__del__ = lambda self : None;
|
|
HammingComputer8_swigregister = _swigfaiss_gpu.HammingComputer8_swigregister
|
|
HammingComputer8_swigregister(HammingComputer8)
|
|
|
|
class HammingComputer16(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HammingComputer16, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HammingComputer16, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a0"] = _swigfaiss_gpu.HammingComputer16_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss_gpu.HammingComputer16_a0_get
|
|
if _newclass:a0 = _swig_property(_swigfaiss_gpu.HammingComputer16_a0_get, _swigfaiss_gpu.HammingComputer16_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss_gpu.HammingComputer16_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss_gpu.HammingComputer16_a1_get
|
|
if _newclass:a1 = _swig_property(_swigfaiss_gpu.HammingComputer16_a1_get, _swigfaiss_gpu.HammingComputer16_a1_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_HammingComputer16(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.HammingComputer16_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_HammingComputer16
|
|
__del__ = lambda self : None;
|
|
HammingComputer16_swigregister = _swigfaiss_gpu.HammingComputer16_swigregister
|
|
HammingComputer16_swigregister(HammingComputer16)
|
|
|
|
class HammingComputer20(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HammingComputer20, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HammingComputer20, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a0"] = _swigfaiss_gpu.HammingComputer20_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss_gpu.HammingComputer20_a0_get
|
|
if _newclass:a0 = _swig_property(_swigfaiss_gpu.HammingComputer20_a0_get, _swigfaiss_gpu.HammingComputer20_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss_gpu.HammingComputer20_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss_gpu.HammingComputer20_a1_get
|
|
if _newclass:a1 = _swig_property(_swigfaiss_gpu.HammingComputer20_a1_get, _swigfaiss_gpu.HammingComputer20_a1_set)
|
|
__swig_setmethods__["a2"] = _swigfaiss_gpu.HammingComputer20_a2_set
|
|
__swig_getmethods__["a2"] = _swigfaiss_gpu.HammingComputer20_a2_get
|
|
if _newclass:a2 = _swig_property(_swigfaiss_gpu.HammingComputer20_a2_get, _swigfaiss_gpu.HammingComputer20_a2_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_HammingComputer20(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.HammingComputer20_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_HammingComputer20
|
|
__del__ = lambda self : None;
|
|
HammingComputer20_swigregister = _swigfaiss_gpu.HammingComputer20_swigregister
|
|
HammingComputer20_swigregister(HammingComputer20)
|
|
|
|
class HammingComputer32(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HammingComputer32, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HammingComputer32, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a0"] = _swigfaiss_gpu.HammingComputer32_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss_gpu.HammingComputer32_a0_get
|
|
if _newclass:a0 = _swig_property(_swigfaiss_gpu.HammingComputer32_a0_get, _swigfaiss_gpu.HammingComputer32_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss_gpu.HammingComputer32_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss_gpu.HammingComputer32_a1_get
|
|
if _newclass:a1 = _swig_property(_swigfaiss_gpu.HammingComputer32_a1_get, _swigfaiss_gpu.HammingComputer32_a1_set)
|
|
__swig_setmethods__["a2"] = _swigfaiss_gpu.HammingComputer32_a2_set
|
|
__swig_getmethods__["a2"] = _swigfaiss_gpu.HammingComputer32_a2_get
|
|
if _newclass:a2 = _swig_property(_swigfaiss_gpu.HammingComputer32_a2_get, _swigfaiss_gpu.HammingComputer32_a2_set)
|
|
__swig_setmethods__["a3"] = _swigfaiss_gpu.HammingComputer32_a3_set
|
|
__swig_getmethods__["a3"] = _swigfaiss_gpu.HammingComputer32_a3_get
|
|
if _newclass:a3 = _swig_property(_swigfaiss_gpu.HammingComputer32_a3_get, _swigfaiss_gpu.HammingComputer32_a3_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_HammingComputer32(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.HammingComputer32_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_HammingComputer32
|
|
__del__ = lambda self : None;
|
|
HammingComputer32_swigregister = _swigfaiss_gpu.HammingComputer32_swigregister
|
|
HammingComputer32_swigregister(HammingComputer32)
|
|
|
|
class HammingComputer64(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HammingComputer64, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HammingComputer64, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a0"] = _swigfaiss_gpu.HammingComputer64_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss_gpu.HammingComputer64_a0_get
|
|
if _newclass:a0 = _swig_property(_swigfaiss_gpu.HammingComputer64_a0_get, _swigfaiss_gpu.HammingComputer64_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss_gpu.HammingComputer64_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss_gpu.HammingComputer64_a1_get
|
|
if _newclass:a1 = _swig_property(_swigfaiss_gpu.HammingComputer64_a1_get, _swigfaiss_gpu.HammingComputer64_a1_set)
|
|
__swig_setmethods__["a2"] = _swigfaiss_gpu.HammingComputer64_a2_set
|
|
__swig_getmethods__["a2"] = _swigfaiss_gpu.HammingComputer64_a2_get
|
|
if _newclass:a2 = _swig_property(_swigfaiss_gpu.HammingComputer64_a2_get, _swigfaiss_gpu.HammingComputer64_a2_set)
|
|
__swig_setmethods__["a3"] = _swigfaiss_gpu.HammingComputer64_a3_set
|
|
__swig_getmethods__["a3"] = _swigfaiss_gpu.HammingComputer64_a3_get
|
|
if _newclass:a3 = _swig_property(_swigfaiss_gpu.HammingComputer64_a3_get, _swigfaiss_gpu.HammingComputer64_a3_set)
|
|
__swig_setmethods__["a4"] = _swigfaiss_gpu.HammingComputer64_a4_set
|
|
__swig_getmethods__["a4"] = _swigfaiss_gpu.HammingComputer64_a4_get
|
|
if _newclass:a4 = _swig_property(_swigfaiss_gpu.HammingComputer64_a4_get, _swigfaiss_gpu.HammingComputer64_a4_set)
|
|
__swig_setmethods__["a5"] = _swigfaiss_gpu.HammingComputer64_a5_set
|
|
__swig_getmethods__["a5"] = _swigfaiss_gpu.HammingComputer64_a5_get
|
|
if _newclass:a5 = _swig_property(_swigfaiss_gpu.HammingComputer64_a5_get, _swigfaiss_gpu.HammingComputer64_a5_set)
|
|
__swig_setmethods__["a6"] = _swigfaiss_gpu.HammingComputer64_a6_set
|
|
__swig_getmethods__["a6"] = _swigfaiss_gpu.HammingComputer64_a6_get
|
|
if _newclass:a6 = _swig_property(_swigfaiss_gpu.HammingComputer64_a6_get, _swigfaiss_gpu.HammingComputer64_a6_set)
|
|
__swig_setmethods__["a7"] = _swigfaiss_gpu.HammingComputer64_a7_set
|
|
__swig_getmethods__["a7"] = _swigfaiss_gpu.HammingComputer64_a7_get
|
|
if _newclass:a7 = _swig_property(_swigfaiss_gpu.HammingComputer64_a7_get, _swigfaiss_gpu.HammingComputer64_a7_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_HammingComputer64(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.HammingComputer64_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_HammingComputer64
|
|
__del__ = lambda self : None;
|
|
HammingComputer64_swigregister = _swigfaiss_gpu.HammingComputer64_swigregister
|
|
HammingComputer64_swigregister(HammingComputer64)
|
|
|
|
class HammingComputerDefault(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HammingComputerDefault, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HammingComputerDefault, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a"] = _swigfaiss_gpu.HammingComputerDefault_a_set
|
|
__swig_getmethods__["a"] = _swigfaiss_gpu.HammingComputerDefault_a_get
|
|
if _newclass:a = _swig_property(_swigfaiss_gpu.HammingComputerDefault_a_get, _swigfaiss_gpu.HammingComputerDefault_a_set)
|
|
__swig_setmethods__["n"] = _swigfaiss_gpu.HammingComputerDefault_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss_gpu.HammingComputerDefault_n_get
|
|
if _newclass:n = _swig_property(_swigfaiss_gpu.HammingComputerDefault_n_get, _swigfaiss_gpu.HammingComputerDefault_n_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_HammingComputerDefault(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.HammingComputerDefault_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_HammingComputerDefault
|
|
__del__ = lambda self : None;
|
|
HammingComputerDefault_swigregister = _swigfaiss_gpu.HammingComputerDefault_swigregister
|
|
HammingComputerDefault_swigregister(HammingComputerDefault)
|
|
|
|
class HammingComputerM8(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HammingComputerM8, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HammingComputerM8, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a"] = _swigfaiss_gpu.HammingComputerM8_a_set
|
|
__swig_getmethods__["a"] = _swigfaiss_gpu.HammingComputerM8_a_get
|
|
if _newclass:a = _swig_property(_swigfaiss_gpu.HammingComputerM8_a_get, _swigfaiss_gpu.HammingComputerM8_a_set)
|
|
__swig_setmethods__["n"] = _swigfaiss_gpu.HammingComputerM8_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss_gpu.HammingComputerM8_n_get
|
|
if _newclass:n = _swig_property(_swigfaiss_gpu.HammingComputerM8_n_get, _swigfaiss_gpu.HammingComputerM8_n_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_HammingComputerM8(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.HammingComputerM8_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_HammingComputerM8
|
|
__del__ = lambda self : None;
|
|
HammingComputerM8_swigregister = _swigfaiss_gpu.HammingComputerM8_swigregister
|
|
HammingComputerM8_swigregister(HammingComputerM8)
|
|
|
|
class HammingComputerM4(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HammingComputerM4, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HammingComputerM4, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a"] = _swigfaiss_gpu.HammingComputerM4_a_set
|
|
__swig_getmethods__["a"] = _swigfaiss_gpu.HammingComputerM4_a_get
|
|
if _newclass:a = _swig_property(_swigfaiss_gpu.HammingComputerM4_a_get, _swigfaiss_gpu.HammingComputerM4_a_set)
|
|
__swig_setmethods__["n"] = _swigfaiss_gpu.HammingComputerM4_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss_gpu.HammingComputerM4_n_get
|
|
if _newclass:n = _swig_property(_swigfaiss_gpu.HammingComputerM4_n_get, _swigfaiss_gpu.HammingComputerM4_n_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_HammingComputerM4(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.HammingComputerM4_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_HammingComputerM4
|
|
__del__ = lambda self : None;
|
|
HammingComputerM4_swigregister = _swigfaiss_gpu.HammingComputerM4_swigregister
|
|
HammingComputerM4_swigregister(HammingComputerM4)
|
|
|
|
|
|
def generalized_hamming_64(*args):
|
|
return _swigfaiss_gpu.generalized_hamming_64(*args)
|
|
generalized_hamming_64 = _swigfaiss_gpu.generalized_hamming_64
|
|
class GenHammingComputer8(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GenHammingComputer8, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GenHammingComputer8, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a0"] = _swigfaiss_gpu.GenHammingComputer8_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss_gpu.GenHammingComputer8_a0_get
|
|
if _newclass:a0 = _swig_property(_swigfaiss_gpu.GenHammingComputer8_a0_get, _swigfaiss_gpu.GenHammingComputer8_a0_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_GenHammingComputer8(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.GenHammingComputer8_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GenHammingComputer8
|
|
__del__ = lambda self : None;
|
|
GenHammingComputer8_swigregister = _swigfaiss_gpu.GenHammingComputer8_swigregister
|
|
GenHammingComputer8_swigregister(GenHammingComputer8)
|
|
|
|
class GenHammingComputer16(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GenHammingComputer16, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GenHammingComputer16, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a0"] = _swigfaiss_gpu.GenHammingComputer16_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss_gpu.GenHammingComputer16_a0_get
|
|
if _newclass:a0 = _swig_property(_swigfaiss_gpu.GenHammingComputer16_a0_get, _swigfaiss_gpu.GenHammingComputer16_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss_gpu.GenHammingComputer16_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss_gpu.GenHammingComputer16_a1_get
|
|
if _newclass:a1 = _swig_property(_swigfaiss_gpu.GenHammingComputer16_a1_get, _swigfaiss_gpu.GenHammingComputer16_a1_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_GenHammingComputer16(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.GenHammingComputer16_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GenHammingComputer16
|
|
__del__ = lambda self : None;
|
|
GenHammingComputer16_swigregister = _swigfaiss_gpu.GenHammingComputer16_swigregister
|
|
GenHammingComputer16_swigregister(GenHammingComputer16)
|
|
|
|
class GenHammingComputer32(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GenHammingComputer32, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GenHammingComputer32, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a0"] = _swigfaiss_gpu.GenHammingComputer32_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss_gpu.GenHammingComputer32_a0_get
|
|
if _newclass:a0 = _swig_property(_swigfaiss_gpu.GenHammingComputer32_a0_get, _swigfaiss_gpu.GenHammingComputer32_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss_gpu.GenHammingComputer32_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss_gpu.GenHammingComputer32_a1_get
|
|
if _newclass:a1 = _swig_property(_swigfaiss_gpu.GenHammingComputer32_a1_get, _swigfaiss_gpu.GenHammingComputer32_a1_set)
|
|
__swig_setmethods__["a2"] = _swigfaiss_gpu.GenHammingComputer32_a2_set
|
|
__swig_getmethods__["a2"] = _swigfaiss_gpu.GenHammingComputer32_a2_get
|
|
if _newclass:a2 = _swig_property(_swigfaiss_gpu.GenHammingComputer32_a2_get, _swigfaiss_gpu.GenHammingComputer32_a2_set)
|
|
__swig_setmethods__["a3"] = _swigfaiss_gpu.GenHammingComputer32_a3_set
|
|
__swig_getmethods__["a3"] = _swigfaiss_gpu.GenHammingComputer32_a3_get
|
|
if _newclass:a3 = _swig_property(_swigfaiss_gpu.GenHammingComputer32_a3_get, _swigfaiss_gpu.GenHammingComputer32_a3_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_GenHammingComputer32(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.GenHammingComputer32_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GenHammingComputer32
|
|
__del__ = lambda self : None;
|
|
GenHammingComputer32_swigregister = _swigfaiss_gpu.GenHammingComputer32_swigregister
|
|
GenHammingComputer32_swigregister(GenHammingComputer32)
|
|
|
|
class GenHammingComputerM8(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GenHammingComputerM8, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GenHammingComputerM8, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["a"] = _swigfaiss_gpu.GenHammingComputerM8_a_set
|
|
__swig_getmethods__["a"] = _swigfaiss_gpu.GenHammingComputerM8_a_get
|
|
if _newclass:a = _swig_property(_swigfaiss_gpu.GenHammingComputerM8_a_get, _swigfaiss_gpu.GenHammingComputerM8_a_set)
|
|
__swig_setmethods__["n"] = _swigfaiss_gpu.GenHammingComputerM8_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss_gpu.GenHammingComputerM8_n_get
|
|
if _newclass:n = _swig_property(_swigfaiss_gpu.GenHammingComputerM8_n_get, _swigfaiss_gpu.GenHammingComputerM8_n_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_GenHammingComputerM8(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def hamming(self, *args): return _swigfaiss_gpu.GenHammingComputerM8_hamming(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GenHammingComputerM8
|
|
__del__ = lambda self : None;
|
|
GenHammingComputerM8_swigregister = _swigfaiss_gpu.GenHammingComputerM8_swigregister
|
|
GenHammingComputerM8_swigregister(GenHammingComputerM8)
|
|
|
|
|
|
def generalized_hammings_knn(*args):
|
|
return _swigfaiss_gpu.generalized_hammings_knn(*args)
|
|
generalized_hammings_knn = _swigfaiss_gpu.generalized_hammings_knn
|
|
|
|
def get_num_gpus():
|
|
return _swigfaiss_gpu.get_num_gpus()
|
|
get_num_gpus = _swigfaiss_gpu.get_num_gpus
|
|
class GpuResources(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuResources, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuResources, name)
|
|
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuResources
|
|
__del__ = lambda self : None;
|
|
def initializeForDevice(self, *args): return _swigfaiss_gpu.GpuResources_initializeForDevice(self, *args)
|
|
def getBlasHandle(self, *args): return _swigfaiss_gpu.GpuResources_getBlasHandle(self, *args)
|
|
def getDefaultStream(self, *args): return _swigfaiss_gpu.GpuResources_getDefaultStream(self, *args)
|
|
def getAlternateStreams(self, *args): return _swigfaiss_gpu.GpuResources_getAlternateStreams(self, *args)
|
|
def getPinnedMemory(self): return _swigfaiss_gpu.GpuResources_getPinnedMemory(self)
|
|
def getAsyncCopyStream(self, *args): return _swigfaiss_gpu.GpuResources_getAsyncCopyStream(self, *args)
|
|
def getBlasHandleCurrentDevice(self): return _swigfaiss_gpu.GpuResources_getBlasHandleCurrentDevice(self)
|
|
def getDefaultStreamCurrentDevice(self): return _swigfaiss_gpu.GpuResources_getDefaultStreamCurrentDevice(self)
|
|
def syncDefaultStream(self, *args): return _swigfaiss_gpu.GpuResources_syncDefaultStream(self, *args)
|
|
def syncDefaultStreamCurrentDevice(self): return _swigfaiss_gpu.GpuResources_syncDefaultStreamCurrentDevice(self)
|
|
def getAlternateStreamsCurrentDevice(self): return _swigfaiss_gpu.GpuResources_getAlternateStreamsCurrentDevice(self)
|
|
def getAsyncCopyStreamCurrentDevice(self): return _swigfaiss_gpu.GpuResources_getAsyncCopyStreamCurrentDevice(self)
|
|
GpuResources_swigregister = _swigfaiss_gpu.GpuResources_swigregister
|
|
GpuResources_swigregister(GpuResources)
|
|
|
|
class StandardGpuResources(GpuResources):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuResources]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, StandardGpuResources, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuResources]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, StandardGpuResources, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_StandardGpuResources()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_StandardGpuResources
|
|
__del__ = lambda self : None;
|
|
def noTempMemory(self): return _swigfaiss_gpu.StandardGpuResources_noTempMemory(self)
|
|
def setTempMemory(self, *args): return _swigfaiss_gpu.StandardGpuResources_setTempMemory(self, *args)
|
|
def setTempMemoryFraction(self, *args): return _swigfaiss_gpu.StandardGpuResources_setTempMemoryFraction(self, *args)
|
|
def setPinnedMemory(self, *args): return _swigfaiss_gpu.StandardGpuResources_setPinnedMemory(self, *args)
|
|
def setDefaultStream(self, *args): return _swigfaiss_gpu.StandardGpuResources_setDefaultStream(self, *args)
|
|
def setDefaultNullStreamAllDevices(self): return _swigfaiss_gpu.StandardGpuResources_setDefaultNullStreamAllDevices(self)
|
|
def initializeForDevice(self, *args): return _swigfaiss_gpu.StandardGpuResources_initializeForDevice(self, *args)
|
|
def getBlasHandle(self, *args): return _swigfaiss_gpu.StandardGpuResources_getBlasHandle(self, *args)
|
|
def getDefaultStream(self, *args): return _swigfaiss_gpu.StandardGpuResources_getDefaultStream(self, *args)
|
|
def getAlternateStreams(self, *args): return _swigfaiss_gpu.StandardGpuResources_getAlternateStreams(self, *args)
|
|
def getPinnedMemory(self): return _swigfaiss_gpu.StandardGpuResources_getPinnedMemory(self)
|
|
def getAsyncCopyStream(self, *args): return _swigfaiss_gpu.StandardGpuResources_getAsyncCopyStream(self, *args)
|
|
StandardGpuResources_swigregister = _swigfaiss_gpu.StandardGpuResources_swigregister
|
|
StandardGpuResources_swigregister(StandardGpuResources)
|
|
|
|
|
|
def getmillisecs():
|
|
return _swigfaiss_gpu.getmillisecs()
|
|
getmillisecs = _swigfaiss_gpu.getmillisecs
|
|
|
|
def get_mem_usage_kb():
|
|
return _swigfaiss_gpu.get_mem_usage_kb()
|
|
get_mem_usage_kb = _swigfaiss_gpu.get_mem_usage_kb
|
|
class RandomGenerator(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, RandomGenerator, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, RandomGenerator, name)
|
|
__repr__ = _swig_repr
|
|
def rand_long(self): return _swigfaiss_gpu.RandomGenerator_rand_long(self)
|
|
def rand_int(self, *args): return _swigfaiss_gpu.RandomGenerator_rand_int(self, *args)
|
|
def rand_float(self): return _swigfaiss_gpu.RandomGenerator_rand_float(self)
|
|
def rand_double(self): return _swigfaiss_gpu.RandomGenerator_rand_double(self)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_RandomGenerator(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_RandomGenerator
|
|
__del__ = lambda self : None;
|
|
RandomGenerator_swigregister = _swigfaiss_gpu.RandomGenerator_swigregister
|
|
RandomGenerator_swigregister(RandomGenerator)
|
|
|
|
|
|
def float_rand(*args):
|
|
return _swigfaiss_gpu.float_rand(*args)
|
|
float_rand = _swigfaiss_gpu.float_rand
|
|
|
|
def float_randn(*args):
|
|
return _swigfaiss_gpu.float_randn(*args)
|
|
float_randn = _swigfaiss_gpu.float_randn
|
|
|
|
def long_rand(*args):
|
|
return _swigfaiss_gpu.long_rand(*args)
|
|
long_rand = _swigfaiss_gpu.long_rand
|
|
|
|
def byte_rand(*args):
|
|
return _swigfaiss_gpu.byte_rand(*args)
|
|
byte_rand = _swigfaiss_gpu.byte_rand
|
|
|
|
def rand_perm(*args):
|
|
return _swigfaiss_gpu.rand_perm(*args)
|
|
rand_perm = _swigfaiss_gpu.rand_perm
|
|
|
|
def fvec_L2sqr(*args):
|
|
return _swigfaiss_gpu.fvec_L2sqr(*args)
|
|
fvec_L2sqr = _swigfaiss_gpu.fvec_L2sqr
|
|
|
|
def fvec_inner_product(*args):
|
|
return _swigfaiss_gpu.fvec_inner_product(*args)
|
|
fvec_inner_product = _swigfaiss_gpu.fvec_inner_product
|
|
|
|
def imbalance_factor(*args):
|
|
return _swigfaiss_gpu.imbalance_factor(*args)
|
|
imbalance_factor = _swigfaiss_gpu.imbalance_factor
|
|
|
|
def pairwise_L2sqr(*args):
|
|
return _swigfaiss_gpu.pairwise_L2sqr(*args)
|
|
pairwise_L2sqr = _swigfaiss_gpu.pairwise_L2sqr
|
|
|
|
def fvec_inner_products_ny(*args):
|
|
return _swigfaiss_gpu.fvec_inner_products_ny(*args)
|
|
fvec_inner_products_ny = _swigfaiss_gpu.fvec_inner_products_ny
|
|
|
|
def fvec_L2sqr_ny(*args):
|
|
return _swigfaiss_gpu.fvec_L2sqr_ny(*args)
|
|
fvec_L2sqr_ny = _swigfaiss_gpu.fvec_L2sqr_ny
|
|
|
|
def fvec_norm_L2sqr(*args):
|
|
return _swigfaiss_gpu.fvec_norm_L2sqr(*args)
|
|
fvec_norm_L2sqr = _swigfaiss_gpu.fvec_norm_L2sqr
|
|
|
|
def fvec_norms_L2(*args):
|
|
return _swigfaiss_gpu.fvec_norms_L2(*args)
|
|
fvec_norms_L2 = _swigfaiss_gpu.fvec_norms_L2
|
|
|
|
def fvec_norms_L2sqr(*args):
|
|
return _swigfaiss_gpu.fvec_norms_L2sqr(*args)
|
|
fvec_norms_L2sqr = _swigfaiss_gpu.fvec_norms_L2sqr
|
|
|
|
def fvec_renorm_L2(*args):
|
|
return _swigfaiss_gpu.fvec_renorm_L2(*args)
|
|
fvec_renorm_L2 = _swigfaiss_gpu.fvec_renorm_L2
|
|
|
|
def inner_product_to_L2sqr(*args):
|
|
return _swigfaiss_gpu.inner_product_to_L2sqr(*args)
|
|
inner_product_to_L2sqr = _swigfaiss_gpu.inner_product_to_L2sqr
|
|
|
|
def fvec_inner_products_by_idx(*args):
|
|
return _swigfaiss_gpu.fvec_inner_products_by_idx(*args)
|
|
fvec_inner_products_by_idx = _swigfaiss_gpu.fvec_inner_products_by_idx
|
|
|
|
def fvec_L2sqr_by_idx(*args):
|
|
return _swigfaiss_gpu.fvec_L2sqr_by_idx(*args)
|
|
fvec_L2sqr_by_idx = _swigfaiss_gpu.fvec_L2sqr_by_idx
|
|
|
|
def knn_inner_product(*args):
|
|
return _swigfaiss_gpu.knn_inner_product(*args)
|
|
knn_inner_product = _swigfaiss_gpu.knn_inner_product
|
|
|
|
def knn_L2sqr(*args):
|
|
return _swigfaiss_gpu.knn_L2sqr(*args)
|
|
knn_L2sqr = _swigfaiss_gpu.knn_L2sqr
|
|
|
|
def knn_L2sqr_base_shift(*args):
|
|
return _swigfaiss_gpu.knn_L2sqr_base_shift(*args)
|
|
knn_L2sqr_base_shift = _swigfaiss_gpu.knn_L2sqr_base_shift
|
|
|
|
def knn_inner_products_by_idx(*args):
|
|
return _swigfaiss_gpu.knn_inner_products_by_idx(*args)
|
|
knn_inner_products_by_idx = _swigfaiss_gpu.knn_inner_products_by_idx
|
|
|
|
def knn_L2sqr_by_idx(*args):
|
|
return _swigfaiss_gpu.knn_L2sqr_by_idx(*args)
|
|
knn_L2sqr_by_idx = _swigfaiss_gpu.knn_L2sqr_by_idx
|
|
|
|
def range_search_L2sqr(*args):
|
|
return _swigfaiss_gpu.range_search_L2sqr(*args)
|
|
range_search_L2sqr = _swigfaiss_gpu.range_search_L2sqr
|
|
|
|
def range_search_inner_product(*args):
|
|
return _swigfaiss_gpu.range_search_inner_product(*args)
|
|
range_search_inner_product = _swigfaiss_gpu.range_search_inner_product
|
|
|
|
def fvec_madd(*args):
|
|
return _swigfaiss_gpu.fvec_madd(*args)
|
|
fvec_madd = _swigfaiss_gpu.fvec_madd
|
|
|
|
def fvec_madd_and_argmin(*args):
|
|
return _swigfaiss_gpu.fvec_madd_and_argmin(*args)
|
|
fvec_madd_and_argmin = _swigfaiss_gpu.fvec_madd_and_argmin
|
|
|
|
def reflection(*args):
|
|
return _swigfaiss_gpu.reflection(*args)
|
|
reflection = _swigfaiss_gpu.reflection
|
|
|
|
def km_update_centroids(*args):
|
|
return _swigfaiss_gpu.km_update_centroids(*args)
|
|
km_update_centroids = _swigfaiss_gpu.km_update_centroids
|
|
|
|
def matrix_qr(*args):
|
|
return _swigfaiss_gpu.matrix_qr(*args)
|
|
matrix_qr = _swigfaiss_gpu.matrix_qr
|
|
|
|
def ranklist_handle_ties(*args):
|
|
return _swigfaiss_gpu.ranklist_handle_ties(*args)
|
|
ranklist_handle_ties = _swigfaiss_gpu.ranklist_handle_ties
|
|
|
|
def ranklist_intersection_size(*args):
|
|
return _swigfaiss_gpu.ranklist_intersection_size(*args)
|
|
ranklist_intersection_size = _swigfaiss_gpu.ranklist_intersection_size
|
|
|
|
def merge_result_table_with(*args):
|
|
return _swigfaiss_gpu.merge_result_table_with(*args)
|
|
merge_result_table_with = _swigfaiss_gpu.merge_result_table_with
|
|
|
|
def fvec_argsort(*args):
|
|
return _swigfaiss_gpu.fvec_argsort(*args)
|
|
fvec_argsort = _swigfaiss_gpu.fvec_argsort
|
|
|
|
def fvec_argsort_parallel(*args):
|
|
return _swigfaiss_gpu.fvec_argsort_parallel(*args)
|
|
fvec_argsort_parallel = _swigfaiss_gpu.fvec_argsort_parallel
|
|
|
|
def ivec_hist(*args):
|
|
return _swigfaiss_gpu.ivec_hist(*args)
|
|
ivec_hist = _swigfaiss_gpu.ivec_hist
|
|
|
|
def bincode_hist(*args):
|
|
return _swigfaiss_gpu.bincode_hist(*args)
|
|
bincode_hist = _swigfaiss_gpu.bincode_hist
|
|
|
|
def ivec_checksum(*args):
|
|
return _swigfaiss_gpu.ivec_checksum(*args)
|
|
ivec_checksum = _swigfaiss_gpu.ivec_checksum
|
|
|
|
def fvecs_maybe_subsample(*args):
|
|
return _swigfaiss_gpu.fvecs_maybe_subsample(*args)
|
|
fvecs_maybe_subsample = _swigfaiss_gpu.fvecs_maybe_subsample
|
|
METRIC_INNER_PRODUCT = _swigfaiss_gpu.METRIC_INNER_PRODUCT
|
|
METRIC_L2 = _swigfaiss_gpu.METRIC_L2
|
|
class Index(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Index, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Index, name)
|
|
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["d"] = _swigfaiss_gpu.Index_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss_gpu.Index_d_get
|
|
if _newclass:d = _swig_property(_swigfaiss_gpu.Index_d_get, _swigfaiss_gpu.Index_d_set)
|
|
__swig_setmethods__["ntotal"] = _swigfaiss_gpu.Index_ntotal_set
|
|
__swig_getmethods__["ntotal"] = _swigfaiss_gpu.Index_ntotal_get
|
|
if _newclass:ntotal = _swig_property(_swigfaiss_gpu.Index_ntotal_get, _swigfaiss_gpu.Index_ntotal_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss_gpu.Index_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss_gpu.Index_verbose_get
|
|
if _newclass:verbose = _swig_property(_swigfaiss_gpu.Index_verbose_get, _swigfaiss_gpu.Index_verbose_set)
|
|
__swig_setmethods__["is_trained"] = _swigfaiss_gpu.Index_is_trained_set
|
|
__swig_getmethods__["is_trained"] = _swigfaiss_gpu.Index_is_trained_get
|
|
if _newclass:is_trained = _swig_property(_swigfaiss_gpu.Index_is_trained_get, _swigfaiss_gpu.Index_is_trained_set)
|
|
__swig_setmethods__["metric_type"] = _swigfaiss_gpu.Index_metric_type_set
|
|
__swig_getmethods__["metric_type"] = _swigfaiss_gpu.Index_metric_type_get
|
|
if _newclass:metric_type = _swig_property(_swigfaiss_gpu.Index_metric_type_get, _swigfaiss_gpu.Index_metric_type_set)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_Index
|
|
__del__ = lambda self : None;
|
|
def train(self, *args): return _swigfaiss_gpu.Index_train(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.Index_add(self, *args)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.Index_add_with_ids(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.Index_search(self, *args)
|
|
def range_search(self, *args): return _swigfaiss_gpu.Index_range_search(self, *args)
|
|
def assign(self, *args): return _swigfaiss_gpu.Index_assign(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.Index_reset(self)
|
|
def remove_ids(self, *args): return _swigfaiss_gpu.Index_remove_ids(self, *args)
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.Index_reconstruct(self, *args)
|
|
def reconstruct_n(self, *args): return _swigfaiss_gpu.Index_reconstruct_n(self, *args)
|
|
def compute_residual(self, *args): return _swigfaiss_gpu.Index_compute_residual(self, *args)
|
|
def display(self): return _swigfaiss_gpu.Index_display(self)
|
|
Index_swigregister = _swigfaiss_gpu.Index_swigregister
|
|
Index_swigregister(Index)
|
|
|
|
class ClusteringParameters(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ClusteringParameters, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ClusteringParameters, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["niter"] = _swigfaiss_gpu.ClusteringParameters_niter_set
|
|
__swig_getmethods__["niter"] = _swigfaiss_gpu.ClusteringParameters_niter_get
|
|
if _newclass:niter = _swig_property(_swigfaiss_gpu.ClusteringParameters_niter_get, _swigfaiss_gpu.ClusteringParameters_niter_set)
|
|
__swig_setmethods__["nredo"] = _swigfaiss_gpu.ClusteringParameters_nredo_set
|
|
__swig_getmethods__["nredo"] = _swigfaiss_gpu.ClusteringParameters_nredo_get
|
|
if _newclass:nredo = _swig_property(_swigfaiss_gpu.ClusteringParameters_nredo_get, _swigfaiss_gpu.ClusteringParameters_nredo_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss_gpu.ClusteringParameters_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss_gpu.ClusteringParameters_verbose_get
|
|
if _newclass:verbose = _swig_property(_swigfaiss_gpu.ClusteringParameters_verbose_get, _swigfaiss_gpu.ClusteringParameters_verbose_set)
|
|
__swig_setmethods__["spherical"] = _swigfaiss_gpu.ClusteringParameters_spherical_set
|
|
__swig_getmethods__["spherical"] = _swigfaiss_gpu.ClusteringParameters_spherical_get
|
|
if _newclass:spherical = _swig_property(_swigfaiss_gpu.ClusteringParameters_spherical_get, _swigfaiss_gpu.ClusteringParameters_spherical_set)
|
|
__swig_setmethods__["update_index"] = _swigfaiss_gpu.ClusteringParameters_update_index_set
|
|
__swig_getmethods__["update_index"] = _swigfaiss_gpu.ClusteringParameters_update_index_get
|
|
if _newclass:update_index = _swig_property(_swigfaiss_gpu.ClusteringParameters_update_index_get, _swigfaiss_gpu.ClusteringParameters_update_index_set)
|
|
__swig_setmethods__["frozen_centroids"] = _swigfaiss_gpu.ClusteringParameters_frozen_centroids_set
|
|
__swig_getmethods__["frozen_centroids"] = _swigfaiss_gpu.ClusteringParameters_frozen_centroids_get
|
|
if _newclass:frozen_centroids = _swig_property(_swigfaiss_gpu.ClusteringParameters_frozen_centroids_get, _swigfaiss_gpu.ClusteringParameters_frozen_centroids_set)
|
|
__swig_setmethods__["min_points_per_centroid"] = _swigfaiss_gpu.ClusteringParameters_min_points_per_centroid_set
|
|
__swig_getmethods__["min_points_per_centroid"] = _swigfaiss_gpu.ClusteringParameters_min_points_per_centroid_get
|
|
if _newclass:min_points_per_centroid = _swig_property(_swigfaiss_gpu.ClusteringParameters_min_points_per_centroid_get, _swigfaiss_gpu.ClusteringParameters_min_points_per_centroid_set)
|
|
__swig_setmethods__["max_points_per_centroid"] = _swigfaiss_gpu.ClusteringParameters_max_points_per_centroid_set
|
|
__swig_getmethods__["max_points_per_centroid"] = _swigfaiss_gpu.ClusteringParameters_max_points_per_centroid_get
|
|
if _newclass:max_points_per_centroid = _swig_property(_swigfaiss_gpu.ClusteringParameters_max_points_per_centroid_get, _swigfaiss_gpu.ClusteringParameters_max_points_per_centroid_set)
|
|
__swig_setmethods__["seed"] = _swigfaiss_gpu.ClusteringParameters_seed_set
|
|
__swig_getmethods__["seed"] = _swigfaiss_gpu.ClusteringParameters_seed_get
|
|
if _newclass:seed = _swig_property(_swigfaiss_gpu.ClusteringParameters_seed_get, _swigfaiss_gpu.ClusteringParameters_seed_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_ClusteringParameters()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_ClusteringParameters
|
|
__del__ = lambda self : None;
|
|
ClusteringParameters_swigregister = _swigfaiss_gpu.ClusteringParameters_swigregister
|
|
ClusteringParameters_swigregister(ClusteringParameters)
|
|
|
|
class Clustering(ClusteringParameters):
|
|
__swig_setmethods__ = {}
|
|
for _s in [ClusteringParameters]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Clustering, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [ClusteringParameters]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Clustering, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["d"] = _swigfaiss_gpu.Clustering_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss_gpu.Clustering_d_get
|
|
if _newclass:d = _swig_property(_swigfaiss_gpu.Clustering_d_get, _swigfaiss_gpu.Clustering_d_set)
|
|
__swig_setmethods__["k"] = _swigfaiss_gpu.Clustering_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss_gpu.Clustering_k_get
|
|
if _newclass:k = _swig_property(_swigfaiss_gpu.Clustering_k_get, _swigfaiss_gpu.Clustering_k_set)
|
|
__swig_setmethods__["centroids"] = _swigfaiss_gpu.Clustering_centroids_set
|
|
__swig_getmethods__["centroids"] = _swigfaiss_gpu.Clustering_centroids_get
|
|
if _newclass:centroids = _swig_property(_swigfaiss_gpu.Clustering_centroids_get, _swigfaiss_gpu.Clustering_centroids_set)
|
|
__swig_setmethods__["obj"] = _swigfaiss_gpu.Clustering_obj_set
|
|
__swig_getmethods__["obj"] = _swigfaiss_gpu.Clustering_obj_get
|
|
if _newclass:obj = _swig_property(_swigfaiss_gpu.Clustering_obj_get, _swigfaiss_gpu.Clustering_obj_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_Clustering(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def train(self, *args): return _swigfaiss_gpu.Clustering_train(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_Clustering
|
|
__del__ = lambda self : None;
|
|
Clustering_swigregister = _swigfaiss_gpu.Clustering_swigregister
|
|
Clustering_swigregister(Clustering)
|
|
|
|
|
|
def kmeans_clustering(*args):
|
|
return _swigfaiss_gpu.kmeans_clustering(*args)
|
|
kmeans_clustering = _swigfaiss_gpu.kmeans_clustering
|
|
class ProductQuantizer(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ProductQuantizer, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ProductQuantizer, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["d"] = _swigfaiss_gpu.ProductQuantizer_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss_gpu.ProductQuantizer_d_get
|
|
if _newclass:d = _swig_property(_swigfaiss_gpu.ProductQuantizer_d_get, _swigfaiss_gpu.ProductQuantizer_d_set)
|
|
__swig_setmethods__["M"] = _swigfaiss_gpu.ProductQuantizer_M_set
|
|
__swig_getmethods__["M"] = _swigfaiss_gpu.ProductQuantizer_M_get
|
|
if _newclass:M = _swig_property(_swigfaiss_gpu.ProductQuantizer_M_get, _swigfaiss_gpu.ProductQuantizer_M_set)
|
|
__swig_setmethods__["nbits"] = _swigfaiss_gpu.ProductQuantizer_nbits_set
|
|
__swig_getmethods__["nbits"] = _swigfaiss_gpu.ProductQuantizer_nbits_get
|
|
if _newclass:nbits = _swig_property(_swigfaiss_gpu.ProductQuantizer_nbits_get, _swigfaiss_gpu.ProductQuantizer_nbits_set)
|
|
__swig_setmethods__["dsub"] = _swigfaiss_gpu.ProductQuantizer_dsub_set
|
|
__swig_getmethods__["dsub"] = _swigfaiss_gpu.ProductQuantizer_dsub_get
|
|
if _newclass:dsub = _swig_property(_swigfaiss_gpu.ProductQuantizer_dsub_get, _swigfaiss_gpu.ProductQuantizer_dsub_set)
|
|
__swig_setmethods__["byte_per_idx"] = _swigfaiss_gpu.ProductQuantizer_byte_per_idx_set
|
|
__swig_getmethods__["byte_per_idx"] = _swigfaiss_gpu.ProductQuantizer_byte_per_idx_get
|
|
if _newclass:byte_per_idx = _swig_property(_swigfaiss_gpu.ProductQuantizer_byte_per_idx_get, _swigfaiss_gpu.ProductQuantizer_byte_per_idx_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss_gpu.ProductQuantizer_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss_gpu.ProductQuantizer_code_size_get
|
|
if _newclass:code_size = _swig_property(_swigfaiss_gpu.ProductQuantizer_code_size_get, _swigfaiss_gpu.ProductQuantizer_code_size_set)
|
|
__swig_setmethods__["ksub"] = _swigfaiss_gpu.ProductQuantizer_ksub_set
|
|
__swig_getmethods__["ksub"] = _swigfaiss_gpu.ProductQuantizer_ksub_get
|
|
if _newclass:ksub = _swig_property(_swigfaiss_gpu.ProductQuantizer_ksub_get, _swigfaiss_gpu.ProductQuantizer_ksub_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss_gpu.ProductQuantizer_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss_gpu.ProductQuantizer_verbose_get
|
|
if _newclass:verbose = _swig_property(_swigfaiss_gpu.ProductQuantizer_verbose_get, _swigfaiss_gpu.ProductQuantizer_verbose_set)
|
|
Train_default = _swigfaiss_gpu.ProductQuantizer_Train_default
|
|
Train_hot_start = _swigfaiss_gpu.ProductQuantizer_Train_hot_start
|
|
Train_shared = _swigfaiss_gpu.ProductQuantizer_Train_shared
|
|
Train_hypercube = _swigfaiss_gpu.ProductQuantizer_Train_hypercube
|
|
Train_hypercube_pca = _swigfaiss_gpu.ProductQuantizer_Train_hypercube_pca
|
|
__swig_setmethods__["train_type"] = _swigfaiss_gpu.ProductQuantizer_train_type_set
|
|
__swig_getmethods__["train_type"] = _swigfaiss_gpu.ProductQuantizer_train_type_get
|
|
if _newclass:train_type = _swig_property(_swigfaiss_gpu.ProductQuantizer_train_type_get, _swigfaiss_gpu.ProductQuantizer_train_type_set)
|
|
__swig_setmethods__["cp"] = _swigfaiss_gpu.ProductQuantizer_cp_set
|
|
__swig_getmethods__["cp"] = _swigfaiss_gpu.ProductQuantizer_cp_get
|
|
if _newclass:cp = _swig_property(_swigfaiss_gpu.ProductQuantizer_cp_get, _swigfaiss_gpu.ProductQuantizer_cp_set)
|
|
__swig_setmethods__["centroids"] = _swigfaiss_gpu.ProductQuantizer_centroids_set
|
|
__swig_getmethods__["centroids"] = _swigfaiss_gpu.ProductQuantizer_centroids_get
|
|
if _newclass:centroids = _swig_property(_swigfaiss_gpu.ProductQuantizer_centroids_get, _swigfaiss_gpu.ProductQuantizer_centroids_set)
|
|
def get_centroids(self, *args): return _swigfaiss_gpu.ProductQuantizer_get_centroids(self, *args)
|
|
def train(self, *args): return _swigfaiss_gpu.ProductQuantizer_train(self, *args)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_ProductQuantizer(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def set_derived_values(self): return _swigfaiss_gpu.ProductQuantizer_set_derived_values(self)
|
|
def set_params(self, *args): return _swigfaiss_gpu.ProductQuantizer_set_params(self, *args)
|
|
def compute_code(self, *args): return _swigfaiss_gpu.ProductQuantizer_compute_code(self, *args)
|
|
def compute_codes(self, *args): return _swigfaiss_gpu.ProductQuantizer_compute_codes(self, *args)
|
|
def decode(self, *args): return _swigfaiss_gpu.ProductQuantizer_decode(self, *args)
|
|
def compute_code_from_distance_table(self, *args): return _swigfaiss_gpu.ProductQuantizer_compute_code_from_distance_table(self, *args)
|
|
def compute_distance_table(self, *args): return _swigfaiss_gpu.ProductQuantizer_compute_distance_table(self, *args)
|
|
def compute_inner_prod_table(self, *args): return _swigfaiss_gpu.ProductQuantizer_compute_inner_prod_table(self, *args)
|
|
def compute_distance_tables(self, *args): return _swigfaiss_gpu.ProductQuantizer_compute_distance_tables(self, *args)
|
|
def compute_inner_prod_tables(self, *args): return _swigfaiss_gpu.ProductQuantizer_compute_inner_prod_tables(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.ProductQuantizer_search(self, *args)
|
|
def search_ip(self, *args): return _swigfaiss_gpu.ProductQuantizer_search_ip(self, *args)
|
|
__swig_setmethods__["sdc_table"] = _swigfaiss_gpu.ProductQuantizer_sdc_table_set
|
|
__swig_getmethods__["sdc_table"] = _swigfaiss_gpu.ProductQuantizer_sdc_table_get
|
|
if _newclass:sdc_table = _swig_property(_swigfaiss_gpu.ProductQuantizer_sdc_table_get, _swigfaiss_gpu.ProductQuantizer_sdc_table_set)
|
|
def compute_sdc_table(self): return _swigfaiss_gpu.ProductQuantizer_compute_sdc_table(self)
|
|
def search_sdc(self, *args): return _swigfaiss_gpu.ProductQuantizer_search_sdc(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_ProductQuantizer
|
|
__del__ = lambda self : None;
|
|
ProductQuantizer_swigregister = _swigfaiss_gpu.ProductQuantizer_swigregister
|
|
ProductQuantizer_swigregister(ProductQuantizer)
|
|
|
|
class VectorTransform(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, VectorTransform, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, VectorTransform, name)
|
|
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["d_in"] = _swigfaiss_gpu.VectorTransform_d_in_set
|
|
__swig_getmethods__["d_in"] = _swigfaiss_gpu.VectorTransform_d_in_get
|
|
if _newclass:d_in = _swig_property(_swigfaiss_gpu.VectorTransform_d_in_get, _swigfaiss_gpu.VectorTransform_d_in_set)
|
|
__swig_setmethods__["d_out"] = _swigfaiss_gpu.VectorTransform_d_out_set
|
|
__swig_getmethods__["d_out"] = _swigfaiss_gpu.VectorTransform_d_out_get
|
|
if _newclass:d_out = _swig_property(_swigfaiss_gpu.VectorTransform_d_out_get, _swigfaiss_gpu.VectorTransform_d_out_set)
|
|
__swig_setmethods__["is_trained"] = _swigfaiss_gpu.VectorTransform_is_trained_set
|
|
__swig_getmethods__["is_trained"] = _swigfaiss_gpu.VectorTransform_is_trained_get
|
|
if _newclass:is_trained = _swig_property(_swigfaiss_gpu.VectorTransform_is_trained_get, _swigfaiss_gpu.VectorTransform_is_trained_set)
|
|
def train(self, *args): return _swigfaiss_gpu.VectorTransform_train(self, *args)
|
|
def apply(self, *args): return _swigfaiss_gpu.VectorTransform_apply(self, *args)
|
|
def apply_noalloc(self, *args): return _swigfaiss_gpu.VectorTransform_apply_noalloc(self, *args)
|
|
def reverse_transform(self, *args): return _swigfaiss_gpu.VectorTransform_reverse_transform(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_VectorTransform
|
|
__del__ = lambda self : None;
|
|
VectorTransform_swigregister = _swigfaiss_gpu.VectorTransform_swigregister
|
|
VectorTransform_swigregister(VectorTransform)
|
|
|
|
class LinearTransform(VectorTransform):
|
|
__swig_setmethods__ = {}
|
|
for _s in [VectorTransform]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, LinearTransform, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [VectorTransform]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, LinearTransform, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["have_bias"] = _swigfaiss_gpu.LinearTransform_have_bias_set
|
|
__swig_getmethods__["have_bias"] = _swigfaiss_gpu.LinearTransform_have_bias_get
|
|
if _newclass:have_bias = _swig_property(_swigfaiss_gpu.LinearTransform_have_bias_get, _swigfaiss_gpu.LinearTransform_have_bias_set)
|
|
__swig_setmethods__["A"] = _swigfaiss_gpu.LinearTransform_A_set
|
|
__swig_getmethods__["A"] = _swigfaiss_gpu.LinearTransform_A_get
|
|
if _newclass:A = _swig_property(_swigfaiss_gpu.LinearTransform_A_get, _swigfaiss_gpu.LinearTransform_A_set)
|
|
__swig_setmethods__["b"] = _swigfaiss_gpu.LinearTransform_b_set
|
|
__swig_getmethods__["b"] = _swigfaiss_gpu.LinearTransform_b_get
|
|
if _newclass:b = _swig_property(_swigfaiss_gpu.LinearTransform_b_get, _swigfaiss_gpu.LinearTransform_b_set)
|
|
def __init__(self, d_in=0, d_out=0, have_bias=False):
|
|
this = _swigfaiss_gpu.new_LinearTransform(d_in, d_out, have_bias)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def apply_noalloc(self, *args): return _swigfaiss_gpu.LinearTransform_apply_noalloc(self, *args)
|
|
def transform_transpose(self, *args): return _swigfaiss_gpu.LinearTransform_transform_transpose(self, *args)
|
|
__swig_setmethods__["verbose"] = _swigfaiss_gpu.LinearTransform_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss_gpu.LinearTransform_verbose_get
|
|
if _newclass:verbose = _swig_property(_swigfaiss_gpu.LinearTransform_verbose_get, _swigfaiss_gpu.LinearTransform_verbose_set)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_LinearTransform
|
|
__del__ = lambda self : None;
|
|
LinearTransform_swigregister = _swigfaiss_gpu.LinearTransform_swigregister
|
|
LinearTransform_swigregister(LinearTransform)
|
|
|
|
class RandomRotationMatrix(LinearTransform):
|
|
__swig_setmethods__ = {}
|
|
for _s in [LinearTransform]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, RandomRotationMatrix, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [LinearTransform]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, RandomRotationMatrix, name)
|
|
__repr__ = _swig_repr
|
|
def init(self, *args): return _swigfaiss_gpu.RandomRotationMatrix_init(self, *args)
|
|
def reverse_transform(self, *args): return _swigfaiss_gpu.RandomRotationMatrix_reverse_transform(self, *args)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_RandomRotationMatrix(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_RandomRotationMatrix
|
|
__del__ = lambda self : None;
|
|
RandomRotationMatrix_swigregister = _swigfaiss_gpu.RandomRotationMatrix_swigregister
|
|
RandomRotationMatrix_swigregister(RandomRotationMatrix)
|
|
|
|
class PCAMatrix(LinearTransform):
|
|
__swig_setmethods__ = {}
|
|
for _s in [LinearTransform]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, PCAMatrix, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [LinearTransform]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, PCAMatrix, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["eigen_power"] = _swigfaiss_gpu.PCAMatrix_eigen_power_set
|
|
__swig_getmethods__["eigen_power"] = _swigfaiss_gpu.PCAMatrix_eigen_power_get
|
|
if _newclass:eigen_power = _swig_property(_swigfaiss_gpu.PCAMatrix_eigen_power_get, _swigfaiss_gpu.PCAMatrix_eigen_power_set)
|
|
__swig_setmethods__["random_rotation"] = _swigfaiss_gpu.PCAMatrix_random_rotation_set
|
|
__swig_getmethods__["random_rotation"] = _swigfaiss_gpu.PCAMatrix_random_rotation_get
|
|
if _newclass:random_rotation = _swig_property(_swigfaiss_gpu.PCAMatrix_random_rotation_get, _swigfaiss_gpu.PCAMatrix_random_rotation_set)
|
|
__swig_setmethods__["max_points_per_d"] = _swigfaiss_gpu.PCAMatrix_max_points_per_d_set
|
|
__swig_getmethods__["max_points_per_d"] = _swigfaiss_gpu.PCAMatrix_max_points_per_d_get
|
|
if _newclass:max_points_per_d = _swig_property(_swigfaiss_gpu.PCAMatrix_max_points_per_d_get, _swigfaiss_gpu.PCAMatrix_max_points_per_d_set)
|
|
__swig_setmethods__["balanced_bins"] = _swigfaiss_gpu.PCAMatrix_balanced_bins_set
|
|
__swig_getmethods__["balanced_bins"] = _swigfaiss_gpu.PCAMatrix_balanced_bins_get
|
|
if _newclass:balanced_bins = _swig_property(_swigfaiss_gpu.PCAMatrix_balanced_bins_get, _swigfaiss_gpu.PCAMatrix_balanced_bins_set)
|
|
__swig_setmethods__["mean"] = _swigfaiss_gpu.PCAMatrix_mean_set
|
|
__swig_getmethods__["mean"] = _swigfaiss_gpu.PCAMatrix_mean_get
|
|
if _newclass:mean = _swig_property(_swigfaiss_gpu.PCAMatrix_mean_get, _swigfaiss_gpu.PCAMatrix_mean_set)
|
|
__swig_setmethods__["eigenvalues"] = _swigfaiss_gpu.PCAMatrix_eigenvalues_set
|
|
__swig_getmethods__["eigenvalues"] = _swigfaiss_gpu.PCAMatrix_eigenvalues_get
|
|
if _newclass:eigenvalues = _swig_property(_swigfaiss_gpu.PCAMatrix_eigenvalues_get, _swigfaiss_gpu.PCAMatrix_eigenvalues_set)
|
|
__swig_setmethods__["PCAMat"] = _swigfaiss_gpu.PCAMatrix_PCAMat_set
|
|
__swig_getmethods__["PCAMat"] = _swigfaiss_gpu.PCAMatrix_PCAMat_get
|
|
if _newclass:PCAMat = _swig_property(_swigfaiss_gpu.PCAMatrix_PCAMat_get, _swigfaiss_gpu.PCAMatrix_PCAMat_set)
|
|
def __init__(self, d_in=0, d_out=0, eigen_power=0, random_rotation=False):
|
|
this = _swigfaiss_gpu.new_PCAMatrix(d_in, d_out, eigen_power, random_rotation)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def train(self, *args): return _swigfaiss_gpu.PCAMatrix_train(self, *args)
|
|
def reverse_transform(self, *args): return _swigfaiss_gpu.PCAMatrix_reverse_transform(self, *args)
|
|
def copy_from(self, *args): return _swigfaiss_gpu.PCAMatrix_copy_from(self, *args)
|
|
def prepare_Ab(self): return _swigfaiss_gpu.PCAMatrix_prepare_Ab(self)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_PCAMatrix
|
|
__del__ = lambda self : None;
|
|
PCAMatrix_swigregister = _swigfaiss_gpu.PCAMatrix_swigregister
|
|
PCAMatrix_swigregister(PCAMatrix)
|
|
|
|
class OPQMatrix(LinearTransform):
|
|
__swig_setmethods__ = {}
|
|
for _s in [LinearTransform]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, OPQMatrix, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [LinearTransform]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, OPQMatrix, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["M"] = _swigfaiss_gpu.OPQMatrix_M_set
|
|
__swig_getmethods__["M"] = _swigfaiss_gpu.OPQMatrix_M_get
|
|
if _newclass:M = _swig_property(_swigfaiss_gpu.OPQMatrix_M_get, _swigfaiss_gpu.OPQMatrix_M_set)
|
|
__swig_setmethods__["niter"] = _swigfaiss_gpu.OPQMatrix_niter_set
|
|
__swig_getmethods__["niter"] = _swigfaiss_gpu.OPQMatrix_niter_get
|
|
if _newclass:niter = _swig_property(_swigfaiss_gpu.OPQMatrix_niter_get, _swigfaiss_gpu.OPQMatrix_niter_set)
|
|
__swig_setmethods__["niter_pq"] = _swigfaiss_gpu.OPQMatrix_niter_pq_set
|
|
__swig_getmethods__["niter_pq"] = _swigfaiss_gpu.OPQMatrix_niter_pq_get
|
|
if _newclass:niter_pq = _swig_property(_swigfaiss_gpu.OPQMatrix_niter_pq_get, _swigfaiss_gpu.OPQMatrix_niter_pq_set)
|
|
__swig_setmethods__["niter_pq_0"] = _swigfaiss_gpu.OPQMatrix_niter_pq_0_set
|
|
__swig_getmethods__["niter_pq_0"] = _swigfaiss_gpu.OPQMatrix_niter_pq_0_get
|
|
if _newclass:niter_pq_0 = _swig_property(_swigfaiss_gpu.OPQMatrix_niter_pq_0_get, _swigfaiss_gpu.OPQMatrix_niter_pq_0_set)
|
|
__swig_setmethods__["max_train_points"] = _swigfaiss_gpu.OPQMatrix_max_train_points_set
|
|
__swig_getmethods__["max_train_points"] = _swigfaiss_gpu.OPQMatrix_max_train_points_get
|
|
if _newclass:max_train_points = _swig_property(_swigfaiss_gpu.OPQMatrix_max_train_points_get, _swigfaiss_gpu.OPQMatrix_max_train_points_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss_gpu.OPQMatrix_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss_gpu.OPQMatrix_verbose_get
|
|
if _newclass:verbose = _swig_property(_swigfaiss_gpu.OPQMatrix_verbose_get, _swigfaiss_gpu.OPQMatrix_verbose_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_OPQMatrix(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def train(self, *args): return _swigfaiss_gpu.OPQMatrix_train(self, *args)
|
|
def reverse_transform(self, *args): return _swigfaiss_gpu.OPQMatrix_reverse_transform(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_OPQMatrix
|
|
__del__ = lambda self : None;
|
|
OPQMatrix_swigregister = _swigfaiss_gpu.OPQMatrix_swigregister
|
|
OPQMatrix_swigregister(OPQMatrix)
|
|
|
|
class RemapDimensionsTransform(VectorTransform):
|
|
__swig_setmethods__ = {}
|
|
for _s in [VectorTransform]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, RemapDimensionsTransform, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [VectorTransform]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, RemapDimensionsTransform, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["map"] = _swigfaiss_gpu.RemapDimensionsTransform_map_set
|
|
__swig_getmethods__["map"] = _swigfaiss_gpu.RemapDimensionsTransform_map_get
|
|
if _newclass:map = _swig_property(_swigfaiss_gpu.RemapDimensionsTransform_map_get, _swigfaiss_gpu.RemapDimensionsTransform_map_set)
|
|
def apply_noalloc(self, *args): return _swigfaiss_gpu.RemapDimensionsTransform_apply_noalloc(self, *args)
|
|
def reverse_transform(self, *args): return _swigfaiss_gpu.RemapDimensionsTransform_reverse_transform(self, *args)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_RemapDimensionsTransform(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_RemapDimensionsTransform
|
|
__del__ = lambda self : None;
|
|
RemapDimensionsTransform_swigregister = _swigfaiss_gpu.RemapDimensionsTransform_swigregister
|
|
RemapDimensionsTransform_swigregister(RemapDimensionsTransform)
|
|
|
|
class NormalizationTransform(VectorTransform):
|
|
__swig_setmethods__ = {}
|
|
for _s in [VectorTransform]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, NormalizationTransform, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [VectorTransform]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, NormalizationTransform, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["norm"] = _swigfaiss_gpu.NormalizationTransform_norm_set
|
|
__swig_getmethods__["norm"] = _swigfaiss_gpu.NormalizationTransform_norm_get
|
|
if _newclass:norm = _swig_property(_swigfaiss_gpu.NormalizationTransform_norm_get, _swigfaiss_gpu.NormalizationTransform_norm_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_NormalizationTransform(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def apply_noalloc(self, *args): return _swigfaiss_gpu.NormalizationTransform_apply_noalloc(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_NormalizationTransform
|
|
__del__ = lambda self : None;
|
|
NormalizationTransform_swigregister = _swigfaiss_gpu.NormalizationTransform_swigregister
|
|
NormalizationTransform_swigregister(NormalizationTransform)
|
|
|
|
class IndexPreTransform(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexPreTransform, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexPreTransform, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["chain"] = _swigfaiss_gpu.IndexPreTransform_chain_set
|
|
__swig_getmethods__["chain"] = _swigfaiss_gpu.IndexPreTransform_chain_get
|
|
if _newclass:chain = _swig_property(_swigfaiss_gpu.IndexPreTransform_chain_get, _swigfaiss_gpu.IndexPreTransform_chain_set)
|
|
__swig_setmethods__["index"] = _swigfaiss_gpu.IndexPreTransform_index_set
|
|
__swig_getmethods__["index"] = _swigfaiss_gpu.IndexPreTransform_index_get
|
|
if _newclass:index = _swig_property(_swigfaiss_gpu.IndexPreTransform_index_get, _swigfaiss_gpu.IndexPreTransform_index_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss_gpu.IndexPreTransform_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss_gpu.IndexPreTransform_own_fields_get
|
|
if _newclass:own_fields = _swig_property(_swigfaiss_gpu.IndexPreTransform_own_fields_get, _swigfaiss_gpu.IndexPreTransform_own_fields_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexPreTransform(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def prepend_transform(self, *args): return _swigfaiss_gpu.IndexPreTransform_prepend_transform(self, *args)
|
|
def train(self, *args): return _swigfaiss_gpu.IndexPreTransform_train(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexPreTransform_add(self, *args)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.IndexPreTransform_add_with_ids(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexPreTransform_reset(self)
|
|
def remove_ids(self, *args): return _swigfaiss_gpu.IndexPreTransform_remove_ids(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexPreTransform_search(self, *args)
|
|
def reconstruct_n(self, *args): return _swigfaiss_gpu.IndexPreTransform_reconstruct_n(self, *args)
|
|
def apply_chain(self, *args): return _swigfaiss_gpu.IndexPreTransform_apply_chain(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexPreTransform
|
|
__del__ = lambda self : None;
|
|
IndexPreTransform_swigregister = _swigfaiss_gpu.IndexPreTransform_swigregister
|
|
IndexPreTransform_swigregister(IndexPreTransform)
|
|
|
|
class IndexFlat(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexFlat, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexFlat, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["xb"] = _swigfaiss_gpu.IndexFlat_xb_set
|
|
__swig_getmethods__["xb"] = _swigfaiss_gpu.IndexFlat_xb_get
|
|
if _newclass:xb = _swig_property(_swigfaiss_gpu.IndexFlat_xb_get, _swigfaiss_gpu.IndexFlat_xb_set)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexFlat_add(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexFlat_reset(self)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexFlat_search(self, *args)
|
|
def range_search(self, *args): return _swigfaiss_gpu.IndexFlat_range_search(self, *args)
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.IndexFlat_reconstruct(self, *args)
|
|
def compute_distance_subset(self, *args): return _swigfaiss_gpu.IndexFlat_compute_distance_subset(self, *args)
|
|
def remove_ids(self, *args): return _swigfaiss_gpu.IndexFlat_remove_ids(self, *args)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexFlat(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexFlat
|
|
__del__ = lambda self : None;
|
|
IndexFlat_swigregister = _swigfaiss_gpu.IndexFlat_swigregister
|
|
IndexFlat_swigregister(IndexFlat)
|
|
|
|
class IndexFlatIP(IndexFlat):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexFlat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexFlatIP, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexFlat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexFlatIP, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexFlatIP(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexFlatIP
|
|
__del__ = lambda self : None;
|
|
IndexFlatIP_swigregister = _swigfaiss_gpu.IndexFlatIP_swigregister
|
|
IndexFlatIP_swigregister(IndexFlatIP)
|
|
|
|
class IndexFlatL2(IndexFlat):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexFlat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexFlatL2, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexFlat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexFlatL2, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexFlatL2(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexFlatL2
|
|
__del__ = lambda self : None;
|
|
IndexFlatL2_swigregister = _swigfaiss_gpu.IndexFlatL2_swigregister
|
|
IndexFlatL2_swigregister(IndexFlatL2)
|
|
|
|
class IndexFlatL2BaseShift(IndexFlatL2):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexFlatL2]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexFlatL2BaseShift, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexFlatL2]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexFlatL2BaseShift, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["shift"] = _swigfaiss_gpu.IndexFlatL2BaseShift_shift_set
|
|
__swig_getmethods__["shift"] = _swigfaiss_gpu.IndexFlatL2BaseShift_shift_get
|
|
if _newclass:shift = _swig_property(_swigfaiss_gpu.IndexFlatL2BaseShift_shift_get, _swigfaiss_gpu.IndexFlatL2BaseShift_shift_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexFlatL2BaseShift(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def search(self, *args): return _swigfaiss_gpu.IndexFlatL2BaseShift_search(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexFlatL2BaseShift
|
|
__del__ = lambda self : None;
|
|
IndexFlatL2BaseShift_swigregister = _swigfaiss_gpu.IndexFlatL2BaseShift_swigregister
|
|
IndexFlatL2BaseShift_swigregister(IndexFlatL2BaseShift)
|
|
|
|
class IndexRefineFlat(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexRefineFlat, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexRefineFlat, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["refine_index"] = _swigfaiss_gpu.IndexRefineFlat_refine_index_set
|
|
__swig_getmethods__["refine_index"] = _swigfaiss_gpu.IndexRefineFlat_refine_index_get
|
|
if _newclass:refine_index = _swig_property(_swigfaiss_gpu.IndexRefineFlat_refine_index_get, _swigfaiss_gpu.IndexRefineFlat_refine_index_set)
|
|
__swig_setmethods__["base_index"] = _swigfaiss_gpu.IndexRefineFlat_base_index_set
|
|
__swig_getmethods__["base_index"] = _swigfaiss_gpu.IndexRefineFlat_base_index_get
|
|
if _newclass:base_index = _swig_property(_swigfaiss_gpu.IndexRefineFlat_base_index_get, _swigfaiss_gpu.IndexRefineFlat_base_index_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss_gpu.IndexRefineFlat_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss_gpu.IndexRefineFlat_own_fields_get
|
|
if _newclass:own_fields = _swig_property(_swigfaiss_gpu.IndexRefineFlat_own_fields_get, _swigfaiss_gpu.IndexRefineFlat_own_fields_set)
|
|
__swig_setmethods__["k_factor"] = _swigfaiss_gpu.IndexRefineFlat_k_factor_set
|
|
__swig_getmethods__["k_factor"] = _swigfaiss_gpu.IndexRefineFlat_k_factor_get
|
|
if _newclass:k_factor = _swig_property(_swigfaiss_gpu.IndexRefineFlat_k_factor_get, _swigfaiss_gpu.IndexRefineFlat_k_factor_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexRefineFlat(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def train(self, *args): return _swigfaiss_gpu.IndexRefineFlat_train(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexRefineFlat_add(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexRefineFlat_reset(self)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexRefineFlat_search(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexRefineFlat
|
|
__del__ = lambda self : None;
|
|
IndexRefineFlat_swigregister = _swigfaiss_gpu.IndexRefineFlat_swigregister
|
|
IndexRefineFlat_swigregister(IndexRefineFlat)
|
|
|
|
class IndexFlat1D(IndexFlatL2):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexFlatL2]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexFlat1D, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexFlatL2]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexFlat1D, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["continuous_update"] = _swigfaiss_gpu.IndexFlat1D_continuous_update_set
|
|
__swig_getmethods__["continuous_update"] = _swigfaiss_gpu.IndexFlat1D_continuous_update_get
|
|
if _newclass:continuous_update = _swig_property(_swigfaiss_gpu.IndexFlat1D_continuous_update_get, _swigfaiss_gpu.IndexFlat1D_continuous_update_set)
|
|
__swig_setmethods__["perm"] = _swigfaiss_gpu.IndexFlat1D_perm_set
|
|
__swig_getmethods__["perm"] = _swigfaiss_gpu.IndexFlat1D_perm_get
|
|
if _newclass:perm = _swig_property(_swigfaiss_gpu.IndexFlat1D_perm_get, _swigfaiss_gpu.IndexFlat1D_perm_set)
|
|
def __init__(self, continuous_update=True):
|
|
this = _swigfaiss_gpu.new_IndexFlat1D(continuous_update)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def update_permutation(self): return _swigfaiss_gpu.IndexFlat1D_update_permutation(self)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexFlat1D_add(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexFlat1D_reset(self)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexFlat1D_search(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexFlat1D
|
|
__del__ = lambda self : None;
|
|
IndexFlat1D_swigregister = _swigfaiss_gpu.IndexFlat1D_swigregister
|
|
IndexFlat1D_swigregister(IndexFlat1D)
|
|
|
|
class IndexLSH(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexLSH, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexLSH, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nbits"] = _swigfaiss_gpu.IndexLSH_nbits_set
|
|
__swig_getmethods__["nbits"] = _swigfaiss_gpu.IndexLSH_nbits_get
|
|
if _newclass:nbits = _swig_property(_swigfaiss_gpu.IndexLSH_nbits_get, _swigfaiss_gpu.IndexLSH_nbits_set)
|
|
__swig_setmethods__["bytes_per_vec"] = _swigfaiss_gpu.IndexLSH_bytes_per_vec_set
|
|
__swig_getmethods__["bytes_per_vec"] = _swigfaiss_gpu.IndexLSH_bytes_per_vec_get
|
|
if _newclass:bytes_per_vec = _swig_property(_swigfaiss_gpu.IndexLSH_bytes_per_vec_get, _swigfaiss_gpu.IndexLSH_bytes_per_vec_set)
|
|
__swig_setmethods__["rotate_data"] = _swigfaiss_gpu.IndexLSH_rotate_data_set
|
|
__swig_getmethods__["rotate_data"] = _swigfaiss_gpu.IndexLSH_rotate_data_get
|
|
if _newclass:rotate_data = _swig_property(_swigfaiss_gpu.IndexLSH_rotate_data_get, _swigfaiss_gpu.IndexLSH_rotate_data_set)
|
|
__swig_setmethods__["train_thresholds"] = _swigfaiss_gpu.IndexLSH_train_thresholds_set
|
|
__swig_getmethods__["train_thresholds"] = _swigfaiss_gpu.IndexLSH_train_thresholds_get
|
|
if _newclass:train_thresholds = _swig_property(_swigfaiss_gpu.IndexLSH_train_thresholds_get, _swigfaiss_gpu.IndexLSH_train_thresholds_set)
|
|
__swig_setmethods__["rrot"] = _swigfaiss_gpu.IndexLSH_rrot_set
|
|
__swig_getmethods__["rrot"] = _swigfaiss_gpu.IndexLSH_rrot_get
|
|
if _newclass:rrot = _swig_property(_swigfaiss_gpu.IndexLSH_rrot_get, _swigfaiss_gpu.IndexLSH_rrot_set)
|
|
__swig_setmethods__["thresholds"] = _swigfaiss_gpu.IndexLSH_thresholds_set
|
|
__swig_getmethods__["thresholds"] = _swigfaiss_gpu.IndexLSH_thresholds_get
|
|
if _newclass:thresholds = _swig_property(_swigfaiss_gpu.IndexLSH_thresholds_get, _swigfaiss_gpu.IndexLSH_thresholds_set)
|
|
__swig_setmethods__["codes"] = _swigfaiss_gpu.IndexLSH_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss_gpu.IndexLSH_codes_get
|
|
if _newclass:codes = _swig_property(_swigfaiss_gpu.IndexLSH_codes_get, _swigfaiss_gpu.IndexLSH_codes_set)
|
|
def apply_preprocess(self, *args): return _swigfaiss_gpu.IndexLSH_apply_preprocess(self, *args)
|
|
def train(self, *args): return _swigfaiss_gpu.IndexLSH_train(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexLSH_add(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexLSH_search(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexLSH_reset(self)
|
|
def transfer_thresholds(self, *args): return _swigfaiss_gpu.IndexLSH_transfer_thresholds(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexLSH
|
|
__del__ = lambda self : None;
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexLSH(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
IndexLSH_swigregister = _swigfaiss_gpu.IndexLSH_swigregister
|
|
IndexLSH_swigregister(IndexLSH)
|
|
|
|
class SimulatedAnnealingParameters(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, SimulatedAnnealingParameters, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, SimulatedAnnealingParameters, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["init_temperature"] = _swigfaiss_gpu.SimulatedAnnealingParameters_init_temperature_set
|
|
__swig_getmethods__["init_temperature"] = _swigfaiss_gpu.SimulatedAnnealingParameters_init_temperature_get
|
|
if _newclass:init_temperature = _swig_property(_swigfaiss_gpu.SimulatedAnnealingParameters_init_temperature_get, _swigfaiss_gpu.SimulatedAnnealingParameters_init_temperature_set)
|
|
__swig_setmethods__["temperature_decay"] = _swigfaiss_gpu.SimulatedAnnealingParameters_temperature_decay_set
|
|
__swig_getmethods__["temperature_decay"] = _swigfaiss_gpu.SimulatedAnnealingParameters_temperature_decay_get
|
|
if _newclass:temperature_decay = _swig_property(_swigfaiss_gpu.SimulatedAnnealingParameters_temperature_decay_get, _swigfaiss_gpu.SimulatedAnnealingParameters_temperature_decay_set)
|
|
__swig_setmethods__["n_iter"] = _swigfaiss_gpu.SimulatedAnnealingParameters_n_iter_set
|
|
__swig_getmethods__["n_iter"] = _swigfaiss_gpu.SimulatedAnnealingParameters_n_iter_get
|
|
if _newclass:n_iter = _swig_property(_swigfaiss_gpu.SimulatedAnnealingParameters_n_iter_get, _swigfaiss_gpu.SimulatedAnnealingParameters_n_iter_set)
|
|
__swig_setmethods__["n_redo"] = _swigfaiss_gpu.SimulatedAnnealingParameters_n_redo_set
|
|
__swig_getmethods__["n_redo"] = _swigfaiss_gpu.SimulatedAnnealingParameters_n_redo_get
|
|
if _newclass:n_redo = _swig_property(_swigfaiss_gpu.SimulatedAnnealingParameters_n_redo_get, _swigfaiss_gpu.SimulatedAnnealingParameters_n_redo_set)
|
|
__swig_setmethods__["seed"] = _swigfaiss_gpu.SimulatedAnnealingParameters_seed_set
|
|
__swig_getmethods__["seed"] = _swigfaiss_gpu.SimulatedAnnealingParameters_seed_get
|
|
if _newclass:seed = _swig_property(_swigfaiss_gpu.SimulatedAnnealingParameters_seed_get, _swigfaiss_gpu.SimulatedAnnealingParameters_seed_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss_gpu.SimulatedAnnealingParameters_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss_gpu.SimulatedAnnealingParameters_verbose_get
|
|
if _newclass:verbose = _swig_property(_swigfaiss_gpu.SimulatedAnnealingParameters_verbose_get, _swigfaiss_gpu.SimulatedAnnealingParameters_verbose_set)
|
|
__swig_setmethods__["only_bit_flips"] = _swigfaiss_gpu.SimulatedAnnealingParameters_only_bit_flips_set
|
|
__swig_getmethods__["only_bit_flips"] = _swigfaiss_gpu.SimulatedAnnealingParameters_only_bit_flips_get
|
|
if _newclass:only_bit_flips = _swig_property(_swigfaiss_gpu.SimulatedAnnealingParameters_only_bit_flips_get, _swigfaiss_gpu.SimulatedAnnealingParameters_only_bit_flips_set)
|
|
__swig_setmethods__["init_random"] = _swigfaiss_gpu.SimulatedAnnealingParameters_init_random_set
|
|
__swig_getmethods__["init_random"] = _swigfaiss_gpu.SimulatedAnnealingParameters_init_random_get
|
|
if _newclass:init_random = _swig_property(_swigfaiss_gpu.SimulatedAnnealingParameters_init_random_get, _swigfaiss_gpu.SimulatedAnnealingParameters_init_random_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_SimulatedAnnealingParameters()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_SimulatedAnnealingParameters
|
|
__del__ = lambda self : None;
|
|
SimulatedAnnealingParameters_swigregister = _swigfaiss_gpu.SimulatedAnnealingParameters_swigregister
|
|
SimulatedAnnealingParameters_swigregister(SimulatedAnnealingParameters)
|
|
|
|
class PermutationObjective(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, PermutationObjective, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, PermutationObjective, name)
|
|
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["n"] = _swigfaiss_gpu.PermutationObjective_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss_gpu.PermutationObjective_n_get
|
|
if _newclass:n = _swig_property(_swigfaiss_gpu.PermutationObjective_n_get, _swigfaiss_gpu.PermutationObjective_n_set)
|
|
def compute_cost(self, *args): return _swigfaiss_gpu.PermutationObjective_compute_cost(self, *args)
|
|
def cost_update(self, *args): return _swigfaiss_gpu.PermutationObjective_cost_update(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_PermutationObjective
|
|
__del__ = lambda self : None;
|
|
PermutationObjective_swigregister = _swigfaiss_gpu.PermutationObjective_swigregister
|
|
PermutationObjective_swigregister(PermutationObjective)
|
|
|
|
class ReproduceDistancesObjective(PermutationObjective):
|
|
__swig_setmethods__ = {}
|
|
for _s in [PermutationObjective]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ReproduceDistancesObjective, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [PermutationObjective]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ReproduceDistancesObjective, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["dis_weight_factor"] = _swigfaiss_gpu.ReproduceDistancesObjective_dis_weight_factor_set
|
|
__swig_getmethods__["dis_weight_factor"] = _swigfaiss_gpu.ReproduceDistancesObjective_dis_weight_factor_get
|
|
if _newclass:dis_weight_factor = _swig_property(_swigfaiss_gpu.ReproduceDistancesObjective_dis_weight_factor_get, _swigfaiss_gpu.ReproduceDistancesObjective_dis_weight_factor_set)
|
|
__swig_getmethods__["sqr"] = lambda x: _swigfaiss_gpu.ReproduceDistancesObjective_sqr
|
|
if _newclass:sqr = staticmethod(_swigfaiss_gpu.ReproduceDistancesObjective_sqr)
|
|
def dis_weight(self, *args): return _swigfaiss_gpu.ReproduceDistancesObjective_dis_weight(self, *args)
|
|
__swig_setmethods__["source_dis"] = _swigfaiss_gpu.ReproduceDistancesObjective_source_dis_set
|
|
__swig_getmethods__["source_dis"] = _swigfaiss_gpu.ReproduceDistancesObjective_source_dis_get
|
|
if _newclass:source_dis = _swig_property(_swigfaiss_gpu.ReproduceDistancesObjective_source_dis_get, _swigfaiss_gpu.ReproduceDistancesObjective_source_dis_set)
|
|
__swig_setmethods__["target_dis"] = _swigfaiss_gpu.ReproduceDistancesObjective_target_dis_set
|
|
__swig_getmethods__["target_dis"] = _swigfaiss_gpu.ReproduceDistancesObjective_target_dis_get
|
|
if _newclass:target_dis = _swig_property(_swigfaiss_gpu.ReproduceDistancesObjective_target_dis_get, _swigfaiss_gpu.ReproduceDistancesObjective_target_dis_set)
|
|
__swig_setmethods__["weights"] = _swigfaiss_gpu.ReproduceDistancesObjective_weights_set
|
|
__swig_getmethods__["weights"] = _swigfaiss_gpu.ReproduceDistancesObjective_weights_get
|
|
if _newclass:weights = _swig_property(_swigfaiss_gpu.ReproduceDistancesObjective_weights_get, _swigfaiss_gpu.ReproduceDistancesObjective_weights_set)
|
|
def get_source_dis(self, *args): return _swigfaiss_gpu.ReproduceDistancesObjective_get_source_dis(self, *args)
|
|
def compute_cost(self, *args): return _swigfaiss_gpu.ReproduceDistancesObjective_compute_cost(self, *args)
|
|
def cost_update(self, *args): return _swigfaiss_gpu.ReproduceDistancesObjective_cost_update(self, *args)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_ReproduceDistancesObjective(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_getmethods__["compute_mean_stdev"] = lambda x: _swigfaiss_gpu.ReproduceDistancesObjective_compute_mean_stdev
|
|
if _newclass:compute_mean_stdev = staticmethod(_swigfaiss_gpu.ReproduceDistancesObjective_compute_mean_stdev)
|
|
def set_affine_target_dis(self, *args): return _swigfaiss_gpu.ReproduceDistancesObjective_set_affine_target_dis(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_ReproduceDistancesObjective
|
|
__del__ = lambda self : None;
|
|
ReproduceDistancesObjective_swigregister = _swigfaiss_gpu.ReproduceDistancesObjective_swigregister
|
|
ReproduceDistancesObjective_swigregister(ReproduceDistancesObjective)
|
|
|
|
def ReproduceDistancesObjective_sqr(*args):
|
|
return _swigfaiss_gpu.ReproduceDistancesObjective_sqr(*args)
|
|
ReproduceDistancesObjective_sqr = _swigfaiss_gpu.ReproduceDistancesObjective_sqr
|
|
|
|
def ReproduceDistancesObjective_compute_mean_stdev(*args):
|
|
return _swigfaiss_gpu.ReproduceDistancesObjective_compute_mean_stdev(*args)
|
|
ReproduceDistancesObjective_compute_mean_stdev = _swigfaiss_gpu.ReproduceDistancesObjective_compute_mean_stdev
|
|
|
|
class SimulatedAnnealingOptimizer(SimulatedAnnealingParameters):
|
|
__swig_setmethods__ = {}
|
|
for _s in [SimulatedAnnealingParameters]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, SimulatedAnnealingOptimizer, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [SimulatedAnnealingParameters]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, SimulatedAnnealingOptimizer, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["obj"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_obj_set
|
|
__swig_getmethods__["obj"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_obj_get
|
|
if _newclass:obj = _swig_property(_swigfaiss_gpu.SimulatedAnnealingOptimizer_obj_get, _swigfaiss_gpu.SimulatedAnnealingOptimizer_obj_set)
|
|
__swig_setmethods__["n"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_n_get
|
|
if _newclass:n = _swig_property(_swigfaiss_gpu.SimulatedAnnealingOptimizer_n_get, _swigfaiss_gpu.SimulatedAnnealingOptimizer_n_set)
|
|
__swig_setmethods__["logfile"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_logfile_set
|
|
__swig_getmethods__["logfile"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_logfile_get
|
|
if _newclass:logfile = _swig_property(_swigfaiss_gpu.SimulatedAnnealingOptimizer_logfile_get, _swigfaiss_gpu.SimulatedAnnealingOptimizer_logfile_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_SimulatedAnnealingOptimizer(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["rnd"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_rnd_set
|
|
__swig_getmethods__["rnd"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_rnd_get
|
|
if _newclass:rnd = _swig_property(_swigfaiss_gpu.SimulatedAnnealingOptimizer_rnd_get, _swigfaiss_gpu.SimulatedAnnealingOptimizer_rnd_set)
|
|
__swig_setmethods__["init_cost"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_init_cost_set
|
|
__swig_getmethods__["init_cost"] = _swigfaiss_gpu.SimulatedAnnealingOptimizer_init_cost_get
|
|
if _newclass:init_cost = _swig_property(_swigfaiss_gpu.SimulatedAnnealingOptimizer_init_cost_get, _swigfaiss_gpu.SimulatedAnnealingOptimizer_init_cost_set)
|
|
def optimize(self, *args): return _swigfaiss_gpu.SimulatedAnnealingOptimizer_optimize(self, *args)
|
|
def run_optimization(self, *args): return _swigfaiss_gpu.SimulatedAnnealingOptimizer_run_optimization(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_SimulatedAnnealingOptimizer
|
|
__del__ = lambda self : None;
|
|
SimulatedAnnealingOptimizer_swigregister = _swigfaiss_gpu.SimulatedAnnealingOptimizer_swigregister
|
|
SimulatedAnnealingOptimizer_swigregister(SimulatedAnnealingOptimizer)
|
|
|
|
class PolysemousTraining(SimulatedAnnealingParameters):
|
|
__swig_setmethods__ = {}
|
|
for _s in [SimulatedAnnealingParameters]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, PolysemousTraining, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [SimulatedAnnealingParameters]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, PolysemousTraining, name)
|
|
__repr__ = _swig_repr
|
|
OT_None = _swigfaiss_gpu.PolysemousTraining_OT_None
|
|
OT_ReproduceDistances_affine = _swigfaiss_gpu.PolysemousTraining_OT_ReproduceDistances_affine
|
|
OT_Ranking_weighted_diff = _swigfaiss_gpu.PolysemousTraining_OT_Ranking_weighted_diff
|
|
__swig_setmethods__["optimization_type"] = _swigfaiss_gpu.PolysemousTraining_optimization_type_set
|
|
__swig_getmethods__["optimization_type"] = _swigfaiss_gpu.PolysemousTraining_optimization_type_get
|
|
if _newclass:optimization_type = _swig_property(_swigfaiss_gpu.PolysemousTraining_optimization_type_get, _swigfaiss_gpu.PolysemousTraining_optimization_type_set)
|
|
__swig_setmethods__["ntrain_permutation"] = _swigfaiss_gpu.PolysemousTraining_ntrain_permutation_set
|
|
__swig_getmethods__["ntrain_permutation"] = _swigfaiss_gpu.PolysemousTraining_ntrain_permutation_get
|
|
if _newclass:ntrain_permutation = _swig_property(_swigfaiss_gpu.PolysemousTraining_ntrain_permutation_get, _swigfaiss_gpu.PolysemousTraining_ntrain_permutation_set)
|
|
__swig_setmethods__["dis_weight_factor"] = _swigfaiss_gpu.PolysemousTraining_dis_weight_factor_set
|
|
__swig_getmethods__["dis_weight_factor"] = _swigfaiss_gpu.PolysemousTraining_dis_weight_factor_get
|
|
if _newclass:dis_weight_factor = _swig_property(_swigfaiss_gpu.PolysemousTraining_dis_weight_factor_get, _swigfaiss_gpu.PolysemousTraining_dis_weight_factor_set)
|
|
__swig_setmethods__["log_pattern"] = _swigfaiss_gpu.PolysemousTraining_log_pattern_set
|
|
__swig_getmethods__["log_pattern"] = _swigfaiss_gpu.PolysemousTraining_log_pattern_get
|
|
if _newclass:log_pattern = _swig_property(_swigfaiss_gpu.PolysemousTraining_log_pattern_get, _swigfaiss_gpu.PolysemousTraining_log_pattern_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_PolysemousTraining()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def optimize_pq_for_hamming(self, *args): return _swigfaiss_gpu.PolysemousTraining_optimize_pq_for_hamming(self, *args)
|
|
def optimize_ranking(self, *args): return _swigfaiss_gpu.PolysemousTraining_optimize_ranking(self, *args)
|
|
def optimize_reproduce_distances(self, *args): return _swigfaiss_gpu.PolysemousTraining_optimize_reproduce_distances(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_PolysemousTraining
|
|
__del__ = lambda self : None;
|
|
PolysemousTraining_swigregister = _swigfaiss_gpu.PolysemousTraining_swigregister
|
|
PolysemousTraining_swigregister(PolysemousTraining)
|
|
|
|
class IndexPQ(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexPQ, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexPQ, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["pq"] = _swigfaiss_gpu.IndexPQ_pq_set
|
|
__swig_getmethods__["pq"] = _swigfaiss_gpu.IndexPQ_pq_get
|
|
if _newclass:pq = _swig_property(_swigfaiss_gpu.IndexPQ_pq_get, _swigfaiss_gpu.IndexPQ_pq_set)
|
|
__swig_setmethods__["codes"] = _swigfaiss_gpu.IndexPQ_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss_gpu.IndexPQ_codes_get
|
|
if _newclass:codes = _swig_property(_swigfaiss_gpu.IndexPQ_codes_get, _swigfaiss_gpu.IndexPQ_codes_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexPQ(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def train(self, *args): return _swigfaiss_gpu.IndexPQ_train(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexPQ_add(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexPQ_search(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexPQ_reset(self)
|
|
def reconstruct_n(self, *args): return _swigfaiss_gpu.IndexPQ_reconstruct_n(self, *args)
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.IndexPQ_reconstruct(self, *args)
|
|
__swig_setmethods__["do_polysemous_training"] = _swigfaiss_gpu.IndexPQ_do_polysemous_training_set
|
|
__swig_getmethods__["do_polysemous_training"] = _swigfaiss_gpu.IndexPQ_do_polysemous_training_get
|
|
if _newclass:do_polysemous_training = _swig_property(_swigfaiss_gpu.IndexPQ_do_polysemous_training_get, _swigfaiss_gpu.IndexPQ_do_polysemous_training_set)
|
|
__swig_setmethods__["polysemous_training"] = _swigfaiss_gpu.IndexPQ_polysemous_training_set
|
|
__swig_getmethods__["polysemous_training"] = _swigfaiss_gpu.IndexPQ_polysemous_training_get
|
|
if _newclass:polysemous_training = _swig_property(_swigfaiss_gpu.IndexPQ_polysemous_training_get, _swigfaiss_gpu.IndexPQ_polysemous_training_set)
|
|
ST_PQ = _swigfaiss_gpu.IndexPQ_ST_PQ
|
|
ST_HE = _swigfaiss_gpu.IndexPQ_ST_HE
|
|
ST_generalized_HE = _swigfaiss_gpu.IndexPQ_ST_generalized_HE
|
|
ST_SDC = _swigfaiss_gpu.IndexPQ_ST_SDC
|
|
ST_polysemous = _swigfaiss_gpu.IndexPQ_ST_polysemous
|
|
ST_polysemous_generalize = _swigfaiss_gpu.IndexPQ_ST_polysemous_generalize
|
|
__swig_setmethods__["search_type"] = _swigfaiss_gpu.IndexPQ_search_type_set
|
|
__swig_getmethods__["search_type"] = _swigfaiss_gpu.IndexPQ_search_type_get
|
|
if _newclass:search_type = _swig_property(_swigfaiss_gpu.IndexPQ_search_type_get, _swigfaiss_gpu.IndexPQ_search_type_set)
|
|
__swig_setmethods__["encode_signs"] = _swigfaiss_gpu.IndexPQ_encode_signs_set
|
|
__swig_getmethods__["encode_signs"] = _swigfaiss_gpu.IndexPQ_encode_signs_get
|
|
if _newclass:encode_signs = _swig_property(_swigfaiss_gpu.IndexPQ_encode_signs_get, _swigfaiss_gpu.IndexPQ_encode_signs_set)
|
|
__swig_setmethods__["polysemous_ht"] = _swigfaiss_gpu.IndexPQ_polysemous_ht_set
|
|
__swig_getmethods__["polysemous_ht"] = _swigfaiss_gpu.IndexPQ_polysemous_ht_get
|
|
if _newclass:polysemous_ht = _swig_property(_swigfaiss_gpu.IndexPQ_polysemous_ht_get, _swigfaiss_gpu.IndexPQ_polysemous_ht_set)
|
|
def search_core_polysemous(self, *args): return _swigfaiss_gpu.IndexPQ_search_core_polysemous(self, *args)
|
|
def hamming_distance_histogram(self, *args): return _swigfaiss_gpu.IndexPQ_hamming_distance_histogram(self, *args)
|
|
def hamming_distance_table(self, *args): return _swigfaiss_gpu.IndexPQ_hamming_distance_table(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexPQ
|
|
__del__ = lambda self : None;
|
|
IndexPQ_swigregister = _swigfaiss_gpu.IndexPQ_swigregister
|
|
IndexPQ_swigregister(IndexPQ)
|
|
|
|
class IndexPQStats(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexPQStats, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexPQStats, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nq"] = _swigfaiss_gpu.IndexPQStats_nq_set
|
|
__swig_getmethods__["nq"] = _swigfaiss_gpu.IndexPQStats_nq_get
|
|
if _newclass:nq = _swig_property(_swigfaiss_gpu.IndexPQStats_nq_get, _swigfaiss_gpu.IndexPQStats_nq_set)
|
|
__swig_setmethods__["ncode"] = _swigfaiss_gpu.IndexPQStats_ncode_set
|
|
__swig_getmethods__["ncode"] = _swigfaiss_gpu.IndexPQStats_ncode_get
|
|
if _newclass:ncode = _swig_property(_swigfaiss_gpu.IndexPQStats_ncode_get, _swigfaiss_gpu.IndexPQStats_ncode_set)
|
|
__swig_setmethods__["n_hamming_pass"] = _swigfaiss_gpu.IndexPQStats_n_hamming_pass_set
|
|
__swig_getmethods__["n_hamming_pass"] = _swigfaiss_gpu.IndexPQStats_n_hamming_pass_get
|
|
if _newclass:n_hamming_pass = _swig_property(_swigfaiss_gpu.IndexPQStats_n_hamming_pass_get, _swigfaiss_gpu.IndexPQStats_n_hamming_pass_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_IndexPQStats()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def reset(self): return _swigfaiss_gpu.IndexPQStats_reset(self)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexPQStats
|
|
__del__ = lambda self : None;
|
|
IndexPQStats_swigregister = _swigfaiss_gpu.IndexPQStats_swigregister
|
|
IndexPQStats_swigregister(IndexPQStats)
|
|
|
|
class MultiIndexQuantizer(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, MultiIndexQuantizer, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, MultiIndexQuantizer, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["pq"] = _swigfaiss_gpu.MultiIndexQuantizer_pq_set
|
|
__swig_getmethods__["pq"] = _swigfaiss_gpu.MultiIndexQuantizer_pq_get
|
|
if _newclass:pq = _swig_property(_swigfaiss_gpu.MultiIndexQuantizer_pq_get, _swigfaiss_gpu.MultiIndexQuantizer_pq_set)
|
|
def train(self, *args): return _swigfaiss_gpu.MultiIndexQuantizer_train(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.MultiIndexQuantizer_search(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.MultiIndexQuantizer_add(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.MultiIndexQuantizer_reset(self)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_MultiIndexQuantizer(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.MultiIndexQuantizer_reconstruct(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_MultiIndexQuantizer
|
|
__del__ = lambda self : None;
|
|
MultiIndexQuantizer_swigregister = _swigfaiss_gpu.MultiIndexQuantizer_swigregister
|
|
MultiIndexQuantizer_swigregister(MultiIndexQuantizer)
|
|
cvar = _swigfaiss_gpu.cvar
|
|
|
|
class IndexIVF(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVF, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVF, name)
|
|
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nlist"] = _swigfaiss_gpu.IndexIVF_nlist_set
|
|
__swig_getmethods__["nlist"] = _swigfaiss_gpu.IndexIVF_nlist_get
|
|
if _newclass:nlist = _swig_property(_swigfaiss_gpu.IndexIVF_nlist_get, _swigfaiss_gpu.IndexIVF_nlist_set)
|
|
__swig_setmethods__["nprobe"] = _swigfaiss_gpu.IndexIVF_nprobe_set
|
|
__swig_getmethods__["nprobe"] = _swigfaiss_gpu.IndexIVF_nprobe_get
|
|
if _newclass:nprobe = _swig_property(_swigfaiss_gpu.IndexIVF_nprobe_get, _swigfaiss_gpu.IndexIVF_nprobe_set)
|
|
__swig_setmethods__["quantizer"] = _swigfaiss_gpu.IndexIVF_quantizer_set
|
|
__swig_getmethods__["quantizer"] = _swigfaiss_gpu.IndexIVF_quantizer_get
|
|
if _newclass:quantizer = _swig_property(_swigfaiss_gpu.IndexIVF_quantizer_get, _swigfaiss_gpu.IndexIVF_quantizer_set)
|
|
__swig_setmethods__["quantizer_trains_alone"] = _swigfaiss_gpu.IndexIVF_quantizer_trains_alone_set
|
|
__swig_getmethods__["quantizer_trains_alone"] = _swigfaiss_gpu.IndexIVF_quantizer_trains_alone_get
|
|
if _newclass:quantizer_trains_alone = _swig_property(_swigfaiss_gpu.IndexIVF_quantizer_trains_alone_get, _swigfaiss_gpu.IndexIVF_quantizer_trains_alone_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss_gpu.IndexIVF_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss_gpu.IndexIVF_own_fields_get
|
|
if _newclass:own_fields = _swig_property(_swigfaiss_gpu.IndexIVF_own_fields_get, _swigfaiss_gpu.IndexIVF_own_fields_set)
|
|
__swig_setmethods__["cp"] = _swigfaiss_gpu.IndexIVF_cp_set
|
|
__swig_getmethods__["cp"] = _swigfaiss_gpu.IndexIVF_cp_get
|
|
if _newclass:cp = _swig_property(_swigfaiss_gpu.IndexIVF_cp_get, _swigfaiss_gpu.IndexIVF_cp_set)
|
|
__swig_setmethods__["clustering_index"] = _swigfaiss_gpu.IndexIVF_clustering_index_set
|
|
__swig_getmethods__["clustering_index"] = _swigfaiss_gpu.IndexIVF_clustering_index_get
|
|
if _newclass:clustering_index = _swig_property(_swigfaiss_gpu.IndexIVF_clustering_index_get, _swigfaiss_gpu.IndexIVF_clustering_index_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss_gpu.IndexIVF_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss_gpu.IndexIVF_ids_get
|
|
if _newclass:ids = _swig_property(_swigfaiss_gpu.IndexIVF_ids_get, _swigfaiss_gpu.IndexIVF_ids_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss_gpu.IndexIVF_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss_gpu.IndexIVF_code_size_get
|
|
if _newclass:code_size = _swig_property(_swigfaiss_gpu.IndexIVF_code_size_get, _swigfaiss_gpu.IndexIVF_code_size_set)
|
|
__swig_setmethods__["codes"] = _swigfaiss_gpu.IndexIVF_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss_gpu.IndexIVF_codes_get
|
|
if _newclass:codes = _swig_property(_swigfaiss_gpu.IndexIVF_codes_get, _swigfaiss_gpu.IndexIVF_codes_set)
|
|
__swig_setmethods__["maintain_direct_map"] = _swigfaiss_gpu.IndexIVF_maintain_direct_map_set
|
|
__swig_getmethods__["maintain_direct_map"] = _swigfaiss_gpu.IndexIVF_maintain_direct_map_get
|
|
if _newclass:maintain_direct_map = _swig_property(_swigfaiss_gpu.IndexIVF_maintain_direct_map_get, _swigfaiss_gpu.IndexIVF_maintain_direct_map_set)
|
|
__swig_setmethods__["direct_map"] = _swigfaiss_gpu.IndexIVF_direct_map_set
|
|
__swig_getmethods__["direct_map"] = _swigfaiss_gpu.IndexIVF_direct_map_get
|
|
if _newclass:direct_map = _swig_property(_swigfaiss_gpu.IndexIVF_direct_map_get, _swigfaiss_gpu.IndexIVF_direct_map_set)
|
|
def reset(self): return _swigfaiss_gpu.IndexIVF_reset(self)
|
|
def train(self, *args): return _swigfaiss_gpu.IndexIVF_train(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexIVF_add(self, *args)
|
|
def train_residual(self, *args): return _swigfaiss_gpu.IndexIVF_train_residual(self, *args)
|
|
def search_preassigned(self, *args): return _swigfaiss_gpu.IndexIVF_search_preassigned(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexIVF_search(self, *args)
|
|
def remove_ids(self, *args): return _swigfaiss_gpu.IndexIVF_remove_ids(self, *args)
|
|
def merge_from(self, *args): return _swigfaiss_gpu.IndexIVF_merge_from(self, *args)
|
|
def copy_subset_to(self, *args): return _swigfaiss_gpu.IndexIVF_copy_subset_to(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIVF
|
|
__del__ = lambda self : None;
|
|
def get_list_size(self, *args): return _swigfaiss_gpu.IndexIVF_get_list_size(self, *args)
|
|
def make_direct_map(self, new_maintain_direct_map=True): return _swigfaiss_gpu.IndexIVF_make_direct_map(self, new_maintain_direct_map)
|
|
def imbalance_factor(self): return _swigfaiss_gpu.IndexIVF_imbalance_factor(self)
|
|
def print_stats(self): return _swigfaiss_gpu.IndexIVF_print_stats(self)
|
|
IndexIVF_swigregister = _swigfaiss_gpu.IndexIVF_swigregister
|
|
IndexIVF_swigregister(IndexIVF)
|
|
|
|
class IndexIVFFlatStats(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVFFlatStats, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVFFlatStats, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nq"] = _swigfaiss_gpu.IndexIVFFlatStats_nq_set
|
|
__swig_getmethods__["nq"] = _swigfaiss_gpu.IndexIVFFlatStats_nq_get
|
|
if _newclass:nq = _swig_property(_swigfaiss_gpu.IndexIVFFlatStats_nq_get, _swigfaiss_gpu.IndexIVFFlatStats_nq_set)
|
|
__swig_setmethods__["nlist"] = _swigfaiss_gpu.IndexIVFFlatStats_nlist_set
|
|
__swig_getmethods__["nlist"] = _swigfaiss_gpu.IndexIVFFlatStats_nlist_get
|
|
if _newclass:nlist = _swig_property(_swigfaiss_gpu.IndexIVFFlatStats_nlist_get, _swigfaiss_gpu.IndexIVFFlatStats_nlist_set)
|
|
__swig_setmethods__["ndis"] = _swigfaiss_gpu.IndexIVFFlatStats_ndis_set
|
|
__swig_getmethods__["ndis"] = _swigfaiss_gpu.IndexIVFFlatStats_ndis_get
|
|
if _newclass:ndis = _swig_property(_swigfaiss_gpu.IndexIVFFlatStats_ndis_get, _swigfaiss_gpu.IndexIVFFlatStats_ndis_set)
|
|
__swig_setmethods__["npartial"] = _swigfaiss_gpu.IndexIVFFlatStats_npartial_set
|
|
__swig_getmethods__["npartial"] = _swigfaiss_gpu.IndexIVFFlatStats_npartial_get
|
|
if _newclass:npartial = _swig_property(_swigfaiss_gpu.IndexIVFFlatStats_npartial_get, _swigfaiss_gpu.IndexIVFFlatStats_npartial_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_IndexIVFFlatStats()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def reset(self): return _swigfaiss_gpu.IndexIVFFlatStats_reset(self)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIVFFlatStats
|
|
__del__ = lambda self : None;
|
|
IndexIVFFlatStats_swigregister = _swigfaiss_gpu.IndexIVFFlatStats_swigregister
|
|
IndexIVFFlatStats_swigregister(IndexIVFFlatStats)
|
|
|
|
class IndexIVFFlat(IndexIVF):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexIVF]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVFFlat, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexIVF]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVFFlat, name)
|
|
__repr__ = _swig_repr
|
|
def add_core(self, *args): return _swigfaiss_gpu.IndexIVFFlat_add_core(self, *args)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.IndexIVFFlat_add_with_ids(self, *args)
|
|
def search_preassigned(self, *args): return _swigfaiss_gpu.IndexIVFFlat_search_preassigned(self, *args)
|
|
def range_search(self, *args): return _swigfaiss_gpu.IndexIVFFlat_range_search(self, *args)
|
|
def update_vectors(self, *args): return _swigfaiss_gpu.IndexIVFFlat_update_vectors(self, *args)
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.IndexIVFFlat_reconstruct(self, *args)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexIVFFlat(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIVFFlat
|
|
__del__ = lambda self : None;
|
|
IndexIVFFlat_swigregister = _swigfaiss_gpu.IndexIVFFlat_swigregister
|
|
IndexIVFFlat_swigregister(IndexIVFFlat)
|
|
|
|
class ScalarQuantizer(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ScalarQuantizer, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ScalarQuantizer, name)
|
|
__repr__ = _swig_repr
|
|
QT_8bit = _swigfaiss_gpu.ScalarQuantizer_QT_8bit
|
|
QT_4bit = _swigfaiss_gpu.ScalarQuantizer_QT_4bit
|
|
QT_8bit_uniform = _swigfaiss_gpu.ScalarQuantizer_QT_8bit_uniform
|
|
QT_4bit_uniform = _swigfaiss_gpu.ScalarQuantizer_QT_4bit_uniform
|
|
__swig_setmethods__["qtype"] = _swigfaiss_gpu.ScalarQuantizer_qtype_set
|
|
__swig_getmethods__["qtype"] = _swigfaiss_gpu.ScalarQuantizer_qtype_get
|
|
if _newclass:qtype = _swig_property(_swigfaiss_gpu.ScalarQuantizer_qtype_get, _swigfaiss_gpu.ScalarQuantizer_qtype_set)
|
|
RS_minmax = _swigfaiss_gpu.ScalarQuantizer_RS_minmax
|
|
RS_meanstd = _swigfaiss_gpu.ScalarQuantizer_RS_meanstd
|
|
RS_quantiles = _swigfaiss_gpu.ScalarQuantizer_RS_quantiles
|
|
RS_optim = _swigfaiss_gpu.ScalarQuantizer_RS_optim
|
|
__swig_setmethods__["rangestat"] = _swigfaiss_gpu.ScalarQuantizer_rangestat_set
|
|
__swig_getmethods__["rangestat"] = _swigfaiss_gpu.ScalarQuantizer_rangestat_get
|
|
if _newclass:rangestat = _swig_property(_swigfaiss_gpu.ScalarQuantizer_rangestat_get, _swigfaiss_gpu.ScalarQuantizer_rangestat_set)
|
|
__swig_setmethods__["rangestat_arg"] = _swigfaiss_gpu.ScalarQuantizer_rangestat_arg_set
|
|
__swig_getmethods__["rangestat_arg"] = _swigfaiss_gpu.ScalarQuantizer_rangestat_arg_get
|
|
if _newclass:rangestat_arg = _swig_property(_swigfaiss_gpu.ScalarQuantizer_rangestat_arg_get, _swigfaiss_gpu.ScalarQuantizer_rangestat_arg_set)
|
|
__swig_setmethods__["d"] = _swigfaiss_gpu.ScalarQuantizer_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss_gpu.ScalarQuantizer_d_get
|
|
if _newclass:d = _swig_property(_swigfaiss_gpu.ScalarQuantizer_d_get, _swigfaiss_gpu.ScalarQuantizer_d_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss_gpu.ScalarQuantizer_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss_gpu.ScalarQuantizer_code_size_get
|
|
if _newclass:code_size = _swig_property(_swigfaiss_gpu.ScalarQuantizer_code_size_get, _swigfaiss_gpu.ScalarQuantizer_code_size_set)
|
|
__swig_setmethods__["trained"] = _swigfaiss_gpu.ScalarQuantizer_trained_set
|
|
__swig_getmethods__["trained"] = _swigfaiss_gpu.ScalarQuantizer_trained_get
|
|
if _newclass:trained = _swig_property(_swigfaiss_gpu.ScalarQuantizer_trained_get, _swigfaiss_gpu.ScalarQuantizer_trained_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_ScalarQuantizer(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def train(self, *args): return _swigfaiss_gpu.ScalarQuantizer_train(self, *args)
|
|
def compute_codes(self, *args): return _swigfaiss_gpu.ScalarQuantizer_compute_codes(self, *args)
|
|
def decode(self, *args): return _swigfaiss_gpu.ScalarQuantizer_decode(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_ScalarQuantizer
|
|
__del__ = lambda self : None;
|
|
ScalarQuantizer_swigregister = _swigfaiss_gpu.ScalarQuantizer_swigregister
|
|
ScalarQuantizer_swigregister(ScalarQuantizer)
|
|
|
|
class IndexScalarQuantizer(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexScalarQuantizer, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexScalarQuantizer, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["sq"] = _swigfaiss_gpu.IndexScalarQuantizer_sq_set
|
|
__swig_getmethods__["sq"] = _swigfaiss_gpu.IndexScalarQuantizer_sq_get
|
|
if _newclass:sq = _swig_property(_swigfaiss_gpu.IndexScalarQuantizer_sq_get, _swigfaiss_gpu.IndexScalarQuantizer_sq_set)
|
|
__swig_setmethods__["codes"] = _swigfaiss_gpu.IndexScalarQuantizer_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss_gpu.IndexScalarQuantizer_codes_get
|
|
if _newclass:codes = _swig_property(_swigfaiss_gpu.IndexScalarQuantizer_codes_get, _swigfaiss_gpu.IndexScalarQuantizer_codes_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss_gpu.IndexScalarQuantizer_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss_gpu.IndexScalarQuantizer_code_size_get
|
|
if _newclass:code_size = _swig_property(_swigfaiss_gpu.IndexScalarQuantizer_code_size_get, _swigfaiss_gpu.IndexScalarQuantizer_code_size_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexScalarQuantizer(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def train(self, *args): return _swigfaiss_gpu.IndexScalarQuantizer_train(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexScalarQuantizer_add(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexScalarQuantizer_search(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexScalarQuantizer_reset(self)
|
|
def reconstruct_n(self, *args): return _swigfaiss_gpu.IndexScalarQuantizer_reconstruct_n(self, *args)
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.IndexScalarQuantizer_reconstruct(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexScalarQuantizer
|
|
__del__ = lambda self : None;
|
|
IndexScalarQuantizer_swigregister = _swigfaiss_gpu.IndexScalarQuantizer_swigregister
|
|
IndexScalarQuantizer_swigregister(IndexScalarQuantizer)
|
|
|
|
class IndexIVFScalarQuantizer(IndexIVF):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexIVF]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVFScalarQuantizer, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexIVF]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVFScalarQuantizer, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["sq"] = _swigfaiss_gpu.IndexIVFScalarQuantizer_sq_set
|
|
__swig_getmethods__["sq"] = _swigfaiss_gpu.IndexIVFScalarQuantizer_sq_get
|
|
if _newclass:sq = _swig_property(_swigfaiss_gpu.IndexIVFScalarQuantizer_sq_get, _swigfaiss_gpu.IndexIVFScalarQuantizer_sq_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexIVFScalarQuantizer(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def train_residual(self, *args): return _swigfaiss_gpu.IndexIVFScalarQuantizer_train_residual(self, *args)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.IndexIVFScalarQuantizer_add_with_ids(self, *args)
|
|
def search_preassigned(self, *args): return _swigfaiss_gpu.IndexIVFScalarQuantizer_search_preassigned(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIVFScalarQuantizer
|
|
__del__ = lambda self : None;
|
|
IndexIVFScalarQuantizer_swigregister = _swigfaiss_gpu.IndexIVFScalarQuantizer_swigregister
|
|
IndexIVFScalarQuantizer_swigregister(IndexIVFScalarQuantizer)
|
|
|
|
class IndexIVFPQ(IndexIVF):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexIVF]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVFPQ, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexIVF]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVFPQ, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["by_residual"] = _swigfaiss_gpu.IndexIVFPQ_by_residual_set
|
|
__swig_getmethods__["by_residual"] = _swigfaiss_gpu.IndexIVFPQ_by_residual_get
|
|
if _newclass:by_residual = _swig_property(_swigfaiss_gpu.IndexIVFPQ_by_residual_get, _swigfaiss_gpu.IndexIVFPQ_by_residual_set)
|
|
__swig_setmethods__["use_precomputed_table"] = _swigfaiss_gpu.IndexIVFPQ_use_precomputed_table_set
|
|
__swig_getmethods__["use_precomputed_table"] = _swigfaiss_gpu.IndexIVFPQ_use_precomputed_table_get
|
|
if _newclass:use_precomputed_table = _swig_property(_swigfaiss_gpu.IndexIVFPQ_use_precomputed_table_get, _swigfaiss_gpu.IndexIVFPQ_use_precomputed_table_set)
|
|
__swig_setmethods__["pq"] = _swigfaiss_gpu.IndexIVFPQ_pq_set
|
|
__swig_getmethods__["pq"] = _swigfaiss_gpu.IndexIVFPQ_pq_get
|
|
if _newclass:pq = _swig_property(_swigfaiss_gpu.IndexIVFPQ_pq_get, _swigfaiss_gpu.IndexIVFPQ_pq_set)
|
|
__swig_setmethods__["do_polysemous_training"] = _swigfaiss_gpu.IndexIVFPQ_do_polysemous_training_set
|
|
__swig_getmethods__["do_polysemous_training"] = _swigfaiss_gpu.IndexIVFPQ_do_polysemous_training_get
|
|
if _newclass:do_polysemous_training = _swig_property(_swigfaiss_gpu.IndexIVFPQ_do_polysemous_training_get, _swigfaiss_gpu.IndexIVFPQ_do_polysemous_training_set)
|
|
__swig_setmethods__["polysemous_training"] = _swigfaiss_gpu.IndexIVFPQ_polysemous_training_set
|
|
__swig_getmethods__["polysemous_training"] = _swigfaiss_gpu.IndexIVFPQ_polysemous_training_get
|
|
if _newclass:polysemous_training = _swig_property(_swigfaiss_gpu.IndexIVFPQ_polysemous_training_get, _swigfaiss_gpu.IndexIVFPQ_polysemous_training_set)
|
|
__swig_setmethods__["scan_table_threshold"] = _swigfaiss_gpu.IndexIVFPQ_scan_table_threshold_set
|
|
__swig_getmethods__["scan_table_threshold"] = _swigfaiss_gpu.IndexIVFPQ_scan_table_threshold_get
|
|
if _newclass:scan_table_threshold = _swig_property(_swigfaiss_gpu.IndexIVFPQ_scan_table_threshold_get, _swigfaiss_gpu.IndexIVFPQ_scan_table_threshold_set)
|
|
__swig_setmethods__["max_codes"] = _swigfaiss_gpu.IndexIVFPQ_max_codes_set
|
|
__swig_getmethods__["max_codes"] = _swigfaiss_gpu.IndexIVFPQ_max_codes_get
|
|
if _newclass:max_codes = _swig_property(_swigfaiss_gpu.IndexIVFPQ_max_codes_get, _swigfaiss_gpu.IndexIVFPQ_max_codes_set)
|
|
__swig_setmethods__["polysemous_ht"] = _swigfaiss_gpu.IndexIVFPQ_polysemous_ht_set
|
|
__swig_getmethods__["polysemous_ht"] = _swigfaiss_gpu.IndexIVFPQ_polysemous_ht_get
|
|
if _newclass:polysemous_ht = _swig_property(_swigfaiss_gpu.IndexIVFPQ_polysemous_ht_get, _swigfaiss_gpu.IndexIVFPQ_polysemous_ht_set)
|
|
__swig_setmethods__["precomputed_table"] = _swigfaiss_gpu.IndexIVFPQ_precomputed_table_set
|
|
__swig_getmethods__["precomputed_table"] = _swigfaiss_gpu.IndexIVFPQ_precomputed_table_get
|
|
if _newclass:precomputed_table = _swig_property(_swigfaiss_gpu.IndexIVFPQ_precomputed_table_get, _swigfaiss_gpu.IndexIVFPQ_precomputed_table_set)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.IndexIVFPQ_add_with_ids(self, *args)
|
|
def add_core_o(self, *args): return _swigfaiss_gpu.IndexIVFPQ_add_core_o(self, *args)
|
|
def train_residual(self, *args): return _swigfaiss_gpu.IndexIVFPQ_train_residual(self, *args)
|
|
def train_residual_o(self, *args): return _swigfaiss_gpu.IndexIVFPQ_train_residual_o(self, *args)
|
|
def reconstruct_n(self, *args): return _swigfaiss_gpu.IndexIVFPQ_reconstruct_n(self, *args)
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.IndexIVFPQ_reconstruct(self, *args)
|
|
def find_duplicates(self, *args): return _swigfaiss_gpu.IndexIVFPQ_find_duplicates(self, *args)
|
|
def encode(self, *args): return _swigfaiss_gpu.IndexIVFPQ_encode(self, *args)
|
|
def encode_multiple(self, *args): return _swigfaiss_gpu.IndexIVFPQ_encode_multiple(self, *args)
|
|
def decode_multiple(self, *args): return _swigfaiss_gpu.IndexIVFPQ_decode_multiple(self, *args)
|
|
def search_preassigned(self, *args): return _swigfaiss_gpu.IndexIVFPQ_search_preassigned(self, *args)
|
|
def search_and_reconstruct(self, *args): return _swigfaiss_gpu.IndexIVFPQ_search_and_reconstruct(self, *args)
|
|
def precompute_table(self): return _swigfaiss_gpu.IndexIVFPQ_precompute_table(self)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexIVFPQ(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIVFPQ
|
|
__del__ = lambda self : None;
|
|
IndexIVFPQ_swigregister = _swigfaiss_gpu.IndexIVFPQ_swigregister
|
|
IndexIVFPQ_swigregister(IndexIVFPQ)
|
|
|
|
class IndexIVFPQStats(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVFPQStats, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVFPQStats, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nq"] = _swigfaiss_gpu.IndexIVFPQStats_nq_set
|
|
__swig_getmethods__["nq"] = _swigfaiss_gpu.IndexIVFPQStats_nq_get
|
|
if _newclass:nq = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_nq_get, _swigfaiss_gpu.IndexIVFPQStats_nq_set)
|
|
__swig_setmethods__["nlist"] = _swigfaiss_gpu.IndexIVFPQStats_nlist_set
|
|
__swig_getmethods__["nlist"] = _swigfaiss_gpu.IndexIVFPQStats_nlist_get
|
|
if _newclass:nlist = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_nlist_get, _swigfaiss_gpu.IndexIVFPQStats_nlist_set)
|
|
__swig_setmethods__["ncode"] = _swigfaiss_gpu.IndexIVFPQStats_ncode_set
|
|
__swig_getmethods__["ncode"] = _swigfaiss_gpu.IndexIVFPQStats_ncode_get
|
|
if _newclass:ncode = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_ncode_get, _swigfaiss_gpu.IndexIVFPQStats_ncode_set)
|
|
__swig_setmethods__["nrefine"] = _swigfaiss_gpu.IndexIVFPQStats_nrefine_set
|
|
__swig_getmethods__["nrefine"] = _swigfaiss_gpu.IndexIVFPQStats_nrefine_get
|
|
if _newclass:nrefine = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_nrefine_get, _swigfaiss_gpu.IndexIVFPQStats_nrefine_set)
|
|
__swig_setmethods__["n_hamming_pass"] = _swigfaiss_gpu.IndexIVFPQStats_n_hamming_pass_set
|
|
__swig_getmethods__["n_hamming_pass"] = _swigfaiss_gpu.IndexIVFPQStats_n_hamming_pass_get
|
|
if _newclass:n_hamming_pass = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_n_hamming_pass_get, _swigfaiss_gpu.IndexIVFPQStats_n_hamming_pass_set)
|
|
__swig_setmethods__["assign_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_assign_cycles_set
|
|
__swig_getmethods__["assign_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_assign_cycles_get
|
|
if _newclass:assign_cycles = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_assign_cycles_get, _swigfaiss_gpu.IndexIVFPQStats_assign_cycles_set)
|
|
__swig_setmethods__["search_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_search_cycles_set
|
|
__swig_getmethods__["search_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_search_cycles_get
|
|
if _newclass:search_cycles = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_search_cycles_get, _swigfaiss_gpu.IndexIVFPQStats_search_cycles_set)
|
|
__swig_setmethods__["refine_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_refine_cycles_set
|
|
__swig_getmethods__["refine_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_refine_cycles_get
|
|
if _newclass:refine_cycles = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_refine_cycles_get, _swigfaiss_gpu.IndexIVFPQStats_refine_cycles_set)
|
|
__swig_setmethods__["init_query_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_init_query_cycles_set
|
|
__swig_getmethods__["init_query_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_init_query_cycles_get
|
|
if _newclass:init_query_cycles = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_init_query_cycles_get, _swigfaiss_gpu.IndexIVFPQStats_init_query_cycles_set)
|
|
__swig_setmethods__["init_list_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_init_list_cycles_set
|
|
__swig_getmethods__["init_list_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_init_list_cycles_get
|
|
if _newclass:init_list_cycles = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_init_list_cycles_get, _swigfaiss_gpu.IndexIVFPQStats_init_list_cycles_set)
|
|
__swig_setmethods__["scan_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_scan_cycles_set
|
|
__swig_getmethods__["scan_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_scan_cycles_get
|
|
if _newclass:scan_cycles = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_scan_cycles_get, _swigfaiss_gpu.IndexIVFPQStats_scan_cycles_set)
|
|
__swig_setmethods__["heap_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_heap_cycles_set
|
|
__swig_getmethods__["heap_cycles"] = _swigfaiss_gpu.IndexIVFPQStats_heap_cycles_get
|
|
if _newclass:heap_cycles = _swig_property(_swigfaiss_gpu.IndexIVFPQStats_heap_cycles_get, _swigfaiss_gpu.IndexIVFPQStats_heap_cycles_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_IndexIVFPQStats()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def reset(self): return _swigfaiss_gpu.IndexIVFPQStats_reset(self)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIVFPQStats
|
|
__del__ = lambda self : None;
|
|
IndexIVFPQStats_swigregister = _swigfaiss_gpu.IndexIVFPQStats_swigregister
|
|
IndexIVFPQStats_swigregister(IndexIVFPQStats)
|
|
|
|
class IndexIVFPQR(IndexIVFPQ):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexIVFPQ]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVFPQR, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexIVFPQ]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVFPQR, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["refine_pq"] = _swigfaiss_gpu.IndexIVFPQR_refine_pq_set
|
|
__swig_getmethods__["refine_pq"] = _swigfaiss_gpu.IndexIVFPQR_refine_pq_get
|
|
if _newclass:refine_pq = _swig_property(_swigfaiss_gpu.IndexIVFPQR_refine_pq_get, _swigfaiss_gpu.IndexIVFPQR_refine_pq_set)
|
|
__swig_setmethods__["refine_codes"] = _swigfaiss_gpu.IndexIVFPQR_refine_codes_set
|
|
__swig_getmethods__["refine_codes"] = _swigfaiss_gpu.IndexIVFPQR_refine_codes_get
|
|
if _newclass:refine_codes = _swig_property(_swigfaiss_gpu.IndexIVFPQR_refine_codes_get, _swigfaiss_gpu.IndexIVFPQR_refine_codes_set)
|
|
__swig_setmethods__["k_factor"] = _swigfaiss_gpu.IndexIVFPQR_k_factor_set
|
|
__swig_getmethods__["k_factor"] = _swigfaiss_gpu.IndexIVFPQR_k_factor_get
|
|
if _newclass:k_factor = _swig_property(_swigfaiss_gpu.IndexIVFPQR_k_factor_get, _swigfaiss_gpu.IndexIVFPQR_k_factor_set)
|
|
def reset(self): return _swigfaiss_gpu.IndexIVFPQR_reset(self)
|
|
def remove_ids(self, *args): return _swigfaiss_gpu.IndexIVFPQR_remove_ids(self, *args)
|
|
def train_residual(self, *args): return _swigfaiss_gpu.IndexIVFPQR_train_residual(self, *args)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.IndexIVFPQR_add_with_ids(self, *args)
|
|
def add_core(self, *args): return _swigfaiss_gpu.IndexIVFPQR_add_core(self, *args)
|
|
def reconstruct_n(self, *args): return _swigfaiss_gpu.IndexIVFPQR_reconstruct_n(self, *args)
|
|
def merge_from(self, *args): return _swigfaiss_gpu.IndexIVFPQR_merge_from(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexIVFPQR_search(self, *args)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexIVFPQR(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIVFPQR
|
|
__del__ = lambda self : None;
|
|
IndexIVFPQR_swigregister = _swigfaiss_gpu.IndexIVFPQR_swigregister
|
|
IndexIVFPQR_swigregister(IndexIVFPQR)
|
|
|
|
class IndexIVFPQCompact(IndexIVFPQ):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexIVFPQ]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVFPQCompact, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexIVFPQ]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVFPQCompact, name)
|
|
__repr__ = _swig_repr
|
|
Alloc_type_none = _swigfaiss_gpu.IndexIVFPQCompact_Alloc_type_none
|
|
Alloc_type_new = _swigfaiss_gpu.IndexIVFPQCompact_Alloc_type_new
|
|
Alloc_type_mmap = _swigfaiss_gpu.IndexIVFPQCompact_Alloc_type_mmap
|
|
__swig_setmethods__["limits"] = _swigfaiss_gpu.IndexIVFPQCompact_limits_set
|
|
__swig_getmethods__["limits"] = _swigfaiss_gpu.IndexIVFPQCompact_limits_get
|
|
if _newclass:limits = _swig_property(_swigfaiss_gpu.IndexIVFPQCompact_limits_get, _swigfaiss_gpu.IndexIVFPQCompact_limits_set)
|
|
__swig_setmethods__["compact_ids"] = _swigfaiss_gpu.IndexIVFPQCompact_compact_ids_set
|
|
__swig_getmethods__["compact_ids"] = _swigfaiss_gpu.IndexIVFPQCompact_compact_ids_get
|
|
if _newclass:compact_ids = _swig_property(_swigfaiss_gpu.IndexIVFPQCompact_compact_ids_get, _swigfaiss_gpu.IndexIVFPQCompact_compact_ids_set)
|
|
__swig_setmethods__["compact_codes"] = _swigfaiss_gpu.IndexIVFPQCompact_compact_codes_set
|
|
__swig_getmethods__["compact_codes"] = _swigfaiss_gpu.IndexIVFPQCompact_compact_codes_get
|
|
if _newclass:compact_codes = _swig_property(_swigfaiss_gpu.IndexIVFPQCompact_compact_codes_get, _swigfaiss_gpu.IndexIVFPQCompact_compact_codes_set)
|
|
__swig_setmethods__["mmap_buffer"] = _swigfaiss_gpu.IndexIVFPQCompact_mmap_buffer_set
|
|
__swig_getmethods__["mmap_buffer"] = _swigfaiss_gpu.IndexIVFPQCompact_mmap_buffer_get
|
|
if _newclass:mmap_buffer = _swig_property(_swigfaiss_gpu.IndexIVFPQCompact_mmap_buffer_get, _swigfaiss_gpu.IndexIVFPQCompact_mmap_buffer_set)
|
|
__swig_setmethods__["mmap_length"] = _swigfaiss_gpu.IndexIVFPQCompact_mmap_length_set
|
|
__swig_getmethods__["mmap_length"] = _swigfaiss_gpu.IndexIVFPQCompact_mmap_length_get
|
|
if _newclass:mmap_length = _swig_property(_swigfaiss_gpu.IndexIVFPQCompact_mmap_length_get, _swigfaiss_gpu.IndexIVFPQCompact_mmap_length_set)
|
|
def search_preassigned(self, *args): return _swigfaiss_gpu.IndexIVFPQCompact_search_preassigned(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexIVFPQCompact_add(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexIVFPQCompact_reset(self)
|
|
def train(self, *args): return _swigfaiss_gpu.IndexIVFPQCompact_train(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIVFPQCompact
|
|
__del__ = lambda self : None;
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexIVFPQCompact(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
IndexIVFPQCompact_swigregister = _swigfaiss_gpu.IndexIVFPQCompact_swigregister
|
|
IndexIVFPQCompact_swigregister(IndexIVFPQCompact)
|
|
|
|
class IndexIDMap(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIDMap, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIDMap, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["index"] = _swigfaiss_gpu.IndexIDMap_index_set
|
|
__swig_getmethods__["index"] = _swigfaiss_gpu.IndexIDMap_index_get
|
|
if _newclass:index = _swig_property(_swigfaiss_gpu.IndexIDMap_index_get, _swigfaiss_gpu.IndexIDMap_index_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss_gpu.IndexIDMap_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss_gpu.IndexIDMap_own_fields_get
|
|
if _newclass:own_fields = _swig_property(_swigfaiss_gpu.IndexIDMap_own_fields_get, _swigfaiss_gpu.IndexIDMap_own_fields_set)
|
|
__swig_setmethods__["id_map"] = _swigfaiss_gpu.IndexIDMap_id_map_set
|
|
__swig_getmethods__["id_map"] = _swigfaiss_gpu.IndexIDMap_id_map_get
|
|
if _newclass:id_map = _swig_property(_swigfaiss_gpu.IndexIDMap_id_map_get, _swigfaiss_gpu.IndexIDMap_id_map_set)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.IndexIDMap_add_with_ids(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexIDMap_add(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexIDMap_search(self, *args)
|
|
def train(self, *args): return _swigfaiss_gpu.IndexIDMap_train(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexIDMap_reset(self)
|
|
def remove_ids(self, *args): return _swigfaiss_gpu.IndexIDMap_remove_ids(self, *args)
|
|
def range_search(self, *args): return _swigfaiss_gpu.IndexIDMap_range_search(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIDMap
|
|
__del__ = lambda self : None;
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexIDMap(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
IndexIDMap_swigregister = _swigfaiss_gpu.IndexIDMap_swigregister
|
|
IndexIDMap_swigregister(IndexIDMap)
|
|
|
|
class IndexIDMap2(IndexIDMap):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexIDMap]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIDMap2, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexIDMap]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIDMap2, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["rev_map"] = _swigfaiss_gpu.IndexIDMap2_rev_map_set
|
|
__swig_getmethods__["rev_map"] = _swigfaiss_gpu.IndexIDMap2_rev_map_get
|
|
if _newclass:rev_map = _swig_property(_swigfaiss_gpu.IndexIDMap2_rev_map_get, _swigfaiss_gpu.IndexIDMap2_rev_map_set)
|
|
def construct_rev_map(self): return _swigfaiss_gpu.IndexIDMap2_construct_rev_map(self)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.IndexIDMap2_add_with_ids(self, *args)
|
|
def remove_ids(self, *args): return _swigfaiss_gpu.IndexIDMap2_remove_ids(self, *args)
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.IndexIDMap2_reconstruct(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexIDMap2
|
|
__del__ = lambda self : None;
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexIDMap2(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
IndexIDMap2_swigregister = _swigfaiss_gpu.IndexIDMap2_swigregister
|
|
IndexIDMap2_swigregister(IndexIDMap2)
|
|
|
|
class IndexShards(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexShards, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexShards, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["shard_indexes"] = _swigfaiss_gpu.IndexShards_shard_indexes_set
|
|
__swig_getmethods__["shard_indexes"] = _swigfaiss_gpu.IndexShards_shard_indexes_get
|
|
if _newclass:shard_indexes = _swig_property(_swigfaiss_gpu.IndexShards_shard_indexes_get, _swigfaiss_gpu.IndexShards_shard_indexes_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss_gpu.IndexShards_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss_gpu.IndexShards_own_fields_get
|
|
if _newclass:own_fields = _swig_property(_swigfaiss_gpu.IndexShards_own_fields_get, _swigfaiss_gpu.IndexShards_own_fields_set)
|
|
__swig_setmethods__["threaded"] = _swigfaiss_gpu.IndexShards_threaded_set
|
|
__swig_getmethods__["threaded"] = _swigfaiss_gpu.IndexShards_threaded_get
|
|
if _newclass:threaded = _swig_property(_swigfaiss_gpu.IndexShards_threaded_get, _swigfaiss_gpu.IndexShards_threaded_set)
|
|
__swig_setmethods__["successive_ids"] = _swigfaiss_gpu.IndexShards_successive_ids_set
|
|
__swig_getmethods__["successive_ids"] = _swigfaiss_gpu.IndexShards_successive_ids_get
|
|
if _newclass:successive_ids = _swig_property(_swigfaiss_gpu.IndexShards_successive_ids_get, _swigfaiss_gpu.IndexShards_successive_ids_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexShards(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def add_shard(self, *args): return _swigfaiss_gpu.IndexShards_add_shard(self, *args)
|
|
def sync_with_shard_indexes(self): return _swigfaiss_gpu.IndexShards_sync_with_shard_indexes(self)
|
|
def at(self, *args): return _swigfaiss_gpu.IndexShards_at(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexShards_add(self, *args)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.IndexShards_add_with_ids(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexShards_search(self, *args)
|
|
def train(self, *args): return _swigfaiss_gpu.IndexShards_train(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexShards_reset(self)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexShards
|
|
__del__ = lambda self : None;
|
|
IndexShards_swigregister = _swigfaiss_gpu.IndexShards_swigregister
|
|
IndexShards_swigregister(IndexShards)
|
|
|
|
class IndexSplitVectors(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexSplitVectors, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexSplitVectors, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["own_fields"] = _swigfaiss_gpu.IndexSplitVectors_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss_gpu.IndexSplitVectors_own_fields_get
|
|
if _newclass:own_fields = _swig_property(_swigfaiss_gpu.IndexSplitVectors_own_fields_get, _swigfaiss_gpu.IndexSplitVectors_own_fields_set)
|
|
__swig_setmethods__["threaded"] = _swigfaiss_gpu.IndexSplitVectors_threaded_set
|
|
__swig_getmethods__["threaded"] = _swigfaiss_gpu.IndexSplitVectors_threaded_get
|
|
if _newclass:threaded = _swig_property(_swigfaiss_gpu.IndexSplitVectors_threaded_get, _swigfaiss_gpu.IndexSplitVectors_threaded_set)
|
|
__swig_setmethods__["sub_indexes"] = _swigfaiss_gpu.IndexSplitVectors_sub_indexes_set
|
|
__swig_getmethods__["sub_indexes"] = _swigfaiss_gpu.IndexSplitVectors_sub_indexes_get
|
|
if _newclass:sub_indexes = _swig_property(_swigfaiss_gpu.IndexSplitVectors_sub_indexes_get, _swigfaiss_gpu.IndexSplitVectors_sub_indexes_set)
|
|
__swig_setmethods__["sum_d"] = _swigfaiss_gpu.IndexSplitVectors_sum_d_set
|
|
__swig_getmethods__["sum_d"] = _swigfaiss_gpu.IndexSplitVectors_sum_d_get
|
|
if _newclass:sum_d = _swig_property(_swigfaiss_gpu.IndexSplitVectors_sum_d_get, _swigfaiss_gpu.IndexSplitVectors_sum_d_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IndexSplitVectors(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def add_sub_index(self, *args): return _swigfaiss_gpu.IndexSplitVectors_add_sub_index(self, *args)
|
|
def sync_with_sub_indexes(self): return _swigfaiss_gpu.IndexSplitVectors_sync_with_sub_indexes(self)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexSplitVectors_add(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexSplitVectors_search(self, *args)
|
|
def train(self, *args): return _swigfaiss_gpu.IndexSplitVectors_train(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexSplitVectors_reset(self)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexSplitVectors
|
|
__del__ = lambda self : None;
|
|
IndexSplitVectors_swigregister = _swigfaiss_gpu.IndexSplitVectors_swigregister
|
|
IndexSplitVectors_swigregister(IndexSplitVectors)
|
|
|
|
INDICES_CPU = _swigfaiss_gpu.INDICES_CPU
|
|
INDICES_IVF = _swigfaiss_gpu.INDICES_IVF
|
|
INDICES_32_BIT = _swigfaiss_gpu.INDICES_32_BIT
|
|
INDICES_64_BIT = _swigfaiss_gpu.INDICES_64_BIT
|
|
class GpuClonerOptions(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuClonerOptions, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuClonerOptions, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_GpuClonerOptions()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["indicesOptions"] = _swigfaiss_gpu.GpuClonerOptions_indicesOptions_set
|
|
__swig_getmethods__["indicesOptions"] = _swigfaiss_gpu.GpuClonerOptions_indicesOptions_get
|
|
if _newclass:indicesOptions = _swig_property(_swigfaiss_gpu.GpuClonerOptions_indicesOptions_get, _swigfaiss_gpu.GpuClonerOptions_indicesOptions_set)
|
|
__swig_setmethods__["useFloat16CoarseQuantizer"] = _swigfaiss_gpu.GpuClonerOptions_useFloat16CoarseQuantizer_set
|
|
__swig_getmethods__["useFloat16CoarseQuantizer"] = _swigfaiss_gpu.GpuClonerOptions_useFloat16CoarseQuantizer_get
|
|
if _newclass:useFloat16CoarseQuantizer = _swig_property(_swigfaiss_gpu.GpuClonerOptions_useFloat16CoarseQuantizer_get, _swigfaiss_gpu.GpuClonerOptions_useFloat16CoarseQuantizer_set)
|
|
__swig_setmethods__["useFloat16"] = _swigfaiss_gpu.GpuClonerOptions_useFloat16_set
|
|
__swig_getmethods__["useFloat16"] = _swigfaiss_gpu.GpuClonerOptions_useFloat16_get
|
|
if _newclass:useFloat16 = _swig_property(_swigfaiss_gpu.GpuClonerOptions_useFloat16_get, _swigfaiss_gpu.GpuClonerOptions_useFloat16_set)
|
|
__swig_setmethods__["usePrecomputed"] = _swigfaiss_gpu.GpuClonerOptions_usePrecomputed_set
|
|
__swig_getmethods__["usePrecomputed"] = _swigfaiss_gpu.GpuClonerOptions_usePrecomputed_get
|
|
if _newclass:usePrecomputed = _swig_property(_swigfaiss_gpu.GpuClonerOptions_usePrecomputed_get, _swigfaiss_gpu.GpuClonerOptions_usePrecomputed_set)
|
|
__swig_setmethods__["reserveVecs"] = _swigfaiss_gpu.GpuClonerOptions_reserveVecs_set
|
|
__swig_getmethods__["reserveVecs"] = _swigfaiss_gpu.GpuClonerOptions_reserveVecs_get
|
|
if _newclass:reserveVecs = _swig_property(_swigfaiss_gpu.GpuClonerOptions_reserveVecs_get, _swigfaiss_gpu.GpuClonerOptions_reserveVecs_set)
|
|
__swig_setmethods__["storeTransposed"] = _swigfaiss_gpu.GpuClonerOptions_storeTransposed_set
|
|
__swig_getmethods__["storeTransposed"] = _swigfaiss_gpu.GpuClonerOptions_storeTransposed_get
|
|
if _newclass:storeTransposed = _swig_property(_swigfaiss_gpu.GpuClonerOptions_storeTransposed_get, _swigfaiss_gpu.GpuClonerOptions_storeTransposed_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss_gpu.GpuClonerOptions_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss_gpu.GpuClonerOptions_verbose_get
|
|
if _newclass:verbose = _swig_property(_swigfaiss_gpu.GpuClonerOptions_verbose_get, _swigfaiss_gpu.GpuClonerOptions_verbose_set)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuClonerOptions
|
|
__del__ = lambda self : None;
|
|
GpuClonerOptions_swigregister = _swigfaiss_gpu.GpuClonerOptions_swigregister
|
|
GpuClonerOptions_swigregister(GpuClonerOptions)
|
|
|
|
class GpuMultipleClonerOptions(GpuClonerOptions):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuClonerOptions]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuMultipleClonerOptions, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuClonerOptions]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuMultipleClonerOptions, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_GpuMultipleClonerOptions()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["shard"] = _swigfaiss_gpu.GpuMultipleClonerOptions_shard_set
|
|
__swig_getmethods__["shard"] = _swigfaiss_gpu.GpuMultipleClonerOptions_shard_get
|
|
if _newclass:shard = _swig_property(_swigfaiss_gpu.GpuMultipleClonerOptions_shard_get, _swigfaiss_gpu.GpuMultipleClonerOptions_shard_set)
|
|
__swig_setmethods__["shard_type"] = _swigfaiss_gpu.GpuMultipleClonerOptions_shard_type_set
|
|
__swig_getmethods__["shard_type"] = _swigfaiss_gpu.GpuMultipleClonerOptions_shard_type_get
|
|
if _newclass:shard_type = _swig_property(_swigfaiss_gpu.GpuMultipleClonerOptions_shard_type_get, _swigfaiss_gpu.GpuMultipleClonerOptions_shard_type_set)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuMultipleClonerOptions
|
|
__del__ = lambda self : None;
|
|
GpuMultipleClonerOptions_swigregister = _swigfaiss_gpu.GpuMultipleClonerOptions_swigregister
|
|
GpuMultipleClonerOptions_swigregister(GpuMultipleClonerOptions)
|
|
|
|
Device = _swigfaiss_gpu.Device
|
|
Unified = _swigfaiss_gpu.Unified
|
|
|
|
def allocMemorySpace(*args):
|
|
return _swigfaiss_gpu.allocMemorySpace(*args)
|
|
allocMemorySpace = _swigfaiss_gpu.allocMemorySpace
|
|
class GpuIndexConfig(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexConfig, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexConfig, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_GpuIndexConfig()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["device"] = _swigfaiss_gpu.GpuIndexConfig_device_set
|
|
__swig_getmethods__["device"] = _swigfaiss_gpu.GpuIndexConfig_device_get
|
|
if _newclass:device = _swig_property(_swigfaiss_gpu.GpuIndexConfig_device_get, _swigfaiss_gpu.GpuIndexConfig_device_set)
|
|
__swig_setmethods__["memorySpace"] = _swigfaiss_gpu.GpuIndexConfig_memorySpace_set
|
|
__swig_getmethods__["memorySpace"] = _swigfaiss_gpu.GpuIndexConfig_memorySpace_get
|
|
if _newclass:memorySpace = _swig_property(_swigfaiss_gpu.GpuIndexConfig_memorySpace_get, _swigfaiss_gpu.GpuIndexConfig_memorySpace_set)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexConfig
|
|
__del__ = lambda self : None;
|
|
GpuIndexConfig_swigregister = _swigfaiss_gpu.GpuIndexConfig_swigregister
|
|
GpuIndexConfig_swigregister(GpuIndexConfig)
|
|
|
|
class GpuIndex(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndex, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndex, name)
|
|
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
def getDevice(self): return _swigfaiss_gpu.GpuIndex_getDevice(self)
|
|
def getResources(self): return _swigfaiss_gpu.GpuIndex_getResources(self)
|
|
def add(self, *args): return _swigfaiss_gpu.GpuIndex_add(self, *args)
|
|
def add_with_ids(self, *args): return _swigfaiss_gpu.GpuIndex_add_with_ids(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.GpuIndex_search(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndex
|
|
__del__ = lambda self : None;
|
|
GpuIndex_swigregister = _swigfaiss_gpu.GpuIndex_swigregister
|
|
GpuIndex_swigregister(GpuIndex)
|
|
|
|
class GpuIndexFlatConfig(GpuIndexConfig):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndexConfig]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexFlatConfig, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndexConfig]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexFlatConfig, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_GpuIndexFlatConfig()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["useFloat16"] = _swigfaiss_gpu.GpuIndexFlatConfig_useFloat16_set
|
|
__swig_getmethods__["useFloat16"] = _swigfaiss_gpu.GpuIndexFlatConfig_useFloat16_get
|
|
if _newclass:useFloat16 = _swig_property(_swigfaiss_gpu.GpuIndexFlatConfig_useFloat16_get, _swigfaiss_gpu.GpuIndexFlatConfig_useFloat16_set)
|
|
__swig_setmethods__["useFloat16Accumulator"] = _swigfaiss_gpu.GpuIndexFlatConfig_useFloat16Accumulator_set
|
|
__swig_getmethods__["useFloat16Accumulator"] = _swigfaiss_gpu.GpuIndexFlatConfig_useFloat16Accumulator_get
|
|
if _newclass:useFloat16Accumulator = _swig_property(_swigfaiss_gpu.GpuIndexFlatConfig_useFloat16Accumulator_get, _swigfaiss_gpu.GpuIndexFlatConfig_useFloat16Accumulator_set)
|
|
__swig_setmethods__["storeTransposed"] = _swigfaiss_gpu.GpuIndexFlatConfig_storeTransposed_set
|
|
__swig_getmethods__["storeTransposed"] = _swigfaiss_gpu.GpuIndexFlatConfig_storeTransposed_get
|
|
if _newclass:storeTransposed = _swig_property(_swigfaiss_gpu.GpuIndexFlatConfig_storeTransposed_get, _swigfaiss_gpu.GpuIndexFlatConfig_storeTransposed_set)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexFlatConfig
|
|
__del__ = lambda self : None;
|
|
GpuIndexFlatConfig_swigregister = _swigfaiss_gpu.GpuIndexFlatConfig_swigregister
|
|
GpuIndexFlatConfig_swigregister(GpuIndexFlatConfig)
|
|
|
|
class GpuIndexFlat(GpuIndex):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndex]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexFlat, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndex]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexFlat, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_GpuIndexFlat(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexFlat
|
|
__del__ = lambda self : None;
|
|
def setMinPagingSize(self, *args): return _swigfaiss_gpu.GpuIndexFlat_setMinPagingSize(self, *args)
|
|
def getMinPagingSize(self): return _swigfaiss_gpu.GpuIndexFlat_getMinPagingSize(self)
|
|
def copyFrom(self, *args): return _swigfaiss_gpu.GpuIndexFlat_copyFrom(self, *args)
|
|
def copyTo(self, *args): return _swigfaiss_gpu.GpuIndexFlat_copyTo(self, *args)
|
|
def getNumVecs(self): return _swigfaiss_gpu.GpuIndexFlat_getNumVecs(self)
|
|
def reset(self): return _swigfaiss_gpu.GpuIndexFlat_reset(self)
|
|
def train(self, *args): return _swigfaiss_gpu.GpuIndexFlat_train(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.GpuIndexFlat_add(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.GpuIndexFlat_search(self, *args)
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.GpuIndexFlat_reconstruct(self, *args)
|
|
def reconstruct_n(self, *args): return _swigfaiss_gpu.GpuIndexFlat_reconstruct_n(self, *args)
|
|
def getGpuData(self): return _swigfaiss_gpu.GpuIndexFlat_getGpuData(self)
|
|
GpuIndexFlat_swigregister = _swigfaiss_gpu.GpuIndexFlat_swigregister
|
|
GpuIndexFlat_swigregister(GpuIndexFlat)
|
|
|
|
class GpuIndexFlatL2(GpuIndexFlat):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndexFlat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexFlatL2, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndexFlat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexFlatL2, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_GpuIndexFlatL2(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def copyFrom(self, *args): return _swigfaiss_gpu.GpuIndexFlatL2_copyFrom(self, *args)
|
|
def copyTo(self, *args): return _swigfaiss_gpu.GpuIndexFlatL2_copyTo(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexFlatL2
|
|
__del__ = lambda self : None;
|
|
GpuIndexFlatL2_swigregister = _swigfaiss_gpu.GpuIndexFlatL2_swigregister
|
|
GpuIndexFlatL2_swigregister(GpuIndexFlatL2)
|
|
|
|
class GpuIndexFlatIP(GpuIndexFlat):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndexFlat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexFlatIP, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndexFlat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexFlatIP, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_GpuIndexFlatIP(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def copyFrom(self, *args): return _swigfaiss_gpu.GpuIndexFlatIP_copyFrom(self, *args)
|
|
def copyTo(self, *args): return _swigfaiss_gpu.GpuIndexFlatIP_copyTo(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexFlatIP
|
|
__del__ = lambda self : None;
|
|
GpuIndexFlatIP_swigregister = _swigfaiss_gpu.GpuIndexFlatIP_swigregister
|
|
GpuIndexFlatIP_swigregister(GpuIndexFlatIP)
|
|
|
|
class GpuIndexIVFConfig(GpuIndexConfig):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndexConfig]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexIVFConfig, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndexConfig]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexIVFConfig, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_GpuIndexIVFConfig()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["indicesOptions"] = _swigfaiss_gpu.GpuIndexIVFConfig_indicesOptions_set
|
|
__swig_getmethods__["indicesOptions"] = _swigfaiss_gpu.GpuIndexIVFConfig_indicesOptions_get
|
|
if _newclass:indicesOptions = _swig_property(_swigfaiss_gpu.GpuIndexIVFConfig_indicesOptions_get, _swigfaiss_gpu.GpuIndexIVFConfig_indicesOptions_set)
|
|
__swig_setmethods__["flatConfig"] = _swigfaiss_gpu.GpuIndexIVFConfig_flatConfig_set
|
|
__swig_getmethods__["flatConfig"] = _swigfaiss_gpu.GpuIndexIVFConfig_flatConfig_get
|
|
if _newclass:flatConfig = _swig_property(_swigfaiss_gpu.GpuIndexIVFConfig_flatConfig_get, _swigfaiss_gpu.GpuIndexIVFConfig_flatConfig_set)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexIVFConfig
|
|
__del__ = lambda self : None;
|
|
GpuIndexIVFConfig_swigregister = _swigfaiss_gpu.GpuIndexIVFConfig_swigregister
|
|
GpuIndexIVFConfig_swigregister(GpuIndexIVFConfig)
|
|
|
|
class GpuIndexIVF(GpuIndex):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndex]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexIVF, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndex]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexIVF, name)
|
|
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexIVF
|
|
__del__ = lambda self : None;
|
|
def copyFrom(self, *args): return _swigfaiss_gpu.GpuIndexIVF_copyFrom(self, *args)
|
|
def copyTo(self, *args): return _swigfaiss_gpu.GpuIndexIVF_copyTo(self, *args)
|
|
def getNumLists(self): return _swigfaiss_gpu.GpuIndexIVF_getNumLists(self)
|
|
def getQuantizer(self): return _swigfaiss_gpu.GpuIndexIVF_getQuantizer(self)
|
|
def setNumProbes(self, *args): return _swigfaiss_gpu.GpuIndexIVF_setNumProbes(self, *args)
|
|
def getNumProbes(self): return _swigfaiss_gpu.GpuIndexIVF_getNumProbes(self)
|
|
def add(self, *args): return _swigfaiss_gpu.GpuIndexIVF_add(self, *args)
|
|
__swig_setmethods__["cp"] = _swigfaiss_gpu.GpuIndexIVF_cp_set
|
|
__swig_getmethods__["cp"] = _swigfaiss_gpu.GpuIndexIVF_cp_get
|
|
if _newclass:cp = _swig_property(_swigfaiss_gpu.GpuIndexIVF_cp_get, _swigfaiss_gpu.GpuIndexIVF_cp_set)
|
|
GpuIndexIVF_swigregister = _swigfaiss_gpu.GpuIndexIVF_swigregister
|
|
GpuIndexIVF_swigregister(GpuIndexIVF)
|
|
|
|
class GpuIndexIVFPQConfig(GpuIndexIVFConfig):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndexIVFConfig]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexIVFPQConfig, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndexIVFConfig]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexIVFPQConfig, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_GpuIndexIVFPQConfig()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["useFloat16LookupTables"] = _swigfaiss_gpu.GpuIndexIVFPQConfig_useFloat16LookupTables_set
|
|
__swig_getmethods__["useFloat16LookupTables"] = _swigfaiss_gpu.GpuIndexIVFPQConfig_useFloat16LookupTables_get
|
|
if _newclass:useFloat16LookupTables = _swig_property(_swigfaiss_gpu.GpuIndexIVFPQConfig_useFloat16LookupTables_get, _swigfaiss_gpu.GpuIndexIVFPQConfig_useFloat16LookupTables_set)
|
|
__swig_setmethods__["usePrecomputedTables"] = _swigfaiss_gpu.GpuIndexIVFPQConfig_usePrecomputedTables_set
|
|
__swig_getmethods__["usePrecomputedTables"] = _swigfaiss_gpu.GpuIndexIVFPQConfig_usePrecomputedTables_get
|
|
if _newclass:usePrecomputedTables = _swig_property(_swigfaiss_gpu.GpuIndexIVFPQConfig_usePrecomputedTables_get, _swigfaiss_gpu.GpuIndexIVFPQConfig_usePrecomputedTables_set)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexIVFPQConfig
|
|
__del__ = lambda self : None;
|
|
GpuIndexIVFPQConfig_swigregister = _swigfaiss_gpu.GpuIndexIVFPQConfig_swigregister
|
|
GpuIndexIVFPQConfig_swigregister(GpuIndexIVFPQConfig)
|
|
|
|
class GpuIndexIVFPQ(GpuIndexIVF):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndexIVF]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexIVFPQ, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndexIVF]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexIVFPQ, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_GpuIndexIVFPQ(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexIVFPQ
|
|
__del__ = lambda self : None;
|
|
def copyFrom(self, *args): return _swigfaiss_gpu.GpuIndexIVFPQ_copyFrom(self, *args)
|
|
def copyTo(self, *args): return _swigfaiss_gpu.GpuIndexIVFPQ_copyTo(self, *args)
|
|
def reserveMemory(self, *args): return _swigfaiss_gpu.GpuIndexIVFPQ_reserveMemory(self, *args)
|
|
def setPrecomputedCodes(self, *args): return _swigfaiss_gpu.GpuIndexIVFPQ_setPrecomputedCodes(self, *args)
|
|
def getPrecomputedCodes(self): return _swigfaiss_gpu.GpuIndexIVFPQ_getPrecomputedCodes(self)
|
|
def getNumSubQuantizers(self): return _swigfaiss_gpu.GpuIndexIVFPQ_getNumSubQuantizers(self)
|
|
def getBitsPerCode(self): return _swigfaiss_gpu.GpuIndexIVFPQ_getBitsPerCode(self)
|
|
def getCentroidsPerSubQuantizer(self): return _swigfaiss_gpu.GpuIndexIVFPQ_getCentroidsPerSubQuantizer(self)
|
|
def reclaimMemory(self): return _swigfaiss_gpu.GpuIndexIVFPQ_reclaimMemory(self)
|
|
def reset(self): return _swigfaiss_gpu.GpuIndexIVFPQ_reset(self)
|
|
def train(self, *args): return _swigfaiss_gpu.GpuIndexIVFPQ_train(self, *args)
|
|
def getListLength(self, *args): return _swigfaiss_gpu.GpuIndexIVFPQ_getListLength(self, *args)
|
|
def getListCodes(self, *args): return _swigfaiss_gpu.GpuIndexIVFPQ_getListCodes(self, *args)
|
|
def getListIndices(self, *args): return _swigfaiss_gpu.GpuIndexIVFPQ_getListIndices(self, *args)
|
|
GpuIndexIVFPQ_swigregister = _swigfaiss_gpu.GpuIndexIVFPQ_swigregister
|
|
GpuIndexIVFPQ_swigregister(GpuIndexIVFPQ)
|
|
|
|
class GpuIndexIVFFlatConfig(GpuIndexIVFConfig):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndexIVFConfig]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexIVFFlatConfig, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndexIVFConfig]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexIVFFlatConfig, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_GpuIndexIVFFlatConfig()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["useFloat16IVFStorage"] = _swigfaiss_gpu.GpuIndexIVFFlatConfig_useFloat16IVFStorage_set
|
|
__swig_getmethods__["useFloat16IVFStorage"] = _swigfaiss_gpu.GpuIndexIVFFlatConfig_useFloat16IVFStorage_get
|
|
if _newclass:useFloat16IVFStorage = _swig_property(_swigfaiss_gpu.GpuIndexIVFFlatConfig_useFloat16IVFStorage_get, _swigfaiss_gpu.GpuIndexIVFFlatConfig_useFloat16IVFStorage_set)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexIVFFlatConfig
|
|
__del__ = lambda self : None;
|
|
GpuIndexIVFFlatConfig_swigregister = _swigfaiss_gpu.GpuIndexIVFFlatConfig_swigregister
|
|
GpuIndexIVFFlatConfig_swigregister(GpuIndexIVFFlatConfig)
|
|
|
|
class GpuIndexIVFFlat(GpuIndexIVF):
|
|
__swig_setmethods__ = {}
|
|
for _s in [GpuIndexIVF]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuIndexIVFFlat, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [GpuIndexIVF]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuIndexIVFFlat, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_GpuIndexIVFFlat(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuIndexIVFFlat
|
|
__del__ = lambda self : None;
|
|
def reserveMemory(self, *args): return _swigfaiss_gpu.GpuIndexIVFFlat_reserveMemory(self, *args)
|
|
def copyFrom(self, *args): return _swigfaiss_gpu.GpuIndexIVFFlat_copyFrom(self, *args)
|
|
def copyTo(self, *args): return _swigfaiss_gpu.GpuIndexIVFFlat_copyTo(self, *args)
|
|
def reclaimMemory(self): return _swigfaiss_gpu.GpuIndexIVFFlat_reclaimMemory(self)
|
|
def reset(self): return _swigfaiss_gpu.GpuIndexIVFFlat_reset(self)
|
|
def train(self, *args): return _swigfaiss_gpu.GpuIndexIVFFlat_train(self, *args)
|
|
GpuIndexIVFFlat_swigregister = _swigfaiss_gpu.GpuIndexIVFFlat_swigregister
|
|
GpuIndexIVFFlat_swigregister(GpuIndexIVFFlat)
|
|
|
|
class IndexProxy(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexProxy, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexProxy, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_IndexProxy()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IndexProxy
|
|
__del__ = lambda self : None;
|
|
def addIndex(self, *args): return _swigfaiss_gpu.IndexProxy_addIndex(self, *args)
|
|
def removeIndex(self, *args): return _swigfaiss_gpu.IndexProxy_removeIndex(self, *args)
|
|
def runOnIndex(self, *args): return _swigfaiss_gpu.IndexProxy_runOnIndex(self, *args)
|
|
def reset(self): return _swigfaiss_gpu.IndexProxy_reset(self)
|
|
def train(self, *args): return _swigfaiss_gpu.IndexProxy_train(self, *args)
|
|
def add(self, *args): return _swigfaiss_gpu.IndexProxy_add(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.IndexProxy_search(self, *args)
|
|
def reconstruct(self, *args): return _swigfaiss_gpu.IndexProxy_reconstruct(self, *args)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss_gpu.IndexProxy_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss_gpu.IndexProxy_own_fields_get
|
|
if _newclass:own_fields = _swig_property(_swigfaiss_gpu.IndexProxy_own_fields_get, _swigfaiss_gpu.IndexProxy_own_fields_set)
|
|
def count(self): return _swigfaiss_gpu.IndexProxy_count(self)
|
|
def at(self, *args): return _swigfaiss_gpu.IndexProxy_at(self, *args)
|
|
IndexProxy_swigregister = _swigfaiss_gpu.IndexProxy_swigregister
|
|
IndexProxy_swigregister(IndexProxy)
|
|
|
|
|
|
def kmeans_clustering_gpu(*args):
|
|
return _swigfaiss_gpu.kmeans_clustering_gpu(*args)
|
|
kmeans_clustering_gpu = _swigfaiss_gpu.kmeans_clustering_gpu
|
|
|
|
def downcast_index(*args):
|
|
return _swigfaiss_gpu.downcast_index(*args)
|
|
downcast_index = _swigfaiss_gpu.downcast_index
|
|
|
|
def downcast_VectorTransform(*args):
|
|
return _swigfaiss_gpu.downcast_VectorTransform(*args)
|
|
downcast_VectorTransform = _swigfaiss_gpu.downcast_VectorTransform
|
|
|
|
def write_index(*args):
|
|
return _swigfaiss_gpu.write_index(*args)
|
|
write_index = _swigfaiss_gpu.write_index
|
|
|
|
def read_index(*args):
|
|
return _swigfaiss_gpu.read_index(*args)
|
|
read_index = _swigfaiss_gpu.read_index
|
|
|
|
def write_VectorTransform(*args):
|
|
return _swigfaiss_gpu.write_VectorTransform(*args)
|
|
write_VectorTransform = _swigfaiss_gpu.write_VectorTransform
|
|
|
|
def read_VectorTransform(*args):
|
|
return _swigfaiss_gpu.read_VectorTransform(*args)
|
|
read_VectorTransform = _swigfaiss_gpu.read_VectorTransform
|
|
|
|
def read_ProductQuantizer(*args):
|
|
return _swigfaiss_gpu.read_ProductQuantizer(*args)
|
|
read_ProductQuantizer = _swigfaiss_gpu.read_ProductQuantizer
|
|
|
|
def write_ProductQuantizer(*args):
|
|
return _swigfaiss_gpu.write_ProductQuantizer(*args)
|
|
write_ProductQuantizer = _swigfaiss_gpu.write_ProductQuantizer
|
|
|
|
def clone_index(*args):
|
|
return _swigfaiss_gpu.clone_index(*args)
|
|
clone_index = _swigfaiss_gpu.clone_index
|
|
class Cloner(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Cloner, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Cloner, name)
|
|
__repr__ = _swig_repr
|
|
def clone_VectorTransform(self, *args): return _swigfaiss_gpu.Cloner_clone_VectorTransform(self, *args)
|
|
def clone_Index(self, *args): return _swigfaiss_gpu.Cloner_clone_Index(self, *args)
|
|
def clone_IndexIVF(self, *args): return _swigfaiss_gpu.Cloner_clone_IndexIVF(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_Cloner
|
|
__del__ = lambda self : None;
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_Cloner()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
Cloner_swigregister = _swigfaiss_gpu.Cloner_swigregister
|
|
Cloner_swigregister(Cloner)
|
|
|
|
class AutoTuneCriterion(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, AutoTuneCriterion, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, AutoTuneCriterion, name)
|
|
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nq"] = _swigfaiss_gpu.AutoTuneCriterion_nq_set
|
|
__swig_getmethods__["nq"] = _swigfaiss_gpu.AutoTuneCriterion_nq_get
|
|
if _newclass:nq = _swig_property(_swigfaiss_gpu.AutoTuneCriterion_nq_get, _swigfaiss_gpu.AutoTuneCriterion_nq_set)
|
|
__swig_setmethods__["nnn"] = _swigfaiss_gpu.AutoTuneCriterion_nnn_set
|
|
__swig_getmethods__["nnn"] = _swigfaiss_gpu.AutoTuneCriterion_nnn_get
|
|
if _newclass:nnn = _swig_property(_swigfaiss_gpu.AutoTuneCriterion_nnn_get, _swigfaiss_gpu.AutoTuneCriterion_nnn_set)
|
|
__swig_setmethods__["gt_nnn"] = _swigfaiss_gpu.AutoTuneCriterion_gt_nnn_set
|
|
__swig_getmethods__["gt_nnn"] = _swigfaiss_gpu.AutoTuneCriterion_gt_nnn_get
|
|
if _newclass:gt_nnn = _swig_property(_swigfaiss_gpu.AutoTuneCriterion_gt_nnn_get, _swigfaiss_gpu.AutoTuneCriterion_gt_nnn_set)
|
|
__swig_setmethods__["gt_D"] = _swigfaiss_gpu.AutoTuneCriterion_gt_D_set
|
|
__swig_getmethods__["gt_D"] = _swigfaiss_gpu.AutoTuneCriterion_gt_D_get
|
|
if _newclass:gt_D = _swig_property(_swigfaiss_gpu.AutoTuneCriterion_gt_D_get, _swigfaiss_gpu.AutoTuneCriterion_gt_D_set)
|
|
__swig_setmethods__["gt_I"] = _swigfaiss_gpu.AutoTuneCriterion_gt_I_set
|
|
__swig_getmethods__["gt_I"] = _swigfaiss_gpu.AutoTuneCriterion_gt_I_get
|
|
if _newclass:gt_I = _swig_property(_swigfaiss_gpu.AutoTuneCriterion_gt_I_get, _swigfaiss_gpu.AutoTuneCriterion_gt_I_set)
|
|
def set_groundtruth(self, *args): return _swigfaiss_gpu.AutoTuneCriterion_set_groundtruth(self, *args)
|
|
def evaluate(self, *args): return _swigfaiss_gpu.AutoTuneCriterion_evaluate(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_AutoTuneCriterion
|
|
__del__ = lambda self : None;
|
|
AutoTuneCriterion_swigregister = _swigfaiss_gpu.AutoTuneCriterion_swigregister
|
|
AutoTuneCriterion_swigregister(AutoTuneCriterion)
|
|
|
|
class OneRecallAtRCriterion(AutoTuneCriterion):
|
|
__swig_setmethods__ = {}
|
|
for _s in [AutoTuneCriterion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, OneRecallAtRCriterion, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [AutoTuneCriterion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, OneRecallAtRCriterion, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["R"] = _swigfaiss_gpu.OneRecallAtRCriterion_R_set
|
|
__swig_getmethods__["R"] = _swigfaiss_gpu.OneRecallAtRCriterion_R_get
|
|
if _newclass:R = _swig_property(_swigfaiss_gpu.OneRecallAtRCriterion_R_get, _swigfaiss_gpu.OneRecallAtRCriterion_R_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_OneRecallAtRCriterion(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def evaluate(self, *args): return _swigfaiss_gpu.OneRecallAtRCriterion_evaluate(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_OneRecallAtRCriterion
|
|
__del__ = lambda self : None;
|
|
OneRecallAtRCriterion_swigregister = _swigfaiss_gpu.OneRecallAtRCriterion_swigregister
|
|
OneRecallAtRCriterion_swigregister(OneRecallAtRCriterion)
|
|
|
|
class IntersectionCriterion(AutoTuneCriterion):
|
|
__swig_setmethods__ = {}
|
|
for _s in [AutoTuneCriterion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IntersectionCriterion, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [AutoTuneCriterion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IntersectionCriterion, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["R"] = _swigfaiss_gpu.IntersectionCriterion_R_set
|
|
__swig_getmethods__["R"] = _swigfaiss_gpu.IntersectionCriterion_R_get
|
|
if _newclass:R = _swig_property(_swigfaiss_gpu.IntersectionCriterion_R_get, _swigfaiss_gpu.IntersectionCriterion_R_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IntersectionCriterion(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def evaluate(self, *args): return _swigfaiss_gpu.IntersectionCriterion_evaluate(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IntersectionCriterion
|
|
__del__ = lambda self : None;
|
|
IntersectionCriterion_swigregister = _swigfaiss_gpu.IntersectionCriterion_swigregister
|
|
IntersectionCriterion_swigregister(IntersectionCriterion)
|
|
|
|
class OperatingPoint(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, OperatingPoint, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, OperatingPoint, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["perf"] = _swigfaiss_gpu.OperatingPoint_perf_set
|
|
__swig_getmethods__["perf"] = _swigfaiss_gpu.OperatingPoint_perf_get
|
|
if _newclass:perf = _swig_property(_swigfaiss_gpu.OperatingPoint_perf_get, _swigfaiss_gpu.OperatingPoint_perf_set)
|
|
__swig_setmethods__["t"] = _swigfaiss_gpu.OperatingPoint_t_set
|
|
__swig_getmethods__["t"] = _swigfaiss_gpu.OperatingPoint_t_get
|
|
if _newclass:t = _swig_property(_swigfaiss_gpu.OperatingPoint_t_get, _swigfaiss_gpu.OperatingPoint_t_set)
|
|
__swig_setmethods__["key"] = _swigfaiss_gpu.OperatingPoint_key_set
|
|
__swig_getmethods__["key"] = _swigfaiss_gpu.OperatingPoint_key_get
|
|
if _newclass:key = _swig_property(_swigfaiss_gpu.OperatingPoint_key_get, _swigfaiss_gpu.OperatingPoint_key_set)
|
|
__swig_setmethods__["cno"] = _swigfaiss_gpu.OperatingPoint_cno_set
|
|
__swig_getmethods__["cno"] = _swigfaiss_gpu.OperatingPoint_cno_get
|
|
if _newclass:cno = _swig_property(_swigfaiss_gpu.OperatingPoint_cno_get, _swigfaiss_gpu.OperatingPoint_cno_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_OperatingPoint()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_OperatingPoint
|
|
__del__ = lambda self : None;
|
|
OperatingPoint_swigregister = _swigfaiss_gpu.OperatingPoint_swigregister
|
|
OperatingPoint_swigregister(OperatingPoint)
|
|
|
|
class OperatingPoints(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, OperatingPoints, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, OperatingPoints, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["all_pts"] = _swigfaiss_gpu.OperatingPoints_all_pts_set
|
|
__swig_getmethods__["all_pts"] = _swigfaiss_gpu.OperatingPoints_all_pts_get
|
|
if _newclass:all_pts = _swig_property(_swigfaiss_gpu.OperatingPoints_all_pts_get, _swigfaiss_gpu.OperatingPoints_all_pts_set)
|
|
__swig_setmethods__["optimal_pts"] = _swigfaiss_gpu.OperatingPoints_optimal_pts_set
|
|
__swig_getmethods__["optimal_pts"] = _swigfaiss_gpu.OperatingPoints_optimal_pts_get
|
|
if _newclass:optimal_pts = _swig_property(_swigfaiss_gpu.OperatingPoints_optimal_pts_get, _swigfaiss_gpu.OperatingPoints_optimal_pts_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_OperatingPoints()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def merge_with(self, *args): return _swigfaiss_gpu.OperatingPoints_merge_with(self, *args)
|
|
def clear(self): return _swigfaiss_gpu.OperatingPoints_clear(self)
|
|
def add(self, *args): return _swigfaiss_gpu.OperatingPoints_add(self, *args)
|
|
def t_for_perf(self, *args): return _swigfaiss_gpu.OperatingPoints_t_for_perf(self, *args)
|
|
def display(self, only_optimal=True): return _swigfaiss_gpu.OperatingPoints_display(self, only_optimal)
|
|
def all_to_gnuplot(self, *args): return _swigfaiss_gpu.OperatingPoints_all_to_gnuplot(self, *args)
|
|
def optimal_to_gnuplot(self, *args): return _swigfaiss_gpu.OperatingPoints_optimal_to_gnuplot(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_OperatingPoints
|
|
__del__ = lambda self : None;
|
|
OperatingPoints_swigregister = _swigfaiss_gpu.OperatingPoints_swigregister
|
|
OperatingPoints_swigregister(OperatingPoints)
|
|
|
|
class ParameterRange(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ParameterRange, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ParameterRange, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["name"] = _swigfaiss_gpu.ParameterRange_name_set
|
|
__swig_getmethods__["name"] = _swigfaiss_gpu.ParameterRange_name_get
|
|
if _newclass:name = _swig_property(_swigfaiss_gpu.ParameterRange_name_get, _swigfaiss_gpu.ParameterRange_name_set)
|
|
__swig_setmethods__["values"] = _swigfaiss_gpu.ParameterRange_values_set
|
|
__swig_getmethods__["values"] = _swigfaiss_gpu.ParameterRange_values_get
|
|
if _newclass:values = _swig_property(_swigfaiss_gpu.ParameterRange_values_get, _swigfaiss_gpu.ParameterRange_values_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_ParameterRange()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_ParameterRange
|
|
__del__ = lambda self : None;
|
|
ParameterRange_swigregister = _swigfaiss_gpu.ParameterRange_swigregister
|
|
ParameterRange_swigregister(ParameterRange)
|
|
|
|
class ParameterSpace(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ParameterSpace, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ParameterSpace, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["parameter_ranges"] = _swigfaiss_gpu.ParameterSpace_parameter_ranges_set
|
|
__swig_getmethods__["parameter_ranges"] = _swigfaiss_gpu.ParameterSpace_parameter_ranges_get
|
|
if _newclass:parameter_ranges = _swig_property(_swigfaiss_gpu.ParameterSpace_parameter_ranges_get, _swigfaiss_gpu.ParameterSpace_parameter_ranges_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss_gpu.ParameterSpace_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss_gpu.ParameterSpace_verbose_get
|
|
if _newclass:verbose = _swig_property(_swigfaiss_gpu.ParameterSpace_verbose_get, _swigfaiss_gpu.ParameterSpace_verbose_set)
|
|
__swig_setmethods__["n_experiments"] = _swigfaiss_gpu.ParameterSpace_n_experiments_set
|
|
__swig_getmethods__["n_experiments"] = _swigfaiss_gpu.ParameterSpace_n_experiments_get
|
|
if _newclass:n_experiments = _swig_property(_swigfaiss_gpu.ParameterSpace_n_experiments_get, _swigfaiss_gpu.ParameterSpace_n_experiments_set)
|
|
__swig_setmethods__["batchsize"] = _swigfaiss_gpu.ParameterSpace_batchsize_set
|
|
__swig_getmethods__["batchsize"] = _swigfaiss_gpu.ParameterSpace_batchsize_get
|
|
if _newclass:batchsize = _swig_property(_swigfaiss_gpu.ParameterSpace_batchsize_get, _swigfaiss_gpu.ParameterSpace_batchsize_set)
|
|
__swig_setmethods__["thread_over_batches"] = _swigfaiss_gpu.ParameterSpace_thread_over_batches_set
|
|
__swig_getmethods__["thread_over_batches"] = _swigfaiss_gpu.ParameterSpace_thread_over_batches_get
|
|
if _newclass:thread_over_batches = _swig_property(_swigfaiss_gpu.ParameterSpace_thread_over_batches_get, _swigfaiss_gpu.ParameterSpace_thread_over_batches_set)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_ParameterSpace()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def n_combinations(self): return _swigfaiss_gpu.ParameterSpace_n_combinations(self)
|
|
def combination_ge(self, *args): return _swigfaiss_gpu.ParameterSpace_combination_ge(self, *args)
|
|
def combination_name(self, *args): return _swigfaiss_gpu.ParameterSpace_combination_name(self, *args)
|
|
def display(self): return _swigfaiss_gpu.ParameterSpace_display(self)
|
|
def add_range(self, *args): return _swigfaiss_gpu.ParameterSpace_add_range(self, *args)
|
|
def initialize(self, *args): return _swigfaiss_gpu.ParameterSpace_initialize(self, *args)
|
|
def set_index_parameters(self, *args): return _swigfaiss_gpu.ParameterSpace_set_index_parameters(self, *args)
|
|
def set_index_parameter(self, *args): return _swigfaiss_gpu.ParameterSpace_set_index_parameter(self, *args)
|
|
def update_bounds(self, *args): return _swigfaiss_gpu.ParameterSpace_update_bounds(self, *args)
|
|
def explore(self, *args): return _swigfaiss_gpu.ParameterSpace_explore(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_ParameterSpace
|
|
__del__ = lambda self : None;
|
|
ParameterSpace_swigregister = _swigfaiss_gpu.ParameterSpace_swigregister
|
|
ParameterSpace_swigregister(ParameterSpace)
|
|
|
|
|
|
def index_factory(*args):
|
|
return _swigfaiss_gpu.index_factory(*args)
|
|
index_factory = _swigfaiss_gpu.index_factory
|
|
|
|
def index_gpu_to_cpu(*args):
|
|
return _swigfaiss_gpu.index_gpu_to_cpu(*args)
|
|
index_gpu_to_cpu = _swigfaiss_gpu.index_gpu_to_cpu
|
|
|
|
def index_cpu_to_gpu(*args):
|
|
return _swigfaiss_gpu.index_cpu_to_gpu(*args)
|
|
index_cpu_to_gpu = _swigfaiss_gpu.index_cpu_to_gpu
|
|
|
|
def index_cpu_to_gpu_multiple(*args):
|
|
return _swigfaiss_gpu.index_cpu_to_gpu_multiple(*args)
|
|
index_cpu_to_gpu_multiple = _swigfaiss_gpu.index_cpu_to_gpu_multiple
|
|
class GpuParameterSpace(ParameterSpace):
|
|
__swig_setmethods__ = {}
|
|
for _s in [ParameterSpace]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, GpuParameterSpace, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [ParameterSpace]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, GpuParameterSpace, name)
|
|
__repr__ = _swig_repr
|
|
def initialize(self, *args): return _swigfaiss_gpu.GpuParameterSpace_initialize(self, *args)
|
|
def set_index_parameter(self, *args): return _swigfaiss_gpu.GpuParameterSpace_set_index_parameter(self, *args)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_GpuParameterSpace()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_GpuParameterSpace
|
|
__del__ = lambda self : None;
|
|
GpuParameterSpace_swigregister = _swigfaiss_gpu.GpuParameterSpace_swigregister
|
|
GpuParameterSpace_swigregister(GpuParameterSpace)
|
|
|
|
|
|
def swig_ptr(*args):
|
|
return _swigfaiss_gpu.swig_ptr(*args)
|
|
swig_ptr = _swigfaiss_gpu.swig_ptr
|
|
|
|
def rev_swig_ptr(*args):
|
|
return _swigfaiss_gpu.rev_swig_ptr(*args)
|
|
rev_swig_ptr = _swigfaiss_gpu.rev_swig_ptr
|
|
class float_minheap_array_t(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, float_minheap_array_t, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, float_minheap_array_t, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nh"] = _swigfaiss_gpu.float_minheap_array_t_nh_set
|
|
__swig_getmethods__["nh"] = _swigfaiss_gpu.float_minheap_array_t_nh_get
|
|
if _newclass:nh = _swig_property(_swigfaiss_gpu.float_minheap_array_t_nh_get, _swigfaiss_gpu.float_minheap_array_t_nh_set)
|
|
__swig_setmethods__["k"] = _swigfaiss_gpu.float_minheap_array_t_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss_gpu.float_minheap_array_t_k_get
|
|
if _newclass:k = _swig_property(_swigfaiss_gpu.float_minheap_array_t_k_get, _swigfaiss_gpu.float_minheap_array_t_k_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss_gpu.float_minheap_array_t_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss_gpu.float_minheap_array_t_ids_get
|
|
if _newclass:ids = _swig_property(_swigfaiss_gpu.float_minheap_array_t_ids_get, _swigfaiss_gpu.float_minheap_array_t_ids_set)
|
|
__swig_setmethods__["val"] = _swigfaiss_gpu.float_minheap_array_t_val_set
|
|
__swig_getmethods__["val"] = _swigfaiss_gpu.float_minheap_array_t_val_get
|
|
if _newclass:val = _swig_property(_swigfaiss_gpu.float_minheap_array_t_val_get, _swigfaiss_gpu.float_minheap_array_t_val_set)
|
|
def get_val(self, *args): return _swigfaiss_gpu.float_minheap_array_t_get_val(self, *args)
|
|
def get_ids(self, *args): return _swigfaiss_gpu.float_minheap_array_t_get_ids(self, *args)
|
|
def heapify(self): return _swigfaiss_gpu.float_minheap_array_t_heapify(self)
|
|
def addn(self, *args): return _swigfaiss_gpu.float_minheap_array_t_addn(self, *args)
|
|
def addn_with_ids(self, *args): return _swigfaiss_gpu.float_minheap_array_t_addn_with_ids(self, *args)
|
|
def reorder(self): return _swigfaiss_gpu.float_minheap_array_t_reorder(self)
|
|
def per_line_extrema(self, *args): return _swigfaiss_gpu.float_minheap_array_t_per_line_extrema(self, *args)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_float_minheap_array_t()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_float_minheap_array_t
|
|
__del__ = lambda self : None;
|
|
float_minheap_array_t_swigregister = _swigfaiss_gpu.float_minheap_array_t_swigregister
|
|
float_minheap_array_t_swigregister(float_minheap_array_t)
|
|
|
|
class int_minheap_array_t(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, int_minheap_array_t, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, int_minheap_array_t, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nh"] = _swigfaiss_gpu.int_minheap_array_t_nh_set
|
|
__swig_getmethods__["nh"] = _swigfaiss_gpu.int_minheap_array_t_nh_get
|
|
if _newclass:nh = _swig_property(_swigfaiss_gpu.int_minheap_array_t_nh_get, _swigfaiss_gpu.int_minheap_array_t_nh_set)
|
|
__swig_setmethods__["k"] = _swigfaiss_gpu.int_minheap_array_t_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss_gpu.int_minheap_array_t_k_get
|
|
if _newclass:k = _swig_property(_swigfaiss_gpu.int_minheap_array_t_k_get, _swigfaiss_gpu.int_minheap_array_t_k_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss_gpu.int_minheap_array_t_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss_gpu.int_minheap_array_t_ids_get
|
|
if _newclass:ids = _swig_property(_swigfaiss_gpu.int_minheap_array_t_ids_get, _swigfaiss_gpu.int_minheap_array_t_ids_set)
|
|
__swig_setmethods__["val"] = _swigfaiss_gpu.int_minheap_array_t_val_set
|
|
__swig_getmethods__["val"] = _swigfaiss_gpu.int_minheap_array_t_val_get
|
|
if _newclass:val = _swig_property(_swigfaiss_gpu.int_minheap_array_t_val_get, _swigfaiss_gpu.int_minheap_array_t_val_set)
|
|
def get_val(self, *args): return _swigfaiss_gpu.int_minheap_array_t_get_val(self, *args)
|
|
def get_ids(self, *args): return _swigfaiss_gpu.int_minheap_array_t_get_ids(self, *args)
|
|
def heapify(self): return _swigfaiss_gpu.int_minheap_array_t_heapify(self)
|
|
def addn(self, *args): return _swigfaiss_gpu.int_minheap_array_t_addn(self, *args)
|
|
def addn_with_ids(self, *args): return _swigfaiss_gpu.int_minheap_array_t_addn_with_ids(self, *args)
|
|
def reorder(self): return _swigfaiss_gpu.int_minheap_array_t_reorder(self)
|
|
def per_line_extrema(self, *args): return _swigfaiss_gpu.int_minheap_array_t_per_line_extrema(self, *args)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_int_minheap_array_t()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_int_minheap_array_t
|
|
__del__ = lambda self : None;
|
|
int_minheap_array_t_swigregister = _swigfaiss_gpu.int_minheap_array_t_swigregister
|
|
int_minheap_array_t_swigregister(int_minheap_array_t)
|
|
|
|
class float_maxheap_array_t(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, float_maxheap_array_t, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, float_maxheap_array_t, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nh"] = _swigfaiss_gpu.float_maxheap_array_t_nh_set
|
|
__swig_getmethods__["nh"] = _swigfaiss_gpu.float_maxheap_array_t_nh_get
|
|
if _newclass:nh = _swig_property(_swigfaiss_gpu.float_maxheap_array_t_nh_get, _swigfaiss_gpu.float_maxheap_array_t_nh_set)
|
|
__swig_setmethods__["k"] = _swigfaiss_gpu.float_maxheap_array_t_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss_gpu.float_maxheap_array_t_k_get
|
|
if _newclass:k = _swig_property(_swigfaiss_gpu.float_maxheap_array_t_k_get, _swigfaiss_gpu.float_maxheap_array_t_k_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss_gpu.float_maxheap_array_t_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss_gpu.float_maxheap_array_t_ids_get
|
|
if _newclass:ids = _swig_property(_swigfaiss_gpu.float_maxheap_array_t_ids_get, _swigfaiss_gpu.float_maxheap_array_t_ids_set)
|
|
__swig_setmethods__["val"] = _swigfaiss_gpu.float_maxheap_array_t_val_set
|
|
__swig_getmethods__["val"] = _swigfaiss_gpu.float_maxheap_array_t_val_get
|
|
if _newclass:val = _swig_property(_swigfaiss_gpu.float_maxheap_array_t_val_get, _swigfaiss_gpu.float_maxheap_array_t_val_set)
|
|
def get_val(self, *args): return _swigfaiss_gpu.float_maxheap_array_t_get_val(self, *args)
|
|
def get_ids(self, *args): return _swigfaiss_gpu.float_maxheap_array_t_get_ids(self, *args)
|
|
def heapify(self): return _swigfaiss_gpu.float_maxheap_array_t_heapify(self)
|
|
def addn(self, *args): return _swigfaiss_gpu.float_maxheap_array_t_addn(self, *args)
|
|
def addn_with_ids(self, *args): return _swigfaiss_gpu.float_maxheap_array_t_addn_with_ids(self, *args)
|
|
def reorder(self): return _swigfaiss_gpu.float_maxheap_array_t_reorder(self)
|
|
def per_line_extrema(self, *args): return _swigfaiss_gpu.float_maxheap_array_t_per_line_extrema(self, *args)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_float_maxheap_array_t()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_float_maxheap_array_t
|
|
__del__ = lambda self : None;
|
|
float_maxheap_array_t_swigregister = _swigfaiss_gpu.float_maxheap_array_t_swigregister
|
|
float_maxheap_array_t_swigregister(float_maxheap_array_t)
|
|
|
|
class int_maxheap_array_t(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, int_maxheap_array_t, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, int_maxheap_array_t, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nh"] = _swigfaiss_gpu.int_maxheap_array_t_nh_set
|
|
__swig_getmethods__["nh"] = _swigfaiss_gpu.int_maxheap_array_t_nh_get
|
|
if _newclass:nh = _swig_property(_swigfaiss_gpu.int_maxheap_array_t_nh_get, _swigfaiss_gpu.int_maxheap_array_t_nh_set)
|
|
__swig_setmethods__["k"] = _swigfaiss_gpu.int_maxheap_array_t_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss_gpu.int_maxheap_array_t_k_get
|
|
if _newclass:k = _swig_property(_swigfaiss_gpu.int_maxheap_array_t_k_get, _swigfaiss_gpu.int_maxheap_array_t_k_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss_gpu.int_maxheap_array_t_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss_gpu.int_maxheap_array_t_ids_get
|
|
if _newclass:ids = _swig_property(_swigfaiss_gpu.int_maxheap_array_t_ids_get, _swigfaiss_gpu.int_maxheap_array_t_ids_set)
|
|
__swig_setmethods__["val"] = _swigfaiss_gpu.int_maxheap_array_t_val_set
|
|
__swig_getmethods__["val"] = _swigfaiss_gpu.int_maxheap_array_t_val_get
|
|
if _newclass:val = _swig_property(_swigfaiss_gpu.int_maxheap_array_t_val_get, _swigfaiss_gpu.int_maxheap_array_t_val_set)
|
|
def get_val(self, *args): return _swigfaiss_gpu.int_maxheap_array_t_get_val(self, *args)
|
|
def get_ids(self, *args): return _swigfaiss_gpu.int_maxheap_array_t_get_ids(self, *args)
|
|
def heapify(self): return _swigfaiss_gpu.int_maxheap_array_t_heapify(self)
|
|
def addn(self, *args): return _swigfaiss_gpu.int_maxheap_array_t_addn(self, *args)
|
|
def addn_with_ids(self, *args): return _swigfaiss_gpu.int_maxheap_array_t_addn_with_ids(self, *args)
|
|
def reorder(self): return _swigfaiss_gpu.int_maxheap_array_t_reorder(self)
|
|
def per_line_extrema(self, *args): return _swigfaiss_gpu.int_maxheap_array_t_per_line_extrema(self, *args)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_int_maxheap_array_t()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_int_maxheap_array_t
|
|
__del__ = lambda self : None;
|
|
int_maxheap_array_t_swigregister = _swigfaiss_gpu.int_maxheap_array_t_swigregister
|
|
int_maxheap_array_t_swigregister(int_maxheap_array_t)
|
|
|
|
|
|
def omp_set_num_threads(*args):
|
|
return _swigfaiss_gpu.omp_set_num_threads(*args)
|
|
omp_set_num_threads = _swigfaiss_gpu.omp_set_num_threads
|
|
|
|
def omp_get_max_threads():
|
|
return _swigfaiss_gpu.omp_get_max_threads()
|
|
omp_get_max_threads = _swigfaiss_gpu.omp_get_max_threads
|
|
|
|
def memcpy(*args):
|
|
return _swigfaiss_gpu.memcpy(*args)
|
|
memcpy = _swigfaiss_gpu.memcpy
|
|
|
|
def cast_integer_to_float_ptr(*args):
|
|
return _swigfaiss_gpu.cast_integer_to_float_ptr(*args)
|
|
cast_integer_to_float_ptr = _swigfaiss_gpu.cast_integer_to_float_ptr
|
|
|
|
def cast_integer_to_long_ptr(*args):
|
|
return _swigfaiss_gpu.cast_integer_to_long_ptr(*args)
|
|
cast_integer_to_long_ptr = _swigfaiss_gpu.cast_integer_to_long_ptr
|
|
|
|
def cast_integer_to_int_ptr(*args):
|
|
return _swigfaiss_gpu.cast_integer_to_int_ptr(*args)
|
|
cast_integer_to_int_ptr = _swigfaiss_gpu.cast_integer_to_int_ptr
|
|
class RangeSearchResult(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, RangeSearchResult, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, RangeSearchResult, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nq"] = _swigfaiss_gpu.RangeSearchResult_nq_set
|
|
__swig_getmethods__["nq"] = _swigfaiss_gpu.RangeSearchResult_nq_get
|
|
if _newclass:nq = _swig_property(_swigfaiss_gpu.RangeSearchResult_nq_get, _swigfaiss_gpu.RangeSearchResult_nq_set)
|
|
__swig_setmethods__["lims"] = _swigfaiss_gpu.RangeSearchResult_lims_set
|
|
__swig_getmethods__["lims"] = _swigfaiss_gpu.RangeSearchResult_lims_get
|
|
if _newclass:lims = _swig_property(_swigfaiss_gpu.RangeSearchResult_lims_get, _swigfaiss_gpu.RangeSearchResult_lims_set)
|
|
__swig_setmethods__["labels"] = _swigfaiss_gpu.RangeSearchResult_labels_set
|
|
__swig_getmethods__["labels"] = _swigfaiss_gpu.RangeSearchResult_labels_get
|
|
if _newclass:labels = _swig_property(_swigfaiss_gpu.RangeSearchResult_labels_get, _swigfaiss_gpu.RangeSearchResult_labels_set)
|
|
__swig_setmethods__["distances"] = _swigfaiss_gpu.RangeSearchResult_distances_set
|
|
__swig_getmethods__["distances"] = _swigfaiss_gpu.RangeSearchResult_distances_get
|
|
if _newclass:distances = _swig_property(_swigfaiss_gpu.RangeSearchResult_distances_get, _swigfaiss_gpu.RangeSearchResult_distances_set)
|
|
__swig_setmethods__["buffer_size"] = _swigfaiss_gpu.RangeSearchResult_buffer_size_set
|
|
__swig_getmethods__["buffer_size"] = _swigfaiss_gpu.RangeSearchResult_buffer_size_get
|
|
if _newclass:buffer_size = _swig_property(_swigfaiss_gpu.RangeSearchResult_buffer_size_get, _swigfaiss_gpu.RangeSearchResult_buffer_size_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_RangeSearchResult(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def do_allocation(self): return _swigfaiss_gpu.RangeSearchResult_do_allocation(self)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_RangeSearchResult
|
|
__del__ = lambda self : None;
|
|
RangeSearchResult_swigregister = _swigfaiss_gpu.RangeSearchResult_swigregister
|
|
RangeSearchResult_swigregister(RangeSearchResult)
|
|
|
|
class IDSelector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IDSelector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IDSelector, name)
|
|
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
def is_member(self, *args): return _swigfaiss_gpu.IDSelector_is_member(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IDSelector
|
|
__del__ = lambda self : None;
|
|
IDSelector_swigregister = _swigfaiss_gpu.IDSelector_swigregister
|
|
IDSelector_swigregister(IDSelector)
|
|
|
|
class IDSelectorRange(IDSelector):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IDSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IDSelectorRange, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IDSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IDSelectorRange, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["imin"] = _swigfaiss_gpu.IDSelectorRange_imin_set
|
|
__swig_getmethods__["imin"] = _swigfaiss_gpu.IDSelectorRange_imin_get
|
|
if _newclass:imin = _swig_property(_swigfaiss_gpu.IDSelectorRange_imin_get, _swigfaiss_gpu.IDSelectorRange_imin_set)
|
|
__swig_setmethods__["imax"] = _swigfaiss_gpu.IDSelectorRange_imax_set
|
|
__swig_getmethods__["imax"] = _swigfaiss_gpu.IDSelectorRange_imax_get
|
|
if _newclass:imax = _swig_property(_swigfaiss_gpu.IDSelectorRange_imax_get, _swigfaiss_gpu.IDSelectorRange_imax_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IDSelectorRange(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def is_member(self, *args): return _swigfaiss_gpu.IDSelectorRange_is_member(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IDSelectorRange
|
|
__del__ = lambda self : None;
|
|
IDSelectorRange_swigregister = _swigfaiss_gpu.IDSelectorRange_swigregister
|
|
IDSelectorRange_swigregister(IDSelectorRange)
|
|
|
|
class IDSelectorBatch(IDSelector):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IDSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IDSelectorBatch, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IDSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IDSelectorBatch, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nbits"] = _swigfaiss_gpu.IDSelectorBatch_nbits_set
|
|
__swig_getmethods__["nbits"] = _swigfaiss_gpu.IDSelectorBatch_nbits_get
|
|
if _newclass:nbits = _swig_property(_swigfaiss_gpu.IDSelectorBatch_nbits_get, _swigfaiss_gpu.IDSelectorBatch_nbits_set)
|
|
__swig_setmethods__["mask"] = _swigfaiss_gpu.IDSelectorBatch_mask_set
|
|
__swig_getmethods__["mask"] = _swigfaiss_gpu.IDSelectorBatch_mask_get
|
|
if _newclass:mask = _swig_property(_swigfaiss_gpu.IDSelectorBatch_mask_get, _swigfaiss_gpu.IDSelectorBatch_mask_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_IDSelectorBatch(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def is_member(self, *args): return _swigfaiss_gpu.IDSelectorBatch_is_member(self, *args)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_IDSelectorBatch
|
|
__del__ = lambda self : None;
|
|
IDSelectorBatch_swigregister = _swigfaiss_gpu.IDSelectorBatch_swigregister
|
|
IDSelectorBatch_swigregister(IDSelectorBatch)
|
|
|
|
class BufferList(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, BufferList, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, BufferList, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["buffer_size"] = _swigfaiss_gpu.BufferList_buffer_size_set
|
|
__swig_getmethods__["buffer_size"] = _swigfaiss_gpu.BufferList_buffer_size_get
|
|
if _newclass:buffer_size = _swig_property(_swigfaiss_gpu.BufferList_buffer_size_get, _swigfaiss_gpu.BufferList_buffer_size_set)
|
|
__swig_setmethods__["buffers"] = _swigfaiss_gpu.BufferList_buffers_set
|
|
__swig_getmethods__["buffers"] = _swigfaiss_gpu.BufferList_buffers_get
|
|
if _newclass:buffers = _swig_property(_swigfaiss_gpu.BufferList_buffers_get, _swigfaiss_gpu.BufferList_buffers_set)
|
|
__swig_setmethods__["wp"] = _swigfaiss_gpu.BufferList_wp_set
|
|
__swig_getmethods__["wp"] = _swigfaiss_gpu.BufferList_wp_get
|
|
if _newclass:wp = _swig_property(_swigfaiss_gpu.BufferList_wp_get, _swigfaiss_gpu.BufferList_wp_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_BufferList(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_BufferList
|
|
__del__ = lambda self : None;
|
|
def append_buffer(self): return _swigfaiss_gpu.BufferList_append_buffer(self)
|
|
def add(self, *args): return _swigfaiss_gpu.BufferList_add(self, *args)
|
|
def copy_range(self, *args): return _swigfaiss_gpu.BufferList_copy_range(self, *args)
|
|
BufferList_swigregister = _swigfaiss_gpu.BufferList_swigregister
|
|
BufferList_swigregister(BufferList)
|
|
|
|
class RangeSearchPartialResult(BufferList):
|
|
__swig_setmethods__ = {}
|
|
for _s in [BufferList]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, RangeSearchPartialResult, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [BufferList]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, RangeSearchPartialResult, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["res"] = _swigfaiss_gpu.RangeSearchPartialResult_res_set
|
|
__swig_getmethods__["res"] = _swigfaiss_gpu.RangeSearchPartialResult_res_get
|
|
if _newclass:res = _swig_property(_swigfaiss_gpu.RangeSearchPartialResult_res_get, _swigfaiss_gpu.RangeSearchPartialResult_res_set)
|
|
def __init__(self, *args):
|
|
this = _swigfaiss_gpu.new_RangeSearchPartialResult(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["queries"] = _swigfaiss_gpu.RangeSearchPartialResult_queries_set
|
|
__swig_getmethods__["queries"] = _swigfaiss_gpu.RangeSearchPartialResult_queries_get
|
|
if _newclass:queries = _swig_property(_swigfaiss_gpu.RangeSearchPartialResult_queries_get, _swigfaiss_gpu.RangeSearchPartialResult_queries_set)
|
|
def new_result(self, *args): return _swigfaiss_gpu.RangeSearchPartialResult_new_result(self, *args)
|
|
def finalize(self): return _swigfaiss_gpu.RangeSearchPartialResult_finalize(self)
|
|
def set_lims(self): return _swigfaiss_gpu.RangeSearchPartialResult_set_lims(self)
|
|
def set_result(self, incremental=False): return _swigfaiss_gpu.RangeSearchPartialResult_set_result(self, incremental)
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_RangeSearchPartialResult
|
|
__del__ = lambda self : None;
|
|
RangeSearchPartialResult_swigregister = _swigfaiss_gpu.RangeSearchPartialResult_swigregister
|
|
RangeSearchPartialResult_swigregister(RangeSearchPartialResult)
|
|
|
|
|
|
def ignore_SIGTTIN():
|
|
return _swigfaiss_gpu.ignore_SIGTTIN()
|
|
ignore_SIGTTIN = _swigfaiss_gpu.ignore_SIGTTIN
|
|
class MapLong2Long(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, MapLong2Long, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, MapLong2Long, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["map"] = _swigfaiss_gpu.MapLong2Long_map_set
|
|
__swig_getmethods__["map"] = _swigfaiss_gpu.MapLong2Long_map_get
|
|
if _newclass:map = _swig_property(_swigfaiss_gpu.MapLong2Long_map_get, _swigfaiss_gpu.MapLong2Long_map_set)
|
|
def add(self, *args): return _swigfaiss_gpu.MapLong2Long_add(self, *args)
|
|
def search(self, *args): return _swigfaiss_gpu.MapLong2Long_search(self, *args)
|
|
def search_multiple(self, *args): return _swigfaiss_gpu.MapLong2Long_search_multiple(self, *args)
|
|
def __init__(self):
|
|
this = _swigfaiss_gpu.new_MapLong2Long()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _swigfaiss_gpu.delete_MapLong2Long
|
|
__del__ = lambda self : None;
|
|
MapLong2Long_swigregister = _swigfaiss_gpu.MapLong2Long_swigregister
|
|
MapLong2Long_swigregister(MapLong2Long)
|
|
|
|
# This file is compatible with both classic and new-style classes.
|
|
|
|
|