让KNN Imputer在大数据集上狂飙：性能优化策略深度解析

2025/3/27 14:28:53 18 0 0 0

瓶颈在哪？拆解 KNN Imputer 的核心计算

优化策略一：近似最近邻（ANN）—— 牺牲一点精度，换取巨大速度提升

优化策略二：并行计算 —— 让多个 CPU 核心一起上

优化策略三：数据采样/子集化 —— 少即是多？

优化策略四：维度约减 —— 降低距离计算的成本

优化策略五：算法本身的调整

实践工作流：如何选择和组合策略？

结语

处理数据时，缺失值是个绕不开的坎。各种插补方法里，KNN Imputer 因其非参数、能处理混合数据类型的特性而备受青睐。简单来说，它用特征空间中最近的 K 个邻居的（加权）平均值来填充缺失值。听起来很美好，对吧？

但现实是骨感的。当你的数据集从几万行膨胀到几百万、甚至上千万行时，你会发现 Scikit-learn 里的 KNNImputer 跑得像老牛拉车，甚至直接爆掉内存。为什么？因为它本质上需要在样本间计算距离并找到最近邻，这个操作的计算复杂度相当高，尤其是在数据量 N 和特征维度 D 都很大的时候。

标准的 KNNImputer 在查找最近邻时，最坏情况下复杂度可能接近 O(N_missing * N_complete * D)，其中 N_missing 是有缺失值的样本数，N_complete 是用于查找邻居的完整样本数（或者所有样本数，取决于实现），D 是用于计算距离的特征维度。当 N 巨大时，这个计算量是灾难性的。

别灰心！这不意味着 KNN Imputer 就废了。今天我们就来深入扒一扒，有哪些“黑科技”能给 KNN Imputer 装上涡轮增压，让它在大数据集上也能跑得飞起。

瓶颈在哪？拆解 KNN Imputer 的核心计算

优化之前，先搞清楚慢在哪。KNN Imputer 的核心就两步：

距离计算：对于每个需要插补的样本点（我们称之为查询点），计算它与其他所有（或部分）样本点（我们称之为候选点）之间的距离。距离度量通常是欧氏距离或曼哈顿距离等。
最近邻搜索：根据计算出的距离，找出离查询点最近的 K 个候选点。
值插补：使用这 K 个邻居对应特征的值（通常是加权平均）来填充查询点的缺失值。

在大数据集场景下，计算所有样本对之间的距离（步骤1）和从中找出 K 个最近邻（步骤2）是主要的性能瓶颈。尤其是步骤 2，如果采用暴力搜索（Brute-force search），那效率可想而知。

Scikit-learn 的实现会尝试使用 KDTree 或 BallTree 来加速最近邻搜索（当 algorithm 参数设为 'auto', 'kd_tree', 或 'ball_tree' 时）。这些基于树的数据结构在低维数据上表现不错，但在高维（比如几十维以上）时，它们的性能会急剧下降，甚至不如暴力搜索，这就是所谓的“维度诅咒”。

所以，优化的关键就在于如何更快、更省地完成距离计算和最近邻搜索。

优化策略一：近似最近邻（ANN）—— 牺牲一点精度，换取巨大速度提升

既然精确找到 K 个最近邻代价太大，那找 K 个“差不多近”的邻居行不行？这就是近似最近邻（Approximate Nearest Neighbor, ANN）的核心思想。它允许在搜索结果中存在少量误差，以换取查询速度的指数级提升。

想象一下，你不是大海捞针，而是先用声纳大致确定鱼群位置，再在那片区域撒网。ANN 就是那个声纳。

目前有很多成熟的 ANN 库：

Annoy (Approximate Nearest Neighbors Oh Yeah)：由 Spotify 开源，基于随机投影树构建索引，简单易用。
NMSLIB (Non-Metric Space Library)：支持多种 ANN 算法，如 HNSW（Hierarchical Navigable Small World graphs），性能通常非常好。
Faiss (Facebook AI Similarity Search)：由 Facebook AI 开源，功能强大，支持 GPU 加速，提供了多种索引类型（如 IVF、HNSW），是目前业界领先的库之一。
ScaNN (Scalable Nearest Neighbors)：Google 开源，专注于向量相似性搜索的性能和准确性。

如何将 ANN 应用于 KNN Imputer？

思路是这样的：

