标签: matrix-factorization

我有一个非常基本的问题.我想做低级矩阵分解,我正在查看有关该主题的Vowpal Wabbit文档.我的问题是:

这两种方法有区别吗？(实施或其他)

$ vw --lrq ab5

要么

$ vw -q ab --rank 5

在这里,a并b有多项功能的命名空间和5为潜在因素维度.

可能的后续行动:

如果这些是等价的,--rank也适用于高阶交互？

我记得lightfm的一个优点是模型没有冷启动问题,用户和物品冷启动:lightfm原纸

但是,我仍然不明白如何使用lightfm来解决冷启动问题.我训练了我的模特user-item interaction data.据我所知,我只能对我的数据集上存在的profile_ids进行预测.

def predict(self, user_ids, item_ids, item_features=None,
            user_features=None, num_threads=1):
    """
    Compute the recommendation score for user-item pairs.

    Arguments
    ---------

    user_ids: integer or np.int32 array of shape [n_pairs,]
         single user id or an array containing the user ids for the
         user-item pairs for which a prediction is to be computed
    item_ids: np.int32 array of shape [n_pairs,]
         an array containing the item ids for the user-item pairs for which
         a prediction is to be computed.
    user_features: np.float32 …

给定L和U LU分解和常量向量b这样LU*x=b ,是否有任何内置函数可以找到x？意思是这样的 -

X = functionName(L,U,b) 

注意在这两个L和U我们面对的是可直接要解决三角矩阵向前和向后的替换,而无需使用高斯消元过程.

编辑:

解决这个线性方程系统应该按照以下步骤 -

1. define y - s.t Ux=y
2. solve Ly=b by forward substitution
3. solve Ux=y by backward substitution
4. return y

编辑2:

我发现linalg :: matlinsolveLU 但我没有尝试它因为我的版本太旧(R2010a).它适合任何人吗？

我有一个稀疏的带状矩阵A,我想(直接)解决Ax = b.我有大约500个向量b,所以我想解决相应的500 x.我是CUDA的新手,所以我对我有哪些选择感到困惑.

cuSOLVER有一个批量直接求解器cuSolverSP,用于在这里使用QR的稀疏A_i x_i = b_i .(由于A的条件很好,我对LU也没问题.)但是,据我所知,我无法利用我所有的A_i都是一样的事实.

另一种选择是首先确定CPU或GPU上的稀疏LU(QR)因子分解,然后并行执行GPU上的后置替换(分别为backsub和matrix mult)吗？如果cusolverSp <t> csrlsvlu()用于一个b_i,是否有一种标准方法可以为多个b_i批量执行此操作？

最后,由于我对此没有直觉,考虑到必要的开销,我是否应该期望在这些选项中的GPU加速？x的长度约为10000-100000.谢谢.

我不明白如何使用cholR中的函数来计算正半正定矩阵.(或者我这样做,并且有一个错误.)文档说明:

如果pivot = TRUE,则可以计算正半正定x的Choleski分解.x的等级作为attr(Q,"rank")返回,受数字误差的影响.枢轴以attr(Q,"pivot")返回.不再是t(Q)%*%Q等于x的情况.但是,设置pivot < - attr(Q,"pivot")和oo < - order(pivot),t(Q [,oo])%*%Q [,oo]等于x ...

以下示例似乎与此描述相符.

> x <- matrix(1, nrow=3, ncol=3)
> Q <- chol(x, pivot=TRUE)
> oo <- order(attr(Q, 'pivot'))
> t(Q[, oo]) %*% Q[, oo]
     [,1] [,2] [,3]
[1,]    1    1    1
[2,]    1    1    1
[3,]    1    1    3

结果不是x.我错误地使用了枢轴吗？

我正在尝试在 Dask 中实现 ALS 算法，但我无法弄清楚如何一步计算潜在特征。我遵循了这个 stackoverflow 线程上的公式，并提出了以下代码：

    Items = da.linalg.lstsq(da.add(da.dot(Users, Users.T), lambda_ * da.eye(n_factors)), 
                            da.dot(Users, X))[0].T.compute()
    Items = np.where(Items < 0, 0, Items)

    Users = da.linalg.lstsq(da.add(da.dot(Items.T, Items), lambda_ * da.eye(n_factors)), 
                            da.dot(Items.T, X.T))[0].compute()
    Users = np.where(Users < 0, 0, Users)

但我认为这不正确，因为 MSE 并没有减少。

示例输入：

n_factors = 2
lambda_ = 0.1
# We have 6 users and 4 items

矩阵X_train(6x4)、R(4x6)、Users(2x6) 和Items(4x2) 看起来像：

1  0  0  0  5  2        1 0 0 0 …

我将 SVD 包与 R 一起使用，我可以通过将最低奇异值替换为 0 来降低矩阵的维数。但是当我重新组合矩阵时，我仍然具有相同数量的特征，我无法找到如何有效删除源矩阵中最无用的特征，以减少其列数。

例如我现在正在做的事情：

这是我的源矩阵 A：

  A B C D
1 7 6 1 6
2 4 8 2 4
3 2 3 2 3
4 2 3 1 3

如果我做：

s = svd(A)
s$d[3:4] = 0  # Replacement of the 2 smallest singular values by 0
A' = s$u %*% diag(s$d)  %*% t(s$v)

我得到 A'，它具有相同的尺寸（4x4），仅用 2 个“组件”进行重建，并且是 A 的近似值（包含较少的信息，可能较少的噪声等）：

      [,1]     [,2]      [,3]     [,4]
1 6.871009 5.887558 1.1791440 6.215131
2 3.799792 7.779251 2.3862880 4.357163
3 2.289294 …

使用Scikit-learn(v 0.15.2)对大型稀疏矩阵进行非负矩阵分解(小于1%值> 0).我想通过最小化矩阵的非零值上的错误来找到因子(即,不计算零的条目的错误),并且有利于稀疏性.我不确定我正在尝试的是否有什么问题.scikit-learn包的NMF和ProjectedGradientNMF以前对我有用.但似乎当矩阵大小增加时,因子分解非常缓慢.

我在谈论> 10 ^ 10个细胞的基质.对于具有~10 ^ 7个单元的矩阵,我发现执行时间是好的.

我使用的参数如下:nmf_model = NMF(n_components = 100, init='nndsvd', random_state=0, tol = 0.01, sparseness='data').

当我尝试稍微不同的参数(更改为init=random)时,我收到以下警告.警告之后,脚本的执行停止.

/lib/python2.7/site-packages/sklearn/decomposition/nmf.py:252: UserWarning: Iteration limit reached in nls subproblem.
  warnings.warn("Iteration limit reached in nls subproblem.")

有没有办法让这更快,并解决上述问题？我已经尝试过使用numpy稀疏矩阵(列稀疏和行稀疏),但令人惊讶的是 - 在测试中我使用较小的矩阵(~10 ^ 7个单元格)进行测试的速度较慢.

考虑到必须运行这种因子分解的多次迭代(选择理想数量的因子和k倍交叉验证),非常需要更快的方法来解决这个问题.

我也愿意接受不基于sklearn或Pyhon的软件包/工具的建议.我理解不鼓励有关包/工具选择的问题,但对于这样一个特定的用例,了解该领域其他人使用的技术将非常有帮助.

我正在尝试使用交替最小二乘法来实现 NMF。我只是好奇问题的以下基本实现：

如果我理解正确的话，我们可以在没有非负性约束的情况下求解该伪代码中所述的每个矩阵方程，使用封闭形式解并将负项设置为 0，以强力方式。这种理解正确吗？这是更复杂、受限的优化问题（例如我们使用投影梯度下降）的基本替代方案吗？更重要的是，如果按照这种基本方式实现，算法还有什么实用价值吗？我想使用 NMF 来减少变量，并且使用 NMF 很重要，因为我的数据根据​​定义是非负的。我正在寻找对此的意见。

我尝试使用 lightfm v.1.14 构建混合推荐系统。

我可以使用以下代码将所有数据放入稀疏矩阵中：

db = DBConnector().getDBConnector()
data = pd.read_sql('call get_UserItemRating();', con=db)

rows = data.loc[data['userID'].idxmax()]['userID'] + 1
cols = data.loc[data['itemID'].idxmax()]['itemID'] + 1
mat = sp.lil_matrix((rows, cols), dtype=np.int32)
for index, row in data.iterrows():
    if row['rating'] >= 4:
        mat[row['userID'], row['itemID']] = row['rating']

train = mat.tocoo()

data = pd.read_sql('SELECT * FROM wine_grapes;', con=db)
db.close()
rows = data.loc[data['fk_Wine'].idxmax()]['fk_Wine'] + 1
cols = data.loc[data['fk_Grapes'].idxmax()]['fk_Grapes'] + 1
mat = sp.lil_matrix((rows, cols), dtype=np.int32)
for index, row in data.iterrows():
    mat[row['fk_Wine'],row['fk_Grapes']] = 1

item_features = mat.tocoo()

model = …