예제 #1
0
 def test_compare(self):
     for X in [self.Xtrain1, self.Xtrain2]:
         for Y in [self.Ytrain1, self.Ytrain2]:
             #No bias
             greedy_rls = GreedyRLS(X,
                                    Y,
                                    subsetsize=10,
                                    regparam=12,
                                    bias=0.)
             selected = greedy_rls.selected
             s_complement = list(
                 set(range(X.shape[1])).difference(selected))
             X_cut = X[:, selected]
             rls = RLS(X_cut, Y, regparam=12., bias=0.)
             W = greedy_rls.predictor.W[selected]
             W2 = rls.predictor.W
             assert_allclose(W, W2)
             assert_array_equal(greedy_rls.predictor.W[s_complement], 0)
             assert_array_equal(greedy_rls.predictor.b, 0)
             #Bias
             greedy_rls = GreedyRLS(X,
                                    Y,
                                    subsetsize=10,
                                    regparam=12,
                                    bias=2.)
             selected = greedy_rls.selected
             X_cut = X[:, selected]
             rls = RLS(X_cut, Y, regparam=12., bias=2.)
             W = greedy_rls.predictor.W[selected]
             W2 = rls.predictor.W
             assert_allclose(W, W2)
             assert_allclose(greedy_rls.predictor.b, rls.predictor.b)
예제 #2
0
def speedtest():
    tsize, fsize = 3000, 3000
    desiredfcount = 5
    Xtrain = mat(random.rand(fsize, tsize), dtype=float64)
    bias = 2.
    rp = 1.
    ylen = 2
    Y = mat(random.rand(tsize, ylen), dtype=float64)

    rpool = {}

    class TestCallback(object):
        def callback(self, learner):
            print('round')

        def finished(self, learner):
            pass

    tcb = TestCallback()
    rpool['callback'] = tcb
    rpool['X'] = Xtrain.T
    rpool['Y'] = Y

    rpool['subsetsize'] = str(desiredfcount)
    rpool['regparam'] = rp
    rpool['bias'] = bias
    grls = GreedyRLS(**rpool)

    print(grls.selected)
    print(grls.A[grls.selected])
    print(grls.b)
예제 #3
0
def train_rls():
    X_train, Y_train, X_test, Y_test = load_housing()
    #we select 5 features
    learner = GreedyRLS(X_train, Y_train, 5)
    #Test set predictions
    P_test = learner.predict(X_test)
    print("test error %f" %sqerror(Y_test, P_test))
    print("Selected features " +str(learner.selected))
예제 #4
0
def train_rls():
    X_train, Y_train, X_test, Y_test = load_housing()
    cb = Callback(X_test, Y_test)
    learner = GreedyRLS(X_train, Y_train, 13, callbackfun=cb)
    #Test set predictions
    P_test = learner.predict(X_test)
    print("test error %f" % sqerror(Y_test, P_test))
    print("Selected features " + str(learner.selected))
예제 #5
0
def core_greedyrls(X, y, regparam, scount):
    cb = Callback()
    learner = GreedyRLS(X,
                        y,
                        scount,
                        regparam=regparam,
                        callbackfun=cb,
                        bias=0.)
    selected = learner.selected
    return selected
예제 #6
0
def train_rls():
    mndata = MNIST("./data")
    X_train, Y_train = mndata.load_training()
    X_test, Y_test = mndata.load_testing()
    X_train, X_test = np.array(X_train), np.array(X_test)
    #One-vs-all mapping
    Y_train = ova(Y_train)
    Y_test = ova(Y_test)
    #Train greedy RLS, select 10 features
    cb = Callback(X_test, Y_test)
    learner = GreedyRLS(X_train, Y_train, 50, callbackfun=cb)
    print("Selected features " + str(learner.selected))
예제 #7
0
파일: predictor2.py 프로젝트: disc5/RLScore
def train_rls():
    #Trains RLS with default parameters (regparam=1.0, kernel='LinearKernel')
    X_train, Y_train, X_test, Y_test = load_housing()
    learner = GreedyRLS(X_train, Y_train, 5)
    #This is how we make predictions
    P_test = learner.predict(X_test)
    #We can separate the predictor from learner
    predictor = learner.predictor
    #And do the same predictions
    P_test = predictor.predict(X_test)
    #Let's get the coefficients of the predictor
    w = predictor.W
    b = predictor.b
    print("number of coefficients %d" % len(w))
    print("w-coefficients " + str(w))
    print("bias term %f" % b)
예제 #8
0
    def testRLS(self):
        print("\n\n\n\nTesting the correctness of the GreedyRLS module.\n\n")
        tsize, fsize = 10, 30
        desiredfcount = 5
        Xtrain = mat(random.rand(fsize, tsize), dtype=float64)
        bias = 2.
        bias_slice = sqrt(bias) * mat(ones(
            (1, Xtrain.shape[1]), dtype=float64))
        Xtrain_biased = vstack([Xtrain, bias_slice])
        ylen = 2
        Y = mat(random.rand(tsize, ylen), dtype=float64)
        selected = []
        rp = 1.
        currentfcount = 0
        while currentfcount < desiredfcount:
            selected_plus_bias = selected + [fsize]
            bestlooperf = 9999999999.
            for ci in range(fsize):
                if ci in selected_plus_bias: continue
                updK = Xtrain_biased[selected_plus_bias +
                                     [ci]].T * Xtrain_biased[selected_plus_bias
                                                             + [ci]]
                looperf = 0.
                for hi in range(tsize):
                    hoinds = list(range(0, hi)) + list(range(hi + 1, tsize))
                    updcutK = updK[ix_(hoinds, hoinds)]
                    updcrossK = updK[ix_([hi], hoinds)]
                    loopred = updcrossK * la.inv(
                        updcutK + rp * mat(eye(tsize - 1))) * Y[hoinds]
                    looperf += mean(
                        multiply((loopred - Y[hi]), (loopred - Y[hi])))
                if looperf < bestlooperf:
                    bestcind = ci
                    bestlooperf = looperf
                print('Tester ', ci, looperf)
            selected.append(bestcind)
            print('Tester ', selected)
            currentfcount += 1
        selected_plus_bias = selected + [fsize]
        K = Xtrain_biased[selected_plus_bias].T * Xtrain_biased[
            selected_plus_bias]
        G = la.inv(K + rp * mat(eye(tsize)))
        A = Xtrain_biased[selected_plus_bias] * G * Y
        print('Tester ', A)
        rpool = {}

        class TestCallback(object):
            def callback(self, learner):
                print('GreedyRLS', learner.looperf.T)
                pass

            def finished(self, learner):
                pass

        tcb = TestCallback()
        rpool['callback'] = tcb
        rpool['X'] = Xtrain.T
        rpool['Y'] = Y
        rpool['subsetsize'] = desiredfcount
        rpool['regparam'] = rp
        rpool['bias'] = bias
        grls = GreedyRLS(**rpool)
        assert_array_equal(selected, grls.selected)
        assert_allclose(A[:-1], grls.A[selected])
        assert_allclose(np.sqrt(bias) * A[-1], grls.b)