def lev(str_a,str_b):
    """
    ED距离，用来衡量单词之间的相似度
    :param str_a:
    :param str_b:
    :return:
    """
    str_a=str_a.lower()
    str_b=str_b.lower()
    matrix_ed=np.zeros((len(str_a)+1,len(str_b)+1),dtype=np.int)
    matrix_ed[0]=np.arange(len(str_b)+1)
    matrix_ed[:,0] = np.arange(len(str_a) + 1)
    for i in range(1,len(str_a)+1):
        for j in range(1,len(str_b)+1):
            # 表示删除a_i
            dist_1 = matrix_ed[i - 1, j] + 1
            # 表示插入b_i
            dist_2 = matrix_ed[i, j - 1] + 1
            # 表示替换b_i
            dist_3 = matrix_ed[i - 1, j - 1] + (1 if str_a[i - 1] != str_b[j - 1] else 0)
            #取最小距离
            matrix_ed[i,j]=np.min([dist_1, dist_2, dist_3])
    print(matrix_ed)
    return matrix_ed[-1,-1]

import pandas as pd
import jieba
import numpy  as np
from sklearn.externals import joblib
from scipy.linalg import norm


class TF_IDF_Model(object):
    def __init__(self, corpus_list):

        self.documents_list = corpus_list
        self.documents_number = len(corpus_list)
        self.get_idf()

    def get_idf(self):
        df = {}
        self.idf = {}
        tf = []
        for document in self.documents_list:
            temp = {}
            for word in document:
                temp[word] = temp.get(word, 0) + 1 / len(document)
            tf.append(temp)
            for key in temp.keys():
                df[key] = df.get(key, 0) + 1
        for key, value in df.items():
            self.idf[key] = np.log10(self.documents_number / (value + 1))

    def get_tf(self, document):
        document = list(jieba.cut(document))
        # tf = []
        temp = {}
        for word in document:
            temp[word] = temp.get(word, 0) + 1 / len(document)
        # tf.append(temp)
        return temp

    def tf_idf_vec(self, text):
        tf = self.get_tf(text)
        word = list(self.idf.keys())
        vec = [0] * len(self.idf)
        text = list(jieba.cut(text))
        for ele in text:
            if ele in word:
                vec[word.index(ele)] = tf[ele] * self.idf[ele]
        return vec

    def cal_similarty(self, sentence1, sentence2):
        vec1 = self.tf_idf_vec(sentence1)
        vec2 = self.tf_idf_vec(sentence2)
        similarty = np.dot(vec1, vec2) / (norm(vec1) * norm(vec2))
        return similarty


def train_model():
    #####bulid corpus
    corpus = pd.read_csv(corpus_path)
    corpus_list = corpus["name"].get_values().tolist()
    # corpus_list = corpus1["name"].get_values().tolist()
    corpus_list = [list(jieba.cut(str(doc))) for doc in corpus_list]
    tf_idf_model = TF_IDF_Model(corpus_list)
    joblib.dump(tf_idf_model, model_path)


def load_model(path):
    tf_idf_model = joblib.load(path)
    return tf_idf_model


if __name__ == '__main__':
    from supercat.data_qualifier.tf_idf import TF_IDF_Model
    ####
    train_model()
    ######
    tf_idf_model = load_model(model_path)
    sentence1="XXXX"
    sentence2="XXXX"
    print(tf_idf_model.get_tf(sentence1))
    print(tf_idf_model.idf)
    print(tf_idf_model.tf_idf_vec(sentence1))
    print(tf_idf_model.cal_similarty(sentence1,sentence2))

Aa01A01= 人 士 人物 人士 人氏 人选
Aa01A02= 人类 生人 全人类
Aa01A03= 人手 人员 人口 人丁 口 食指
Aa01A04= 劳力 劳动力 工作者
Aa01A05= 匹夫 个人

