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_1_c(x, y): """ Solution for exercise 1 c) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Add a point (4,0) with label 1 to the data set and then x_new = np.vstack((x, (4, 0))) y_new = np.hstack((y, 1)) ## train an SVM with a linear kernel with different values of C ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function ########### Cs = [1e6, 1, 0.1, 0.001] for C in Cs: clf = svm.SVC(kernel="linear", C=C) clf.fit(x_new, y_new) print("Support Vectors (C=" + str(C) + "): " + str(len(clf.support_vectors_))) plot_svm_decision_boundary(clf, x_new, y_new)
def ex_1_c(x, y): """ Solution for exercise 1 c) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Add a point (4,0) with label 1 to the data set and then ## train an SVM with a linear kernel with different values of C ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function ########### Cs = [1e6, 1, 0.1, 0.001] point_x = [4, 0] point_y = [1] x_extended = np.vstack((x, point_x)) y_extended = np.hstack((y, point_y)) for i in Cs: clf = svm.SVC(kernel='linear', C=i) clf.fit(x_extended, y_extended) plot_svm_decision_boundary(clf, x_extended, y_extended) pass
def ex_1_c(x, y): """ Solution for exercise 1 c) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Add a point (4,0) with label 1 to the data set and then ## train an SVM with a linear kernel with different values of C ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function ########### # helper vars m = 0 kernel_mode = 'linear' # given C values Cs = [1e6, 1, 0.1, 0.001] # adding point (4, 0) with label 1 x_new = np.vstack((x, [4, -4])) y_new = np.hstack((y, 1)) # for loop over all Cs values for m in range(len(Cs)): # init linear svm lin_svm = svm.SVC(kernel=kernel_mode, C=Cs[m]) # train linear svm lin_svm.fit(x_new, y_new) # plotting the decision boundary plot_svm_decision_boundary(lin_svm, x_new, y_new)
def ex_1_c(x, y): """ Solution for exercise 1 c) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Add a point (4,0) with label 1 to the data set and then ## train an SVM with a linear kernel with different values of C ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function ########### Cs = [1e6, 1, 0.1, 0.001] new_x = (4, 0) new_y = 1 x = np.vstack([x, new_x]) y = np.hstack([y, new_y]) for C in Cs: clf = svm.SVC(kernel='linear', C=C) clf.fit(x, y) plot_svm_decision_boundary(clf, x, y)
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_1_b(x, y): """ Solution for exercise 1 b) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Add a point (4,0) with label 1 to the data set and then ## train an SVM with a linear kernel ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function ########### # adding point (4, 0) with label 1 x_new = np.vstack((x, [4, 0])) y_new = np.hstack((y, 1)) # init linear svm kernel_mode = 'linear' lin_svm = svm.SVC(kernel=kernel_mode) # train linear svm lin_svm.fit(x_new, y_new) # plotting the decision boundary plot_svm_decision_boundary(lin_svm, x_new, y_new)
def ex_2_a(x_train, y_train, x_test, y_test): """ Solution for exercise 2 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 an SVM with a linear kernel for the given dataset ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function ########### linSVM = svm.SVC(kernel="linear") linSVM.fit(x_train, y_train) train_score = linSVM.score(x_train, y_train) test_score = linSVM.score(x_test, y_test) print("lin nSV:", linSVM.support_vectors_.shape) print("train_score for linear kernel: ", train_score) print("test_score for linear kernel: ", test_score) plot_svm_decision_boundary(linSVM, x_train, y_train, x_test, y_test)
def ex_2_a(x_train, y_train, x_test, y_test): """ Solution for exercise 2 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 an SVM with a linear kernel for the given dataset ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function ########### # init linear svm kernel_mode = 'linear' lin_svm = svm.SVC(kernel=kernel_mode) # train linear svm lin_svm.fit(x_train, y_train) # calc. & print svc.score() = mean accuracy of classification lin_svm_score = lin_svm.score(x_test, y_test) print("lin_swm_score: ", lin_svm_score) # plotting the decision boundary plot_svm_decision_boundary(lin_svm, x_train, y_train, x_test, y_test)
def ex_2_b(x_train, y_train, x_test, y_test): """ Solution for exercise 2 b) :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 polynomial kernels for different values of the degree ## (Remember to set the 'coef0' parameter to 1) ## and plot the variation of the test and training scores with polynomial degree using 'plot_score_vs_degree' func. ## Plot the decision boundary and support vectors for the best value of degree ## using 'plot_svm_decision_boundary' function ########### degrees = range(1, 20) scorepolylist_test = np.zeros(np.array(degrees).shape[0]) scorepolylist_train = np.zeros(np.array(degrees).shape[0]) for deg in degrees: SVMpoly = svm.SVC(kernel='poly', coef0=1, degree=deg) SVMpoly.fit(x_train, y_train) scorepolylist_test[deg - 1] = SVMpoly.score(x_test, y_test) scorepolylist_train[deg - 1] = SVMpoly.score(x_train, y_train) max_score_index = np.argmax(scorepolylist_test) optimal_deg = max_score_index + 1 SVMpolyopt = svm.SVC(kernel='poly', coef0=1, degree=optimal_deg) SVMpolyopt.fit(x_train, y_train) plot_score_vs_degree(scorepolylist_train, scorepolylist_test, degrees) plot_svm_decision_boundary(SVMpolyopt, x_train, y_train, x_test, y_test) print("Optimal degree", optimal_deg, "Optimal score", scorepolylist_test[max_score_index])
def ex_1_b(x, y): """ Solution for exercise 1 b) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Add a point (4,0) with label 1 to the data set and then ## train an SVM with a linear kernel ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function ########### #print("x:", x) #print("y:", y) #print("x.shape:", x.shape) #print("y.shape:", y.shape) point = np.array([4, 0]) #print("point:", point) #print("point_shape:", point.shape) x_new = np.vstack((x, point)) #print("x_new:", x_new) #print("x_new.shape:", x_new.shape) y_new = np.hstack((y, 1)) #print("y_new:", y_new) #print("y_new.shape:", y_new.shape) linSVM = svm.SVC(kernel="linear") linSVM.fit(x_new, y_new) plot_svm_decision_boundary(linSVM, x_new, y_new)
def ex_2_b(x_train, y_train, x_test, y_test): """ Solution for exercise 2 b) :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 polynomial kernels for different values of the degree ## (Remember to set the 'coef0' parameter to 1) ## and plot the variation of the test and training scores with polynomial degree using 'plot_score_vs_degree' func. ## Plot the decision boundary and support vectors for the best value of degree ## using 'plot_svm_decision_boundary' function ########### degrees = range(1, 21) machines = [svm.SVC(kernel='poly', degree=d, coef0=1.0) for d in degrees] 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_degree(trainScores, testScores, degrees) bestDegree = testScores.index(max(testScores)) print('Score of best polynomial degree ({}): {}'.format( bestDegree + 1, testScores[bestDegree])) plot_svm_decision_boundary(machines[bestDegree], 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_b(x_train, y_train, x_test, y_test): """ Solution for exercise 2 b) :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 polynomial kernels for different values of the degree ## (Remember to set the 'coef0' parameter to 1) ## and plot the variation of the test and training scores with polynomial degree using 'plot_score_vs_degree' func. ## Plot the decision boundary and support vectors for the best value of degree ## using 'plot_svm_decision_boundary' function ########### degrees = range(1, 20) train_scores = np.zeros(np.size(degrees)) test_scores = np.zeros(np.size(degrees)) for j in range(np.size(degrees)): svc = svm.SVC(kernel='poly', C=1, coef0=1, degree=degrees[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_degree(train_scores, test_scores, degrees) acc_max = test_scores.argmax() svc = svm.SVC(kernel='poly', C=1, coef0=1, degree=degrees[acc_max]).fit(x_train, y_train) plot_svm_decision_boundary(svc, x_train, y_train, x_test, y_test)
def ex_1_a(x, y): """ Solution for exercise 1 a) :param x: The x values :param y: The y values :return: """ # create and train the support vector machine. clf = svm.SVC(C=1, kernel='linear') clf.fit(x, y) # plot results plot_svm_decision_boundary(clf, x, y) pass
def ex_1_a(x, y): """ Solution for exercise 1 a) :param x: The x values :param y: The y values :return: """ ########### # TODO: - done # Train an SVM with a linear kernel # and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function ########### svc = svm.SVC(kernel=LINEAR) svc.fit(x, y) plot_svm_decision_boundary(svc, x, y)
def ex_1_a(x, y): """ Solution for exercise 1 a) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Train an ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function ########### #pass svc = svm.SVC(kernel='linear', C=1).fit(x, y) plot_svm_decision_boundary(svc, x, y)
def ex_1_a(x, y): """ Solution for exercise 1 a) :param x: The x values :param y: The y values :return: """ ########### ## Train an SVM with a linear kernel ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function ########### clf = svm.SVC(kernel='linear') clf.fit(x, y) plot_svm_decision_boundary(clf, x, y) pass
def ex_1_a(x, y): """ Solution for exercise 1 a) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Train an SVM with a linear kernel ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function SVM = svm.SVC(kernel='linear') SVM.fit(x, y) plot_svm_decision_boundary(SVM, x, y, x_test=None, y_test=None) ########### pass
def ex_1_b(x, y): """ Solution for exercise 1 b) :param x: The x values :param y: The y values :return: """ # add the point to the datas x = np.vstack((x, [4, 0])) y = np.hstack((y, 1)) # create and train the SVM. clf = svm.SVC(C=1, kernel='linear') clf.fit(x, y) # plot results plot_svm_decision_boundary(clf, x, y) pass
def ex_1_a(x, y): """ Solution for exercise 1 a) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Train an SVM with a linear kernel ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function ########### linSVM = svm.SVC(kernel="linear") #print("X:", x.shape) #print("Y:", y.shape) linSVM.fit(x, y) plot_svm_decision_boundary(linSVM, x, y)
def ex_1_b(x, y): """ Solution for exercise 1 b) :param x: The x values :param y: The y values :return: """ ########### ## Add a point (4,0) with label 1 to the data set and then ## train an SVM with a linear kernel ## and plot the decision boundary and support vectors using 'plot_svm_decision_boundary' function ########### new_x = np.vstack((x, np.array([4, 0]))) new_y = np.hstack((y, np.array((1)))) clf = svm.SVC(kernel='linear') clf.fit(new_x, new_y) plot_svm_decision_boundary(clf, new_x, new_y) pass
def ex_1_b(x, y): """ Solution for exercise 1 b) :param x: The x values :param y: The y values :return: """ ########### ## TODO: ## Add a point (4,0) with label 1 to the data set and then ## train an SVM with a linear kernel ## and plot the decisSVM with a linear kernelion boundary and support vectors using 'plot_svm_decision_boundary' function ########### #pass x = np.append(x, [[4, 0]], axis=0) y = np.append(y, 1) svc = svm.SVC(kernel='linear', C=1).fit(x, y) plot_svm_decision_boundary(svc, x, y)
def ex_2_a(x_train, y_train, x_test, y_test): """ Solution for exercise 2 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 an SVM with a linear kernel for the given dataset ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function ########### #pass svc = svm.SVC(kernel='linear', C=1).fit(x_train, y_train) score_svc = svc.score(x_test, y_test) print("Score for linear kernel SVC:", score_svc) plot_svm_decision_boundary(svc, x_train, y_train, x_test, y_test)
def ex_2_b(x_train, y_train, x_test, y_test): """ Solution for exercise 2 b) :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 polynomial kernels for different values of the degree ## (Remember to set the 'coef0' parameter to 1) ## and plot the variation of the test and training scores with polynomial degree using 'plot_score_vs_degree' func. ## Plot the decision boundary and support vectors for the best value of degree ## using 'plot_svm_decision_boundary' function ########### degrees = range(1, 21) train_scores = [] test_scores = [] polySVMs = [] for degree in degrees: polySVM = svm.SVC(kernel="poly", coef0=1) polySVM.set_params(degree=degree) polySVM.fit(x_train, y_train) train_scores.append(polySVM.score(x_train, y_train)) test_scores.append(polySVM.score(x_test, y_test)) polySVMs.append(polySVM) best_test_score_index = np.argmax(test_scores) print("best_train_score for poly kernel: ", train_scores[best_test_score_index]) print("best_test_score for poly kernel: ", test_scores[best_test_score_index]) print("degree for best test_score: ", degrees[best_test_score_index]) plot_score_vs_degree(train_scores, test_scores, degrees) print("polySVm nSV: ", polySVM.support_vectors_.shape) plot_svm_decision_boundary(polySVMs[best_test_score_index], x_train, y_train, x_test, y_test)
def ex_2_b(x_train, y_train, x_test, y_test): """ Solution for exercise 2 b) :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 r_value = 1 degrees = range(1, 21) 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 d in degrees: clf = svm.SVC(C=C, kernel='poly', degree=d, coef0=r_value) 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 d value: {}, with an accuracy of {}".format( degrees[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 d plot_score_vs_degree(train_scores, test_scores, degrees)
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_2_a(x_train, y_train, x_test, y_test): """ Solution for exercise 2 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 an SVM with a linear kernel for the given dataset ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function ########### clf = svm.SVC(kernel='linear') clf.fit(x_train, y_train) plot_svm_decision_boundary(clf, x_train, y_train, x_test, y_test) print("ex_2_a score:", clf.score(x_test, y_test)) pass
def ex_2_a(x_train, y_train, x_test, y_test): """ Solution for exercise 2 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 an SVM with a linear kernel for the given dataset ## and plot the decision boundary and support vectors for each using 'plot_svm_decision_boundary' function ########### machine = svm.SVC(kernel='linear') machine.fit(x_train, y_train) plot_svm_decision_boundary(machine, x_train, y_train, x_test, y_test) print('Linear SVM score: {}'.format(machine.score(x_test, y_test)))