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_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_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_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_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 training and test 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)
test_scores = np.array([])
train_scores = np.array([])
best_svm = None
best_test_score = 0
for deg in degrees:
clf = svm.SVC(kernel='poly', degree=deg, coef0=1)
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_degree(train_scores, test_scores, degrees)
plot_svm_decision_boundary(clf, 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 = list(range(1, 21))
train_score = []
test_score = []
svc = svm.SVC(kernel='poly', coef0=1)
for degree in degrees:
svc.degree = degree
svc.fit(x_train, y_train)
test_score.append(svc.score(x_test, y_test))
train_score.append(svc.score(x_train, y_train))
plot_score_vs_degree(train_score, test_score, degrees)
highest_test_score = max(test_score)
degree = test_score.index(highest_test_score) + 1
print("Degree " + str(degree) + " produces the Highest Test Score " +
str(highest_test_score))
svc.degree = degree
svc.fit(x_train, y_train)
plot_svm_decision_boundary(svc, x_train, y_train, x_test, y_test)
def svm_poly(x_train, y_train, x_test, y_test):
#Polynomial kernel
# svc = svm.SVC(kernel='poly')
# 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
degrees = range(1, 8)
training_scores = list()
test_scores = list()
for i in degrees:
svc = svm.SVC(kernel="poly", degree=i)
svc.fit(x_train, y_train)
training_scores.append(svc.score(x_train, y_train))
test_scores.append(svc.score(x_test, y_test))
degree_best = test_scores.index(max(test_scores)) + 1
plot_score_vs_degree(training_scores, test_scores, degrees)
print("Polynomial kernel:")
print("Best degree is ", degree_best, " with testing score=",
max(test_scores))
poly_best = svm.SVC(kernel="poly", degree=degree_best, coef0=1)
poly_best.fit(x_train, y_train)
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 training and test 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 = list()
test_scores = list()
for i in degrees:
clf = svm.SVC(kernel='poly', degree=i, coef0=1)
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_degree(train_scores, test_scores, degrees)
j = max(test_scores)
best_degree = 0
for i in range(0, 21):
if test_scores[i] == j:
best_degree = i
clf = svm.SVC(kernel='poly', degree=i, coef0=1)
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(best_degree)
break
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 = np.array(range(1, 20))
best_score = -1
train_scores = np.zeros(degrees.shape[0])
test_scores = np.zeros(degrees.shape[0])
for i, d in np.ndenumerate(degrees):
clf = svm.SVC(kernel="poly", degree=d, coef0=1)
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 degree = " +
str(degrees[np.argmax(test_scores)]))
plot_score_vs_degree(train_scores, test_scores, degrees)
plot_svm_decision_boundary(best_clf, 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
###########
# given degree values
degrees = range(1, 20)
# helper variables
m = 0
coef_value = 1
kernel_mode = 'poly'
all_train_scores = []
temp_train = 0
all_test_scores = []
temp_test = 0
temp_highscore = 0
top_degree = 0
# for loop over all 20 degrees, saving all results inbetween
for m in degrees:
# init non-linear svm
nonlin_svm = svm.SVC(kernel=kernel_mode, coef0=coef_value, degree=m)
# train non-linear svm
nonlin_svm.fit(x_train, y_train)
# calc scores
temp_train = nonlin_svm.score(x_train, y_train)
temp_test = nonlin_svm.score(x_test, y_test)
# update highscore
if (temp_test > temp_highscore):
temp_highscore = temp_test
top_degree = m
# save scores
all_train_scores.append(temp_train)
all_test_scores.append(temp_test)
#
print("top degree: ", top_degree)
print("top score: ", temp_highscore)
# plotting scores
plot_score_vs_degree(all_train_scores, all_test_scores, degrees)
# recreate best svm and plotting it
best_svm = svm.SVC(kernel=kernel_mode, coef0=coef_value, degree=top_degree)
best_svm.fit(x_train, y_train)
plot_svm_decision_boundary(best_svm, x_train, y_train, x_test, y_test)