import faiss

d = 128  # 向量维度
M = 16   # 子空间数
pq_bits = 8  # 每个子空间的比特数

# 1. 创建 OPQ 索引（先旋转，再 PQ）
opq = faiss.IndexOPQ(d, M, pq_bits)
# 2. 训练旋转矩阵（需大量样本向量）
opq.train(train_vectors)  # train_vectors: (n_train, d)
# 3. 添加向量并编码
opq.add(db_vectors)  # db_vectors: (n_db, d)
# 4. 检索
D, I = opq.search(query_vectors, k=10)  # D: 距离，I: 索引

import faiss
import numpy as np

# 1. 生成测试数据
d = 128  # 向量维度
n_db = 10000  # 数据库向量数
n_query = 100  # 查询向量数
db_vectors = np.random.rand(n_db, d).astype(np.float32)  # 数据库向量
query_vectors = np.random.rand(n_query, d).astype(np.float32)  # 查询向量

# 2. 创建 IndexFlatL2（L2 距离）
index = faiss.IndexFlatL2(d)
# 若需内积，使用 IndexFlatIP（需先归一化）
# faiss.normalize_L2(db_vectors)
# index = faiss.IndexFlatIP(d)

# 3. 添加向量到索引
index.add(db_vectors)
print(f"索引中向量数：{index.ntotal}")  # 输出：10000

# 4. 检索（返回 Top-10 结果）
k = 10
D, I = index.search(query_vectors, k)  # D: (100,10) 距离矩阵，I: (100,10) 索引矩阵

# 5. 查看结果（以第一个查询向量为例）
print("第一个查询向量的 Top-10 距离：", D[0])
print("第一个查询向量的 Top-10 索引：", I[0])

import faiss
import numpy as np

# 1. 生成测试数据
d = 128
n_db = 1_000_000  # 100万数据库向量
n_query = 100
db_vectors = np.random.rand(n_db, d).astype(np.float32)
query_vectors = np.random.rand(n_query, d).astype(np.float32)

# 2. 配置 IVF-PQ 参数
nlist = 4096  # 聚类中心数（约 4*sqrt(1e6) = 4000）
M = 16        # PQ 子空间数
pq_bits = 8   # 每个子空间的比特数
nprobe = 10   # 检索时查询的桶数

# 3. 创建粗量化器（IndexFlatL2）
coarse_quantizer = faiss.IndexFlatL2(d)

# 4. 创建 IndexIVFPQ 索引
index = faiss.IndexIVFPQ(
    coarse_quantizer,  # 粗量化器
    d,                 # 向量维度
    nlist,             # 聚类中心数
    M,                 # PQ 子空间数
    pq_bits            # PQ 比特数
)

# 5. 训练索引（必须先训练，再添加向量）
index.train(db_vectors)

# 6. 添加向量到索引（自动分配到对应桶）
index.add(db_vectors)
print(f"索引中向量数：{index.ntotal}")  # 输出：1000000

# 7. 设置检索参数（nprobe）
index.nprobe = nprobe

# 8. 检索
k = 10
D, I = index.search(query_vectors, k)

# 9. 评估精度（与 IndexFlat 对比）
# 创建基准索引
benchmark_index = faiss.IndexFlatL2(d)
benchmark_index.add(db_vectors)
D_bench, I_bench = benchmark_index.search(query_vectors, k)

# 计算召回率（衡量近似索引的精度）
recall = 0
for i in range(n_query):
    # 近似结果与基准结果的交集大小
    intersection = len(set(I[i]) & set(I_bench[i]))
    recall += intersection / k
recall /= n_query
print(f"召回率：{recall:.4f}")  # 通常 nprobe=10 时召回率 > 0.95

import faiss
import numpy as np

# 1. 生成测试数据（高维向量）
d = 512  # 高维（如 CNN 图像特征）
n_db = 100_000  # 10万数据库向量
n_query = 100
db_vectors = np.random.rand(n_db, d).astype(np.float32)
query_vectors = np.random.rand(n_query, d).astype(np.float32)

# 2. 配置 HNSW 参数
m = 32  # 每层邻域数
ef_construction = 100  # 构建时的探索范围
ef_search = 100  # 检索时的探索范围

