Embedding.cs

// Copyright (c) Microsoft. All rights reserved.

usingSystem;
usingSystem.Numerics.Tensors;
usingSystem.Runtime.InteropServices;
usingSystem.Text.Json;
usingSystem.Text.Json.Serialization;

#pragma warning disable IDE0130// first class concept we want to have readily available
#pragma warning disable CA2225// no need for explicit methods

// ReSharper disable once CheckNamespace - reduce number of "using" statements
namespaceMicrosoft.KernelMemory;

/// <summary>
/// Note: use Embedding.JsonConverter to serialize objects using this type.
/// Example:
/// [JsonPropertyName("vector")]
/// [JsonConverter(typeof(Embedding.JsonConverter))]
/// public Embedding Vector { get; set; }
/// </summary>
publicstructEmbedding:IEquatable<Embedding>
{
/// <summary>
/// Note: use Embedding.JsonConverter to serialize objects using this type.
/// </summary>
[JsonIgnore]
publicReadOnlyMemory<float>Data{get;set;}=new();

/// <summary>
/// Note: use Embedding.JsonConverter to serialize objects using this type.
/// </summary>
[JsonIgnore]
publicreadonlyintLength=>this.Data.Length;

publicEmbedding(float[]vector)
{
this.Data=vector;
}

/// <summary>
/// This is not a ctor on purpose so we can use collections syntax with
/// the main ctor, and surface the extra casting cost when not using floats.
/// </summary>
publicstaticEmbeddingFromDoubles(double[]vector)
{
float[]f=newfloat[vector.Length];
for(inti=0;i<vector.Length;i++){f[i]=(float)vector[i];}

returnnewEmbedding(f);
}

publicEmbedding(ReadOnlyMemory<float>vector)
{
this.Data=vector;
}

publicEmbedding(intsize)
{
this.Data=newReadOnlyMemory<float>(newfloat[size]);
}

publicreadonlydoubleCosineSimilarity(Embeddingembedding)
{
varsize1=this.Data.Span.Length;
varsize2=embedding.Data.Span.Length;
if(size1!=size2)
{
thrownewInvalidOperationException(
"Embedding vectors must have the same length to calculate cosine similarity. "+
$"Embedding 1 length: {size1}; Embedding 2 length: {size2}.");
}

returnTensorPrimitives.CosineSimilarity(this.Data.Span,embedding.Data.Span);
}

/// <summary>
/// Convert Semantic Kernel data type
/// </summary>
publicstaticimplicitoperatorEmbedding(ReadOnlyMemory<float>data)=>new(data);

/// <summary>
/// Allows simple embedding definition using float[]
/// </summary>
publicstaticimplicitoperatorEmbedding(float[]data)=>new(data);

publicreadonlyboolEquals(Embeddingother)=>this.Data.Equals(other.Data);

publicoverridereadonlyboolEquals(object?obj)=>(objisEmbeddingother&&this.Equals(other));

publicstaticbooloperator==(Embeddingv1,Embeddingv2)=>v1.Equals(v2);

publicstaticbooloperator!=(Embeddingv1,Embeddingv2)=>!(v1==v2);

publicoverridereadonlyintGetHashCode()=>this.Data.GetHashCode();

/// <summary>
/// Note: use Embedding.JsonConverter to serialize objects using
/// the Embedding type, for example:
/// [JsonPropertyName("vector")]
/// [JsonConverter(typeof(Embedding.JsonConverter))]
/// public Embedding Vector { get; set; }
/// </summary>
publicsealedclassJsonConverter:JsonConverter<Embedding>
{
/// <summary>An instance of a converter for float[] that all operations delegate to</summary>
privatestaticreadonlyJsonConverter<float[]>s_converter=
(JsonConverter<float[]>)newJsonSerializerOptions().GetConverter(typeof(float[]));

publicoverrideEmbeddingRead(refUtf8JsonReaderreader,TypetypeToConvert,JsonSerializerOptionsoptions)
{
returnnewEmbedding(s_converter.Read(refreader,typeof(float[]),options)??[]);
}

publicoverridevoidWrite(Utf8JsonWriterwriter,Embeddingvalue,JsonSerializerOptionsoptions)
{
s_converter.Write(writer,MemoryMarshal.TryGetArray(value.Data,outArraySegment<float>array)&&array.Count==value.Length
?array.Array!
:value.Data.ToArray(),options);
}
}
}