Cosine Similarity

easyFREEText RepresentationNLP 1: Foundations

Calculate the cosine similarity between two vectors.

Cosine similarity measures the angle between two vectors, regardless of their magnitude:

$\text{cosine\_similarity}(A, B) = \frac{A \cdot B}{\|A\| \times \|B\|}$

Where:

$A \cdot B = \sum_i A_i \times B_i$ (dot product)
$\|A\| = \sqrt{\sum_i A_i^2}$ (Euclidean norm)

This is widely used in NLP to measure document or word similarity.

Input: cosine_similarity(a, b) receives two lists of numbers of the same length (vectors A and B). The example shows each vector as a line of space-separated values.

Output: Return the cosine similarity as a float rounded to 4 decimal places.

Example

Input

1 2 3
4 5 6

Output

0.9746

Reasoning

Inputs: a $= [1, 2, 3]$ and b $= [4, 5, 6]$ are two vectors of the same length (3), e.g. word or document embeddings.
Dot product: multiply matching entries and add them: $1 \cdot 4 + 2 \cdot 5 + 3 \cdot 6 = 4 + 10 + 18 = 32$ .
Lengths: $\|A\| = \sqrt{1 + 4 + 9} = \sqrt{14} \approx 3.7417$ and $\|B\| = \sqrt{16 + 25 + 36} = \sqrt{77} \approx 8.7750$ . Their product is $\sqrt{1078} \approx 32.8329$ .
Divide: $32 / 32.8329 \approx 0.97463$ , which rounds to 4 decimal places as 0.9746.
Output: a single float in $[-1, 1]$ . A value this close to 1 means the two vectors point in almost the same direction, even though $B$ is more than twice as long as $A$ .
Notice that scaling a vector changes nothing: $A = [2, 4, 6]$ gives the same 0.9746, while perpendicular vectors give 0.0.

Constraints

Both vectors have the same length
Vectors are non-zero
Use only math module (no numpy)
Round result to 4 decimal places

Learn this in

Word EmbeddingsNLP Study Plan

More from NLP 1: Foundations

Embedding Lookupeasy Cosine Similarity Calculatoreasy Binary Vectorizereasy Document Term Matrixeasy Character Frequency Countereasy

Concept primer

Background Knowledge

The cosine similarity is a measure used to calculate the similarity between two vectors. It is defined as the dot product of the two vectors divided by the product of their Euclidean norms. The cosine similarity is a widely used metric in Natural Language Processing (NLP) to measure the similarity between documents or words. It is particularly useful for comparing vectors in high-dimensional spaces, where other similarity metrics may not be effective.

The dot product of two vectors $A$ and $B$ is the sum of the products of their corresponding components. It is a way to combine two vectors by multiplying their corresponding elements and summing them up. The Euclidean norm, also known as the magnitude or length of a vector, is the square root of the sum of the squares of its components. It is a measure of the length of a vector in a multi-dimensional space.

In the context of NLP, the cosine similarity is used to compare the semantic meaning of words or documents. By representing words or documents as vectors in a high-dimensional space, the cosine similarity can be used to measure the similarity between them. This is particularly useful in applications such as text classification, clustering, and information retrieval.

Algorithm/Approach

The general approach to solving this problem involves calculating the dot product of the two input vectors and their Euclidean norms, and then using these values to compute the cosine similarity. This can be achieved by following a simple mathematical formula, which involves summing up the products of corresponding components of the two vectors and dividing by the product of their lengths.

Step-by-Step Strategy

To implement the solution, follow these steps:

Read the input vectors from the input lines
Calculate the dot product of the two vectors by summing up the products of their corresponding components
Calculate the Euclidean norm of each vector by summing up the squares of their components and taking the square root
Compute the cosine similarity by dividing the dot product by the product of the Euclidean norms
Round the result to 4 decimal places

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
Failing to round 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 number of components in the input vectors, since we need to iterate over each component to calculate the dot product and Euclidean norms. The space complexity is O(1), since we only need to store a few variables to store the intermediate results. Note that the input vectors are assumed to be stored in memory already, so we don't need to account for their space complexity.

solution.py

Python 3.13

Test results