利用余弦计算文本相似性

余弦相似性

余弦的概念对我们来说并不陌生，中学数学就开始接触余弦的概念了，在三角形中，余弦的公式是：

cosα=b2+c2−a22bc(式1−1)

在向量表示的三角形中，假设向量 a⃗ =(x1,y1) , b⃗ =(x2,y2) 则向量 a⃗ ,和向量b⃗  的夹角的余弦为：

cos（a⃗ ,b⃗ ）=a⃗ ⋅b⃗ |a||b|(式1−2)

余弦有这样的性质：余弦值越接近1，就表明夹角越接近0度，也就是两个向量越相似，夹角等于0，即两个向量相等，这就叫”余弦相似性”。
那么该怎么利用余弦来计算文本的相似性了？首先来看一个例子。

文本1：我们喜欢足球
文本2：我喜欢踢足球

大致思路是：我们认为问用词越相似，则文本的相似度越高，所以计算文本相似性主要按照以下步骤进行：

1. 分词
   此处利用 ansj 分词工具进行分词，文本1和文本2的分词结果为：
   文本1：我/喜欢/足球
   文本2：我们/喜欢/踢/足球

2. 列出所有的词
   我, 喜欢, 踢, 我们, 足球

3. 计算词频
   文本1： 我：1，喜欢：1，踢：0，我们：0，足球：1
   文本2： 我：0，喜欢：1，踢：1，我们：1，足球：1

4. 转化为向量
   文本1：[1, 1, 0, 0, 1]
   文本2：[0, 1, 1, 1, 1]

代码示例

package com.myapp.ml.nlp;

import lombok.Data;

/**
 * Created by lionel on 16/12/21.
 */
@Data
public class WordValue {
    private String word;
    private Integer frequecy;

    public WordValue() {
    }

    public WordValue(String word, Integer frequecy) {
        this.word = word;
        this.frequecy = frequecy;
    }

}

package com.myapp.ml.nlp;

import org.ansj.domain.Term;
import org.ansj.splitWord.analysis.ToAnalysis;
import org.ansj.util.FilterModifWord;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Created by lionel on 16/12/21.
 */
public class CosineSimilarity {
    /**
     * 向量余弦
     *
     * @param text1 文本1
     * @param text2 文本2
     * @return 向量余弦
     */
    public double cos(String text1, String text2) {
        if (StringUtils.isBlank(text2 + text1)) {
            return 0.0;
        }
        List words = parse(text1);
        List words1 = parse(text2);
        Set set = mergeList(words, words1);
        List wordValueList = computeWordCount(words);
        List wordValueList1 = computeWordCount(words1);
        int[] vector = wordToVector(set, wordValueList);
        int[] vector1 = wordToVector(set, wordValueList1);
        int moduleA = 0;
        int moduleB = 0;
        int AMutiplyB = 0;
        for (int i = 0; i < vector.length; i++) {
            moduleA += vector[i] * vector[i];
            moduleB += vector1[i] * vector1[i];
            AMutiplyB += vector[i] * vector1[i];
        }
        return (double) AMutiplyB / (Math.sqrt(moduleA) * Math.sqrt(moduleB));

    }

    /**
     * 转化为向量
     *
     * @param set  所有的词表
     * @param list 词信息
     * @return 向量
     */

    private int[] wordToVector(Set set, List list) {
        if (set == null || set.size() == 0 || list == null || list.size() == 0) {
            return null;
        }
        List mergeList = new ArrayList(set);
        int[] vector = new int[mergeList.size()];

        for (int i = 0; i < mergeList.size(); i++) {
            for (WordValue wordValue : list) {
                if (wordValue.getWord().equals(mergeList.get(i))) {
                    vector[i] = wordValue.getFrequecy();
                    break;
                } else {
                    vector[i] = 0;
                }
            }
        }
        return vector;
    }

    /**
     * 分词
     *
     * @param text 文本
     * @return 分词结果
     */

    private List parse(String text) {
        if (StringUtils.isBlank(text)) {
            return null;
        }

        List terms = FilterModifWord.modifResult(ToAnalysis.parse(text));
        if (terms == null || terms.size() == 0) {
            return null;
        }
        List words = new ArrayList();
        for (Term term : terms) {
            if (StringUtils.isNotBlank(term.getName())) {
                words.add(term.getName());
            }
        }
        return words;
    }

    /**
     * 获取所有的词
     *
     * @param str1 文本1分词结果
     * @param str2 文本2分词结果
     * @return 返回所有的词，不重复
     */

    private Set mergeList(List str1, List str2) {
        if (str1 == null || str1.size() == 0
                || str2 == null || str2.size() == 0) {
            return null;
        }
        Set set = new HashSet();
        for (String ele : str1) {
            set.add(ele);
        }
        for (String ele : str2) {
            set.add(ele);
        }
        return set;
    }

    /**
     * 计算词频
     *
     * @param list 分词结果
     * @return 词频
     */

    private List computeWordCount(List list) {
        List wordValueList = new ArrayList();
        for (String element : list) {
            if (isInWordValueList(element, wordValueList)) {
                WordValue wordValue = wordValueList.get(getElementIndex(element, wordValueList));
                wordValue.setFrequecy(wordValue.getFrequecy() + 1);
            } else {
                WordValue wordValue = new WordValue(element, 1);
                wordValueList.add(wordValue);
            }
        }
        return wordValueList;
    }

    private int getElementIndex(String word, List wordValueList) {
        if (StringUtils.isBlank(word) || wordValueList == null || wordValueList.size() == 0) {
            return -1;
        }
        for (int i = 0; i < wordValueList.size(); i++) {
            if (wordValueList.get(i).getWord().equals(word)) {
                return i;
            }
        }
        return -1;
    }

    private boolean isInWordValueList(String str, List wordValueList) {
        if (StringUtils.isBlank(str) || wordValueList == null || wordValueList.size() == 0) {
            return false;
        }
        for (WordValue wordValue : wordValueList) {
            if (wordValue.getWord().equals(str)) {
                return true;
            }
        }
        return false;
    }
}

测试代码

package com.myapp.ml.nlp;

import org.junit.Test;

/**
 * Created by lionel on 16/12/21.
 */
public class CosineSimilarityTest {
    @Test
    public void test() {
        String text = "我喜欢足球";
        String text1 = "我们喜欢踢足球";
        CosineSimilarity cosineSimilarity = new CosineSimilarity();
        System.out.println(cosineSimilarity.cos(text, text1));//0.5773502691896258
    }
}

以上程序结果是0.5773502691896258，经验证结果是正确的。
注意：以上程序只符合简单的应用情况,不适用复杂的情况。另外，余弦相似性还可以用来判别文档的相似性，大致思路是：首先求出文档的关键词（可以利用 TF-IDF 方法），以后可以按照以上2，3，4步骤进行计算。