Тип поля плотного вектора

Поиск k ближайших соседей (kNN) находит k ближайших векторов к запросу вектора, измеренных с помощью метрики сходства.

Поля плотных векторов могут использоваться для ранжирования документов в script_score запросах. Это позволяет выполнять поиск k ближайших соседей методом перебора, сканируя все документы и ранжируя их по сходству.

Во многих случаях поиск k ближайших соседей методом перебора недостаточно эффективен. По этой причине тип dense_vector поддерживает индексирование векторов в специализированную структуру данных для поддержки быстрого поиска k ближайших соседей с помощью параметра knn в API поиска.

Неотображенные массивы элементов с плавающей запятой размером от 128 до 4096 динамически отображаются как dense_vector с по умолчанию сходством cosine. Вы можете переопределить сходство по умолчанию, явно отобразив поле как dense_vector с желаемым сходством.

Индексирование по умолчанию включено для полей плотных векторов и индексируется как int8_hnsw. При включенном индексировании вы можете определить метрику сходства векторов для использования в поиске k ближайших соседей:

resp = client.indices.create(
    index="my-index-2",
    mappings={
        "properties": {
            "my_vector": {
                "type": "dense_vector",
                "dims": 3,
                "similarity": "dot_product"
            }
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'my-index-2',
  body: {
    mappings: {
      properties: {
        my_vector: {
          type: 'dense_vector',
          dims: 3,
          similarity: 'dot_product'
        }
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "my-index-2",
  mappings: {
    properties: {
      my_vector: {
        type: "dense_vector",
        dims: 3,
        similarity: "dot_product",
      },
    },
  },
});
console.log(response);

PUT my-index-2
{
  "mappings": {
    "properties": {
      "my_vector": {
        "type": "dense_vector",
        "dims": 3,
        "similarity": "dot_product"
      }
    }
  }
}

Вы можете отключить индексирование, установив параметр index в false:

resp = client.indices.create(
    index="my-index-2",
    mappings={
        "properties": {
            "my_vector": {
                "type": "dense_vector",
                "dims": 3,
                "index": False
            }
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'my-index-2',
  body: {
    mappings: {
      properties: {
        my_vector: {
          type: 'dense_vector',
          dims: 3,
          index: false
        }
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "my-index-2",
  mappings: {
    properties: {
      my_vector: {
        type: "dense_vector",
        dims: 3,
        index: false,
      },
    },
  },
});
console.log(response);

PUT my-index-2
{
  "mappings": {
    "properties": {
      "my_vector": {
        "type": "dense_vector",
        "dims": 3,
        "index": false
      }
    }
  }
}

Elasticsearch использует алгоритм HNSW для поддержки эффективного поиска k ближайших соседей. Как и большинство алгоритмов kNN, HNSW является приближенным методом, который жертвует точностью результата для повышения скорости.

Тип dense_vector поддерживает квантование для уменьшения объема памяти, требуемого при поиске float векторов. Поддерживаются три стратегии квантования:

При использовании квантованного формата вам может потребоваться передискретизация и повторное ранжирование результатов для повышения точности. Подробнее см. передискретизацию и повторное ранжирование.

Для использования квантованного индекса вы можете установить тип индекса на int8_hnsw, int4_hnsw или bbq_hnsw. При индексировании float векторов текущий тип индекса по умолчанию — int8_hnsw.

Вот пример создания индекса с байтовым квантованием:

resp = client.indices.create(
    index="my-byte-quantized-index",
    mappings={
        "properties": {
            "my_vector": {
                "type": "dense_vector",
                "dims": 3,
                "index": True,
                "index_options": {
                    "type": "int8_hnsw"
                }
            }
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'my-byte-quantized-index',
  body: {
    mappings: {
      properties: {
        my_vector: {
          type: 'dense_vector',
          dims: 3,
          index: true,
          index_options: {
            type: 'int8_hnsw'
          }
        }
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "my-byte-quantized-index",
  mappings: {
    properties: {
      my_vector: {
        type: "dense_vector",
        dims: 3,
        index: true,
        index_options: {
          type: "int8_hnsw",
        },
      },
    },
  },
});
console.log(response);

PUT my-byte-quantized-index
{
  "mappings": {
    "properties": {
      "my_vector": {
        "type": "dense_vector",
        "dims": 3,
        "index": true,
        "index_options": {
          "type": "int8_hnsw"
        }
      }
    }
  }
}

Вот пример создания индекса с полубайтовым квантованием:

resp = client.indices.create(
    index="my-byte-quantized-index",
    mappings={
        "properties": {
            "my_vector": {
                "type": "dense_vector",
                "dims": 4,
                "index": True,
                "index_options": {
                    "type": "int4_hnsw"
                }
            }
        }
    },
)
print(resp)

const response = await client.indices.create({
  index: "my-byte-quantized-index",
  mappings: {
    properties: {
      my_vector: {
        type: "dense_vector",
        dims: 4,
        index: true,
        index_options: {
          type: "int4_hnsw",
        },
      },
    },
  },
});
console.log(response);

PUT my-byte-quantized-index
{
  "mappings": {
    "properties": {
      "my_vector": {
        "type": "dense_vector",
        "dims": 4,
        "index": true,
        "index_options": {
          "type": "int4_hnsw"
        }
      }
    }
  }
}

[предварительный просмотр] Эта функциональность находится на стадии технического предварительного просмотра и может быть изменена или удалена в будущих выпусках. Elastic будет работать над устранением любых проблем, но функции предварительного просмотра не подпадают под SLA поддержки официальных функций GA. Вот пример создания бинарного квантованного индекса:

resp = client.indices.create(
    index="my-byte-quantized-index",
    mappings={
        "properties": {
            "my_vector": {
                "type": "dense_vector",
                "dims": 64,
                "index": True,
                "index_options": {
                    "type": "bbq_hnsw"
                }
            }
        }
    },
)
print(resp)

const response = await client.indices.create({
  index: "my-byte-quantized-index",
  mappings: {
    properties: {
      my_vector: {
        type: "dense_vector",
        dims: 64,
        index: true,
        index_options: {
          type: "bbq_hnsw",
        },
      },
    },
  },
});
console.log(response);

PUT my-byte-quantized-index
{
  "mappings": {
    "properties": {
      "my_vector": {
        "type": "dense_vector",
        "dims": 64,
        "index": true,
        "index_options": {
          "type": "bbq_hnsw"
        }
      }
    }
  }
}

Поля dense_vector поддерживают синтетический _source.

При использовании element_type: bit, все векторы будут обрабатываться как битовые векторы. Битовые векторы используют только один бит на измерение и кодируются как байты внутри. Это может быть полезно для векторов очень высокой размерности или моделей.

При использовании bit, количество измерений должно быть кратно 8 и должно представлять количество битов. Кроме того, для векторов bit, типичные значения сходства векторов фактически все одинаково оцениваются, например, с помощью расстояния hamming.

Сравним два массива byte[], каждый из которых представляет 40 отдельных битов.

[-127, 0, 1, 42, 127] в битах 1000000100000000000000010010101001111111 [127, -127, 0, 1, 42] в битах 0111111110000001000000000000000100101010

При сравнении этих двух битовых векторов сначала вычисляется расстояние Хэмминга.

Результат вычисления hamming расстояния:

1000000100000000000000010010101001111111
^
0111111110000001000000000000000100101010
=
1111111010000001000000010010101101010101

Затем подсчитывается количество 1 бит в результате xor: 18. Для масштабирования оценки вычитаем полученное значение из общего числа бит и разделим на общее количество бит: (40 - 18) / 40 = 0.55. Это будет значение _score между этими двумя векторами.

Вот пример индексирования и поиска битовых векторов:

resp = client.indices.create(
    index="my-bit-vectors",
    mappings={
        "properties": {
            "my_vector": {
                "type": "dense_vector",
                "dims": 40,
                "element_type": "bit"
            }
        }
    },
)
print(resp)

const response = await client.indices.create({
  index: "my-bit-vectors",
  mappings: {
    properties: {
      my_vector: {
        type: "dense_vector",
        dims: 40,
        element_type: "bit",
      },
    },
  },
});
console.log(response);

PUT my-bit-vectors
{
  "mappings": {
    "properties": {
      "my_vector": {
        "type": "dense_vector",
        "dims": 40, 
        "element_type": "bit"
      }
    }
  }
}

resp = client.bulk(
    index="my-bit-vectors",
    refresh=True,
    operations=[
        {
            "index": {
                "_id": "1"
            }
        },
        {
            "my_vector": [
                127,
                -127,
                0,
                1,
                42
            ]
        },
        {
            "index": {
                "_id": "2"
            }
        },
        {
            "my_vector": "8100012a7f"
        }
    ],
)
print(resp)

const response = await client.bulk({
  index: "my-bit-vectors",
  refresh: "true",
  operations: [
    {
      index: {
        _id: "1",
      },
    },
    {
      my_vector: [127, -127, 0, 1, 42],
    },
    {
      index: {
        _id: "2",
      },
    },
    {
      my_vector: "8100012a7f",
    },
  ],
});
console.log(response);

POST /my-bit-vectors/_bulk?refresh
{"index": {"_id" : "1"}}
{"my_vector": [127, -127, 0, 1, 42]} 
{"index": {"_id" : "2"}}
{"my_vector": "8100012a7f"} 

Затем при поиске вы можете использовать запрос knn для поиска похожих битовых векторов:

resp = client.search(
    index="my-bit-vectors",
    filter_path="hits.hits",
    query={
        "knn": {
            "query_vector": [
                127,
                -127,
                0,
                1,
                42
            ],
            "field": "my_vector"
        }
    },
)
print(resp)

const response = await client.search({
  index: "my-bit-vectors",
  filter_path: "hits.hits",
  query: {
    knn: {
      query_vector: [127, -127, 0, 1, 42],
      field: "my_vector",
    },
  },
});
console.log(response);

POST /my-bit-vectors/_search?filter_path=hits.hits
{
  "query": {
    "knn": {
      "query_vector": [127, -127, 0, 1, 42],
      "field": "my_vector"
    }
  }
}

{
    "hits": {
        "hits": [
            {
                "_index": "my-bit-vectors",
                "_id": "1",
                "_score": 1.0,
                "_source": {
                    "my_vector": [
                        127,
                        -127,
                        0,
                        1,
                        42
                    ]
                }
            },
            {
                "_index": "my-bit-vectors",
                "_id": "2",
                "_score": 0.55,
                "_source": {
                    "my_vector": "8100012a7f"
                }
            }
        ]
    }
}

Для лучшего масштабирования и производительности, обновление параметра type в index_options возможно с помощью API обновления схемы в соответствии с приведенной ниже диаграммой (разрешены переходы):

flat --> int8_flat --> int4_flat --> hnsw --> int8_hnsw --> int4_hnsw

Для обновления всех типов HNSW (hnsw, int8_hnsw, int4_hnsw) количество подключений m должно оставаться неизменным или увеличиваться. Для скалярных квантованных форматов (int8_flat, int4_flat, int8_hnsw, int4_hnsw) значение confidence_interval должно всегда оставаться неизменным (после определения оно не может быть изменено).

Обновление type в index_options не удастся во всех остальных случаях.

Переключение types не переиндексирует векторы, которые уже были индексированы (они будут продолжать использовать свой исходный type), векторы, индексируемые после изменения, будут использовать новый type вместо этого.

Например, можно определить поле векторного типа, использующего тип flat (сырые массивы float32) для первой партии данных, подлежащих индексированию.

resp = client.indices.create(
    index="my-index-000001",
    mappings={
        "properties": {
            "text_embedding": {
                "type": "dense_vector",
                "dims": 384,
                "index_options": {
                    "type": "flat"
                }
            }
        }
    },
)
print(resp)

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
    properties: {
      text_embedding: {
        type: "dense_vector",
        dims: 384,
        index_options: {
          type: "flat",
        },
      },
    },
  },
});
console.log(response);

PUT my-index-000001
{
    "mappings": {
        "properties": {
            "text_embedding": {
                "type": "dense_vector",
                "dims": 384,
                "index_options": {
                    "type": "flat"
                }
            }
        }
    }
}

Изменение type на int4_hnsw гарантирует, что векторы, индексируемые после изменения, будут использовать целочисленное скалярное квантованное представление int4 и HNSW (например, для запросов KNN). Это включает новые сегменты, созданные путем слияния ранее созданных сегментов.

resp = client.indices.put_mapping(
    index="my-index-000001",
    properties={
        "text_embedding": {
            "type": "dense_vector",
            "dims": 384,
            "index_options": {
                "type": "int4_hnsw"
            }
        }
    },
)
print(resp)

const response = await client.indices.putMapping({
  index: "my-index-000001",
  properties: {
    text_embedding: {
      type: "dense_vector",
      dims: 384,
      index_options: {
        type: "int4_hnsw",
      },
    },
  },
});
console.log(response);

PUT /my-index-000001/_mapping
{
    "properties": {
        "text_embedding": {
            "type": "dense_vector",
            "dims": 384,
            "index_options": {
                "type": "int4_hnsw"
            }
        }
    }
}

Векторы, индексированные до этого изменения, будут продолжать использовать тип flat (сырое представление float32 и поиск по силе грубой силы для запросов KNN).

Для обновления всех векторов до нового типа необходимо использовать переиндексацию или принудительное слияние.

Для отладки можно проверить, сколько сегментов (и документов) существует для каждого type с помощью API сегментов индекса.