Exemple #1
0
def training(opt, ev, tsc, event_feature=None, fold=0):
    """
    training model

    Parameters
    ----------
    opt : dict
        parsed command line options
    ev : array, size=(n_events, 2), dtype=np.int
        array of events in external ids
    tsc : array, size=(n_events,), dtype=np.float
        true scores
    event_feature : optional, structured array
        structured array of event features
    fold : int, default=0
        fold No.

    Returns
    -------
    rcmdr : EventScorePredictor
        trained recommender
    """

    # generate event data
    data = EventWithScoreData(n_otypes=2, n_stypes=1)
    if np.all(opt.domain == [0, 0, 0]):
        score_domain = (np.min(tsc), np.max(tsc),
                        np.min(np.diff(np.unique(tsc))))
    else:
        score_domain = tuple(opt.domain)
    logger.info("score_domain = " + str(score_domain))
    data.set_events(ev,
                    tsc,
                    score_domain=score_domain,
                    event_feature=event_feature)

    # init learning results
    if 'training_start_time' not in opt:
        opt.training_start_time = [0] * opt.fold
    if 'training_end_time' not in opt:
        opt.training_end_time = [0] * opt.fold
    if 'learning_i_loss' not in opt:
        opt.learning_i_loss = [np.inf] * opt.fold
    if 'learning_f_loss' not in opt:
        opt.learning_f_loss = [np.inf] * opt.fold
    if 'learning_opt_outputs' not in opt:
        opt.learning_opt_outputs = [None] * opt.fold

    # set starting time
    start_time = datetime.datetime.now()
    start_utime = os.times()[0]
    opt.training_start_time[fold] = start_time.isoformat()
    logger.info("training_start_time = " + start_time.isoformat())

    # create and learning model
    rcmdr = EventScorePredictor(C=opt.C,
                                k=opt.k,
                                tol=opt.tol,
                                maxiter=opt.maxiter,
                                random_state=opt.rseed)
    rcmdr.fit(data)

    # set end and elapsed time
    end_time = datetime.datetime.now()
    end_utime = os.times()[0]
    elapsed_time = end_time - start_time
    elapsed_utime = end_utime - start_utime
    opt.training_end_time[fold] = end_time.isoformat()
    logger.info("training_end_time = " + end_time.isoformat())
    if 'training_elapsed_time' not in opt:
        opt.training_elapsed_time = elapsed_time
    else:
        opt.training_elapsed_time += elapsed_time
    logger.info("training_elapsed_time = " + str(opt.training_elapsed_time))
    if 'training_elapsed_utime' not in opt:
        opt.training_elapsed_utime = elapsed_utime
    else:
        opt.training_elapsed_utime += elapsed_utime
    logger.info("training_elapsed_utime = " + str(opt.training_elapsed_utime))

    # preserve optimizer's outputs
    opt.learning_i_loss[fold] = rcmdr.i_loss_
    opt.learning_f_loss[fold] = rcmdr.f_loss_
    opt.learning_opt_outputs[fold] = rcmdr.opt_outputs_

    return rcmdr
Exemple #2
0
    def test_class(self):
        import numpy as np
        from kamrecsys.datasets import load_movielens_mini
        from kamrecsys.mf.pmf import EventScorePredictor

        data = load_movielens_mini()

        recommender = EventScorePredictor(C=0.1, k=2, tol=1e-03,
                                          random_state=1234)
        self.assertDictEqual(
            vars(recommender),
            {'C': 0.1, 'n_otypes': 0, 'bu_': None, 'bi_': None, 'k': 2,
             'p_': None, 'q_': None, '_coef': None, 'f_loss_': np.inf,
             'iid': None, 'i_loss_': np.inf, 'eid': None, 'tol': 1e-03,
             'n_objects': None, '_dt': None, 'mu_': None, 'opt_outputs_': None,
             'maxiter': 200, 'random_state': 1234, '_rng': None})

        recommender.fit(data, disp=False)
        self.assertAlmostEqual(recommender.i_loss_,
                               0.74652578358324106, delta=1e-5)
        self.assertAlmostEqual(recommender.f_loss_,
                               0.025638738121075231, delta=1e-5)

        self.assertAlmostEqual(recommender.predict((1, 7)),
                               3.9873641434545979, delta=1e-5)
        self.assertAlmostEqual(recommender.predict((1, 9)),
                               4.9892118821609106, delta=1e-5)
        self.assertAlmostEqual(recommender.predict((1, 11)),
                               3.6480799850368273, delta=1e-5)
        self.assertAlmostEqual(recommender.predict((3, 7)),
                               3.6336318795279228, delta=1e-5)
        self.assertAlmostEqual(recommender.predict((3, 9)),
                               4.2482001235634943, delta=1e-5)
        self.assertAlmostEqual(recommender.predict((3, 11)),
                               3.7236984083417841, delta=1e-5)
        self.assertAlmostEqual(recommender.predict((5, 7)),
                               3.4141968145802597, delta=1e-5)
        self.assertAlmostEqual(recommender.predict((5, 9)),
                               3.9818882049478654, delta=1e-5)
        self.assertAlmostEqual(recommender.predict((5, 11)),
                               3.4710520150321895, delta=1e-5)
        x = np.array([
            [1, 7], [1, 9], [1, 11],
            [3, 7], [3, 9], [3, 11],
            [5, 7], [5, 9], [5, 11]])
        assert_allclose(
            recommender.predict(x),
            [3.98736414, 4.98921188, 3.64807999, 3.63363188, 4.24820012,
             3.72369841, 3.41419681, 3.9818882, 3.47105202],
            rtol=1e-5)
