1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include "angular_distance.h"
#include "temporary_vector_store.h"
#include <numbers>
using vespalib::typify_invoke;
using vespalib::eval::TypifyCellType;
using vespalib::eval::TypedCells;
namespace search::tensor {
namespace {
struct CalcAngular {
template <typename LCT, typename RCT>
static double invoke(const vespalib::eval::TypedCells& lhs,
const vespalib::eval::TypedCells& rhs)
{
auto lhs_vector = lhs.unsafe_typify<LCT>();
auto rhs_vector = rhs.unsafe_typify<RCT>();
size_t sz = lhs_vector.size();
assert(sz == rhs_vector.size());
double a_norm_sq = 0.0;
double b_norm_sq = 0.0;
double dot_product = 0.0;
for (size_t i = 0; i < sz; ++i) {
double a = lhs_vector[i];
double b = rhs_vector[i];
a_norm_sq += a*a;
b_norm_sq += b*b;
dot_product += a*b;
}
double squared_norms = a_norm_sq * b_norm_sq;
double div = (squared_norms > 0) ? sqrt(squared_norms) : 1.0;
double cosine_similarity = dot_product / div;
double distance = 1.0 - cosine_similarity; // in range [0,2]
return std::max(0.0, distance);
}
};
}
template<typename FloatType>
class BoundAngularDistance : public BoundDistanceFunction {
private:
const vespalib::hwaccelrated::IAccelrated & _computer;
mutable TemporaryVectorStore<FloatType> _tmpSpace;
const vespalib::ConstArrayRef<FloatType> _lhs;
double _lhs_norm_sq;
public:
BoundAngularDistance(const vespalib::eval::TypedCells& lhs)
: _computer(vespalib::hwaccelrated::IAccelrated::getAccelerator()),
_tmpSpace(lhs.size),
_lhs(_tmpSpace.storeLhs(lhs))
{
auto a = _lhs.data();
_lhs_norm_sq = _computer.dotProduct(a, a, lhs.size);
}
double calc(const vespalib::eval::TypedCells& rhs) const override {
size_t sz = _lhs.size();
vespalib::ConstArrayRef<FloatType> rhs_vector = _tmpSpace.convertRhs(rhs);
assert(sz == rhs_vector.size());
auto a = _lhs.data();
auto b = rhs_vector.data();
double b_norm_sq = _computer.dotProduct(b, b, sz);
double squared_norms = _lhs_norm_sq * b_norm_sq;
double dot_product = _computer.dotProduct(a, b, sz);
double div = (squared_norms > 0) ? sqrt(squared_norms) : 1.0;
double cosine_similarity = dot_product / div;
double distance = 1.0 - cosine_similarity; // in range [0,2]
return distance;
}
double convert_threshold(double threshold) const override {
if (threshold < 0.0) {
return 0.0;
}
if (threshold > std::numbers::pi) {
return 2.0;
}
double cosine_similarity = cos(threshold);
return 1.0 - cosine_similarity;
}
double to_rawscore(double distance) const override {
double cosine_similarity = 1.0 - distance;
// should be in the range [-1,1] but roundoff may cause problems:
cosine_similarity = std::min(1.0, cosine_similarity);
cosine_similarity = std::max(-1.0, cosine_similarity);
double angle_distance = acos(cosine_similarity); // in range [0,pi]
double score = 1.0 / (1.0 + angle_distance);
return score;
}
double calc_with_limit(const vespalib::eval::TypedCells& rhs, double) const override {
return calc(rhs);
}
};
template class BoundAngularDistance<float>;
template class BoundAngularDistance<double>;
template <typename FloatType>
BoundDistanceFunction::UP
AngularDistanceFunctionFactory<FloatType>::for_query_vector(const vespalib::eval::TypedCells& lhs) {
using DFT = BoundAngularDistance<FloatType>;
return std::make_unique<DFT>(lhs);
}
template <typename FloatType>
BoundDistanceFunction::UP
AngularDistanceFunctionFactory<FloatType>::for_insertion_vector(const vespalib::eval::TypedCells& lhs) {
using DFT = BoundAngularDistance<FloatType>;
return std::make_unique<DFT>(lhs);
}
template class AngularDistanceFunctionFactory<float>;
template class AngularDistanceFunctionFactory<double>;
}
|
