计算 lambda 层中两个张量向量之间的余弦相似度？

Question

Here's the basic code,

def euclidean_distance(vects):
    x, y = vects
    sum_square = K.sum(K.square(x - y), axis=1, keepdims=True)
    return K.sqrt(K.maximum(sum_square, K.epsilon()))

def eucl_dist_output_shape(shapes):
    shape1, shape2 = shapes
    return (shape1[0], 1)


# measure the similarity of the two vector outputs
output = Lambda(euclidean_distance, name="output_layer", output_shape=eucl_dist_output_shape)([output_a, output_b])

# specify the inputs and output of the model
model = Model([input_a, input_b], output)

I want to use cosine similarity (0 to 1 scale) instead of euclidean distance to measure the similarity between two vectors, I tried to use cosine_similarity from scikit-learn but it didn't work.

So, we need to use keras.backend to build it? Can someone tell me how do I do it?

Answer 1

Previously, in old keras , we can use mode='cos' in the merge layer but it's deprecated in new tf. keras tf. keras . Now we can use layers. Dot layers. Dot layer and specify normalize=True for cosine proximity or cosine similarity or ( 1 - cosine distance ). According to the doc :

tf.keras.layers.Dot(
    axes, normalize=False, **kwargs
)

normalize : Whether to L2-normalize samples along the dot product axis before taking the dot product. If set to True , then the output of the dot product is the cosine proximity between the two samples.

So, we can compute cosine similarity of the two samples using the built-in layer. But as you seeking a way to use the Lambda layer to wrap a custom-defined cosine similarity function, here are some demonstration using both of them.

from tensorflow.keras import backend as K
from tensorflow.keras.layers import Lambda
import tensorflow as tf 

# computing cosine similarity 
def cosine_similarity(vests):
    x, y = vests
    x = K.l2_normalize(x, axis=-1)
    y = K.l2_normalize(y, axis=-1)
    return K.batch_dot(x, y, axes=-1)

def cos_sim_output_shape(shapes):
    shape1, shape2 = shapes
    return (shape1[0], 1)

Let's take 2 samples and run them to check their similarity:

# 2 samples 
x1 = tf.keras.layers.Dense(8)(np.arange(10).reshape(5, 2))
x2 = tf.keras.layers.Dense(8)(np.arange(10).reshape(5, 2))

# (1). Wrap custom function into Lambda layer
distance = Lambda(cosine_similarity, 
                  output_shape=cos_sim_output_shape)([x1, x2])
print(distance.shape, distance.numpy())

# (2). Use built-in method: Dot layer with normalize = True
dotted = tf.keras.layers.Dot(axes=-1, normalize=True)([x1, x2])
print(dotted.shape, dotted.numpy())

(5, 1) [[-0.22463222]
 [-0.22639492]
 [-0.2283202 ]
 [-0.22915731]
 [-0.22962123]]

(5, 1) [[-0.22463222]
 [-0.22639492]
 [-0.2283202 ]
 [-0.22915731]
 [-0.22962123]]

Answer 2

The following article has details on how to calculate the cosine similarity. I have created a simple example using the same article:

Article: https://towardsdatascience.com/cosine-similarity-how-does-it-measure-the-similarity-maths-behind-and-usage-in-python-50ad30aad7db

Example:

import tensorflow as tf
from tensorflow.keras.layers import Lambda

A = tf.constant([7,3])
B = tf.constant([3,7])

# cosine similarity between A and B using numpy

def cos_sim(vects):
  A, B = vects
  cos_sim=np.dot(A,B)/(np.linalg.norm(A)*np.linalg.norm(B))
  return cos_sim

output = Lambda(cos_sim, name="output_layer")([A, B])

>>>output: 0.7241379310344827