# 3. 创建 IndexHNSWFlat 索引
# 注意：HNSW 不支持直接设置 nprobe，通过 ef_search 控制精度
index = faiss.IndexHNSWFlat(d, m)
# 设置构建参数
index.hnsw.efConstruction = ef_construction

# 4. 添加向量（HNSW 无需预训练，直接添加）
index.add(db_vectors)
print(f"索引中向量数：{index.ntotal}")  # 输出：100000

# 5. 设置检索参数
index.hnsw.efSearch = ef_search

# 6. 检索
k = 10
D, I = index.search(query_vectors, k)

# 7. 评估精度（与 IndexFlat 对比）
benchmark_index = faiss.IndexFlatL2(d)
benchmark_index.add(db_vectors)
D_bench, I_bench = benchmark_index.search(query_vectors, k)

recall = 0
for i in range(n_query):
    intersection = len(set(I[i]) & set(I_bench[i]))
    recall += intersection / k
recall /= n_query
print(f"召回率：{recall:.4f}")  # ef_search=100 时召回率 > 0.98

import faiss
import numpy as np

# 1. 生成测试数据
d = 128
n_db = 10_000_000  # 1000万数据库向量
n_query = 100
db_vectors = np.random.rand(n_db, d).astype(np.float32)
query_vectors = np.random.rand(n_query, d).astype(np.float32)

# 2. 配置 PQ 参数
M = 16        # 子空间数
pq_bits = 8   # 每个子空间的比特数

# 3. 创建 IndexPQ 索引
index = faiss.IndexPQ(d, M, pq_bits)

# 4. 训练索引（需大量样本向量）
index.train(db_vectors)

# 5. 添加向量（自动编码为 PQ 格式）
index.add(db_vectors)
print(f"索引中向量数：{index.ntotal}")  # 输出：10000000

# 6. 检索
k = 10
D, I = index.search(query_vectors, k)

# 7. 评估精度
benchmark_index = faiss.IndexFlatL2(d)
benchmark_index.add(db_vectors[:100_000])  # 取10万样本评估（避免内存不足）
D_bench, I_bench = benchmark_index.search(query_vectors, k)

recall = 0
for i in range(n_query):
    # 注意：I 是全局索引，I_bench 是样本索引，需映射后对比
    sample_I = I[i][I[i] < 100_000]  # 仅保留样本内的索引
    sample_I_bench = I_bench[i]
    intersection = len(set(sample_I) & set(sample_I_bench))
    recall += intersection / min(len(sample_I), k)
recall /= n_query
print(f"召回率：{recall:.4f}")  # 通常召回率 > 0.90

import faiss
import numpy as np

# 1. 生成测试数据（高维向量）
d = 256  # 原始维度
n_db = 1_000_000
n_query = 100
db_vectors = np.random.rand(n_db, d).astype(np.float32)
query_vectors = np.random.rand(n_query, d).astype(np.float32)

# 2. 用 index_factory 构建复合索引（PCA降维+IVF-PQ）
index_str = "PCA80,IVF1024,PQ64"  # 降维到80维，IVF(nlist=1024)，PQ(M=64)
index = faiss.index_factory(d, index_str, faiss.METRIC_L2)  # METRIC_L2 表示L2距离

# 3. 训练索引（复合索引需训练所有组件，包括PCA和IVF）
index.train(db_vectors)

# 4. 添加向量
index.add(db_vectors)
print(f"索引中向量数：{index.ntotal}")  # 输出：1000000

# 5. 设置检索参数（nprobe）
index.nprobe = 20

# 6. 检索
k = 10
D, I = index.search(query_vectors, k)

print("Top-10 距离（第一个查询向量）：", D[0])

