Cosine Similarity and Cosine Distance

Cosine similarity is a measure of the similarity of two vectors. Cosine similarity is commonly used in semantic text search, generative AI, searches of images and audio files, and other applications.

In these applications, images, blocks of text, audio files, and other content are converted to vectors. These vectors can be stored and then searched over using measures of vector similarity, including cosine similarity.

Also see Working with Vector Data for more information about and examples of working with vector data in SingleStore.

Cosine Similarity Calculation: Cosine similarity can be calculated in two different ways in SingleStore. Cosine similarity can be calculated with the DOT_PRODUCT function when the input vectors are all of length 1. SingleStore recommends normalizing all vectors before storing in the database and then using DOT_PRODUCT to calculate cosine similarity. Vector Normalization provides a function for normalizing vectors in SingleStore.

Using DOT_PRODUCT to calculate cosine similarity gives the best performance since DOT_PRODUCT does not have to normalize its input every time it is called and because indexed vector search can be used. 


When performing cosine similarity calculations with DOT_PRODUCT, the vectors should be normalized to length 1 before storing them in the database.

Example 1 below shows a brief example of using DOT_Product.

In some cases, it is necessary to calculate cosine similarity directly or to calculate cosine distance. Example 2 defines functions for cosine_similiarity and cosine_distance. cosine distance is the inverse of cosine similarity (cosine_distance = 1 - cosine_similarity). These functions are more expensive than DOT_PRODUCT.

Euclidean distance is another common measure or vector similarity. See EUCLIDEAN_DISTANCE for information on using the Euclidean distance metric in SingleStore.


When finding the top K closest matches, descending (DESC) sort order must be used when you are using DOT_PRODUCT and cosine similarity. The sort order for cosine distance and Euclidean distance are opposite of the sort order for cosine similarity; use ascending (ASC) sort order for cosine distance and EUCLIDEAN_DISTANCE.


Example 1 - Cosine Similarity using DOT_PRODUCT

To calculate the cosine similarity between two vectors, make sure your vectors are all of length 1 before storing them in your database, and then simply use DOT_PRODUCT.


This example assumes that the vectors are already normalized. And, for the purposes of this example, we assume that the vectors in the example have length 1. In fact, these vectors have length very close to 1, but not exactly 1. The vectors have been simplified to improve the readability of the example. In practice, it is important to use fully normalized vectors.

The example below demonstrates the use of DOT_PRODUCT to find the cosine similarity between a query vector and vectors in a table.

CREATE TABLE vectors_b (id int, vec BLOB not null);
INSERT INTO vectors_b VALUES (1, JSON_ARRAY_PACK('[0.1, 0.8, 0.2, 0.555]')); 
INSERT INTO vectors_b VALUES (2, JSON_ARRAY_PACK('[0.45, 0.55, 0.495, 0.5]'));

The SQL below creates a query vector and then uses DOT_PRODUCT to find the cosine similarity between the @query_vec and the vectors in the vectors_b table.

SET @query_vec = JSON_ARRAY_PACK('[0.44, 0.554, 0.34, 0.62]');
SELECT DOT_PRODUCT(vec, @query_vec) AS score 
FROM vectors_b
| score               |
| 0.9810000061988831  |
| 0.8993000388145447  |

Example 2 - Cosine Similarity and Cosine Distance

The following is a User Defined Function (UDF) (CREATE FUNCTION (UDF)) for calculating cosine similarity.

CREATE OR REPLACE FUNCTION cosine_similarity(v1 BLOB, v2 BLOB)
  RETURN DOT_PRODUCT(normalize(v1), normalize(v2));
END //

This function uses DOT_PRODUCT and the normalize function defined in Vector Normalization to compute the cosine similarity of two vectors of length 4.

You can adapt this code to suit your application by changing the vector length. If you work with different vector lengths, you can create a function with a different name for each desired length.

The UDF below calculates cosine_distance using the cosine_similarity UDF defined above.

  RETURN 1 - cosine_similarity(v1, v2);
END //

With cosine similarity, a higher score means the vectors have greater similarity. The opposite is true of cosine difference, in which a lower score (lower distance) means the vectors are more similar.


For top K queries, you must use a descending (DESC) sort order when using cosine similarity and an ascending (ASC) sort order when using cosine distance.

The following examples use the functions above to compute similarity and distance for all pairs of a set of three vectors.

CREATE TABLE <table_name> (id INT, v BLOB);
INSERT INTO <table_name>
(1, JSON_ARRAY_PACK('[3, 4, 7]')),
  (2, JSON_ARRAY_PACK('[-2, 0, 6]')),
  (3, JSON_ARRAY_PACK('[1, 0, 0]'));

The SELECT clause below uses the id column from both instances in the table (Note: a1 and a2 are aliases). The cosine similarity is calculated based on the two vectors a1.v and a2.v. The cosine distance is calculated between the vectors a1.v and a2.v. The FROM clause specifies the table being used. The WHERE clause is used so a row is not compared with itself. Note: the operator <>; indicates not equal. ORDER BY ALL indicates the results will be in default order.

SELECT,, FORMAT(cosine_similarity(a1.v, a2.v), 3),
    FORMAT(cosine_distance(a1.v, a2.v), 3) 
FROM <table_name> a1, <table_name> a2 

Last modified: March 12, 2024

Was this article helpful?