github.com/weaviate/weaviate@v1.24.6/usecases/classification/ref_meta_test.go (about)

     1  //                           _       _
     2  // __      _____  __ ___   ___  __ _| |_ ___
     3  // \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
     4  //  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
     5  //   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
     6  //
     7  //  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
     8  //
     9  //  CONTACT: hello@weaviate.io
    10  //
    11  
    12  package classification
    13  
    14  import (
    15  	"testing"
    16  
    17  	"github.com/stretchr/testify/assert"
    18  	"github.com/weaviate/weaviate/entities/models"
    19  )
    20  
    21  func Test_RefMeta(t *testing.T) {
    22  	t.Run("without a losing group", func(t *testing.T) {
    23  		source := NeighborRef{
    24  			WinningCount: 3,
    25  			OverallCount: 3,
    26  			LosingCount:  0,
    27  			Distances: NeighborRefDistances{
    28  				ClosestWinningDistance: 0.1,
    29  				ClosestOverallDistance: 0.1,
    30  				MeanWinningDistance:    0.2,
    31  			},
    32  		}
    33  
    34  		expected := &models.ReferenceMetaClassification{
    35  			ClosestWinningDistance: 0.1,
    36  			ClosestOverallDistance: 0.1,
    37  			MeanWinningDistance:    0.2,
    38  			WinningDistance:        0.2, // deprecated, must be removed in 0.23.0
    39  			OverallCount:           3,
    40  			WinningCount:           3,
    41  			LosingCount:            0,
    42  		}
    43  
    44  		actual := source.Meta()
    45  		assert.InDelta(t, expected.ClosestWinningDistance, actual.ClosestWinningDistance, 0.001)
    46  		assert.InDelta(t, expected.ClosestOverallDistance, actual.ClosestOverallDistance, 0.001)
    47  		assert.InDelta(t, expected.MeanWinningDistance, actual.MeanWinningDistance, 0.001)
    48  		assert.InDelta(t, expected.WinningDistance, actual.WinningDistance, 0.001)
    49  		assert.Equal(t, expected.OverallCount, actual.OverallCount)
    50  		assert.Equal(t, expected.WinningCount, actual.WinningCount)
    51  		assert.Equal(t, expected.LosingCount, actual.LosingCount)
    52  	})
    53  
    54  	t.Run("with a losing group", func(t *testing.T) {
    55  		source := NeighborRef{
    56  			WinningCount: 3,
    57  			OverallCount: 5,
    58  			LosingCount:  2,
    59  			Distances: NeighborRefDistances{
    60  				ClosestWinningDistance: 0.1,
    61  				ClosestOverallDistance: 0.1,
    62  				MeanWinningDistance:    0.2,
    63  				ClosestLosingDistance:  ptFloat32(0.15),
    64  				MeanLosingDistance:     ptFloat32(0.25),
    65  			},
    66  		}
    67  
    68  		expected := &models.ReferenceMetaClassification{
    69  			ClosestOverallDistance: 0.1,
    70  			ClosestWinningDistance: 0.1,
    71  			MeanWinningDistance:    0.2,
    72  			WinningDistance:        0.2, // deprecated, must be removed in 0.23.0
    73  			ClosestLosingDistance:  ptFloat64(0.15),
    74  			MeanLosingDistance:     ptFloat64(0.25),
    75  			LosingDistance:         ptFloat64(0.25), // deprecated, must be removed in 0.23.0
    76  			OverallCount:           5,
    77  			WinningCount:           3,
    78  			LosingCount:            2,
    79  		}
    80  
    81  		actual := source.Meta()
    82  		assert.InDelta(t, expected.ClosestOverallDistance, actual.ClosestOverallDistance, 0.001)
    83  		assert.InDelta(t, expected.ClosestWinningDistance, actual.ClosestWinningDistance, 0.001)
    84  		assert.InDelta(t, expected.MeanWinningDistance, actual.MeanWinningDistance, 0.001)
    85  		assert.InDelta(t, expected.WinningDistance, actual.WinningDistance, 0.001)
    86  		assert.InDelta(t, *expected.ClosestLosingDistance, *actual.ClosestLosingDistance, 0.001)
    87  		assert.InDelta(t, *expected.MeanLosingDistance, *actual.MeanLosingDistance, 0.001)
    88  		assert.InDelta(t, *expected.LosingDistance, *actual.LosingDistance, 0.001)
    89  		assert.Equal(t, expected.OverallCount, actual.OverallCount)
    90  		assert.Equal(t, expected.OverallCount, actual.OverallCount)
    91  		assert.Equal(t, expected.WinningCount, actual.WinningCount)
    92  		assert.Equal(t, expected.LosingCount, actual.LosingCount)
    93  	})
    94  }
    95  
    96  func ptFloat32(in float32) *float32 {
    97  	return &in
    98  }