标签: cosine-similarity

我有两个 MXN 矩阵，它们是在从图像中提取数据后构建的。两个向量都有很长的第一行，在第三行之后它们都变成了第一列。例如原始向量看起来像这样

1,23,2,5,6,2,2,6,2,
12,4,5,5,
1,2,4,
1,
2,
2
:

两个向量都有一个相似的模式，其中前三行有很长的行，然后随着它的进展而变细。做余弦相似度我想使用填充技术来添加零并使这两个向量 NX N。我查看了余弦相似度的 Python 选项，但一些示例使用了包调用 numpy。我无法弄清楚 numpy 究竟如何进行这种类型的填充并执行余弦相似度。任何指导将不胜感激。

我想在我的IR项目中使用余弦相似性但是因为向量的大小很大并且它必须多次浮动多次,所以需要很长时间.

有没有办法更快地计算余弦相似度？

这是我的代码:

private double diffrence(HashMap<Integer, Float> hashMap,
 HashMap<Integer, Float> hashMap2 ) {
    Integer[] keys = new Integer[hashMap.size()];
    hashMap.keySet().toArray(keys);

     float ans = 0;

    for (int i = 0; i < keys.length; i++) {
        if (hashMap2.containsKey(keys[i])) {
             ans += hashMap.get(keys[i]) * hashMap2.get(keys[i]);

        }
    }

     float hashLength = 0;
    for (int i = 0; i < keys.length; i++) {
         hashLength += (hashMap.get(keys[i]) * hashMap.get(keys[i]));
    }
     hashLength = (float) Math.sqrt(hashLength);

    Integer[] keys2 = new Integer[hashMap2.size()];
    hashMap2.keySet().toArray(keys2);

     float hash2Length = 0;
    for (int i …

我已经看到 K-Nearest Neighbor 算法中使用余弦相似度来根据用户偏好生成推荐。在这些模型中，用户对给定产品的评分被视为向量，然后两个用户之间的相似度由两个向量之间的余弦相似度确定。（例如http://www.neo4j.org/graphgist?8173017）

我的问题是： 谁能解释一下使用余弦相似度的推荐引擎如何解释并行用户偏好？在我看来，如果两个用户具有平行（但不同）的偏好，则他们可以具有完全极性的评级偏好，并且产生 1 的余弦相似度。例如，如果一个用户将 5 部电影评为 10 颗星中的 1 部电影，而另一个用户将 5 部电影评为 10 颗星中的 10 颗，则他们的余弦相似度将为 1（在我看来，这似乎是一个不准确的衡量标准用户相似性）。

问题示例：如果我们测量两个用户的用户偏好，并且测量他们对 3 个产品的偏好，我们可以将他们的偏好存储为两个向量：

a =(1,1,1) 和 b=(10,10,10)

然后我们可以使用余弦相似度来衡量它们彼此之间的相似程度。但在这种情况下，它们的余弦相似度将是 1，即使它们代表了相反的用户偏好。

这是我的数据框：

                    ui 194635691 194153563 177382028 177382031 195129144 196972549 196258704 194907960 196950156 194139014 153444738
1 56320e0e55e89c3e14e26d3d      0.00      0.00      0.00      0.00      0.00      0.00      0.00      0.01     0.000         0         0
2 563734c3b65dd40e340eaa56      0.01      0.00      0.00      0.00      0.00      0.00      0.00      0.00     0.000         0         0
3 563e12657d4c410c5832579c      0.00      0.00      0.01      0.01      0.00      0.00      0.00      0.00     0.000         0         0
4 565181854c24b410e4891e11      0.00      0.00      0.00      0.00      0.00      0.01      0.00      0.00     0.000         0         0
5 5651b53fec231f1df8482d23      0.00      0.00      0.00      0.00      0.00      0.00      0.00      0.00     0.027         0         0
6 56548df4b84c321fe4cdfb8f …

我正在尝试使用Apache Spark在TFIDF上计算余弦相似度矩阵。这是我的代码：

def cosSim(input: RDD[Seq[String]]) = {
  val hashingTF = new HashingTF()
  val tf = hashingTF.transform(input)
  tf.cache()
  val idf = new IDF().fit(tf)
  val tfidf = idf.transform(tf)
  val mat = new RowMatrix(tfidf)
  val sim = mat.columnSimilarities
  sim
}

我在输入中大约有3000行，但是如果我执行sim.numRows（）或sim.numCols（），我会看到1048576而不是3K，据我了解，这是因为val tfidf和val mat的大小均为3K * 1048576其中1048576是tf功能的数量。也许要解决这个问题，我必须移调垫子，但是我不知道该怎么做。

我有4个带有架构的表(app,text_id,title,text).现在我想计算所有可能的文本对(标题和文本连接)之间的余弦相似度,并最终将它们存储在带有字段的csv文件中(app1,app2,text_id1,text1,text_id2,text2,cosine_similarity).

由于有很多可能的组合,它应该运行非常有效.这里最常见的方法是什么？我很感激任何指针.

编辑:虽然提供的参考可能会触及我的问题,但我仍然无法弄清楚如何处理这个问题.有人可以提供有关完成此任务的策略的更多详细信息吗？在计算的余弦相似度旁边,我还需要相应的文本对作为输出.

我加载了一个 word2vec 格式的文件，我想计算向量之间的相似度，但我不知道这个问题意味着什么。

from gensim.models import Word2Vec
from sklearn.metrics.pairwise import cosine_similarity
from gensim.models import KeyedVectors
import numpy as np

model = KeyedVectors.load_word2vec_format('it-vectors.100.5.50.w2v')

similarities = cosine_similarity(model.vectors)


---------------------------------------------------------------------------
MemoryError                               Traceback (most recent call last)
<ipython-input-54-1d4e62f55ebf> in <module>()
----> 1 similarities = cosine_similarity(model.vectors)

/usr/local/lib/python3.5/dist-packages/sklearn/metrics/pairwise.py in cosine_similarity(X, Y, dense_output)
    923         Y_normalized = normalize(Y, copy=True)
    924 
--> 925     K = safe_sparse_dot(X_normalized, Y_normalized.T, dense_output=dense_output)
    926 
    927     return K

/usr/local/lib/python3.5/dist-packages/sklearn/utils/extmath.py in safe_sparse_dot(a, b, dense_output)
    138         return ret
    139     else:
--> 140         return np.dot(a, b)
    141 
    142 

MemoryError: …

基本上给定一些向量v，我想获得另一个在向量v和w之间具有余弦相似性的随机向量w。有什么办法可以在python中获得它吗？

示例：为简单起见，我将具有v [3，-4]的2D向量。我想获得余弦相似度为60％或加0.6的随机向量w。这将生成具有值[0.875，3]的向量w或具有相同余弦相似度的任何其他向量。所以我希望这足够清楚。

嗨，Stackoverflow 用户，

我目前正在努力解决这个问题：

我有 2 个二维张量：

a = Tensor(shape=[600,52]) # 600 vectors of length 52
b = Tensor(shape=[16000,52]) # 1600 vectors of length 52

我正在尝试计算所有向量组合的余弦相似度并将它们存储在第三张量中。

similarity = Tensor(shape=[600, 16000])

我现在的问题如下

a) 我不太确定如何以非迭代方式实现这一点，我考虑过将广播语义与 tf.losses.cosine_distance 结合使用，但我无法完全理解它的实际外观.

b) 根据实现（如果使用 tf.losses.cosine_distance，这需要匹配两个输入张量的维度）内存占用可能会变得非常大，因为它需要创建两个形状 [600, 1600, 52] 的张量为了计算所有向量组合的距离。你能想到解决这个问题的任何可能性吗？

