使用向量检索非结构化数据

HNSW

HNSW通过IndexHNSWFlat实现，适用于对性能和召回率有高要求的场景。

核心参数

// HNSW索引创建示例，请将<my-hnsw-index>替换为您的实际的索引名称
PUT /<my-hnsw-index>
{
  "settings": {
    "index": { 
      "knn": true 
    } 
  },
  "mappings": {
    "properties": {
      "<my_vector_field>": {//请将<my_vector_field>替换为您的实际的字段名称
        "type": "knn_vector",
        "dimension": 128,
        "data_type": "float",
        "method": {
          "name": "hnsw",
          "engine": "faiss",
          "space_type": "l2",
          "parameters": {
            "m": 16,
            "ef_construction": 256,
            "ef_search": 512 // ef_search通常在查询时指定，此处为示例
          }
        }
      }
    }
  }
}

IVF

IVF通过IndexIVFFlat实现，适用于内存受限的超大规模数据集场景。

核心参数

// IVF索引创建示例，请将<my-ivf-index>替换为您的实际的索引名称
PUT /<my-ivf-index>
{
  "settings": {
    "index": { 
      "knn": true 
    } 
  },
  "mappings": {
    "properties": {
      "<my_vector_field>": {// 请将<my_vector_field>替换为您的实际的字段名称
        "type": "knn_vector",
        "dimension": 4,
        "data_type": "byte",
        "method": {
          "name": "ivf",
          "engine": "faiss",
          "space_type": "l2",
          "parameters": {
            "nlist": 1024,
            "nprobes": 10 // nprobes通常在查询时指定，此处为示例
          }
        }
      }
    }
  }
}

标量量化（SQ）

• 工作原理：将标准的32位浮点（float）向量转换为16位浮点（fp16）向量进行存储，使内存占用直接减半。在计算距离时，会解码回32位进行，因此对精度的影响非常小。

• 内存估算：

  • 公式：内存 (GB) ≈ 1.1 * (2 * dimension + 8 * m) * num_vectors / 1024^3

  • 参数详解：

    • dimension：向量的维度。

    • m：HNSW索引中的m参数，即每个节点的最大邻居数。

    • num_vectors：向量总数。

    • 1.1：约10%的系统开销系数。

  • 示例：假设您有 100 万个向量，每个向量的维度为 256，每个向量的维度m为 16。内存需求可以估算如下：1.1 * (2 * 256 + 8 * 16) * 1,000,000 ~= 0.656 GB

• 使用示例：

  // HNSW + 标量量化(SQ)示例
  PUT /<my-sq-index>
  {
    "settings": {
      "index": { 
        "knn": true 
      }
    },
    "mappings": {
      "properties": {
        "<my_vector_field>": {
          "type": "knn_vector",
          "dimension": 128,
          "method": {
            "name": "hnsw",
            "engine": "faiss",
            "parameters": {
              "m": 16,
              "ef_construction": 256,
              "encoder": {// 启用SQ
                "name": "fp16"
               } 
            }
          }
        }
      }
    }
  }
  

二值量化（BQ）

• 工作原理：将浮点向量的每个维度压缩为二进制位（0和1）进行存储，从而实现极高的压缩率。训练过程在索引构建时自动完成。

• 内存估算：

  • 公式：内存 (GB) ≈ 1.1 * ((dimension * bits / 8) + 8 * m) * num_vectors / 1024^3

  • 参数详解：

    • dimension：向量的维度。

    • bits：每个维度用多少个二进制位表示，可选值为1,2,4。bits越小，压缩率越高，但精度损失越大。

    • m：HNSW索引中的m参数。

    • num_vectors：向量总数。

  • 示例：假设您有100万个向量，每个向量的维度为256，每个向量的维度m为16。以下部分提供了各种压缩值对内存需求的估算。

    • 1位量化（32倍压缩）：在1位量化中，每个维度用1位表示，相当于32倍压缩系数。内存需求可以估算如下：1.1 * ((256 * 1 / 8) + 8 * 16) * 1,000,000 ~= 0.176 GB

    • 2位量化（16倍压缩）：在2位量化中，每个维度用2位表示，相当于16倍压缩系数。内存需求可以估算如下：1.1 * ((256 * 2 / 8) + 8 * 16) * 1,000,000 ~= 0.211 GB

• 使用示例：

  // HNSW + 二值量化(BQ)示例
  PUT /<my-bq-index>
  {
    "settings" : { 
      "index": { 
        "knn": true 
      } 
    },
    "mappings": {
      "properties": {
        "<my_vector_field>": {
          "type": "knn_vector",
          "dimension": 128,
          "method": {
              "name": "hnsw",
              "engine": "faiss",
              "parameters": {
                "m": 16,
                "ef_construction": 512,
                "encoder": {
                  "name": "binary",
                  "parameters": {// 启用BQ，使用1位量化
                    "bits": 1 
                  }
                }
              }
          }
        }
      }
    }
  }
  

乘积量化（PQ）

PQ是一种先进的向量压缩技术，它能实现比SQ或BQ更高的压缩率，但代价是需要一个独立的训练步骤来构建压缩模型。

