Beispiel #1
0
def test_cross_val_score():
    # Generate some toy data.
    rng = np.random.RandomState(0)
    U = rng.rand(50, 3)
    V = rng.rand(3, 20)
    X = np.dot(U, V)

    cv = ShuffleSplit(n_iter=10)
    mf = ExplicitMF(n_components=3, max_iter=10, alpha=1e-3, random_state=0,
                    verbose=0)
    scores = cross_val_score(mf, X, cv)
    assert_equal(len(scores), cv.n_iter)
Beispiel #2
0
def test_cross_val_score_multi():
    # Generate some toy data.
    rng = np.random.RandomState(0)
    U = rng.rand(50, 3)
    V = rng.rand(3, 20)
    X = np.dot(U, V)
    X = (X > X.mean()).astype(np.int32)

    cv = ShuffleSplit(n_iter=10)
    mf = ImplicitMF(n_components=3, max_iter=10, alpha=1e-3, random_state=0)
    scores = cross_val_score(mf, X, cv, metric=["precision", "recall"])
    assert_equal(scores.shape, (cv.n_iter, 2))
def single_fit(mf, alpha, X_tr, cv, nested=True):
    mf_cv = clone(mf)
    if isinstance(mf_cv, DictMF):
        mf_cv.set_params(n_epochs=2)
    else:
        mf_cv.set_params(max_iter=10)
    mf_cv.set_params(alpha=alpha)
    if nested:
        score = cross_val_score(mf_cv, X_tr, cv)
    else:
        X_te = cv
        mf_cv.fit(X_tr)
        score = [mf_cv.score(X_te)]
    return score
def single_fit(mf, alpha, X_tr, cv, nested=True):
    mf_cv = clone(mf)
    if isinstance(mf_cv, DictMF):
        mf_cv.set_params(n_epochs=2)
    else:
        mf_cv.set_params(max_iter=10)
    mf_cv.set_params(alpha=alpha)
    if nested:
        score = cross_val_score(mf_cv, X_tr, cv)
    else:
        X_te = cv
        mf_cv.fit(X_tr)
        score = [mf_cv.score(X_te)]
    return score
Beispiel #5
0
X = load_movielens(version)
print(X.shape)

alphas = np.logspace(-2, 1, 10)
mf_scores = []

cv = ShuffleSplit(n_iter=3, train_size=0.75, random_state=0)

for alpha in alphas:
    mf = ExplicitMF(n_components=30, max_iter=10, alpha=alpha)
    # mf = DictMF(n_components=30, n_epochs=10, alpha=alpha, verbose=1,
    #             batch_size=10, normalize=True,
    #             fit_intercept=True,
    #             random_state=0,
    #             learning_rate=.5)
    mf_scores.append(cross_val_score(mf, X, cv))

# Array of size n_alphas x n_folds.
mf_scores = np.array(mf_scores)

dummy = Dummy()
dummy_scores = cross_val_score(dummy, X, cv)

dummy = Dummy(axis=0)
dummy_scores2 = cross_val_score(dummy, X, cv)

plt.figure()
plt.plot(alphas, mf_scores.mean(axis=1), label="Matrix Factorization")
plt.plot(alphas, [dummy_scores.mean()] * len(alphas), label="User mean")
plt.plot(alphas, [dummy_scores2.mean()] * len(alphas), label="Movie mean")
plt.xlabel("alpha")