def solver_dcd_shogun_debug(C, all_xt, all_lt, task_indicator, M, L): """ use standard LibLinear for debugging purposes """ xt = numpy.array(all_xt) lt = numpy.array(all_lt) tt = numpy.array(task_indicator, dtype=numpy.int32) tsm = numpy.array(M) num_tasks = L.shape[0] # sanity checks assert len(xt) == len(lt) == len(tt) assert M.shape == L.shape assert num_tasks == len(set(tt)) # set up shogun objects if type(xt[0]) == str: feat = create_hashed_features_wdk(xt, 8) else: feat = RealFeatures(xt.T) lab = Labels(lt) # set up machinery svm = LibLinear() svm.set_liblinear_solver_type(L2R_L1LOSS_SVC_DUAL) svm.io.set_loglevel(MSG_DEBUG) svm.set_C(C, C) svm.set_bias_enabled(False) # invoke training svm.set_labels(lab) svm.train(feat) # get model parameters W = [svm.get_w()] return W, 42, 42
lab_presvm = Labels(numpy.array(labels_presvm)) wdk_presvm = LinearKernel(feat_presvm, feat_presvm) presvm_liblinear = LibLinear(1, feat_presvm, lab_presvm) presvm_liblinear.set_max_iterations(10000) presvm_liblinear.set_bias_enabled(False) presvm_liblinear.train() presvm_libsvm = LibSVM(1, wdk_presvm, lab_presvm) #presvm_libsvm = SVMLight(1, wdk_presvm, lab_presvm) #presvm_libsvm.io.set_loglevel(MSG_DEBUG) presvm_libsvm.set_bias_enabled(False) presvm_libsvm.train() my_w = presvm_liblinear.get_w() presvm_liblinear = LibLinear(1, feat_presvm, lab_presvm) presvm_liblinear.set_w(my_w) ############################################# # compute linear term manually ############################################# examples = numpy.array(examples, dtype=numpy.float64) examples = numpy.transpose(examples) feat = RealFeatures(examples) lab = Labels(numpy.array(labels)) wdk = LinearKernel(feat, feat) lab = Labels(numpy.array(labels))
def classifier_perceptron_graphical(n=100, distance=5, learn_rate=1., max_iter=1000, num_threads=1, seed=None, nperceptrons=5): from shogun.Features import RealFeatures, BinaryLabels from shogun.Classifier import Perceptron, LibLinear, L2R_L2LOSS_SVC from modshogun import MSG_INFO # 2D data _DIM = 2 # To get the nice message that the perceptron has converged dummy = BinaryLabels() # dummy.io.set_loglevel(MSG_INFO) np.random.seed(seed) # Produce some (probably) linearly separable training data by hand # Two Gaussians at a far enough distance X = np.array(np.random.randn(_DIM,n))+distance Y = np.array(np.random.randn(_DIM,n)) label_train_twoclass = np.hstack((np.ones(n), -np.ones(n))) fm_train_real = np.hstack((X,Y)) feats_train = RealFeatures(fm_train_real) labels = BinaryLabels(label_train_twoclass) perceptron = Perceptron(feats_train, labels) perceptron.set_learn_rate(learn_rate) perceptron.set_max_iter(max_iter) perceptron.set_initialize_hyperplane(False) # Find limits for visualization x_min = min(np.min(X[0,:]), np.min(Y[0,:])) x_max = max(np.max(X[0,:]), np.max(Y[0,:])) y_min = min(np.min(X[1,:]), np.min(Y[1,:])) y_max = max(np.max(X[1,:]), np.max(Y[1,:])) fig1, axes1 = plt.subplots(1,1) fig2, axes2 = plt.subplots(1,1) for i in xrange(nperceptrons): # Initialize randomly weight vector and bias perceptron.set_w(np.random.random(2)) perceptron.set_bias(np.random.random()) # Run the perceptron algorithm perceptron.train() # Construct the hyperplane for visualization # Equation of the decision boundary is w^T x + b = 0 b = perceptron.get_bias() w = perceptron.get_w() hx = np.linspace(x_min-1,x_max+1) hy = -w[1]/w[0] * hx axes1.plot(hx, -1/w[1]*(w[0]*hx+b)) axes2.plot(hx, -1/w[1]*(w[0]*hx+b), alpha=0.5) print('minimum distance with perceptron is %f' % min_distance(w, b, feats_train)) C = 1 epsilon = 1e-3 svm = LibLinear(C, feats_train, labels) svm.set_liblinear_solver_type(L2R_L2LOSS_SVC) svm.set_epsilon(epsilon) svm.set_bias_enabled(True) svm.train() b = svm.get_bias() w = svm.get_w() print('minimum distance with svm is %f' % min_distance(w, b, feats_train)) hx = np.linspace(x_min-1,x_max+1) hy = -w[1]/w[0] * hx axes2.plot(hx, -1/w[1]*(w[0]*hx+b), 'k', linewidth=2.0) # Plot the two-class data axes1.scatter(X[0,:], X[1,:], s=40, marker='o', facecolors='none', edgecolors='b') axes1.scatter(Y[0,:], Y[1,:], s=40, marker='s', facecolors='none', edgecolors='r') axes2.scatter(X[0,:], X[1,:], s=40, marker='o', facecolors='none', edgecolors='b') axes2.scatter(Y[0,:], Y[1,:], s=40, marker='s', facecolors='none', edgecolors='r') # Customize the plot axes1.axis([x_min-1, x_max+1, y_min-1, y_max+1]) axes1.set_title('Rosenblatt\'s Perceptron Algorithm') axes1.set_xlabel('x') axes1.set_ylabel('y') axes2.axis([x_min-1, x_max+1, y_min-1, y_max+1]) axes2.set_title('Support Vector Machine') axes2.set_xlabel('x') axes2.set_ylabel('y') plt.show() return perceptron
def SVMLinear(traindata, trainlabs, testdata, C=1.0, eps=1e-5, threads=1, getw=False, useLibLinear=False, useL1R=False): """ Does efficient linear SVM using the OCAS subgradient solver (as interfaced by shogun). Handles multiclass problems using a one-versus-all approach. NOTE: the training and testing data should both be scaled such that each dimension ranges from 0 to 1 traindata = n by d training data array trainlabs = n-length training data label vector (should be normalized so labels range from 0 to c-1, where c is the number of classes) testdata = m by d array of data to test C = SVM regularization constant eps = precision parameter used by OCAS threads = number of threads to use getw = whether or not to return the learned weight vector from the SVM (note: only works for 2-class problems) returns: m-length vector containing the predicted labels of the instances in testdata if problem is 2-class and getw == True, then a d-length weight vector is also returned """ numc = trainlabs.max() + 1 # # when using an L1 solver, we need the data transposed # # trainfeats = wrapFeatures(traindata, sparse=True) # testfeats = wrapFeatures(testdata, sparse=True) if not useL1R: ### traindata directly here for LR2_L2LOSS_SVC trainfeats = wrapFeatures(traindata, sparse=False) else: ### traindata.T here for L1R_LR trainfeats = wrapFeatures(traindata.T, sparse=False) testfeats = wrapFeatures(testdata, sparse=False) if numc > 2: preds = np.zeros(testdata.shape[0], dtype=np.int32) predprobs = np.zeros(testdata.shape[0]) predprobs[:] = -np.inf for i in xrange(numc): # set up svm tlabs = np.int32(trainlabs == i) tlabs[tlabs == 0] = -1 # print tlabs # print i, ' ', np.sum(tlabs==-1), ' ', np.sum(tlabs==1) labels = BinaryLabels(np.float64(tlabs)) if useLibLinear: # Use LibLinear and set the solver type svm = LibLinear(C, trainfeats, labels) if useL1R: # this is L1 regularization on logistic loss svm.set_liblinear_solver_type(L1R_LR) else: # most of my results were computed with this (ucf50) svm.set_liblinear_solver_type(L2R_L2LOSS_SVC) else: # Or Use SVMOcas svm = SVMOcas(C, trainfeats, labels) svm.set_epsilon(eps) svm.parallel.set_num_threads(threads) svm.set_bias_enabled(True) # train svm.train() # test res = svm.apply(testfeats).get_labels() thisclass = res > predprobs preds[thisclass] = i predprobs[thisclass] = res[thisclass] return preds else: tlabs = trainlabs.copy() tlabs[tlabs == 0] = -1 labels = Labels(np.float64(tlabs)) svm = SVMOcas(C, trainfeats, labels) svm.set_epsilon(eps) svm.parallel.set_num_threads(threads) svm.set_bias_enabled(True) # train svm.train() # test res = svm.classify(testfeats).get_labels() res[res > 0] = 1 res[res <= 0] = 0 if getw == True: return res, svm.get_w() else: return res
presvm_liblinear = LibLinear(1, feat_presvm, lab_presvm) presvm_liblinear.set_max_iterations(10000) presvm_liblinear.set_bias_enabled(False) presvm_liblinear.train() presvm_libsvm = LibSVM(1, wdk_presvm, lab_presvm) #presvm_libsvm = SVMLight(1, wdk_presvm, lab_presvm) #presvm_libsvm.io.set_loglevel(MSG_DEBUG) presvm_libsvm.set_bias_enabled(False) presvm_libsvm.train() my_w = presvm_liblinear.get_w() presvm_liblinear = LibLinear(1, feat_presvm, lab_presvm) presvm_liblinear.set_w(my_w) ############################################# # compute linear term manually ############################################# examples = numpy.array(examples, dtype=numpy.float64) examples = numpy.transpose(examples) feat = RealFeatures(examples) lab = Labels(numpy.array(labels)) wdk = LinearKernel(feat, feat)
def classifier_non_separable_svm(n=100, m=10, distance=5, seed=None): ''' n is the number of examples per class and m is the number of examples per class that gets its label swapped to force non-linear separability ''' from shogun.Features import RealFeatures, BinaryLabels from shogun.Classifier import LibLinear, L2R_L2LOSS_SVC # 2D data _DIM = 2 # To get the nice message that the perceptron has converged dummy = BinaryLabels() np.random.seed(seed) # Produce some (probably) linearly separable training data by hand # Two Gaussians at a far enough distance X = np.array(np.random.randn(_DIM, n)) + distance Y = np.array(np.random.randn(_DIM, n)) # The last five points of each class are swapped to force non-linear separable data label_train_twoclass = np.hstack( (np.ones(n - m), -np.ones(m), -np.ones(n - m), np.ones(m))) fm_train_real = np.hstack((X, Y)) feats_train = RealFeatures(fm_train_real) labels = BinaryLabels(label_train_twoclass) # Train linear SVM C = 1 epsilon = 1e-3 svm = LibLinear(C, feats_train, labels) svm.set_liblinear_solver_type(L2R_L2LOSS_SVC) svm.set_epsilon(epsilon) svm.set_bias_enabled(True) svm.train() # Get hyperplane parameters b = svm.get_bias() w = svm.get_w() # Find limits for visualization x_min = min(np.min(X[0, :]), np.min(Y[0, :])) x_max = max(np.max(X[0, :]), np.max(Y[0, :])) y_min = min(np.min(X[1, :]), np.min(Y[1, :])) y_max = max(np.max(X[1, :]), np.max(Y[1, :])) hx = np.linspace(x_min - 1, x_max + 1) hy = -w[1] / w[0] * hx plt.plot(hx, -1 / w[1] * (w[0] * hx + b), 'k', linewidth=2.0) # Plot the two-class data pos_idxs = label_train_twoclass == +1 plt.scatter(fm_train_real[0, pos_idxs], fm_train_real[1, pos_idxs], s=40, marker='o', facecolors='none', edgecolors='b') neg_idxs = label_train_twoclass == -1 plt.scatter(fm_train_real[0, neg_idxs], fm_train_real[1, neg_idxs], s=40, marker='s', facecolors='none', edgecolors='r') # Customize the plot plt.axis([x_min - 1, x_max + 1, y_min - 1, y_max + 1]) plt.title('SVM with non-linearly separable data') plt.xlabel('x') plt.ylabel('y') plt.show() return svm