milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

calc_distance typo (#6380) 

* calc_distance typo

Signed-off-by: yhmo <yihua.mo@zilliz.com>

* calc_distance typo

Signed-off-by: yhmo <yihua.mo@zilliz.com>
pull/6407/head
groot 2021-07-09 14:53:52 +08:00 committed by GitHub
parent 5d1f784bcb
commit 19fc42c9eb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 53 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
internal/proxy/impl.go
View File

@ -1618,6 +1618,15 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
}
}
if vectorsLeft == nil {
return &milvuspb.CalcDistanceResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: "Left vectors array is empty",
},
}, nil
}
vectorsRight := request.GetOpRight().GetDataArray()
opRight := request.GetOpRight().GetIdArray()
if opRight != nil {
@ -1639,6 +1648,15 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
}
}
if vectorsRight == nil {
return &milvuspb.CalcDistanceResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: "Right vectors array is empty",
},
}, nil
}
if vectorsLeft.Dim == vectorsRight.Dim && vectorsLeft.GetFloatVector() != nil && vectorsRight.GetFloatVector() != nil {
distances, err := distance.CalcFloatDistance(vectorsLeft.Dim, vectorsLeft.GetFloatVector().Data, vectorsRight.GetFloatVector().Data, metric)
if err != nil {
@ -1661,7 +1679,7 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
}
if vectorsLeft.Dim == vectorsRight.Dim && vectorsLeft.GetBinaryVector() != nil && vectorsRight.GetBinaryVector() != nil {
hammin, err := distance.CalcHamminDistance(vectorsLeft.Dim, vectorsLeft.GetBinaryVector(), vectorsRight.GetBinaryVector())
hamming, err := distance.CalcHammingDistance(vectorsLeft.Dim, vectorsLeft.GetBinaryVector(), vectorsRight.GetBinaryVector())
if err != nil {
return &milvuspb.CalcDistanceResults{
Status: &commonpb.Status{
@ -1676,14 +1694,14 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success, Reason: ""},
Array: &milvuspb.CalcDistanceResults_IntDist{
IntDist: &schemapb.IntArray{
Data: hammin,
Data: hamming,
},
},
}, nil
}
if metric == distance.TANIMOTO {
tanimoto, err := distance.CalcTanimotoCoefficient(vectorsLeft.Dim, hammin)
tanimoto, err := distance.CalcTanimotoCoefficient(vectorsLeft.Dim, hamming)
if err != nil {
return &milvuspb.CalcDistanceResults{
Status: &commonpb.Status{

36
internal/util/distance/calc_distance.go
View File

@ -20,7 +20,7 @@ import (
const (
L2 = "L2"
IP = "IP"
HAMMING = "HAMMIN"
HAMMING = "HAMMING"
TANIMOTO = "TANIMOTO"
)
@ -162,14 +162,14 @@ func CountOne(n uint8) int32 {
return count
}
// HAMMIN distance
func CalcHammin(dim int64, left []byte, lIndex int64, right []byte, rIndex int64) int32 {
// HAMMING distance
func CalcHamming(dim int64, left []byte, lIndex int64, right []byte, rIndex int64) int32 {
singleBitLen := SingleBitLen(dim)
numBytes := singleBitLen / 8
lFrom := lIndex * numBytes
rFrom := rIndex * numBytes
var hammin int32 = 0
var hamming int32 = 0
for i := int64(0); i < numBytes; i++ {
var xor uint8 = left[lFrom+i] ^ right[rFrom+i]
@ -182,22 +182,22 @@ func CalcHammin(dim int64, left []byte, lIndex int64, right []byte, rIndex int64
xor = xor & (255 << offset)
}
hammin += CountOne(xor)
hamming += CountOne(xor)
}
return hammin
return hamming
}
func CalcHamminBatch(dim int64, left []byte, lIndex int64, right []byte, result *[]int32) {
func CalcHammingBatch(dim int64, left []byte, lIndex int64, right []byte, result *[]int32) {
rightNum := VectorCount(dim, len(right))
for i := int64(0); i < rightNum; i++ {
hammin := CalcHammin(dim, left, lIndex, right, i)
(*result)[lIndex*rightNum+i] = hammin
hamming := CalcHamming(dim, left, lIndex, right, i)
(*result)[lIndex*rightNum+i] = hamming
}
}
func CalcHamminDistance(dim int64, left []byte, right []byte) ([]int32, error) {
func CalcHammingDistance(dim int64, left []byte, right []byte) ([]int32, error) {
if dim <= 0 {
err := errors.New("Invalid dimension")
return nil, err
@ -219,7 +219,7 @@ func CalcHamminDistance(dim int64, left []byte, right []byte) ([]int32, error) {
var waitGroup sync.WaitGroup
CalcWorker := func(index int64) {
CalcHamminBatch(dim, left, index, right, &distArray)
CalcHammingBatch(dim, left, index, right, &distArray)
waitGroup.Done()
}
for i := int64(0); i < leftNum; i++ {
@ -231,19 +231,19 @@ func CalcHamminDistance(dim int64, left []byte, right []byte) ([]int32, error) {
return distArray, nil
}
func CalcTanimotoCoefficient(dim int64, hammin []int32) ([]float32, error) {
if dim <= 0 || len(hammin) == 0 {
func CalcTanimotoCoefficient(dim int64, hamming []int32) ([]float32, error) {
if dim <= 0 || len(hamming) == 0 {
err := errors.New("Invalid input for tanimoto")
return nil, err
}
array := make([]float32, len(hammin))
for i := 0; i < len(hammin); i++ {
if hammin[i] >= int32(dim)*2 {
err := errors.New("Invalid hammin for tanimoto")
array := make([]float32, len(hamming))
for i := 0; i < len(hamming); i++ {
if hamming[i] >= int32(dim)*2 {
err := errors.New("Invalid hamming for tanimoto")
return nil, err
}
array[i] = float32(hammin[i] / (int32(dim)*2 - hammin[i]))
array[i] = float32(hamming[i]) / (float32(dim)*2 - float32(hamming[i]))
}
return array, nil

27
internal/util/distance/calc_distance_test.go
View File

@ -29,7 +29,7 @@ func TestValidateMetricType(t *testing.T) {
assert.Error(t, err)
}
validMetric := []string{"L2", "ip", "Hammin", "Tanimoto"}
validMetric := []string{"L2", "ip", "Hamming", "Tanimoto"}
for _, str := range validMetric {
metric, err := ValidateMetricType(str)
assert.Nil(t, err)
@ -210,7 +210,7 @@ func TestCountOne(t *testing.T) {
assert.Equal(t, n, int32(8))
}
func TestCalcHammin(t *testing.T) {
func TestCalcHamming(t *testing.T) {
var dim int64 = 22
// v1 = 00000010 00000110 00001000
v1 := make([]uint8, 3)
@ -222,14 +222,15 @@ func TestCalcHammin(t *testing.T) {
v2[0] = 1
v2[1] = 7
v2[2] = 27
n := CalcHammin(dim, v1, 0, v2, 0)
n := CalcHamming(dim, v1, 0, v2, 0)
assert.Equal(t, n, int32(4))
hammin := make([]int32, 1)
hammin[0] = n
tanimoto, err := CalcTanimotoCoefficient(dim, hammin)
hamming := make([]int32, 1)
hamming[0] = n
tanimoto, err := CalcTanimotoCoefficient(dim, hamming)
realTanimoto := float64(n) / (float64(dim)*2.0 - float64(n))
assert.Nil(t, err)
assert.Less(t, math.Abs(float64(tanimoto[0]-float32(n/(int32(dim)*2-n)))), float64(PRECISION))
assert.Less(t, math.Abs(float64(tanimoto[0])-realTanimoto), float64(PRECISION))
}
func TestCalcHamminDistance(t *testing.T) {
@ -238,21 +239,21 @@ func TestCalcHamminDistance(t *testing.T) {
left := CreateBinaryArray(leftNum, dim)
_, e := CalcHamminDistance(0, left, left)
_, e := CalcHammingDistance(0, left, left)
assert.Error(t, e)
distances, err := CalcHamminDistance(dim, left, left)
distances, err := CalcHammingDistance(dim, left, left)
assert.Nil(t, err)
n := CalcHammin(dim, left, 0, left, 0)
n := CalcHamming(dim, left, 0, left, 0)
assert.Equal(t, n, int32(0))
n = CalcHammin(dim, left, 1, left, 1)
n = CalcHamming(dim, left, 1, left, 1)
assert.Equal(t, n, int32(0))
n = CalcHammin(dim, left, 0, left, 1)
n = CalcHamming(dim, left, 0, left, 1)
assert.Equal(t, n, distances[1])
n = CalcHammin(dim, left, 1, left, 0)
n = CalcHamming(dim, left, 1, left, 0)
assert.Equal(t, n, distances[2])
}