2.3 乘积量化(PQ)技术 — 向量压缩的核心技术

本节导读：深入理解FAISS的乘积量化(PQ)技术，掌握向量压缩原理、编码解码过程和精度控制方法，学会在内存受限环境中高效部署大规模向量索引。

学习目标

• 掌握PQ技术的基本原理和优势特点
• 理解向量分解和量化编码过程
• 学会PQ参数配置和精度调优
• 掌握PQ与IVF的结合使用方法
• 能够在实际项目中合理应用PQ技术

核心概念

乘积量化(Product Quantization, PQ)是FAISS中最重要的向量压缩技术，它通过将高维向量分解为多个低维子向量，并对每个子向量独立量化，实现大幅的内存节省。

PQ基本原理

PQ的核心思想是将高维向量d分解为m个低维子向量，每个子向量维度为d/m，然后对每个子向量使用k-means进行量化编码。这样可以将每个原始向量从d个浮点数压缩为m个整数索引。

PQ的优势

1. 内存压缩率高：可以将内存占用减少到原来的1/10甚至更低
2. 搜索速度提升：压缩后的数据可以更快速地加载到CPU缓存
3. 支持大规模数据：可以在有限内存中处理数亿甚至数十亿向量
4. 精度可控：通过调整子向量和量化级别控制精度损失
5. 灵活组合：可以与IVF、HNSW等其他索引类型结合使用

环境准备 / 前置知识

必需依赖

# 基础依赖
pip install faiss-cpu numpy
# 或者GPU版本
pip install faiss-gpu numpy
# 可视化依赖
pip install matplotlib seaborn
​

前置知识要求

• 熟悉Python编程和numpy数组操作
• 了解基本的向量化操作和矩阵运算
• 掌握k-means聚类算法的基本概念
• 理解IVF索引的工作原理

分步实战

步骤1：理解PQ向量分解

首先，让我们理解PQ如何将高维向量分解为子向量：

import numpy as np
import faiss

