Merge pull request #132 from weaviate/chore/more-target-vectors

Fix hybrid multi vector target search issues

Author: dirkkul

src/Weaviate.Client.Tests/Integration/TestNamedVectorMultiTarget.cs

@@ -190,6 +190,180 @@ string[] targetVector
         Assert.Equal(expected, ids);
     }
 
+    public static IEnumerable<object[]> HybridMultiInputCombinations =>
+        new List<object[]>
+        {
+            new object[]
+            {
+                new Vectors
+                {
+                    { "first", new[] { 0f, 1f } },
+                    {
+                        "second",
+                        new float[,]
+                        {
+                            { 1f, 0f, 0f },
+                            { 0f, 0f, 1f },
+                        }
+                    },
+                },
+                new[] { "first", "second" },
+            },
+            new object[]
+            {
+                new Vectors
+                {
+                    {
+                        "first",
+                        new float[,]
+                        {
+                            { 0f, 1f },
+                            { 0f, 1f },
+                        }
+                    },
+                    { "second", new[] { 1f, 0f, 0f } },
+                },
+                new[] { "first", "second" },
+            },
+            new object[]
+            {
+                new Vectors
+                {
+                    {
+                        "first",
+                        new float[,]
+                        {
+                            { 0f, 1f },
+                            { 0f, 1f },
+                        }
+                    },
+                    {
+                        "second",
+                        new float[,]
+                        {
+                            { 1f, 0f, 0f },
+                            { 0f, 0f, 1f },
+                        }
+                    },
+                },
+                new[] { "first", "second" },
+            },
+            // The following are equivalent to above, but mimic the Python HybridVector.near_vector usage
+            new object[]
+            {
+                new HybridNearVector(
+                    new Vectors
+                    {
+                        { "first", new[] { 0f, 1f } },
+                        {
+                            "second",
+                            new float[,]
+                            {
+                                { 1f, 0f, 0f },
+                                { 0f, 0f, 1f },
+                            }
+                        },
+                    },
+                    Certainty: null,
+                    Distance: null
+                ),
+                new[] { "first", "second" },
+            },
+            new object[]
+            {
+                new HybridNearVector(
+                    new Vectors
+                    {
+                        {
+                            "first",
+                            new float[,]
+                            {
+                                { 0f, 1f },
+                                { 0f, 1f },
+                            }
+                        },
+                        { "second", new[] { 1f, 0f, 0f } },
+                    }
+                ),
+                new[] { "first", "second" },
+            },
+            new object[]
+            {
+                new HybridNearVector(
+                    new Vectors
+                    {
+                        {
+                            "first",
+                            new float[,]
+                            {
+                                { 0f, 1f },
+                                { 0f, 1f },
+                            }
+                        },
+                        {
+                            "second",
+                            new float[,]
+                            {
+                                { 1f, 0f, 0f },
+                                { 0f, 0f, 1f },
+                            }
+                        },
+                    }
+                ),
+                new[] { "first", "second" },
+            },
+        };
+
+    [Theory]
+    [MemberData(nameof(HybridMultiInputCombinations))]
+    public async Task Test_SameTargetVector_MultipleInputCombinations_Hybrid(
+        IHybridVectorInput nearVector,
+        string[] targetVector
+    )
+    {
+        var dummy = await CollectionFactory();
+        if (dummy.WeaviateVersion < Version.Parse("1.27.0"))
+        {
+            Assert.Skip("Multi vector per target is not supported in versions lower than 1.27.0");
+        }
+
+        var collection = await CollectionFactory(
+            properties: Array.Empty<Property>(),
+            vectorConfig: new[]
+            {
+                Configure.Vectors.SelfProvided(name: "first"),
+                Configure.Vectors.SelfProvided(name: "second"),
+            }
+        );
+
+        var uuid1 = await collection.Data.Insert(
+            new { },
+            vectors: new Vectors
+            {
+                { "first", new[] { 1f, 0f } },
+                { "second", new[] { 0f, 1f, 0f } },
+            }
+        );
+        var uuid2 = await collection.Data.Insert(
+            new { },
+            vectors: new Vectors
+            {
+                { "first", new[] { 0f, 1f } },
+                { "second", new[] { 1f, 0f, 0f } },
+            }
+        );
+
+        var objs = await collection.Query.Hybrid(
+            query: null,
+            vectors: nearVector,
+            targetVector: targetVector,
+            returnMetadata: MetadataOptions.All
+        );
+        var ids = objs.Objects.Select(o => o.ID!.Value).OrderBy(x => x).ToList();
+        var expected = new[] { uuid2, uuid1 }.OrderBy(x => x).ToList();
+        Assert.Equal(expected, ids);
+    }
+
     public static IEnumerable<object[]> MultiTargetVectorsWithDistances =>
         new List<object[]>
         {

src/Weaviate.Client.Tests/Integration/TestSearchHybrid.cs

@@ -227,6 +227,7 @@ await collection.Query.NearVector(
             query: null,
             vectors: new HybridNearVector(
                 obj.Vectors["default"],
+                Certainty: null,
                 Distance: Convert.ToSingle(nearVec.First().Metadata.Distance!.Value + 0.001)
             ),
             returnMetadata: MetadataOptions.All
@@ -286,6 +287,7 @@ await collection.Query.Hybrid(
                 query: null,
                 vectors: new HybridNearVector(
                     obj.Vectors["text"],
+                    Certainty: null,
                     Distance: Convert.ToSingle(nearVec.First().Metadata.Distance!.Value + 0.001)
                 ),
                 targetVector: ["text"],
@@ -325,6 +327,8 @@ await collection.Query.Hybrid(
                 query: null,
                 vectors: new HybridNearText(
                     "banana",
+                    Certainty: null,
+                    Distance: null,
                     MoveTo: new Move(force: 0.1f, concepts: ["pudding"]),
                     MoveAway: new Move(force: 0.1f, concepts: ["smoothie"])
                 ),
@@ -368,6 +372,8 @@ await collection.Query.Hybrid(
                 query: null,
                 vectors: new HybridNearText(
                     "banana",
+                    Certainty: null,
+                    Distance: null,
                     MoveTo: new Move(force: 0.1f, concepts: ["pudding"]),
                     MoveAway: new Move(force: 0.1f, concepts: ["smoothie"])
                 ),
@@ -429,7 +435,7 @@ await collection.Query.Hybrid(
         objs = (
             await collection.Query.Hybrid(
                 query: null,
-                vectors: new HybridNearVector(vector, Distance: 0.1f),
+                vectors: new HybridNearVector(vector, Certainty: null, Distance: 0.1f),
                 targetVector: new[] { "first", "second" }
             )
         ).Objects.ToList();

src/Weaviate.Client/Models/Search.cs

@@ -8,15 +8,15 @@ public interface IHybridVectorInput
 
 public record HybridNearVector(
     Models.Vectors? Vector,
-    float? Distance = null,
     float? Certainty = null,
+    float? Distance = null,
     TargetVectors? targetVector = null
 ) : IHybridVectorInput { };
 
 public record HybridNearText(
     string Query,
-    float? Distance = null,
     float? Certainty = null,
+    float? Distance = null,
     Move? MoveTo = null,
     Move? MoveAway = null
 ) : IHybridVectorInput;