给定一个查询,我有一个文档的余弦分数.我也有文件pagerank.是否有标准的好方法将两者结合起来？

我在考虑增加它们

 Total_Score = cosine-score * pagerank

因为如果你在pagerank或cosine-score上得到低分,那么文档就不那么有趣了.

或者最好是加权和？

Total_Score = weight1 * cosine-score + weight2 * pagerank

这是否更好？然后你可能有零余弦分数,但是高分页,并且页面将显示在结果中.

数据结构:

User has many Profiles
    (Limit - no more than one of each profile type per user, no duplicates)
Profiles has many Attribute Values
    (A user can have as many or few attribute values as they like)
Attributes belong to a category
    (No overlap. This controls which attribute values a profile can have)

实施例/上下文:

我相信通过堆栈交换,您可以为一个用户提供许多配置文件,因为它们因交换站点不同而不同？在这个问题:

• 配置文件:视频,因此视频配置文件仅包含视频类别的属性
• 属性,因此视频类别中的属性可以是流派
• 属性值,例如喜剧,动作,惊悚都是属性值

配置文件和属性只是在两个级别上对属性值进行分组的方法.如果没有分组(在2.之后加权需要),关系就是User hasMany Attribute Values.

问题:

为每个用户提供与其他用户相似的评级.

1. 基于与用户关联的所有属性值的相似性.
   • 平/一层
   • 两个用户之间的属性值数量不等
   • 每个用户只能选择一次属性值,因此不能重复
   • 因此,具有余弦相似性的二进制字符串/布尔数组？
2. 1 +重量配置文件 …

我使用word2vec来表示一个小短语(3到4个单词)作为一个独特的向量,通过添加每个单独的嵌入或通过计算单词嵌入的平均值.

从我做过的实验中,我总是得到相同的余弦相似度.我怀疑它与训练后word2vec生成的单词长度(单位长度(Euclidean norm))有关吗？或者我在代码中有BUG,或者我遗漏了一些东西.

这是代码:

import numpy as np
from nltk import PunktWordTokenizer
from gensim.models import Word2Vec
from numpy.linalg import norm
from scipy.spatial.distance import cosine

def pattern2vector(tokens, word2vec, AVG=False):
    pattern_vector = np.zeros(word2vec.layer1_size)
    n_words = 0
    if len(tokens) > 1:
        for t in tokens:
            try:
                vector = word2vec[t.strip()]
                pattern_vector = np.add(pattern_vector,vector)
                n_words += 1
            except KeyError, e:
                continue
        if AVG is True:
            pattern_vector = np.divide(pattern_vector,n_words)
    elif len(tokens) == 1:
        try:
            pattern_vector = word2vec[tokens[0].strip()]
        except KeyError:
            pass
    return pattern_vector


def main():
    print "Loading …

我正在使用Python。现在我有一个mongoDB数据库集合，其中所有文档都有这样的格式：

{"_id":ObjectId("53590a43dc17421e9db46a31"),
 "latlng": {"type" : "Polygon", "coordinates":[[[....],[....],[....],[....],[.....]]]}
 "self":{"school":2,"home":3,"hospital":6}
 }

其中，“self”字段表示Polygon中的场地类型以及对应的场地类型的数量。不同的文档有不同的 self 字段，例如 {"KFC":1,"building":2,"home":6}, {"shopping mall":1, "gas station":2}

现在我需要计算两个文档的两个“自身”字段之间的余弦相似度。之前，我的所有文档都以字典形式保存在pickle文件中，我使用以下代码来计算相似度：

vec = DictVectorizer()
total_arrays = vec.fit_transform(data + citymap).A
vector_matrix = total_arrays[:len(data)]
citymap_base_matrix = total_arrays[len(data):]

def cos_cdist(matrix, vector):
v = vector.reshape(1, -1)
return scipy.spatial.distance.cdist(matrix, v, 'cosine').reshape(-1)

for vector in vector_matrix:
    distance_result = cos_cdist(citymap_base_matrix,vector)

这里，数据和城市地图就像 [{"KFC":1,"building":2,"home":6},{"school":2,"home":3,"hospital":6}, {“购物中心”：1，“加油站”：2}]

但现在我正在使用 mongoDB，我想知道是否有 mongoDB 方法以更直接的方式计算相似度，有什么想法吗？

我有两大组向量，A和B. 中的每个元素A是长度400的1维向量，用-10和10之间的浮点值对于每个向量A，我试图以计算余弦相似性的所有向量B，以便找到前5矢量在B该最佳匹配给定的A向量。现在，我正在遍历所有A，并遍历所有B，与 SciPy 的spatial.distance.cosine(a, b). 有没有更快的方法来做到这一点？也许与矩阵？

