def testCGRLS(self): m, n = 100, 300 for regparam in [0.00000001, 1, 100000000]: Xtrain = np.mat(np.random.rand(m, n)) Y = np.mat(np.random.rand(m, 1)) rpool = {} rpool["train_features"] = Xtrain rpool["train_labels"] = Y rpool["regparam"] = regparam rpool["bias"] = 1.0 rls = RLS.createLearner(**rpool) rls.solve(regparam) model = rls.getModel() W = model.W b = model.b rls = CGRLS.createLearner(**rpool) rls.train() model = rls.getModel() W2 = model.W b2 = model.b for i in range(W.shape[0]): # for j in range(W.shape[1]): # self.assertAlmostEqual(W[i,j],W2[i,j],places=5) self.assertAlmostEqual(W[i], W2[i], places=5) self.assertAlmostEqual(b, b2, places=5)
def nfoldRLS(X, Y, fcount): kwargs = {} kwargs['train_features'] = X kwargs['train_labels'] = Y rls = RLS.createLearner(**kwargs) rls.train() bestperf = -1. for logrp in range(5, 25): rp = 2. ** logrp rls.solve(rp) perfs = [] kf = KFold(len(Y), n_folds=fcount, indices=True, shuffle=True, random_state=77) for train, test in kf: P = rls.computeHO(test) perf = cindex(Y[test], P) perfs.append(perf) perf = np.mean(perfs) print "N-fold CV %f for lambda 2^%d" %(perf, logrp) if perf > bestperf: bestperf = perf bestlogrp = logrp rp = 2. ** bestlogrp print "Best N-fold CV %f for lambda 2^%d" %(bestperf, bestlogrp) rls.solve(rp) model = rls.getModel() return model
def looRLS(XPath, yPath, metaPath): X, Y = readAuto(XPath, yPath) meta = {} if metaPath != None: print "Loading metadata from", metaPath meta = result.getMeta(metaPath) X_train, X_hidden, Y_train, Y_hidden = hidden.split(X, Y, meta=meta) kwargs = {} kwargs['train_features'] = X_train kwargs['train_labels'] = Y_train kwargs['regparam'] = 1.0 rls = RLS.createLearner(**kwargs) rls.train() bestperf = -1. for logrp in range(5, 25): rp = 2. ** logrp rls.solve(rp) Ploo = rls.computeLOO() perf = cindex(Y_train, Ploo) print "Leave-one-out %f for lambda 2^%d" %(perf, logrp) if perf > bestperf: bestperf = perf bestlogrp = logrp rp = 2. ** bestlogrp print "Best leave-one-out %f for lambda 2^%d" %(bestperf, bestlogrp) rls.solve(rp) model = rls.getModel() P = model.predict(X_hidden) perf = cindex(Y_hidden, P) print "final performance: %f" %perf
def testRLS(input): X, Y = svmlight_format.load_svmlight_file(input) hoindices = range(int(0.1 * len(Y))) hocompl = list(set(range(len(Y))) - set(hoindices)) trainX = X[hocompl] testX = X[hoindices] trainY = Y[hocompl] testY = Y[hoindices] print len(trainY), len(testY) kwargs = {} kwargs["train_features"] = trainX kwargs["train_labels"] = trainY rls = RLS.createLearner(**kwargs) rls.train() bestperf = -1.0 for logrp in range(-5, 5): rp = 2.0 ** logrp rls.solve(rp) Ploo = rls.computeLOO() perf = cindex(trainY, Ploo) print logrp, perf if perf > bestperf: bestperf = perf bestlogrp = logrp rp = 2.0 ** bestlogrp rls.solve(rp) P = rls.getModel().predict(testX)
def testCGRLS(self): m, n = 100, 300 for regparam in [0.00000001, 1, 100000000]: Xtrain = np.mat(np.random.rand(m, n)) Y = np.mat(np.random.rand(m, 1)) rpool = {} rpool['train_features'] = Xtrain rpool['train_labels'] = Y rpool['regparam'] = regparam rpool["bias"] = 1.0 rls = RLS.createLearner(**rpool) rls.solve(regparam) model = rls.getModel() W = model.W b = model.b rls = CGRLS.createLearner(**rpool) rls.train() model = rls.getModel() W2 = model.W b2 = model.b for i in range(W.shape[0]): #for j in range(W.shape[1]): # self.assertAlmostEqual(W[i,j],W2[i,j],places=5) self.assertAlmostEqual(W[i], W2[i], places=5) self.assertAlmostEqual(b, b2, places=5)
def search_params_linear(trainX, trainY, group_ids, rprange): """Search best parameters for kernel and regularization.""" kwargs = { 'train_features': trainX, 'train_labels': trainY, 'kernel_obj': LinearKernel(trainX), } rls = RLS.createLearner(**kwargs) rls.train() perf, perf_groups, rp = search_rp(rls, trainY, group_ids, rprange) return perf, perf_groups, rp
def search_params_nonlinear(trainX, trainY, group_ids, rprange, gammarange): """Search best parameters for kernel and regularization.""" bestperf = -1. for loggamma in range(*gammarange): gamma = 2. ** loggamma kwargs = { 'train_features': trainX, 'train_labels': trainY, #'kernel_obj': LinearKernel(trainX), 'kernel_obj': GaussianKernel(trainX, gamma=gamma), #'kernel_obj': PolynomialKernel(trainX, gamma=gamma, coef0=1, degree=2), } rls = RLS.createLearner(**kwargs) rls.train() perf, perf_groups, rp = search_rp(rls, trainY, group_ids, rprange) if perf > bestperf: bestperf = perf bestperf_groups = perf_groups bestrp = rp bestgamma = gamma return bestperf, bestperf_groups, bestrp, bestgamma
def testRLS(self): print print print print print "Testing the cross-validation routines of the RLS module." print print floattype = float64 m, n = 400, 100 Xtrain = mat(random.rand(m, n)) K = Xtrain * Xtrain.T ylen = 2 Y = mat(zeros((m, ylen), dtype=floattype)) Y = mat(random.rand(m, ylen)) #hoindices = [45, 50, 55] hoindices = [45] hocompl = list(set(range(m)) - set(hoindices)) Kho = K[ix_(hocompl, hocompl)] Yho = Y[hocompl] kwargs = {} kwargs['train_labels'] = Y kwargs['kernel_matrix'] = K dualrls = RLS.createLearner(**kwargs) kwargs = {} kwargs["train_features"] = Xtrain kwargs["train_labels"] = Y primalrls = RLS.createLearner(**kwargs) kwargs = {} kwargs['train_labels'] = Yho kwargs['kernel_matrix'] = Kho dualrls_naive = RLS.createLearner(**kwargs) testkm = K[ix_(hocompl, hoindices)] trainX = Xtrain[hocompl] testX = Xtrain[hoindices] kwargs = {} kwargs['train_labels'] = Yho kwargs['train_features'] = trainX primalrls_naive = RLS.createLearner(**kwargs) loglambdas = range(-5, 5) for j in range(0, len(loglambdas)): regparam = 2. ** loglambdas[j] print print "Regparam 2^%1d" % loglambdas[j] dumbho = testkm.T * la.inv(Kho + regparam * eye(Kho.shape[0])) * Yho print dumbho, 'Dumb HO (dual)' dualrls_naive.solve(regparam) predho1 = dualrls_naive.getModel().predict(testkm.T) print predho1, 'Naive HO (dual)' dualrls.solve(regparam) predho2 = dualrls.computeHO(hoindices) print predho2, 'Fast HO (dual)' dualrls.solve(regparam) predho = dualrls.computeLOO()[hoindices[0]] print predho, 'Fast LOO (dual)' primalrls_naive.solve(regparam) predho3 = primalrls_naive.getModel().predict(testX) print predho3, 'Naive HO (primal)' primalrls.solve(regparam) predho4 = primalrls.computeHO(hoindices) print predho4, 'Fast HO (primal)' for predho in [predho1, predho2, predho3, predho4]: self.assertEqual(dumbho.shape, predho.shape) for row in range(predho.shape[0]): for col in range(predho.shape[1]): self.assertAlmostEqual(dumbho[row,col],predho[row,col]) primalrls.solve(regparam) predho = primalrls.computeLOO()[hoindices[0]] print predho, 'Fast LOO (primal)' print hoindices = range(100, 300) hocompl = list(set(range(m)) - set(hoindices)) Kho = K[ix_(hocompl, hocompl)] Yho = Y[hocompl] testkm = K[ix_(hocompl, hoindices)] dumbho = testkm.T * la.inv(Kho + regparam * eye(Kho.shape[0])) * Yho kwargs = {} kwargs['train_labels'] = Yho kwargs['kernel_matrix'] = Kho dualrls_naive = RLS.createLearner(**kwargs) dualrls_naive.solve(regparam) predho1 = dualrls_naive.getModel().predict(testkm.T) print sum(abs(predho1-dumbho)), 'Naive HO (dual)' dualrls.solve(regparam) predho2 = dualrls.computeHO(hoindices) print sum(abs(predho2-dumbho)), 'Fast HO (dual)'
def testRLS(self): print print print print print "Testing the cross-validation routines of the RLS module." print print floattype = float64 m, n = 100, 300 Xtrain = random.rand(m, n) ylen = 1 Y = mat(zeros((m, ylen), dtype=floattype)) Y = mat(random.rand(m, 1)) basis_vectors = [0,3,7,8] def complement(indices, m): compl = range(m) for ind in indices: compl.remove(ind) return compl #hoindices = [45, 50, 55] hoindices = [0, 1, 2] hocompl = complement(hoindices, m) #bk = LinearKernel.Kernel() #bk = GaussianKernel.Kernel() bk = GaussianKernel.createKernel(**{'train_features':Xtrain[basis_vectors], 'gamma':'0.001'}) rk = RsetKernel.createKernel(**{'base_kernel':bk, 'basis_features':Xtrain[basis_vectors], 'train_features':Xtrain}) rpool = {} rpool['train_features'] = Xtrain bk2 = GaussianKernel.createKernel(**{'train_features':Xtrain, 'gamma':'0.001'}) K = np.mat(bk2.getKM(Xtrain)) Kho = K[ix_(hocompl, hocompl)] Yho = Y[hocompl] #rpool = {} #rpool['train_labels'] = Y #rpool['kernel_matrix'] = K[basis_vectors] #rpool['basis_vectors'] = basis_vectors #dualrls = RLS.createLearner(**rpool) rpool = {} rpool['train_labels'] = Y rpool['train_features'] = Xtrain rpool['basis_vectors'] = Xtrain[basis_vectors] primalrls = RLS.createLearner(**rpool) testkm = K[ix_(hocompl, hoindices)] Xhocompl = Xtrain[hocompl] testX = Xtrain[hoindices] rpool = {} rpool['train_labels'] = Yho rpool['train_features'] = Xhocompl rk = RsetKernel.createKernel(**{'base_kernel':bk, 'basis_features':Xtrain[basis_vectors], 'train_features':Xhocompl}) rpool['kernel_obj'] = rk dualrls_naive = RLS.createLearner(**rpool) rpool = {} rpool['train_labels'] = Yho rpool['train_features'] = Xhocompl primalrls_naive = RLS.createLearner(**rpool) rsaK = K[:, basis_vectors] * la.inv(K[ix_(basis_vectors, basis_vectors)]) * K[basis_vectors] rsaKho = rsaK[ix_(hocompl, hocompl)] rsa_testkm = rsaK[ix_(hocompl, hoindices)] loglambdas = range(-5, 5) for j in range(0, len(loglambdas)): regparam = 2. ** loglambdas[j] print print "Regparam 2^%1d" % loglambdas[j] print (rsa_testkm.T * la.inv(rsaKho + regparam * eye(rsaKho.shape[0])) * Yho).T, 'Dumb HO (dual)' dumbho = np.squeeze(np.array(rsa_testkm.T * la.inv(rsaKho + regparam * eye(rsaKho.shape[0])) * Yho)) dualrls_naive.solve(regparam) predho1 = np.squeeze(dualrls_naive.getModel().predict(testX)) print predho1.T, 'Naive HO (dual)' #dualrls.solve(regparam) #predho2 = np.squeeze(dualrls.computeHO(hoindices)) #print predho2.T, 'Fast HO (dual)' for predho in [dumbho, predho1]:#, predho2]: self.assertEqual(dumbho.shape, predho.shape) for row in range(predho.shape[0]): #for col in range(predho.shape[1]): # self.assertAlmostEqual(dumbho[row,col],predho[row,col]) self.assertAlmostEqual(dumbho[row],predho[row])