def call(n_components, alpha, learning_rate, batch_size):
    cb = Callback(X_tr, X_te)
    mf = DictMF(n_components=n_components, n_epochs=8, alpha=alpha, verbose=10,
                batch_size=batch_size,
                normalize=True,
                fit_intercept=True,
                random_state=0,
                learning_rate=learning_rate)

    start_time = time.time()
    mf.fit(X_tr)
    runtime = time.time() - start_time
    X_pred = mf.predict(X_te)
    rmse = np.sqrt(np.mean((X_pred.data - X_te.data) ** 2))
    print('rmse %i %.2f %.2f %.2f: %.4f' % (n_components,
                                            alpha, learning_rate,
                                            batch_size, rmse))
    return [n_components, alpha, learning_rate, batch_size, runtime, rmse]
Esempio n. 2
0
def call(n_components, alpha, learning_rate, batch_size):
    cb = Callback(X_tr, X_te)
    mf = DictMF(n_components=n_components,
                n_epochs=8,
                alpha=alpha,
                verbose=10,
                batch_size=batch_size,
                normalize=True,
                fit_intercept=True,
                random_state=0,
                learning_rate=learning_rate)

    start_time = time.time()
    mf.fit(X_tr)
    runtime = time.time() - start_time
    X_pred = mf.predict(X_te)
    rmse = np.sqrt(np.mean((X_pred.data - X_te.data)**2))
    print('rmse %i %.2f %.2f %.2f: %.4f' %
          (n_components, alpha, learning_rate, batch_size, rmse))
    return [n_components, alpha, learning_rate, batch_size, runtime, rmse]
Esempio n. 3
0
def test_matrix_fact_cd():
    # Generate some toy data.
    rng = np.random.RandomState(0)
    U = rng.rand(50, 3)
    V = rng.rand(3, 20)
    X = np.dot(U, V)

    mf = DictMF(n_components=3, n_epochs=3, alpha=1e-3, random_state=0,
                verbose=0, normalize=False)

    mf.fit(X)

    Y = np.dot(mf.P_.T, mf.Q_)
    Y2 = mf.predict(X).toarray()

    assert_array_almost_equal(Y, Y2)

    rmse = np.sqrt(np.mean((X - Y) ** 2))
    rmse2 = mf.score(X)

    assert_almost_equal(rmse, rmse2)
Esempio n. 4
0
def test_dict_fact_normalize():
    # Generate some toy data.
    rng = np.random.RandomState(0)
    U = rng.rand(50, 3)
    V = rng.rand(3, 20)
    X = np.dot(U, V)

    mf = DictMF(n_components=3,
                n_epochs=1,
                alpha=1e-3,
                random_state=0,
                verbose=0,
                normalize=True)

    mf.fit(X)

    Y = np.dot(mf.P_.T, mf.Q_)
    Y += mf.col_mean_[np.newaxis, :]
    Y += mf.row_mean_[:, np.newaxis]
    Y2 = mf.predict(X).toarray()

    assert_array_almost_equal(Y, Y2)

    rmse = np.sqrt(np.mean((X - Y)**2))
    rmse2 = mf.score(X)

    assert_almost_equal(rmse, rmse2)
Esempio n. 5
0
def test_matrix_fact_cd():
    # Generate some toy data.
    rng = np.random.RandomState(0)
    U = rng.rand(50, 3)
    V = rng.rand(3, 20)
    X = np.dot(U, V)

    mf = DictMF(n_components=3,
                n_epochs=3,
                alpha=1e-3,
                random_state=0,
                verbose=0,
                normalize=False)

    mf.fit(X)

    Y = np.dot(mf.P_.T, mf.Q_)
    Y2 = mf.predict(X).toarray()

    assert_array_almost_equal(Y, Y2)

    rmse = np.sqrt(np.mean((X - Y)**2))
    rmse2 = mf.score(X)

    assert_almost_equal(rmse, rmse2)