class WordSimilarity2010(SimilarBase):
    '''
        本类根据下面的论文方法：
        基于同义词词林的词语相似度计算方法，田久乐, 赵 蔚(东北师范大学 计算机科学与信息技术学院, 长春 130117 )
        计算两个单词所有编码组合的相似度，取最大的一个
    '''

    def __init__(self):
        super(WordSimilarity2010, self).__init__()
        self.a = 0.65
        self.b = 0.8
        self.c = 0.9
        self.d = 0.96
        self.e = 0.5
        self.f = 0.1
        self.degree = 180
        self.PI = math.pi

    def similarity(self, w1, w2):
        '''
        判断两个词的相似性。
        :param w1: [string]
        :param w2: [string]
        :return: [float]0~1之间。
        '''

        code1 = self._data.get(w1, None)
        code2 = self._data.get(w2, None)

        if not code1 or not code2:
            return 0  # 只要有一个不在库里则代表没有相似性。

        # 最终返回的最大相似度
        sim_max = 0

        # 两个词可能对应多个编码
        for c1 in code1:
            for c2 in code2:
                cur_sim = self.sim_by_code(c1, c2)
                # print(c1, c2, '的相似度为：', cur_sim)
                if cur_sim > sim_max:
                    sim_max = cur_sim

        return sim_max

    def sim_by_code(self, c1, c2):
        """
        根据编码计算相似度
        """

        # 先把code的层级信息提取出来
        clayer1 = self._parse_code(c1)
        clayer2 = self._parse_code(c2)

        common_layer = self.get_common_layer(clayer1,clayer2)
        length = len(common_layer)

        # 如果有一个编码以'@'结尾，那么表示自我封闭，这个编码中只有一个词，直接返回f
        if c1.endswith('@') or c2.endswith('@') or 0 == length:
            return self.f

        cur_sim = 0
        if 6 <= length:
            # 如果前面七个字符相同，则第八个字符也相同，要么同为'='，要么同为'#''
            if c1.endswith('=') and c2.endswith('='):
                cur_sim = 1
            elif c1.endswith('#') and c2.endswith('#'):
                cur_sim = self.e
        else:
            k = self.get_k(clayer1, clayer2)
            n = self.get_n(common_layer)
            if 1 == length:
                cur_sim = self.sim_formula(self.a, n, k)
            elif 2 == length:
                cur_sim = self.sim_formula(self.b, n, k)
            elif 3 == length:
                cur_sim = self.sim_formula(self.c, n, k)
            elif 4 == length:
                cur_sim = self.sim_formula(self.d, n, k)

        return cur_sim

    def sim_formula(self, coeff, n, k):
        """
        计算相似度的公式，不同的层系数不同
        """
        return coeff * math.cos(n * self.PI / self.degree) * ((n - k + 1) / n)

    def get_common_layer(self, ca, cb):
        '''
        返回相应的layer层
        :param ca:     [list(str)] 分解后的编码。
        :param cb:     [list(str)] 分解后的编码。
        :return:   [list(str)]列表代表相应的根编码。
        '''
        common_layer = []

        for i, j in zip(ca, cb):
            if i == j:
                common_layer.append(i)
            else:
                break
        return common_layer

    def get_k(self, c1, c2):
        """
        返回两个编码对应分支的距离，相邻距离为1
        """
        if c1[0] != c2[0]:
            return abs(ord(c1[0]) - ord(c2[0]))
        elif c1[1] != c2[1]:
            return abs(ord(c1[1]) - ord(c2[1]))
        elif c1[2] != c2[2]:
            return abs(int(c1[2]) - int(c2[2]))
        elif c1[3] != c2[3]:
            return abs(ord(c1[3]) - ord(c2[3]))
        else:
            return abs(int(c1[4]) - int(c2[4]))

    def get_n(self, common_layer):
        '''
        返回相应结点下有多少个同级子结点。
        :param common_layer:    [listr(str)]相同的结点。
        :return:    int
        '''

        end_node = self._code_tree
        for t_node_name in common_layer:
            end_node = end_node[t_node_name]

        if not isinstance(end_node, dict):
            return end_node
        return len(end_node.keys())

