python推荐算法之余弦相似度

前言

假设有一组数据集，该数据集包含有多个数据特征，现在需要对其特征维度进行算法分析，判断相互之间的相似度。如果说，有了特征维度的数据，再结合余弦定理的算法进行向量化，分析起来倒比较方便。所以说，重点是找出该数据集的特征维度。

代码如下：

import pandas as pd
import time
import re
import math


def fx_data():

    # 特征信息
    data_list = ['hello world',
                 'hello james, you are handsame',
                 'hello world, hello python']
    n = 0
    for t1 in data_list:
        text_x = t1   # 从列表取出数据1，依次与数据2中的信息进行对比
        n += 1
        for t2 in data_list[n:]:
            text_y = t2     # 取出数据2 (数据2不包含数据1)

            # 找出文本词频
            word_1 = text_x.split(' ')
            word_2 = text_y.split(' ')

            word_1_dict = {}
            word_2_dict = {}
            for w1 in word_1:
                word = re.sub('[^a-zA-Z]', '', w1)
                word_x = word.lower()   # 将大写字符转换为小写

                # if word_s != '' and word_1_dict.has_key(word_s):
                if word_x != '' and word_x in word_1_dict:
                    num = word_1_dict[word_x]
                    word_1_dict[word_x] = num + 1
                elif word_x != '':
                    word_1_dict[word_x] = 1
                else:
                    continue
            # print(word_1_dict)

            for w2 in word_2:
                word = re.sub('[^a-zA-Z]', '', w2)
                word_y = word.lower()

                if word_y != '' and word_y in word_2_dict:
                    num = word_2_dict[word_y]
                    word_2_dict[word_y] = num + 1
                elif word_y != '':
                    word_2_dict[word_y] = 1
                else:
                    continue
            # print(word_2_dict)

            dic1 = sorted(word_1_dict.items(), key=lambda x: x[1], reverse=True)
            dic2 = sorted(word_2_dict.items(), key=lambda y: y[1], reverse=True)

            # 获取词向量
            word_key = []
            for i in range(len(dic1)):
                # 向word_key添加元素
                word_key.append(dic1[i][0])
            for j in range(len(dic2)):
                if dic2[j][0] in word_key:
                    pass
                else:
                    word_key.append(dic2[j][0])
            # print(word_key)

            v1 = []   # 存放向量数据
            v2 = []   # 存放向量数据
            for w in word_key:
                if w in word_1_dict:
                    v1.append(word_1_dict[w])
                else:
                    v1.append(0)
                if w in word_2_dict:
                    v2.append(word_2_dict[w])
                else:
                    v2.append(0)
            # print(v1)
            # print(v2)

            # 余弦相似度计算
            sum = 0
            q1 = 0
            q2 = 0

            for s in range(len(v1)):
                sum += v1[s] * v2[s]
                q1 += pow(v1[s], 2)     # pow() 方法返回 xy（x的y次方） 的值
                q2 += pow(v2[s], 2)
            try:
                # round() 方法返回浮点数x的四舍五入值
                result = round(float(sum) / (math.sqrt(q1) * math.sqrt(q2)), 2)
            except ZeroDivisionError:
                result = 0.0
            print(text_x, '与', text_y, '余弦相似度为:', result)
            # return result


if __name__ == '__main__':
    start_time = time.time()
    fx_data()
    end_time = time.time()
    print('耗费时间: ', end_time-start_time)

这里的具体算法思路就不细说了，可以好好看看余弦相似度算法。

如果喜欢本文或者本文对你有帮助的话，记得关注小编并点个赞哟，欢迎留言私信。

机器学习|决策树-sklearn实现