mirror of
https://github.com/facebookresearch/faiss.git
synced 2025-06-03 21:54:02 +08:00
5762 lines
260 KiB
Python
5762 lines
260 KiB
Python
# This file was automatically generated by SWIG (http://www.swig.org).
|
|
# Version 3.0.12
|
|
#
|
|
# 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 as _swig_python_version_info
|
|
if _swig_python_version_info >= (2, 7, 0):
|
|
def swig_import_helper():
|
|
import importlib
|
|
pkg = __name__.rpartition('.')[0]
|
|
mname = '.'.join((pkg, '_swigfaiss')).lstrip('.')
|
|
try:
|
|
return importlib.import_module(mname)
|
|
except ImportError:
|
|
return importlib.import_module('_swigfaiss')
|
|
_swigfaiss = swig_import_helper()
|
|
del swig_import_helper
|
|
elif _swig_python_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', [dirname(__file__)])
|
|
except ImportError:
|
|
import _swigfaiss
|
|
return _swigfaiss
|
|
try:
|
|
_mod = imp.load_module('_swigfaiss', fp, pathname, description)
|
|
finally:
|
|
if fp is not None:
|
|
fp.close()
|
|
return _mod
|
|
_swigfaiss = swig_import_helper()
|
|
del swig_import_helper
|
|
else:
|
|
import _swigfaiss
|
|
del _swig_python_version_info
|
|
|
|
try:
|
|
_swig_property = property
|
|
except NameError:
|
|
pass # Python < 2.2 doesn't have 'property'.
|
|
|
|
try:
|
|
import builtins as __builtin__
|
|
except ImportError:
|
|
import __builtin__
|
|
|
|
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):
|
|
if _newclass:
|
|
object.__setattr__(self, name, value)
|
|
else:
|
|
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("'%s' object has no attribute '%s'" % (class_type.__name__, name))
|
|
|
|
|
|
def _swig_repr(self):
|
|
try:
|
|
strthis = "proxy of " + self.this.__repr__()
|
|
except __builtin__.Exception:
|
|
strthis = ""
|
|
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
|
|
|
|
try:
|
|
_object = object
|
|
_newclass = 1
|
|
except __builtin__.Exception:
|
|
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.new_FloatVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.FloatVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.FloatVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.FloatVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.FloatVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.FloatVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.FloatVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.FloatVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_FloatVector
|
|
__del__ = lambda self: None
|
|
FloatVector_swigregister = _swigfaiss.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.new_DoubleVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.DoubleVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.DoubleVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.DoubleVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.DoubleVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.DoubleVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.DoubleVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.DoubleVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_DoubleVector
|
|
__del__ = lambda self: None
|
|
DoubleVector_swigregister = _swigfaiss.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.new_ByteVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.ByteVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.ByteVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.ByteVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.ByteVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.ByteVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.ByteVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.ByteVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_ByteVector
|
|
__del__ = lambda self: None
|
|
ByteVector_swigregister = _swigfaiss.ByteVector_swigregister
|
|
ByteVector_swigregister(ByteVector)
|
|
|
|
class CharVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, CharVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, CharVector, name)
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_CharVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.CharVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.CharVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.CharVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.CharVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.CharVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.CharVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.CharVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_CharVector
|
|
__del__ = lambda self: None
|
|
CharVector_swigregister = _swigfaiss.CharVector_swigregister
|
|
CharVector_swigregister(CharVector)
|
|
|
|
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.new_Uint64Vector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.Uint64Vector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.Uint64Vector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.Uint64Vector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.Uint64Vector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.Uint64Vector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.Uint64Vector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.Uint64Vector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_Uint64Vector
|
|
__del__ = lambda self: None
|
|
Uint64Vector_swigregister = _swigfaiss.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.new_LongVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.LongVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.LongVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.LongVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.LongVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.LongVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.LongVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.LongVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_LongVector
|
|
__del__ = lambda self: None
|
|
LongVector_swigregister = _swigfaiss.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.new_IntVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.IntVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.IntVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.IntVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.IntVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.IntVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.IntVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.IntVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_IntVector
|
|
__del__ = lambda self: None
|
|
IntVector_swigregister = _swigfaiss.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.new_VectorTransformVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.VectorTransformVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.VectorTransformVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.VectorTransformVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.VectorTransformVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.VectorTransformVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.VectorTransformVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.VectorTransformVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_VectorTransformVector
|
|
__del__ = lambda self: None
|
|
VectorTransformVector_swigregister = _swigfaiss.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.new_OperatingPointVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.OperatingPointVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.OperatingPointVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.OperatingPointVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.OperatingPointVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.OperatingPointVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.OperatingPointVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.OperatingPointVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_OperatingPointVector
|
|
__del__ = lambda self: None
|
|
OperatingPointVector_swigregister = _swigfaiss.OperatingPointVector_swigregister
|
|
OperatingPointVector_swigregister(OperatingPointVector)
|
|
|
|
class InvertedListsPtrVector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, InvertedListsPtrVector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, InvertedListsPtrVector, name)
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_InvertedListsPtrVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.InvertedListsPtrVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.InvertedListsPtrVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.InvertedListsPtrVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.InvertedListsPtrVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.InvertedListsPtrVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.InvertedListsPtrVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.InvertedListsPtrVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_InvertedListsPtrVector
|
|
__del__ = lambda self: None
|
|
InvertedListsPtrVector_swigregister = _swigfaiss.InvertedListsPtrVector_swigregister
|
|
InvertedListsPtrVector_swigregister(InvertedListsPtrVector)
|
|
|
|
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.new_FloatVectorVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.FloatVectorVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.FloatVectorVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.FloatVectorVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.FloatVectorVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.FloatVectorVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.FloatVectorVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.FloatVectorVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_FloatVectorVector
|
|
__del__ = lambda self: None
|
|
FloatVectorVector_swigregister = _swigfaiss.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.new_ByteVectorVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.ByteVectorVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.ByteVectorVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.ByteVectorVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.ByteVectorVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.ByteVectorVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.ByteVectorVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.ByteVectorVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_ByteVectorVector
|
|
__del__ = lambda self: None
|
|
ByteVectorVector_swigregister = _swigfaiss.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.new_LongVectorVector()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def push_back(self, arg2):
|
|
return _swigfaiss.LongVectorVector_push_back(self, arg2)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.LongVectorVector_clear(self)
|
|
|
|
def data(self):
|
|
return _swigfaiss.LongVectorVector_data(self)
|
|
|
|
def size(self):
|
|
return _swigfaiss.LongVectorVector_size(self)
|
|
|
|
def at(self, n):
|
|
return _swigfaiss.LongVectorVector_at(self, n)
|
|
|
|
def resize(self, n):
|
|
return _swigfaiss.LongVectorVector_resize(self, n)
|
|
|
|
def swap(self, other):
|
|
return _swigfaiss.LongVectorVector_swap(self, other)
|
|
__swig_destroy__ = _swigfaiss.delete_LongVectorVector
|
|
__del__ = lambda self: None
|
|
LongVectorVector_swigregister = _swigfaiss.LongVectorVector_swigregister
|
|
LongVectorVector_swigregister(LongVectorVector)
|
|
|
|
|
|
def popcount64(x):
|
|
return _swigfaiss.popcount64(x)
|
|
popcount64 = _swigfaiss.popcount64
|
|
|
|
def hammings(a, b, na, nb, nbytespercode, dis):
|
|
return _swigfaiss.hammings(a, b, na, nb, nbytespercode, dis)
|
|
hammings = _swigfaiss.hammings
|
|
|
|
def bitvec_print(b, d):
|
|
return _swigfaiss.bitvec_print(b, d)
|
|
bitvec_print = _swigfaiss.bitvec_print
|
|
|
|
def fvecs2bitvecs(x, b, d, n):
|
|
return _swigfaiss.fvecs2bitvecs(x, b, d, n)
|
|
fvecs2bitvecs = _swigfaiss.fvecs2bitvecs
|
|
|
|
def fvec2bitvec(x, b, d):
|
|
return _swigfaiss.fvec2bitvec(x, b, d)
|
|
fvec2bitvec = _swigfaiss.fvec2bitvec
|
|
|
|
def hammings_knn_hc(ha, a, b, nb, ncodes, ordered):
|
|
return _swigfaiss.hammings_knn_hc(ha, a, b, nb, ncodes, ordered)
|
|
hammings_knn_hc = _swigfaiss.hammings_knn_hc
|
|
|
|
def hammings_knn(ha, a, b, nb, ncodes, ordered):
|
|
return _swigfaiss.hammings_knn(ha, a, b, nb, ncodes, ordered)
|
|
hammings_knn = _swigfaiss.hammings_knn
|
|
|
|
def hammings_knn_mc(a, b, na, nb, k, ncodes, distances, labels):
|
|
return _swigfaiss.hammings_knn_mc(a, b, na, nb, k, ncodes, distances, labels)
|
|
hammings_knn_mc = _swigfaiss.hammings_knn_mc
|
|
|
|
def hamming_count_thres(bs1, bs2, n1, n2, ht, ncodes, nptr):
|
|
return _swigfaiss.hamming_count_thres(bs1, bs2, n1, n2, ht, ncodes, nptr)
|
|
hamming_count_thres = _swigfaiss.hamming_count_thres
|
|
|
|
def match_hamming_thres(bs1, bs2, n1, n2, ht, ncodes, idx, dis):
|
|
return _swigfaiss.match_hamming_thres(bs1, bs2, n1, n2, ht, ncodes, idx, dis)
|
|
match_hamming_thres = _swigfaiss.match_hamming_thres
|
|
|
|
def crosshamming_count_thres(dbs, n, ht, ncodes, nptr):
|
|
return _swigfaiss.crosshamming_count_thres(dbs, n, ht, ncodes, nptr)
|
|
crosshamming_count_thres = _swigfaiss.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.HammingComputer4_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss.HammingComputer4_a0_get
|
|
if _newclass:
|
|
a0 = _swig_property(_swigfaiss.HammingComputer4_a0_get, _swigfaiss.HammingComputer4_a0_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_HammingComputer4(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, a, code_size):
|
|
return _swigfaiss.HammingComputer4_set(self, a, code_size)
|
|
|
|
def hamming(self, b):
|
|
return _swigfaiss.HammingComputer4_hamming(self, b)
|
|
__swig_destroy__ = _swigfaiss.delete_HammingComputer4
|
|
__del__ = lambda self: None
|
|
HammingComputer4_swigregister = _swigfaiss.HammingComputer4_swigregister
|
|
HammingComputer4_swigregister(HammingComputer4)
|
|
cvar = _swigfaiss.cvar
|
|
|
|
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.HammingComputer8_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss.HammingComputer8_a0_get
|
|
if _newclass:
|
|
a0 = _swig_property(_swigfaiss.HammingComputer8_a0_get, _swigfaiss.HammingComputer8_a0_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_HammingComputer8(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, a, code_size):
|
|
return _swigfaiss.HammingComputer8_set(self, a, code_size)
|
|
|
|
def hamming(self, b):
|
|
return _swigfaiss.HammingComputer8_hamming(self, b)
|
|
__swig_destroy__ = _swigfaiss.delete_HammingComputer8
|
|
__del__ = lambda self: None
|
|
HammingComputer8_swigregister = _swigfaiss.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.HammingComputer16_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss.HammingComputer16_a0_get
|
|
if _newclass:
|
|
a0 = _swig_property(_swigfaiss.HammingComputer16_a0_get, _swigfaiss.HammingComputer16_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss.HammingComputer16_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss.HammingComputer16_a1_get
|
|
if _newclass:
|
|
a1 = _swig_property(_swigfaiss.HammingComputer16_a1_get, _swigfaiss.HammingComputer16_a1_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_HammingComputer16(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, a8, code_size):
|
|
return _swigfaiss.HammingComputer16_set(self, a8, code_size)
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.HammingComputer16_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_HammingComputer16
|
|
__del__ = lambda self: None
|
|
HammingComputer16_swigregister = _swigfaiss.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.HammingComputer20_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss.HammingComputer20_a0_get
|
|
if _newclass:
|
|
a0 = _swig_property(_swigfaiss.HammingComputer20_a0_get, _swigfaiss.HammingComputer20_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss.HammingComputer20_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss.HammingComputer20_a1_get
|
|
if _newclass:
|
|
a1 = _swig_property(_swigfaiss.HammingComputer20_a1_get, _swigfaiss.HammingComputer20_a1_set)
|
|
__swig_setmethods__["a2"] = _swigfaiss.HammingComputer20_a2_set
|
|
__swig_getmethods__["a2"] = _swigfaiss.HammingComputer20_a2_get
|
|
if _newclass:
|
|
a2 = _swig_property(_swigfaiss.HammingComputer20_a2_get, _swigfaiss.HammingComputer20_a2_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_HammingComputer20(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, a8, code_size):
|
|
return _swigfaiss.HammingComputer20_set(self, a8, code_size)
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.HammingComputer20_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_HammingComputer20
|
|
__del__ = lambda self: None
|
|
HammingComputer20_swigregister = _swigfaiss.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.HammingComputer32_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss.HammingComputer32_a0_get
|
|
if _newclass:
|
|
a0 = _swig_property(_swigfaiss.HammingComputer32_a0_get, _swigfaiss.HammingComputer32_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss.HammingComputer32_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss.HammingComputer32_a1_get
|
|
if _newclass:
|
|
a1 = _swig_property(_swigfaiss.HammingComputer32_a1_get, _swigfaiss.HammingComputer32_a1_set)
|
|
__swig_setmethods__["a2"] = _swigfaiss.HammingComputer32_a2_set
|
|
__swig_getmethods__["a2"] = _swigfaiss.HammingComputer32_a2_get
|
|
if _newclass:
|
|
a2 = _swig_property(_swigfaiss.HammingComputer32_a2_get, _swigfaiss.HammingComputer32_a2_set)
|
|
__swig_setmethods__["a3"] = _swigfaiss.HammingComputer32_a3_set
|
|
__swig_getmethods__["a3"] = _swigfaiss.HammingComputer32_a3_get
|
|
if _newclass:
|
|
a3 = _swig_property(_swigfaiss.HammingComputer32_a3_get, _swigfaiss.HammingComputer32_a3_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_HammingComputer32(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, a8, code_size):
|
|
return _swigfaiss.HammingComputer32_set(self, a8, code_size)
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.HammingComputer32_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_HammingComputer32
|
|
__del__ = lambda self: None
|
|
HammingComputer32_swigregister = _swigfaiss.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.HammingComputer64_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss.HammingComputer64_a0_get
|
|
if _newclass:
|
|
a0 = _swig_property(_swigfaiss.HammingComputer64_a0_get, _swigfaiss.HammingComputer64_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss.HammingComputer64_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss.HammingComputer64_a1_get
|
|
if _newclass:
|
|
a1 = _swig_property(_swigfaiss.HammingComputer64_a1_get, _swigfaiss.HammingComputer64_a1_set)
|
|
__swig_setmethods__["a2"] = _swigfaiss.HammingComputer64_a2_set
|
|
__swig_getmethods__["a2"] = _swigfaiss.HammingComputer64_a2_get
|
|
if _newclass:
|
|
a2 = _swig_property(_swigfaiss.HammingComputer64_a2_get, _swigfaiss.HammingComputer64_a2_set)
|
|
__swig_setmethods__["a3"] = _swigfaiss.HammingComputer64_a3_set
|
|
__swig_getmethods__["a3"] = _swigfaiss.HammingComputer64_a3_get
|
|
if _newclass:
|
|
a3 = _swig_property(_swigfaiss.HammingComputer64_a3_get, _swigfaiss.HammingComputer64_a3_set)
|
|
__swig_setmethods__["a4"] = _swigfaiss.HammingComputer64_a4_set
|
|
__swig_getmethods__["a4"] = _swigfaiss.HammingComputer64_a4_get
|
|
if _newclass:
|
|
a4 = _swig_property(_swigfaiss.HammingComputer64_a4_get, _swigfaiss.HammingComputer64_a4_set)
|
|
__swig_setmethods__["a5"] = _swigfaiss.HammingComputer64_a5_set
|
|
__swig_getmethods__["a5"] = _swigfaiss.HammingComputer64_a5_get
|
|
if _newclass:
|
|
a5 = _swig_property(_swigfaiss.HammingComputer64_a5_get, _swigfaiss.HammingComputer64_a5_set)
|
|
__swig_setmethods__["a6"] = _swigfaiss.HammingComputer64_a6_set
|
|
__swig_getmethods__["a6"] = _swigfaiss.HammingComputer64_a6_get
|
|
if _newclass:
|
|
a6 = _swig_property(_swigfaiss.HammingComputer64_a6_get, _swigfaiss.HammingComputer64_a6_set)
|
|
__swig_setmethods__["a7"] = _swigfaiss.HammingComputer64_a7_set
|
|
__swig_getmethods__["a7"] = _swigfaiss.HammingComputer64_a7_get
|
|
if _newclass:
|
|
a7 = _swig_property(_swigfaiss.HammingComputer64_a7_get, _swigfaiss.HammingComputer64_a7_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_HammingComputer64(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, a8, code_size):
|
|
return _swigfaiss.HammingComputer64_set(self, a8, code_size)
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.HammingComputer64_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_HammingComputer64
|
|
__del__ = lambda self: None
|
|
HammingComputer64_swigregister = _swigfaiss.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.HammingComputerDefault_a_set
|
|
__swig_getmethods__["a"] = _swigfaiss.HammingComputerDefault_a_get
|
|
if _newclass:
|
|
a = _swig_property(_swigfaiss.HammingComputerDefault_a_get, _swigfaiss.HammingComputerDefault_a_set)
|
|
__swig_setmethods__["n"] = _swigfaiss.HammingComputerDefault_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss.HammingComputerDefault_n_get
|
|
if _newclass:
|
|
n = _swig_property(_swigfaiss.HammingComputerDefault_n_get, _swigfaiss.HammingComputerDefault_n_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_HammingComputerDefault(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, a8, code_size):
|
|
return _swigfaiss.HammingComputerDefault_set(self, a8, code_size)
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.HammingComputerDefault_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_HammingComputerDefault
|
|
__del__ = lambda self: None
|
|
HammingComputerDefault_swigregister = _swigfaiss.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.HammingComputerM8_a_set
|
|
__swig_getmethods__["a"] = _swigfaiss.HammingComputerM8_a_get
|
|
if _newclass:
|
|
a = _swig_property(_swigfaiss.HammingComputerM8_a_get, _swigfaiss.HammingComputerM8_a_set)
|
|
__swig_setmethods__["n"] = _swigfaiss.HammingComputerM8_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss.HammingComputerM8_n_get
|
|
if _newclass:
|
|
n = _swig_property(_swigfaiss.HammingComputerM8_n_get, _swigfaiss.HammingComputerM8_n_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_HammingComputerM8(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, a8, code_size):
|
|
return _swigfaiss.HammingComputerM8_set(self, a8, code_size)
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.HammingComputerM8_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_HammingComputerM8
|
|
__del__ = lambda self: None
|
|
HammingComputerM8_swigregister = _swigfaiss.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.HammingComputerM4_a_set
|
|
__swig_getmethods__["a"] = _swigfaiss.HammingComputerM4_a_get
|
|
if _newclass:
|
|
a = _swig_property(_swigfaiss.HammingComputerM4_a_get, _swigfaiss.HammingComputerM4_a_set)
|
|
__swig_setmethods__["n"] = _swigfaiss.HammingComputerM4_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss.HammingComputerM4_n_get
|
|
if _newclass:
|
|
n = _swig_property(_swigfaiss.HammingComputerM4_n_get, _swigfaiss.HammingComputerM4_n_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_HammingComputerM4(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, a4, code_size):
|
|
return _swigfaiss.HammingComputerM4_set(self, a4, code_size)
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.HammingComputerM4_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_HammingComputerM4
|
|
__del__ = lambda self: None
|
|
HammingComputerM4_swigregister = _swigfaiss.HammingComputerM4_swigregister
|
|
HammingComputerM4_swigregister(HammingComputerM4)
|
|
|
|
|
|
def generalized_hamming_64(a):
|
|
return _swigfaiss.generalized_hamming_64(a)
|
|
generalized_hamming_64 = _swigfaiss.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.GenHammingComputer8_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss.GenHammingComputer8_a0_get
|
|
if _newclass:
|
|
a0 = _swig_property(_swigfaiss.GenHammingComputer8_a0_get, _swigfaiss.GenHammingComputer8_a0_set)
|
|
|
|
def __init__(self, a, code_size):
|
|
this = _swigfaiss.new_GenHammingComputer8(a, code_size)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def hamming(self, b):
|
|
return _swigfaiss.GenHammingComputer8_hamming(self, b)
|
|
__swig_destroy__ = _swigfaiss.delete_GenHammingComputer8
|
|
__del__ = lambda self: None
|
|
GenHammingComputer8_swigregister = _swigfaiss.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.GenHammingComputer16_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss.GenHammingComputer16_a0_get
|
|
if _newclass:
|
|
a0 = _swig_property(_swigfaiss.GenHammingComputer16_a0_get, _swigfaiss.GenHammingComputer16_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss.GenHammingComputer16_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss.GenHammingComputer16_a1_get
|
|
if _newclass:
|
|
a1 = _swig_property(_swigfaiss.GenHammingComputer16_a1_get, _swigfaiss.GenHammingComputer16_a1_set)
|
|
|
|
def __init__(self, a8, code_size):
|
|
this = _swigfaiss.new_GenHammingComputer16(a8, code_size)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.GenHammingComputer16_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_GenHammingComputer16
|
|
__del__ = lambda self: None
|
|
GenHammingComputer16_swigregister = _swigfaiss.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.GenHammingComputer32_a0_set
|
|
__swig_getmethods__["a0"] = _swigfaiss.GenHammingComputer32_a0_get
|
|
if _newclass:
|
|
a0 = _swig_property(_swigfaiss.GenHammingComputer32_a0_get, _swigfaiss.GenHammingComputer32_a0_set)
|
|
__swig_setmethods__["a1"] = _swigfaiss.GenHammingComputer32_a1_set
|
|
__swig_getmethods__["a1"] = _swigfaiss.GenHammingComputer32_a1_get
|
|
if _newclass:
|
|
a1 = _swig_property(_swigfaiss.GenHammingComputer32_a1_get, _swigfaiss.GenHammingComputer32_a1_set)
|
|
__swig_setmethods__["a2"] = _swigfaiss.GenHammingComputer32_a2_set
|
|
__swig_getmethods__["a2"] = _swigfaiss.GenHammingComputer32_a2_get
|
|
if _newclass:
|
|
a2 = _swig_property(_swigfaiss.GenHammingComputer32_a2_get, _swigfaiss.GenHammingComputer32_a2_set)
|
|
__swig_setmethods__["a3"] = _swigfaiss.GenHammingComputer32_a3_set
|
|
__swig_getmethods__["a3"] = _swigfaiss.GenHammingComputer32_a3_get
|
|
if _newclass:
|
|
a3 = _swig_property(_swigfaiss.GenHammingComputer32_a3_get, _swigfaiss.GenHammingComputer32_a3_set)
|
|
|
|
def __init__(self, a8, code_size):
|
|
this = _swigfaiss.new_GenHammingComputer32(a8, code_size)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.GenHammingComputer32_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_GenHammingComputer32
|
|
__del__ = lambda self: None
|
|
GenHammingComputer32_swigregister = _swigfaiss.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.GenHammingComputerM8_a_set
|
|
__swig_getmethods__["a"] = _swigfaiss.GenHammingComputerM8_a_get
|
|
if _newclass:
|
|
a = _swig_property(_swigfaiss.GenHammingComputerM8_a_get, _swigfaiss.GenHammingComputerM8_a_set)
|
|
__swig_setmethods__["n"] = _swigfaiss.GenHammingComputerM8_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss.GenHammingComputerM8_n_get
|
|
if _newclass:
|
|
n = _swig_property(_swigfaiss.GenHammingComputerM8_n_get, _swigfaiss.GenHammingComputerM8_n_set)
|
|
|
|
def __init__(self, a8, code_size):
|
|
this = _swigfaiss.new_GenHammingComputerM8(a8, code_size)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def hamming(self, b8):
|
|
return _swigfaiss.GenHammingComputerM8_hamming(self, b8)
|
|
__swig_destroy__ = _swigfaiss.delete_GenHammingComputerM8
|
|
__del__ = lambda self: None
|
|
GenHammingComputerM8_swigregister = _swigfaiss.GenHammingComputerM8_swigregister
|
|
GenHammingComputerM8_swigregister(GenHammingComputerM8)
|
|
|
|
|
|
def generalized_hammings_knn_hc(ha, a, b, nb, code_size, ordered=True):
|
|
return _swigfaiss.generalized_hammings_knn_hc(ha, a, b, nb, code_size, ordered)
|
|
generalized_hammings_knn_hc = _swigfaiss.generalized_hammings_knn_hc
|
|
|
|
def get_num_gpus():
|
|
return _swigfaiss.get_num_gpus()
|
|
get_num_gpus = _swigfaiss.get_num_gpus
|
|
|
|
def getmillisecs():
|
|
return _swigfaiss.getmillisecs()
|
|
getmillisecs = _swigfaiss.getmillisecs
|
|
|
|
def get_mem_usage_kb():
|
|
return _swigfaiss.get_mem_usage_kb()
|
|
get_mem_usage_kb = _swigfaiss.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
|
|
__swig_setmethods__["mt"] = _swigfaiss.RandomGenerator_mt_set
|
|
__swig_getmethods__["mt"] = _swigfaiss.RandomGenerator_mt_get
|
|
if _newclass:
|
|
mt = _swig_property(_swigfaiss.RandomGenerator_mt_get, _swigfaiss.RandomGenerator_mt_set)
|
|
|
|
def rand_long(self):
|
|
return _swigfaiss.RandomGenerator_rand_long(self)
|
|
|
|
def rand_int(self, *args):
|
|
return _swigfaiss.RandomGenerator_rand_int(self, *args)
|
|
|
|
def rand_float(self):
|
|
return _swigfaiss.RandomGenerator_rand_float(self)
|
|
|
|
def rand_double(self):
|
|
return _swigfaiss.RandomGenerator_rand_double(self)
|
|
|
|
def __init__(self, seed=1234):
|
|
this = _swigfaiss.new_RandomGenerator(seed)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_RandomGenerator
|
|
__del__ = lambda self: None
|
|
RandomGenerator_swigregister = _swigfaiss.RandomGenerator_swigregister
|
|
RandomGenerator_swigregister(RandomGenerator)
|
|
|
|
|
|
def float_rand(x, n, seed):
|
|
return _swigfaiss.float_rand(x, n, seed)
|
|
float_rand = _swigfaiss.float_rand
|
|
|
|
def float_randn(x, n, seed):
|
|
return _swigfaiss.float_randn(x, n, seed)
|
|
float_randn = _swigfaiss.float_randn
|
|
|
|
def long_rand(x, n, seed):
|
|
return _swigfaiss.long_rand(x, n, seed)
|
|
long_rand = _swigfaiss.long_rand
|
|
|
|
def byte_rand(x, n, seed):
|
|
return _swigfaiss.byte_rand(x, n, seed)
|
|
byte_rand = _swigfaiss.byte_rand
|
|
|
|
def rand_perm(perm, n, seed):
|
|
return _swigfaiss.rand_perm(perm, n, seed)
|
|
rand_perm = _swigfaiss.rand_perm
|
|
|
|
def fvec_L2sqr(x, y, d):
|
|
return _swigfaiss.fvec_L2sqr(x, y, d)
|
|
fvec_L2sqr = _swigfaiss.fvec_L2sqr
|
|
|
|
def fvec_inner_product(x, y, d):
|
|
return _swigfaiss.fvec_inner_product(x, y, d)
|
|
fvec_inner_product = _swigfaiss.fvec_inner_product
|
|
|
|
def imbalance_factor(*args):
|
|
return _swigfaiss.imbalance_factor(*args)
|
|
imbalance_factor = _swigfaiss.imbalance_factor
|
|
|
|
def pairwise_L2sqr(d, nq, xq, nb, xb, dis, ldq=-1, ldb=-1, ldd=-1):
|
|
return _swigfaiss.pairwise_L2sqr(d, nq, xq, nb, xb, dis, ldq, ldb, ldd)
|
|
pairwise_L2sqr = _swigfaiss.pairwise_L2sqr
|
|
|
|
def fvec_inner_products_ny(ip, x, y, d, ny):
|
|
return _swigfaiss.fvec_inner_products_ny(ip, x, y, d, ny)
|
|
fvec_inner_products_ny = _swigfaiss.fvec_inner_products_ny
|
|
|
|
def fvec_L2sqr_ny(dis, x, y, d, ny):
|
|
return _swigfaiss.fvec_L2sqr_ny(dis, x, y, d, ny)
|
|
fvec_L2sqr_ny = _swigfaiss.fvec_L2sqr_ny
|
|
|
|
def fvec_norm_L2sqr(x, d):
|
|
return _swigfaiss.fvec_norm_L2sqr(x, d)
|
|
fvec_norm_L2sqr = _swigfaiss.fvec_norm_L2sqr
|
|
|
|
def fvec_norms_L2(ip, x, d, nx):
|
|
return _swigfaiss.fvec_norms_L2(ip, x, d, nx)
|
|
fvec_norms_L2 = _swigfaiss.fvec_norms_L2
|
|
|
|
def fvec_norms_L2sqr(ip, x, d, nx):
|
|
return _swigfaiss.fvec_norms_L2sqr(ip, x, d, nx)
|
|
fvec_norms_L2sqr = _swigfaiss.fvec_norms_L2sqr
|
|
|
|
def fvec_renorm_L2(d, nx, x):
|
|
return _swigfaiss.fvec_renorm_L2(d, nx, x)
|
|
fvec_renorm_L2 = _swigfaiss.fvec_renorm_L2
|
|
|
|
def inner_product_to_L2sqr(dis, nr1, nr2, n1, n2):
|
|
return _swigfaiss.inner_product_to_L2sqr(dis, nr1, nr2, n1, n2)
|
|
inner_product_to_L2sqr = _swigfaiss.inner_product_to_L2sqr
|
|
|
|
def fvec_inner_products_by_idx(ip, x, y, ids, d, nx, ny):
|
|
return _swigfaiss.fvec_inner_products_by_idx(ip, x, y, ids, d, nx, ny)
|
|
fvec_inner_products_by_idx = _swigfaiss.fvec_inner_products_by_idx
|
|
|
|
def fvec_L2sqr_by_idx(dis, x, y, ids, d, nx, ny):
|
|
return _swigfaiss.fvec_L2sqr_by_idx(dis, x, y, ids, d, nx, ny)
|
|
fvec_L2sqr_by_idx = _swigfaiss.fvec_L2sqr_by_idx
|
|
|
|
def knn_inner_product(x, y, d, nx, ny, res):
|
|
return _swigfaiss.knn_inner_product(x, y, d, nx, ny, res)
|
|
knn_inner_product = _swigfaiss.knn_inner_product
|
|
|
|
def knn_L2sqr(x, y, d, nx, ny, res):
|
|
return _swigfaiss.knn_L2sqr(x, y, d, nx, ny, res)
|
|
knn_L2sqr = _swigfaiss.knn_L2sqr
|
|
|
|
def knn_L2sqr_base_shift(x, y, d, nx, ny, res, base_shift):
|
|
return _swigfaiss.knn_L2sqr_base_shift(x, y, d, nx, ny, res, base_shift)
|
|
knn_L2sqr_base_shift = _swigfaiss.knn_L2sqr_base_shift
|
|
|
|
def knn_inner_products_by_idx(x, y, ids, d, nx, ny, res):
|
|
return _swigfaiss.knn_inner_products_by_idx(x, y, ids, d, nx, ny, res)
|
|
knn_inner_products_by_idx = _swigfaiss.knn_inner_products_by_idx
|
|
|
|
def knn_L2sqr_by_idx(x, y, ids, d, nx, ny, res):
|
|
return _swigfaiss.knn_L2sqr_by_idx(x, y, ids, d, nx, ny, res)
|
|
knn_L2sqr_by_idx = _swigfaiss.knn_L2sqr_by_idx
|
|
|
|
def range_search_L2sqr(x, y, d, nx, ny, radius, result):
|
|
return _swigfaiss.range_search_L2sqr(x, y, d, nx, ny, radius, result)
|
|
range_search_L2sqr = _swigfaiss.range_search_L2sqr
|
|
|
|
def range_search_inner_product(x, y, d, nx, ny, radius, result):
|
|
return _swigfaiss.range_search_inner_product(x, y, d, nx, ny, radius, result)
|
|
range_search_inner_product = _swigfaiss.range_search_inner_product
|
|
|
|
def fvec_madd(n, a, bf, b, c):
|
|
return _swigfaiss.fvec_madd(n, a, bf, b, c)
|
|
fvec_madd = _swigfaiss.fvec_madd
|
|
|
|
def fvec_madd_and_argmin(n, a, bf, b, c):
|
|
return _swigfaiss.fvec_madd_and_argmin(n, a, bf, b, c)
|
|
fvec_madd_and_argmin = _swigfaiss.fvec_madd_and_argmin
|
|
|
|
def reflection(u, x, n, d, nu):
|
|
return _swigfaiss.reflection(u, x, n, d, nu)
|
|
reflection = _swigfaiss.reflection
|
|
|
|
def km_update_centroids(x, centroids, assign, d, k, n, k_frozen):
|
|
return _swigfaiss.km_update_centroids(x, centroids, assign, d, k, n, k_frozen)
|
|
km_update_centroids = _swigfaiss.km_update_centroids
|
|
|
|
def matrix_qr(m, n, a):
|
|
return _swigfaiss.matrix_qr(m, n, a)
|
|
matrix_qr = _swigfaiss.matrix_qr
|
|
|
|
def ranklist_handle_ties(k, idx, dis):
|
|
return _swigfaiss.ranklist_handle_ties(k, idx, dis)
|
|
ranklist_handle_ties = _swigfaiss.ranklist_handle_ties
|
|
|
|
def ranklist_intersection_size(k1, v1, k2, v2):
|
|
return _swigfaiss.ranklist_intersection_size(k1, v1, k2, v2)
|
|
ranklist_intersection_size = _swigfaiss.ranklist_intersection_size
|
|
|
|
def merge_result_table_with(n, k, I0, D0, I1, D1, keep_min=True, translation=0):
|
|
return _swigfaiss.merge_result_table_with(n, k, I0, D0, I1, D1, keep_min, translation)
|
|
merge_result_table_with = _swigfaiss.merge_result_table_with
|
|
|
|
def fvec_argsort(n, vals, perm):
|
|
return _swigfaiss.fvec_argsort(n, vals, perm)
|
|
fvec_argsort = _swigfaiss.fvec_argsort
|
|
|
|
def fvec_argsort_parallel(n, vals, perm):
|
|
return _swigfaiss.fvec_argsort_parallel(n, vals, perm)
|
|
fvec_argsort_parallel = _swigfaiss.fvec_argsort_parallel
|
|
|
|
def ivec_hist(n, v, vmax, hist):
|
|
return _swigfaiss.ivec_hist(n, v, vmax, hist)
|
|
ivec_hist = _swigfaiss.ivec_hist
|
|
|
|
def bincode_hist(n, nbits, codes, hist):
|
|
return _swigfaiss.bincode_hist(n, nbits, codes, hist)
|
|
bincode_hist = _swigfaiss.bincode_hist
|
|
|
|
def ivec_checksum(n, a):
|
|
return _swigfaiss.ivec_checksum(n, a)
|
|
ivec_checksum = _swigfaiss.ivec_checksum
|
|
|
|
def fvecs_maybe_subsample(d, n, nmax, x, verbose=False, seed=1234):
|
|
return _swigfaiss.fvecs_maybe_subsample(d, n, nmax, x, verbose, seed)
|
|
fvecs_maybe_subsample = _swigfaiss.fvecs_maybe_subsample
|
|
|
|
def binary_to_real(d, x_in, x_out):
|
|
return _swigfaiss.binary_to_real(d, x_in, x_out)
|
|
binary_to_real = _swigfaiss.binary_to_real
|
|
|
|
def real_to_binary(d, x_in, x_out):
|
|
return _swigfaiss.real_to_binary(d, x_in, x_out)
|
|
real_to_binary = _swigfaiss.real_to_binary
|
|
FAISS_VERSION_MAJOR = _swigfaiss.FAISS_VERSION_MAJOR
|
|
FAISS_VERSION_MINOR = _swigfaiss.FAISS_VERSION_MINOR
|
|
FAISS_VERSION_PATCH = _swigfaiss.FAISS_VERSION_PATCH
|
|
METRIC_INNER_PRODUCT = _swigfaiss.METRIC_INNER_PRODUCT
|
|
METRIC_L2 = _swigfaiss.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.Index_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss.Index_d_get
|
|
if _newclass:
|
|
d = _swig_property(_swigfaiss.Index_d_get, _swigfaiss.Index_d_set)
|
|
__swig_setmethods__["ntotal"] = _swigfaiss.Index_ntotal_set
|
|
__swig_getmethods__["ntotal"] = _swigfaiss.Index_ntotal_get
|
|
if _newclass:
|
|
ntotal = _swig_property(_swigfaiss.Index_ntotal_get, _swigfaiss.Index_ntotal_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss.Index_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss.Index_verbose_get
|
|
if _newclass:
|
|
verbose = _swig_property(_swigfaiss.Index_verbose_get, _swigfaiss.Index_verbose_set)
|
|
__swig_setmethods__["is_trained"] = _swigfaiss.Index_is_trained_set
|
|
__swig_getmethods__["is_trained"] = _swigfaiss.Index_is_trained_get
|
|
if _newclass:
|
|
is_trained = _swig_property(_swigfaiss.Index_is_trained_get, _swigfaiss.Index_is_trained_set)
|
|
__swig_setmethods__["metric_type"] = _swigfaiss.Index_metric_type_set
|
|
__swig_getmethods__["metric_type"] = _swigfaiss.Index_metric_type_get
|
|
if _newclass:
|
|
metric_type = _swig_property(_swigfaiss.Index_metric_type_get, _swigfaiss.Index_metric_type_set)
|
|
__swig_destroy__ = _swigfaiss.delete_Index
|
|
__del__ = lambda self: None
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.Index_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.Index_add(self, n, x)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.Index_add_with_ids(self, n, x, xids)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.Index_search(self, n, x, k, distances, labels)
|
|
|
|
def range_search(self, n, x, radius, result):
|
|
return _swigfaiss.Index_range_search(self, n, x, radius, result)
|
|
|
|
def assign(self, n, x, labels, k=1):
|
|
return _swigfaiss.Index_assign(self, n, x, labels, k)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.Index_reset(self)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.Index_remove_ids(self, sel)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.Index_reconstruct(self, key, recons)
|
|
|
|
def reconstruct_n(self, i0, ni, recons):
|
|
return _swigfaiss.Index_reconstruct_n(self, i0, ni, recons)
|
|
|
|
def search_and_reconstruct(self, n, x, k, distances, labels, recons):
|
|
return _swigfaiss.Index_search_and_reconstruct(self, n, x, k, distances, labels, recons)
|
|
|
|
def compute_residual(self, x, residual, key):
|
|
return _swigfaiss.Index_compute_residual(self, x, residual, key)
|
|
|
|
def display(self):
|
|
return _swigfaiss.Index_display(self)
|
|
Index_swigregister = _swigfaiss.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.ClusteringParameters_niter_set
|
|
__swig_getmethods__["niter"] = _swigfaiss.ClusteringParameters_niter_get
|
|
if _newclass:
|
|
niter = _swig_property(_swigfaiss.ClusteringParameters_niter_get, _swigfaiss.ClusteringParameters_niter_set)
|
|
__swig_setmethods__["nredo"] = _swigfaiss.ClusteringParameters_nredo_set
|
|
__swig_getmethods__["nredo"] = _swigfaiss.ClusteringParameters_nredo_get
|
|
if _newclass:
|
|
nredo = _swig_property(_swigfaiss.ClusteringParameters_nredo_get, _swigfaiss.ClusteringParameters_nredo_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss.ClusteringParameters_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss.ClusteringParameters_verbose_get
|
|
if _newclass:
|
|
verbose = _swig_property(_swigfaiss.ClusteringParameters_verbose_get, _swigfaiss.ClusteringParameters_verbose_set)
|
|
__swig_setmethods__["spherical"] = _swigfaiss.ClusteringParameters_spherical_set
|
|
__swig_getmethods__["spherical"] = _swigfaiss.ClusteringParameters_spherical_get
|
|
if _newclass:
|
|
spherical = _swig_property(_swigfaiss.ClusteringParameters_spherical_get, _swigfaiss.ClusteringParameters_spherical_set)
|
|
__swig_setmethods__["update_index"] = _swigfaiss.ClusteringParameters_update_index_set
|
|
__swig_getmethods__["update_index"] = _swigfaiss.ClusteringParameters_update_index_get
|
|
if _newclass:
|
|
update_index = _swig_property(_swigfaiss.ClusteringParameters_update_index_get, _swigfaiss.ClusteringParameters_update_index_set)
|
|
__swig_setmethods__["frozen_centroids"] = _swigfaiss.ClusteringParameters_frozen_centroids_set
|
|
__swig_getmethods__["frozen_centroids"] = _swigfaiss.ClusteringParameters_frozen_centroids_get
|
|
if _newclass:
|
|
frozen_centroids = _swig_property(_swigfaiss.ClusteringParameters_frozen_centroids_get, _swigfaiss.ClusteringParameters_frozen_centroids_set)
|
|
__swig_setmethods__["min_points_per_centroid"] = _swigfaiss.ClusteringParameters_min_points_per_centroid_set
|
|
__swig_getmethods__["min_points_per_centroid"] = _swigfaiss.ClusteringParameters_min_points_per_centroid_get
|
|
if _newclass:
|
|
min_points_per_centroid = _swig_property(_swigfaiss.ClusteringParameters_min_points_per_centroid_get, _swigfaiss.ClusteringParameters_min_points_per_centroid_set)
|
|
__swig_setmethods__["max_points_per_centroid"] = _swigfaiss.ClusteringParameters_max_points_per_centroid_set
|
|
__swig_getmethods__["max_points_per_centroid"] = _swigfaiss.ClusteringParameters_max_points_per_centroid_get
|
|
if _newclass:
|
|
max_points_per_centroid = _swig_property(_swigfaiss.ClusteringParameters_max_points_per_centroid_get, _swigfaiss.ClusteringParameters_max_points_per_centroid_set)
|
|
__swig_setmethods__["seed"] = _swigfaiss.ClusteringParameters_seed_set
|
|
__swig_getmethods__["seed"] = _swigfaiss.ClusteringParameters_seed_get
|
|
if _newclass:
|
|
seed = _swig_property(_swigfaiss.ClusteringParameters_seed_get, _swigfaiss.ClusteringParameters_seed_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_ClusteringParameters()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_ClusteringParameters
|
|
__del__ = lambda self: None
|
|
ClusteringParameters_swigregister = _swigfaiss.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.Clustering_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss.Clustering_d_get
|
|
if _newclass:
|
|
d = _swig_property(_swigfaiss.Clustering_d_get, _swigfaiss.Clustering_d_set)
|
|
__swig_setmethods__["k"] = _swigfaiss.Clustering_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss.Clustering_k_get
|
|
if _newclass:
|
|
k = _swig_property(_swigfaiss.Clustering_k_get, _swigfaiss.Clustering_k_set)
|
|
__swig_setmethods__["centroids"] = _swigfaiss.Clustering_centroids_set
|
|
__swig_getmethods__["centroids"] = _swigfaiss.Clustering_centroids_get
|
|
if _newclass:
|
|
centroids = _swig_property(_swigfaiss.Clustering_centroids_get, _swigfaiss.Clustering_centroids_set)
|
|
__swig_setmethods__["obj"] = _swigfaiss.Clustering_obj_set
|
|
__swig_getmethods__["obj"] = _swigfaiss.Clustering_obj_get
|
|
if _newclass:
|
|
obj = _swig_property(_swigfaiss.Clustering_obj_get, _swigfaiss.Clustering_obj_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_Clustering(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train(self, n, x, index):
|
|
return _swigfaiss.Clustering_train(self, n, x, index)
|
|
__swig_destroy__ = _swigfaiss.delete_Clustering
|
|
__del__ = lambda self: None
|
|
Clustering_swigregister = _swigfaiss.Clustering_swigregister
|
|
Clustering_swigregister(Clustering)
|
|
|
|
|
|
def kmeans_clustering(d, n, k, x, centroids):
|
|
return _swigfaiss.kmeans_clustering(d, n, k, x, centroids)
|
|
kmeans_clustering = _swigfaiss.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.ProductQuantizer_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss.ProductQuantizer_d_get
|
|
if _newclass:
|
|
d = _swig_property(_swigfaiss.ProductQuantizer_d_get, _swigfaiss.ProductQuantizer_d_set)
|
|
__swig_setmethods__["M"] = _swigfaiss.ProductQuantizer_M_set
|
|
__swig_getmethods__["M"] = _swigfaiss.ProductQuantizer_M_get
|
|
if _newclass:
|
|
M = _swig_property(_swigfaiss.ProductQuantizer_M_get, _swigfaiss.ProductQuantizer_M_set)
|
|
__swig_setmethods__["nbits"] = _swigfaiss.ProductQuantizer_nbits_set
|
|
__swig_getmethods__["nbits"] = _swigfaiss.ProductQuantizer_nbits_get
|
|
if _newclass:
|
|
nbits = _swig_property(_swigfaiss.ProductQuantizer_nbits_get, _swigfaiss.ProductQuantizer_nbits_set)
|
|
__swig_setmethods__["dsub"] = _swigfaiss.ProductQuantizer_dsub_set
|
|
__swig_getmethods__["dsub"] = _swigfaiss.ProductQuantizer_dsub_get
|
|
if _newclass:
|
|
dsub = _swig_property(_swigfaiss.ProductQuantizer_dsub_get, _swigfaiss.ProductQuantizer_dsub_set)
|
|
__swig_setmethods__["byte_per_idx"] = _swigfaiss.ProductQuantizer_byte_per_idx_set
|
|
__swig_getmethods__["byte_per_idx"] = _swigfaiss.ProductQuantizer_byte_per_idx_get
|
|
if _newclass:
|
|
byte_per_idx = _swig_property(_swigfaiss.ProductQuantizer_byte_per_idx_get, _swigfaiss.ProductQuantizer_byte_per_idx_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss.ProductQuantizer_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss.ProductQuantizer_code_size_get
|
|
if _newclass:
|
|
code_size = _swig_property(_swigfaiss.ProductQuantizer_code_size_get, _swigfaiss.ProductQuantizer_code_size_set)
|
|
__swig_setmethods__["ksub"] = _swigfaiss.ProductQuantizer_ksub_set
|
|
__swig_getmethods__["ksub"] = _swigfaiss.ProductQuantizer_ksub_get
|
|
if _newclass:
|
|
ksub = _swig_property(_swigfaiss.ProductQuantizer_ksub_get, _swigfaiss.ProductQuantizer_ksub_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss.ProductQuantizer_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss.ProductQuantizer_verbose_get
|
|
if _newclass:
|
|
verbose = _swig_property(_swigfaiss.ProductQuantizer_verbose_get, _swigfaiss.ProductQuantizer_verbose_set)
|
|
Train_default = _swigfaiss.ProductQuantizer_Train_default
|
|
Train_hot_start = _swigfaiss.ProductQuantizer_Train_hot_start
|
|
Train_shared = _swigfaiss.ProductQuantizer_Train_shared
|
|
Train_hypercube = _swigfaiss.ProductQuantizer_Train_hypercube
|
|
Train_hypercube_pca = _swigfaiss.ProductQuantizer_Train_hypercube_pca
|
|
__swig_setmethods__["train_type"] = _swigfaiss.ProductQuantizer_train_type_set
|
|
__swig_getmethods__["train_type"] = _swigfaiss.ProductQuantizer_train_type_get
|
|
if _newclass:
|
|
train_type = _swig_property(_swigfaiss.ProductQuantizer_train_type_get, _swigfaiss.ProductQuantizer_train_type_set)
|
|
__swig_setmethods__["cp"] = _swigfaiss.ProductQuantizer_cp_set
|
|
__swig_getmethods__["cp"] = _swigfaiss.ProductQuantizer_cp_get
|
|
if _newclass:
|
|
cp = _swig_property(_swigfaiss.ProductQuantizer_cp_get, _swigfaiss.ProductQuantizer_cp_set)
|
|
__swig_setmethods__["assign_index"] = _swigfaiss.ProductQuantizer_assign_index_set
|
|
__swig_getmethods__["assign_index"] = _swigfaiss.ProductQuantizer_assign_index_get
|
|
if _newclass:
|
|
assign_index = _swig_property(_swigfaiss.ProductQuantizer_assign_index_get, _swigfaiss.ProductQuantizer_assign_index_set)
|
|
__swig_setmethods__["centroids"] = _swigfaiss.ProductQuantizer_centroids_set
|
|
__swig_getmethods__["centroids"] = _swigfaiss.ProductQuantizer_centroids_get
|
|
if _newclass:
|
|
centroids = _swig_property(_swigfaiss.ProductQuantizer_centroids_get, _swigfaiss.ProductQuantizer_centroids_set)
|
|
|
|
def get_centroids(self, m, i):
|
|
return _swigfaiss.ProductQuantizer_get_centroids(self, m, i)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.ProductQuantizer_train(self, n, x)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_ProductQuantizer(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set_derived_values(self):
|
|
return _swigfaiss.ProductQuantizer_set_derived_values(self)
|
|
|
|
def set_params(self, centroids, m):
|
|
return _swigfaiss.ProductQuantizer_set_params(self, centroids, m)
|
|
|
|
def compute_code(self, x, code):
|
|
return _swigfaiss.ProductQuantizer_compute_code(self, x, code)
|
|
|
|
def compute_codes(self, x, codes, n):
|
|
return _swigfaiss.ProductQuantizer_compute_codes(self, x, codes, n)
|
|
|
|
def decode(self, *args):
|
|
return _swigfaiss.ProductQuantizer_decode(self, *args)
|
|
|
|
def compute_code_from_distance_table(self, tab, code):
|
|
return _swigfaiss.ProductQuantizer_compute_code_from_distance_table(self, tab, code)
|
|
|
|
def compute_distance_table(self, x, dis_table):
|
|
return _swigfaiss.ProductQuantizer_compute_distance_table(self, x, dis_table)
|
|
|
|
def compute_inner_prod_table(self, x, dis_table):
|
|
return _swigfaiss.ProductQuantizer_compute_inner_prod_table(self, x, dis_table)
|
|
|
|
def compute_distance_tables(self, nx, x, dis_tables):
|
|
return _swigfaiss.ProductQuantizer_compute_distance_tables(self, nx, x, dis_tables)
|
|
|
|
def compute_inner_prod_tables(self, nx, x, dis_tables):
|
|
return _swigfaiss.ProductQuantizer_compute_inner_prod_tables(self, nx, x, dis_tables)
|
|
|
|
def search(self, x, nx, codes, ncodes, res, init_finalize_heap=True):
|
|
return _swigfaiss.ProductQuantizer_search(self, x, nx, codes, ncodes, res, init_finalize_heap)
|
|
|
|
def search_ip(self, x, nx, codes, ncodes, res, init_finalize_heap=True):
|
|
return _swigfaiss.ProductQuantizer_search_ip(self, x, nx, codes, ncodes, res, init_finalize_heap)
|
|
__swig_setmethods__["sdc_table"] = _swigfaiss.ProductQuantizer_sdc_table_set
|
|
__swig_getmethods__["sdc_table"] = _swigfaiss.ProductQuantizer_sdc_table_get
|
|
if _newclass:
|
|
sdc_table = _swig_property(_swigfaiss.ProductQuantizer_sdc_table_get, _swigfaiss.ProductQuantizer_sdc_table_set)
|
|
|
|
def compute_sdc_table(self):
|
|
return _swigfaiss.ProductQuantizer_compute_sdc_table(self)
|
|
|
|
def search_sdc(self, qcodes, nq, bcodes, ncodes, res, init_finalize_heap=True):
|
|
return _swigfaiss.ProductQuantizer_search_sdc(self, qcodes, nq, bcodes, ncodes, res, init_finalize_heap)
|
|
__swig_destroy__ = _swigfaiss.delete_ProductQuantizer
|
|
__del__ = lambda self: None
|
|
ProductQuantizer_swigregister = _swigfaiss.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.VectorTransform_d_in_set
|
|
__swig_getmethods__["d_in"] = _swigfaiss.VectorTransform_d_in_get
|
|
if _newclass:
|
|
d_in = _swig_property(_swigfaiss.VectorTransform_d_in_get, _swigfaiss.VectorTransform_d_in_set)
|
|
__swig_setmethods__["d_out"] = _swigfaiss.VectorTransform_d_out_set
|
|
__swig_getmethods__["d_out"] = _swigfaiss.VectorTransform_d_out_get
|
|
if _newclass:
|
|
d_out = _swig_property(_swigfaiss.VectorTransform_d_out_get, _swigfaiss.VectorTransform_d_out_set)
|
|
__swig_setmethods__["is_trained"] = _swigfaiss.VectorTransform_is_trained_set
|
|
__swig_getmethods__["is_trained"] = _swigfaiss.VectorTransform_is_trained_get
|
|
if _newclass:
|
|
is_trained = _swig_property(_swigfaiss.VectorTransform_is_trained_get, _swigfaiss.VectorTransform_is_trained_set)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.VectorTransform_train(self, n, x)
|
|
|
|
def apply(self, n, x):
|
|
return _swigfaiss.VectorTransform_apply(self, n, x)
|
|
|
|
def apply_noalloc(self, n, x, xt):
|
|
return _swigfaiss.VectorTransform_apply_noalloc(self, n, x, xt)
|
|
|
|
def reverse_transform(self, n, xt, x):
|
|
return _swigfaiss.VectorTransform_reverse_transform(self, n, xt, x)
|
|
__swig_destroy__ = _swigfaiss.delete_VectorTransform
|
|
__del__ = lambda self: None
|
|
VectorTransform_swigregister = _swigfaiss.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.LinearTransform_have_bias_set
|
|
__swig_getmethods__["have_bias"] = _swigfaiss.LinearTransform_have_bias_get
|
|
if _newclass:
|
|
have_bias = _swig_property(_swigfaiss.LinearTransform_have_bias_get, _swigfaiss.LinearTransform_have_bias_set)
|
|
__swig_setmethods__["is_orthonormal"] = _swigfaiss.LinearTransform_is_orthonormal_set
|
|
__swig_getmethods__["is_orthonormal"] = _swigfaiss.LinearTransform_is_orthonormal_get
|
|
if _newclass:
|
|
is_orthonormal = _swig_property(_swigfaiss.LinearTransform_is_orthonormal_get, _swigfaiss.LinearTransform_is_orthonormal_set)
|
|
__swig_setmethods__["A"] = _swigfaiss.LinearTransform_A_set
|
|
__swig_getmethods__["A"] = _swigfaiss.LinearTransform_A_get
|
|
if _newclass:
|
|
A = _swig_property(_swigfaiss.LinearTransform_A_get, _swigfaiss.LinearTransform_A_set)
|
|
__swig_setmethods__["b"] = _swigfaiss.LinearTransform_b_set
|
|
__swig_getmethods__["b"] = _swigfaiss.LinearTransform_b_get
|
|
if _newclass:
|
|
b = _swig_property(_swigfaiss.LinearTransform_b_get, _swigfaiss.LinearTransform_b_set)
|
|
|
|
def __init__(self, d_in=0, d_out=0, have_bias=False):
|
|
this = _swigfaiss.new_LinearTransform(d_in, d_out, have_bias)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def apply_noalloc(self, n, x, xt):
|
|
return _swigfaiss.LinearTransform_apply_noalloc(self, n, x, xt)
|
|
|
|
def transform_transpose(self, n, y, x):
|
|
return _swigfaiss.LinearTransform_transform_transpose(self, n, y, x)
|
|
|
|
def reverse_transform(self, n, xt, x):
|
|
return _swigfaiss.LinearTransform_reverse_transform(self, n, xt, x)
|
|
|
|
def set_is_orthonormal(self):
|
|
return _swigfaiss.LinearTransform_set_is_orthonormal(self)
|
|
__swig_setmethods__["verbose"] = _swigfaiss.LinearTransform_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss.LinearTransform_verbose_get
|
|
if _newclass:
|
|
verbose = _swig_property(_swigfaiss.LinearTransform_verbose_get, _swigfaiss.LinearTransform_verbose_set)
|
|
__swig_destroy__ = _swigfaiss.delete_LinearTransform
|
|
__del__ = lambda self: None
|
|
LinearTransform_swigregister = _swigfaiss.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, seed):
|
|
return _swigfaiss.RandomRotationMatrix_init(self, seed)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.RandomRotationMatrix_train(self, n, x)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_RandomRotationMatrix(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_RandomRotationMatrix
|
|
__del__ = lambda self: None
|
|
RandomRotationMatrix_swigregister = _swigfaiss.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.PCAMatrix_eigen_power_set
|
|
__swig_getmethods__["eigen_power"] = _swigfaiss.PCAMatrix_eigen_power_get
|
|
if _newclass:
|
|
eigen_power = _swig_property(_swigfaiss.PCAMatrix_eigen_power_get, _swigfaiss.PCAMatrix_eigen_power_set)
|
|
__swig_setmethods__["random_rotation"] = _swigfaiss.PCAMatrix_random_rotation_set
|
|
__swig_getmethods__["random_rotation"] = _swigfaiss.PCAMatrix_random_rotation_get
|
|
if _newclass:
|
|
random_rotation = _swig_property(_swigfaiss.PCAMatrix_random_rotation_get, _swigfaiss.PCAMatrix_random_rotation_set)
|
|
__swig_setmethods__["max_points_per_d"] = _swigfaiss.PCAMatrix_max_points_per_d_set
|
|
__swig_getmethods__["max_points_per_d"] = _swigfaiss.PCAMatrix_max_points_per_d_get
|
|
if _newclass:
|
|
max_points_per_d = _swig_property(_swigfaiss.PCAMatrix_max_points_per_d_get, _swigfaiss.PCAMatrix_max_points_per_d_set)
|
|
__swig_setmethods__["balanced_bins"] = _swigfaiss.PCAMatrix_balanced_bins_set
|
|
__swig_getmethods__["balanced_bins"] = _swigfaiss.PCAMatrix_balanced_bins_get
|
|
if _newclass:
|
|
balanced_bins = _swig_property(_swigfaiss.PCAMatrix_balanced_bins_get, _swigfaiss.PCAMatrix_balanced_bins_set)
|
|
__swig_setmethods__["mean"] = _swigfaiss.PCAMatrix_mean_set
|
|
__swig_getmethods__["mean"] = _swigfaiss.PCAMatrix_mean_get
|
|
if _newclass:
|
|
mean = _swig_property(_swigfaiss.PCAMatrix_mean_get, _swigfaiss.PCAMatrix_mean_set)
|
|
__swig_setmethods__["eigenvalues"] = _swigfaiss.PCAMatrix_eigenvalues_set
|
|
__swig_getmethods__["eigenvalues"] = _swigfaiss.PCAMatrix_eigenvalues_get
|
|
if _newclass:
|
|
eigenvalues = _swig_property(_swigfaiss.PCAMatrix_eigenvalues_get, _swigfaiss.PCAMatrix_eigenvalues_set)
|
|
__swig_setmethods__["PCAMat"] = _swigfaiss.PCAMatrix_PCAMat_set
|
|
__swig_getmethods__["PCAMat"] = _swigfaiss.PCAMatrix_PCAMat_get
|
|
if _newclass:
|
|
PCAMat = _swig_property(_swigfaiss.PCAMatrix_PCAMat_get, _swigfaiss.PCAMatrix_PCAMat_set)
|
|
|
|
def __init__(self, d_in=0, d_out=0, eigen_power=0, random_rotation=False):
|
|
this = _swigfaiss.new_PCAMatrix(d_in, d_out, eigen_power, random_rotation)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.PCAMatrix_train(self, n, x)
|
|
|
|
def copy_from(self, other):
|
|
return _swigfaiss.PCAMatrix_copy_from(self, other)
|
|
|
|
def prepare_Ab(self):
|
|
return _swigfaiss.PCAMatrix_prepare_Ab(self)
|
|
__swig_destroy__ = _swigfaiss.delete_PCAMatrix
|
|
__del__ = lambda self: None
|
|
PCAMatrix_swigregister = _swigfaiss.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.OPQMatrix_M_set
|
|
__swig_getmethods__["M"] = _swigfaiss.OPQMatrix_M_get
|
|
if _newclass:
|
|
M = _swig_property(_swigfaiss.OPQMatrix_M_get, _swigfaiss.OPQMatrix_M_set)
|
|
__swig_setmethods__["niter"] = _swigfaiss.OPQMatrix_niter_set
|
|
__swig_getmethods__["niter"] = _swigfaiss.OPQMatrix_niter_get
|
|
if _newclass:
|
|
niter = _swig_property(_swigfaiss.OPQMatrix_niter_get, _swigfaiss.OPQMatrix_niter_set)
|
|
__swig_setmethods__["niter_pq"] = _swigfaiss.OPQMatrix_niter_pq_set
|
|
__swig_getmethods__["niter_pq"] = _swigfaiss.OPQMatrix_niter_pq_get
|
|
if _newclass:
|
|
niter_pq = _swig_property(_swigfaiss.OPQMatrix_niter_pq_get, _swigfaiss.OPQMatrix_niter_pq_set)
|
|
__swig_setmethods__["niter_pq_0"] = _swigfaiss.OPQMatrix_niter_pq_0_set
|
|
__swig_getmethods__["niter_pq_0"] = _swigfaiss.OPQMatrix_niter_pq_0_get
|
|
if _newclass:
|
|
niter_pq_0 = _swig_property(_swigfaiss.OPQMatrix_niter_pq_0_get, _swigfaiss.OPQMatrix_niter_pq_0_set)
|
|
__swig_setmethods__["max_train_points"] = _swigfaiss.OPQMatrix_max_train_points_set
|
|
__swig_getmethods__["max_train_points"] = _swigfaiss.OPQMatrix_max_train_points_get
|
|
if _newclass:
|
|
max_train_points = _swig_property(_swigfaiss.OPQMatrix_max_train_points_get, _swigfaiss.OPQMatrix_max_train_points_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss.OPQMatrix_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss.OPQMatrix_verbose_get
|
|
if _newclass:
|
|
verbose = _swig_property(_swigfaiss.OPQMatrix_verbose_get, _swigfaiss.OPQMatrix_verbose_set)
|
|
__swig_setmethods__["pq"] = _swigfaiss.OPQMatrix_pq_set
|
|
__swig_getmethods__["pq"] = _swigfaiss.OPQMatrix_pq_get
|
|
if _newclass:
|
|
pq = _swig_property(_swigfaiss.OPQMatrix_pq_get, _swigfaiss.OPQMatrix_pq_set)
|
|
|
|
def __init__(self, d=0, M=1, d2=-1):
|
|
this = _swigfaiss.new_OPQMatrix(d, M, d2)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.OPQMatrix_train(self, n, x)
|
|
__swig_destroy__ = _swigfaiss.delete_OPQMatrix
|
|
__del__ = lambda self: None
|
|
OPQMatrix_swigregister = _swigfaiss.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.RemapDimensionsTransform_map_set
|
|
__swig_getmethods__["map"] = _swigfaiss.RemapDimensionsTransform_map_get
|
|
if _newclass:
|
|
map = _swig_property(_swigfaiss.RemapDimensionsTransform_map_get, _swigfaiss.RemapDimensionsTransform_map_set)
|
|
|
|
def apply_noalloc(self, n, x, xt):
|
|
return _swigfaiss.RemapDimensionsTransform_apply_noalloc(self, n, x, xt)
|
|
|
|
def reverse_transform(self, n, xt, x):
|
|
return _swigfaiss.RemapDimensionsTransform_reverse_transform(self, n, xt, x)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_RemapDimensionsTransform(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_RemapDimensionsTransform
|
|
__del__ = lambda self: None
|
|
RemapDimensionsTransform_swigregister = _swigfaiss.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.NormalizationTransform_norm_set
|
|
__swig_getmethods__["norm"] = _swigfaiss.NormalizationTransform_norm_get
|
|
if _newclass:
|
|
norm = _swig_property(_swigfaiss.NormalizationTransform_norm_get, _swigfaiss.NormalizationTransform_norm_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_NormalizationTransform(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def apply_noalloc(self, n, x, xt):
|
|
return _swigfaiss.NormalizationTransform_apply_noalloc(self, n, x, xt)
|
|
|
|
def reverse_transform(self, n, xt, x):
|
|
return _swigfaiss.NormalizationTransform_reverse_transform(self, n, xt, x)
|
|
__swig_destroy__ = _swigfaiss.delete_NormalizationTransform
|
|
__del__ = lambda self: None
|
|
NormalizationTransform_swigregister = _swigfaiss.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.IndexPreTransform_chain_set
|
|
__swig_getmethods__["chain"] = _swigfaiss.IndexPreTransform_chain_get
|
|
if _newclass:
|
|
chain = _swig_property(_swigfaiss.IndexPreTransform_chain_get, _swigfaiss.IndexPreTransform_chain_set)
|
|
__swig_setmethods__["index"] = _swigfaiss.IndexPreTransform_index_set
|
|
__swig_getmethods__["index"] = _swigfaiss.IndexPreTransform_index_get
|
|
if _newclass:
|
|
index = _swig_property(_swigfaiss.IndexPreTransform_index_get, _swigfaiss.IndexPreTransform_index_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.IndexPreTransform_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.IndexPreTransform_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.IndexPreTransform_own_fields_get, _swigfaiss.IndexPreTransform_own_fields_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexPreTransform(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def prepend_transform(self, ltrans):
|
|
return _swigfaiss.IndexPreTransform_prepend_transform(self, ltrans)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexPreTransform_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexPreTransform_add(self, n, x)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexPreTransform_add_with_ids(self, n, x, xids)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexPreTransform_reset(self)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexPreTransform_remove_ids(self, sel)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexPreTransform_search(self, n, x, k, distances, labels)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexPreTransform_reconstruct(self, key, recons)
|
|
|
|
def reconstruct_n(self, i0, ni, recons):
|
|
return _swigfaiss.IndexPreTransform_reconstruct_n(self, i0, ni, recons)
|
|
|
|
def search_and_reconstruct(self, n, x, k, distances, labels, recons):
|
|
return _swigfaiss.IndexPreTransform_search_and_reconstruct(self, n, x, k, distances, labels, recons)
|
|
|
|
def apply_chain(self, n, x):
|
|
return _swigfaiss.IndexPreTransform_apply_chain(self, n, x)
|
|
|
|
def reverse_chain(self, n, xt, x):
|
|
return _swigfaiss.IndexPreTransform_reverse_chain(self, n, xt, x)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexPreTransform
|
|
__del__ = lambda self: None
|
|
IndexPreTransform_swigregister = _swigfaiss.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.IndexFlat_xb_set
|
|
__swig_getmethods__["xb"] = _swigfaiss.IndexFlat_xb_get
|
|
if _newclass:
|
|
xb = _swig_property(_swigfaiss.IndexFlat_xb_get, _swigfaiss.IndexFlat_xb_set)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexFlat_add(self, n, x)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexFlat_reset(self)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexFlat_search(self, n, x, k, distances, labels)
|
|
|
|
def range_search(self, n, x, radius, result):
|
|
return _swigfaiss.IndexFlat_range_search(self, n, x, radius, result)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexFlat_reconstruct(self, key, recons)
|
|
|
|
def compute_distance_subset(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexFlat_compute_distance_subset(self, n, x, k, distances, labels)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexFlat_remove_ids(self, sel)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexFlat(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexFlat
|
|
__del__ = lambda self: None
|
|
IndexFlat_swigregister = _swigfaiss.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.new_IndexFlatIP(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexFlatIP
|
|
__del__ = lambda self: None
|
|
IndexFlatIP_swigregister = _swigfaiss.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.new_IndexFlatL2(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexFlatL2
|
|
__del__ = lambda self: None
|
|
IndexFlatL2_swigregister = _swigfaiss.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.IndexFlatL2BaseShift_shift_set
|
|
__swig_getmethods__["shift"] = _swigfaiss.IndexFlatL2BaseShift_shift_get
|
|
if _newclass:
|
|
shift = _swig_property(_swigfaiss.IndexFlatL2BaseShift_shift_get, _swigfaiss.IndexFlatL2BaseShift_shift_set)
|
|
|
|
def __init__(self, d, nshift, shift):
|
|
this = _swigfaiss.new_IndexFlatL2BaseShift(d, nshift, shift)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexFlatL2BaseShift_search(self, n, x, k, distances, labels)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexFlatL2BaseShift
|
|
__del__ = lambda self: None
|
|
IndexFlatL2BaseShift_swigregister = _swigfaiss.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.IndexRefineFlat_refine_index_set
|
|
__swig_getmethods__["refine_index"] = _swigfaiss.IndexRefineFlat_refine_index_get
|
|
if _newclass:
|
|
refine_index = _swig_property(_swigfaiss.IndexRefineFlat_refine_index_get, _swigfaiss.IndexRefineFlat_refine_index_set)
|
|
__swig_setmethods__["base_index"] = _swigfaiss.IndexRefineFlat_base_index_set
|
|
__swig_getmethods__["base_index"] = _swigfaiss.IndexRefineFlat_base_index_get
|
|
if _newclass:
|
|
base_index = _swig_property(_swigfaiss.IndexRefineFlat_base_index_get, _swigfaiss.IndexRefineFlat_base_index_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.IndexRefineFlat_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.IndexRefineFlat_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.IndexRefineFlat_own_fields_get, _swigfaiss.IndexRefineFlat_own_fields_set)
|
|
__swig_setmethods__["k_factor"] = _swigfaiss.IndexRefineFlat_k_factor_set
|
|
__swig_getmethods__["k_factor"] = _swigfaiss.IndexRefineFlat_k_factor_get
|
|
if _newclass:
|
|
k_factor = _swig_property(_swigfaiss.IndexRefineFlat_k_factor_get, _swigfaiss.IndexRefineFlat_k_factor_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexRefineFlat(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexRefineFlat_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexRefineFlat_add(self, n, x)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexRefineFlat_reset(self)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexRefineFlat_search(self, n, x, k, distances, labels)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexRefineFlat
|
|
__del__ = lambda self: None
|
|
IndexRefineFlat_swigregister = _swigfaiss.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.IndexFlat1D_continuous_update_set
|
|
__swig_getmethods__["continuous_update"] = _swigfaiss.IndexFlat1D_continuous_update_get
|
|
if _newclass:
|
|
continuous_update = _swig_property(_swigfaiss.IndexFlat1D_continuous_update_get, _swigfaiss.IndexFlat1D_continuous_update_set)
|
|
__swig_setmethods__["perm"] = _swigfaiss.IndexFlat1D_perm_set
|
|
__swig_getmethods__["perm"] = _swigfaiss.IndexFlat1D_perm_get
|
|
if _newclass:
|
|
perm = _swig_property(_swigfaiss.IndexFlat1D_perm_get, _swigfaiss.IndexFlat1D_perm_set)
|
|
|
|
def __init__(self, continuous_update=True):
|
|
this = _swigfaiss.new_IndexFlat1D(continuous_update)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def update_permutation(self):
|
|
return _swigfaiss.IndexFlat1D_update_permutation(self)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexFlat1D_add(self, n, x)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexFlat1D_reset(self)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexFlat1D_search(self, n, x, k, distances, labels)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexFlat1D
|
|
__del__ = lambda self: None
|
|
IndexFlat1D_swigregister = _swigfaiss.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.IndexLSH_nbits_set
|
|
__swig_getmethods__["nbits"] = _swigfaiss.IndexLSH_nbits_get
|
|
if _newclass:
|
|
nbits = _swig_property(_swigfaiss.IndexLSH_nbits_get, _swigfaiss.IndexLSH_nbits_set)
|
|
__swig_setmethods__["bytes_per_vec"] = _swigfaiss.IndexLSH_bytes_per_vec_set
|
|
__swig_getmethods__["bytes_per_vec"] = _swigfaiss.IndexLSH_bytes_per_vec_get
|
|
if _newclass:
|
|
bytes_per_vec = _swig_property(_swigfaiss.IndexLSH_bytes_per_vec_get, _swigfaiss.IndexLSH_bytes_per_vec_set)
|
|
__swig_setmethods__["rotate_data"] = _swigfaiss.IndexLSH_rotate_data_set
|
|
__swig_getmethods__["rotate_data"] = _swigfaiss.IndexLSH_rotate_data_get
|
|
if _newclass:
|
|
rotate_data = _swig_property(_swigfaiss.IndexLSH_rotate_data_get, _swigfaiss.IndexLSH_rotate_data_set)
|
|
__swig_setmethods__["train_thresholds"] = _swigfaiss.IndexLSH_train_thresholds_set
|
|
__swig_getmethods__["train_thresholds"] = _swigfaiss.IndexLSH_train_thresholds_get
|
|
if _newclass:
|
|
train_thresholds = _swig_property(_swigfaiss.IndexLSH_train_thresholds_get, _swigfaiss.IndexLSH_train_thresholds_set)
|
|
__swig_setmethods__["rrot"] = _swigfaiss.IndexLSH_rrot_set
|
|
__swig_getmethods__["rrot"] = _swigfaiss.IndexLSH_rrot_get
|
|
if _newclass:
|
|
rrot = _swig_property(_swigfaiss.IndexLSH_rrot_get, _swigfaiss.IndexLSH_rrot_set)
|
|
__swig_setmethods__["thresholds"] = _swigfaiss.IndexLSH_thresholds_set
|
|
__swig_getmethods__["thresholds"] = _swigfaiss.IndexLSH_thresholds_get
|
|
if _newclass:
|
|
thresholds = _swig_property(_swigfaiss.IndexLSH_thresholds_get, _swigfaiss.IndexLSH_thresholds_set)
|
|
__swig_setmethods__["codes"] = _swigfaiss.IndexLSH_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss.IndexLSH_codes_get
|
|
if _newclass:
|
|
codes = _swig_property(_swigfaiss.IndexLSH_codes_get, _swigfaiss.IndexLSH_codes_set)
|
|
|
|
def apply_preprocess(self, n, x):
|
|
return _swigfaiss.IndexLSH_apply_preprocess(self, n, x)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexLSH_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexLSH_add(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexLSH_search(self, n, x, k, distances, labels)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexLSH_reset(self)
|
|
|
|
def transfer_thresholds(self, vt):
|
|
return _swigfaiss.IndexLSH_transfer_thresholds(self, vt)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexLSH
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexLSH(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
IndexLSH_swigregister = _swigfaiss.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.SimulatedAnnealingParameters_init_temperature_set
|
|
__swig_getmethods__["init_temperature"] = _swigfaiss.SimulatedAnnealingParameters_init_temperature_get
|
|
if _newclass:
|
|
init_temperature = _swig_property(_swigfaiss.SimulatedAnnealingParameters_init_temperature_get, _swigfaiss.SimulatedAnnealingParameters_init_temperature_set)
|
|
__swig_setmethods__["temperature_decay"] = _swigfaiss.SimulatedAnnealingParameters_temperature_decay_set
|
|
__swig_getmethods__["temperature_decay"] = _swigfaiss.SimulatedAnnealingParameters_temperature_decay_get
|
|
if _newclass:
|
|
temperature_decay = _swig_property(_swigfaiss.SimulatedAnnealingParameters_temperature_decay_get, _swigfaiss.SimulatedAnnealingParameters_temperature_decay_set)
|
|
__swig_setmethods__["n_iter"] = _swigfaiss.SimulatedAnnealingParameters_n_iter_set
|
|
__swig_getmethods__["n_iter"] = _swigfaiss.SimulatedAnnealingParameters_n_iter_get
|
|
if _newclass:
|
|
n_iter = _swig_property(_swigfaiss.SimulatedAnnealingParameters_n_iter_get, _swigfaiss.SimulatedAnnealingParameters_n_iter_set)
|
|
__swig_setmethods__["n_redo"] = _swigfaiss.SimulatedAnnealingParameters_n_redo_set
|
|
__swig_getmethods__["n_redo"] = _swigfaiss.SimulatedAnnealingParameters_n_redo_get
|
|
if _newclass:
|
|
n_redo = _swig_property(_swigfaiss.SimulatedAnnealingParameters_n_redo_get, _swigfaiss.SimulatedAnnealingParameters_n_redo_set)
|
|
__swig_setmethods__["seed"] = _swigfaiss.SimulatedAnnealingParameters_seed_set
|
|
__swig_getmethods__["seed"] = _swigfaiss.SimulatedAnnealingParameters_seed_get
|
|
if _newclass:
|
|
seed = _swig_property(_swigfaiss.SimulatedAnnealingParameters_seed_get, _swigfaiss.SimulatedAnnealingParameters_seed_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss.SimulatedAnnealingParameters_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss.SimulatedAnnealingParameters_verbose_get
|
|
if _newclass:
|
|
verbose = _swig_property(_swigfaiss.SimulatedAnnealingParameters_verbose_get, _swigfaiss.SimulatedAnnealingParameters_verbose_set)
|
|
__swig_setmethods__["only_bit_flips"] = _swigfaiss.SimulatedAnnealingParameters_only_bit_flips_set
|
|
__swig_getmethods__["only_bit_flips"] = _swigfaiss.SimulatedAnnealingParameters_only_bit_flips_get
|
|
if _newclass:
|
|
only_bit_flips = _swig_property(_swigfaiss.SimulatedAnnealingParameters_only_bit_flips_get, _swigfaiss.SimulatedAnnealingParameters_only_bit_flips_set)
|
|
__swig_setmethods__["init_random"] = _swigfaiss.SimulatedAnnealingParameters_init_random_set
|
|
__swig_getmethods__["init_random"] = _swigfaiss.SimulatedAnnealingParameters_init_random_get
|
|
if _newclass:
|
|
init_random = _swig_property(_swigfaiss.SimulatedAnnealingParameters_init_random_get, _swigfaiss.SimulatedAnnealingParameters_init_random_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_SimulatedAnnealingParameters()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_SimulatedAnnealingParameters
|
|
__del__ = lambda self: None
|
|
SimulatedAnnealingParameters_swigregister = _swigfaiss.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.PermutationObjective_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss.PermutationObjective_n_get
|
|
if _newclass:
|
|
n = _swig_property(_swigfaiss.PermutationObjective_n_get, _swigfaiss.PermutationObjective_n_set)
|
|
|
|
def compute_cost(self, perm):
|
|
return _swigfaiss.PermutationObjective_compute_cost(self, perm)
|
|
|
|
def cost_update(self, perm, iw, jw):
|
|
return _swigfaiss.PermutationObjective_cost_update(self, perm, iw, jw)
|
|
__swig_destroy__ = _swigfaiss.delete_PermutationObjective
|
|
__del__ = lambda self: None
|
|
PermutationObjective_swigregister = _swigfaiss.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.ReproduceDistancesObjective_dis_weight_factor_set
|
|
__swig_getmethods__["dis_weight_factor"] = _swigfaiss.ReproduceDistancesObjective_dis_weight_factor_get
|
|
if _newclass:
|
|
dis_weight_factor = _swig_property(_swigfaiss.ReproduceDistancesObjective_dis_weight_factor_get, _swigfaiss.ReproduceDistancesObjective_dis_weight_factor_set)
|
|
if _newclass:
|
|
sqr = staticmethod(_swigfaiss.ReproduceDistancesObjective_sqr)
|
|
else:
|
|
sqr = _swigfaiss.ReproduceDistancesObjective_sqr
|
|
|
|
def dis_weight(self, x):
|
|
return _swigfaiss.ReproduceDistancesObjective_dis_weight(self, x)
|
|
__swig_setmethods__["source_dis"] = _swigfaiss.ReproduceDistancesObjective_source_dis_set
|
|
__swig_getmethods__["source_dis"] = _swigfaiss.ReproduceDistancesObjective_source_dis_get
|
|
if _newclass:
|
|
source_dis = _swig_property(_swigfaiss.ReproduceDistancesObjective_source_dis_get, _swigfaiss.ReproduceDistancesObjective_source_dis_set)
|
|
__swig_setmethods__["target_dis"] = _swigfaiss.ReproduceDistancesObjective_target_dis_set
|
|
__swig_getmethods__["target_dis"] = _swigfaiss.ReproduceDistancesObjective_target_dis_get
|
|
if _newclass:
|
|
target_dis = _swig_property(_swigfaiss.ReproduceDistancesObjective_target_dis_get, _swigfaiss.ReproduceDistancesObjective_target_dis_set)
|
|
__swig_setmethods__["weights"] = _swigfaiss.ReproduceDistancesObjective_weights_set
|
|
__swig_getmethods__["weights"] = _swigfaiss.ReproduceDistancesObjective_weights_get
|
|
if _newclass:
|
|
weights = _swig_property(_swigfaiss.ReproduceDistancesObjective_weights_get, _swigfaiss.ReproduceDistancesObjective_weights_set)
|
|
|
|
def get_source_dis(self, i, j):
|
|
return _swigfaiss.ReproduceDistancesObjective_get_source_dis(self, i, j)
|
|
|
|
def compute_cost(self, perm):
|
|
return _swigfaiss.ReproduceDistancesObjective_compute_cost(self, perm)
|
|
|
|
def cost_update(self, perm, iw, jw):
|
|
return _swigfaiss.ReproduceDistancesObjective_cost_update(self, perm, iw, jw)
|
|
|
|
def __init__(self, n, source_dis_in, target_dis_in, dis_weight_factor):
|
|
this = _swigfaiss.new_ReproduceDistancesObjective(n, source_dis_in, target_dis_in, dis_weight_factor)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
if _newclass:
|
|
compute_mean_stdev = staticmethod(_swigfaiss.ReproduceDistancesObjective_compute_mean_stdev)
|
|
else:
|
|
compute_mean_stdev = _swigfaiss.ReproduceDistancesObjective_compute_mean_stdev
|
|
|
|
def set_affine_target_dis(self, source_dis_in):
|
|
return _swigfaiss.ReproduceDistancesObjective_set_affine_target_dis(self, source_dis_in)
|
|
__swig_destroy__ = _swigfaiss.delete_ReproduceDistancesObjective
|
|
__del__ = lambda self: None
|
|
ReproduceDistancesObjective_swigregister = _swigfaiss.ReproduceDistancesObjective_swigregister
|
|
ReproduceDistancesObjective_swigregister(ReproduceDistancesObjective)
|
|
|
|
def ReproduceDistancesObjective_sqr(x):
|
|
return _swigfaiss.ReproduceDistancesObjective_sqr(x)
|
|
ReproduceDistancesObjective_sqr = _swigfaiss.ReproduceDistancesObjective_sqr
|
|
|
|
def ReproduceDistancesObjective_compute_mean_stdev(tab, n2, mean_out, stddev_out):
|
|
return _swigfaiss.ReproduceDistancesObjective_compute_mean_stdev(tab, n2, mean_out, stddev_out)
|
|
ReproduceDistancesObjective_compute_mean_stdev = _swigfaiss.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.SimulatedAnnealingOptimizer_obj_set
|
|
__swig_getmethods__["obj"] = _swigfaiss.SimulatedAnnealingOptimizer_obj_get
|
|
if _newclass:
|
|
obj = _swig_property(_swigfaiss.SimulatedAnnealingOptimizer_obj_get, _swigfaiss.SimulatedAnnealingOptimizer_obj_set)
|
|
__swig_setmethods__["n"] = _swigfaiss.SimulatedAnnealingOptimizer_n_set
|
|
__swig_getmethods__["n"] = _swigfaiss.SimulatedAnnealingOptimizer_n_get
|
|
if _newclass:
|
|
n = _swig_property(_swigfaiss.SimulatedAnnealingOptimizer_n_get, _swigfaiss.SimulatedAnnealingOptimizer_n_set)
|
|
__swig_setmethods__["logfile"] = _swigfaiss.SimulatedAnnealingOptimizer_logfile_set
|
|
__swig_getmethods__["logfile"] = _swigfaiss.SimulatedAnnealingOptimizer_logfile_get
|
|
if _newclass:
|
|
logfile = _swig_property(_swigfaiss.SimulatedAnnealingOptimizer_logfile_get, _swigfaiss.SimulatedAnnealingOptimizer_logfile_set)
|
|
|
|
def __init__(self, obj, p):
|
|
this = _swigfaiss.new_SimulatedAnnealingOptimizer(obj, p)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_setmethods__["rnd"] = _swigfaiss.SimulatedAnnealingOptimizer_rnd_set
|
|
__swig_getmethods__["rnd"] = _swigfaiss.SimulatedAnnealingOptimizer_rnd_get
|
|
if _newclass:
|
|
rnd = _swig_property(_swigfaiss.SimulatedAnnealingOptimizer_rnd_get, _swigfaiss.SimulatedAnnealingOptimizer_rnd_set)
|
|
__swig_setmethods__["init_cost"] = _swigfaiss.SimulatedAnnealingOptimizer_init_cost_set
|
|
__swig_getmethods__["init_cost"] = _swigfaiss.SimulatedAnnealingOptimizer_init_cost_get
|
|
if _newclass:
|
|
init_cost = _swig_property(_swigfaiss.SimulatedAnnealingOptimizer_init_cost_get, _swigfaiss.SimulatedAnnealingOptimizer_init_cost_set)
|
|
|
|
def optimize(self, perm):
|
|
return _swigfaiss.SimulatedAnnealingOptimizer_optimize(self, perm)
|
|
|
|
def run_optimization(self, best_perm):
|
|
return _swigfaiss.SimulatedAnnealingOptimizer_run_optimization(self, best_perm)
|
|
__swig_destroy__ = _swigfaiss.delete_SimulatedAnnealingOptimizer
|
|
__del__ = lambda self: None
|
|
SimulatedAnnealingOptimizer_swigregister = _swigfaiss.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.PolysemousTraining_OT_None
|
|
OT_ReproduceDistances_affine = _swigfaiss.PolysemousTraining_OT_ReproduceDistances_affine
|
|
OT_Ranking_weighted_diff = _swigfaiss.PolysemousTraining_OT_Ranking_weighted_diff
|
|
__swig_setmethods__["optimization_type"] = _swigfaiss.PolysemousTraining_optimization_type_set
|
|
__swig_getmethods__["optimization_type"] = _swigfaiss.PolysemousTraining_optimization_type_get
|
|
if _newclass:
|
|
optimization_type = _swig_property(_swigfaiss.PolysemousTraining_optimization_type_get, _swigfaiss.PolysemousTraining_optimization_type_set)
|
|
__swig_setmethods__["ntrain_permutation"] = _swigfaiss.PolysemousTraining_ntrain_permutation_set
|
|
__swig_getmethods__["ntrain_permutation"] = _swigfaiss.PolysemousTraining_ntrain_permutation_get
|
|
if _newclass:
|
|
ntrain_permutation = _swig_property(_swigfaiss.PolysemousTraining_ntrain_permutation_get, _swigfaiss.PolysemousTraining_ntrain_permutation_set)
|
|
__swig_setmethods__["dis_weight_factor"] = _swigfaiss.PolysemousTraining_dis_weight_factor_set
|
|
__swig_getmethods__["dis_weight_factor"] = _swigfaiss.PolysemousTraining_dis_weight_factor_get
|
|
if _newclass:
|
|
dis_weight_factor = _swig_property(_swigfaiss.PolysemousTraining_dis_weight_factor_get, _swigfaiss.PolysemousTraining_dis_weight_factor_set)
|
|
__swig_setmethods__["log_pattern"] = _swigfaiss.PolysemousTraining_log_pattern_set
|
|
__swig_getmethods__["log_pattern"] = _swigfaiss.PolysemousTraining_log_pattern_get
|
|
if _newclass:
|
|
log_pattern = _swig_property(_swigfaiss.PolysemousTraining_log_pattern_get, _swigfaiss.PolysemousTraining_log_pattern_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_PolysemousTraining()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def optimize_pq_for_hamming(self, pq, n, x):
|
|
return _swigfaiss.PolysemousTraining_optimize_pq_for_hamming(self, pq, n, x)
|
|
|
|
def optimize_ranking(self, pq, n, x):
|
|
return _swigfaiss.PolysemousTraining_optimize_ranking(self, pq, n, x)
|
|
|
|
def optimize_reproduce_distances(self, pq):
|
|
return _swigfaiss.PolysemousTraining_optimize_reproduce_distances(self, pq)
|
|
__swig_destroy__ = _swigfaiss.delete_PolysemousTraining
|
|
__del__ = lambda self: None
|
|
PolysemousTraining_swigregister = _swigfaiss.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.IndexPQ_pq_set
|
|
__swig_getmethods__["pq"] = _swigfaiss.IndexPQ_pq_get
|
|
if _newclass:
|
|
pq = _swig_property(_swigfaiss.IndexPQ_pq_get, _swigfaiss.IndexPQ_pq_set)
|
|
__swig_setmethods__["codes"] = _swigfaiss.IndexPQ_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss.IndexPQ_codes_get
|
|
if _newclass:
|
|
codes = _swig_property(_swigfaiss.IndexPQ_codes_get, _swigfaiss.IndexPQ_codes_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexPQ(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexPQ_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexPQ_add(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexPQ_search(self, n, x, k, distances, labels)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexPQ_reset(self)
|
|
|
|
def reconstruct_n(self, i0, ni, recons):
|
|
return _swigfaiss.IndexPQ_reconstruct_n(self, i0, ni, recons)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexPQ_reconstruct(self, key, recons)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexPQ_remove_ids(self, sel)
|
|
__swig_setmethods__["do_polysemous_training"] = _swigfaiss.IndexPQ_do_polysemous_training_set
|
|
__swig_getmethods__["do_polysemous_training"] = _swigfaiss.IndexPQ_do_polysemous_training_get
|
|
if _newclass:
|
|
do_polysemous_training = _swig_property(_swigfaiss.IndexPQ_do_polysemous_training_get, _swigfaiss.IndexPQ_do_polysemous_training_set)
|
|
__swig_setmethods__["polysemous_training"] = _swigfaiss.IndexPQ_polysemous_training_set
|
|
__swig_getmethods__["polysemous_training"] = _swigfaiss.IndexPQ_polysemous_training_get
|
|
if _newclass:
|
|
polysemous_training = _swig_property(_swigfaiss.IndexPQ_polysemous_training_get, _swigfaiss.IndexPQ_polysemous_training_set)
|
|
ST_PQ = _swigfaiss.IndexPQ_ST_PQ
|
|
ST_HE = _swigfaiss.IndexPQ_ST_HE
|
|
ST_generalized_HE = _swigfaiss.IndexPQ_ST_generalized_HE
|
|
ST_SDC = _swigfaiss.IndexPQ_ST_SDC
|
|
ST_polysemous = _swigfaiss.IndexPQ_ST_polysemous
|
|
ST_polysemous_generalize = _swigfaiss.IndexPQ_ST_polysemous_generalize
|
|
__swig_setmethods__["search_type"] = _swigfaiss.IndexPQ_search_type_set
|
|
__swig_getmethods__["search_type"] = _swigfaiss.IndexPQ_search_type_get
|
|
if _newclass:
|
|
search_type = _swig_property(_swigfaiss.IndexPQ_search_type_get, _swigfaiss.IndexPQ_search_type_set)
|
|
__swig_setmethods__["encode_signs"] = _swigfaiss.IndexPQ_encode_signs_set
|
|
__swig_getmethods__["encode_signs"] = _swigfaiss.IndexPQ_encode_signs_get
|
|
if _newclass:
|
|
encode_signs = _swig_property(_swigfaiss.IndexPQ_encode_signs_get, _swigfaiss.IndexPQ_encode_signs_set)
|
|
__swig_setmethods__["polysemous_ht"] = _swigfaiss.IndexPQ_polysemous_ht_set
|
|
__swig_getmethods__["polysemous_ht"] = _swigfaiss.IndexPQ_polysemous_ht_get
|
|
if _newclass:
|
|
polysemous_ht = _swig_property(_swigfaiss.IndexPQ_polysemous_ht_get, _swigfaiss.IndexPQ_polysemous_ht_set)
|
|
|
|
def search_core_polysemous(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexPQ_search_core_polysemous(self, n, x, k, distances, labels)
|
|
|
|
def hamming_distance_histogram(self, n, x, nb, xb, dist_histogram):
|
|
return _swigfaiss.IndexPQ_hamming_distance_histogram(self, n, x, nb, xb, dist_histogram)
|
|
|
|
def hamming_distance_table(self, n, x, dis):
|
|
return _swigfaiss.IndexPQ_hamming_distance_table(self, n, x, dis)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexPQ
|
|
__del__ = lambda self: None
|
|
IndexPQ_swigregister = _swigfaiss.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.IndexPQStats_nq_set
|
|
__swig_getmethods__["nq"] = _swigfaiss.IndexPQStats_nq_get
|
|
if _newclass:
|
|
nq = _swig_property(_swigfaiss.IndexPQStats_nq_get, _swigfaiss.IndexPQStats_nq_set)
|
|
__swig_setmethods__["ncode"] = _swigfaiss.IndexPQStats_ncode_set
|
|
__swig_getmethods__["ncode"] = _swigfaiss.IndexPQStats_ncode_get
|
|
if _newclass:
|
|
ncode = _swig_property(_swigfaiss.IndexPQStats_ncode_get, _swigfaiss.IndexPQStats_ncode_set)
|
|
__swig_setmethods__["n_hamming_pass"] = _swigfaiss.IndexPQStats_n_hamming_pass_set
|
|
__swig_getmethods__["n_hamming_pass"] = _swigfaiss.IndexPQStats_n_hamming_pass_get
|
|
if _newclass:
|
|
n_hamming_pass = _swig_property(_swigfaiss.IndexPQStats_n_hamming_pass_get, _swigfaiss.IndexPQStats_n_hamming_pass_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_IndexPQStats()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexPQStats_reset(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexPQStats
|
|
__del__ = lambda self: None
|
|
IndexPQStats_swigregister = _swigfaiss.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.MultiIndexQuantizer_pq_set
|
|
__swig_getmethods__["pq"] = _swigfaiss.MultiIndexQuantizer_pq_get
|
|
if _newclass:
|
|
pq = _swig_property(_swigfaiss.MultiIndexQuantizer_pq_get, _swigfaiss.MultiIndexQuantizer_pq_set)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.MultiIndexQuantizer_train(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.MultiIndexQuantizer_search(self, n, x, k, distances, labels)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.MultiIndexQuantizer_add(self, n, x)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.MultiIndexQuantizer_reset(self)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_MultiIndexQuantizer(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.MultiIndexQuantizer_reconstruct(self, key, recons)
|
|
__swig_destroy__ = _swigfaiss.delete_MultiIndexQuantizer
|
|
__del__ = lambda self: None
|
|
MultiIndexQuantizer_swigregister = _swigfaiss.MultiIndexQuantizer_swigregister
|
|
MultiIndexQuantizer_swigregister(MultiIndexQuantizer)
|
|
|
|
class MultiIndexQuantizer2(MultiIndexQuantizer):
|
|
__swig_setmethods__ = {}
|
|
for _s in [MultiIndexQuantizer]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, MultiIndexQuantizer2, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [MultiIndexQuantizer]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, MultiIndexQuantizer2, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["assign_indexes"] = _swigfaiss.MultiIndexQuantizer2_assign_indexes_set
|
|
__swig_getmethods__["assign_indexes"] = _swigfaiss.MultiIndexQuantizer2_assign_indexes_get
|
|
if _newclass:
|
|
assign_indexes = _swig_property(_swigfaiss.MultiIndexQuantizer2_assign_indexes_get, _swigfaiss.MultiIndexQuantizer2_assign_indexes_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.MultiIndexQuantizer2_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.MultiIndexQuantizer2_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.MultiIndexQuantizer2_own_fields_get, _swigfaiss.MultiIndexQuantizer2_own_fields_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_MultiIndexQuantizer2(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.MultiIndexQuantizer2_train(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.MultiIndexQuantizer2_search(self, n, x, k, distances, labels)
|
|
__swig_destroy__ = _swigfaiss.delete_MultiIndexQuantizer2
|
|
__del__ = lambda self: None
|
|
MultiIndexQuantizer2_swigregister = _swigfaiss.MultiIndexQuantizer2_swigregister
|
|
MultiIndexQuantizer2_swigregister(MultiIndexQuantizer2)
|
|
|
|
class InvertedLists(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, InvertedLists, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, InvertedLists, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nlist"] = _swigfaiss.InvertedLists_nlist_set
|
|
__swig_getmethods__["nlist"] = _swigfaiss.InvertedLists_nlist_get
|
|
if _newclass:
|
|
nlist = _swig_property(_swigfaiss.InvertedLists_nlist_get, _swigfaiss.InvertedLists_nlist_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss.InvertedLists_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss.InvertedLists_code_size_get
|
|
if _newclass:
|
|
code_size = _swig_property(_swigfaiss.InvertedLists_code_size_get, _swigfaiss.InvertedLists_code_size_set)
|
|
|
|
def list_size(self, list_no):
|
|
return _swigfaiss.InvertedLists_list_size(self, list_no)
|
|
|
|
def get_codes(self, list_no):
|
|
return _swigfaiss.InvertedLists_get_codes(self, list_no)
|
|
|
|
def get_ids(self, list_no):
|
|
return _swigfaiss.InvertedLists_get_ids(self, list_no)
|
|
|
|
def release_codes(self, codes):
|
|
return _swigfaiss.InvertedLists_release_codes(self, codes)
|
|
|
|
def release_ids(self, ids):
|
|
return _swigfaiss.InvertedLists_release_ids(self, ids)
|
|
|
|
def get_single_id(self, list_no, offset):
|
|
return _swigfaiss.InvertedLists_get_single_id(self, list_no, offset)
|
|
|
|
def get_single_code(self, list_no, offset):
|
|
return _swigfaiss.InvertedLists_get_single_code(self, list_no, offset)
|
|
|
|
def prefetch_lists(self, list_nos, nlist):
|
|
return _swigfaiss.InvertedLists_prefetch_lists(self, list_nos, nlist)
|
|
|
|
def add_entry(self, list_no, theid, code):
|
|
return _swigfaiss.InvertedLists_add_entry(self, list_no, theid, code)
|
|
|
|
def add_entries(self, list_no, n_entry, ids, code):
|
|
return _swigfaiss.InvertedLists_add_entries(self, list_no, n_entry, ids, code)
|
|
|
|
def update_entry(self, list_no, offset, id, code):
|
|
return _swigfaiss.InvertedLists_update_entry(self, list_no, offset, id, code)
|
|
|
|
def update_entries(self, list_no, offset, n_entry, ids, code):
|
|
return _swigfaiss.InvertedLists_update_entries(self, list_no, offset, n_entry, ids, code)
|
|
|
|
def resize(self, list_no, new_size):
|
|
return _swigfaiss.InvertedLists_resize(self, list_no, new_size)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.InvertedLists_reset(self)
|
|
|
|
def merge_from(self, oivf, add_id):
|
|
return _swigfaiss.InvertedLists_merge_from(self, oivf, add_id)
|
|
__swig_destroy__ = _swigfaiss.delete_InvertedLists
|
|
__del__ = lambda self: None
|
|
InvertedLists_swigregister = _swigfaiss.InvertedLists_swigregister
|
|
InvertedLists_swigregister(InvertedLists)
|
|
|
|
class ArrayInvertedLists(InvertedLists):
|
|
__swig_setmethods__ = {}
|
|
for _s in [InvertedLists]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ArrayInvertedLists, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [InvertedLists]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ArrayInvertedLists, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["codes"] = _swigfaiss.ArrayInvertedLists_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss.ArrayInvertedLists_codes_get
|
|
if _newclass:
|
|
codes = _swig_property(_swigfaiss.ArrayInvertedLists_codes_get, _swigfaiss.ArrayInvertedLists_codes_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss.ArrayInvertedLists_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss.ArrayInvertedLists_ids_get
|
|
if _newclass:
|
|
ids = _swig_property(_swigfaiss.ArrayInvertedLists_ids_get, _swigfaiss.ArrayInvertedLists_ids_set)
|
|
|
|
def __init__(self, nlist, code_size):
|
|
this = _swigfaiss.new_ArrayInvertedLists(nlist, code_size)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def list_size(self, list_no):
|
|
return _swigfaiss.ArrayInvertedLists_list_size(self, list_no)
|
|
|
|
def get_codes(self, list_no):
|
|
return _swigfaiss.ArrayInvertedLists_get_codes(self, list_no)
|
|
|
|
def get_ids(self, list_no):
|
|
return _swigfaiss.ArrayInvertedLists_get_ids(self, list_no)
|
|
|
|
def add_entries(self, list_no, n_entry, ids, code):
|
|
return _swigfaiss.ArrayInvertedLists_add_entries(self, list_no, n_entry, ids, code)
|
|
|
|
def update_entries(self, list_no, offset, n_entry, ids, code):
|
|
return _swigfaiss.ArrayInvertedLists_update_entries(self, list_no, offset, n_entry, ids, code)
|
|
|
|
def resize(self, list_no, new_size):
|
|
return _swigfaiss.ArrayInvertedLists_resize(self, list_no, new_size)
|
|
__swig_destroy__ = _swigfaiss.delete_ArrayInvertedLists
|
|
__del__ = lambda self: None
|
|
ArrayInvertedLists_swigregister = _swigfaiss.ArrayInvertedLists_swigregister
|
|
ArrayInvertedLists_swigregister(ArrayInvertedLists)
|
|
|
|
class ConcatenatedInvertedLists(InvertedLists):
|
|
__swig_setmethods__ = {}
|
|
for _s in [InvertedLists]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ConcatenatedInvertedLists, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [InvertedLists]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ConcatenatedInvertedLists, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["ils"] = _swigfaiss.ConcatenatedInvertedLists_ils_set
|
|
__swig_getmethods__["ils"] = _swigfaiss.ConcatenatedInvertedLists_ils_get
|
|
if _newclass:
|
|
ils = _swig_property(_swigfaiss.ConcatenatedInvertedLists_ils_get, _swigfaiss.ConcatenatedInvertedLists_ils_set)
|
|
|
|
def __init__(self, nil, ils):
|
|
this = _swigfaiss.new_ConcatenatedInvertedLists(nil, ils)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def list_size(self, list_no):
|
|
return _swigfaiss.ConcatenatedInvertedLists_list_size(self, list_no)
|
|
|
|
def get_codes(self, list_no):
|
|
return _swigfaiss.ConcatenatedInvertedLists_get_codes(self, list_no)
|
|
|
|
def get_ids(self, list_no):
|
|
return _swigfaiss.ConcatenatedInvertedLists_get_ids(self, list_no)
|
|
|
|
def release_codes(self, codes):
|
|
return _swigfaiss.ConcatenatedInvertedLists_release_codes(self, codes)
|
|
|
|
def release_ids(self, ids):
|
|
return _swigfaiss.ConcatenatedInvertedLists_release_ids(self, ids)
|
|
|
|
def get_single_id(self, list_no, offset):
|
|
return _swigfaiss.ConcatenatedInvertedLists_get_single_id(self, list_no, offset)
|
|
|
|
def get_single_code(self, list_no, offset):
|
|
return _swigfaiss.ConcatenatedInvertedLists_get_single_code(self, list_no, offset)
|
|
|
|
def add_entries(self, list_no, n_entry, ids, code):
|
|
return _swigfaiss.ConcatenatedInvertedLists_add_entries(self, list_no, n_entry, ids, code)
|
|
|
|
def update_entries(self, list_no, offset, n_entry, ids, code):
|
|
return _swigfaiss.ConcatenatedInvertedLists_update_entries(self, list_no, offset, n_entry, ids, code)
|
|
|
|
def resize(self, list_no, new_size):
|
|
return _swigfaiss.ConcatenatedInvertedLists_resize(self, list_no, new_size)
|
|
__swig_destroy__ = _swigfaiss.delete_ConcatenatedInvertedLists
|
|
__del__ = lambda self: None
|
|
ConcatenatedInvertedLists_swigregister = _swigfaiss.ConcatenatedInvertedLists_swigregister
|
|
ConcatenatedInvertedLists_swigregister(ConcatenatedInvertedLists)
|
|
|
|
class Level1Quantizer(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Level1Quantizer, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Level1Quantizer, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["quantizer"] = _swigfaiss.Level1Quantizer_quantizer_set
|
|
__swig_getmethods__["quantizer"] = _swigfaiss.Level1Quantizer_quantizer_get
|
|
if _newclass:
|
|
quantizer = _swig_property(_swigfaiss.Level1Quantizer_quantizer_get, _swigfaiss.Level1Quantizer_quantizer_set)
|
|
__swig_setmethods__["nlist"] = _swigfaiss.Level1Quantizer_nlist_set
|
|
__swig_getmethods__["nlist"] = _swigfaiss.Level1Quantizer_nlist_get
|
|
if _newclass:
|
|
nlist = _swig_property(_swigfaiss.Level1Quantizer_nlist_get, _swigfaiss.Level1Quantizer_nlist_set)
|
|
__swig_setmethods__["quantizer_trains_alone"] = _swigfaiss.Level1Quantizer_quantizer_trains_alone_set
|
|
__swig_getmethods__["quantizer_trains_alone"] = _swigfaiss.Level1Quantizer_quantizer_trains_alone_get
|
|
if _newclass:
|
|
quantizer_trains_alone = _swig_property(_swigfaiss.Level1Quantizer_quantizer_trains_alone_get, _swigfaiss.Level1Quantizer_quantizer_trains_alone_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.Level1Quantizer_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.Level1Quantizer_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.Level1Quantizer_own_fields_get, _swigfaiss.Level1Quantizer_own_fields_set)
|
|
__swig_setmethods__["cp"] = _swigfaiss.Level1Quantizer_cp_set
|
|
__swig_getmethods__["cp"] = _swigfaiss.Level1Quantizer_cp_get
|
|
if _newclass:
|
|
cp = _swig_property(_swigfaiss.Level1Quantizer_cp_get, _swigfaiss.Level1Quantizer_cp_set)
|
|
__swig_setmethods__["clustering_index"] = _swigfaiss.Level1Quantizer_clustering_index_set
|
|
__swig_getmethods__["clustering_index"] = _swigfaiss.Level1Quantizer_clustering_index_get
|
|
if _newclass:
|
|
clustering_index = _swig_property(_swigfaiss.Level1Quantizer_clustering_index_get, _swigfaiss.Level1Quantizer_clustering_index_set)
|
|
|
|
def train_q1(self, n, x, verbose, metric_type):
|
|
return _swigfaiss.Level1Quantizer_train_q1(self, n, x, verbose, metric_type)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_Level1Quantizer(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_Level1Quantizer
|
|
__del__ = lambda self: None
|
|
Level1Quantizer_swigregister = _swigfaiss.Level1Quantizer_swigregister
|
|
Level1Quantizer_swigregister(Level1Quantizer)
|
|
|
|
class IVFSearchParameters(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IVFSearchParameters, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IVFSearchParameters, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nprobe"] = _swigfaiss.IVFSearchParameters_nprobe_set
|
|
__swig_getmethods__["nprobe"] = _swigfaiss.IVFSearchParameters_nprobe_get
|
|
if _newclass:
|
|
nprobe = _swig_property(_swigfaiss.IVFSearchParameters_nprobe_get, _swigfaiss.IVFSearchParameters_nprobe_set)
|
|
__swig_setmethods__["max_codes"] = _swigfaiss.IVFSearchParameters_max_codes_set
|
|
__swig_getmethods__["max_codes"] = _swigfaiss.IVFSearchParameters_max_codes_get
|
|
if _newclass:
|
|
max_codes = _swig_property(_swigfaiss.IVFSearchParameters_max_codes_get, _swigfaiss.IVFSearchParameters_max_codes_set)
|
|
__swig_destroy__ = _swigfaiss.delete_IVFSearchParameters
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_IVFSearchParameters()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
IVFSearchParameters_swigregister = _swigfaiss.IVFSearchParameters_swigregister
|
|
IVFSearchParameters_swigregister(IVFSearchParameters)
|
|
|
|
class IndexIVF(Index, Level1Quantizer):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index, Level1Quantizer]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVF, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index, Level1Quantizer]:
|
|
__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__["invlists"] = _swigfaiss.IndexIVF_invlists_set
|
|
__swig_getmethods__["invlists"] = _swigfaiss.IndexIVF_invlists_get
|
|
if _newclass:
|
|
invlists = _swig_property(_swigfaiss.IndexIVF_invlists_get, _swigfaiss.IndexIVF_invlists_set)
|
|
__swig_setmethods__["own_invlists"] = _swigfaiss.IndexIVF_own_invlists_set
|
|
__swig_getmethods__["own_invlists"] = _swigfaiss.IndexIVF_own_invlists_get
|
|
if _newclass:
|
|
own_invlists = _swig_property(_swigfaiss.IndexIVF_own_invlists_get, _swigfaiss.IndexIVF_own_invlists_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss.IndexIVF_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss.IndexIVF_code_size_get
|
|
if _newclass:
|
|
code_size = _swig_property(_swigfaiss.IndexIVF_code_size_get, _swigfaiss.IndexIVF_code_size_set)
|
|
__swig_setmethods__["nprobe"] = _swigfaiss.IndexIVF_nprobe_set
|
|
__swig_getmethods__["nprobe"] = _swigfaiss.IndexIVF_nprobe_get
|
|
if _newclass:
|
|
nprobe = _swig_property(_swigfaiss.IndexIVF_nprobe_get, _swigfaiss.IndexIVF_nprobe_set)
|
|
__swig_setmethods__["max_codes"] = _swigfaiss.IndexIVF_max_codes_set
|
|
__swig_getmethods__["max_codes"] = _swigfaiss.IndexIVF_max_codes_get
|
|
if _newclass:
|
|
max_codes = _swig_property(_swigfaiss.IndexIVF_max_codes_get, _swigfaiss.IndexIVF_max_codes_set)
|
|
__swig_setmethods__["maintain_direct_map"] = _swigfaiss.IndexIVF_maintain_direct_map_set
|
|
__swig_getmethods__["maintain_direct_map"] = _swigfaiss.IndexIVF_maintain_direct_map_get
|
|
if _newclass:
|
|
maintain_direct_map = _swig_property(_swigfaiss.IndexIVF_maintain_direct_map_get, _swigfaiss.IndexIVF_maintain_direct_map_set)
|
|
__swig_setmethods__["direct_map"] = _swigfaiss.IndexIVF_direct_map_set
|
|
__swig_getmethods__["direct_map"] = _swigfaiss.IndexIVF_direct_map_get
|
|
if _newclass:
|
|
direct_map = _swig_property(_swigfaiss.IndexIVF_direct_map_get, _swigfaiss.IndexIVF_direct_map_set)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexIVF_reset(self)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexIVF_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexIVF_add(self, n, x)
|
|
|
|
def encode_vectors(self, n, x, list_nos, codes):
|
|
return _swigfaiss.IndexIVF_encode_vectors(self, n, x, list_nos, codes)
|
|
|
|
def train_residual(self, n, x):
|
|
return _swigfaiss.IndexIVF_train_residual(self, n, x)
|
|
|
|
def search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None):
|
|
return _swigfaiss.IndexIVF_search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexIVF_search(self, n, x, k, distances, labels)
|
|
|
|
def get_InvertedListScanner(self, store_pairs=False):
|
|
return _swigfaiss.IndexIVF_get_InvertedListScanner(self, store_pairs)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexIVF_reconstruct(self, key, recons)
|
|
|
|
def reconstruct_n(self, i0, ni, recons):
|
|
return _swigfaiss.IndexIVF_reconstruct_n(self, i0, ni, recons)
|
|
|
|
def search_and_reconstruct(self, n, x, k, distances, labels, recons):
|
|
return _swigfaiss.IndexIVF_search_and_reconstruct(self, n, x, k, distances, labels, recons)
|
|
|
|
def reconstruct_from_offset(self, list_no, offset, recons):
|
|
return _swigfaiss.IndexIVF_reconstruct_from_offset(self, list_no, offset, recons)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexIVF_remove_ids(self, sel)
|
|
|
|
def check_compatible_for_merge(self, other):
|
|
return _swigfaiss.IndexIVF_check_compatible_for_merge(self, other)
|
|
|
|
def merge_from(self, other, add_id):
|
|
return _swigfaiss.IndexIVF_merge_from(self, other, add_id)
|
|
|
|
def copy_subset_to(self, other, subset_type, a1, a2):
|
|
return _swigfaiss.IndexIVF_copy_subset_to(self, other, subset_type, a1, a2)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIVF
|
|
__del__ = lambda self: None
|
|
|
|
def get_list_size(self, list_no):
|
|
return _swigfaiss.IndexIVF_get_list_size(self, list_no)
|
|
|
|
def make_direct_map(self, new_maintain_direct_map=True):
|
|
return _swigfaiss.IndexIVF_make_direct_map(self, new_maintain_direct_map)
|
|
|
|
def imbalance_factor(self):
|
|
return _swigfaiss.IndexIVF_imbalance_factor(self)
|
|
|
|
def print_stats(self):
|
|
return _swigfaiss.IndexIVF_print_stats(self)
|
|
|
|
def replace_invlists(self, il, own=False):
|
|
return _swigfaiss.IndexIVF_replace_invlists(self, il, own)
|
|
IndexIVF_swigregister = _swigfaiss.IndexIVF_swigregister
|
|
IndexIVF_swigregister(IndexIVF)
|
|
|
|
class IndexIVFStats(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVFStats, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVFStats, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["nq"] = _swigfaiss.IndexIVFStats_nq_set
|
|
__swig_getmethods__["nq"] = _swigfaiss.IndexIVFStats_nq_get
|
|
if _newclass:
|
|
nq = _swig_property(_swigfaiss.IndexIVFStats_nq_get, _swigfaiss.IndexIVFStats_nq_set)
|
|
__swig_setmethods__["nlist"] = _swigfaiss.IndexIVFStats_nlist_set
|
|
__swig_getmethods__["nlist"] = _swigfaiss.IndexIVFStats_nlist_get
|
|
if _newclass:
|
|
nlist = _swig_property(_swigfaiss.IndexIVFStats_nlist_get, _swigfaiss.IndexIVFStats_nlist_set)
|
|
__swig_setmethods__["ndis"] = _swigfaiss.IndexIVFStats_ndis_set
|
|
__swig_getmethods__["ndis"] = _swigfaiss.IndexIVFStats_ndis_get
|
|
if _newclass:
|
|
ndis = _swig_property(_swigfaiss.IndexIVFStats_ndis_get, _swigfaiss.IndexIVFStats_ndis_set)
|
|
__swig_setmethods__["nheap_updates"] = _swigfaiss.IndexIVFStats_nheap_updates_set
|
|
__swig_getmethods__["nheap_updates"] = _swigfaiss.IndexIVFStats_nheap_updates_get
|
|
if _newclass:
|
|
nheap_updates = _swig_property(_swigfaiss.IndexIVFStats_nheap_updates_get, _swigfaiss.IndexIVFStats_nheap_updates_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_IndexIVFStats()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexIVFStats_reset(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIVFStats
|
|
__del__ = lambda self: None
|
|
IndexIVFStats_swigregister = _swigfaiss.IndexIVFStats_swigregister
|
|
IndexIVFStats_swigregister(IndexIVFStats)
|
|
|
|
|
|
def check_compatible_for_merge(index1, index2):
|
|
return _swigfaiss.check_compatible_for_merge(index1, index2)
|
|
check_compatible_for_merge = _swigfaiss.check_compatible_for_merge
|
|
|
|
def extract_index_ivf(*args):
|
|
return _swigfaiss.extract_index_ivf(*args)
|
|
extract_index_ivf = _swigfaiss.extract_index_ivf
|
|
|
|
def merge_into(index0, index1, shift_ids):
|
|
return _swigfaiss.merge_into(index0, index1, shift_ids)
|
|
merge_into = _swigfaiss.merge_into
|
|
|
|
def search_centroid(index, x, n, centroid_ids):
|
|
return _swigfaiss.search_centroid(index, x, n, centroid_ids)
|
|
search_centroid = _swigfaiss.search_centroid
|
|
|
|
def search_and_return_centroids(index, n, xin, k, distances, labels, query_centroid_ids, result_centroid_ids):
|
|
return _swigfaiss.search_and_return_centroids(index, n, xin, k, distances, labels, query_centroid_ids, result_centroid_ids)
|
|
search_and_return_centroids = _swigfaiss.search_and_return_centroids
|
|
class SlidingIndexWindow(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, SlidingIndexWindow, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, SlidingIndexWindow, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["index"] = _swigfaiss.SlidingIndexWindow_index_set
|
|
__swig_getmethods__["index"] = _swigfaiss.SlidingIndexWindow_index_get
|
|
if _newclass:
|
|
index = _swig_property(_swigfaiss.SlidingIndexWindow_index_get, _swigfaiss.SlidingIndexWindow_index_set)
|
|
__swig_setmethods__["ils"] = _swigfaiss.SlidingIndexWindow_ils_set
|
|
__swig_getmethods__["ils"] = _swigfaiss.SlidingIndexWindow_ils_get
|
|
if _newclass:
|
|
ils = _swig_property(_swigfaiss.SlidingIndexWindow_ils_get, _swigfaiss.SlidingIndexWindow_ils_set)
|
|
__swig_setmethods__["n_slice"] = _swigfaiss.SlidingIndexWindow_n_slice_set
|
|
__swig_getmethods__["n_slice"] = _swigfaiss.SlidingIndexWindow_n_slice_get
|
|
if _newclass:
|
|
n_slice = _swig_property(_swigfaiss.SlidingIndexWindow_n_slice_get, _swigfaiss.SlidingIndexWindow_n_slice_set)
|
|
__swig_setmethods__["nlist"] = _swigfaiss.SlidingIndexWindow_nlist_set
|
|
__swig_getmethods__["nlist"] = _swigfaiss.SlidingIndexWindow_nlist_get
|
|
if _newclass:
|
|
nlist = _swig_property(_swigfaiss.SlidingIndexWindow_nlist_get, _swigfaiss.SlidingIndexWindow_nlist_set)
|
|
__swig_setmethods__["sizes"] = _swigfaiss.SlidingIndexWindow_sizes_set
|
|
__swig_getmethods__["sizes"] = _swigfaiss.SlidingIndexWindow_sizes_get
|
|
if _newclass:
|
|
sizes = _swig_property(_swigfaiss.SlidingIndexWindow_sizes_get, _swigfaiss.SlidingIndexWindow_sizes_set)
|
|
|
|
def __init__(self, index):
|
|
this = _swigfaiss.new_SlidingIndexWindow(index)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def step(self, sub_index, remove_oldest):
|
|
return _swigfaiss.SlidingIndexWindow_step(self, sub_index, remove_oldest)
|
|
__swig_destroy__ = _swigfaiss.delete_SlidingIndexWindow
|
|
__del__ = lambda self: None
|
|
SlidingIndexWindow_swigregister = _swigfaiss.SlidingIndexWindow_swigregister
|
|
SlidingIndexWindow_swigregister(SlidingIndexWindow)
|
|
|
|
|
|
def get_invlist_range(index, i0, i1):
|
|
return _swigfaiss.get_invlist_range(index, i0, i1)
|
|
get_invlist_range = _swigfaiss.get_invlist_range
|
|
|
|
def set_invlist_range(index, i0, i1, src):
|
|
return _swigfaiss.set_invlist_range(index, i0, i1, src)
|
|
set_invlist_range = _swigfaiss.set_invlist_range
|
|
|
|
def search_with_parameters(index, n, x, k, distances, labels, params):
|
|
return _swigfaiss.search_with_parameters(index, n, x, k, distances, labels, params)
|
|
search_with_parameters = _swigfaiss.search_with_parameters
|
|
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.ScalarQuantizer_QT_8bit
|
|
QT_4bit = _swigfaiss.ScalarQuantizer_QT_4bit
|
|
QT_8bit_uniform = _swigfaiss.ScalarQuantizer_QT_8bit_uniform
|
|
QT_4bit_uniform = _swigfaiss.ScalarQuantizer_QT_4bit_uniform
|
|
QT_fp16 = _swigfaiss.ScalarQuantizer_QT_fp16
|
|
__swig_setmethods__["qtype"] = _swigfaiss.ScalarQuantizer_qtype_set
|
|
__swig_getmethods__["qtype"] = _swigfaiss.ScalarQuantizer_qtype_get
|
|
if _newclass:
|
|
qtype = _swig_property(_swigfaiss.ScalarQuantizer_qtype_get, _swigfaiss.ScalarQuantizer_qtype_set)
|
|
RS_minmax = _swigfaiss.ScalarQuantizer_RS_minmax
|
|
RS_meanstd = _swigfaiss.ScalarQuantizer_RS_meanstd
|
|
RS_quantiles = _swigfaiss.ScalarQuantizer_RS_quantiles
|
|
RS_optim = _swigfaiss.ScalarQuantizer_RS_optim
|
|
__swig_setmethods__["rangestat"] = _swigfaiss.ScalarQuantizer_rangestat_set
|
|
__swig_getmethods__["rangestat"] = _swigfaiss.ScalarQuantizer_rangestat_get
|
|
if _newclass:
|
|
rangestat = _swig_property(_swigfaiss.ScalarQuantizer_rangestat_get, _swigfaiss.ScalarQuantizer_rangestat_set)
|
|
__swig_setmethods__["rangestat_arg"] = _swigfaiss.ScalarQuantizer_rangestat_arg_set
|
|
__swig_getmethods__["rangestat_arg"] = _swigfaiss.ScalarQuantizer_rangestat_arg_get
|
|
if _newclass:
|
|
rangestat_arg = _swig_property(_swigfaiss.ScalarQuantizer_rangestat_arg_get, _swigfaiss.ScalarQuantizer_rangestat_arg_set)
|
|
__swig_setmethods__["d"] = _swigfaiss.ScalarQuantizer_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss.ScalarQuantizer_d_get
|
|
if _newclass:
|
|
d = _swig_property(_swigfaiss.ScalarQuantizer_d_get, _swigfaiss.ScalarQuantizer_d_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss.ScalarQuantizer_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss.ScalarQuantizer_code_size_get
|
|
if _newclass:
|
|
code_size = _swig_property(_swigfaiss.ScalarQuantizer_code_size_get, _swigfaiss.ScalarQuantizer_code_size_set)
|
|
__swig_setmethods__["trained"] = _swigfaiss.ScalarQuantizer_trained_set
|
|
__swig_getmethods__["trained"] = _swigfaiss.ScalarQuantizer_trained_get
|
|
if _newclass:
|
|
trained = _swig_property(_swigfaiss.ScalarQuantizer_trained_get, _swigfaiss.ScalarQuantizer_trained_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_ScalarQuantizer(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.ScalarQuantizer_train(self, n, x)
|
|
|
|
def compute_codes(self, x, codes, n):
|
|
return _swigfaiss.ScalarQuantizer_compute_codes(self, x, codes, n)
|
|
|
|
def decode(self, code, x, n):
|
|
return _swigfaiss.ScalarQuantizer_decode(self, code, x, n)
|
|
|
|
def get_distance_computer(self, *args):
|
|
return _swigfaiss.ScalarQuantizer_get_distance_computer(self, *args)
|
|
__swig_destroy__ = _swigfaiss.delete_ScalarQuantizer
|
|
__del__ = lambda self: None
|
|
ScalarQuantizer_swigregister = _swigfaiss.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.IndexScalarQuantizer_sq_set
|
|
__swig_getmethods__["sq"] = _swigfaiss.IndexScalarQuantizer_sq_get
|
|
if _newclass:
|
|
sq = _swig_property(_swigfaiss.IndexScalarQuantizer_sq_get, _swigfaiss.IndexScalarQuantizer_sq_set)
|
|
__swig_setmethods__["codes"] = _swigfaiss.IndexScalarQuantizer_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss.IndexScalarQuantizer_codes_get
|
|
if _newclass:
|
|
codes = _swig_property(_swigfaiss.IndexScalarQuantizer_codes_get, _swigfaiss.IndexScalarQuantizer_codes_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss.IndexScalarQuantizer_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss.IndexScalarQuantizer_code_size_get
|
|
if _newclass:
|
|
code_size = _swig_property(_swigfaiss.IndexScalarQuantizer_code_size_get, _swigfaiss.IndexScalarQuantizer_code_size_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexScalarQuantizer(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexScalarQuantizer_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexScalarQuantizer_add(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexScalarQuantizer_search(self, n, x, k, distances, labels)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexScalarQuantizer_reset(self)
|
|
|
|
def reconstruct_n(self, i0, ni, recons):
|
|
return _swigfaiss.IndexScalarQuantizer_reconstruct_n(self, i0, ni, recons)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexScalarQuantizer_reconstruct(self, key, recons)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexScalarQuantizer
|
|
__del__ = lambda self: None
|
|
IndexScalarQuantizer_swigregister = _swigfaiss.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.IndexIVFScalarQuantizer_sq_set
|
|
__swig_getmethods__["sq"] = _swigfaiss.IndexIVFScalarQuantizer_sq_get
|
|
if _newclass:
|
|
sq = _swig_property(_swigfaiss.IndexIVFScalarQuantizer_sq_get, _swigfaiss.IndexIVFScalarQuantizer_sq_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexIVFScalarQuantizer(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train_residual(self, n, x):
|
|
return _swigfaiss.IndexIVFScalarQuantizer_train_residual(self, n, x)
|
|
|
|
def encode_vectors(self, n, x, list_nos, codes):
|
|
return _swigfaiss.IndexIVFScalarQuantizer_encode_vectors(self, n, x, list_nos, codes)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexIVFScalarQuantizer_add_with_ids(self, n, x, xids)
|
|
|
|
def get_InvertedListScanner(self, store_pairs):
|
|
return _swigfaiss.IndexIVFScalarQuantizer_get_InvertedListScanner(self, store_pairs)
|
|
|
|
def reconstruct_from_offset(self, list_no, offset, recons):
|
|
return _swigfaiss.IndexIVFScalarQuantizer_reconstruct_from_offset(self, list_no, offset, recons)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIVFScalarQuantizer
|
|
__del__ = lambda self: None
|
|
IndexIVFScalarQuantizer_swigregister = _swigfaiss.IndexIVFScalarQuantizer_swigregister
|
|
IndexIVFScalarQuantizer_swigregister(IndexIVFScalarQuantizer)
|
|
|
|
class HNSW(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HNSW, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HNSW, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["assign_probas"] = _swigfaiss.HNSW_assign_probas_set
|
|
__swig_getmethods__["assign_probas"] = _swigfaiss.HNSW_assign_probas_get
|
|
if _newclass:
|
|
assign_probas = _swig_property(_swigfaiss.HNSW_assign_probas_get, _swigfaiss.HNSW_assign_probas_set)
|
|
__swig_setmethods__["cum_nneighbor_per_level"] = _swigfaiss.HNSW_cum_nneighbor_per_level_set
|
|
__swig_getmethods__["cum_nneighbor_per_level"] = _swigfaiss.HNSW_cum_nneighbor_per_level_get
|
|
if _newclass:
|
|
cum_nneighbor_per_level = _swig_property(_swigfaiss.HNSW_cum_nneighbor_per_level_get, _swigfaiss.HNSW_cum_nneighbor_per_level_set)
|
|
__swig_setmethods__["levels"] = _swigfaiss.HNSW_levels_set
|
|
__swig_getmethods__["levels"] = _swigfaiss.HNSW_levels_get
|
|
if _newclass:
|
|
levels = _swig_property(_swigfaiss.HNSW_levels_get, _swigfaiss.HNSW_levels_set)
|
|
__swig_setmethods__["offsets"] = _swigfaiss.HNSW_offsets_set
|
|
__swig_getmethods__["offsets"] = _swigfaiss.HNSW_offsets_get
|
|
if _newclass:
|
|
offsets = _swig_property(_swigfaiss.HNSW_offsets_get, _swigfaiss.HNSW_offsets_set)
|
|
__swig_setmethods__["neighbors"] = _swigfaiss.HNSW_neighbors_set
|
|
__swig_getmethods__["neighbors"] = _swigfaiss.HNSW_neighbors_get
|
|
if _newclass:
|
|
neighbors = _swig_property(_swigfaiss.HNSW_neighbors_get, _swigfaiss.HNSW_neighbors_set)
|
|
__swig_setmethods__["entry_point"] = _swigfaiss.HNSW_entry_point_set
|
|
__swig_getmethods__["entry_point"] = _swigfaiss.HNSW_entry_point_get
|
|
if _newclass:
|
|
entry_point = _swig_property(_swigfaiss.HNSW_entry_point_get, _swigfaiss.HNSW_entry_point_set)
|
|
__swig_setmethods__["rng"] = _swigfaiss.HNSW_rng_set
|
|
__swig_getmethods__["rng"] = _swigfaiss.HNSW_rng_get
|
|
if _newclass:
|
|
rng = _swig_property(_swigfaiss.HNSW_rng_get, _swigfaiss.HNSW_rng_set)
|
|
__swig_setmethods__["max_level"] = _swigfaiss.HNSW_max_level_set
|
|
__swig_getmethods__["max_level"] = _swigfaiss.HNSW_max_level_get
|
|
if _newclass:
|
|
max_level = _swig_property(_swigfaiss.HNSW_max_level_get, _swigfaiss.HNSW_max_level_set)
|
|
__swig_setmethods__["efConstruction"] = _swigfaiss.HNSW_efConstruction_set
|
|
__swig_getmethods__["efConstruction"] = _swigfaiss.HNSW_efConstruction_get
|
|
if _newclass:
|
|
efConstruction = _swig_property(_swigfaiss.HNSW_efConstruction_get, _swigfaiss.HNSW_efConstruction_set)
|
|
__swig_setmethods__["efSearch"] = _swigfaiss.HNSW_efSearch_set
|
|
__swig_getmethods__["efSearch"] = _swigfaiss.HNSW_efSearch_get
|
|
if _newclass:
|
|
efSearch = _swig_property(_swigfaiss.HNSW_efSearch_get, _swigfaiss.HNSW_efSearch_set)
|
|
__swig_setmethods__["upper_beam"] = _swigfaiss.HNSW_upper_beam_set
|
|
__swig_getmethods__["upper_beam"] = _swigfaiss.HNSW_upper_beam_get
|
|
if _newclass:
|
|
upper_beam = _swig_property(_swigfaiss.HNSW_upper_beam_get, _swigfaiss.HNSW_upper_beam_set)
|
|
|
|
def set_default_probas(self, M, levelMult):
|
|
return _swigfaiss.HNSW_set_default_probas(self, M, levelMult)
|
|
|
|
def set_nb_neighbors(self, level_no, n):
|
|
return _swigfaiss.HNSW_set_nb_neighbors(self, level_no, n)
|
|
|
|
def nb_neighbors(self, layer_no):
|
|
return _swigfaiss.HNSW_nb_neighbors(self, layer_no)
|
|
|
|
def cum_nb_neighbors(self, layer_no):
|
|
return _swigfaiss.HNSW_cum_nb_neighbors(self, layer_no)
|
|
|
|
def neighbor_range(self, no, layer_no, begin, end):
|
|
return _swigfaiss.HNSW_neighbor_range(self, no, layer_no, begin, end)
|
|
|
|
def __init__(self, M=32):
|
|
this = _swigfaiss.new_HNSW(M)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def random_level(self):
|
|
return _swigfaiss.HNSW_random_level(self)
|
|
|
|
def fill_with_random_links(self, n):
|
|
return _swigfaiss.HNSW_fill_with_random_links(self, n)
|
|
|
|
def add_links_starting_from(self, ptdis, pt_id, nearest, d_nearest, level, locks, vt):
|
|
return _swigfaiss.HNSW_add_links_starting_from(self, ptdis, pt_id, nearest, d_nearest, level, locks, vt)
|
|
|
|
def add_with_locks(self, ptdis, pt_level, pt_id, locks, vt):
|
|
return _swigfaiss.HNSW_add_with_locks(self, ptdis, pt_level, pt_id, locks, vt)
|
|
|
|
def search_from_candidates(self, qdis, k, I, D, candidates, vt, level, nres_in=0):
|
|
return _swigfaiss.HNSW_search_from_candidates(self, qdis, k, I, D, candidates, vt, level, nres_in)
|
|
|
|
def search_from(self, node, qdis, ef, vt):
|
|
return _swigfaiss.HNSW_search_from(self, node, qdis, ef, vt)
|
|
|
|
def search(self, qdis, k, I, D, vt):
|
|
return _swigfaiss.HNSW_search(self, qdis, k, I, D, vt)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.HNSW_reset(self)
|
|
|
|
def clear_neighbor_tables(self, level):
|
|
return _swigfaiss.HNSW_clear_neighbor_tables(self, level)
|
|
|
|
def print_neighbor_stats(self, level):
|
|
return _swigfaiss.HNSW_print_neighbor_stats(self, level)
|
|
|
|
def prepare_level_tab(self, n, preset_levels=False):
|
|
return _swigfaiss.HNSW_prepare_level_tab(self, n, preset_levels)
|
|
if _newclass:
|
|
shrink_neighbor_list = staticmethod(_swigfaiss.HNSW_shrink_neighbor_list)
|
|
else:
|
|
shrink_neighbor_list = _swigfaiss.HNSW_shrink_neighbor_list
|
|
__swig_destroy__ = _swigfaiss.delete_HNSW
|
|
__del__ = lambda self: None
|
|
HNSW_swigregister = _swigfaiss.HNSW_swigregister
|
|
HNSW_swigregister(HNSW)
|
|
|
|
def HNSW_shrink_neighbor_list(qdis, input, output, max_size):
|
|
return _swigfaiss.HNSW_shrink_neighbor_list(qdis, input, output, max_size)
|
|
HNSW_shrink_neighbor_list = _swigfaiss.HNSW_shrink_neighbor_list
|
|
|
|
class VisitedTable(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, VisitedTable, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, VisitedTable, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["visited"] = _swigfaiss.VisitedTable_visited_set
|
|
__swig_getmethods__["visited"] = _swigfaiss.VisitedTable_visited_get
|
|
if _newclass:
|
|
visited = _swig_property(_swigfaiss.VisitedTable_visited_get, _swigfaiss.VisitedTable_visited_set)
|
|
__swig_setmethods__["visno"] = _swigfaiss.VisitedTable_visno_set
|
|
__swig_getmethods__["visno"] = _swigfaiss.VisitedTable_visno_get
|
|
if _newclass:
|
|
visno = _swig_property(_swigfaiss.VisitedTable_visno_get, _swigfaiss.VisitedTable_visno_set)
|
|
|
|
def __init__(self, size):
|
|
this = _swigfaiss.new_VisitedTable(size)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def set(self, no):
|
|
return _swigfaiss.VisitedTable_set(self, no)
|
|
|
|
def get(self, no):
|
|
return _swigfaiss.VisitedTable_get(self, no)
|
|
|
|
def advance(self):
|
|
return _swigfaiss.VisitedTable_advance(self)
|
|
__swig_destroy__ = _swigfaiss.delete_VisitedTable
|
|
__del__ = lambda self: None
|
|
VisitedTable_swigregister = _swigfaiss.VisitedTable_swigregister
|
|
VisitedTable_swigregister(VisitedTable)
|
|
|
|
class HNSWStats(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HNSWStats, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HNSWStats, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["n1"] = _swigfaiss.HNSWStats_n1_set
|
|
__swig_getmethods__["n1"] = _swigfaiss.HNSWStats_n1_get
|
|
if _newclass:
|
|
n1 = _swig_property(_swigfaiss.HNSWStats_n1_get, _swigfaiss.HNSWStats_n1_set)
|
|
__swig_setmethods__["n2"] = _swigfaiss.HNSWStats_n2_set
|
|
__swig_getmethods__["n2"] = _swigfaiss.HNSWStats_n2_get
|
|
if _newclass:
|
|
n2 = _swig_property(_swigfaiss.HNSWStats_n2_get, _swigfaiss.HNSWStats_n2_set)
|
|
__swig_setmethods__["n3"] = _swigfaiss.HNSWStats_n3_set
|
|
__swig_getmethods__["n3"] = _swigfaiss.HNSWStats_n3_get
|
|
if _newclass:
|
|
n3 = _swig_property(_swigfaiss.HNSWStats_n3_get, _swigfaiss.HNSWStats_n3_set)
|
|
__swig_setmethods__["ndis"] = _swigfaiss.HNSWStats_ndis_set
|
|
__swig_getmethods__["ndis"] = _swigfaiss.HNSWStats_ndis_get
|
|
if _newclass:
|
|
ndis = _swig_property(_swigfaiss.HNSWStats_ndis_get, _swigfaiss.HNSWStats_ndis_set)
|
|
__swig_setmethods__["nreorder"] = _swigfaiss.HNSWStats_nreorder_set
|
|
__swig_getmethods__["nreorder"] = _swigfaiss.HNSWStats_nreorder_get
|
|
if _newclass:
|
|
nreorder = _swig_property(_swigfaiss.HNSWStats_nreorder_get, _swigfaiss.HNSWStats_nreorder_set)
|
|
__swig_setmethods__["view"] = _swigfaiss.HNSWStats_view_set
|
|
__swig_getmethods__["view"] = _swigfaiss.HNSWStats_view_get
|
|
if _newclass:
|
|
view = _swig_property(_swigfaiss.HNSWStats_view_get, _swigfaiss.HNSWStats_view_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_HNSWStats()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def reset(self):
|
|
return _swigfaiss.HNSWStats_reset(self)
|
|
__swig_destroy__ = _swigfaiss.delete_HNSWStats
|
|
__del__ = lambda self: None
|
|
HNSWStats_swigregister = _swigfaiss.HNSWStats_swigregister
|
|
HNSWStats_swigregister(HNSWStats)
|
|
|
|
class ReconstructFromNeighbors(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ReconstructFromNeighbors, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ReconstructFromNeighbors, name)
|
|
__repr__ = _swig_repr
|
|
__swig_getmethods__["index"] = _swigfaiss.ReconstructFromNeighbors_index_get
|
|
if _newclass:
|
|
index = _swig_property(_swigfaiss.ReconstructFromNeighbors_index_get)
|
|
__swig_setmethods__["M"] = _swigfaiss.ReconstructFromNeighbors_M_set
|
|
__swig_getmethods__["M"] = _swigfaiss.ReconstructFromNeighbors_M_get
|
|
if _newclass:
|
|
M = _swig_property(_swigfaiss.ReconstructFromNeighbors_M_get, _swigfaiss.ReconstructFromNeighbors_M_set)
|
|
__swig_setmethods__["k"] = _swigfaiss.ReconstructFromNeighbors_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss.ReconstructFromNeighbors_k_get
|
|
if _newclass:
|
|
k = _swig_property(_swigfaiss.ReconstructFromNeighbors_k_get, _swigfaiss.ReconstructFromNeighbors_k_set)
|
|
__swig_setmethods__["nsq"] = _swigfaiss.ReconstructFromNeighbors_nsq_set
|
|
__swig_getmethods__["nsq"] = _swigfaiss.ReconstructFromNeighbors_nsq_get
|
|
if _newclass:
|
|
nsq = _swig_property(_swigfaiss.ReconstructFromNeighbors_nsq_get, _swigfaiss.ReconstructFromNeighbors_nsq_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss.ReconstructFromNeighbors_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss.ReconstructFromNeighbors_code_size_get
|
|
if _newclass:
|
|
code_size = _swig_property(_swigfaiss.ReconstructFromNeighbors_code_size_get, _swigfaiss.ReconstructFromNeighbors_code_size_set)
|
|
__swig_setmethods__["k_reorder"] = _swigfaiss.ReconstructFromNeighbors_k_reorder_set
|
|
__swig_getmethods__["k_reorder"] = _swigfaiss.ReconstructFromNeighbors_k_reorder_get
|
|
if _newclass:
|
|
k_reorder = _swig_property(_swigfaiss.ReconstructFromNeighbors_k_reorder_get, _swigfaiss.ReconstructFromNeighbors_k_reorder_set)
|
|
__swig_setmethods__["codebook"] = _swigfaiss.ReconstructFromNeighbors_codebook_set
|
|
__swig_getmethods__["codebook"] = _swigfaiss.ReconstructFromNeighbors_codebook_get
|
|
if _newclass:
|
|
codebook = _swig_property(_swigfaiss.ReconstructFromNeighbors_codebook_get, _swigfaiss.ReconstructFromNeighbors_codebook_set)
|
|
__swig_setmethods__["codes"] = _swigfaiss.ReconstructFromNeighbors_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss.ReconstructFromNeighbors_codes_get
|
|
if _newclass:
|
|
codes = _swig_property(_swigfaiss.ReconstructFromNeighbors_codes_get, _swigfaiss.ReconstructFromNeighbors_codes_set)
|
|
__swig_setmethods__["ntotal"] = _swigfaiss.ReconstructFromNeighbors_ntotal_set
|
|
__swig_getmethods__["ntotal"] = _swigfaiss.ReconstructFromNeighbors_ntotal_get
|
|
if _newclass:
|
|
ntotal = _swig_property(_swigfaiss.ReconstructFromNeighbors_ntotal_get, _swigfaiss.ReconstructFromNeighbors_ntotal_set)
|
|
__swig_setmethods__["d"] = _swigfaiss.ReconstructFromNeighbors_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss.ReconstructFromNeighbors_d_get
|
|
if _newclass:
|
|
d = _swig_property(_swigfaiss.ReconstructFromNeighbors_d_get, _swigfaiss.ReconstructFromNeighbors_d_set)
|
|
__swig_setmethods__["dsub"] = _swigfaiss.ReconstructFromNeighbors_dsub_set
|
|
__swig_getmethods__["dsub"] = _swigfaiss.ReconstructFromNeighbors_dsub_get
|
|
if _newclass:
|
|
dsub = _swig_property(_swigfaiss.ReconstructFromNeighbors_dsub_get, _swigfaiss.ReconstructFromNeighbors_dsub_set)
|
|
|
|
def __init__(self, index, k=256, nsq=1):
|
|
this = _swigfaiss.new_ReconstructFromNeighbors(index, k, nsq)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def add_codes(self, n, x):
|
|
return _swigfaiss.ReconstructFromNeighbors_add_codes(self, n, x)
|
|
|
|
def compute_distances(self, n, shortlist, query, distances):
|
|
return _swigfaiss.ReconstructFromNeighbors_compute_distances(self, n, shortlist, query, distances)
|
|
|
|
def estimate_code(self, x, i, code):
|
|
return _swigfaiss.ReconstructFromNeighbors_estimate_code(self, x, i, code)
|
|
|
|
def reconstruct(self, i, x, tmp):
|
|
return _swigfaiss.ReconstructFromNeighbors_reconstruct(self, i, x, tmp)
|
|
|
|
def reconstruct_n(self, n0, ni, x):
|
|
return _swigfaiss.ReconstructFromNeighbors_reconstruct_n(self, n0, ni, x)
|
|
|
|
def get_neighbor_table(self, i, out):
|
|
return _swigfaiss.ReconstructFromNeighbors_get_neighbor_table(self, i, out)
|
|
__swig_destroy__ = _swigfaiss.delete_ReconstructFromNeighbors
|
|
__del__ = lambda self: None
|
|
ReconstructFromNeighbors_swigregister = _swigfaiss.ReconstructFromNeighbors_swigregister
|
|
ReconstructFromNeighbors_swigregister(ReconstructFromNeighbors)
|
|
|
|
class IndexHNSW(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexHNSW, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexHNSW, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["hnsw"] = _swigfaiss.IndexHNSW_hnsw_set
|
|
__swig_getmethods__["hnsw"] = _swigfaiss.IndexHNSW_hnsw_get
|
|
if _newclass:
|
|
hnsw = _swig_property(_swigfaiss.IndexHNSW_hnsw_get, _swigfaiss.IndexHNSW_hnsw_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.IndexHNSW_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.IndexHNSW_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.IndexHNSW_own_fields_get, _swigfaiss.IndexHNSW_own_fields_set)
|
|
__swig_setmethods__["storage"] = _swigfaiss.IndexHNSW_storage_set
|
|
__swig_getmethods__["storage"] = _swigfaiss.IndexHNSW_storage_get
|
|
if _newclass:
|
|
storage = _swig_property(_swigfaiss.IndexHNSW_storage_get, _swigfaiss.IndexHNSW_storage_set)
|
|
__swig_setmethods__["reconstruct_from_neighbors"] = _swigfaiss.IndexHNSW_reconstruct_from_neighbors_set
|
|
__swig_getmethods__["reconstruct_from_neighbors"] = _swigfaiss.IndexHNSW_reconstruct_from_neighbors_get
|
|
if _newclass:
|
|
reconstruct_from_neighbors = _swig_property(_swigfaiss.IndexHNSW_reconstruct_from_neighbors_get, _swigfaiss.IndexHNSW_reconstruct_from_neighbors_set)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexHNSW
|
|
__del__ = lambda self: None
|
|
|
|
def get_distance_computer(self):
|
|
return _swigfaiss.IndexHNSW_get_distance_computer(self)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexHNSW_add(self, n, x)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexHNSW_train(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexHNSW_search(self, n, x, k, distances, labels)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexHNSW_reconstruct(self, key, recons)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexHNSW_reset(self)
|
|
|
|
def shrink_level_0_neighbors(self, size):
|
|
return _swigfaiss.IndexHNSW_shrink_level_0_neighbors(self, size)
|
|
|
|
def search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe=1, search_type=1):
|
|
return _swigfaiss.IndexHNSW_search_level_0(self, n, x, k, nearest, nearest_d, distances, labels, nprobe, search_type)
|
|
|
|
def init_level_0_from_knngraph(self, k, D, I):
|
|
return _swigfaiss.IndexHNSW_init_level_0_from_knngraph(self, k, D, I)
|
|
|
|
def init_level_0_from_entry_points(self, npt, points, nearests):
|
|
return _swigfaiss.IndexHNSW_init_level_0_from_entry_points(self, npt, points, nearests)
|
|
|
|
def reorder_links(self):
|
|
return _swigfaiss.IndexHNSW_reorder_links(self)
|
|
|
|
def link_singletons(self):
|
|
return _swigfaiss.IndexHNSW_link_singletons(self)
|
|
IndexHNSW_swigregister = _swigfaiss.IndexHNSW_swigregister
|
|
IndexHNSW_swigregister(IndexHNSW)
|
|
|
|
class IndexHNSWFlat(IndexHNSW):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexHNSW]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexHNSWFlat, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexHNSW]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexHNSWFlat, name)
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexHNSWFlat(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def get_distance_computer(self):
|
|
return _swigfaiss.IndexHNSWFlat_get_distance_computer(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexHNSWFlat
|
|
__del__ = lambda self: None
|
|
IndexHNSWFlat_swigregister = _swigfaiss.IndexHNSWFlat_swigregister
|
|
IndexHNSWFlat_swigregister(IndexHNSWFlat)
|
|
|
|
class IndexHNSWPQ(IndexHNSW):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexHNSW]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexHNSWPQ, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexHNSW]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexHNSWPQ, name)
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexHNSWPQ(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexHNSWPQ_train(self, n, x)
|
|
|
|
def get_distance_computer(self):
|
|
return _swigfaiss.IndexHNSWPQ_get_distance_computer(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexHNSWPQ
|
|
__del__ = lambda self: None
|
|
IndexHNSWPQ_swigregister = _swigfaiss.IndexHNSWPQ_swigregister
|
|
IndexHNSWPQ_swigregister(IndexHNSWPQ)
|
|
|
|
class IndexHNSWSQ(IndexHNSW):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexHNSW]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexHNSWSQ, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexHNSW]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexHNSWSQ, name)
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexHNSWSQ(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def get_distance_computer(self):
|
|
return _swigfaiss.IndexHNSWSQ_get_distance_computer(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexHNSWSQ
|
|
__del__ = lambda self: None
|
|
IndexHNSWSQ_swigregister = _swigfaiss.IndexHNSWSQ_swigregister
|
|
IndexHNSWSQ_swigregister(IndexHNSWSQ)
|
|
|
|
class IndexHNSW2Level(IndexHNSW):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexHNSW]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexHNSW2Level, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexHNSW]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexHNSW2Level, name)
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexHNSW2Level(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def get_distance_computer(self):
|
|
return _swigfaiss.IndexHNSW2Level_get_distance_computer(self)
|
|
|
|
def flip_to_ivf(self):
|
|
return _swigfaiss.IndexHNSW2Level_flip_to_ivf(self)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexHNSW2Level_search(self, n, x, k, distances, labels)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexHNSW2Level
|
|
__del__ = lambda self: None
|
|
IndexHNSW2Level_swigregister = _swigfaiss.IndexHNSW2Level_swigregister
|
|
IndexHNSW2Level_swigregister(IndexHNSW2Level)
|
|
|
|
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, n, x, xids, precomputed_idx):
|
|
return _swigfaiss.IndexIVFFlat_add_core(self, n, x, xids, precomputed_idx)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexIVFFlat_add_with_ids(self, n, x, xids)
|
|
|
|
def encode_vectors(self, n, x, list_nos, codes):
|
|
return _swigfaiss.IndexIVFFlat_encode_vectors(self, n, x, list_nos, codes)
|
|
|
|
def get_InvertedListScanner(self, store_pairs):
|
|
return _swigfaiss.IndexIVFFlat_get_InvertedListScanner(self, store_pairs)
|
|
|
|
def range_search(self, n, x, radius, result):
|
|
return _swigfaiss.IndexIVFFlat_range_search(self, n, x, radius, result)
|
|
|
|
def update_vectors(self, nv, idx, v):
|
|
return _swigfaiss.IndexIVFFlat_update_vectors(self, nv, idx, v)
|
|
|
|
def reconstruct_from_offset(self, list_no, offset, recons):
|
|
return _swigfaiss.IndexIVFFlat_reconstruct_from_offset(self, list_no, offset, recons)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexIVFFlat(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIVFFlat
|
|
__del__ = lambda self: None
|
|
IndexIVFFlat_swigregister = _swigfaiss.IndexIVFFlat_swigregister
|
|
IndexIVFFlat_swigregister(IndexIVFFlat)
|
|
|
|
class IndexIVFFlatDedup(IndexIVFFlat):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexIVFFlat]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexIVFFlatDedup, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexIVFFlat]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexIVFFlatDedup, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["instances"] = _swigfaiss.IndexIVFFlatDedup_instances_set
|
|
__swig_getmethods__["instances"] = _swigfaiss.IndexIVFFlatDedup_instances_get
|
|
if _newclass:
|
|
instances = _swig_property(_swigfaiss.IndexIVFFlatDedup_instances_get, _swigfaiss.IndexIVFFlatDedup_instances_set)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexIVFFlatDedup_train(self, n, x)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexIVFFlatDedup_add_with_ids(self, n, x, xids)
|
|
|
|
def search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None):
|
|
return _swigfaiss.IndexIVFFlatDedup_search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexIVFFlatDedup_remove_ids(self, sel)
|
|
|
|
def range_search(self, n, x, radius, result):
|
|
return _swigfaiss.IndexIVFFlatDedup_range_search(self, n, x, radius, result)
|
|
|
|
def update_vectors(self, nv, idx, v):
|
|
return _swigfaiss.IndexIVFFlatDedup_update_vectors(self, nv, idx, v)
|
|
|
|
def reconstruct_from_offset(self, list_no, offset, recons):
|
|
return _swigfaiss.IndexIVFFlatDedup_reconstruct_from_offset(self, list_no, offset, recons)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexIVFFlatDedup(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIVFFlatDedup
|
|
__del__ = lambda self: None
|
|
IndexIVFFlatDedup_swigregister = _swigfaiss.IndexIVFFlatDedup_swigregister
|
|
IndexIVFFlatDedup_swigregister(IndexIVFFlatDedup)
|
|
|
|
class OnDiskInvertedLists(InvertedLists):
|
|
__swig_setmethods__ = {}
|
|
for _s in [InvertedLists]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, OnDiskInvertedLists, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [InvertedLists]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, OnDiskInvertedLists, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["lists"] = _swigfaiss.OnDiskInvertedLists_lists_set
|
|
__swig_getmethods__["lists"] = _swigfaiss.OnDiskInvertedLists_lists_get
|
|
if _newclass:
|
|
lists = _swig_property(_swigfaiss.OnDiskInvertedLists_lists_get, _swigfaiss.OnDiskInvertedLists_lists_set)
|
|
__swig_setmethods__["slots"] = _swigfaiss.OnDiskInvertedLists_slots_set
|
|
__swig_getmethods__["slots"] = _swigfaiss.OnDiskInvertedLists_slots_get
|
|
if _newclass:
|
|
slots = _swig_property(_swigfaiss.OnDiskInvertedLists_slots_get, _swigfaiss.OnDiskInvertedLists_slots_set)
|
|
__swig_setmethods__["filename"] = _swigfaiss.OnDiskInvertedLists_filename_set
|
|
__swig_getmethods__["filename"] = _swigfaiss.OnDiskInvertedLists_filename_get
|
|
if _newclass:
|
|
filename = _swig_property(_swigfaiss.OnDiskInvertedLists_filename_get, _swigfaiss.OnDiskInvertedLists_filename_set)
|
|
__swig_setmethods__["totsize"] = _swigfaiss.OnDiskInvertedLists_totsize_set
|
|
__swig_getmethods__["totsize"] = _swigfaiss.OnDiskInvertedLists_totsize_get
|
|
if _newclass:
|
|
totsize = _swig_property(_swigfaiss.OnDiskInvertedLists_totsize_get, _swigfaiss.OnDiskInvertedLists_totsize_set)
|
|
__swig_setmethods__["ptr"] = _swigfaiss.OnDiskInvertedLists_ptr_set
|
|
__swig_getmethods__["ptr"] = _swigfaiss.OnDiskInvertedLists_ptr_get
|
|
if _newclass:
|
|
ptr = _swig_property(_swigfaiss.OnDiskInvertedLists_ptr_get, _swigfaiss.OnDiskInvertedLists_ptr_set)
|
|
__swig_setmethods__["read_only"] = _swigfaiss.OnDiskInvertedLists_read_only_set
|
|
__swig_getmethods__["read_only"] = _swigfaiss.OnDiskInvertedLists_read_only_get
|
|
if _newclass:
|
|
read_only = _swig_property(_swigfaiss.OnDiskInvertedLists_read_only_get, _swigfaiss.OnDiskInvertedLists_read_only_set)
|
|
|
|
def list_size(self, list_no):
|
|
return _swigfaiss.OnDiskInvertedLists_list_size(self, list_no)
|
|
|
|
def get_codes(self, list_no):
|
|
return _swigfaiss.OnDiskInvertedLists_get_codes(self, list_no)
|
|
|
|
def get_ids(self, list_no):
|
|
return _swigfaiss.OnDiskInvertedLists_get_ids(self, list_no)
|
|
|
|
def add_entries(self, list_no, n_entry, ids, code):
|
|
return _swigfaiss.OnDiskInvertedLists_add_entries(self, list_no, n_entry, ids, code)
|
|
|
|
def update_entries(self, list_no, offset, n_entry, ids, code):
|
|
return _swigfaiss.OnDiskInvertedLists_update_entries(self, list_no, offset, n_entry, ids, code)
|
|
|
|
def resize(self, list_no, new_size):
|
|
return _swigfaiss.OnDiskInvertedLists_resize(self, list_no, new_size)
|
|
|
|
def merge_from(self, ils, n_il):
|
|
return _swigfaiss.OnDiskInvertedLists_merge_from(self, ils, n_il)
|
|
|
|
def prefetch_lists(self, list_nos, nlist):
|
|
return _swigfaiss.OnDiskInvertedLists_prefetch_lists(self, list_nos, nlist)
|
|
__swig_destroy__ = _swigfaiss.delete_OnDiskInvertedLists
|
|
__del__ = lambda self: None
|
|
__swig_setmethods__["locks"] = _swigfaiss.OnDiskInvertedLists_locks_set
|
|
__swig_getmethods__["locks"] = _swigfaiss.OnDiskInvertedLists_locks_get
|
|
if _newclass:
|
|
locks = _swig_property(_swigfaiss.OnDiskInvertedLists_locks_get, _swigfaiss.OnDiskInvertedLists_locks_set)
|
|
__swig_setmethods__["pf"] = _swigfaiss.OnDiskInvertedLists_pf_set
|
|
__swig_getmethods__["pf"] = _swigfaiss.OnDiskInvertedLists_pf_get
|
|
if _newclass:
|
|
pf = _swig_property(_swigfaiss.OnDiskInvertedLists_pf_get, _swigfaiss.OnDiskInvertedLists_pf_set)
|
|
|
|
def do_mmap(self):
|
|
return _swigfaiss.OnDiskInvertedLists_do_mmap(self)
|
|
|
|
def update_totsize(self, new_totsize):
|
|
return _swigfaiss.OnDiskInvertedLists_update_totsize(self, new_totsize)
|
|
|
|
def resize_locked(self, list_no, new_size):
|
|
return _swigfaiss.OnDiskInvertedLists_resize_locked(self, list_no, new_size)
|
|
|
|
def allocate_slot(self, capacity):
|
|
return _swigfaiss.OnDiskInvertedLists_allocate_slot(self, capacity)
|
|
|
|
def free_slot(self, offset, capacity):
|
|
return _swigfaiss.OnDiskInvertedLists_free_slot(self, offset, capacity)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_OnDiskInvertedLists(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
OnDiskInvertedLists_swigregister = _swigfaiss.OnDiskInvertedLists_swigregister
|
|
OnDiskInvertedLists_swigregister(OnDiskInvertedLists)
|
|
|
|
class IVFPQSearchParameters(IVFSearchParameters):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IVFSearchParameters]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IVFPQSearchParameters, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IVFSearchParameters]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IVFPQSearchParameters, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["scan_table_threshold"] = _swigfaiss.IVFPQSearchParameters_scan_table_threshold_set
|
|
__swig_getmethods__["scan_table_threshold"] = _swigfaiss.IVFPQSearchParameters_scan_table_threshold_get
|
|
if _newclass:
|
|
scan_table_threshold = _swig_property(_swigfaiss.IVFPQSearchParameters_scan_table_threshold_get, _swigfaiss.IVFPQSearchParameters_scan_table_threshold_set)
|
|
__swig_setmethods__["polysemous_ht"] = _swigfaiss.IVFPQSearchParameters_polysemous_ht_set
|
|
__swig_getmethods__["polysemous_ht"] = _swigfaiss.IVFPQSearchParameters_polysemous_ht_get
|
|
if _newclass:
|
|
polysemous_ht = _swig_property(_swigfaiss.IVFPQSearchParameters_polysemous_ht_get, _swigfaiss.IVFPQSearchParameters_polysemous_ht_set)
|
|
__swig_destroy__ = _swigfaiss.delete_IVFPQSearchParameters
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_IVFPQSearchParameters()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
IVFPQSearchParameters_swigregister = _swigfaiss.IVFPQSearchParameters_swigregister
|
|
IVFPQSearchParameters_swigregister(IVFPQSearchParameters)
|
|
|
|
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.IndexIVFPQ_by_residual_set
|
|
__swig_getmethods__["by_residual"] = _swigfaiss.IndexIVFPQ_by_residual_get
|
|
if _newclass:
|
|
by_residual = _swig_property(_swigfaiss.IndexIVFPQ_by_residual_get, _swigfaiss.IndexIVFPQ_by_residual_set)
|
|
__swig_setmethods__["pq"] = _swigfaiss.IndexIVFPQ_pq_set
|
|
__swig_getmethods__["pq"] = _swigfaiss.IndexIVFPQ_pq_get
|
|
if _newclass:
|
|
pq = _swig_property(_swigfaiss.IndexIVFPQ_pq_get, _swigfaiss.IndexIVFPQ_pq_set)
|
|
__swig_setmethods__["do_polysemous_training"] = _swigfaiss.IndexIVFPQ_do_polysemous_training_set
|
|
__swig_getmethods__["do_polysemous_training"] = _swigfaiss.IndexIVFPQ_do_polysemous_training_get
|
|
if _newclass:
|
|
do_polysemous_training = _swig_property(_swigfaiss.IndexIVFPQ_do_polysemous_training_get, _swigfaiss.IndexIVFPQ_do_polysemous_training_set)
|
|
__swig_setmethods__["polysemous_training"] = _swigfaiss.IndexIVFPQ_polysemous_training_set
|
|
__swig_getmethods__["polysemous_training"] = _swigfaiss.IndexIVFPQ_polysemous_training_get
|
|
if _newclass:
|
|
polysemous_training = _swig_property(_swigfaiss.IndexIVFPQ_polysemous_training_get, _swigfaiss.IndexIVFPQ_polysemous_training_set)
|
|
__swig_setmethods__["scan_table_threshold"] = _swigfaiss.IndexIVFPQ_scan_table_threshold_set
|
|
__swig_getmethods__["scan_table_threshold"] = _swigfaiss.IndexIVFPQ_scan_table_threshold_get
|
|
if _newclass:
|
|
scan_table_threshold = _swig_property(_swigfaiss.IndexIVFPQ_scan_table_threshold_get, _swigfaiss.IndexIVFPQ_scan_table_threshold_set)
|
|
__swig_setmethods__["polysemous_ht"] = _swigfaiss.IndexIVFPQ_polysemous_ht_set
|
|
__swig_getmethods__["polysemous_ht"] = _swigfaiss.IndexIVFPQ_polysemous_ht_get
|
|
if _newclass:
|
|
polysemous_ht = _swig_property(_swigfaiss.IndexIVFPQ_polysemous_ht_get, _swigfaiss.IndexIVFPQ_polysemous_ht_set)
|
|
__swig_setmethods__["use_precomputed_table"] = _swigfaiss.IndexIVFPQ_use_precomputed_table_set
|
|
__swig_getmethods__["use_precomputed_table"] = _swigfaiss.IndexIVFPQ_use_precomputed_table_get
|
|
if _newclass:
|
|
use_precomputed_table = _swig_property(_swigfaiss.IndexIVFPQ_use_precomputed_table_get, _swigfaiss.IndexIVFPQ_use_precomputed_table_set)
|
|
__swig_setmethods__["precomputed_table_max_bytes"] = _swigfaiss.IndexIVFPQ_precomputed_table_max_bytes_set
|
|
__swig_getmethods__["precomputed_table_max_bytes"] = _swigfaiss.IndexIVFPQ_precomputed_table_max_bytes_get
|
|
if _newclass:
|
|
precomputed_table_max_bytes = _swig_property(_swigfaiss.IndexIVFPQ_precomputed_table_max_bytes_get, _swigfaiss.IndexIVFPQ_precomputed_table_max_bytes_set)
|
|
__swig_setmethods__["precomputed_table"] = _swigfaiss.IndexIVFPQ_precomputed_table_set
|
|
__swig_getmethods__["precomputed_table"] = _swigfaiss.IndexIVFPQ_precomputed_table_get
|
|
if _newclass:
|
|
precomputed_table = _swig_property(_swigfaiss.IndexIVFPQ_precomputed_table_get, _swigfaiss.IndexIVFPQ_precomputed_table_set)
|
|
|
|
def add_with_ids(self, n, x, xids=None):
|
|
return _swigfaiss.IndexIVFPQ_add_with_ids(self, n, x, xids)
|
|
|
|
def encode_vectors(self, n, x, list_nos, codes):
|
|
return _swigfaiss.IndexIVFPQ_encode_vectors(self, n, x, list_nos, codes)
|
|
|
|
def add_core_o(self, n, x, xids, residuals_2, precomputed_idx=None):
|
|
return _swigfaiss.IndexIVFPQ_add_core_o(self, n, x, xids, residuals_2, precomputed_idx)
|
|
|
|
def train_residual(self, n, x):
|
|
return _swigfaiss.IndexIVFPQ_train_residual(self, n, x)
|
|
|
|
def train_residual_o(self, n, x, residuals_2):
|
|
return _swigfaiss.IndexIVFPQ_train_residual_o(self, n, x, residuals_2)
|
|
|
|
def reconstruct_from_offset(self, list_no, offset, recons):
|
|
return _swigfaiss.IndexIVFPQ_reconstruct_from_offset(self, list_no, offset, recons)
|
|
|
|
def find_duplicates(self, ids, lims):
|
|
return _swigfaiss.IndexIVFPQ_find_duplicates(self, ids, lims)
|
|
|
|
def encode(self, key, x, code):
|
|
return _swigfaiss.IndexIVFPQ_encode(self, key, x, code)
|
|
|
|
def encode_multiple(self, n, keys, x, codes, compute_keys=False):
|
|
return _swigfaiss.IndexIVFPQ_encode_multiple(self, n, keys, x, codes, compute_keys)
|
|
|
|
def decode_multiple(self, n, keys, xcodes, x):
|
|
return _swigfaiss.IndexIVFPQ_decode_multiple(self, n, keys, xcodes, x)
|
|
|
|
def get_InvertedListScanner(self, store_pairs):
|
|
return _swigfaiss.IndexIVFPQ_get_InvertedListScanner(self, store_pairs)
|
|
|
|
def precompute_table(self):
|
|
return _swigfaiss.IndexIVFPQ_precompute_table(self)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexIVFPQ(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIVFPQ
|
|
__del__ = lambda self: None
|
|
IndexIVFPQ_swigregister = _swigfaiss.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__["nrefine"] = _swigfaiss.IndexIVFPQStats_nrefine_set
|
|
__swig_getmethods__["nrefine"] = _swigfaiss.IndexIVFPQStats_nrefine_get
|
|
if _newclass:
|
|
nrefine = _swig_property(_swigfaiss.IndexIVFPQStats_nrefine_get, _swigfaiss.IndexIVFPQStats_nrefine_set)
|
|
__swig_setmethods__["n_hamming_pass"] = _swigfaiss.IndexIVFPQStats_n_hamming_pass_set
|
|
__swig_getmethods__["n_hamming_pass"] = _swigfaiss.IndexIVFPQStats_n_hamming_pass_get
|
|
if _newclass:
|
|
n_hamming_pass = _swig_property(_swigfaiss.IndexIVFPQStats_n_hamming_pass_get, _swigfaiss.IndexIVFPQStats_n_hamming_pass_set)
|
|
__swig_setmethods__["search_cycles"] = _swigfaiss.IndexIVFPQStats_search_cycles_set
|
|
__swig_getmethods__["search_cycles"] = _swigfaiss.IndexIVFPQStats_search_cycles_get
|
|
if _newclass:
|
|
search_cycles = _swig_property(_swigfaiss.IndexIVFPQStats_search_cycles_get, _swigfaiss.IndexIVFPQStats_search_cycles_set)
|
|
__swig_setmethods__["refine_cycles"] = _swigfaiss.IndexIVFPQStats_refine_cycles_set
|
|
__swig_getmethods__["refine_cycles"] = _swigfaiss.IndexIVFPQStats_refine_cycles_get
|
|
if _newclass:
|
|
refine_cycles = _swig_property(_swigfaiss.IndexIVFPQStats_refine_cycles_get, _swigfaiss.IndexIVFPQStats_refine_cycles_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_IndexIVFPQStats()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexIVFPQStats_reset(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIVFPQStats
|
|
__del__ = lambda self: None
|
|
IndexIVFPQStats_swigregister = _swigfaiss.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.IndexIVFPQR_refine_pq_set
|
|
__swig_getmethods__["refine_pq"] = _swigfaiss.IndexIVFPQR_refine_pq_get
|
|
if _newclass:
|
|
refine_pq = _swig_property(_swigfaiss.IndexIVFPQR_refine_pq_get, _swigfaiss.IndexIVFPQR_refine_pq_set)
|
|
__swig_setmethods__["refine_codes"] = _swigfaiss.IndexIVFPQR_refine_codes_set
|
|
__swig_getmethods__["refine_codes"] = _swigfaiss.IndexIVFPQR_refine_codes_get
|
|
if _newclass:
|
|
refine_codes = _swig_property(_swigfaiss.IndexIVFPQR_refine_codes_get, _swigfaiss.IndexIVFPQR_refine_codes_set)
|
|
__swig_setmethods__["k_factor"] = _swigfaiss.IndexIVFPQR_k_factor_set
|
|
__swig_getmethods__["k_factor"] = _swigfaiss.IndexIVFPQR_k_factor_get
|
|
if _newclass:
|
|
k_factor = _swig_property(_swigfaiss.IndexIVFPQR_k_factor_get, _swigfaiss.IndexIVFPQR_k_factor_set)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexIVFPQR_reset(self)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexIVFPQR_remove_ids(self, sel)
|
|
|
|
def train_residual(self, n, x):
|
|
return _swigfaiss.IndexIVFPQR_train_residual(self, n, x)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexIVFPQR_add_with_ids(self, n, x, xids)
|
|
|
|
def add_core(self, n, x, xids, precomputed_idx=None):
|
|
return _swigfaiss.IndexIVFPQR_add_core(self, n, x, xids, precomputed_idx)
|
|
|
|
def reconstruct_from_offset(self, list_no, offset, recons):
|
|
return _swigfaiss.IndexIVFPQR_reconstruct_from_offset(self, list_no, offset, recons)
|
|
|
|
def merge_from(self, other, add_id):
|
|
return _swigfaiss.IndexIVFPQR_merge_from(self, other, add_id)
|
|
|
|
def search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None):
|
|
return _swigfaiss.IndexIVFPQR_search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexIVFPQR(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIVFPQR
|
|
__del__ = lambda self: None
|
|
IndexIVFPQR_swigregister = _swigfaiss.IndexIVFPQR_swigregister
|
|
IndexIVFPQR_swigregister(IndexIVFPQR)
|
|
|
|
class Index2Layer(Index):
|
|
__swig_setmethods__ = {}
|
|
for _s in [Index]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Index2Layer, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [Index]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Index2Layer, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["q1"] = _swigfaiss.Index2Layer_q1_set
|
|
__swig_getmethods__["q1"] = _swigfaiss.Index2Layer_q1_get
|
|
if _newclass:
|
|
q1 = _swig_property(_swigfaiss.Index2Layer_q1_get, _swigfaiss.Index2Layer_q1_set)
|
|
__swig_setmethods__["pq"] = _swigfaiss.Index2Layer_pq_set
|
|
__swig_getmethods__["pq"] = _swigfaiss.Index2Layer_pq_get
|
|
if _newclass:
|
|
pq = _swig_property(_swigfaiss.Index2Layer_pq_get, _swigfaiss.Index2Layer_pq_set)
|
|
__swig_setmethods__["codes"] = _swigfaiss.Index2Layer_codes_set
|
|
__swig_getmethods__["codes"] = _swigfaiss.Index2Layer_codes_get
|
|
if _newclass:
|
|
codes = _swig_property(_swigfaiss.Index2Layer_codes_get, _swigfaiss.Index2Layer_codes_set)
|
|
__swig_setmethods__["code_size_1"] = _swigfaiss.Index2Layer_code_size_1_set
|
|
__swig_getmethods__["code_size_1"] = _swigfaiss.Index2Layer_code_size_1_get
|
|
if _newclass:
|
|
code_size_1 = _swig_property(_swigfaiss.Index2Layer_code_size_1_get, _swigfaiss.Index2Layer_code_size_1_set)
|
|
__swig_setmethods__["code_size_2"] = _swigfaiss.Index2Layer_code_size_2_set
|
|
__swig_getmethods__["code_size_2"] = _swigfaiss.Index2Layer_code_size_2_get
|
|
if _newclass:
|
|
code_size_2 = _swig_property(_swigfaiss.Index2Layer_code_size_2_get, _swigfaiss.Index2Layer_code_size_2_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss.Index2Layer_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss.Index2Layer_code_size_get
|
|
if _newclass:
|
|
code_size = _swig_property(_swigfaiss.Index2Layer_code_size_get, _swigfaiss.Index2Layer_code_size_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_Index2Layer(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_Index2Layer
|
|
__del__ = lambda self: None
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.Index2Layer_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.Index2Layer_add(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.Index2Layer_search(self, n, x, k, distances, labels)
|
|
|
|
def reconstruct_n(self, i0, ni, recons):
|
|
return _swigfaiss.Index2Layer_reconstruct_n(self, i0, ni, recons)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.Index2Layer_reconstruct(self, key, recons)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.Index2Layer_reset(self)
|
|
|
|
def transfer_to_IVFPQ(self, other):
|
|
return _swigfaiss.Index2Layer_transfer_to_IVFPQ(self, other)
|
|
Index2Layer_swigregister = _swigfaiss.Index2Layer_swigregister
|
|
Index2Layer_swigregister(Index2Layer)
|
|
|
|
class IndexBinary(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexBinary, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexBinary, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["d"] = _swigfaiss.IndexBinary_d_set
|
|
__swig_getmethods__["d"] = _swigfaiss.IndexBinary_d_get
|
|
if _newclass:
|
|
d = _swig_property(_swigfaiss.IndexBinary_d_get, _swigfaiss.IndexBinary_d_set)
|
|
__swig_setmethods__["code_size"] = _swigfaiss.IndexBinary_code_size_set
|
|
__swig_getmethods__["code_size"] = _swigfaiss.IndexBinary_code_size_get
|
|
if _newclass:
|
|
code_size = _swig_property(_swigfaiss.IndexBinary_code_size_get, _swigfaiss.IndexBinary_code_size_set)
|
|
__swig_setmethods__["ntotal"] = _swigfaiss.IndexBinary_ntotal_set
|
|
__swig_getmethods__["ntotal"] = _swigfaiss.IndexBinary_ntotal_get
|
|
if _newclass:
|
|
ntotal = _swig_property(_swigfaiss.IndexBinary_ntotal_get, _swigfaiss.IndexBinary_ntotal_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss.IndexBinary_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss.IndexBinary_verbose_get
|
|
if _newclass:
|
|
verbose = _swig_property(_swigfaiss.IndexBinary_verbose_get, _swigfaiss.IndexBinary_verbose_set)
|
|
__swig_setmethods__["is_trained"] = _swigfaiss.IndexBinary_is_trained_set
|
|
__swig_getmethods__["is_trained"] = _swigfaiss.IndexBinary_is_trained_get
|
|
if _newclass:
|
|
is_trained = _swig_property(_swigfaiss.IndexBinary_is_trained_get, _swigfaiss.IndexBinary_is_trained_set)
|
|
__swig_setmethods__["metric_type"] = _swigfaiss.IndexBinary_metric_type_set
|
|
__swig_getmethods__["metric_type"] = _swigfaiss.IndexBinary_metric_type_get
|
|
if _newclass:
|
|
metric_type = _swig_property(_swigfaiss.IndexBinary_metric_type_get, _swigfaiss.IndexBinary_metric_type_set)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexBinary
|
|
__del__ = lambda self: None
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexBinary_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexBinary_add(self, n, x)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexBinary_add_with_ids(self, n, x, xids)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexBinary_search(self, n, x, k, distances, labels)
|
|
|
|
def range_search(self, n, x, radius, result):
|
|
return _swigfaiss.IndexBinary_range_search(self, n, x, radius, result)
|
|
|
|
def assign(self, n, x, labels, k=1):
|
|
return _swigfaiss.IndexBinary_assign(self, n, x, labels, k)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexBinary_reset(self)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexBinary_remove_ids(self, sel)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexBinary_reconstruct(self, key, recons)
|
|
|
|
def reconstruct_n(self, i0, ni, recons):
|
|
return _swigfaiss.IndexBinary_reconstruct_n(self, i0, ni, recons)
|
|
|
|
def search_and_reconstruct(self, n, x, k, distances, labels, recons):
|
|
return _swigfaiss.IndexBinary_search_and_reconstruct(self, n, x, k, distances, labels, recons)
|
|
|
|
def display(self):
|
|
return _swigfaiss.IndexBinary_display(self)
|
|
IndexBinary_swigregister = _swigfaiss.IndexBinary_swigregister
|
|
IndexBinary_swigregister(IndexBinary)
|
|
|
|
class IndexBinaryFlat(IndexBinary):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexBinary]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexBinaryFlat, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexBinary]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexBinaryFlat, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["xb"] = _swigfaiss.IndexBinaryFlat_xb_set
|
|
__swig_getmethods__["xb"] = _swigfaiss.IndexBinaryFlat_xb_get
|
|
if _newclass:
|
|
xb = _swig_property(_swigfaiss.IndexBinaryFlat_xb_get, _swigfaiss.IndexBinaryFlat_xb_set)
|
|
__swig_setmethods__["use_heap"] = _swigfaiss.IndexBinaryFlat_use_heap_set
|
|
__swig_getmethods__["use_heap"] = _swigfaiss.IndexBinaryFlat_use_heap_get
|
|
if _newclass:
|
|
use_heap = _swig_property(_swigfaiss.IndexBinaryFlat_use_heap_get, _swigfaiss.IndexBinaryFlat_use_heap_set)
|
|
__swig_setmethods__["query_batch_size"] = _swigfaiss.IndexBinaryFlat_query_batch_size_set
|
|
__swig_getmethods__["query_batch_size"] = _swigfaiss.IndexBinaryFlat_query_batch_size_get
|
|
if _newclass:
|
|
query_batch_size = _swig_property(_swigfaiss.IndexBinaryFlat_query_batch_size_get, _swigfaiss.IndexBinaryFlat_query_batch_size_set)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexBinaryFlat_add(self, n, x)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexBinaryFlat_reset(self)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexBinaryFlat_search(self, n, x, k, distances, labels)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexBinaryFlat_reconstruct(self, key, recons)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexBinaryFlat_remove_ids(self, sel)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexBinaryFlat(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexBinaryFlat
|
|
__del__ = lambda self: None
|
|
IndexBinaryFlat_swigregister = _swigfaiss.IndexBinaryFlat_swigregister
|
|
IndexBinaryFlat_swigregister(IndexBinaryFlat)
|
|
|
|
class IndexBinaryIVF(IndexBinary):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexBinary]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexBinaryIVF, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexBinary]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexBinaryIVF, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["invlists"] = _swigfaiss.IndexBinaryIVF_invlists_set
|
|
__swig_getmethods__["invlists"] = _swigfaiss.IndexBinaryIVF_invlists_get
|
|
if _newclass:
|
|
invlists = _swig_property(_swigfaiss.IndexBinaryIVF_invlists_get, _swigfaiss.IndexBinaryIVF_invlists_set)
|
|
__swig_setmethods__["own_invlists"] = _swigfaiss.IndexBinaryIVF_own_invlists_set
|
|
__swig_getmethods__["own_invlists"] = _swigfaiss.IndexBinaryIVF_own_invlists_get
|
|
if _newclass:
|
|
own_invlists = _swig_property(_swigfaiss.IndexBinaryIVF_own_invlists_get, _swigfaiss.IndexBinaryIVF_own_invlists_set)
|
|
__swig_setmethods__["nprobe"] = _swigfaiss.IndexBinaryIVF_nprobe_set
|
|
__swig_getmethods__["nprobe"] = _swigfaiss.IndexBinaryIVF_nprobe_get
|
|
if _newclass:
|
|
nprobe = _swig_property(_swigfaiss.IndexBinaryIVF_nprobe_get, _swigfaiss.IndexBinaryIVF_nprobe_set)
|
|
__swig_setmethods__["max_codes"] = _swigfaiss.IndexBinaryIVF_max_codes_set
|
|
__swig_getmethods__["max_codes"] = _swigfaiss.IndexBinaryIVF_max_codes_get
|
|
if _newclass:
|
|
max_codes = _swig_property(_swigfaiss.IndexBinaryIVF_max_codes_get, _swigfaiss.IndexBinaryIVF_max_codes_set)
|
|
__swig_setmethods__["use_heap"] = _swigfaiss.IndexBinaryIVF_use_heap_set
|
|
__swig_getmethods__["use_heap"] = _swigfaiss.IndexBinaryIVF_use_heap_get
|
|
if _newclass:
|
|
use_heap = _swig_property(_swigfaiss.IndexBinaryIVF_use_heap_get, _swigfaiss.IndexBinaryIVF_use_heap_set)
|
|
__swig_setmethods__["maintain_direct_map"] = _swigfaiss.IndexBinaryIVF_maintain_direct_map_set
|
|
__swig_getmethods__["maintain_direct_map"] = _swigfaiss.IndexBinaryIVF_maintain_direct_map_get
|
|
if _newclass:
|
|
maintain_direct_map = _swig_property(_swigfaiss.IndexBinaryIVF_maintain_direct_map_get, _swigfaiss.IndexBinaryIVF_maintain_direct_map_set)
|
|
__swig_setmethods__["direct_map"] = _swigfaiss.IndexBinaryIVF_direct_map_set
|
|
__swig_getmethods__["direct_map"] = _swigfaiss.IndexBinaryIVF_direct_map_get
|
|
if _newclass:
|
|
direct_map = _swig_property(_swigfaiss.IndexBinaryIVF_direct_map_get, _swigfaiss.IndexBinaryIVF_direct_map_set)
|
|
__swig_setmethods__["quantizer"] = _swigfaiss.IndexBinaryIVF_quantizer_set
|
|
__swig_getmethods__["quantizer"] = _swigfaiss.IndexBinaryIVF_quantizer_get
|
|
if _newclass:
|
|
quantizer = _swig_property(_swigfaiss.IndexBinaryIVF_quantizer_get, _swigfaiss.IndexBinaryIVF_quantizer_set)
|
|
__swig_setmethods__["nlist"] = _swigfaiss.IndexBinaryIVF_nlist_set
|
|
__swig_getmethods__["nlist"] = _swigfaiss.IndexBinaryIVF_nlist_get
|
|
if _newclass:
|
|
nlist = _swig_property(_swigfaiss.IndexBinaryIVF_nlist_get, _swigfaiss.IndexBinaryIVF_nlist_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.IndexBinaryIVF_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.IndexBinaryIVF_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.IndexBinaryIVF_own_fields_get, _swigfaiss.IndexBinaryIVF_own_fields_set)
|
|
__swig_setmethods__["cp"] = _swigfaiss.IndexBinaryIVF_cp_set
|
|
__swig_getmethods__["cp"] = _swigfaiss.IndexBinaryIVF_cp_get
|
|
if _newclass:
|
|
cp = _swig_property(_swigfaiss.IndexBinaryIVF_cp_get, _swigfaiss.IndexBinaryIVF_cp_set)
|
|
__swig_setmethods__["clustering_index"] = _swigfaiss.IndexBinaryIVF_clustering_index_set
|
|
__swig_getmethods__["clustering_index"] = _swigfaiss.IndexBinaryIVF_clustering_index_get
|
|
if _newclass:
|
|
clustering_index = _swig_property(_swigfaiss.IndexBinaryIVF_clustering_index_get, _swigfaiss.IndexBinaryIVF_clustering_index_set)
|
|
|
|
def train_q1(self, n, x, verbose):
|
|
return _swigfaiss.IndexBinaryIVF_train_q1(self, n, x, verbose)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexBinaryIVF(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexBinaryIVF
|
|
__del__ = lambda self: None
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexBinaryIVF_reset(self)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexBinaryIVF_train(self, n, x)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexBinaryIVF_add(self, n, x)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexBinaryIVF_add_with_ids(self, n, x, xids)
|
|
|
|
def add_core(self, n, x, xids, precomputed_idx):
|
|
return _swigfaiss.IndexBinaryIVF_add_core(self, n, x, xids, precomputed_idx)
|
|
|
|
def search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params=None):
|
|
return _swigfaiss.IndexBinaryIVF_search_preassigned(self, n, x, k, assign, centroid_dis, distances, labels, store_pairs, params)
|
|
|
|
def get_InvertedListScanner(self, store_pairs=False):
|
|
return _swigfaiss.IndexBinaryIVF_get_InvertedListScanner(self, store_pairs)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexBinaryIVF_search(self, n, x, k, distances, labels)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexBinaryIVF_reconstruct(self, key, recons)
|
|
|
|
def reconstruct_n(self, i0, ni, recons):
|
|
return _swigfaiss.IndexBinaryIVF_reconstruct_n(self, i0, ni, recons)
|
|
|
|
def search_and_reconstruct(self, n, x, k, distances, labels, recons):
|
|
return _swigfaiss.IndexBinaryIVF_search_and_reconstruct(self, n, x, k, distances, labels, recons)
|
|
|
|
def reconstruct_from_offset(self, list_no, offset, recons):
|
|
return _swigfaiss.IndexBinaryIVF_reconstruct_from_offset(self, list_no, offset, recons)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexBinaryIVF_remove_ids(self, sel)
|
|
|
|
def merge_from(self, other, add_id):
|
|
return _swigfaiss.IndexBinaryIVF_merge_from(self, other, add_id)
|
|
|
|
def get_list_size(self, list_no):
|
|
return _swigfaiss.IndexBinaryIVF_get_list_size(self, list_no)
|
|
|
|
def make_direct_map(self, new_maintain_direct_map=True):
|
|
return _swigfaiss.IndexBinaryIVF_make_direct_map(self, new_maintain_direct_map)
|
|
|
|
def imbalance_factor(self):
|
|
return _swigfaiss.IndexBinaryIVF_imbalance_factor(self)
|
|
|
|
def print_stats(self):
|
|
return _swigfaiss.IndexBinaryIVF_print_stats(self)
|
|
|
|
def replace_invlists(self, il, own=False):
|
|
return _swigfaiss.IndexBinaryIVF_replace_invlists(self, il, own)
|
|
IndexBinaryIVF_swigregister = _swigfaiss.IndexBinaryIVF_swigregister
|
|
IndexBinaryIVF_swigregister(IndexBinaryIVF)
|
|
|
|
class IndexBinaryFromFloat(IndexBinary):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexBinary]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexBinaryFromFloat, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexBinary]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexBinaryFromFloat, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["index"] = _swigfaiss.IndexBinaryFromFloat_index_set
|
|
__swig_getmethods__["index"] = _swigfaiss.IndexBinaryFromFloat_index_get
|
|
if _newclass:
|
|
index = _swig_property(_swigfaiss.IndexBinaryFromFloat_index_get, _swigfaiss.IndexBinaryFromFloat_index_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.IndexBinaryFromFloat_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.IndexBinaryFromFloat_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.IndexBinaryFromFloat_own_fields_get, _swigfaiss.IndexBinaryFromFloat_own_fields_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexBinaryFromFloat(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexBinaryFromFloat
|
|
__del__ = lambda self: None
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexBinaryFromFloat_add(self, n, x)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexBinaryFromFloat_reset(self)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexBinaryFromFloat_search(self, n, x, k, distances, labels)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexBinaryFromFloat_train(self, n, x)
|
|
IndexBinaryFromFloat_swigregister = _swigfaiss.IndexBinaryFromFloat_swigregister
|
|
IndexBinaryFromFloat_swigregister(IndexBinaryFromFloat)
|
|
|
|
class IndexBinaryHNSW(IndexBinary):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IndexBinary]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IndexBinaryHNSW, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IndexBinary]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IndexBinaryHNSW, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["hnsw"] = _swigfaiss.IndexBinaryHNSW_hnsw_set
|
|
__swig_getmethods__["hnsw"] = _swigfaiss.IndexBinaryHNSW_hnsw_get
|
|
if _newclass:
|
|
hnsw = _swig_property(_swigfaiss.IndexBinaryHNSW_hnsw_get, _swigfaiss.IndexBinaryHNSW_hnsw_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.IndexBinaryHNSW_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.IndexBinaryHNSW_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.IndexBinaryHNSW_own_fields_get, _swigfaiss.IndexBinaryHNSW_own_fields_set)
|
|
__swig_setmethods__["storage"] = _swigfaiss.IndexBinaryHNSW_storage_set
|
|
__swig_getmethods__["storage"] = _swigfaiss.IndexBinaryHNSW_storage_get
|
|
if _newclass:
|
|
storage = _swig_property(_swigfaiss.IndexBinaryHNSW_storage_get, _swigfaiss.IndexBinaryHNSW_storage_set)
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexBinaryHNSW(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_IndexBinaryHNSW
|
|
__del__ = lambda self: None
|
|
|
|
def get_distance_computer(self):
|
|
return _swigfaiss.IndexBinaryHNSW_get_distance_computer(self)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexBinaryHNSW_add(self, n, x)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexBinaryHNSW_train(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexBinaryHNSW_search(self, n, x, k, distances, labels)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexBinaryHNSW_reconstruct(self, key, recons)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexBinaryHNSW_reset(self)
|
|
IndexBinaryHNSW_swigregister = _swigfaiss.IndexBinaryHNSW_swigregister
|
|
IndexBinaryHNSW_swigregister(IndexBinaryHNSW)
|
|
|
|
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.IndexIDMap_index_set
|
|
__swig_getmethods__["index"] = _swigfaiss.IndexIDMap_index_get
|
|
if _newclass:
|
|
index = _swig_property(_swigfaiss.IndexIDMap_index_get, _swigfaiss.IndexIDMap_index_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.IndexIDMap_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.IndexIDMap_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.IndexIDMap_own_fields_get, _swigfaiss.IndexIDMap_own_fields_set)
|
|
__swig_setmethods__["id_map"] = _swigfaiss.IndexIDMap_id_map_set
|
|
__swig_getmethods__["id_map"] = _swigfaiss.IndexIDMap_id_map_get
|
|
if _newclass:
|
|
id_map = _swig_property(_swigfaiss.IndexIDMap_id_map_get, _swigfaiss.IndexIDMap_id_map_set)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexIDMap_add_with_ids(self, n, x, xids)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexIDMap_add(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexIDMap_search(self, n, x, k, distances, labels)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexIDMap_train(self, n, x)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexIDMap_reset(self)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexIDMap_remove_ids(self, sel)
|
|
|
|
def range_search(self, n, x, radius, result):
|
|
return _swigfaiss.IndexIDMap_range_search(self, n, x, radius, result)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIDMap
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexIDMap(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
IndexIDMap_swigregister = _swigfaiss.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.IndexIDMap2_rev_map_set
|
|
__swig_getmethods__["rev_map"] = _swigfaiss.IndexIDMap2_rev_map_get
|
|
if _newclass:
|
|
rev_map = _swig_property(_swigfaiss.IndexIDMap2_rev_map_get, _swigfaiss.IndexIDMap2_rev_map_set)
|
|
|
|
def construct_rev_map(self):
|
|
return _swigfaiss.IndexIDMap2_construct_rev_map(self)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexIDMap2_add_with_ids(self, n, x, xids)
|
|
|
|
def remove_ids(self, sel):
|
|
return _swigfaiss.IndexIDMap2_remove_ids(self, sel)
|
|
|
|
def reconstruct(self, key, recons):
|
|
return _swigfaiss.IndexIDMap2_reconstruct(self, key, recons)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexIDMap2
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self, *args):
|
|
this = _swigfaiss.new_IndexIDMap2(*args)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
IndexIDMap2_swigregister = _swigfaiss.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.IndexShards_shard_indexes_set
|
|
__swig_getmethods__["shard_indexes"] = _swigfaiss.IndexShards_shard_indexes_get
|
|
if _newclass:
|
|
shard_indexes = _swig_property(_swigfaiss.IndexShards_shard_indexes_get, _swigfaiss.IndexShards_shard_indexes_set)
|
|
__swig_setmethods__["own_fields"] = _swigfaiss.IndexShards_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.IndexShards_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.IndexShards_own_fields_get, _swigfaiss.IndexShards_own_fields_set)
|
|
__swig_setmethods__["threaded"] = _swigfaiss.IndexShards_threaded_set
|
|
__swig_getmethods__["threaded"] = _swigfaiss.IndexShards_threaded_get
|
|
if _newclass:
|
|
threaded = _swig_property(_swigfaiss.IndexShards_threaded_get, _swigfaiss.IndexShards_threaded_set)
|
|
__swig_setmethods__["successive_ids"] = _swigfaiss.IndexShards_successive_ids_set
|
|
__swig_getmethods__["successive_ids"] = _swigfaiss.IndexShards_successive_ids_get
|
|
if _newclass:
|
|
successive_ids = _swig_property(_swigfaiss.IndexShards_successive_ids_get, _swigfaiss.IndexShards_successive_ids_set)
|
|
|
|
def __init__(self, d, threaded=False, successive_ids=True):
|
|
this = _swigfaiss.new_IndexShards(d, threaded, successive_ids)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def add_shard(self, arg2):
|
|
return _swigfaiss.IndexShards_add_shard(self, arg2)
|
|
|
|
def sync_with_shard_indexes(self):
|
|
return _swigfaiss.IndexShards_sync_with_shard_indexes(self)
|
|
|
|
def at(self, i):
|
|
return _swigfaiss.IndexShards_at(self, i)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexShards_add(self, n, x)
|
|
|
|
def add_with_ids(self, n, x, xids):
|
|
return _swigfaiss.IndexShards_add_with_ids(self, n, x, xids)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexShards_search(self, n, x, k, distances, labels)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexShards_train(self, n, x)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexShards_reset(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexShards
|
|
__del__ = lambda self: None
|
|
IndexShards_swigregister = _swigfaiss.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.IndexSplitVectors_own_fields_set
|
|
__swig_getmethods__["own_fields"] = _swigfaiss.IndexSplitVectors_own_fields_get
|
|
if _newclass:
|
|
own_fields = _swig_property(_swigfaiss.IndexSplitVectors_own_fields_get, _swigfaiss.IndexSplitVectors_own_fields_set)
|
|
__swig_setmethods__["threaded"] = _swigfaiss.IndexSplitVectors_threaded_set
|
|
__swig_getmethods__["threaded"] = _swigfaiss.IndexSplitVectors_threaded_get
|
|
if _newclass:
|
|
threaded = _swig_property(_swigfaiss.IndexSplitVectors_threaded_get, _swigfaiss.IndexSplitVectors_threaded_set)
|
|
__swig_setmethods__["sub_indexes"] = _swigfaiss.IndexSplitVectors_sub_indexes_set
|
|
__swig_getmethods__["sub_indexes"] = _swigfaiss.IndexSplitVectors_sub_indexes_get
|
|
if _newclass:
|
|
sub_indexes = _swig_property(_swigfaiss.IndexSplitVectors_sub_indexes_get, _swigfaiss.IndexSplitVectors_sub_indexes_set)
|
|
__swig_setmethods__["sum_d"] = _swigfaiss.IndexSplitVectors_sum_d_set
|
|
__swig_getmethods__["sum_d"] = _swigfaiss.IndexSplitVectors_sum_d_get
|
|
if _newclass:
|
|
sum_d = _swig_property(_swigfaiss.IndexSplitVectors_sum_d_get, _swigfaiss.IndexSplitVectors_sum_d_set)
|
|
|
|
def __init__(self, d, threaded=False):
|
|
this = _swigfaiss.new_IndexSplitVectors(d, threaded)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def add_sub_index(self, arg2):
|
|
return _swigfaiss.IndexSplitVectors_add_sub_index(self, arg2)
|
|
|
|
def sync_with_sub_indexes(self):
|
|
return _swigfaiss.IndexSplitVectors_sync_with_sub_indexes(self)
|
|
|
|
def add(self, n, x):
|
|
return _swigfaiss.IndexSplitVectors_add(self, n, x)
|
|
|
|
def search(self, n, x, k, distances, labels):
|
|
return _swigfaiss.IndexSplitVectors_search(self, n, x, k, distances, labels)
|
|
|
|
def train(self, n, x):
|
|
return _swigfaiss.IndexSplitVectors_train(self, n, x)
|
|
|
|
def reset(self):
|
|
return _swigfaiss.IndexSplitVectors_reset(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IndexSplitVectors
|
|
__del__ = lambda self: None
|
|
IndexSplitVectors_swigregister = _swigfaiss.IndexSplitVectors_swigregister
|
|
IndexSplitVectors_swigregister(IndexSplitVectors)
|
|
|
|
|
|
def downcast_index(index):
|
|
return _swigfaiss.downcast_index(index)
|
|
downcast_index = _swigfaiss.downcast_index
|
|
|
|
def downcast_VectorTransform(vt):
|
|
return _swigfaiss.downcast_VectorTransform(vt)
|
|
downcast_VectorTransform = _swigfaiss.downcast_VectorTransform
|
|
|
|
def downcast_IndexBinary(index):
|
|
return _swigfaiss.downcast_IndexBinary(index)
|
|
downcast_IndexBinary = _swigfaiss.downcast_IndexBinary
|
|
|
|
def write_index(*args):
|
|
return _swigfaiss.write_index(*args)
|
|
write_index = _swigfaiss.write_index
|
|
|
|
def write_index_binary(*args):
|
|
return _swigfaiss.write_index_binary(*args)
|
|
write_index_binary = _swigfaiss.write_index_binary
|
|
|
|
def read_index(*args):
|
|
return _swigfaiss.read_index(*args)
|
|
read_index = _swigfaiss.read_index
|
|
|
|
def read_index_binary(*args):
|
|
return _swigfaiss.read_index_binary(*args)
|
|
read_index_binary = _swigfaiss.read_index_binary
|
|
|
|
def write_VectorTransform(vt, fname):
|
|
return _swigfaiss.write_VectorTransform(vt, fname)
|
|
write_VectorTransform = _swigfaiss.write_VectorTransform
|
|
|
|
def read_VectorTransform(fname):
|
|
return _swigfaiss.read_VectorTransform(fname)
|
|
read_VectorTransform = _swigfaiss.read_VectorTransform
|
|
|
|
def read_ProductQuantizer(*args):
|
|
return _swigfaiss.read_ProductQuantizer(*args)
|
|
read_ProductQuantizer = _swigfaiss.read_ProductQuantizer
|
|
|
|
def write_ProductQuantizer(*args):
|
|
return _swigfaiss.write_ProductQuantizer(*args)
|
|
write_ProductQuantizer = _swigfaiss.write_ProductQuantizer
|
|
|
|
def write_InvertedLists(ils, f):
|
|
return _swigfaiss.write_InvertedLists(ils, f)
|
|
write_InvertedLists = _swigfaiss.write_InvertedLists
|
|
|
|
def read_InvertedLists(reader, io_flags=0):
|
|
return _swigfaiss.read_InvertedLists(reader, io_flags)
|
|
read_InvertedLists = _swigfaiss.read_InvertedLists
|
|
|
|
def clone_index(arg1):
|
|
return _swigfaiss.clone_index(arg1)
|
|
clone_index = _swigfaiss.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, arg2):
|
|
return _swigfaiss.Cloner_clone_VectorTransform(self, arg2)
|
|
|
|
def clone_Index(self, arg2):
|
|
return _swigfaiss.Cloner_clone_Index(self, arg2)
|
|
|
|
def clone_IndexIVF(self, arg2):
|
|
return _swigfaiss.Cloner_clone_IndexIVF(self, arg2)
|
|
__swig_destroy__ = _swigfaiss.delete_Cloner
|
|
__del__ = lambda self: None
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_Cloner()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
Cloner_swigregister = _swigfaiss.Cloner_swigregister
|
|
Cloner_swigregister(Cloner)
|
|
IO_FLAG_MMAP = cvar.IO_FLAG_MMAP
|
|
IO_FLAG_READ_ONLY = cvar.IO_FLAG_READ_ONLY
|
|
|
|
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.AutoTuneCriterion_nq_set
|
|
__swig_getmethods__["nq"] = _swigfaiss.AutoTuneCriterion_nq_get
|
|
if _newclass:
|
|
nq = _swig_property(_swigfaiss.AutoTuneCriterion_nq_get, _swigfaiss.AutoTuneCriterion_nq_set)
|
|
__swig_setmethods__["nnn"] = _swigfaiss.AutoTuneCriterion_nnn_set
|
|
__swig_getmethods__["nnn"] = _swigfaiss.AutoTuneCriterion_nnn_get
|
|
if _newclass:
|
|
nnn = _swig_property(_swigfaiss.AutoTuneCriterion_nnn_get, _swigfaiss.AutoTuneCriterion_nnn_set)
|
|
__swig_setmethods__["gt_nnn"] = _swigfaiss.AutoTuneCriterion_gt_nnn_set
|
|
__swig_getmethods__["gt_nnn"] = _swigfaiss.AutoTuneCriterion_gt_nnn_get
|
|
if _newclass:
|
|
gt_nnn = _swig_property(_swigfaiss.AutoTuneCriterion_gt_nnn_get, _swigfaiss.AutoTuneCriterion_gt_nnn_set)
|
|
__swig_setmethods__["gt_D"] = _swigfaiss.AutoTuneCriterion_gt_D_set
|
|
__swig_getmethods__["gt_D"] = _swigfaiss.AutoTuneCriterion_gt_D_get
|
|
if _newclass:
|
|
gt_D = _swig_property(_swigfaiss.AutoTuneCriterion_gt_D_get, _swigfaiss.AutoTuneCriterion_gt_D_set)
|
|
__swig_setmethods__["gt_I"] = _swigfaiss.AutoTuneCriterion_gt_I_set
|
|
__swig_getmethods__["gt_I"] = _swigfaiss.AutoTuneCriterion_gt_I_get
|
|
if _newclass:
|
|
gt_I = _swig_property(_swigfaiss.AutoTuneCriterion_gt_I_get, _swigfaiss.AutoTuneCriterion_gt_I_set)
|
|
|
|
def set_groundtruth(self, gt_nnn, gt_D_in, gt_I_in):
|
|
return _swigfaiss.AutoTuneCriterion_set_groundtruth(self, gt_nnn, gt_D_in, gt_I_in)
|
|
|
|
def evaluate(self, D, I):
|
|
return _swigfaiss.AutoTuneCriterion_evaluate(self, D, I)
|
|
__swig_destroy__ = _swigfaiss.delete_AutoTuneCriterion
|
|
__del__ = lambda self: None
|
|
AutoTuneCriterion_swigregister = _swigfaiss.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.OneRecallAtRCriterion_R_set
|
|
__swig_getmethods__["R"] = _swigfaiss.OneRecallAtRCriterion_R_get
|
|
if _newclass:
|
|
R = _swig_property(_swigfaiss.OneRecallAtRCriterion_R_get, _swigfaiss.OneRecallAtRCriterion_R_set)
|
|
|
|
def __init__(self, nq, R):
|
|
this = _swigfaiss.new_OneRecallAtRCriterion(nq, R)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def evaluate(self, D, I):
|
|
return _swigfaiss.OneRecallAtRCriterion_evaluate(self, D, I)
|
|
__swig_destroy__ = _swigfaiss.delete_OneRecallAtRCriterion
|
|
__del__ = lambda self: None
|
|
OneRecallAtRCriterion_swigregister = _swigfaiss.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.IntersectionCriterion_R_set
|
|
__swig_getmethods__["R"] = _swigfaiss.IntersectionCriterion_R_get
|
|
if _newclass:
|
|
R = _swig_property(_swigfaiss.IntersectionCriterion_R_get, _swigfaiss.IntersectionCriterion_R_set)
|
|
|
|
def __init__(self, nq, R):
|
|
this = _swigfaiss.new_IntersectionCriterion(nq, R)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def evaluate(self, D, I):
|
|
return _swigfaiss.IntersectionCriterion_evaluate(self, D, I)
|
|
__swig_destroy__ = _swigfaiss.delete_IntersectionCriterion
|
|
__del__ = lambda self: None
|
|
IntersectionCriterion_swigregister = _swigfaiss.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.OperatingPoint_perf_set
|
|
__swig_getmethods__["perf"] = _swigfaiss.OperatingPoint_perf_get
|
|
if _newclass:
|
|
perf = _swig_property(_swigfaiss.OperatingPoint_perf_get, _swigfaiss.OperatingPoint_perf_set)
|
|
__swig_setmethods__["t"] = _swigfaiss.OperatingPoint_t_set
|
|
__swig_getmethods__["t"] = _swigfaiss.OperatingPoint_t_get
|
|
if _newclass:
|
|
t = _swig_property(_swigfaiss.OperatingPoint_t_get, _swigfaiss.OperatingPoint_t_set)
|
|
__swig_setmethods__["key"] = _swigfaiss.OperatingPoint_key_set
|
|
__swig_getmethods__["key"] = _swigfaiss.OperatingPoint_key_get
|
|
if _newclass:
|
|
key = _swig_property(_swigfaiss.OperatingPoint_key_get, _swigfaiss.OperatingPoint_key_set)
|
|
__swig_setmethods__["cno"] = _swigfaiss.OperatingPoint_cno_set
|
|
__swig_getmethods__["cno"] = _swigfaiss.OperatingPoint_cno_get
|
|
if _newclass:
|
|
cno = _swig_property(_swigfaiss.OperatingPoint_cno_get, _swigfaiss.OperatingPoint_cno_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_OperatingPoint()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_OperatingPoint
|
|
__del__ = lambda self: None
|
|
OperatingPoint_swigregister = _swigfaiss.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.OperatingPoints_all_pts_set
|
|
__swig_getmethods__["all_pts"] = _swigfaiss.OperatingPoints_all_pts_get
|
|
if _newclass:
|
|
all_pts = _swig_property(_swigfaiss.OperatingPoints_all_pts_get, _swigfaiss.OperatingPoints_all_pts_set)
|
|
__swig_setmethods__["optimal_pts"] = _swigfaiss.OperatingPoints_optimal_pts_set
|
|
__swig_getmethods__["optimal_pts"] = _swigfaiss.OperatingPoints_optimal_pts_get
|
|
if _newclass:
|
|
optimal_pts = _swig_property(_swigfaiss.OperatingPoints_optimal_pts_get, _swigfaiss.OperatingPoints_optimal_pts_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_OperatingPoints()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def merge_with(self, *args):
|
|
return _swigfaiss.OperatingPoints_merge_with(self, *args)
|
|
|
|
def clear(self):
|
|
return _swigfaiss.OperatingPoints_clear(self)
|
|
|
|
def add(self, perf, t, key, cno=0):
|
|
return _swigfaiss.OperatingPoints_add(self, perf, t, key, cno)
|
|
|
|
def t_for_perf(self, perf):
|
|
return _swigfaiss.OperatingPoints_t_for_perf(self, perf)
|
|
|
|
def display(self, only_optimal=True):
|
|
return _swigfaiss.OperatingPoints_display(self, only_optimal)
|
|
|
|
def all_to_gnuplot(self, fname):
|
|
return _swigfaiss.OperatingPoints_all_to_gnuplot(self, fname)
|
|
|
|
def optimal_to_gnuplot(self, fname):
|
|
return _swigfaiss.OperatingPoints_optimal_to_gnuplot(self, fname)
|
|
__swig_destroy__ = _swigfaiss.delete_OperatingPoints
|
|
__del__ = lambda self: None
|
|
OperatingPoints_swigregister = _swigfaiss.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.ParameterRange_name_set
|
|
__swig_getmethods__["name"] = _swigfaiss.ParameterRange_name_get
|
|
if _newclass:
|
|
name = _swig_property(_swigfaiss.ParameterRange_name_get, _swigfaiss.ParameterRange_name_set)
|
|
__swig_setmethods__["values"] = _swigfaiss.ParameterRange_values_set
|
|
__swig_getmethods__["values"] = _swigfaiss.ParameterRange_values_get
|
|
if _newclass:
|
|
values = _swig_property(_swigfaiss.ParameterRange_values_get, _swigfaiss.ParameterRange_values_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_ParameterRange()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_ParameterRange
|
|
__del__ = lambda self: None
|
|
ParameterRange_swigregister = _swigfaiss.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.ParameterSpace_parameter_ranges_set
|
|
__swig_getmethods__["parameter_ranges"] = _swigfaiss.ParameterSpace_parameter_ranges_get
|
|
if _newclass:
|
|
parameter_ranges = _swig_property(_swigfaiss.ParameterSpace_parameter_ranges_get, _swigfaiss.ParameterSpace_parameter_ranges_set)
|
|
__swig_setmethods__["verbose"] = _swigfaiss.ParameterSpace_verbose_set
|
|
__swig_getmethods__["verbose"] = _swigfaiss.ParameterSpace_verbose_get
|
|
if _newclass:
|
|
verbose = _swig_property(_swigfaiss.ParameterSpace_verbose_get, _swigfaiss.ParameterSpace_verbose_set)
|
|
__swig_setmethods__["n_experiments"] = _swigfaiss.ParameterSpace_n_experiments_set
|
|
__swig_getmethods__["n_experiments"] = _swigfaiss.ParameterSpace_n_experiments_get
|
|
if _newclass:
|
|
n_experiments = _swig_property(_swigfaiss.ParameterSpace_n_experiments_get, _swigfaiss.ParameterSpace_n_experiments_set)
|
|
__swig_setmethods__["batchsize"] = _swigfaiss.ParameterSpace_batchsize_set
|
|
__swig_getmethods__["batchsize"] = _swigfaiss.ParameterSpace_batchsize_get
|
|
if _newclass:
|
|
batchsize = _swig_property(_swigfaiss.ParameterSpace_batchsize_get, _swigfaiss.ParameterSpace_batchsize_set)
|
|
__swig_setmethods__["thread_over_batches"] = _swigfaiss.ParameterSpace_thread_over_batches_set
|
|
__swig_getmethods__["thread_over_batches"] = _swigfaiss.ParameterSpace_thread_over_batches_get
|
|
if _newclass:
|
|
thread_over_batches = _swig_property(_swigfaiss.ParameterSpace_thread_over_batches_get, _swigfaiss.ParameterSpace_thread_over_batches_set)
|
|
__swig_setmethods__["min_test_duration"] = _swigfaiss.ParameterSpace_min_test_duration_set
|
|
__swig_getmethods__["min_test_duration"] = _swigfaiss.ParameterSpace_min_test_duration_get
|
|
if _newclass:
|
|
min_test_duration = _swig_property(_swigfaiss.ParameterSpace_min_test_duration_get, _swigfaiss.ParameterSpace_min_test_duration_set)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_ParameterSpace()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def n_combinations(self):
|
|
return _swigfaiss.ParameterSpace_n_combinations(self)
|
|
|
|
def combination_ge(self, c1, c2):
|
|
return _swigfaiss.ParameterSpace_combination_ge(self, c1, c2)
|
|
|
|
def combination_name(self, cno):
|
|
return _swigfaiss.ParameterSpace_combination_name(self, cno)
|
|
|
|
def display(self):
|
|
return _swigfaiss.ParameterSpace_display(self)
|
|
|
|
def add_range(self, name):
|
|
return _swigfaiss.ParameterSpace_add_range(self, name)
|
|
|
|
def initialize(self, index):
|
|
return _swigfaiss.ParameterSpace_initialize(self, index)
|
|
|
|
def set_index_parameters(self, *args):
|
|
return _swigfaiss.ParameterSpace_set_index_parameters(self, *args)
|
|
|
|
def set_index_parameter(self, index, name, val):
|
|
return _swigfaiss.ParameterSpace_set_index_parameter(self, index, name, val)
|
|
|
|
def update_bounds(self, cno, op, upper_bound_perf, lower_bound_t):
|
|
return _swigfaiss.ParameterSpace_update_bounds(self, cno, op, upper_bound_perf, lower_bound_t)
|
|
|
|
def explore(self, index, nq, xq, crit, ops):
|
|
return _swigfaiss.ParameterSpace_explore(self, index, nq, xq, crit, ops)
|
|
__swig_destroy__ = _swigfaiss.delete_ParameterSpace
|
|
__del__ = lambda self: None
|
|
ParameterSpace_swigregister = _swigfaiss.ParameterSpace_swigregister
|
|
ParameterSpace_swigregister(ParameterSpace)
|
|
|
|
|
|
def index_factory(*args):
|
|
return _swigfaiss.index_factory(*args)
|
|
index_factory = _swigfaiss.index_factory
|
|
|
|
def index_binary_factory(d, description):
|
|
return _swigfaiss.index_binary_factory(d, description)
|
|
index_binary_factory = _swigfaiss.index_binary_factory
|
|
|
|
def swig_ptr(a):
|
|
return _swigfaiss.swig_ptr(a)
|
|
swig_ptr = _swigfaiss.swig_ptr
|
|
|
|
def rev_swig_ptr(*args):
|
|
return _swigfaiss.rev_swig_ptr(*args)
|
|
rev_swig_ptr = _swigfaiss.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.float_minheap_array_t_nh_set
|
|
__swig_getmethods__["nh"] = _swigfaiss.float_minheap_array_t_nh_get
|
|
if _newclass:
|
|
nh = _swig_property(_swigfaiss.float_minheap_array_t_nh_get, _swigfaiss.float_minheap_array_t_nh_set)
|
|
__swig_setmethods__["k"] = _swigfaiss.float_minheap_array_t_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss.float_minheap_array_t_k_get
|
|
if _newclass:
|
|
k = _swig_property(_swigfaiss.float_minheap_array_t_k_get, _swigfaiss.float_minheap_array_t_k_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss.float_minheap_array_t_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss.float_minheap_array_t_ids_get
|
|
if _newclass:
|
|
ids = _swig_property(_swigfaiss.float_minheap_array_t_ids_get, _swigfaiss.float_minheap_array_t_ids_set)
|
|
__swig_setmethods__["val"] = _swigfaiss.float_minheap_array_t_val_set
|
|
__swig_getmethods__["val"] = _swigfaiss.float_minheap_array_t_val_get
|
|
if _newclass:
|
|
val = _swig_property(_swigfaiss.float_minheap_array_t_val_get, _swigfaiss.float_minheap_array_t_val_set)
|
|
|
|
def get_val(self, key):
|
|
return _swigfaiss.float_minheap_array_t_get_val(self, key)
|
|
|
|
def get_ids(self, key):
|
|
return _swigfaiss.float_minheap_array_t_get_ids(self, key)
|
|
|
|
def heapify(self):
|
|
return _swigfaiss.float_minheap_array_t_heapify(self)
|
|
|
|
def addn(self, nj, vin, j0=0, i0=0, ni=-1):
|
|
return _swigfaiss.float_minheap_array_t_addn(self, nj, vin, j0, i0, ni)
|
|
|
|
def addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1):
|
|
return _swigfaiss.float_minheap_array_t_addn_with_ids(self, nj, vin, id_in, id_stride, i0, ni)
|
|
|
|
def reorder(self):
|
|
return _swigfaiss.float_minheap_array_t_reorder(self)
|
|
|
|
def per_line_extrema(self, vals_out, idx_out):
|
|
return _swigfaiss.float_minheap_array_t_per_line_extrema(self, vals_out, idx_out)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_float_minheap_array_t()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_float_minheap_array_t
|
|
__del__ = lambda self: None
|
|
float_minheap_array_t_swigregister = _swigfaiss.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.int_minheap_array_t_nh_set
|
|
__swig_getmethods__["nh"] = _swigfaiss.int_minheap_array_t_nh_get
|
|
if _newclass:
|
|
nh = _swig_property(_swigfaiss.int_minheap_array_t_nh_get, _swigfaiss.int_minheap_array_t_nh_set)
|
|
__swig_setmethods__["k"] = _swigfaiss.int_minheap_array_t_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss.int_minheap_array_t_k_get
|
|
if _newclass:
|
|
k = _swig_property(_swigfaiss.int_minheap_array_t_k_get, _swigfaiss.int_minheap_array_t_k_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss.int_minheap_array_t_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss.int_minheap_array_t_ids_get
|
|
if _newclass:
|
|
ids = _swig_property(_swigfaiss.int_minheap_array_t_ids_get, _swigfaiss.int_minheap_array_t_ids_set)
|
|
__swig_setmethods__["val"] = _swigfaiss.int_minheap_array_t_val_set
|
|
__swig_getmethods__["val"] = _swigfaiss.int_minheap_array_t_val_get
|
|
if _newclass:
|
|
val = _swig_property(_swigfaiss.int_minheap_array_t_val_get, _swigfaiss.int_minheap_array_t_val_set)
|
|
|
|
def get_val(self, key):
|
|
return _swigfaiss.int_minheap_array_t_get_val(self, key)
|
|
|
|
def get_ids(self, key):
|
|
return _swigfaiss.int_minheap_array_t_get_ids(self, key)
|
|
|
|
def heapify(self):
|
|
return _swigfaiss.int_minheap_array_t_heapify(self)
|
|
|
|
def addn(self, nj, vin, j0=0, i0=0, ni=-1):
|
|
return _swigfaiss.int_minheap_array_t_addn(self, nj, vin, j0, i0, ni)
|
|
|
|
def addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1):
|
|
return _swigfaiss.int_minheap_array_t_addn_with_ids(self, nj, vin, id_in, id_stride, i0, ni)
|
|
|
|
def reorder(self):
|
|
return _swigfaiss.int_minheap_array_t_reorder(self)
|
|
|
|
def per_line_extrema(self, vals_out, idx_out):
|
|
return _swigfaiss.int_minheap_array_t_per_line_extrema(self, vals_out, idx_out)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_int_minheap_array_t()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_int_minheap_array_t
|
|
__del__ = lambda self: None
|
|
int_minheap_array_t_swigregister = _swigfaiss.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.float_maxheap_array_t_nh_set
|
|
__swig_getmethods__["nh"] = _swigfaiss.float_maxheap_array_t_nh_get
|
|
if _newclass:
|
|
nh = _swig_property(_swigfaiss.float_maxheap_array_t_nh_get, _swigfaiss.float_maxheap_array_t_nh_set)
|
|
__swig_setmethods__["k"] = _swigfaiss.float_maxheap_array_t_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss.float_maxheap_array_t_k_get
|
|
if _newclass:
|
|
k = _swig_property(_swigfaiss.float_maxheap_array_t_k_get, _swigfaiss.float_maxheap_array_t_k_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss.float_maxheap_array_t_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss.float_maxheap_array_t_ids_get
|
|
if _newclass:
|
|
ids = _swig_property(_swigfaiss.float_maxheap_array_t_ids_get, _swigfaiss.float_maxheap_array_t_ids_set)
|
|
__swig_setmethods__["val"] = _swigfaiss.float_maxheap_array_t_val_set
|
|
__swig_getmethods__["val"] = _swigfaiss.float_maxheap_array_t_val_get
|
|
if _newclass:
|
|
val = _swig_property(_swigfaiss.float_maxheap_array_t_val_get, _swigfaiss.float_maxheap_array_t_val_set)
|
|
|
|
def get_val(self, key):
|
|
return _swigfaiss.float_maxheap_array_t_get_val(self, key)
|
|
|
|
def get_ids(self, key):
|
|
return _swigfaiss.float_maxheap_array_t_get_ids(self, key)
|
|
|
|
def heapify(self):
|
|
return _swigfaiss.float_maxheap_array_t_heapify(self)
|
|
|
|
def addn(self, nj, vin, j0=0, i0=0, ni=-1):
|
|
return _swigfaiss.float_maxheap_array_t_addn(self, nj, vin, j0, i0, ni)
|
|
|
|
def addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1):
|
|
return _swigfaiss.float_maxheap_array_t_addn_with_ids(self, nj, vin, id_in, id_stride, i0, ni)
|
|
|
|
def reorder(self):
|
|
return _swigfaiss.float_maxheap_array_t_reorder(self)
|
|
|
|
def per_line_extrema(self, vals_out, idx_out):
|
|
return _swigfaiss.float_maxheap_array_t_per_line_extrema(self, vals_out, idx_out)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_float_maxheap_array_t()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_float_maxheap_array_t
|
|
__del__ = lambda self: None
|
|
float_maxheap_array_t_swigregister = _swigfaiss.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.int_maxheap_array_t_nh_set
|
|
__swig_getmethods__["nh"] = _swigfaiss.int_maxheap_array_t_nh_get
|
|
if _newclass:
|
|
nh = _swig_property(_swigfaiss.int_maxheap_array_t_nh_get, _swigfaiss.int_maxheap_array_t_nh_set)
|
|
__swig_setmethods__["k"] = _swigfaiss.int_maxheap_array_t_k_set
|
|
__swig_getmethods__["k"] = _swigfaiss.int_maxheap_array_t_k_get
|
|
if _newclass:
|
|
k = _swig_property(_swigfaiss.int_maxheap_array_t_k_get, _swigfaiss.int_maxheap_array_t_k_set)
|
|
__swig_setmethods__["ids"] = _swigfaiss.int_maxheap_array_t_ids_set
|
|
__swig_getmethods__["ids"] = _swigfaiss.int_maxheap_array_t_ids_get
|
|
if _newclass:
|
|
ids = _swig_property(_swigfaiss.int_maxheap_array_t_ids_get, _swigfaiss.int_maxheap_array_t_ids_set)
|
|
__swig_setmethods__["val"] = _swigfaiss.int_maxheap_array_t_val_set
|
|
__swig_getmethods__["val"] = _swigfaiss.int_maxheap_array_t_val_get
|
|
if _newclass:
|
|
val = _swig_property(_swigfaiss.int_maxheap_array_t_val_get, _swigfaiss.int_maxheap_array_t_val_set)
|
|
|
|
def get_val(self, key):
|
|
return _swigfaiss.int_maxheap_array_t_get_val(self, key)
|
|
|
|
def get_ids(self, key):
|
|
return _swigfaiss.int_maxheap_array_t_get_ids(self, key)
|
|
|
|
def heapify(self):
|
|
return _swigfaiss.int_maxheap_array_t_heapify(self)
|
|
|
|
def addn(self, nj, vin, j0=0, i0=0, ni=-1):
|
|
return _swigfaiss.int_maxheap_array_t_addn(self, nj, vin, j0, i0, ni)
|
|
|
|
def addn_with_ids(self, nj, vin, id_in=None, id_stride=0, i0=0, ni=-1):
|
|
return _swigfaiss.int_maxheap_array_t_addn_with_ids(self, nj, vin, id_in, id_stride, i0, ni)
|
|
|
|
def reorder(self):
|
|
return _swigfaiss.int_maxheap_array_t_reorder(self)
|
|
|
|
def per_line_extrema(self, vals_out, idx_out):
|
|
return _swigfaiss.int_maxheap_array_t_per_line_extrema(self, vals_out, idx_out)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_int_maxheap_array_t()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_int_maxheap_array_t
|
|
__del__ = lambda self: None
|
|
int_maxheap_array_t_swigregister = _swigfaiss.int_maxheap_array_t_swigregister
|
|
int_maxheap_array_t_swigregister(int_maxheap_array_t)
|
|
|
|
|
|
def omp_set_num_threads(num_threads):
|
|
return _swigfaiss.omp_set_num_threads(num_threads)
|
|
omp_set_num_threads = _swigfaiss.omp_set_num_threads
|
|
|
|
def omp_get_max_threads():
|
|
return _swigfaiss.omp_get_max_threads()
|
|
omp_get_max_threads = _swigfaiss.omp_get_max_threads
|
|
|
|
def memcpy(dest, src, n):
|
|
return _swigfaiss.memcpy(dest, src, n)
|
|
memcpy = _swigfaiss.memcpy
|
|
|
|
def cast_integer_to_float_ptr(x):
|
|
return _swigfaiss.cast_integer_to_float_ptr(x)
|
|
cast_integer_to_float_ptr = _swigfaiss.cast_integer_to_float_ptr
|
|
|
|
def cast_integer_to_long_ptr(x):
|
|
return _swigfaiss.cast_integer_to_long_ptr(x)
|
|
cast_integer_to_long_ptr = _swigfaiss.cast_integer_to_long_ptr
|
|
|
|
def cast_integer_to_int_ptr(x):
|
|
return _swigfaiss.cast_integer_to_int_ptr(x)
|
|
cast_integer_to_int_ptr = _swigfaiss.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.RangeSearchResult_nq_set
|
|
__swig_getmethods__["nq"] = _swigfaiss.RangeSearchResult_nq_get
|
|
if _newclass:
|
|
nq = _swig_property(_swigfaiss.RangeSearchResult_nq_get, _swigfaiss.RangeSearchResult_nq_set)
|
|
__swig_setmethods__["lims"] = _swigfaiss.RangeSearchResult_lims_set
|
|
__swig_getmethods__["lims"] = _swigfaiss.RangeSearchResult_lims_get
|
|
if _newclass:
|
|
lims = _swig_property(_swigfaiss.RangeSearchResult_lims_get, _swigfaiss.RangeSearchResult_lims_set)
|
|
__swig_setmethods__["labels"] = _swigfaiss.RangeSearchResult_labels_set
|
|
__swig_getmethods__["labels"] = _swigfaiss.RangeSearchResult_labels_get
|
|
if _newclass:
|
|
labels = _swig_property(_swigfaiss.RangeSearchResult_labels_get, _swigfaiss.RangeSearchResult_labels_set)
|
|
__swig_setmethods__["distances"] = _swigfaiss.RangeSearchResult_distances_set
|
|
__swig_getmethods__["distances"] = _swigfaiss.RangeSearchResult_distances_get
|
|
if _newclass:
|
|
distances = _swig_property(_swigfaiss.RangeSearchResult_distances_get, _swigfaiss.RangeSearchResult_distances_set)
|
|
__swig_setmethods__["buffer_size"] = _swigfaiss.RangeSearchResult_buffer_size_set
|
|
__swig_getmethods__["buffer_size"] = _swigfaiss.RangeSearchResult_buffer_size_get
|
|
if _newclass:
|
|
buffer_size = _swig_property(_swigfaiss.RangeSearchResult_buffer_size_get, _swigfaiss.RangeSearchResult_buffer_size_set)
|
|
|
|
def __init__(self, nq, alloc_lims=True):
|
|
this = _swigfaiss.new_RangeSearchResult(nq, alloc_lims)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def do_allocation(self):
|
|
return _swigfaiss.RangeSearchResult_do_allocation(self)
|
|
__swig_destroy__ = _swigfaiss.delete_RangeSearchResult
|
|
__del__ = lambda self: None
|
|
RangeSearchResult_swigregister = _swigfaiss.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, id):
|
|
return _swigfaiss.IDSelector_is_member(self, id)
|
|
__swig_destroy__ = _swigfaiss.delete_IDSelector
|
|
__del__ = lambda self: None
|
|
IDSelector_swigregister = _swigfaiss.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.IDSelectorRange_imin_set
|
|
__swig_getmethods__["imin"] = _swigfaiss.IDSelectorRange_imin_get
|
|
if _newclass:
|
|
imin = _swig_property(_swigfaiss.IDSelectorRange_imin_get, _swigfaiss.IDSelectorRange_imin_set)
|
|
__swig_setmethods__["imax"] = _swigfaiss.IDSelectorRange_imax_set
|
|
__swig_getmethods__["imax"] = _swigfaiss.IDSelectorRange_imax_get
|
|
if _newclass:
|
|
imax = _swig_property(_swigfaiss.IDSelectorRange_imax_get, _swigfaiss.IDSelectorRange_imax_set)
|
|
|
|
def __init__(self, imin, imax):
|
|
this = _swigfaiss.new_IDSelectorRange(imin, imax)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def is_member(self, id):
|
|
return _swigfaiss.IDSelectorRange_is_member(self, id)
|
|
__swig_destroy__ = _swigfaiss.delete_IDSelectorRange
|
|
__del__ = lambda self: None
|
|
IDSelectorRange_swigregister = _swigfaiss.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.IDSelectorBatch_nbits_set
|
|
__swig_getmethods__["nbits"] = _swigfaiss.IDSelectorBatch_nbits_get
|
|
if _newclass:
|
|
nbits = _swig_property(_swigfaiss.IDSelectorBatch_nbits_get, _swigfaiss.IDSelectorBatch_nbits_set)
|
|
__swig_setmethods__["mask"] = _swigfaiss.IDSelectorBatch_mask_set
|
|
__swig_getmethods__["mask"] = _swigfaiss.IDSelectorBatch_mask_get
|
|
if _newclass:
|
|
mask = _swig_property(_swigfaiss.IDSelectorBatch_mask_get, _swigfaiss.IDSelectorBatch_mask_set)
|
|
|
|
def __init__(self, n, indices):
|
|
this = _swigfaiss.new_IDSelectorBatch(n, indices)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
|
|
def is_member(self, id):
|
|
return _swigfaiss.IDSelectorBatch_is_member(self, id)
|
|
__swig_destroy__ = _swigfaiss.delete_IDSelectorBatch
|
|
__del__ = lambda self: None
|
|
IDSelectorBatch_swigregister = _swigfaiss.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.BufferList_buffer_size_set
|
|
__swig_getmethods__["buffer_size"] = _swigfaiss.BufferList_buffer_size_get
|
|
if _newclass:
|
|
buffer_size = _swig_property(_swigfaiss.BufferList_buffer_size_get, _swigfaiss.BufferList_buffer_size_set)
|
|
__swig_setmethods__["buffers"] = _swigfaiss.BufferList_buffers_set
|
|
__swig_getmethods__["buffers"] = _swigfaiss.BufferList_buffers_get
|
|
if _newclass:
|
|
buffers = _swig_property(_swigfaiss.BufferList_buffers_get, _swigfaiss.BufferList_buffers_set)
|
|
__swig_setmethods__["wp"] = _swigfaiss.BufferList_wp_set
|
|
__swig_getmethods__["wp"] = _swigfaiss.BufferList_wp_get
|
|
if _newclass:
|
|
wp = _swig_property(_swigfaiss.BufferList_wp_get, _swigfaiss.BufferList_wp_set)
|
|
|
|
def __init__(self, buffer_size):
|
|
this = _swigfaiss.new_BufferList(buffer_size)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_BufferList
|
|
__del__ = lambda self: None
|
|
|
|
def append_buffer(self):
|
|
return _swigfaiss.BufferList_append_buffer(self)
|
|
|
|
def add(self, id, dis):
|
|
return _swigfaiss.BufferList_add(self, id, dis)
|
|
|
|
def copy_range(self, ofs, n, dest_ids, dest_dis):
|
|
return _swigfaiss.BufferList_copy_range(self, ofs, n, dest_ids, dest_dis)
|
|
BufferList_swigregister = _swigfaiss.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.RangeSearchPartialResult_res_set
|
|
__swig_getmethods__["res"] = _swigfaiss.RangeSearchPartialResult_res_get
|
|
if _newclass:
|
|
res = _swig_property(_swigfaiss.RangeSearchPartialResult_res_get, _swigfaiss.RangeSearchPartialResult_res_set)
|
|
|
|
def __init__(self, res_in):
|
|
this = _swigfaiss.new_RangeSearchPartialResult(res_in)
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_setmethods__["queries"] = _swigfaiss.RangeSearchPartialResult_queries_set
|
|
__swig_getmethods__["queries"] = _swigfaiss.RangeSearchPartialResult_queries_get
|
|
if _newclass:
|
|
queries = _swig_property(_swigfaiss.RangeSearchPartialResult_queries_get, _swigfaiss.RangeSearchPartialResult_queries_set)
|
|
|
|
def new_result(self, qno):
|
|
return _swigfaiss.RangeSearchPartialResult_new_result(self, qno)
|
|
|
|
def finalize(self):
|
|
return _swigfaiss.RangeSearchPartialResult_finalize(self)
|
|
|
|
def set_lims(self):
|
|
return _swigfaiss.RangeSearchPartialResult_set_lims(self)
|
|
|
|
def set_result(self, incremental=False):
|
|
return _swigfaiss.RangeSearchPartialResult_set_result(self, incremental)
|
|
__swig_destroy__ = _swigfaiss.delete_RangeSearchPartialResult
|
|
__del__ = lambda self: None
|
|
RangeSearchPartialResult_swigregister = _swigfaiss.RangeSearchPartialResult_swigregister
|
|
RangeSearchPartialResult_swigregister(RangeSearchPartialResult)
|
|
|
|
class IOReader(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IOReader, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IOReader, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["name"] = _swigfaiss.IOReader_name_set
|
|
__swig_getmethods__["name"] = _swigfaiss.IOReader_name_get
|
|
if _newclass:
|
|
name = _swig_property(_swigfaiss.IOReader_name_get, _swigfaiss.IOReader_name_set)
|
|
|
|
def __call__(self, ptr, size, nitems):
|
|
return _swigfaiss.IOReader___call__(self, ptr, size, nitems)
|
|
|
|
def fileno(self):
|
|
return _swigfaiss.IOReader_fileno(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IOReader
|
|
__del__ = lambda self: None
|
|
IOReader_swigregister = _swigfaiss.IOReader_swigregister
|
|
IOReader_swigregister(IOReader)
|
|
|
|
class IOWriter(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, IOWriter, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, IOWriter, name)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["name"] = _swigfaiss.IOWriter_name_set
|
|
__swig_getmethods__["name"] = _swigfaiss.IOWriter_name_get
|
|
if _newclass:
|
|
name = _swig_property(_swigfaiss.IOWriter_name_get, _swigfaiss.IOWriter_name_set)
|
|
|
|
def __call__(self, ptr, size, nitems):
|
|
return _swigfaiss.IOWriter___call__(self, ptr, size, nitems)
|
|
|
|
def fileno(self):
|
|
return _swigfaiss.IOWriter_fileno(self)
|
|
__swig_destroy__ = _swigfaiss.delete_IOWriter
|
|
__del__ = lambda self: None
|
|
IOWriter_swigregister = _swigfaiss.IOWriter_swigregister
|
|
IOWriter_swigregister(IOWriter)
|
|
|
|
class VectorIOReader(IOReader):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IOReader]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, VectorIOReader, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IOReader]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, VectorIOReader, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["data"] = _swigfaiss.VectorIOReader_data_set
|
|
__swig_getmethods__["data"] = _swigfaiss.VectorIOReader_data_get
|
|
if _newclass:
|
|
data = _swig_property(_swigfaiss.VectorIOReader_data_get, _swigfaiss.VectorIOReader_data_set)
|
|
__swig_setmethods__["rp"] = _swigfaiss.VectorIOReader_rp_set
|
|
__swig_getmethods__["rp"] = _swigfaiss.VectorIOReader_rp_get
|
|
if _newclass:
|
|
rp = _swig_property(_swigfaiss.VectorIOReader_rp_get, _swigfaiss.VectorIOReader_rp_set)
|
|
|
|
def __call__(self, ptr, size, nitems):
|
|
return _swigfaiss.VectorIOReader___call__(self, ptr, size, nitems)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_VectorIOReader()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_VectorIOReader
|
|
__del__ = lambda self: None
|
|
VectorIOReader_swigregister = _swigfaiss.VectorIOReader_swigregister
|
|
VectorIOReader_swigregister(VectorIOReader)
|
|
|
|
class VectorIOWriter(IOWriter):
|
|
__swig_setmethods__ = {}
|
|
for _s in [IOWriter]:
|
|
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, VectorIOWriter, name, value)
|
|
__swig_getmethods__ = {}
|
|
for _s in [IOWriter]:
|
|
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
|
|
__getattr__ = lambda self, name: _swig_getattr(self, VectorIOWriter, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["data"] = _swigfaiss.VectorIOWriter_data_set
|
|
__swig_getmethods__["data"] = _swigfaiss.VectorIOWriter_data_get
|
|
if _newclass:
|
|
data = _swig_property(_swigfaiss.VectorIOWriter_data_get, _swigfaiss.VectorIOWriter_data_set)
|
|
|
|
def __call__(self, ptr, size, nitems):
|
|
return _swigfaiss.VectorIOWriter___call__(self, ptr, size, nitems)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_VectorIOWriter()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_VectorIOWriter
|
|
__del__ = lambda self: None
|
|
VectorIOWriter_swigregister = _swigfaiss.VectorIOWriter_swigregister
|
|
VectorIOWriter_swigregister(VectorIOWriter)
|
|
|
|
|
|
def ignore_SIGTTIN():
|
|
return _swigfaiss.ignore_SIGTTIN()
|
|
ignore_SIGTTIN = _swigfaiss.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.MapLong2Long_map_set
|
|
__swig_getmethods__["map"] = _swigfaiss.MapLong2Long_map_get
|
|
if _newclass:
|
|
map = _swig_property(_swigfaiss.MapLong2Long_map_get, _swigfaiss.MapLong2Long_map_set)
|
|
|
|
def add(self, n, keys, vals):
|
|
return _swigfaiss.MapLong2Long_add(self, n, keys, vals)
|
|
|
|
def search(self, key):
|
|
return _swigfaiss.MapLong2Long_search(self, key)
|
|
|
|
def search_multiple(self, n, keys, vals):
|
|
return _swigfaiss.MapLong2Long_search_multiple(self, n, keys, vals)
|
|
|
|
def __init__(self):
|
|
this = _swigfaiss.new_MapLong2Long()
|
|
try:
|
|
self.this.append(this)
|
|
except __builtin__.Exception:
|
|
self.this = this
|
|
__swig_destroy__ = _swigfaiss.delete_MapLong2Long
|
|
__del__ = lambda self: None
|
|
MapLong2Long_swigregister = _swigfaiss.MapLong2Long_swigregister
|
|
MapLong2Long_swigregister(MapLong2Long)
|
|
|
|
# This file is compatible with both classic and new-style classes.
|
|
|
|
|