from word_similarity import WordSimilarity2010
import time

ws_tool = WordSimilarity2010()
start = time.time()
b_a = "联系方式"
b_b = "电话"
sim_b = ws_tool.similarity(b_a, b_b)
print(b_a, b_b, '相似度为', sim_b)
end = time.time()
print("运行时间："+str(end-start))
b_a = "手机"
b_b = "电话"
sim_b = ws_tool.similarity(b_a, b_b)
print(b_a, b_b, '相似度为', sim_b)
end = time.time()
print("运行时间："+str(end-start))

联系方式 电话 相似度为 0
运行时间：5.793571472167969e-05
手机 电话 相似度为 0.30484094213212237
运行时间：0.0001442432403564453

from hownet.howNet import How_Similarity
from cilin.V3.ciLin import CilinSimilarity

class HybridSim():
    '''
    混合相似度计算策略。使用了词林与知网词汇量的并集。扩大了词汇覆盖范围。
    '''
    ci_lin = CilinSimilarity()  # 实例化词林相似度计算对象
    how_net = How_Similarity()  # 实例化知网相似度计算对象
    Common = ci_lin.vocab & how_net.vocab
    A = how_net.vocab - ci_lin.vocab
    B = ci_lin.vocab - how_net.vocab

    @classmethod
    def get_Final_sim(cls, w1, w2):
        lin = cls.ci_lin.sim2018(w1, w2) if w1 in cls.ci_lin.vocab and w2 in cls.ci_lin.vocab else 0
        how = cls.how_net.calc(w1, w2) if w1 in cls.how_net.vocab and w2 in cls.how_net.vocab else 0

        if w1 in cls.Common and w2 in cls.Common:  # 两个词都被词林和知网共同收录。
            # print('两个词都被词林和知网共同收录。', end='\t')
            # print(w1, w2, '词林改进版相似度：', lin, end='\t')
            # print('知网相似度结果为：', how, end='\t')
            return lin * 1 + how * 0  # 可以调节两者的权重，以获取更优结果！！

        if w1 in cls.A and w2 in cls.A:  # 两个词都只被知网收录。
            return how
        if w1 in cls.B and w2 in cls.B:  # 两个词都只被词林收录。
            return lin

        if w1 in cls.A and w2 in cls.B:  # 一个只被词林收录，另一个只被知网收录。
            print('触发策略三，左词为知网，右词为词林')
            same_words = cls.ci_lin.code_word[cls.ci_lin.word_code[w2][0]]
            if not same_words:
                return 0.2
            all_sims = [cls.how_net.calc(word, w1) for word in same_words]
            print(same_words, all_sims, end='\t')
            return max(all_sims)

        if w2 in cls.A and w1 in cls.B:
            print('触发策略三，左词为词林，右词为知网')
            same_words = cls.ci_lin.code_word[cls.ci_lin.word_code[w1][0]]
            if not same_words:
                return 0.2
            all_sims = [cls.how_net.calc(word, w2) for word in same_words]
            print(w1, '词林同义词有：', same_words, all_sims, end='\t')
            return max(all_sims)

        if w1 in cls.A and w2 in cls.Common:
            print('策略四（左知网）：知网相似度结果为：', how)
            same_words = cls.ci_lin.code_word[cls.ci_lin.word_code[w2][0]]
            if not same_words:
                return how
            all_sims = [cls.how_net.calc(word, w1) for word in same_words]
            print(w2, '词林同义词有：', same_words, all_sims, end='\t')
            return 0.6 * how + 0.4 * max(all_sims)

        if w2 in cls.A and w1 in cls.Common:
            print('策略四（右知网）：知网相似度结果为：', how)
            same_words = cls.ci_lin.code_word[cls.ci_lin.word_code[w1][0]]
            if not same_words:
                return how
            all_sims = [cls.how_net.calc(word, w2) for word in same_words]
            print(same_words, all_sims, end='\t')
            return 0.6 * how + 0.4 * max(all_sims)

        if w1 in cls.B and w2 in cls.Common:
            print(w1, w2, '策略五（左词林）：词林改进版相似度：', lin)
            same_words = cls.ci_lin.code_word[cls.ci_lin.word_code[w1][0]]
            if not same_words:
                return lin
            all_sims = [cls.how_net.calc(word, w2) for word in same_words]
            print(w1, '词林同义词有：', same_words, all_sims, end='\t')
            return 0.6 * lin + 0.4 * max(all_sims)

        if w2 in cls.B and w1 in cls.Common:
            print(w1, w2, '策略五（右词林）：词林改进版相似度：', lin)
            same_words = cls.ci_lin.code_word[cls.ci_lin.word_code[w2][0]]
            if not same_words:
                return lin
            all_sims = [cls.how_net.calc(word, w1) for word in same_words]
            print(w2, '词林同义词有：', same_words, all_sims, end='\t')
            return 0.6 * lin + 0.4 * max(all_sims)

        print('对不起，词语可能未收录，无法计算相似度！')
        return -1

