小编swa*_*his的帖子

我有3个numpy阵列,需要在它们之间形成笛卡尔积.阵列的尺寸不固定,因此它们可以采用不同的值,一个例子可以是A =(10000,50),B =(40,50),C =(10000,50).

然后,我执行一些处理(如a + bc)以下是我用于产品的功能.

def cartesian_2d(arrays, out=None):

    arrays = [np.asarray(x) for x in arrays]
    dtype = arrays[0].dtype

    n = np.prod([x.shape[0] for x in arrays])
    if out is None:
        out = np.empty([n, len(arrays), arrays[0].shape[1]], dtype=dtype)

    m = n // arrays[0].shape[0]
    out[:, 0] = np.repeat(arrays[0], m, axis=0)
    if arrays[1:]:
        cartesian_2d(arrays[1:], out=out[0:m, 1:, :])
        for j in range(1, arrays[0].shape[0]):
            out[j * m:(j + 1) * m, 1:] = out[0:m, 1:]
    return out

a = [[ 0, -0.02], [1, -0.15]]
b …

我有一个 Pandas 数据框，我想根据其他列的值添加一个新列。下面是一个说明我的用例的最小示例。

df = pd.DataFrame([[4,5,19],[1,2,0],[2,5,9],[8,2,5]], columns=['a','b','c'])
df

    a   b   c
---------------
0   4   5   19
1   1   2   0
2   2   5   9
3   8   2   5

x = df.sample(n=2)
x

    a   b   c
---------------
3   8   2   5
1   1   2   0

def get_new(row):
    a, b, c = row
    return random.choice(df[(df['a'] != a) & (df['b'] == b) & (df['c'] != c)]['c'].values)

y = x.apply(lambda row: get_new(row), axis=1)
x['new'] = y
x

    a   b   c   new
--------------------
3   8 …

我已经在AngularJS工作了一段时间并且已经研究了很多.我正在使用AngularJS指令构建可重用的自定义组件/小部件.我在这方面非常成功.但是,我希望在做同样的事情时坚持继承.让我举个例子来解释一下.

我创建了一个指令myButton,创建一个包含所有样式和功能的按钮.现在我想扩展/继承它myButton以创建一个myToggleButton具有一些附加功能的功能.我不想myButton再次重写功能.

我已经探索了各种选择.

1. 正如https://gist.github.com/BrainCrumbz/5832057中所建议的那样,我创建了一个工厂/服务并将其注入指令中.但这不允许我充分利用遗产.我仍然需要重写大部分属性.

2. 我尝试使用普通的面向对象的JavaScript进行继承,但在这种情况下我不会使用AngulrJS指令.我想严格遵循Angular概念.

所以任何建议都会受到欢迎.

我正在尝试使用非负矩阵分解构建推荐系统。使用scikit-learn NMF作为模型，我拟合我的数据，导致一定的损失（即重建误差）。然后，我使用inverse_transform方法生成新数据的推荐。

现在，我使用在 TensorFlow 中构建的另一个模型执行相同的操作。训练后的重建误差接近于之前使用 sklearn 方法获得的重建误差。然而，潜在因素和最终建议都不相同。

据我所知，这两种方法之间的区别之一是：在 sklearn 中，我使用坐标下降求解器，而在 TensorFlow 中，我使用基于梯度下降的 AdamOptimizer。其他一切似乎都是一样的：

1. 使用的损失函数是 Frobenius 范数
2. 两种情况都没有正则化
3. 使用相同数量的潜在维度对相同数据进行测试

我正在使用的相关代码：

1.scikit-learn方法：

model =  NMF(alpha=0.0, init='random', l1_ratio=0.0, max_iter=200, 
n_components=2, random_state=0, shuffle=False, solver='cd', tol=0.0001, 
verbose=0)
model.fit(data)
result = model.inverse_transform(model.transform(data))

2.TensorFlow方法：

w = tf.get_variable(initializer=tf.abs(tf.random_normal((data.shape[0], 
2))), constraint=lambda p: tf.maximum(0., p))
h = tf.get_variable(initializer=tf.abs(tf.random_normal((2, 
data.shape[1]))), constraint=lambda p: tf.maximum(0., p))
loss = tf.sqrt(tf.reduce_sum(tf.squared_difference(x, tf.matmul(w, h))))

我的问题是，如果这两种方法生成的建议不匹配，那么我如何确定哪些是正确的？根据我的用例，sklearn 的 NMF 给了我很好的结果，但 TensorFlow 实现却没有。如何使用我的自定义实现实现相同的目标？

我在训练数据上使用 scikit-learn NMF 模型拟合模型。现在我使用

result_1 = model.inverse_transform(model.transform(new_data))

然后，我计算逆变换的我的数据从NMF模型手动拍摄组件，利用公式在第15页这里。

temp = np.dot(model.components_, model.components_.T)
transform = np.dot(np.dot(model.components_.T, np.linalg.pinv(temp)), 
model.components_)
result_2 = np.dot(new_data, transform)

我想了解为什么 2 个结果不匹配。在计算逆变换和重建数据时我做错了什么？

示例代码：

import numpy as np
from sklearn.decomposition import NMF

data = np.array([[0,0,1,1,1],[0,1,1,0,0],[0,1,0,0,0],[1,0,0,1,0]])
print(data)
//array([[0, 0, 1, 1, 1],
       [0, 1, 1, 0, 0],
       [0, 1, 0, 0, 0],
       [1, 0, 0, 1, 0]])


model = NMF(alpha=0.0, init='random', l1_ratio=0.0, max_iter=200, n_components=2, random_state=0, shuffle=False, solver='cd', tol=0.0001, verbose=0)
model.fit(data)
NMF(alpha=0.0, beta_loss='frobenius', init='random', l1_ratio=0.0,
  max_iter=200, n_components=2, random_state=0, shuffle=False, …