构建索引：选择一个 ANN 库（比如 Faiss）。将你的数据中 没有缺失值的部分（或者用于计算距离的特征列）构建成 ANN 索引。这一步是一次性的预处理，虽然也需要时间，但后续查询会非常快。
查询邻居：对于每个包含缺失值的样本，提取其 非缺失 的特征构成查询向量。使用这个查询向量在 ANN 索引中快速搜索 K 个（或稍多于 K 个，以备筛选）近似最近邻的索引。
获取邻居数据：根据返回的邻居索引，从原始数据集中获取这些邻居样本。
执行插补：基于这些近似邻居，计算缺失值的插补值（例如，加权平均）。

代码示例（使用 Faiss 的概念性 Python 代码）

 import faiss
import numpy as np
from sklearn.preprocessing import StandardScaler
 
# 假设 data 是你的 NumPy 数组，包含缺失值 (np.nan)
# features_for_distance 是用于计算距离的特征列索引
 
# 0. 数据准备
n_samples, n_features = data.shape
scaler = StandardScaler() # 标准化通常是必要的
data_scaled = scaler.fit_transform(data)
 
# 1. 准备索引数据和查询数据
missing_mask = np.isnan(data_scaled).any(axis=1)
complete_indices = np.where(~missing_mask)[0]
missing_indices = np.where(missing_mask)[0]
 
# 只使用完整样本构建索引
data_for_index = data_scaled[complete_indices][:, features_for_distance]
# 确保数据是 float32，Faiss 通常要求
data_for_index = data_for_index.astype('float32') 
 
d = data_for_index.shape[1] # 特征维度
 
# 2. 构建 Faiss 索引 (以 IndexFlatL2 为例，最简单的精确索引，替换为 ANN 索引如 IndexIVFFlat 或 IndexHNSWFlat)
# index = faiss.IndexFlatL2(d) 
 
# 使用 HNSW 索引
nlist = 100 # 聚类中心数量，需要调优
quantizer = faiss.IndexFlatL2(d) # 通常用 FlatL2 作为量化器
index = faiss.IndexHNSWFlat(d, 32) # 32 是每个节点邻居数，需要调优
# index = faiss.IndexIVFFlat(quantizer, d, nlist, faiss.METRIC_L2)
 
# print("Training index...") # IVFFlat 需要训练
# index.train(data_for_index)
 
print("Adding vectors to index...")
index.add(data_for_index)
 
# 3. 对每个缺失样本进行查询和插补
k = 5 # 需要的邻居数量
data_imputed = data_scaled.copy()
 
for i in missing_indices:
    query_vector = data_scaled[i, features_for_distance]
    # 注意：这里简化了处理，实际中查询向量本身可能也有缺失
    # 需要处理查询向量中的缺失值，例如只用非缺失维度，或用均值/中位数临时填充
    # 假设 query_vector 已经处理好，并且是 float32
    query_vector_filled = np.nan_to_num(query_vector.reshape(1, -1).astype('float32'), nan=np.nanmean(query_vector))
 
    # 4. 查询 ANN 索引
    # Faiss 查询返回距离 D 和邻居索引 I
    distances, neighbor_indices_in_complete = index.search(query_vector_filled, k)
    
    # 将索引映射回原始数据的完整样本索引
    original_neighbor_indices = complete_indices[neighbor_indices_in_complete[0]]
 
    # 5. 执行插补 (对样本 i 的所有缺失特征)
    for j in range(n_features):
        if np.isnan(data_imputed[i, j]):
            neighbor_values = data_scaled[original_neighbor_indices, j]
            # 过滤掉邻居中也缺失该特征的情况
            valid_neighbor_values = neighbor_values[~np.isnan(neighbor_values)]
            
            if len(valid_neighbor_values) > 0:
                # 可以实现加权平均等更复杂的逻辑
                # 这里用简单平均值
                data_imputed[i, j] = np.mean(valid_neighbor_values)
            else:
                # 如果所有邻居在这个特征上也缺失，可能需要后备策略，比如用全局均值/中位数
                data_imputed[i, j] = np.nanmean(data_scaled[:, j]) 
 
# 6. 反标准化（如果需要原始尺度）
# data_final = scaler.inverse_transform(data_imputed)
 
print("Imputation complete.")

注意： 上面的代码是一个高度简化的概念证明。实际应用中需要考虑：