from Hybrid_Sim import HybridSim
from Pearson import *

import time


if __name__ == '__main__':

    print('词林词汇量', len(HybridSim.ci_lin.vocab ),'\t知网词汇量', len(HybridSim.how_net.vocab))
    print('两者总词汇量',len(HybridSim.ci_lin.vocab | HybridSim.how_net.vocab),'\t重叠词汇量', len(HybridSim.Common))
    b_a = "联系方式"
    b_b = "电话"
    start = time.time()
    hybrid = HybridSim.get_Final_sim(b_a, b_a)
    end = time.time()
    print(b_a+" "+b_b+"相似度为：", hybrid)
    print("运行时间："+str(end-start))
    b_a = "手机"
    b_b = "电话"
    start = time.time()
    hybrid = HybridSim.get_Final_sim(b_a, b_a)
    end = time.time()
    print(b_a+" "+b_b+"相似度为：", hybrid)
    print("运行时间："+str(end-start))

词林词汇量 77498 	知网词汇量 53336
两者总词汇量 85817 	重叠词汇量 45017
对不起，词语可能未收录，无法计算相似度！
联系方式 电话相似度为： -1
运行时间：3.504753112792969e-05
手机 电话相似度为： 1.0
运行时间：0.019332408905029297

def similarity(self, w1, w2):
    """Compute cosine similarity between two keys.

    Parameters
    ----------
    w1 : str
        Input key.
    w2 : str
        Input key.

    Returns
    -------
    float
        Cosine similarity between `w1` and `w2`.

    """
    return dot(matutils.unitvec(self[w1]), matutils.unitvec(self[w2]))

from gensim.models.word2vec import Word2Vec
import  pandas as pd
from gensim import models
import jieba
###train
data=pd.read_csv(data_path)
sentences=data.tolist()
model= Word2Vec()
model.build_vocab(sentences)
model.train(sentences,total_examples = model.corpus_count,epochs = 5)
model.save(model_path)

from gensim import models
import time

if __name__ == '__main__':
    model=models.Word2Vec.load(model_path)
    start = time.time()
    b_a = "联系方式"
    b_b = "电话"
    sim_b = model.wv.n_similarity(b_a, b_b)
    end = time.time()
    start = time.time()
    print(b_a, b_b, '相似度为', sim_b)
    print("运行时间：" + str(end - start))
    b_a = "手机"
    b_b = "电话"
    sim_b = model.wv.n_similarity(b_a, b_b)
    end = time.time()
    print(b_a, b_b, '相似度为', sim_b)
    print("运行时间：" + str(end - start))

联系方式 电话 相似度为 -0.014857853
运行时间：-4.76837158203125e-07
手机 电话 相似度为 0.1771852
运行时间：0.0004227161407470703