Cosine Similarity Calculator

easyFREEWord EmbeddingsNLP 1: Foundations

Given two vectors as lists of floats, compute the cosine similarity between them.

Cosine similarity measures the cosine of the angle between two vectors: $\text{cosine\_similarity} = \frac{A \cdot B}{\|A\| \times \|B\|}$

Round the result to 4 decimal places.

Function signature: cosine_similarity(a, b)

a: vector A (list of floats)
b: vector B (list of floats, same length as a)
Returns: the cosine similarity as a float rounded to 4 decimal places

Example

Input

1.0,0.0,1.0
0.0,1.0,1.0

Output

0.5

Reasoning

Inputs: a $= [1.0, 0.0, 1.0]$ and b $= [0.0, 1.0, 1.0]$ are two vectors in 3-D space. Only their directions matter for the result; their lengths get divided out.
Dot product: multiply matching components and add: $A \cdot B = (1)(0) + (0)(1) + (1)(1) = 1$ . Only the third coordinate, where both vectors are non-zero, contributes.
Magnitudes: $\|A\| = \sqrt{1^2 + 0^2 + 1^2} = \sqrt{2} \approx 1.4142$ , and likewise $\|B\| = \sqrt{2}$ .
Divide: $\dfrac{1}{\sqrt{2} \cdot \sqrt{2}} = \dfrac{1}{2} = 0.5$ , which is already exact at 4 decimal places, so the output is 0.5.
Notice: $\cos\theta = 0.5$ means the vectors are $60^\circ$ apart. Identical directions give 1.0 and perpendicular vectors such as $[1, 0]$ and $[0, 1]$ give 0.0. Scaling either vector by a positive constant never changes the answer.

Constraints

Vectors have the same dimension
Output: A single float rounded to 4 decimal places
Vectors will not be zero vectors

Learn this in

Tokenization & EmbeddingsLLM Study Plan

More from NLP 1: Foundations

Embedding Lookupeasy Binary Vectorizereasy Document Term Matrixeasy Character Frequency Countereasy Word Reversereasy

Concept primer

Background Knowledge

The cosine similarity is a measure used to calculate the similarity between two vectors. It is commonly used in Natural Language Processing (NLP) and information retrieval to compare the semantic meaning of documents or words. The cosine similarity is defined as the dot product of two vectors divided by the product of their magnitudes. This measure is useful because it is able to capture the orientation of the vectors in space, rather than just their magnitude.

In the context of word embeddings, cosine similarity is used to compare the semantic meaning of words. Word embeddings are vector representations of words in a high-dimensional space, where similar words are mapped to nearby points. By calculating the cosine similarity between two word embeddings, we can determine how similar the words are in meaning. For example, the words "dog" and "cat" would have a high cosine similarity because they are both animals, while the words "dog" and "car" would have a low cosine similarity because they are not related.

The formula for cosine similarity is given by:

\text{cosine\_similarity} = \frac{A \cdot B}{\|A\| \times \|B\|}

where $A \cdot B$ is the dot product of vectors $A$ and $B$ , and $\|A\|$ and $\|B\|$ are the magnitudes (or lengths) of vectors $A$ and $B$ , respectively.

Algorithm/Approach

The general approach to solving this problem involves the following steps:

Parse the input vectors from the comma-separated strings
Calculate the dot product of the two vectors
Calculate the magnitudes of the two vectors
Compute the cosine similarity using the formula
Round the result to 4 decimal places

This approach can be implemented using basic vector operations and does not require any advanced algorithms or data structures.

Step-by-Step Strategy

To implement the solution, follow these steps:

Read the input vectors from the comma-separated strings and store them in arrays or lists.
Calculate the dot product of the two vectors using a loop or a built-in function.
Calculate the magnitudes of the two vectors using the formula $\|A\| = \sqrt{\sum_{i=1}^{n} a_i^2}$ , where $a_i$ are the elements of vector $A$ .
Compute the cosine similarity using the formula and the calculated dot product and magnitudes.
Round the result to 4 decimal places using a rounding function.

Common Pitfalls

Some common pitfalls to watch out for when implementing this solution include:

Forgetting to handle edge cases, such as zero-length vectors
Using incorrect data types or precision for the calculations
Not rounding the result to the correct number of decimal places

Time & Space Complexity

The time complexity of this solution is O(n), where n is the length of the input vectors, because we need to iterate over the elements of the vectors to calculate the dot product and magnitudes. The space complexity is also O(n), because we need to store the input vectors in memory. However, the space complexity can be reduced to O(1) if we use a streaming approach and calculate the dot product and magnitudes on the fly, without storing the entire vectors in memory.

solution.py

Python 3.13

Test results