Como faço para calcular a similaridade do cosseno de dois vetores?
-
21-08-2019 - |
Pergunta
Como faço para encontrar a similaridade do cosseno entre os vetores?
Eu preciso encontrar a similaridade para medir o parentesco entre duas linhas de texto.
Por exemplo, eu tenho duas frases como:
sistema de interface de usuário
máquina de interface de usuário
... e seus respectivos vetores após TF-IDF, seguido pela normalização usando LSI, por exemplo
[1,0.5]
e [0.5,1]
.
Como faço para medir a smiliarity entre esses vetores?
Solução
public class CosineSimilarity extends AbstractSimilarity {
@Override
protected double computeSimilarity(Matrix sourceDoc, Matrix targetDoc) {
double dotProduct = sourceDoc.arrayTimes(targetDoc).norm1();
double eucledianDist = sourceDoc.normF() * targetDoc.normF();
return dotProduct / eucledianDist;
}
}
Eu fiz algumas coisas tf-idf recentemente para minha unidade de Information Retrieval na Universidade. Eu usei esse método Cosine Similaridade que usa Jama:. Java Matrix Package
Para o código fonte completo ver IR Math com Java: medidas de similaridade , realmente bom recurso que cobre um bom número de diferentes medidas de similaridade.
Outras dicas
Se você quiser evitar depender de bibliotecas de terceiros para uma tarefa tão simples, aqui é uma implementação Java simples:
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));
}
Note que a função assume que os dois vetores têm o mesmo comprimento. Você pode querer verificá-la explicitamente para a segurança.
Tenha um olhar em: http://en.wikipedia.org/wiki/Cosine_similarity .
Se você tem vetores A e B.
A semelhança é definida como:
cosine(theta) = A . B / ||A|| ||B||
For a vector A = (a1, a2), ||A|| is defined as sqrt(a1^2 + a2^2)
For vector A = (a1, a2) and B = (b1, b2), A . B is defined as a1 b1 + a2 b2;
So for vector A = (a1, a2) and B = (b1, b2), the cosine similarity is given as:
(a1 b1 + a2 b2) / sqrt(a1^2 + a2^2) sqrt(b1^2 + b2^2)
Exemplo:
A = (1, 0.5), B = (0.5, 1)
cosine(theta) = (0.5 + 0.5) / sqrt(5/4) sqrt(5/4) = 4/5
Para código de matriz em Java Eu recomendo usar o href="http://acs.lbl.gov/~hoschek/colt/" rel="nofollow noreferrer"> Colt biblioteca . Se você tem isso, os olhares de código, como (não testado ou mesmo compilado):
DoubleMatrix1D a = new DenseDoubleMatrix1D(new double[]{1,0.5}});
DoubleMatrix1D b = new DenseDoubleMatrix1D(new double[]{0.5,1}});
double cosineDistance = a.zDotProduct(b)/Math.sqrt(a.zDotProduct(a)*b.zDotProduct(b))
O código acima pode também ser alterado para utilizar um dos métodos Blas.dnrm2()
ou Algebra.DEFAULT.norm2()
para o cálculo norma. Exatamente o mesmo resultado, o que é mais legível depende do gosto.
Quando eu estava trabalhando com texto mineração algum tempo atrás, eu estava usando o href="https://github.com/Simmetrics/simmetrics" rel="nofollow noreferrer"> SimMetrics biblioteca que fornece uma extensa gama de diferentes métricas em Java. Se isso aconteceu que você precisa mais, então há sempre R e CRAN para olhar.
Mas codificá-lo a partir da descrição na Wikipedia é tarefa bastante trivial, e pode ser um exercício agradável.
Para a representação esparsa de vetores utilizando Map(dimension -> magnitude)
Aqui está uma versão scala (Você pode fazer coisas semelhantes em Java 8)
def cosineSim(vec1:Map[Int,Int],
vec2:Map[Int,Int]): Double ={
val dotProduct:Double = vec1.keySet.intersect(vec2.keySet).toList
.map(dim => vec1(dim) * vec2(dim)).sum
val norm1:Double = vec1.values.map(mag => mag * mag).sum
val norm2:Double = vec2.values.map(mag => mag * mag).sum
return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2))
}
def cosineSimilarity(vectorA: Vector[Double], vectorB: Vector[Double]):Double={
var dotProduct = 0.0
var normA = 0.0
var normB = 0.0
var i = 0
for(i <- vectorA.indices){
dotProduct += vectorA(i) * vectorB(i)
normA += Math.pow(vectorA(i), 2)
normB += Math.pow(vectorB(i), 2)
}
dotProduct / (Math.sqrt(normA) * Math.sqrt(normB))
}
def main(args: Array[String]): Unit = {
val vectorA = Array(1.0,2.0,3.0).toVector
val vectorB = Array(4.0,5.0,6.0).toVector
println(cosineSimilarity(vectorA, vectorA))
println(cosineSimilarity(vectorA, vectorB))
}
Versão scala