graph TD
    A[硬件加速层] --> B[基础算法层]
    B --> C[索引核心层]
    C --> D[索引组合层]
    D --> E[接口层]

    %% ========== 硬件加速层 ==========
    subgraph A [硬件加速层]
        direction LR
        A1[CPU 加速<br/>SIMD/AVX2/Neon]
        A2[GPU 加速<br/>CUDA/cuVS]
        A3[多线程并行<br/>OpenMP]
        A1 --> A2 --> A3
        style A1 fill:none,stroke:none
        style A2 fill:none,stroke:none
        style A3 fill:none,stroke:none
    end

    %% ========== 基础算法层 ==========
    subgraph B [基础算法层]
        direction LR
        B1[距离计算<br/>L2/IP/Hamming]
        B2[向量量化<br/>PQ/SQ/OPQ]
        B3[聚类算法<br/>k-means]
        B4[向量变换<br/>PCA/L2norm]
        B1 --> B2 --> B3 --> B4
        style B1 fill:none,stroke:none
        style B2 fill:none,stroke:none
        style B3 fill:none,stroke:none
        style B4 fill:none,stroke:none
    end

    %% ========== 索引核心层 ==========
    subgraph C [索引核心层]
        direction LR
        C1[精确索引<br/>IndexFlat]
        C2[倒排索引<br/>IndexIVF]
        C3[图索引<br/>IndexHNSW]
        C4[量化索引<br/>IndexPQ]
        C1 --> C2 --> C3 --> C4
        style C1 fill:none,stroke:none
        style C2 fill:none,stroke:none
        style C3 fill:none,stroke:none
        style C4 fill:none,stroke:none
    end

    %% ========== 索引组合层 ==========
    subgraph D [索引组合层]
        direction LR
        D1[复合索引构建<br/>index_factory]
        D2[索引包装<br/>IndexIDMap]
        D3[结果精修<br/>IndexRefineFlat]
        D1 --> D2 --> D3
        style D1 fill:none,stroke:none
        style D2 fill:none,stroke:none
        style D3 fill:none,stroke:none
    end

    %% ========== 接口层 ==========
    subgraph E [接口层]
        direction LR
        E1[C++ 核心接口]
        E2[Python 绑定]
        E3[CLI 工具]
        E4[Java/Go 封装]
        E1 --> E2 --> E3 --> E4
        style E1 fill:none,stroke:none
        style E2 fill:none,stroke:none
        style E3 fill:none,stroke:none
        style E4 fill:none,stroke:none
    end

import faiss

d = 128
n_db = 1_000_000

# 1. 初始化 GPU 资源（默认使用所有 GPU）
res = faiss.StandardGpuResources()

# 2. 配置 GPU 索引参数（使用第 0 块 GPU，禁用内存池）
gpu_config = faiss.GpuIndexFlatConfig()
gpu_config.device = 0
gpu_config.useFloat16 = False  # 禁用 FP16 精度
gpu_config.poolBottomUp = False  # 禁用内存池

# 3. 创建 GPU 版 IndexFlatL2
index = faiss.GpuIndexFlatL2(res, d, gpu_config)

# 4. 添加向量（自动将 CPU 向量传输到 GPU）
db_vectors = np.random.rand(n_db, d).astype(np.float32)
index.add(db_vectors)

# 5. 检索（结果自动传回 CPU）
query_vectors = np.random.rand(100, d).astype(np.float32)
D, I = index.search(query_vectors, k=10)

import faiss
import numpy as np

d = 256  # 原始维度
d_pca = 80  # 降维后维度

# 1. 创建 PCA 变换
pca = faiss.PCAMatrix(d, d_pca)

# 2. 训练 PCA 矩阵（需大量样本向量）
train_vectors = np.random.rand(100_000, d).astype(np.float32)
pca.train(train_vectors)

# 3. 应用 PCA 降维
db_vectors = np.random.rand(1_000_000, d).astype(np.float32)
db_vectors_pca = pca.apply_py(db_vectors)  # 降维后向量：(1e6, 80)

# 4. 构建索引（基于降维后的向量）
index = faiss.IndexFlatL2(d_pca)
index.add(db_vectors_pca)

import faiss
import numpy as np

d = 128
n_db = 2_000_000  # 200万向量，分配到 2 块 GPU
n_query = 100

# 1. 初始化 GPU 资源（自动检测所有 GPU）
res = faiss.StandardGpuResources()