查询向量缺失值处理：当查询样本本身在用于距离计算的特征上也有缺失时，如何处理？可以只用非缺失维度计算（如果 ANN 库支持），或者用某种简单方法（如均值）临时填充查询向量。
特征选择：哪些特征用于构建索引和计算距离？这会影响插补质量和性能。
ANN 参数调优：ANN 库通常有多个参数（如 Faiss 的 nlist, nprobe, HNSW 的 M, efConstruction, efSearch）需要仔细调整，以平衡索引构建时间、内存占用、查询速度和准确率。
混合数据类型：如果数据包含分类特征，需要先进行编码（如 One-Hot Encoding），但这会增加维度。或者使用支持分类特征距离的特定方法。

权衡：

优点：查询速度快几个数量级，内存占用可能更低（取决于索引类型）。
缺点：结果是近似的，插补精度可能略有下降。索引构建需要额外时间和内存。参数调优需要经验。

优化策略二：并行计算 —— 让多个 CPU 核心一起上

KNN Imputer 的计算密集性使其非常适合并行化。很多计算步骤可以分解成独立的任务，分配给不同的 CPU 核心（甚至不同的机器）同时处理。

1. 利用 Scikit-learn 内置的并行化 (n_jobs)

KNNImputer 类本身就有一个 n_jobs 参数。当你设置 n_jobs=-1 时，它会尝试使用所有可用的 CPU 核心。这通常是通过 joblib 库实现的。

 from sklearn.impute import KNNImputer
import numpy as np
 
# 假设 data 是你的 NumPy 数组
 
imputer = KNNImputer(n_neighbors=5, n_jobs=-1) # 使用所有核心
data_imputed = imputer.fit_transform(data)

它是如何并行化的？通常 joblib 会在计算距离矩阵或处理独立的插补任务时进行并行。效果取决于你的数据大小、CPU 核心数以及任务分解的开销。对于非常大的数据集，仅靠 n_jobs 可能仍然不够，因为它通常是单机多核并行，内存瓶颈依然存在。

2. 使用 Dask 或 Spark 进行分布式计算

当数据大到单机内存无法容纳，或者需要跨多台机器进行计算时，就需要 Dask 或 Spark 这样的分布式计算框架了。

Dask：与 Pandas 和 NumPy API 类似，可以方便地将现有代码扩展到分布式环境。Dask DataFrame 可以将大型数据集分割成多个小的 Pandas DataFrame，然后在多个核心或多台机器上并行处理。
- 你可以用 Dask 来并行化距离计算。例如，将数据块广播到各个 worker，每个 worker 计算部分距离，然后聚合结果。
- 实现一个基于 Dask 的 KNN Imputer 需要更多工作，可能需要利用 dask.delayed 或 dask_ml 中的工具（如果可用）。
Spark：专为大规模数据处理设计。可以使用 Spark MLlib（虽然它没有直接的 KNN Imputer，但有 KNN 算法可以借鉴）或者基于 RDD/DataFrame API 手动实现分布式 KNN 插补。
- 基本思路类似：将数据分区，在每个分区上计算局部距离或查找候选邻居，然后通过 shuffle 操作聚合全局最近邻。
- 这通常需要对 Spark 编程模型有深入理解，实现复杂度较高。

代码示例（使用 Dask 的概念性思路）

 import dask.array as da
import numpy as np
from sklearn.metrics import pairwise_distances
 
# 假设 dask_data 是一个 Dask Array
# k = 5
 
# 这是一个非常简化的例子，实际分布式 KNN 需要更复杂的逻辑
# 例如，处理块边界、高效的全局 K 近邻查找 (可能需要近似算法)
 
# 概念：计算某个块与所有其他块的距离
def process_chunk(chunk, all_data, k):
    # 计算 chunk 中样本与 all_data 的距离
    distances = pairwise_distances(chunk, all_data, metric='nan_euclidean') # 使用能处理 NaN 的距离
    
    # 对 chunk 中的每个样本找到 k 个最近邻
    neighbors = np.argsort(distances, axis=1)[:, :k]
    
    imputed_chunk = chunk.copy()
    # ... 执行插补逻辑 ...
    return imputed_chunk
 
# 需要一个机制来有效地将 all_data 分发或共享
# 并行处理每个块
# result = dask_data.map_blocks(process_chunk, all_data=dask_data, k=k, dtype=dask_data.dtype).compute()
 
