예제 #1
0
파일: MLC.py 프로젝트: scheeloong/digbeta
    def fit(self,
            X_train,
            Y_train,
            user_playlist_indices=None,
            batch_size=256,
            w0=None,
            njobs=1,
            verbose=0,
            fnpy='_'):
        assert X_train.shape[0] == Y_train.shape[0]
        N, D = X_train.shape
        K = Y_train.shape[1]

        if verbose > 1:
            t0 = time.time()

        if verbose > 0:
            if user_playlist_indices is None:
                print('\nC: %g, p: %g' % (self.C1, self.p))
            else:
                print('\nC1: %g, C3: %g, p: %g' % (self.C1, self.C3, self.p))

        if w0 is not None:
            assert w0.shape[0] == K * (D + 1)
        else:
            if fnpy is not None:
                try:
                    w0 = np.load(fnpy, allow_pickle=False)
                    assert w0.shape[0] == K * (D + 1)
                    print('Restore from %s' % fnpy)
                except (IOError, ValueError):
                    w0 = np.zeros(K * (D + 1))

        data_helper = DataHelper(Y_train, ax=1, batch_size=batch_size)

        try:
            # f: callable(x, g, *args)
            # LBFGS().minimize(f, x0, progress=progress, args=args)
            optim = LBFGS()
            optim.linesearch = 'wolfe'
            res = optim.minimize(objective,
                                 w0,
                                 progress,
                                 args=(X_train, Y_train, self.C1, self.C3,
                                       self.p, user_playlist_indices,
                                       data_helper, njobs, verbose, fnpy))
            self.b = res[:K].reshape(1, K)
            self.W = res[K:].reshape(K, D)
            self.trained = True
        except (LBFGSError, MemoryError) as err:
            self.trained = False
            sys.stderr.write('LBFGS failed: {0}\n'.format(err))
            sys.stderr.flush()

        if verbose > 1:
            print('Training finished in %.1f seconds' % (time.time() - t0))
예제 #2
0
파일: PCMLC.py 프로젝트: scheeloong/digbeta
    def fit(self,
            X_train,
            Y_train,
            user_playlist_indices=None,
            batch_size=256,
            verbose=0,
            w0=None,
            fnpy=None):
        assert X_train.shape[0] == Y_train.shape[0]
        N, D = X_train.shape
        K = Y_train.shape[1]
        VERBOSE = verbose  # set verbose output, use a global variable in this case

        if VERBOSE > 0:
            t0 = time.time()

        if w0 is None:
            if fnpy is not None:
                try:
                    w0 = np.load(fnpy, allow_pickle=False)
                    assert w0.shape[0] == K * D + 1
                    print('Restore from %s' % fnpy)
                except (IOError, ValueError):
                    w0 = np.zeros(K * D + 1)
        else:
            assert w0.shape[0] == K * D + 1

        data_helper_example = None if self.loss_type == 'label' else DataHelper(
            Y_train, ax=0, batch_size=batch_size)
        data_helper_label = None if self.loss_type == 'example' else DataHelper(
            Y_train, ax=1, batch_size=batch_size)

        try:
            # f: callable(x, g, *args)
            # LBFGS().minimize(f, x0, progress=progress, args=args)
            optim = LBFGS()
            optim.linesearch = 'wolfe'
            res = optim.minimize(
                objective,
                w0,
                progress,
                args=(X_train, Y_train, self.C1, self.C2, self.C3, self.p,
                      self.loss_type, user_playlist_indices,
                      data_helper_example, data_helper_label, fnpy))
            self.b = res[0]
            self.W = res[1:].reshape(K, D)
            self.trained = True
        except (LBFGSError, MemoryError) as err:
            self.trained = False
            sys.stderr.write('LBFGS failed: {0}\n'.format(err))
            sys.stderr.flush()

        if VERBOSE > 0:
            print('Training finished in %.1f seconds' % (time.time() - t0))
예제 #3
0
    def fit(self, w0=None, verbose=0, fnpy='_'):
        N, U, D = self.N, self.U, self.D

        if verbose > 0:
            t0 = time.time()

        if verbose > 0:
            print('\nC: %g, %g, p: %g' % (self.C1, self.C2, self.p))

        num_vars = (U + N + 1) * D
        if w0 is None:
            np.random.seed(0)
            if fnpy is not None:
                try:
                    w0 = np.load(fnpy, allow_pickle=False)
                    print('Restore from %s' % fnpy)
                except (IOError, ValueError):
                    w0 = 1e-3 * np.random.randn(num_vars)
            else:
                w0 = 1e-3 * np.random.randn(num_vars)
        if w0.shape != (num_vars, ):
            raise ValueError('ERROR: incorrect dimention for initial weights.')

        try:
            # f: callable(x, g, *args)
            # LBFGS().minimize(f, x0, progress=progress, args=args)
            optim = LBFGS()
            optim.linesearch = 'wolfe'
            optim.orthantwise_c = self.C2
            optim.orthantwise_start = U * D  # start index to compute L1 regularisation (included)
            optim.orthantwise_end = w0.shape[
                0]  # end   index to compute L1 regularisation (not included)
            res = optim.minimize(objective,
                                 w0,
                                 progress,
                                 args=(self.X, self.Y, self.C1, self.p,
                                       self.cliques, self.data_helper, verbose,
                                       fnpy))
            self.V = res[:U * D].reshape(U, D)
            self.W = res[U * D:(U + N) * D].reshape(N, D)
            self.mu = res[(U + N) * D:]
            assert self.mu.shape == (D, )
            self.trained = True
        except (LBFGSError, MemoryError) as err:
            self.trained = False
            sys.stderr.write('LBFGS failed: {0}\n'.format(err))
            sys.stderr.flush()

        if verbose > 0:
            print('Training finished in %.1f seconds' % (time.time() - t0))