我必须计算每行之间的余弦距离，但我不知道如何优雅地使用 Spark API Dataframes 来完成它。这个想法是计算每一行（项目）的相似度，并通过比较它们在行之间的相似度来获取前 10 个相似度。--> 这是 Item-Item Recommender System 所需要的。

我所读到的所有内容都涉及计算列上的相似性Apache Spark Python Cosine Similarity over DataFrames 也许有人会说是否可以使用 PySpark Dataframe 的 API 或 RDD 优雅地计算行之间的余弦距离，或者我必须手动完成？

这只是一些代码来显示我打算做什么

def cosineSimilarity(vec1, vec2):
    return vec1.dot(vec2) / (LA.norm(vec1) * LA.norm(vec2))


#p.s model is ALS
Pred_Factors = model.itemFactors.cache() #Pred_Factors = DataFrame[id: int, features: array<float>]

sims = []

for _id,_feature in Pred_Factors.toLocalIterator():
    for id, feature in Pred_Factors.toLocalIterator():

        itemFactor = _feature

        sims = sims.append(_id, cosineSimilarity(asarray(feature),itemFactor))

sims = sc.parallelize(l)
sortedSims = sims.takeOrdered(10, key=lambda x: -x[1])

提前感谢所有帮助

使用 linear_kernel 或cosine_similarityfor 时TfIdfVectorizer，出现错误“内核已死亡，正在重新启动”。

我正在为 TfID 方法 Vectorizer 和fit_transform一些文本数据运行 scikit 学习函数，如下例所示，但是当我想计算距离矩阵时，我收到错误"Kernel dead, restarting "。

无论我使用的是cosine_similarity还是linear_kernel函数：

tf = TfidfVectorizer(analyzer='word' stop_words='english')
tfidf_matrix = tf.fit_transform(products['ProductDescription'])

 --cosine_sim = linear_kernel(tfidf_matrix, tfidf_matrix)
 --cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)

也许问题是我的数据的大小？

我的 tiidf 矩阵是 (178350,143529)，它应该生成一个 (178350,178350) cosine_sim 矩阵。

我有两个 numpy 数组：

数组 1：500,000 行 x 100 列

数组 2：160,000 行 x 100 列

我想在 Array 1和Array 2 中的每一行之间找到最大的余弦相似度。换句话说，我计算数组 1 中第一行与数组 2 中所有行之间的余弦相似度，并找到最大余弦相似度，然后计算数组 1 中第二行与数组 2 中所有行之间的余弦相似度数组2，求最大余弦相似度；并对数组 1 的其余部分执行此操作。

我目前使用sklearn的cosine_similarity()功能并执行以下操作，但速度非常慢。我想知道是否有一种更快的方法不涉及多处理/多线程来完成我想做的事情。此外，我拥有的数组并不稀疏。

from sklearn.metrics.pairwise import cosine_similarity as cosine

results = []
for i in range(Array1.shape[0]):
     results.append(numpy.max(cosine(Array1[None,i,:], Array2)))

我已经预制了一个充满 512 维向量的数据库，并希望对它们实现一种有效的搜索算法。

研究

余弦相似度：

在这种情况下，最好的算法将包含余弦相似性度量，它基本上是一个归一化的点积，即：

def cossim(a, b): numpy.inner(a, b)/(numpy.linalg.norm(a)*numpy.linalg.norm(b))

在 Python 中。

线性搜索：

这种情况下最明显和最简单的搜索是线性搜索O(n)，它迭代整个数据库并最终选择最相似的结果：

def linear_search(query_text, db):  # where db is set of 512D vectors
    most_similar = ("", 0)  # placeholder
    for query in db:
        current_sim = cossim(query_text, query)  # cossim function defined above
        if current_sim > most_similar[1]:
            most_similar = (query, current_sim)
    return most_similar[0] 

如您所见，应该扫描整个数据库，如果数据库包含数十万个向量，这可能会非常低效。

拟线性搜索：（部分解决）

余弦相似度和欧几里得距离之间存在基本关系（在这个答案中很好地解释了） - 我们可以从以下等式推导出欧几里得距离：

|a - b|² = 2(1 - cossim(a,b))

正如答案中提到的，随着两个向量之间的余弦变大，欧几里得距离会变小，因此我们可以将其转化为最近点对问题，可以使用递归 …

我有一个形状为 (149,1001) 的 TF-IDF 矩阵。想要的是计算最后一列与所有列的余弦相似度

这是我所做的

from numpy import dot
from numpy.linalg import norm
for i in range(mat.shape[1]-1):
    cos_sim = dot(mat[:,i], mat[:,-1])/(norm(mat[:,i])*norm(mat[:,-1]))
    cos_sim

但这个循环使它变慢。那么，有什么有效的方法吗？我只想用 numpy 做