# 2. 创建多 GPU 索引（使用所有可用 GPU）
index = faiss.IndexFlatL2(d)
# 将 CPU 索引包装为多 GPU 索引
gpu_index = faiss.index_cpu_to_all_gpus(
    index,
    ngpu=-1,  # -1 表示使用所有 GPU
    gpu_resources=[res] * faiss.get_num_gpus()  # 为每个 GPU 分配资源
)

# 3. 添加向量（自动分片到各 GPU）
db_vectors = np.random.rand(n_db, d).astype(np.float32)
gpu_index.add(db_vectors)

# 4. 检索（自动并行检索+结果合并）
query_vectors = np.random.rand(n_query, d).astype(np.float32)
D, I = gpu_index.search(query_vectors, k=10)

print(f"使用 GPU 数量：{faiss.get_num_gpus()}")
print(f"Top-10 索引（第一个查询向量）：{I[0]}")

# Python 3.6+
pip install faiss-cpu

# 安装依赖
sudo apt-get install libopenblas-dev liblapack-dev libomp-dev

# 克隆源码
git clone <https://github.com/facebookresearch/faiss.git>
cd faiss

# 编译 CPU 版本
cmake -B build -DFAISS_ENABLE_GPU=OFF -DFAISS_ENABLE_PYTHON=ON
make -C build -j$(nproc)

# 安装 Python 包
cd build/faiss/python
pip install .

# 根据 CUDA 版本选择（如 CUDA 11.7）
pip install faiss-gpu==1.7.4.post2  # 对应 CUDA 11.7

# 确保 CUDA 已安装（nvcc --version 验证）
cmake -B build -DFAISS_ENABLE_GPU=ON -DCUDAToolkit_ROOT=/usr/local/cuda-11.7 -DFAISS_ENABLE_PYTHON=ON
make -C build -j$(nproc)

# 安装 Python 包
cd build/faiss/python
pip install .

import faiss
import numpy as np

# 验证 CPU 版本
print(f"Faiss 版本：{faiss.__version__}")
print(f"CPU 索引支持：{faiss.IndexFlatL2(128) is not None}")

# 验证 GPU 版本（若安装）
if faiss.get_num_gpus() > 0:
    res = faiss.StandardGpuResources()
    gpu_index = faiss.GpuIndexFlatL2(res, 128)
    print(f"GPU 数量：{faiss.get_num_gpus()}")
    print(f"GPU 索引支持：{gpu_index is not None}")
else:
    print("未检测到 GPU，仅支持 CPU 索引")

import faiss
import numpy as np
import time
import psutil
import os

def evaluate_faiss_index(index, db_vectors, query_vectors, k=10):
    """
    评估 Faiss 索引的性能：召回率、QPS、延迟、内存占用
    """
    # 1. 计算召回率（以 IndexFlat 为基准）
    print("=== 计算召回率 ===")
    # 构建基准索引（仅用前 100 万向量避免内存不足，适用于大规模数据）
    bench_size = min(1_000_000, len(db_vectors))
    bench_index = faiss.IndexFlatL2(db_vectors.shape[1])
    bench_index.add(db_vectors[:bench_size])
    # 基准检索结果
    D_bench, I_bench = bench_index.search(query_vectors, k)
    # 待评估索引检索结果（过滤超出基准范围的索引）
    D_test, I_test = index.search(query_vectors, k)
    # 计算 Recall@K
    recall = 0.0
    for i in range(len(query_vectors)):
        # 仅保留基准索引范围内的结果
        valid_test = I_test[i][I_test[i] < bench_size]
        valid_bench = I_bench[i]
        # 计算交集
        intersection = len(set(valid_test) & set(valid_bench))
        # 累加召回率（分母为基准结果数，最多 K 个）
        recall += intersection / min(len(valid_bench), k)
    recall /= len(query_vectors)
    print(f"Recall@{k}: {recall:.4f}")

    # 2. 计算 QPS 与延迟
    print("\n=== 计算 QPS 与延迟 ===")
    n_query = len(query_vectors)
    # 预热（避免冷启动影响）
    index.search(query_vectors[:10], k)
    # 正式测试（重复 5 次取平均）
    total_time = 0.0
    for _ in range(5):
        start = time.time()
        index.search(query_vectors, k)
        end = time.time()
        total_time += (end - start)
    avg_time = total_time / 5  # 平均总耗时（秒）
    qps = n_query / avg_time
    latency = (avg_time * 1000) / n_query  # 平均延迟（毫秒）
    print(f"总查询数：{n_query}")
    print(f"平均总耗时：{avg_time:.4f} 秒")
    print(f"QPS：{qps:.2f}")
    print(f"平均查询延迟：{latency:.4f} 毫秒")

    # 3. 计算内存占用
    print("\n=== 计算内存占用 ===")
    # 方法 1：通过进程内存差（适用于独立索引）
    process = psutil.Process(os.getpid())
    # 记录无索引时的内存
    mem_before = process.memory_info().rss / (1024 ** 2)  # 转换为 MB
    # 加载索引（若已加载则先释放）
    if hasattr(index, "reset"):
        index.reset()
    index.add(db_vectors)
    # 记录加载后的内存
    mem_after = process.memory_info().rss / (1024 ** 2)
    mem_usage = mem_after - mem_before
    print(f"索引内存占用：{mem_usage:.2f} MB")

    # 返回评估结果
    return {
        "recall@k": recall,
        "qps": qps,
        "latency_ms": latency,
        "memory_mb": mem_usage
    }