Exemple #3
0
def training(opt, ev, tsc, event_feature=None, fold=0):
    """
    training model

    Parameters
    ----------
    opt : dict
        parsed command line options
    ev : array, size=(n_events, 2), dtype=np.int
        array of events in external ids
    tsc : array, size=(n_events,), dtype=np.float
        true scores
    event_feature : optional, structured array
        structured array of event features
    fold : int, default=0
        fold No.

    Returns
    -------
    rcmdr : EventScorePredictor
        trained recommender
    """

    # generate event data
    data = EventWithScoreData(n_otypes=2, n_stypes=1)
    if np.all(opt.domain == [0, 0, 0]):
        score_domain = (
            np.min(tsc), np.max(tsc), np.min(np.diff(np.unique(tsc))))
    else:
        score_domain = tuple(opt.domain)
    logger.info("score_domain = " + str(score_domain))
    data.set_events(ev, tsc, score_domain=score_domain,
                    event_feature=event_feature)

    # init learning results
    if 'training_start_time' not in opt:
        opt.training_start_time = [0] * opt.fold
    if 'training_end_time' not in opt:
        opt.training_end_time = [0] * opt.fold
    if 'learning_i_loss' not in opt:
        opt.learning_i_loss = [np.inf] * opt.fold
    if 'learning_f_loss' not in opt:
        opt.learning_f_loss = [np.inf] * opt.fold
    if 'learning_opt_outputs' not in opt:
        opt.learning_opt_outputs = [None] * opt.fold

    # set starting time
    start_time = datetime.datetime.now()
    start_utime = os.times()[0]
    opt.training_start_time[fold] = start_time.isoformat()
    logger.info("training_start_time = " + start_time.isoformat())

    # create and learning model
    rcmdr = EventScorePredictor(
        C=opt.C, k=opt.k, tol=opt.tol, maxiter=opt.maxiter,
        random_state=opt.rseed)
    rcmdr.fit(data)

    # set end and elapsed time
    end_time = datetime.datetime.now()
    end_utime = os.times()[0]
    elapsed_time = end_time - start_time
    elapsed_utime = end_utime - start_utime
    opt.training_end_time[fold] = end_time.isoformat()
    logger.info("training_end_time = " + end_time.isoformat())
    if 'training_elapsed_time' not in opt:
        opt.training_elapsed_time = elapsed_time
    else:
        opt.training_elapsed_time += elapsed_time
    logger.info("training_elapsed_time = " + str(opt.training_elapsed_time))
    if 'training_elapsed_utime' not in opt:
        opt.training_elapsed_utime = elapsed_utime
    else:
        opt.training_elapsed_utime += elapsed_utime
    logger.info("training_elapsed_utime = " + str(opt.training_elapsed_utime))

    # preserve optimizer's outputs
    opt.learning_i_loss[fold] = rcmdr.i_loss_
    opt.learning_f_loss[fold] = rcmdr.f_loss_
    opt.learning_opt_outputs[fold] = rcmdr.opt_outputs_

    return rcmdr
Exemple #4
0
    def test_class(self):
        import numpy as np
        from kamrecsys.datasets import load_movielens_mini
        from kamrecsys.mf.pmf import EventScorePredictor

        data = load_movielens_mini()

        recommender = EventScorePredictor(C=0.1,
                                          k=2,
                                          tol=1e-03,
                                          random_state=1234)
        self.assertDictEqual(
            vars(recommender), {
                'C': 0.1,
                'n_otypes': 0,
                'bu_': None,
                'bi_': None,
                'k': 2,
                'p_': None,
                'q_': None,
                '_coef': None,
                'f_loss_': np.inf,
                'iid': None,
                'i_loss_': np.inf,
                'eid': None,
                'tol': 1e-03,
                'n_objects': None,
                '_dt': None,
                'mu_': None,
                'opt_outputs_': None,
                'maxiter': 200,
                'random_state': 1234,
                '_rng': None
            })

        recommender.fit(data, disp=False)
        self.assertAlmostEqual(recommender.i_loss_,
                               0.74652578358324106,
                               delta=1e-5)
        self.assertAlmostEqual(recommender.f_loss_,
                               0.025638738121075231,
                               delta=1e-5)

        self.assertAlmostEqual(recommender.predict((1, 7)),
                               3.9873641434545979,
                               delta=1e-5)
        self.assertAlmostEqual(recommender.predict((1, 9)),
                               4.9892118821609106,
                               delta=1e-5)
        self.assertAlmostEqual(recommender.predict((1, 11)),
                               3.6480799850368273,
                               delta=1e-5)
        self.assertAlmostEqual(recommender.predict((3, 7)),
                               3.6336318795279228,
                               delta=1e-5)
        self.assertAlmostEqual(recommender.predict((3, 9)),
                               4.2482001235634943,
                               delta=1e-5)
        self.assertAlmostEqual(recommender.predict((3, 11)),
                               3.7236984083417841,
                               delta=1e-5)
        self.assertAlmostEqual(recommender.predict((5, 7)),
                               3.4141968145802597,
                               delta=1e-5)
        self.assertAlmostEqual(recommender.predict((5, 9)),
                               3.9818882049478654,
                               delta=1e-5)
        self.assertAlmostEqual(recommender.predict((5, 11)),
                               3.4710520150321895,
                               delta=1e-5)
        x = np.array([[1, 7], [1, 9], [1, 11], [3, 7], [3, 9], [3, 11], [5, 7],
                      [5, 9], [5, 11]])
        assert_allclose(recommender.predict(x), [
            3.98736414, 4.98921188, 3.64807999, 3.63363188, 4.24820012,
            3.72369841, 3.41419681, 3.9818882, 3.47105202
        ],
                        rtol=1e-5)