Cosine Similarity

What is Cosine Similarity?
Cosine similarity is a measure of similarity between two non-zero vectors of an inner product space that measures the cosine of the angle between them. It is often used in information retrieval and text mining to compare documents and text similarity. The cosine similarity is defined as the dot product of the two vectors divided by the product of their magnitudes.

Photo by Victor Chartin on Unsplash

Formula for the cosine similarity
cosine similarity = (a . b) / (||a|| ||b||) where a and b are the two vectors being compared, “.” represents the dot product of the two vectors, and “||a||” and “||b||” represent the magnitudes of the two vectors

Java Code that calculates the cosine similarities between two vectors:

import java.util.*;

public class CosineSimilarity {
  public static double cosineSimilarity(double[] vectorA, double[] vectorB) {
    double dotProduct = 0.0;
    double normA = 0.0;
    double normB = 0.0;
    for (int i = 0; i < vectorA.length; i++) {
      dotProduct += vectorA[i] * vectorB[i];
      normA += Math.pow(vectorA[i], 2);
      normB += Math.pow(vectorB[i], 2);
    }
    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
  }

  public static void main(String[] args) {
    double[] vectorA = {1, 2, 3};
    double[] vectorB = {3, 2, 1};
    double cosineSimilarity = cosineSimilarity(vectorA, vectorB);
    System.out.println("Cosine similarity: " + cosineSimilarity);
  }
}

This program defines a cosineSimilarity() function that takes two double arrays as input and returns the cosine similarity between them. It first calculates the dot product of the two vectors and the magnitude of each vector. It then divides the dot product by the product of the magnitudes to get the cosine similarity

Python code for finding cosine similarities

import numpy as np

def cosine_similarity(a, b):
    dot_product = np.dot(a, b)
    norm_a = np.linalg.norm(a)
    norm_b = np.linalg.norm(b)
    return dot_product / (norm_a * norm_b)

# Example usage
a = np.array([1, 2, 3])
b = np.array([3, 2, 1])
similarity = cosine_similarity(a, b)
print("Cosine similarity:", similarity)

Use cases for cosine similarity

Text mining: Cosine similarity can be used to compare documents and determine their similarity. This can be useful for tasks such as document clustering, information retrieval, and recommendation systems

Image processing: Cosine similarity can be used to compare images and determine their similarity. This can be useful for tasks such as image retrieval and object recognition

Collaborative filtering: Cosine similarity can be used in collaborative filtering to recommend items to users based on their similarity to other users

Some limitations of using cosine similarity

Linear dependence: Cosine similarity may not be effective in cases where two vectors are linearly dependent. In such cases, the cosine similarity may be 1, even if the vectors are not very similar.

Magnitude: Cosine similarity does not take into account the magnitude of the vectors being compared, only their direction. This means that vectors with different magnitudes may be considered similar, even if they are not

Sparsity: Cosine similarity works best when there are a great many (and likely sparsely populated) features to choose from. If the vectors being compared are not sparse, then other similarity measures may be more appropriate

However, we can use Cosine Similarity for recommendations. This is one of the simple most use cases for this. Using this machine learning concept, we can develop a movie recommendation system.