# 测试代码
if __name__ == "__main__":
    # 生成测试数据
    d = 128
    n_db = 1_000_000  # 100 万数据库向量
    n_query = 1000    # 1000 个查询向量
    db_vectors = np.random.rand(n_db, d).astype(np.float32)
    query_vectors = np.random.rand(n_query, d).astype(np.float32)

    # 构建待评估索引（IVF-PQ）
    nlist = 4096
    M = 16
    pq_bits = 8
    coarse_quantizer = faiss.IndexFlatL2(d)
    index = faiss.IndexIVFPQ(coarse_quantizer, d, nlist, M, pq_bits)
    index.train(db_vectors)

    # 评估
    results = evaluate_faiss_index(index, db_vectors, query_vectors, k=10)
    print("\n=== 最终评估结果 ===")
    for key, value in results.items():
        print(f"{key}: {value}")

import faiss
import numpy as np

d = 128
n_db = 1_000_000
db_vectors = np.random.rand(n_db, d).astype(np.float32)

# 1. 构建并训练索引
index = faiss.IndexIVFPQ(faiss.IndexFlatL2(d), d, 4096, 16, 8)
index.train(db_vectors)
index.add(db_vectors)

# 2. 保存索引到磁盘（二进制文件）
index_path = "ivf_pq_index.faiss"
faiss.write_index(index, index_path)
print(f"索引已保存到：{index_path}")

# 3. 从磁盘加载索引
loaded_index = faiss.read_index(index_path)
print(f"加载的索引向量数：{loaded_index.ntotal}")  # 输出：1000000

# 4. 加载后直接检索
query_vectors = np.random.rand(100, d).astype(np.float32)
D, I = loaded_index.search(query_vectors, k=10)
print("加载后检索结果：", I[0])

import faiss
import numpy as np

# 1. 构建超大规模索引（模拟 10 亿向量，实际需调整参数）
d = 128
n_db = 10_000_000  # 1000 万向量（示例）
db_vectors = np.random.rand(n_db, d).astype(np.float32)
index = faiss.IndexIVFPQ(faiss.IndexFlatL2(d), d, 16384, 32, 8)
index.train(db_vectors)
index.add(db_vectors)

# 2. 保存索引（二进制文件）
index_path = "large_ivf_pq_index.faiss"
faiss.write_index(index, index_path)

# 3. 内存映射加载（关键：使用 faiss.read_index 并指定 IO_FLAG_MMAP）
# IO_FLAG_MMAP：通过内存映射读取，不占用物理内存
loaded_index = faiss.read_index(
    index_path,
    faiss.IO_FLAG_MMAP | faiss.IO_FLAG_READ_ONLY  # 只读模式，避免误修改
)
print(f"加载的索引向量数：{loaded_index.ntotal}")