# 注意：上面的 pairwise_distances 可能还是会产生巨大的中间距离矩阵
# 实际分布式实现通常避免显式计算完整距离矩阵
# 可能会使用基于树的方法、LSH 或其他分布式近邻搜索策略

权衡：

优点：能处理单机内存无法容纳的数据，显著缩短计算时间（如果并行化做得好）。
缺点：n_jobs 受限于单机资源。Dask/Spark 增加了系统复杂性，需要额外的基础设施和编程知识。并行/分布式计算有通信开销，不是任务越多越好。调试分布式程序更困难。

优化策略三：数据采样/子集化 —— 少即是多？

如果完整数据集实在太大，导致连构建 ANN 索引或并行计算都难以承受，可以考虑一个简单粗暴但有时有效的方法：只用数据的一个子集来寻找邻居。

思路：

从完整数据集中（特别是没有缺失值的样本中）抽取一个代表性的样本子集。
对于需要插补的样本，只在这个样本子集中搜索 K 个最近邻。

采样方法：

随机采样：最简单，但可能丢失数据的某些结构。
分层采样：如果数据有重要的类别或分层结构，可以按比例从每层中采样，以保持样本的代表性。

如何选择样本大小？
这是一个经验问题，没有固定答案。需要根据数据特性、可接受的精度损失和计算资源来权衡。可以从小样本开始尝试，逐步增加，观察插补质量和性能的变化。

结合使用：
采样可以与其他方法结合。例如：

对一个较大的样本子集构建 ANN 索引。
使用 Dask/Spark 对采样后的邻居搜索和插补过程进行并行化。

权衡：

优点：显著降低计算量和内存需求，实现简单。
缺点：插补精度几乎肯定会下降，因为邻居搜索空间变小了。如果样本子集不能很好地代表整个数据集，可能引入偏差。需要仔细验证插补效果。

优化策略四：维度约减 —— 降低距离计算的成本

“维度诅咒”不仅影响基于树的搜索算法，也让高维空间中的距离度量本身变得不那么可靠，并且计算成本更高（距离计算复杂度与维度 D 相关）。

因此，在运行 KNN Imputer 之前，可以考虑先对用于计算距离的特征进行维度约减。

常用技术：

PCA (Principal Component Analysis)：线性降维，寻找数据方差最大的方向。
UMAP (Uniform Manifold Approximation and Projection) / t-SNE (t-distributed Stochastic Neighbor Embedding)：非线性降维，擅长保留数据的局部结构（但 t-SNE 通常不用于降维后还原数据）。UMAP 通常比 t-SNE 更快，且能更好地保留全局结构。
特征选择 (Feature Selection)：直接移除不重要或冗余的特征。

应用方法：

选择用于计算距离的特征。
对这些特征应用降维技术（如 PCA），得到一个低维表示。
在降维后的空间中运行 KNN Imputer（计算距离和寻找邻居都在低维空间进行）。
插补完成后，如果需要，可以将数据映射回原始维度（对于 PCA 是可能的，对于 UMAP/t-SNE 则不直接）。不过，插补通常是在原始特征空间中进行的，只是邻居是在降维空间找到的。

权衡：

优点：降低距离计算和邻居搜索的复杂度，可能缓解维度诅咒问题。
缺点：降维可能导致信息损失，影响插补精度。选择合适的降维方法和目标维度需要实验。增加了预处理步骤。

优化策略五：算法本身的调整

除了上述“大招”，还有一些内置的或算法层面的调整可以考虑：

距离度量 (metric)：KNNImputer 支持不同的距离度量，如 'nan_euclidean'（默认，能处理缺失值间的距离）、'manhattan' 等。虽然对性能影响通常不如 ANN 或并行化大，但可以尝试。'nan_euclidean' 计算相对复杂些。
邻居权重 (weights)：'uniform'（所有邻居权重相同）或 'distance'（距离越近权重越大）。'distance' 需要额外计算权重，但通常对插补质量有益。性能差异一般不大。
精确搜索算法 (algorithm)：如前所述，'kd_tree' 和 'ball_tree' 在高维下性能不佳。如果 Scikit-learn 版本允许，并且你确定维度不高，可以显式指定它们。但对于大数据集和高维数据，暴力搜索（'brute'）或结合 ANN 才是方向。

实践工作流：如何选择和组合策略？