Esempio n. 6
0
def test_dict_fact_normalize():
    # Generate some toy data.
    rng = np.random.RandomState(0)
    U = rng.rand(50, 3)
    V = rng.rand(3, 20)
    X = np.dot(U, V)

    mf = DictMF(n_components=3, n_epochs=1, alpha=1e-3, random_state=0,
                verbose=0, normalize=True)

    mf.fit(X)

    Y = np.dot(mf.P_.T, mf.Q_)
    Y += mf.col_mean_[np.newaxis, :]
    Y += mf.row_mean_[:, np.newaxis]
    Y2 = mf.predict(X).toarray()

    assert_array_almost_equal(Y, Y2)

    rmse = np.sqrt(np.mean((X - Y) ** 2))
    rmse2 = mf.score(X)

    assert_almost_equal(rmse, rmse2)
def compare_learning_rate(version='100k', n_jobs=1, random_state=0):
    if version in ['100k', '1m', '10m']:
        X = load_movielens(version)
        X_tr, X_te = train_test_split(X,
                                      train_size=0.75,
                                      random_state=random_state)
        X_tr = X_tr.tocsr()
        X_te = X_te.tocsr()
    elif version is 'netflix':
        X_tr = load(expanduser('~/spira_data/nf_prize/X_tr.pkl'))
        X_te = load(expanduser('~/spira_data/nf_prize/X_te.pkl'))
    mf = DictMF(
        n_components=30,
        n_epochs=20 if version == '10m' else 7,
        alpha=0.1373823795883263 if version == '10m' else 0.16681005372000587,
        verbose=5,
        batch_size=600 if version == '10m' else 4000,
        normalize=True,
        fit_intercept=True,
        random_state=0,
        learning_rate=.75,
        impute=False,
        partial=True,
        backend='c')
    timestamp = datetime.datetime.now().strftime('%Y-%m-%d_%H' '-%M-%S')
    subdir = 'learning_rate'
    output_dir = expanduser(join('~/output/recommender/', timestamp, subdir))

    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    results = {}
    par_res = Parallel(n_jobs=n_jobs, max_nbytes=None)(
        delayed(single_learning_rate)(mf, learning_rate, X_tr, X_te)
        for learning_rate in np.linspace(0.5, 1, 10))

    for i, learning_rate in enumerate(np.linspace(0.5, 1, 10)):
        results[learning_rate] = par_res[i]
    with open(join(output_dir, 'results_%s.json' % version), 'w+') as f:
        json.dump(results, f)