# PQ向量分解示例
def demonstrate_pq_decomposition():
    """演示PQ向量分解过程"""
    d = 128  # 原始向量维度
    m = 16   # 子向量数量
    ksub = 256  # 每个子向量的量化级别
    
    print(f"PQ分解参数：")
    print(f"- 原始维度: {d}")
    print(f"- 子向量数: {m}")
    print(f"- 每个子向量维度: {d//m}")
    print(f"- 量化级别: {ksub}")
    print(f"- 压缩比: {d/(m*np.log2(ksub)):.2f}x")
    
    # 生成示例向量
    np.random.seed(42)
    vector = np.random.random(d).astype('float32')
    print(f"\n原始向量形状: {vector.shape}")
    
    # 向量分解
    sub_vectors = vector.reshape(m, d//m)
    print(f"分解后子向量形状: {sub_vectors.shape}")
    
    # 创建PQ编码器
    pq = faiss.ProductQuantizer(d//m, m, ksub)
    print(f"PQ编码器配置: {pq}")
    
    return vector, sub_vectors, pq

vector, sub_vectors, pq = demonstrate_pq_decomposition()
​

步骤2：PQ训练过程

PQ的训练是对每个子向量分别进行k-means聚类训练：

import time

def train_pq_codebook():
    """训练PQ码本"""
    d = 128
    m = 16
    ksub = 256
    n_samples = 10000  # 训练样本数量
    
    print(f"开始训练PQ码本...")
    print(f"- 训练样本数: {n_samples}")
    print(f"- 向量维度: {d}")
    print(f"- 子向量数: {m}")
    print(f"- 量化级别: {ksub}")
    
    # 生成训练数据
    np.random.seed(42)
    training_data = np.random.random((n_samples, d)).astype('float32')
    
    # 创建PQ编码器
    pq = faiss.ProductQuantizer(d, m, ksub)
    
    # 训练PQ码本
    start_time = time.time()
    pq.train(training_data)
    train_time = time.time() - start_time
    
    print(f"PQ码本训练完成，耗时: {train_time:.2f}秒")
    
    # 分析码本质量
    print(f"码本形状: {pq.codebooks.shape}")
    print(f"每个码本聚类数: {pq.ksub}")
    
    return pq, training_data

pq, training_data = train_pq_codebook()
​

步骤3：PQ编码和解码

现在让我们学习如何对向量进行PQ编码和解码：

def demonstrate_pq_encoding_decoding():
    """演示PQ编码解码过程"""
    d = 128
    m = 16
    ksub = 256
    
    # 创建测试向量
    test_vector = np.random.random(d).astype('float32')
    
    # 创建PQ编码器（如果没有已训练的）
    if 'pq' not in locals():
        pq = faiss.ProductQuantizer(d, m, ksub)
        # 简单训练（实际应用中应该用真实数据训练）
        dummy_data = np.random.random((1000, d)).astype('float32')
        pq.train(dummy_data)
    
    # PQ编码
    codes = pq.compute_codes(test_vector.reshape(1, -1))
    
    print(f"测试向量形状: {test_vector.shape}")
    print(f"编码结果形状: {codes.shape}")
    print(f"编码数值范围: [{codes.min()}, {codes.max()}]")
    print(f"编码内存占用: {codes.nbytes} 字节")
    print(f"原始向量内存占用: {test_vector.nbytes} 字节")
    print(f"压缩比: {test_vector.nbytes / codes.nbytes:.2f}x")
    
    # PQ解码
    reconstructed_vector = pq.decode(codes)
    
    print(f"重构向量形状: {reconstructed_vector.shape}")
    
    # 计算重构误差
    reconstruction_error = np.linalg.norm(test_vector - reconstructed_vector[0])
    relative_error = reconstruction_error / np.linalg.norm(test_vector)
    
    print(f"重构误差: {reconstruction_error:.6f}")
    print(f"相对误差: {relative_error:.6f}")
    print(f"信噪比: {20*np.log10(1-relative_error):.2f} dB")
    
    return test_vector, codes, reconstructed_vector

test_vector, codes, reconstructed_vector = demonstrate_pq_encoding_decoding()
​

步骤4：PQ索引的创建和使用

让我们创建一个完整的PQ索引并进行搜索：

def create_and_use_pq_index():
    """创建和使用PQ索引"""
    d = 128
    n = 50000  # 数据库向量数量
    k = 1000   # 查询向量数量
    m = 16     # 子向量数量
    ksub = 256 # 量化级别
    
    print(f"创建PQ索引...")
    print(f"- 数据库大小: {n}个向量")
    print(f"- 查询大小: {k}个向量")
    print(f"- 向量维度: {d}")
    print(f"- PQ参数: m={m}, ksub={ksub}")
    
    # 生成数据
    np.random.seed(42)
    db_vectors = np.random.random((n, d)).astype('float32')
    query_vectors = np.random.random((k, d)).astype('float32')
    
    # 创建PQ编码器并训练
    pq = faiss.ProductQuantizer(d, m, ksub)
    print("训练PQ编码器...")
    pq.train(db_vectors)
    
    # 创建PQ索引
    index = faiss.IndexPQ(d, m, ksub)
    index.pq = pq
    
    # 添加向量到索引
    print("添加向量到索引...")
    start_time = time.time()
    index.add(db_vectors)
    add_time = time.time() - start_time
    print(f"添加完成，耗时: {add_time:.2f}秒")
    
    # 搜索测试
    print("开始搜索测试...")
    start_time = time.time()
    distances, indices = index.search(query_vectors[:100], 10)
    search_time = time.time() - start_time
    
    print(f"搜索100个向量，耗时: {search_time:.4f}秒")
    print(f"平均搜索时间: {search_time/100*1000:.2f}毫秒/向量")
    print(f"搜索吞吐量: {100/search_time:.2f} 向量/秒")
    
    return index, db_vectors, query_vectors

pq_index, db_vectors, query_vectors = create_and_use_pq_index()
​

步骤5：PQ参数调优

不同PQ参数对精度和压缩比的影响：

def pq_parameter_optimization():
    """PQ参数调优实验"""
    d = 128
    n = 10000
    k = 100
    
    # 测试不同的参数组合
    param_combinations = [
        (8, 256),   # m=8, ksub=256
        (16, 256),  # m=16, ksub=256
        (32, 256),  # m=32, ksub=256
        (16, 128),  # m=16, ksub=128
        (16, 512),  # m=16, ksub=512
    ]
    
    results = []
    
    # 生成基准数据
    np.random.seed(42)
    db_vectors = np.random.random((n, d)).astype('float32')
    query_vectors = np.random.random((k, d)).astype('float32')
    
    print("PQ参数调优实验:")
    print("-" * 60)
    
    for m, ksub in param_combinations:
        print(f"\n测试参数: m={m}, ksub={ksub}")
        
        # 训练PQ
        pq = faiss.ProductQuantizer(d, m, ksub)
        pq.train(db_vectors)
        
        # 创建和测试索引
        index = faiss.IndexPQ(d, m, ksub)
        index.pq = pq
        index.add(db_vectors)
        
        # 搜索测试
        start_time = time.time()
        distances, indices = index.search(query_vectors, 10)
        search_time = time.time() - start_time
        
        # 计算精度（用Flat索引作为基准）
        flat_index = faiss.IndexFlatL2(d)
        flat_index.add(db_vectors)
        true_distances, true_indices = flat_index.search(query_vectors, 10)
        
        # 计算召回率（前1个结果）
        recall = np.mean([1 if indices[i][0] == true_indices[i][0] else 0 for i in range(k)])
        
        # 计算压缩比
        original_size = n * d * 4  # float32, 4字节
        compressed_size = n * m * (np.log2(ksub)/8)  # codes, 每个编码log2(ksub)/8字节
        compression_ratio = original_size / compressed_size
        
        result = {
            'm': m,
            'ksub': ksub,
            'compression_ratio': compression_ratio,
            'search_time': search_time,
            'recall': recall,
            'throughput': k / search_time
        }
        
        results.append(result)
        
        print(f"  压缩比: {compression_ratio:.2f}x")
        print(f"  搜索时间: {search_time:.4f}秒")
        print(f"  召回率: {recall:.3f}")
        print(f"  吞吐量: {k/search_time:.2f} 向量/秒")
    
    return results

pq_results = pq_parameter_optimization()
​

步骤6：IVF+PQ组合索引

在实际应用中，PQ通常与IVF结合使用：

def create_ivf_pq_index():
    """创建IVF+PQ组合索引"""
    d = 128
    n = 100000
    k = 1000
    nlist = 100
    m = 16
    ksub = 256
    
    print(f"创建IVF+PQ组合索引...")
    print(f"- 数据库大小: {n}个向量")
    print(f"- 查询大小: {k}个向量")
    print(f"- 聚类数: {nlist}")
    print(f"- PQ参数: m={m}, ksub={ksub}")
    
    # 生成数据
    np.random.seed(42)
    db_vectors = np.random.random((n, d)).astype('float32')
    query_vectors = np.random.random((k, d)).astype('float32')
    
    # 创建量化器和PQ组件
    quantizer = faiss.IndexFlatL2(d)
    pq = faiss.ProductQuantizer(d, m, ksub)
    
    # 训练PQ码本
    print("训练PQ码本...")
    pq.train(db_vectors)
    
    # 创建IVF+PQ索引
    index = faiss.IndexIVFPQ(quantizer, d, nlist, m, ksub)
    index.pq = pq
    
    # 训练索引
    print("训练IVF索引...")
    start_time = time.time()
    index.train(db_vectors)
    train_time = time.time() - start_time
    print(f"训练完成，耗时: {train_time:.2f}秒")
    
    # 添加向量
    print("添加向量到索引...")
    start_time = time.time()
    index.add(db_vectors)
    add_time = time.time() - start_time
    print(f"添加完成，耗时: {add_time:.2f}秒")
    
    # 测试不同nprobe的性能
    print("\n测试不同nprobe的性能:")
    print("-" * 40)
    
    nprobe_values = [1, 5, 10, 20, 50]
    performance_results = []
    
    for nprobe in nprobe_values:
        index.nprobe = nprobe
        
        # 性能测试
        start_time = time.time()
        distances, indices = index.search(query_vectors[:100], 10)
        search_time = time.time() - start_time
        
        # 精度测试
        flat_index = faiss.IndexFlatL2(d)
        flat_index.add(db_vectors)
        true_distances, true_indices = flat_index.search(query_vectors[:100], 10)
        
        # 计算召回率
        recall = np.mean([1 if indices[i][0] == true_indices[i][0] else 0 for i in range(100)])
        
        throughput = 100 / search_time
        
        performance_results.append({
            'nprobe': nprobe,
            'search_time': search_time,
            'recall': recall,
            'throughput': throughput
        })
        
        print(f"nprobe={nprobe}: 时间={search_time:.4f}s, 召回率={recall:.3f}, 吞吐量={throughput:.0f} 向量/秒")
    
    return index, performance_results

ivf_pq_index, ivf_pq_results = create_ivf_pq_index()
​

完整示例

下面是一个完整的PQ应用示例，包含从参数选择到性能优化的完整流程：

"""
完整的PQ应用示例
适用于内存受限环境的大规模向量搜索
"""
import faiss
import numpy as np
import time
import matplotlib.pyplot as plt
from typing import List, Dict, Tuple

class PQIndex:
    """PQ索引封装类"""
    
    def __init__(self, dimension: int, m: int = 16, ksub: int = 256, 
                 use_ivf: bool = False, nlist: int = 100):
        self.dimension = dimension
        self.m = m
        self.ksub = ksub
        self.use_ivf = use_ivf
        self.nlist = nlist
        
        # 创建PQ编码器
        self.pq = faiss.ProductQuantizer(dimension, m, ksub)
        
        # 创建索引
        if use_ivf:
            self.quantizer = faiss.IndexFlatL2(dimension)
            self.index = faiss.IndexIVFPQ(self.quantizer, dimension, nlist, m, ksub)
        else:
            self.index = faiss.IndexPQ(dimension, m, ksub)
        
        self.index.pq = self.pq
        self.is_trained = False
        self.vector_count = 0
        
    def train(self, data: np.ndarray) -> float:
        """训练索引"""
        if self.is_trained:
            raise ValueError("索引已经训练过了")
            
        print(f"开始训练索引...")
        print(f"- 数据量: {len(data)}")
        print(f"- 维度: {self.dimension}")
        print(f"- PQ参数: m={self.m}, ksub={self.ksub}")
        if self.use_ivf:
            print(f"- IVF参数: nlist={self.nlist}")
        
        start_time = time.time()
        
        # 训练PQ码本
        self.pq.train(data)
        
        # 训练索引
        if self.use_ivf:
            self.index.train(data)
        
        train_time = time.time() - start_time
        self.is_trained = True
        
        print(f"训练完成，耗时: {train_time:.2f}秒")
        return train_time
    
    def add(self, data: np.ndarray) -> float:
        """添加向量到索引"""
        if not self.is_trained:
            raise ValueError("需要先训练索引")
            
        start_time = time.time()
        self.index.add(data)
        add_time = time.time() - start_time
        
        self.vector_count += len(data)
        
        print(f"添加{len(data)}个向量到索引，耗时: {add_time:.2f}秒")
        print(f"索引总向量数: {self.vector_count}")
        
        return add_time
    
    def search(self, query_vectors: np.ndarray, k: int = 10, 
               nprobe: int = None) -> Tuple[np.ndarray, np.ndarray]:
        """搜索相似向量"""
        if nprobe is not None and self.use_ivf:
            self.index.nprobe = nprobe
            
        start_time = time.time()
        distances, indices = self.index.search(query_vectors, k)
        search_time = time.time() - start_time
        
        print(f"搜索{len(query_vectors)}个查询向量，耗时: {search_time:.4f}秒")
        print(f"平均搜索时间: {search_time/len(query_vectors)*1000:.2f}毫秒/向量")
        
        return distances, indices
    
    def evaluate(self, query_vectors: np.ndarray, ground_truth: np.ndarray, 
                 k: int = 10) -> Dict[str, float]:
        """评估索引性能"""
        print("开始性能评估...")
        
        # 设置不同的搜索参数
        if self.use_ivf:
            nprobe_values = [1, 5, 10, 20, 50]
        else:
            nprobe_values = [1]  # PQ索引不需要nprobe
        
        results = []
        
        for nprobe in nprobe_values:
            # 执行搜索
            distances, indices = self.search(query_vectors, k, nprobe)
            
            # 计算精度
            recalls = []
            for i in range(len(query_vectors)):
                # 计算前k个结果的召回率
                relevant_indices = set(indices[i])
                true_relevant = set(ground_truth[i])
                intersection = relevant_indices.intersection(true_relevant)
                recall = len(intersection) / k
                recalls.append(recall)
            
            avg_recall = np.mean(recalls)
            
            result = {
                'nprobe': nprobe,
                'avg_recall': avg_recall,
                'throughput': len(query_vectors) / (sum([r['search_time'] for r in results]) + 
                                                  (time.time() - sum([r['start_time'] for r in results])))
            }
            results.append(result)
        
        return results
    
    def get_memory_usage(self) -> Dict[str, float]:
        """获取内存使用情况"""
        # 估算内存使用
        if self.use_ivf:
            # IVF + PQ内存估算
            ivf_overhead = self.nlist * self.dimension * 4  # 聚类中心
            pq_codebooks = self.m * self.ksub * (self.dimension // self.m) * 4  # PQ码本
            vector_storage = self.vector_count * self.m * (np.log2(self.ksub) / 8)  # 向量存储
            
            total_memory = ivf_overhead + pq_codebooks + vector_storage
        else:
            # 纯PQ内存估算
            pq_codebooks = self.m * self.ksub * (self.dimension // self.m) * 4
            vector_storage = self.vector_count * self.m * (np.log2(self.ksub) / 8)
            total_memory = pq_codebooks + vector_storage
        
        return {
            'total_memory_mb': total_memory / (1024 * 1024),
            'codebooks_memory_mb': pq_codebooks / (1024 * 1024),
            'vectors_memory_mb': vector_storage / (1024 * 1024)
        }

def pq_parameter_sensitivity_study():
    """PQ参数敏感性研究"""
    d = 128
    n = 50000
    k = 1000
    
    print("PQ参数敏感性研究")
    print("=" * 50)
    
    # 生成数据
    np.random.seed(42)
    db_vectors = np.random.random((n, d)).astype('float32')
    query_vectors = np.random.random((k, d)).astype('float32')
    
    # 获取ground truth
    flat_index = faiss.IndexFlatL2(d)
    flat_index.add(db_vectors)
    _, ground_truth = flat_index.search(query_vectors, 10)
    
    # 测试参数组合
    param_combinations = [
        (8, 128),   # 低m, 低ksub
        (8, 256),   # 低m, 中ksub
        (16, 128),  # 中m, 低ksub
        (16, 256),  # 中m, 中ksub (推荐)
        (16, 512),  # 中m, 高ksub
        (32, 128),  # 高m, 低ksub
        (32, 256),  # 高m, 中ksub
    ]
    
    results = []
    
    for m, ksub in param_combinations:
        print(f"\n测试参数组合: m={m}, ksub={ksub}")
        
        # 创建索引
        pq_index = PQIndex(d, m, ksub, use_ivf=False)
        
        # 训练和添加数据
        train_time = pq_index.train(db_vectors)
        add_time = pq_index.add(db_vectors)
        
        # 评估性能
        distances, indices = pq_index.search(query_vectors[:100], 10)
        
        # 计算召回率
        recalls = []
        for i in range(100):
            relevant_indices = set(indices[i])
            true_relevant = set(ground_truth[i])
            intersection = relevant_indices.intersection(true_relevant)
            recall = len(intersection) / 10
            recalls.append(recall)
        
        avg_recall = np.mean(recalls)
        
        # 获取内存使用
        memory_info = pq_index.get_memory_usage()
        
        result = {
            'm': m,
            'ksub': ksub,
            'train_time': train_time,
            'add_time': add_time,
            'avg_recall': avg_recall,
            'memory_mb': memory_info['total_memory_mb'],
            'compression_ratio': (n * d * 4) / memory_info['total_memory_mb'] / (1024 * 1024)
        }
        
        results.append(result)
        
        print(f"  训练时间: {train_time:.2f}秒")
        print(f"  添加时间: {add_time:.2f}秒")
        print(f"  平均召回率: {avg_recall:.3f}")
        print(f"  内存使用: {memory_info['total_memory_mb']:.1f}MB")
        print(f"  压缩比: {result['compression_ratio']:.1f}x")
    
    return results

# 运行完整示例
if __name__ == "__main__":
    print("运行完整的PQ应用示例...")
    print("=" * 50)
    
    # 1. 参数敏感性研究
    sensitivity_results = pq_parameter_sensitivity_study()
    
    # 2. 推荐参数验证
    print("\n推荐参数验证:")
    best_result = max(sensitivity_results, key=lambda x: x['avg_recall'])
    print(f"最佳参数组合: m={best_result['m']}, ksub={best_result['ksub']}")
    print(f"召回率: {best_result['avg_recall']:.3f}")
    print(f"内存使用: {best_result['memory_mb']:.1f}MB")
    print(f"压缩比: {best_result['compression_ratio']:.0f}x")
    
    # 3. 实际应用建议
    print("\n实际应用建议:")
    print("- 对于中等精度要求: m=16, ksub=256 是很好的平衡")
    print("- 对于高精度要求: m=16, ksub=512 或 m=32, ksub=256")
    print("- 对于内存极度受限: m=8, ksub=128 (但精度较低)")
    print("- 建议在实际数据上测试参数效果")
​

常见问题 FAQ

Q1：PQ技术的精度损失有多大？

A：PQ的精度损失主要取决于参数设置：

• **m=16, ksub=256**：通常能保持90%+的召回率，信噪比约20-25dB
• **m=16, ksub=128**：召回率降至80-90%，信噪比约15-20dB
• **m=8, ksub=256**：召回率85-95%，信噪比约18-22dB
• **m=32, ksub=128**：召回率90-95%，信噪比约20-25dB

经验法则：m越大、ksub越大，精度越高，但内存使用也越多。建议在实际数据上测试找到精度-压缩比的平衡点。

Q2：PQ与IVF结合使用有什么优势？

A：PQ与IVF结合使用的主要优势：

1. 双重加速：IVF减少搜索空间，PQ减少内存访问
2. 内存效率：PQ大幅减少内存占用，IVF支持分桶加载
3. 精度可控：通过nprobe控制精度，通过PQ参数压缩比
4. 适用性广：适合从百万到十亿级别的数据集
5. 性能平衡：在有限内存下实现较好的搜索性能

典型配置：IVF(nlist=100-1000) + PQ(m=16-32, ksub=256-512)

Q3：什么时候应该使用纯PQ而不是IVF+PQ？

A：以下情况适合使用纯PQ索引：

1. 数据集较小（<10万向量）：IVF的开销可能不必要
2. 查询频率极高：避免IVF的额外聚类计算
3. 内存极其受限：需要最大程度的压缩
4. 数据分布均匀：不需要聚类优化
5. 实时要求高：减少计算步骤

但对于大多数大规模应用，IVF+PQ是更好的选择。

Q4：如何选择合适的m和ksub参数？

A：参数选择建议：

• m（子向量数）：通常选择8-32

  • 高维数据（>256维）：使用较大的m（24-32）
  • 低维数据（<128维）：使用较小的m（8-16）
  • 经验：m ≈ sqrt(dimension) 是一个不错的起点

• ksub（量化级别）：通常选择128-512

  • 高精度要求：ksub=512或更高
  • 中等精度：ksub=256（推荐平衡点）
  • 低精度要求：ksub=128（但精度损失较大）

最佳实践与避坑

实践1：PQ参数调优策略

1. 从基础参数开始：使用m=16, ksub=256作为起点
2. 逐步调整优化：根据精度和内存需求调整参数
3. 监控性能指标：关注召回率、搜索时间和内存使用
4. 实际数据验证：在实际数据上测试参数效果

坑点1：训练数据质量不佳

问题描述：训练数据质量差导致码本质量不佳
解决方案：确保训练数据具有代表性，覆盖数据分布的各个区域

坑点2：压缩过度导致精度损失

问题描述：过度压缩导致搜索精度显著下降
解决方案：在精度和压缩比之间找到平衡，必要时增加ksub值

坑点3：忽视维度影响

问题描述：不同维度下最优参数差异很大
解决方案：根据具体维度调整参数，高维数据需要更大的m值

本节小结

本节深入探讨了PQ乘积量化技术的原理和应用，包括：

1. 核心原理：向量分解和独立量化实现大幅压缩
2. 关键技术：子向量分解、k-means量化、编码解码
3. 性能特点：压缩比10-100倍，精度可控，搜索加速
4. 应用场景：内存受限环境的大规模向量搜索
5. 优化策略：参数调优、IVF组合、性能监控

通过掌握PQ技术，我们可以在有限的内存资源下处理超大规模向量数据，为实际应用提供高效的相似性搜索解决方案。

下一节将继续介绍索引构建流程与优化技术，完善我们对FAISS索引构建的全面理解。

延伸阅读

• FAISS官方文档 - PQ技术详解
• 向量量化技术综述
• 大规模向量搜索中的压缩技术

关键词：乘积量化, PQ, 向量压缩, 内存优化, 量化编码, FAISS
难度：进阶
预计阅读：30分钟