面对这么多选择，该如何下手？这是一个典型的工程问题，需要根据具体情况迭代优化。

基线测试：首先，尝试使用 Scikit-learn 的 KNNImputer，设置 n_jobs=-1。测量其运行时间和内存消耗。如果可以接受，那就没必要过度优化。
分析瓶颈：如果基线太慢或 OOM (Out of Memory)，分析是计算瓶颈还是内存瓶颈？数据维度高不高？
低成本优化优先：
- 如果维度很高，尝试维度约减 (PCA)，看看是否能在可接受的信息损失下提升性能。
- 如果 n_jobs 没有用满 CPU 或者效果不明显，检查数据类型（确保是 float）和是否有其他资源瓶颈。
引入 ANN：如果计算瓶颈明显，并且可以接受一点精度损失，ANN 是最有潜力的优化方向。选择一个库（如 Faiss），实现基于 ANN 的邻居查找。仔细进行参数调优。
考虑采样：如果数据量巨大，即使 ANN 也面临索引构建或内存压力，可以尝试数据采样。将其与 ANN 结合（在样本子集上构建 ANN 索引）。
上分布式：如果单机内存无论如何都装不下数据（即使采样后），或者需要进一步压榨计算时间，考虑使用 Dask 或 Spark。这通常是最后的手段，因为复杂度最高。
持续监控与评估：
- 性能指标：记录每种策略下的运行时间、峰值内存使用。
- 插补质量：如何评估插补效果？
  - 人造缺失值：在完整数据上人为制造一些缺失值，用模型插补后，与真实值比较（如计算 RMSE）。
  - 下游任务性能：最终目的是服务于某个模型或分析任务。比较使用不同插补策略的数据在下游任务（如分类、回归）上的表现。
  - 数据分布：比较插补后数据的分布与原始数据（或完整部分）的分布是否一致。

结语

KNN Imputer 是一个强大的工具，但其性能扩展性确实是痛点。幸运的是，我们有很多武器库来应对挑战：从近似计算（ANN）到并行/分布式处理（n_jobs, Dask, Spark），再到数据简化（采样、降维）。

没有万能的银弹。最好的策略总是取决于你的具体数据规模、维度、硬件资源、可接受的精度损失以及你愿意投入的工程复杂度。关键在于理解瓶颈所在，了解各种优化技术的原理和权衡，然后大胆地去实验、测量和迭代。

希望这篇深度解析能帮助你在处理大规模数据集时，不再对 KNN Imputer 望而却步，让它真正成为你数据清洗工具箱里的利器！下次遇到性能问题时，你知道该从哪里下手了。