def main(version='100k', n_jobs=1, random_state=0, cross_val=False):
    dl_params = {}
    dl_params['100k'] = dict(learning_rate=1, batch_size=10, offset=0, alpha=1)
    dl_params['1m'] = dict(learning_rate=.75,
                           batch_size=60,
                           offset=0,
                           alpha=.8)
    dl_params['10m'] = dict(learning_rate=.75,
                            batch_size=600,
                            offset=0,
                            alpha=3)
    dl_params['netflix'] = dict(learning_rate=.8,
                                batch_size=4000,
                                offset=0,
                                alpha=0.16)
    cd_params = {
        '100k': dict(alpha=.1),
        '1m': dict(alpha=.03),
        '10m': dict(alpha=.04),
        'netflix': dict(alpha=.1)
    }

    if version in ['100k', '1m', '10m']:
        X = load_movielens(version)
        X_tr, X_te = train_test_split(X,
                                      train_size=0.75,
                                      random_state=random_state)
        X_tr = X_tr.tocsr()
        X_te = X_te.tocsr()
    elif version is 'netflix':
        X_tr = load(expanduser('~/spira_data/nf_prize/X_tr.pkl'))
        X_te = load(expanduser('~/spira_data/nf_prize/X_te.pkl'))

    cd_mf = ExplicitMF(
        n_components=60,
        max_iter=50,
        alpha=.1,
        normalize=True,
        verbose=1,
    )
    dl_mf = DictMF(n_components=30,
                   n_epochs=20,
                   alpha=1.17,
                   verbose=5,
                   batch_size=10000,
                   normalize=True,
                   fit_intercept=True,
                   random_state=0,
                   learning_rate=.75,
                   impute=False,
                   partial=False,
                   backend='python')
    dl_mf_partial = DictMF(n_components=60,
                           n_epochs=20,
                           alpha=1.17,
                           verbose=5,
                           batch_size=10000,
                           normalize=True,
                           fit_intercept=True,
                           random_state=0,
                           learning_rate=.75,
                           impute=False,
                           partial=True,
                           backend='python')

    timestamp = datetime.datetime.now().strftime('%Y-%m-%d_%H' '-%M-%S')
    if cross_val:
        subdir = 'benches_ncv'
    else:
        subdir = 'benches'
    output_dir = expanduser(join('~/output/recommender/', timestamp, subdir))
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    alphas = np.logspace(-2, 1, 10)
    mf_list = [dl_mf_partial]
    dict_id = {cd_mf: 'cd', dl_mf: 'dl', dl_mf_partial: 'dl_partial'}
    names = {
        'cd': 'Coordinate descent',
        'dl': 'Proposed online masked MF',
        'dl_partial': 'Proposed algorithm (with partial projection)'
    }

    if os.path.exists(
            join(output_dir, 'results_%s_%s.json' % (version, random_state))):
        with open(
                join(output_dir,
                     'results_%s_%s.json' % (version, random_state)),
                'r') as f:
            results = json.load(f)
    else:
        results = {}

    for mf in mf_list:
        results[dict_id[mf]] = {}
        if not cross_val:
            if isinstance(mf, DictMF):
                mf.set_params(
                    learning_rate=dl_params[version]['learning_rate'],
                    batch_size=dl_params[version]['batch_size'],
                    alpha=dl_params[version]['alpha'])
            else:
                mf.set_params(alpha=cd_params[version]['alpha'])
        else:
            if isinstance(mf, DictMF):
                mf.set_params(
                    learning_rate=dl_params[version]['learning_rate'],
                    batch_size=dl_params[version]['batch_size'])
            if version != 'netflix':
                cv = ShuffleSplit(n_iter=3, train_size=0.66, random_state=0)
                mf_scores = Parallel(n_jobs=n_jobs, verbose=10)(
                    delayed(single_fit)(mf, alpha, X_tr, cv)
                    for alpha in alphas)
            else:
                mf_scores = Parallel(n_jobs=n_jobs, verbose=10)(
                    delayed(single_fit)(mf, alpha, X_tr, X_te, nested=False)
                    for alpha in alphas)
            mf_scores = np.array(mf_scores).mean(axis=1)
            best_alpha_arg = mf_scores.argmin()
            best_alpha = alphas[best_alpha_arg]
            mf.set_params(alpha=best_alpha)

        cb = Callback(X_tr, X_te, refit=False)
        mf.set_params(callback=cb)
        mf.fit(X_tr)
        results[dict_id[mf]] = dict(name=names[dict_id[mf]],
                                    time=cb.times,
                                    rmse=cb.rmse)
        if cross_val:
            results[dict_id[mf]]['alphas'] = alphas.tolist()
            results[dict_id[mf]]['cv_alpha'] = mf_scores.tolist()
            results[dict_id[mf]]['best_alpha'] = mf.alpha

        with open(
                join(output_dir,
                     'results_%s_%s.json' % (version, random_state)),
                'w+') as f:
            json.dump(results, f)

        print('Done')
Esempio n. 9
0
X_te = load(expanduser('~/spira_data/nf_prize/X_te.pkl'))
# X_te = X_te.T.tocsr()

cb = {}
cd_mf = ExplicitMF(
    n_components=30,
    max_iter=50,
    alpha=0.1,
    verbose=1,
)
dl_mf = DictMF(n_components=30,
               n_epochs=5,
               alpha=.3,
               verbose=10,
               batch_size=10000,
               normalize=True,
               impute=False,
               fit_intercept=True,
               random_state=0,
               learning_rate=.75,
               backend='c')

for mf in [dl_mf]:
    cb[mf] = Callback(X_tr, X_te, refit=(mf is dl_mf))
    mf.set_params(callback=cb[mf])
    mf.fit(X_tr)

timestamp = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
output_dir = join(expanduser('~/output/dl_fast'), timestamp)
if not os.path.exists(output_dir):
    os.makedirs(output_dir)