예제 #4
0
    def fit(self, w0=None, verbose=0, fnpy=None):
        N, U, D = self.N, self.U, self.D
        if verbose > 0:
            t0 = time.time()
            print('\nC: %g, %g, %g' % (self.C1, self.C2, self.C3))

        num_vars = (U + N + 1) * D
        if w0 is None:
            if fnpy is None:
                w0 = self._init_vars()
            else:
                try:
                    assert type(fnpy) == str
                    assert fnpy.endswith('.npy')
                    w0 = np.load(fnpy, allow_pickle=False)
                    print('Restore from %s' % fnpy)
                except (IOError, ValueError):
                    w0 = self._init_vars()
        assert w0.shape == (num_vars, )

        try:
            # f: callable(x, g, *args)
            # LBFGS().minimize(f, x0, progress=progress, args=args)
            optim = LBFGS()
            optim.linesearch = 'wolfe'
            optim.max_linesearch = 100
            param_dict = {'N': self.N, 'C': (self.C1, self.C2, self.C3)}
            res = optim.minimize(objective,
                                 w0,
                                 progress,
                                 args=(self.X, self.cliques, self.data_helper,
                                       param_dict, verbose, fnpy))
            self.mu = res[:D]
            self.V = res[D:(U + 1) * D].reshape(U, D)
            self.W = res[(U + 1) * D:].reshape(N, D)
            self.trained = True
        except (LBFGSError, MemoryError) as err:
            self.trained = False
            sys.stderr.write('LBFGS failed: {0}\n'.format(err))
            sys.stderr.flush()

        if verbose > 0:
            print('Training finished in %.1f seconds' % (time.time() - t0))
예제 #5
0
def train_loglin(trainX, trainY, reg_const):
    D, V = trainX.shape
    K = 2  #two classes
    #print 'K={0}, D={1}, V={2}'.format(K, D, V)
    assert trainX.shape[0] == len(trainY)
    beta = loglinmm.get_beta(trainX)
    gamma0 = np.random.rand(K, V)

    #PYLBFGS stuff
    bb = LBFGS()
    bb.orthantwise_c = 2.0**reg_const
    bb.linesearch = 'wolfe'
    bb.epsilon = 1e-01
    bb.delta = 1e-01

    #find optimum
    gamma_opt = bb.minimize(loglinmm.negll, gamma0, None,
                            [beta, trainX, trainY])
    w_given_class = loglinmm.prob_w_given_k(beta, gamma_opt)
    return w_given_class
예제 #6
0
    def fit(self, w0=None, verbose=0, fnpy='_'):
        N, U, D = self.N, self.U, self.D

        if verbose > 0:
            t0 = time.time()

        if verbose > 0:
            print('\nC: %g, p: %g' % (self.C, self.p))

        if w0 is not None:
            assert w0.shape[0] == (U + N + 1) * D
        else:
            if fnpy is not None:
                try:
                    w0 = np.load(fnpy, allow_pickle=False)
                    assert w0.shape[0] == (U + N + 1) * D
                    print('Restore from %s' % fnpy)
                except (IOError, ValueError):
                    w0 = np.zeros((U + N + 1) * D)

        try:
            # f: callable(x, g, *args)
            # LBFGS().minimize(f, x0, progress=progress, args=args)
            optim = LBFGS()
            optim.linesearch = 'wolfe'
            optim.orthantwise_c = self.C
            optim.orthantwise_start = (U + 1) * D  # start index to compute L1 regularisation (included)
            optim.orthantwise_end = w0.shape[0]     # end   index to compute L1 regularisation (not included)
            res = optim.minimize(objective_L1, w0, progress,
                                 args=(self.X, self.Y, self.C, self.p, self.cliques, self.data_helper, verbose, fnpy))
            self.mu = res[:D]
            self.V = res[D:(U + 1) * D].reshape(U, D)
            self.W = res[(U + 1) * D:].reshape(N, D)
            self.trained = True
        except (LBFGSError, MemoryError) as err:
            self.trained = False
            sys.stderr.write('LBFGS failed: {0}\n'.format(err))
            sys.stderr.flush()

        if verbose > 0:
            print('Training finished in %.1f seconds' % (time.time() - t0))