• 工作原理：

  1. 向量切分：首先，将一个原始的高维向量（例如256维）切分为m个等长的低维子向量。例如，将256维向量按m=32切分，会得到32个8维的子向量。

  2. 码本训练：接着，系统会为每一个子向量空间独立学习一个“码本”（Codebook）。这个码本包含2^code_size个中心点（也称质心）。这个训练过程通常使用K-均值聚类算法完成。

  3. 量化编码：训练完成后，在对新向量进行编码时，其每个子向量不再存储原始的浮点值，而是被替换为该子向量空间码本中距离它最近的那个中心点的ID。如果code_size为8，则ID范围是0-255，正好用1个字节存储。

  4. 最终结果：一个原始向量就被转换成了一组中心点ID的序列，从而实现了极高的压缩。

• 训练要求：PQ的性能严重依赖于训练数据的质量。您必须提供一组与您最终要检索的数据分布相似的向量来进行训练。

  • 训练数据来源：可以是您要索引的向量数据的子集。

  • 建议的训练数据量：

    • 结合HNSW使用时：建议训练向量数量为 2^code_size * 1000。

    • 结合IVF使用时：建议训练向量数量为 max(1000 * nlist, 2^code_size * 1000)。

• 内存估算：以HNSW+PQ为例。因为当HNSW与PQ结合使用时，其内存计算公式较为复杂，因为它包含了压缩向量、HNSW图结构和PQ码本三部分的开销。

  • 公式：内存 (字节) ≈ 1.1 * ( (per_vector_cost) * num_vectors + (codebook_cost) )

    • per_vector_cost = (pq_code_size / 8 * pq_m) + 24 + (8 * hnsw_m)

    • codebook_cost = num_segments * (2^pq_code_size) * 4 * dimension

  • 参数详解：

    • num_vectors：向量总数。

    • dimension：原始向量的维度。

    • pq_m：向量切分的段数。dimension必须能被pq_m整除。

    • pq_code_size：每个子向量码本的大小，以比特为单位。通常为8。

    • hnsw_m：HNSW索引中的m参数，即每个节点的最大邻居数。

    • num_segments：一个底层技术参数，代表索引被分成的段数。在估算时可以按集群分片数或一个保守值（如100）来计算。

    • 1.1：约10%的系统开销系数。

    • 24和8：HNSW图结构中每个节点的固定开销和指针开销。

    • 4：代表码本中的中心点坐标使用32位浮点数（4字节）存储。

  • 示例：假设您有100万个向量（num_vectors），每个向量的维度（dimension）为256，每个向量切分段数（pq_m）为32，每个子向量码本的大小（pq_code_size）为8，HNSW索引的m参数为16，num_segments为100。

    1. 计算单个向量的开销（per_vector_cost）：

       1. 压缩后向量大小 = pq_code_size / 8 * pq_m = 8 / 8 * 32 = 32字节。

       2. HNSW图开销 = 24 + 8 * hnsw_m = 24 + 8 * 16 = 152字节。

       3. per_vector_cost = 32 + 152 = 184字节

    2. 计算码本的总开销（codebook_cost）：

       1. codebook_cost = num_segments * (2^pq_code_size) * 4 * dimension。

       2. codebook_cost = 100 * (2^8) * 4 * 256 = 100 * 256 * 4 * 256 = 26,214,400字节。

    3. 计算总内存：

       1. 总内存 ≈ 1.1 * （per_vector_cost * num_vectors + codebook_cost）

       2. 总内存 ≈ 1.1 * （184 * 1,000,000 + 26,214,400） ≈ 231,235,840 字节 ≈ 0.215 GB

• 使用示例：

  // HNSW + 乘积量化(PQ)示例
  PUT /<my-hnswpq-index>
  {
    "settings" : { 
      "index": { 
        "knn": true 
      } 
    },
    "mappings": {
      "properties": {
        "<my_vector_field>": {
          "type": "knn_vector",
          "dimension": 128, // 维度必须能被 m 整除
          "method": {
              "name": "hnsw",
              "engine": "faiss",
              "parameters": {
                "m": 16, // HNSW的m参数
                "ef_construction": 512,
                "encoder": {
                  "name": "pq",
                  "parameters": {
                    "m": 4, // PQ的m参数：将128维切为4段32维
                    "code_size": 8
                  }
                }
              }
          }
        }
      }
    }
  }

基于磁盘的向量存储

• 工作原理：基于磁盘的向量搜索是利用内部的量化技术压缩向量，并将主要的图结构存储在磁盘上，而不是堆内存中。这种内存优化可以大幅节省内存，但搜索延迟会略有增加，同时仍能保持较高的召回率。

• 内存估算：无固定公式。实际物理内存占用由操作系统根据访问模式动态管理。

• 使用示例：

  // 基于磁盘存储的示例
  PUT /<my-ondisk-index>
  {
    "settings" : { 
      "index": {
         "knn": true 
      } 
    },
    "mappings": {
      "properties": {
        "<my_vector_field>": {
          "type": "knn_vector",
          "dimension": 128,
          "mode": "on_disk" // 启用基于磁盘的模式
        }
      }
    }
  }