我希望我能够以可以理解的方式表达我的想法，谢谢你的帮助

最好的事物，

正如标题所示，我正在尝试基于 SimCLR 框架训练模型（见本文：https ://arxiv.org/pdf/2002.05709.pdf - NT_Xent 损失在等式（1）和算法 1 中说明） ）。

我设法创建了损失函数的 numpy 版本，但这不适合训练模型，因为 numpy 数组无法存储反向传播所需的信息。我很难将我的 numpy 代码转换为 Tensorflow。这是我的 numpy 版本：

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# Define the contrastive loss function, NT_Xent
def NT_Xent(zi, zj, tau=1):
    """ Calculates the contrastive loss of the input data using NT_Xent. The
    equation can be found in the paper: https://arxiv.org/pdf/2002.05709.pdf
    
    Args:
        zi: One half of the input data, shape = (batch_size, feature_1, feature_2, ..., feature_N)
        zj: Other half of the …

我正在做一些尝试推荐文档的工作,为此我使用了Cosine Similarity方法.以下是该方法的代码:

static double cosineSimilarity(HashMap<String, Double> v1, HashMap<String, Double> v2) 
{
    Set<String> both = v1.keySet();
    both.retainAll(v2.keySet());
    double sclar = 0, norm1 = 0, norm2 = 0;
    for (String k : both) 
    {
      sclar += v1.get(k) * v2.get(k);
    }
    for (String k : v1.keySet())
    {
      norm1 += v1.get(k) * v1.get(k);
    }
    for (String k : v2.keySet()) 
    {
      norm2 += v2.get(k) * v2.get(k);
    }
    return sclar / Math.sqrt(norm1 * norm2);
}

问题是结果取决于参数传递的顺序.例如,如果我调用cosineSimilarity(v1, v2)它将返回0.3但如果我调用cosineSimilarity(v2, v1)它将返回一个完全不同的值.

我认为这与Map.keySet() …

我使用Pytorch余弦相似度函数如下。我有两个特征向量，我的目标是使它们彼此不同。所以，我想我可以最小化它们的余弦相似度。我对我的编码方式有一些疑问。感谢您对以下问题的建议。

1. 我不知道为什么这里有一些负值val1？

2. 我已经完成了三个步骤来转换val1为标量。我的做法正确吗？还有其他办法吗？

3. 为了最小化相似性，我使用了1/var1. 这是执行此操作的标准方法吗？如果我使用它正确吗1-var1？

   def loss_func(feat1, feat2):
        cosine_loss = torch.nn.CosineSimilarity(dim=1, eps=1e-6)
        val1 = cosine_loss(feat1, feat2).tolist()
        # 1. calculate the absolute values of each element,
        # 2. sum all values together,
        # 3. divide it by the number of values
        val1 = 1/(sum(list(map(abs, val1)))/int(len(val1)))
        val1 = torch.tensor(val1, device='cuda', requires_grad=True)
        return val1 
   

   Run Code Online (Sandbox Code Playgroud)