use crate::core::util::CoreHelper;
use crate::core::util::error::lucene_error::Result;
use crate::core::util::vector_util::{VECTOR_UTIL, VectorUtil};
#[cfg(test)]
use rand::{Rng, RngExt};
#[cfg(test)]
use strum::EnumCount;
use strum_macros::{Display, EnumCount, FromRepr};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, FromRepr, EnumCount, Display)]
#[repr(u8)]
pub enum VectorSimilarityFunction {
Euclidean,
DotProduct,
Cosine,
MaximumInnerProduct,
}
impl VectorSimilarityFunction {
pub fn ordinal(&self) -> i32 {
match self {
VectorSimilarityFunction::Euclidean => 0,
VectorSimilarityFunction::DotProduct => 1,
VectorSimilarityFunction::Cosine => 2,
VectorSimilarityFunction::MaximumInnerProduct => 3,
}
}
#[cfg(test)]
pub fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
[
Self::Euclidean,
Self::DotProduct,
Self::Cosine,
Self::MaximumInnerProduct,
][rng.random_range(0..Self::COUNT)]
}
}
impl Default for VectorSimilarityFunction {
fn default() -> Self {
VectorSimilarityFunction::Euclidean
}
}
pub trait VectorSimilarity: Copy + Send + Sync + std::fmt::Debug {
const SUPPORTS_MAPPED_FLOAT_INPUT: bool = false;
fn function(self) -> VectorSimilarityFunction;
fn compare_f32(&self, v1: &[f32], v2: &[f32]) -> Result<f32>;
fn compare_u8(&self, v1: &[u8], v2: &[u8]) -> Result<f32>;
}
#[derive(Clone, Copy, Debug, Default)]
pub struct EuclideanSimilarity;
impl VectorSimilarity for EuclideanSimilarity {
const SUPPORTS_MAPPED_FLOAT_INPUT: bool = true;
fn function(self) -> VectorSimilarityFunction {
VectorSimilarityFunction::Euclidean
}
#[inline]
fn compare_f32(&self, v1: &[f32], v2: &[f32]) -> Result<f32> {
let distance = VECTOR_UTIL.square_distance_f32(v1, v2)?;
Ok(1.0 / (1.0 + distance))
}
#[inline]
fn compare_u8(&self, v1: &[u8], v2: &[u8]) -> Result<f32> {
let distance = VECTOR_UTIL.square_distance_u8(v1, v2)? as f32;
Ok(1.0 / (1.0 + distance))
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct DotProductSimilarity;
impl VectorSimilarity for DotProductSimilarity {
const SUPPORTS_MAPPED_FLOAT_INPUT: bool = true;
fn function(self) -> VectorSimilarityFunction {
VectorSimilarityFunction::DotProduct
}
fn compare_f32(&self, v1: &[f32], v2: &[f32]) -> Result<f32> {
let dot = VECTOR_UTIL.dot_product_f32(v1, v2)?;
Ok(CoreHelper::max_f32((1.0 + dot) / 2.0, 0.0))
}
fn compare_u8(&self, v1: &[u8], v2: &[u8]) -> Result<f32> {
VECTOR_UTIL.dot_product_score(v1, v2)
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct CosineSimilarity;
impl VectorSimilarity for CosineSimilarity {
const SUPPORTS_MAPPED_FLOAT_INPUT: bool = true;
fn function(self) -> VectorSimilarityFunction {
VectorSimilarityFunction::Cosine
}
fn compare_f32(&self, v1: &[f32], v2: &[f32]) -> Result<f32> {
let cosine = VECTOR_UTIL.cosine_f32(v1, v2)?;
Ok(CoreHelper::max_f32((1.0 + cosine) / 2.0, 0.0))
}
fn compare_u8(&self, v1: &[u8], v2: &[u8]) -> Result<f32> {
let cosine = VECTOR_UTIL.cosine_u8(v1, v2)?;
Ok((1.0 + cosine) / 2.0)
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct MaximumInnerProductSimilarity;
impl VectorSimilarity for MaximumInnerProductSimilarity {
const SUPPORTS_MAPPED_FLOAT_INPUT: bool = true;
fn function(self) -> VectorSimilarityFunction {
VectorSimilarityFunction::MaximumInnerProduct
}
fn compare_f32(&self, v1: &[f32], v2: &[f32]) -> Result<f32> {
let dot = VECTOR_UTIL.dot_product_f32(v1, v2)?;
Ok(VectorUtil::scale_max_inner_product_score(dot))
}
fn compare_u8(&self, v1: &[u8], v2: &[u8]) -> Result<f32> {
let dot = VECTOR_UTIL.dot_product_u8(v1, v2)? as f32;
Ok(VectorUtil::scale_max_inner_product_score(dot))
}
}
impl VectorSimilarityFunction {
pub fn compare_f32(&self, v1: &[f32], v2: &[f32]) -> Result<f32> {
match self {
Self::Euclidean => EuclideanSimilarity.compare_f32(v1, v2),
Self::DotProduct => DotProductSimilarity.compare_f32(v1, v2),
Self::Cosine => CosineSimilarity.compare_f32(v1, v2),
Self::MaximumInnerProduct => MaximumInnerProductSimilarity.compare_f32(v1, v2),
}
}
pub fn compare_u8(&self, v1: &[u8], v2: &[u8]) -> Result<f32> {
match self {
Self::Euclidean => EuclideanSimilarity.compare_u8(v1, v2),
Self::DotProduct => DotProductSimilarity.compare_u8(v1, v2),
Self::Cosine => CosineSimilarity.compare_u8(v1, v2),
Self::MaximumInnerProduct => MaximumInnerProductSimilarity.compare_u8(v1, v2),
}
}
}
impl VectorSimilarity for VectorSimilarityFunction {
const SUPPORTS_MAPPED_FLOAT_INPUT: bool = true;
fn function(self) -> VectorSimilarityFunction {
self
}
fn compare_f32(&self, v1: &[f32], v2: &[f32]) -> Result<f32> {
VectorSimilarityFunction::compare_f32(self, v1, v2)
}
fn compare_u8(&self, v1: &[u8], v2: &[u8]) -> Result<f32> {
VectorSimilarityFunction::compare_u8(self, v1, v2)
}
}
#[macro_export]
macro_rules! with_vector_similarity {
($function:expr, $similarity:ident, $body:expr) => {{
use $crate::core::index::vector_similarity_function::*;
match $function {
VectorSimilarityFunction::Euclidean => {
let $similarity = EuclideanSimilarity;
$body
},
VectorSimilarityFunction::DotProduct => {
let $similarity = DotProductSimilarity;
$body
},
VectorSimilarityFunction::Cosine => {
let $similarity = CosineSimilarity;
$body
},
VectorSimilarityFunction::MaximumInnerProduct => {
let $similarity = MaximumInnerProductSimilarity;
$body
},
}
}};
}