# 4. 检索（数据按需从磁盘读取，内存占用仅为元数据大小）
query_vectors = np.random.rand(100, d).astype(np.float32)
D, I = loaded_index.search(query_vectors, k=10)
print("内存映射检索结果：", I[0])

import faiss
import numpy as np
from collections import defaultdict

class ShardedFaissIndex:
    def __init__(self, d, index_type="ivf_pq", shard_size=1_000_000):
        self.d = d
        self.index_type = index_type  # "ivf_pq" 或 "hnsw"
        self.shard_size = shard_size  # 每个分片的最大向量数
        self.shards = []  # 存储所有分片索引
        self.current_shard = self._create_new_shard()  # 当前活跃分片

    def _create_new_shard(self):
        """创建新分片索引"""
        if self.index_type == "ivf_pq":
            nlist = 4096
            M = 16
            pq_bits = 8
            coarse_quantizer = faiss.IndexFlatL2(self.d)
            index = faiss.IndexIVFPQ(coarse_quantizer, self.d, nlist, M, pq_bits)
            # 新分片无数据，无需训练（添加数据后训练）
            return {"index": index, "count": 0, "trained": False}
        elif self.index_type == "hnsw":
            m = 32
            index = faiss.IndexHNSWFlat(self.d, m)
            index.hnsw.efConstruction = 100
            return {"index": index, "count": 0, "trained": True}  # HNSW 无需训练
        else:
            raise ValueError("不支持的索引类型")

    def add(self, vectors):
        """添加向量到分片"""
        remaining = vectors.copy()
        while len(remaining) > 0:
            # 计算当前分片可容纳的向量数
            available = self.shard_size - self.current_shard["count"]
            if available <= 0:
                # 当前分片满，保存到分片列表，创建新分片
                self.shards.append(self.current_shard)
                self.current_shard = self._create_new_shard()
                available = self.shard_size

            # 取部分向量写入当前分片
            to_add = remaining[:available]
            remaining = remaining[available:]

            # 若为 IVF-PQ 且未训练，先训练（用当前分片的所有向量）
            if self.index_type == "ivf_pq" and not self.current_shard["trained"]:
                self.current_shard["index"].train(to_add)
                self.current_shard["trained"] = True

            # 添加向量
            self.current_shard["index"].add(to_add)
            self.current_shard["count"] += len(to_add)

    def search(self, query_vectors, k=10):
        """检索所有分片并合并结果"""
        all_D = []
        all_I = []
        # 遍历所有已完成的分片
        for shard in self.shards:
            D, I = shard["index"].search(query_vectors, k)
            all_D.append(D)
            all_I.append(I)
        # 遍历当前活跃分片
        if self.current_shard["count"] > 0:
            D, I = self.current_shard["index"].search(query_vectors, k)
            all_D.append(D)
            all_I.append(I)

        # 合并结果（按距离排序，取 Top-K）
        merged_D = []
        merged_I = []
        for q_idx in range(len(query_vectors)):
            # 收集该查询向量在所有分片的结果
            q_D = []
            q_I = []
            for shard_idx in range(len(all_D)):
                # 为索引添加分片偏移（避免不同分片索引重复）
                shard_offset = shard_idx * self.shard_size
                q_D.extend(all_D[shard_idx][q_idx])
                q_I.extend(all_I[shard_idx][q_idx] + shard_offset)

            # 按距离排序，取 Top-K
            sorted_pairs = sorted(zip(q_D, q_I), key=lambda x: x[0])[:k]
            merged_D.append([p[0] for p in sorted_pairs])
            merged_I.append([p[1] for p in sorted_pairs])

        return np.array(merged_D), np.array(merged_I)

# 测试
if __name__ == "__main__":
    d = 128
    sharded_index = ShardedFaissIndex(d, index_type="ivf_pq", shard_size=500_000)

    # 分批次添加数据（模拟实时流入）
    batch1 = np.random.rand(500_000, d).astype(np.float32)
    batch2 = np.random.rand(600_000, d).astype(np.float32)
    sharded_index.add(batch1)
    sharded_index.add(batch2)

    # 检索
    query = np.random.rand(100, d).astype(np.float32)
    D, I = sharded_index.search(query, k=10)
    print("分片索引检索结果：", I[0])