代码优化师老王 KNN Imputer 性能优化大数据处理

	import faiss
	import numpy as np
	from sklearn.preprocessing import StandardScaler

	# 假设 data 是你的 NumPy 数组，包含缺失值 (np.nan)
	# features_for_distance 是用于计算距离的特征列索引

	# 0. 数据准备
	n_samples, n_features = data.shape
	scaler = StandardScaler() # 标准化通常是必要的
	data_scaled = scaler.fit_transform(data)

	# 1. 准备索引数据和查询数据
	missing_mask = np.isnan(data_scaled).any(axis=1)
	complete_indices = np.where(~missing_mask)[0]
	missing_indices = np.where(missing_mask)[0]

	# 只使用完整样本构建索引
	data_for_index = data_scaled[complete_indices][:, features_for_distance]
	# 确保数据是 float32，Faiss 通常要求
	data_for_index = data_for_index.astype('float32')

	d = data_for_index.shape[1] # 特征维度

	# 2. 构建 Faiss 索引 (以 IndexFlatL2 为例，最简单的精确索引，替换为 ANN 索引如 IndexIVFFlat 或 IndexHNSWFlat)
	# index = faiss.IndexFlatL2(d)

	# 使用 HNSW 索引
	nlist = 100 # 聚类中心数量，需要调优
	quantizer = faiss.IndexFlatL2(d) # 通常用 FlatL2 作为量化器
	index = faiss.IndexHNSWFlat(d, 32) # 32 是每个节点邻居数，需要调优
	# index = faiss.IndexIVFFlat(quantizer, d, nlist, faiss.METRIC_L2)

	# print("Training index...") # IVFFlat 需要训练
	# index.train(data_for_index)

	print("Adding vectors to index...")
	index.add(data_for_index)

	# 3. 对每个缺失样本进行查询和插补
	k = 5 # 需要的邻居数量
	data_imputed = data_scaled.copy()

	for i in missing_indices:
	query_vector = data_scaled[i, features_for_distance]
	# 注意：这里简化了处理，实际中查询向量本身可能也有缺失
	# 需要处理查询向量中的缺失值，例如只用非缺失维度，或用均值/中位数临时填充
	# 假设 query_vector 已经处理好，并且是 float32
	query_vector_filled = np.nan_to_num(query_vector.reshape(1, -1).astype('float32'), nan=np.nanmean(query_vector))

	# 4. 查询 ANN 索引
	# Faiss 查询返回距离 D 和邻居索引 I
	distances, neighbor_indices_in_complete = index.search(query_vector_filled, k)

	# 将索引映射回原始数据的完整样本索引
	original_neighbor_indices = complete_indices[neighbor_indices_in_complete[0]]

	# 5. 执行插补 (对样本 i 的所有缺失特征)
	for j in range(n_features):
	if np.isnan(data_imputed[i, j]):
	neighbor_values = data_scaled[original_neighbor_indices, j]
	# 过滤掉邻居中也缺失该特征的情况
	valid_neighbor_values = neighbor_values[~np.isnan(neighbor_values)]

	if len(valid_neighbor_values) > 0:
	# 可以实现加权平均等更复杂的逻辑
	# 这里用简单平均值
	data_imputed[i, j] = np.mean(valid_neighbor_values)
	else:
	# 如果所有邻居在这个特征上也缺失，可能需要后备策略，比如用全局均值/中位数
	data_imputed[i, j] = np.nanmean(data_scaled[:, j])

	# 6. 反标准化（如果需要原始尺度）
	# data_final = scaler.inverse_transform(data_imputed)

	print("Imputation complete.")

	from sklearn.impute import KNNImputer
	import numpy as np

	# 假设 data 是你的 NumPy 数组

	imputer = KNNImputer(n_neighbors=5, n_jobs=-1) # 使用所有核心
	data_imputed = imputer.fit_transform(data)

	import dask.array as da
	import numpy as np
	from sklearn.metrics import pairwise_distances

	# 假设 dask_data 是一个 Dask Array
	# k = 5

	# 这是一个非常简化的例子，实际分布式 KNN 需要更复杂的逻辑
	# 例如，处理块边界、高效的全局 K 近邻查找 (可能需要近似算法)

	# 概念：计算某个块与所有其他块的距离
	def process_chunk(chunk, all_data, k):
	# 计算 chunk 中样本与 all_data 的距离
	distances = pairwise_distances(chunk, all_data, metric='nan_euclidean') # 使用能处理 NaN 的距离

	# 对 chunk 中的每个样本找到 k 个最近邻
	neighbors = np.argsort(distances, axis=1)[:, :k]

	imputed_chunk = chunk.copy()
	# ... 执行插补逻辑 ...
	return imputed_chunk

	# 需要一个机制来有效地将 all_data 分发或共享
	# 并行处理每个块
	# result = dask_data.map_blocks(process_chunk, all_data=dask_data, k=k, dtype=dask_data.dtype).compute()

	# 注意：上面的 pairwise_distances 可能还是会产生巨大的中间距离矩阵
	# 实际分布式实现通常避免显式计算完整距离矩阵
	# 可能会使用基于树的方法、LSH 或其他分布式近邻搜索策略

让KNN Imputer在大数据集上狂飙：性能优化策略深度解析

瓶颈在哪？拆解 KNN Imputer 的核心计算

优化策略一：近似最近邻（ANN）—— 牺牲一点精度，换取巨大速度提升

优化策略二：并行计算 —— 让多个 CPU 核心一起上

优化策略三：数据采样/子集化 —— 少即是多？

优化策略四：维度约减 —— 降低距离计算的成本

优化策略五：算法本身的调整

实践工作流：如何选择和组合策略？

结语

瓶颈在哪？拆解 KNN Imputer 的核心计算

优化策略一：近似最近邻（ANN）—— 牺牲一点精度，换取巨大速度提升

优化策略二：并行计算 —— 让多个 CPU 核心一起上

优化策略三：数据采样/子集化 —— 少即是多？

优化策略四：维度约减 —— 降低距离计算的成本

优化策略五：算法本身的调整

实践工作流：如何选择和组合策略？

结语

评论点评