def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train SVMs with RBF kernels for different values of the gamma ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function. ## Plot the decision boundary and support vectors for the best value of gamma ## using 'plot_svm_decision_boundary' function ########### # given gamma values gammas = np.arange(0.01, 2, 0.02) # helper variables m = 0 coef_value = 1 kernel_mode = 'rbf' all_train_scores = [] temp_train = 0 all_test_scores = [] temp_test = 0 temp_highscore = 0 top_gamma = 0 # for loop over all 20 degrees, saving all results inbetween for m in gammas: # init non-linear svm rbf_svm = svm.SVC(kernel=kernel_mode, gamma=m) # train non-linear svm rbf_svm.fit(x_train, y_train) # calc scores temp_train = rbf_svm.score(x_train, y_train) temp_test = rbf_svm.score(x_test, y_test) # update highscore if (temp_test > temp_highscore): temp_highscore = temp_test top_gamma = m # save scores all_train_scores.append(temp_train) all_test_scores.append(temp_test) # print("top gamma: ", top_gamma) print("top score: ", temp_highscore) # plotting scores plot_score_vs_gamma(all_train_scores, all_test_scores, gammas) # recreate best svm and plotting it best_svm = svm.SVC(kernel=kernel_mode, gamma=top_gamma) best_svm.fit(x_train, y_train) plot_svm_decision_boundary(best_svm, x_train, y_train, x_test, y_test)
def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train SVMs with RBF kernels for different values of the gamma ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function. ## Plot the decision boundary and support vectors for the best value of gamma ## using 'plot_svm_decision_boundary' function ########### gammas = np.arange(0.01, 2, 0.02) machines = [svm.SVC(kernel='rbf', gamma=g, coef0=1.0) for g in gammas] for machine in machines: machine.fit(x_train, y_train) trainScores = [machine.score(x_train, y_train) for machine in machines] testScores = [machine.score(x_test, y_test) for machine in machines] plot_score_vs_gamma(trainScores, testScores, gammas) bestGamma = np.argmax(testScores) print('Score of best rbf gamma ({}): {}'.format(gammas[bestGamma], testScores[bestGamma])) plot_svm_decision_boundary(machines[bestGamma], x_train, y_train, x_test, y_test)
def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train SVMs with RBF kernels for different values of the gamma ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function. ## Plot the decision boundary and support vectors for the best value of gamma ## using 'plot_svm_decision_boundary' function ########### gammas = np.arange(0.01, 2, 0.02) train_scores = list() test_scores = list() for i in gammas: clf = svm.SVC(kernel='rbf', gamma=i) clf.fit(x_train, y_train) test_scores.append(clf.score(x_test, y_test)) train_scores.append(clf.score(x_train, y_train)) plot_score_vs_gamma(train_scores, test_scores, gammas) j = max(test_scores) best_gamma = test_scores.index(j) clf = svm.SVC(kernel='rbf', gamma=gammas[best_gamma]) clf.fit(x_train, y_train) plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test) print(clf.score(x_test, y_test)) print(gammas[best_gamma])
def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train SVMs with RBF kernels for different values of the gamma ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function. ## Plot the decision boundary and support vectors for the best value of gamma ## using 'plot_svm_decision_boundary' function ########### gammas = np.arange(0.01, 2, 0.02) train_scores = np.zeros(np.size(gammas)) test_scores = np.zeros(np.size(gammas)) for j in range(np.size(gammas)): svc = svm.SVC(kernel='rbf', gamma=gammas[j]).fit(x_train, y_train) test_scores[j] = svc.score(x_test, y_test) train_scores[j] = svc.score(x_train, y_train) plot_score_vs_gamma(train_scores, test_scores, gammas) acc_max = test_scores.argmax() svc = svm.SVC(kernel='rbf', gamma=gammas[acc_max]).fit(x_train, y_train) plot_svm_decision_boundary(svc, x_train, y_train, x_test, y_test)
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train multi-class SVMs with one-versus-rest strategy with ## - linear kernel ## - rbf kernel with gamma going from 10**-5 to 10**-3 ## - plot the scores with varying gamma using the function plot_score_versus_gamma ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function ########### C = 3e-4 linSVM = svm.SVC(kernel="linear", decision_function_shape='ovr', C=C) linSVM.fit(x_train, y_train) lin_score_train = linSVM.score(x_train, y_train) lin_score_test = linSVM.score(x_test, y_test) print("best_train_score for linear kernel: ", lin_score_train) print("best_test_score for linear kernel: ", lin_score_test) number_of_classes = linSVM.decision_function(x_test).shape[1] train_scores_rbf = [] test_scores_rbf = [] rbfSVMs = [] gammas = np.linspace(1e-5, 1e-3, 12) for gamma in gammas: rbfSVM = svm.SVC(kernel="rbf", decision_function_shape='ovr', C=C) rbfSVM.set_params(gamma=gamma) rbfSVM.fit(x_train, y_train) train_scores_rbf.append(rbfSVM.score(x_train, y_train)) test_scores_rbf.append(rbfSVM.score(x_test, y_test)) rbfSVMs.append(rbfSVM) best_test_score_rbf_index = np.argmax(test_scores_rbf) print("gamma of best_test_rbf_score: ", gammas[best_test_score_rbf_index]) print("best_test_score for rbf kernel: ", test_scores_rbf[best_test_score_rbf_index]) # chance level depens on number of classes plot_score_vs_gamma(train_scores_rbf, test_scores_rbf, gammas, lin_score_train, lin_score_test, 1 / number_of_classes)
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### # TODO: # Train multi-class SVMs with one-versus-rest strategy with # - linear kernel # - rbf kernel with gamma going from 10**-5 to 10**5 # - plot the scores with varying gamma using the function plot_score_versus_gamma # - Mind that the chance level is not .5 anymore and add the score obtained # with the linear kernel as optional argument of this function ########### gammas = [pow(10, i) for i in range(-5, 6)] svc = svm.SVC(C=10, kernel=RBF, decision_function_shape='ovr') train_scores = [] test_scores = [] for gamma in gammas: svc.gamma = gamma svc.fit(x_train, y_train) train_scores.append(svc.score(x_train, y_train)) test_scores.append(svc.score(x_test, y_test)) svc.kernel = LINEAR svc.gamma = 'auto' svc.fit(x_train, y_train) lin_score_test = svc.score(x_test, y_test) lin_score_train = svc.score(x_train, y_train) plot_score_vs_gamma(train_scores, test_scores, gammas, lin_score_train=lin_score_train, lin_score_test=lin_score_test, baseline=.2) highest_error_rate = np.max(test_scores) print("Highest error rate: " + str(highest_error_rate))
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train multi-class SVMs with one-versus-rest strategy with ## - linear kernel ## - rbf kernel with gamma going from 10**-5 to 10**5 ## - plot the scores with varying gamma using the function plot_score_versus_gamma ## - Note that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function (parameter baseline) ########### gammas = [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 1e2, 1e3, 1e4, 1e5] decision_function_shape = 'ovr' train_scores = list() test_scores = list() clf_lin = svm.SVC(kernel='linear', C=10) clf_lin.fit(x_train, y_train) test_scores_lin = (clf_lin.score(x_test, y_test)) train_scores_lin = (clf_lin.score(x_train, y_train)) for j in range(0, 11): clf = svm.SVC(decision_function_shape='ovr', kernel='rbf', gamma=gammas[j], C=10) clf.fit(x_train, y_train) test_scores.append(clf.score(x_test, y_test)) train_scores.append(clf.score(x_train, y_train)) plot_score_vs_gamma(train_scores, test_scores, gammas, lin_score_train=train_scores_lin, lin_score_test=test_scores_lin, baseline=.2)
def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ # parameters gammas = np.arange(0.01, 2, 0.02) C = 1 # store the scores train_scores = [] test_scores = [] # store the created svm so we don't have to train the best twice. clfs = [] # create and train the svm with a polynomial kernel for every d value for g in gammas: clf = svm.SVC(C=C, kernel='rbf', gamma=g) clf.fit(x_train, y_train) clfs.append(clf) # compute the scores train_scores.append(clf.score(x_train, y_train)) test_scores.append(clf.score(x_test, y_test)) # find the svm with the better test score max_index = test_scores.index(max(test_scores)) clf = clfs[max_index] a = clf.support_vectors_ print("best g value: {}, with an accuracy of {}".format( gammas[max_index], test_scores[max_index])) print("number of SV:", len(a)) # plot the decision boundary on both datasets for the best svm plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test) # plot the score depending of g plot_score_vs_gamma(train_scores, test_scores, gammas)
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train multi-class SVMs with one-versus-rest strategy with ## - linear kernel ## - rbf kernel with gamma going from 10**-5 to 10**5 ## - plot the scores with varying gamma using the function plot_score_versus_gamma ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function ########### SVMlin = svm.SVC(decision_function_shape='ovr', C=10, kernel='linear') SVMlin.fit(x_train, y_train) scorelin_train = SVMlin.score(x_train, y_train) scorelin_test = SVMlin.score(x_test, y_test) gammas = np.array( [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10, 1e2, 1e2, 1e3, 1e4, 1e5]) # gammas2 = np.linspace(1e-5, 1e5, 11) scorerbf_train = np.zeros(np.array(gammas).shape[0]) scorerbf_test = np.zeros(np.array(gammas).shape[0]) for i in range(np.array(gammas).shape[0]): SVMrbf = svm.SVC(decision_function_shape='ovr', C=10, kernel='rbf', gamma=gammas[i]) SVMrbf.fit(x_train, y_train) scorerbf_train[i] = SVMrbf.score(x_train, y_train) scorerbf_test[i] = SVMrbf.score(x_test, y_test) plot_score_vs_gamma(scorerbf_train, scorerbf_test, gamma_list=gammas, lin_score_train=scorelin_train, lin_score_test=scorelin_test)
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train multi-class SVMs with one-versus-rest strategy with ## - linear kernel ## - rbf kernel with gamma going from 10**-5 to 10**-3 ## - plot the scores with varying gamma using the function plot_score_versus_gamma ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function ########### clf = svm.SVC(kernel="linear", C=3e-4, decision_function_shape='ovr') clf.fit(x_train, y_train) lin_score_train = clf.score(x_train, y_train) lin_score_test = clf.score(x_test, y_test) print("Score (linear): " + str(lin_score_test)) gamma_list = np.arange(10e-5, 10e-3, (10e-3 - 10e-5) / 10.0) train_scores = np.zeros(gamma_list.shape[0]) test_scores = np.zeros(gamma_list.shape[0]) for i, gamma in np.ndenumerate(gamma_list): clf = svm.SVC(kernel="rbf", gamma=gamma, decision_function_shape='ovr', C=3e-4) clf.fit(x_train, y_train) train_scores[i] = clf.score(x_train, y_train) score = clf.score(x_test, y_test) test_scores[i] = score print("Best score is " + str(np.max(test_scores)) + " at gamma = " + str(gamma_list[np.argmax(test_scores)])) plot_score_vs_gamma(train_scores, test_scores, gamma_list, lin_score_train, lin_score_test, np.mean(test_scores))
def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train SVMs with RBF kernels for different values of the gamma ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function. ## Plot the decision boundary and support vectors for the best value of gamma ## using 'plot_svm_decision_boundary' function ########### gammas = np.arange(0.01, 2, 0.02) test_scores = np.array([]) train_scores = np.array([]) best_svm = None best_test_score = 0 for gamma in gammas: clf = svm.SVC(kernel='rbf', gamma=gamma) clf.fit(x_train, y_train) test_score = clf.score(x_test, y_test) if test_score > best_test_score: best_test_score = test_score best_svm = clf test_scores = np.append(test_scores, test_score) train_scores = np.append(train_scores, clf.score(x_train, y_train)) plot_score_vs_gamma(train_scores, test_scores, gammas) plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test)
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train multi-class SVMs with one-versus-rest strategy with ## - linear kernel ## - rbf kernel with gamma going from 10**-5 to 10**-3 ## - plot the scores with varying gamma using the function plot_score_versus_gamma ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function ########### gammas = np.power(10, np.linspace(5, -5, 11, endpoint=True)) train_scores2 = np.zeros(np.size(gammas)) test_scores2 = np.zeros(np.size(gammas)) svc1 = svm.SVC(kernel='linear', decision_function_shape='ovr', C=10).fit(x_train, y_train) test_scores1 = svc1.score(x_test, y_test) train_scores1 = svc1.score(x_train, y_train) for j in range(np.size(gammas)): svc2 = svm.SVC(kernel='rbf', decision_function_shape='ovr', gamma=gammas[j], C=10).fit(x_train, y_train) test_scores2[j] = svc2.score(x_test, y_test) train_scores2[j] = svc2.score(x_train, y_train) plot_score_vs_gamma(train_scores2, test_scores2, gammas, train_scores1, test_scores1, 0.2)
def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train SVMs with RBF kernels for different values of the gamma ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function. ## Plot the decision boundary and support vectors for the best value of gamma ## using 'plot_svm_decision_boundary' function ########### gammas = np.arange(0.01, 2, 0.02) train_scores = [] test_scores = [] rbfSVMs = [] for gamma in gammas: rbfSVM = svm.SVC(kernel="rbf") rbfSVM.set_params(gamma=gamma) rbfSVM.fit(x_train, y_train) train_scores.append(rbfSVM.score(x_train, y_train)) test_scores.append(rbfSVM.score(x_test, y_test)) rbfSVMs.append(rbfSVM) best_test_score_index = np.argmax(test_scores) print("gamma of best_test_score: ", gammas[best_test_score_index]) print("best_test_score for rbf kernel: ", test_scores[best_test_score_index]) print("rbfSVm nSV: ", rbfSVM.support_vectors_.shape) plot_score_vs_gamma(train_scores, test_scores, gammas) plot_svm_decision_boundary(rbfSVMs[best_test_score_index], x_train, y_train, x_test, y_test)
def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### # TODO: - done # Train SVMs with RBF kernels for different values of the gamma # and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function. # Plot the decision boundary and support vectors for the best value of gamma # using 'plot_svm_decision_boundary' function ########### gammas = np.arange(0.01, 2, 0.02) test_score = [] train_score = [] svc = svm.SVC(kernel=RBF) for gamma in gammas: svc.gamma = gamma svc.fit(x_train, y_train) train_score.append(svc.score(x_train, y_train)) test_score.append(svc.score(x_test, y_test)) plot_score_vs_gamma(train_score, test_score, gammas) highest_test_score = max(test_score) highest_testscore_index = np.argmax(test_score) gamma = gammas[highest_testscore_index] print("A Gamma value of " + str(gamma) + " produces the Highest Test Score " + str(highest_test_score)) svc.gamma = gamma svc.fit(x_train, y_train) plot_svm_decision_boundary(svc, x_train, y_train, x_test, y_test)
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## Train multi-class SVMs with one-versus-rest strategy with ## - linear kernel ## - rbf kernel with gamma going from 10**-5 to 10**5 ## - plot the scores with varying gamma using the function plot_score_versus_gamma ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function ########### dfs = 'ovr' c = 10 linear = svm.SVC(kernel='linear', C=c, decision_function_shape=dfs) linear.fit(x_train, y_train) lin_score_train = linear.score(x_train, y_train) lin_score_test = linear.score(x_test, y_test) gammas = [pow(10, i) for i in range(-5, 6)] rbfs = [ svm.SVC(kernel='rbf', gamma=gamma, C=c, decision_function_shape=dfs) for gamma in gammas ] for rbf in rbfs: rbf.fit(x_train, y_train) train_scores = [rbf.score(x_train, y_train) for rbf in rbfs] test_scores = [rbf.score(x_test, y_test) for rbf in rbfs] plot_score_vs_gamma(train_scores, test_scores, gammas, lin_score_train, lin_score_test, .2)
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train multi-class SVMs with one-versus-rest strategy with ## - linear kernel ## - rbf kernel with gamma going from 10**-5 to 10**5 ## - plot the scores with varying gamma using the function plot_score_versus_gamma ## - Note that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function (parameter baseline) ########### gamma_range = [10**-5, 10**-4, 10**-3, 10**-2, 10**-1, 10**0, 10**1, 10**2, 10**3, 10**4, 10**5] lin = svm.SVC(decision_function_shape='ovr', kernel='linear', C=10) lin.fit(x_train, y_train) score_train = lin.score(x_train, y_train) score_test = lin.score(x_test, y_test) gam_score_train = [] gam_score_test = [] for gamma_value in gamma_range: gam = svm.SVC(decision_function_shape='ovr', kernel='rbf', gamma=gamma_value, C=10) gam.fit(x_train, y_train) gam_score_train.append(gam.score(x_train, y_train)) gam_score_test.append(gam.score(x_test, y_test)) plot_score_vs_gamma(gam_score_train, gam_score_test, gamma_range, score_train, score_test, baseline=0.2)
def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train SVMs with RBF kernels for different values of the gamma ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function. ## Plot the decision boundary and support vectors for the best value of gamma ## using 'plot_svm_decision_boundary' function ########### gammas = np.arange(0.01, 2, 0.02) test_score = np.zeros(np.array(gammas).shape[0]) train_score = np.zeros(np.array(gammas).shape[0]) for i in range(np.array(gammas).shape[0]): SVMrbf = svm.SVC(kernel="rbf", gamma=gammas[i]) SVMrbf.fit(x_train, y_train) test_score[i] = SVMrbf.score(x_test, y_test) train_score[i] = SVMrbf.score(x_train, y_train) max_score_index = np.argmax(test_score) opt_gamma = gammas[max_score_index] SVMrbf_opt = svm.SVC(kernel="rbf", gamma=opt_gamma) SVMrbf_opt.fit(x_train, y_train) plot_svm_decision_boundary(SVMrbf_opt, x_train, y_train, x_test, y_test) print("Optimal gamma", opt_gamma, "Optimal score", test_score[max_score_index]) plot_score_vs_gamma(train_score, test_score, gammas)
def svm_rbf(x_train, y_train, x_test, y_test): # RBF kernel # svc = svm.SVC() # svc.fit(x_train,y_train) # train_score = svc.score(x_train, y_train) # test_score = svc.score(x_test, y_test) # return train_score, test_score # gammas = np.arange(0.01, 2, 0.02) training_scores = list() test_scores = list() for g in gammas: svc = svm.SVC(kernel='rbf', gamma=g) svc.fit(x_train, y_train) training_scores.append(svc.score(x_train, y_train)) test_scores.append(svc.score(x_test, y_test)) test_best = test_scores.index(max(test_scores)) best_gamma = gammas[test_best] plot_score_vs_gamma(training_scores, test_scores, gammas) print("RBF kernel:") print("Best gamma is ", best_gamma, " with testing score=", max(test_scores)) rbf_best = svm.SVC(gamma=best_gamma) rbf_best.fit(x_train, y_train)
def ex_2_c(x_train, y_train, x_test, y_test): """ Solution for exercise 2 c) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train SVMs with RBF kernels for different values of the gamma ## and plot the variation of the test and training scores with gamma using 'plot_score_vs_gamma' function. ## Plot the decision boundary and support vectors for the best value of gamma ## using 'plot_svm_decision_boundary' function ########### gammas = np.arange(0.01, 2, 0.02) best_score = -1 train_scores = np.zeros(gammas.shape[0]) test_scores = np.zeros(gammas.shape[0]) for i, gamma in np.ndenumerate(gammas): clf = svm.SVC(kernel="rbf", gamma=gamma) clf.fit(x_train, y_train) train_scores[i] = clf.score(x_train, y_train) score = clf.score(x_test, y_test) test_scores[i] = score # print("Score (degree: " + str(d) + "): " + str(score)) if score > best_score: best_score = score best_clf = clf print("Best score is " + str(np.max(test_scores)) + " at gamma = " + str(gammas[np.argmax(test_scores)])) plot_score_vs_gamma(train_scores, test_scores, gammas) plot_svm_decision_boundary(best_clf, x_train, y_train, x_test, y_test)
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ ########### ## TODO: ## Train multi-class SVMs with one-versus-rest strategy with ## - linear kernel ## - rbf kernel with gamma going from 10**-5 to 10**5 ## - plot the scores with varying gamma using the function plot_score_versus_gamma ## - Mind that the chance level is not .5 anymore and add the score obtained with the linear kernel as optional argument of this function ########### # helper variables c = 10 kernel_mode_lin = 'linear' kernel_mode_rbf = 'rbf' df_shape = 'ovr' #gammas = np.arange(10**(-5), 10**(5), 20000) gammas = [ 10**(-5), 10**(-4), 10**(-3), 10**(-2), 10**(-1), 10**(0), 10**(1), 10**(2), 10**(3), 10**(4), 10**(5) ] #gammas2 = np.linspace(10**(-5), 10**(5), 10) # init linear svm and train lin_svm = svm.SVC(kernel=kernel_mode_lin, C=c, decision_function_shape=df_shape) lin_svm.fit(x_train, y_train) # calc lin scores lin_trainscore = lin_svm.score(x_train, y_train) lin_testscore = lin_svm.score(x_test, y_test) print("LINEAR: \n", "trainscore: ", lin_trainscore, "testscore: ", lin_testscore) # init rbf svm and train it looping over gammas rbf_svm = svm.SVC(kernel=kernel_mode_rbf, C=c, decision_function_shape=df_shape) rbf_trainscore = [] temp_train = 0 rbf_testscore = [] temp_test = 0 for m in gammas: # setting current gamma rbf_svm.gamma = m # training rbf_svm.fit(x_train, y_train) # calc scores temp_train = rbf_svm.score(x_train, y_train) temp_test = rbf_svm.score(x_test, y_test) # save scores rbf_trainscore.append(temp_train) rbf_testscore.append(temp_test) print("RBF: \n", "trainscore: ", max(rbf_trainscore), "testscore: ", max(rbf_testscore)) plot_score_vs_gamma(rbf_trainscore, rbf_testscore, gammas, lin_trainscore, lin_testscore, 0.2)
def ex_3_a(x_train, y_train, x_test, y_test): """ Solution for exercise 3 a) :param x_train: Training samples (2-dimensional) :param y_train: Training labels :param x_test: Testing samples (2-dimensional) :param y_test: Testing labels :return: """ # parameters C = 0.0003 # store the scores train_scores = [] test_scores = [] # store the created svm so we don't have to train the best twice. clfs = [] #first the linear and then the rbf clf = svm.SVC(C=C, kernel='linear', decision_function_shape='ovr') clf.fit(x_train, y_train) clfs.append(clf) # compute the scores train_scores.append(clf.score(x_train, y_train)) test_scores.append(clf.score(x_test, y_test)) # gammas = np.linspace(0.00001, 0.001, 10) # for g in gammas: # clf = svm.SVC(C=C, kernel='rbf', gamma=g,decision_function_shape='ovr') # clf.fit(x_train, y_train) # clfs.append(clf) # # # # # compute the scores # # train_scores.append(clf.score(x_train, y_train)) # test_scores.append(clf.score(x_test, y_test)) # # # plot the score depending of g , with linear score # plot_score_vs_gamma(train_scores[1:], test_scores[1:], gammas,train_scores[0],test_scores[0]) gammas = np.linspace(0.00001, 0.001, 10) for g in gammas: clf = svm.SVC(C=C, kernel='rbf', gamma=g, decision_function_shape='ovr') clf.fit(x_train, y_train) clfs.append(clf) # compute the scores train_scores.append(clf.score(x_train, y_train)) test_scores.append(clf.score(x_test, y_test)) # plot the score depending of g , with linear score plot_score_vs_gamma(train_scores[1:], test_scores[1:], gammas, train_scores[0], test_scores[0])