python_code stringlengths 0 108k |
|---|
#!/usr/bin/env python3
"""Setup script"""
from pathlib import Path
import re
import os
import setuptools
if __name__ == "__main__":
# Read metadata from version.py
with Path("autofaiss/version.py").open(encoding="utf-8") as file:
metadata = dict(re.findall(r'__([a-z]+)__\s*=\s*"([^"]+)"', file.read(... |
"""Check version and git tag script."""
from pathlib import Path
import re
import sys
import subprocess
if __name__ == "__main__":
# Read package version
with Path("autofaiss/version.py").open(encoding="utf-8") as file:
metadata = dict(re.findall(r'__([a-z]+)__\s*=\s*"([^"]+)"', file.read()))
... |
"""Test version."""
from autofaiss import version
def test_version():
"""Test version."""
assert len(version.__version__.split(".")) == 3
assert isinstance(version.__author__, str)
|
""" test utils functions """
# pylint: disable= invalid-name
import numpy as np
import pytest
from autofaiss.utils.array_functions import multi_array_split
def test_multi_array_split():
"""test multi_array_split fct number 1"""
assert len(list(multi_array_split([np.zeros((123, 2)), np.zeros((123, 5))], 41))... |
import numpy as np
from autofaiss import build_index, tune_index, score_index
def test_scoring_tuning():
embs = np.ones((100, 512), "float32")
index, index_infos = build_index(embs, save_on_disk=False)
index = tune_index(index, index_infos["index_key"], save_on_disk=False)
infos = score_index(index, e... |
import logging
import faiss
import numpy as np
import pytest
from autofaiss.external.optimize import (
get_min_param_value_for_best_neighbors_coverage,
get_optimal_hyperparameters,
get_optimal_index_keys_v2,
)
from autofaiss.external.quantize import build_index
from autofaiss.indices.index_factory import i... |
import logging
import os
import py
import random
from tempfile import TemporaryDirectory, NamedTemporaryFile
from typing import Tuple, List
import faiss
import numpy as np
import pandas as pd
import pyarrow.parquet as pq
import pytest
from numpy.testing import assert_array_equal
LOGGER = logging.getLogger(__name__)
... |
import numpy as np
from autofaiss import build_index
def test_np_quantize():
embs = np.ones((100, 512), "float32")
index, _ = build_index(embs, save_on_disk=False)
_, I = index.search(embs, 1)
assert I[0][0] == 0
|
from autofaiss.external.build import estimate_memory_required_for_index_creation
#
# def test_estimate_memory_required_for_index_creation():
# needed_memory, _ = estimate_memory_required_for_index_creation(
# nb_vectors=4_000_000_000,
# vec_dim=512,
# index_key="OPQ4_28,IVF131072_HNSW32,PQ4... |
""" Test that the memory efficient flat index give same results as the faiss flat index """
import time
import faiss
import numpy as np
import pytest
from autofaiss.indices.memory_efficient_flat_index import MemEfficientFlatIndex
@pytest.fixture(name="prod_emb")
def fixture_prod_emb():
"""generate random datab... |
from autofaiss.indices.distributed import _batch_loader
def test_batch_loader():
for input_size in range(2, 500):
for output_size in range(1, input_size):
batches = list(_batch_loader(nb_batches=output_size, total_size=input_size))
# test output size is expected
assert ... |
# Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
# If ex... |
"""
An example of running autofaiss by pyspark to produce N indices.
You need to install pyspark before using the following example.
"""
from typing import Dict
import faiss
import numpy as np
from autofaiss import build_index
# You'd better create a spark session before calling build_index,
# otherwise, a spark se... |
"""
Given a partitioned dataset of embeddings, create an index per partition
"""
import os
from autofaiss import build_partitioned_indexes
from pyspark.sql import SparkSession # pylint: disable=import-outside-toplevel
def create_spark_session():
# PEX file packaging your Python environment and accessible on ya... |
import faiss
import numpy as np
from autofaiss import build_index
embeddings = np.float32(np.random.rand(5000, 100))
# Example on how to build a memory-mapped index and load it from disk
_, index_infos = build_index(
embeddings,
save_on_disk=True,
should_be_memory_mappable=True,
index_path="my_index_f... |
from autofaiss import build_index
import numpy as np
embeddings = np.float32(np.random.rand(100, 512))
index, index_infos = build_index(embeddings, save_on_disk=False)
_, I = index.search(embeddings, 1)
print(I)
|
import numpy as np
from autofaiss import build_index, tune_index, score_index
embs = np.float32(np.random.rand(100, 512))
index, index_infos = build_index(embs, save_on_disk=False)
index = tune_index(index, index_infos["index_key"], save_on_disk=False)
infos = score_index(index, embs, save_on_disk=False)
|
"""
An example of running autofaiss by pyspark.
You need to install pyspark before using the following example.
"""
from autofaiss import build_index
# You'd better create a spark session before calling build_index,
# otherwise, a spark session would be created by autofaiss with the least configuration.
index, index... |
from autofaiss import build_index
build_index(
embeddings="embeddings",
index_path="knn.index",
index_infos_path="infos.json",
max_index_memory_usage="4G",
current_memory_available="5G",
)
|
# pylint: disable=all
__version__ = "2.15.5"
__author__ = "Criteo"
MAJOR = __version__.split(".")[0]
MINOR = __version__.split(".")[1]
PATCH = __version__.split(".")[2]
|
# pylint: disable=unused-import,missing-docstring
from autofaiss.external.quantize import build_index, score_index, tune_index, build_partitioned_indexes
from autofaiss.version import __author__, __version__
|
""" function to compute different kind of recalls """
from typing import List, Optional
import faiss
import numpy as np
def r_recall_at_r_single(
query: np.ndarray,
ground_truth: np.ndarray,
other_index: faiss.Index,
r_max: int = 40,
eval_item_ids: Optional[np.ndarray] = None,
) -> List[int]:
... |
""" function to compute the reconstruction error """
from typing import Optional
import numpy as np
import faiss
def reconstruction_error(before, after, avg_norm_before: Optional[float] = None) -> float:
"""Computes the average reconstruction error"""
diff = np.mean(np.linalg.norm(after - before, axis=1))
... |
""" functions to compare different indices """
import time
import numpy as np
from matplotlib import pyplot as plt
from tqdm import tqdm as tq
from autofaiss.indices.index_utils import format_speed_ms_per_query, get_index_size, speed_test_ms_per_query
from autofaiss.metrics.recalls import r_recall_at_r_single, one_r... |
# pylint: disable=unused-import,missing-docstring
|
""" Common functions to build an index """
import logging
from typing import Dict, Optional, Tuple, Union, Callable, Any
import uuid
import re
import os
import tempfile
import fsspec
import faiss
import pandas as pd
from embedding_reader import EmbeddingReader
from autofaiss.external.optimize import optimize_and_mea... |
""" functions that fixe faiss index_factory function """
# pylint: disable=invalid-name
import re
from typing import Optional
import faiss
def index_factory(d: int, index_key: str, metric_type: int, ef_construction: Optional[int] = None):
"""
custom index_factory that fix some issues of
faiss.index_fact... |
""" useful functions to apply on an index """
import os
import time
from functools import partial
from itertools import chain, repeat
from multiprocessing.pool import ThreadPool
from pathlib import Path
from tempfile import NamedTemporaryFile
from typing import Dict, Optional, Union, List, Tuple
import logging
from f... |
# pylint: disable=unused-import,missing-docstring
|
"""
Building the index with pyspark.
"""
import math
import multiprocessing
import os
import logging
from tempfile import TemporaryDirectory
import tempfile
from typing import Dict, Optional, Iterator, Tuple, Callable, Any, Union, List
from functools import partial
from multiprocessing.pool import ThreadPool
import f... |
""" function related to search on indices """
from typing import Iterable, Tuple
import numpy as np
def knn_query(index, query, ksearch: int) -> Iterable[Tuple[Tuple[int, int], float]]:
"""Do a knn search and return a list of the closest items and the associated distance"""
dist, ind = index.search(np.expa... |
""" This file contain a class describing a memory efficient flat index """
import heapq
from typing import List, Optional, Tuple
from embedding_reader import EmbeddingReader
import faiss
import numpy as np
from tqdm import trange
from autofaiss.indices.faiss_index_wrapper import FaissIndexWrapper
class MemEfficie... |
""" This file contains a wrapper class to create Faiss-like indices """
from abc import ABC, abstractmethod
import faiss
import numpy as np
class FaissIndexWrapper(ABC):
"""
This abstract class is describing a Faiss-like index
It is useful to use this wrapper to use benchmarking functions written for
... |
"""Index training"""
from typing import Union, NamedTuple, Optional, List
import logging
import multiprocessing
import faiss
from embedding_reader import EmbeddingReader
from autofaiss.external.metadata import IndexMetadata
from autofaiss.external.optimize import check_if_index_needs_training, get_optimal_train_size... |
""" function to cast variables in others """
import re
from math import floor
from typing import Union
import faiss
def cast_memory_to_bytes(memory_string: str) -> float:
"""
Parse a memory string and returns the number of bytes
>>> cast_memory_to_bytes("16B")
16
>>> cast_memory_to_bytes("16G")... |
""" Various optimization algorithms """
from typing import Callable
# pylint: disable=invalid-name
def discrete_binary_search(is_ok: Callable[[int], bool], n: int) -> int:
"""
Binary search in a function domain
Parameters
----------
is_ok : bool
Boolean monotone function defined on range(... |
# pylint: disable=unused-import,missing-docstring
|
""" useful functions t apply on numpy arrays """
import numpy as np
def sanitize(x):
return np.ascontiguousarray(x, dtype="float32")
def multi_array_split(array_list, nb_chunk):
total_length = len(array_list[0])
chunk_size = (total_length - 1) // nb_chunk + 1
assert all(len(x) == total_length for x... |
"""path"""
import os
import fsspec
def make_path_absolute(path: str) -> str:
fs, p = fsspec.core.url_to_fs(path, use_listings_cache=False)
if fs.protocol == "file":
return os.path.abspath(p)
return path
def extract_partition_name_from_path(path: str) -> str:
"""Extract partition name from p... |
""" Useful decorators for fast debuging """
import functools
import time
import logging
from contextlib import ContextDecorator
from datetime import datetime
from typing import Optional
logger = logging.getLogger("autofaiss")
class Timeit(ContextDecorator):
"""Timing class, used as a context manager"""
def... |
""" gather functions necessary to build an index """
import logging
from typing import Dict, Optional, Tuple, Union, Callable, Any, List
import faiss
import pandas as pd
from embedding_reader import EmbeddingReader
from autofaiss.external.metadata import IndexMetadata
from autofaiss.external.optimize import check_if... |
""" Functions to find optimal index parameters """
import json
import logging
import re
from functools import partial, reduce
from math import floor, log2, sqrt
from operator import mul
from typing import Callable, List, Optional, TypeVar
import faiss
import fsspec
import numpy as np
from autofaiss.external.metadata i... |
"""
Index metadata for Faiss indices.
"""
import re
from enum import Enum
from math import ceil
from autofaiss.utils.cast import cast_bytes_to_memory_string
from autofaiss.external.descriptions import (
INDEX_DESCRIPTION_BLOCKS,
IndexBlock,
TUNABLE_PARAMETERS_DESCRIPTION_BLOCKS,
TunableParam,
)
clas... |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 4