def compute_at(hyper_params):
learning_rate, regularizer = hyper_params
svm = LinearSVM()
svm.train(X_train, y_train, learning_rate=learning_rate, reg=regularizer, num_iters=1000)
y_train_prediction = svm.predict(X_train)
train_accuracy = np.mean(y_train == y_train_prediction)
y_val_prediction = svm.predict(X_val)
val_accuracy = np.mean(y_val == y_val_prediction)
final_accuracy = min(train_accuracy, val_accuracy)
state.epoch += 1
improved = state.accuracy < final_accuracy
if improved:
state.accuracy = final_accuracy
state.svm = svm
state.hyper = hyper_params[:]
print "Epoch %2d: (%.8f, %f) -> %f %s" % (state.epoch, learning_rate, regularizer, final_accuracy, "(!)" if improved else "")
return improved, final_accuracy
def train(X_train, y_train, X_val, y_val):
# Use the validation set to tune hyperparameters (regularization strength and
# learning rate). You should experiment with different ranges for the learning
# rates and regularization strengths; if you are careful you should be able to
# get a classification accuracy of about 0.4 on the validation set.
learning_rates = [1e-7, 5e-6, 1e-6]
regularization_strengths = [1e4, 5e4, 1e5]
# results is dictionary mapping tuples of the form
# (learning_rate, regularization_strength) to tuples of the form
# (training_accuracy, validation_accuracy). The accuracy is simply the fraction
# of data points that are correctly classified.
results = {}
best_val = -1 # The highest validation accuracy that we have seen so far.
best_svm = None # The LinearSVM object that achieved the highest validation rate.
for lr in learning_rates:
for reg in regularization_strengths:
svm = LinearSVM()
svm.train(X_train, y_train, learning_rate=lr, reg=reg, num_iters=1000)
y_train_pred = svm.predict(X_train)
train_accuracy = np.mean(y_train == y_train_pred)
y_val_pred = svm.predict(X_val)
val_accuracy = np.mean(y_val == y_val_pred)
results[(lr, reg)] = (train_accuracy, val_accuracy)
if best_val < val_accuracy:
best_val = val_accuracy
best_svm = svm
# Print out results.
for lr, reg in sorted(results):
train_accuracy, val_accuracy = results[(lr, reg)]
print 'Learning-rate=%f regularizer=%f train-accuracy=%f validation-accuracy=%f' % (lr, reg, train_accuracy, val_accuracy)
print 'Best validation accuracy achieved during cross-validation: %f' % best_val
return best_svm
def getQoS(self):
X_train, y_train, X_test, y_test = load_CIFAR10(self.data_path)
X_test = np.reshape(X_test, (X_test.shape[0], -1))
X_train = np.reshape(X_train, (X_train.shape[0], -1))
mean_image = np.mean(X_train, axis=0)
X_test -= mean_image
X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])
svm = LinearSVM()
try:
svm.W = pickle.load(open(self.run_dir + "model_svm.p", "rb"),
encoding='latin1')
y_test_pred = svm.predict(X_test)
test_accuracy = np.mean(y_test == y_test_pred)
except:
test_accuracy = 0.0
return test_accuracy * 100.0
print('That took %fs' % (toc - tic))
# In[38]:
# A useful debugging strategy is to plot the loss as a function of
# iteration number:
plt.plot(loss_hist)
plt.xlabel('Iteration number')
plt.ylabel('Loss value')
#plt.show()
# In[39]:
# Write the LinearSVM.predict function and evaluate the performance on both the
# training and validation set
y_train_pred = svm.predict(X_train)
print('training accuracy: %f' % (np.mean(y_train == y_train_pred), ))
y_val_pred = svm.predict(X_val)
print('validation accuracy: %f' % (np.mean(y_val == y_val_pred), ))
# In[46]:
# Use the validation set to tune hyperparameters (regularization strength and
# learning rate). You should experiment with different ranges for the learning
# rates and regularization strengths; if you are careful you should be able to
# get a classification accuracy of about 0.4 on the validation set.
learning_rates = [1e-7, 5e-5]
regularization_strengths = [2.5e4, 5e4]
# results is dictionary mapping tuples of the form
# (learning_rate, regularization_strength) to tuples of the form
# In[ ]:
# A useful debugging strategy is to plot the loss as a function of
# iteration number:
plt.plot(loss_hist)
plt.xlabel('Iteration number')
plt.ylabel('Loss value')
plt.show()
# In[ ]:
# Write the LinearSVM.predict function and evaluate the performance on both the
# training and validation set
y_train_pred = svm.predict(X_train)
print 'training accuracy: %f' % (np.mean(y_train == y_train_pred), )
y_val_pred = svm.predict(X_val)
print 'validation accuracy: %f' % (np.mean(y_val == y_val_pred), )
# In[ ]:
# Use the validation set to tune hyperparameters (regularization strength and
# learning rate). You should experiment with different ranges for the learning
# rates and regularization strengths; if you are careful you should be able to
# get a classification accuracy of about 0.4 on the validation set.
learning_rates = [6e-7] #np.array(range(6))/10000000.0
regularization_strengths = [43600.0] # + np.array(range(0,30))*100.0
# results is dictionary mapping tuples of the form
reg=2.5e4,
num_iters=1500,
verbose=True)
toc = time.time()
print('That took %fs' % (toc - tic))
# A useful debugging strategy is to plot the loss as a function of
# iteration number:
plt.plot(loss_hist)
plt.xlabel('Iteration number')
plt.ylabel('Loss value')
plt.show()
# Write the LinearSVM.predict function and evaluate the performance on both the
# training and validation set
y_train_pred = svm.predict(X_train)
print('training accuracy: %f' % (np.mean(y_train == y_train_pred), ))
y_val_pred = svm.predict(X_val)
print('validation accuracy: %f' % (np.mean(y_val == y_val_pred), ))
# Use the validation set to tune hyperparameters (regularization strength and
# learning rate). You should experiment with different ranges for the learning
# rates and regularization strengths; if you are careful you should be able to
# get a classification accuracy of about 0.4 on the validation set.
learning_rates = [1e-7, 5e-5]
regularization_strengths = [2.5e4, 5e4]
# results is dictionary mapping tuples of the form
# (learning_rate, regularization_strength) to tuples of the form
# (training_accuracy, validation_accuracy). The accuracy is simply the fraction
# of data points that are correctly classified.
# store these numbers in the results dictionary. In addition, store the best #
# validation accuracy in best_val and the LinearSVM object that achieves this #
# accuracy in best_svm. #
# #
# Hint: You should use a small value for num_iters as you develop your #
# validation code so that the SVMs don't take much time to train; once you are #
# confident that your validation code works, you should rerun the validation #
# code with a larger value for num_iters. #
################################################################################
for learning_rate in learning_rates:
for reg in regularization_strengths:
print("LR",learning_rate,"reg",reg)
svm = LinearSVM()
loss_hist = svm.train(X_train, y_train, learning_rate=learning_rate[0], reg=reg,
num_iters=learning_rate[1], verbose=True)
y_train_pred = svm.predict(X_train)
y_val_pred = svm.predict(X_val)
results[(learning_rate[0],reg)] = (np.mean(y_train == y_train_pred),np.mean(y_val == y_val_pred))
if best_val < np.mean(y_val == y_val_pred):
best_val = np.mean(y_val == y_val_pred)
best_parameters = { 'LR':learning_rate[0], 'reg': reg}
################################################################################
# END OF YOUR CODE #
################################################################################
# Print out results.
for lr, reg in sorted(results):
train_accuracy, val_accuracy = results[(lr, reg)]
print 'lr %e reg %e train accuracy: %f val accuracy: %f' % (
reg=5e4,
num_iters=1500,
verbose=True)
toc = time.time()
print 'That took %fs' % (toc - tic)
#%%
# A useful debugging strategy is to plot the loss as a function of
# iteration number:
plt.plot(loss_hist)
plt.xlabel('Iteration number')
plt.ylabel('Loss value')
plt.show()
#%%
# Write the LinearSVM.predict function and evaluate the performance on both the
# training and validation set
y_train_pred = svm.predict(X_train)
print 'training accuracy: %f' % (np.mean(y_train == y_train_pred), )
y_val_pred = svm.predict(X_val)
print 'validation accuracy: %f' % (np.mean(y_val == y_val_pred), )
#%%
# Use the validation set to tune hyperparameters (regularization strength and
# learning rate). You should experiment with different ranges for the learning
# rates and regularization strengths; if you are careful you should be able to
# get a classification accuracy of about 0.4 on the validation set.
learning_rates = [1e-7, 5e-5]
regularization_strengths = [5e4, 1e5]
# results is dictionary mapping tuples of the form
# (learning_rate, regularization_strength) to tuples of the form
# (training_accuracy, validation_accuracy). The accuracy is simply the fraction
# of data points that are correctly classified.
verbose=True)
toc = time.time()
print('That took %fs' % (toc - tic))
# %%
# A useful debugging strategy is to plot the loss as a function of
# iteration number:
plt.plot(loss_hist)
plt.xlabel('Iteration number')
plt.ylabel('Loss value')
plt.show()
# %%
# Write the LinearSVM.predict function and evaluate the performance on both the
# training and validation set
y_train_pred = svm.predict(X_train)
print('training accuracy: %f' % (np.mean(y_train == y_train_pred), ))
y_val_pred = svm.predict(X_val)
print('validation accuracy: %f' % (np.mean(y_val == y_val_pred), ))
# %%
# Use the validation set to tune hyperparameters (regularization strength and
# learning rate). You should experiment with different ranges for the learning
# rates and regularization strengths; if you are careful you should be able to
# get a classification accuracy of about 0.39 on the validation set.
# Note: you may see runtime/overflow warnings during hyper-parameter search.
# This may be caused by extreme values, and is not a bug.
# results is dictionary mapping tuples of the form
# (learning_rate, regularization_strength) to tuples of the form
# validation accuracy in best_val and the LinearSVM object that achieves this #
# accuracy in best_svm. #
# #
# Hint: You should use a small value for num_iters as you develop your #
# validation code so that the SVMs don't take much time to train; once you are #
# confident that your validation code works, you should rerun the validation #
# code with a larger value for num_iters. #
################################################################################
for lr_idx in range(0,len(learning_rates)):
for reg_idx in range(0,len(regularization_strengths)):
lr_use = learning_rates[lr_idx]
reg_use = regularization_strengths[reg_idx]
svm = LinearSVM()
loss_hist = svm.train(X_dev, y_dev, learning_rate=lr_use, reg=reg_use,
num_iters=1500, verbose=True)
y_train_pred = svm.predict(X_dev)
y_val_pred = svm.predict(X_val)
acc_train = np.mean(y_train == y_train_pred)
acc_val = np.mean(y_val == y_val_pred)
if acc_val > best_val:
best_lr = lr_use
best_reg = reg_use
best_val = acc_val
best_svm = svm
results_once = {(lr_use, reg_use): (acc_train, acc_val)}
results.update(results_once)
pdb.set_trace()
################################################################################
# END OF YOUR CODE #
################################################################################
print 'That took %fs' % (toc - tic)
# In[ ]:
# A useful debugging strategy is to plot the loss as a function of
# iteration number:
# plt.plot(loss_hist)
# plt.xlabel('Iteration number')
# plt.ylabel('Loss value')
# plt.show()
# In[ ]:
# Write the LinearSVM.predict function and evaluate the performance on both the
# training and validation set
y_train_pred = svm.predict(X_train)
print 'training accuracy: %f' % (np.mean(y_train == y_train_pred), )
y_val_pred = svm.predict(X_val)
print 'validation accuracy: %f' % (np.mean(y_val == y_val_pred), )
# In[ ]:
# Use the validation set to tune hyperparameters (regularization strength and
# learning rate). You should experiment with different ranges for the learning
# rates and regularization strengths; if you are careful you should be able to
# get a classification accuracy of about 0.4 on the validation set.
learning_rates = [1e-7, 5e-5]
regularization_strengths = [5e4, 1e5]
# results is dictionary mapping tuples of the form
# (learning_rate, regularization_strength) to tuples of the form
# Hint: You should use a small value for num_iters as you develop your #
# validation code so that the SVMs don't take much time to train; once you are #
# confident that your validation code works, you should rerun the validation #
# code with a larger value for num_iters. #
################################################################################
num_iter = 500
for i in learning_rates:
for j in regularization_strengths:
results[(i, j)]=0
for lr, reg in sorted(results):
svm = LinearSVM()
svm.train(X_train, y_train, lr, reg, num_iter, True)
y_pred = svm.predict(X_test)
val_accuracy = float(np.sum(y_pred == y_test))/y_test.shape[0]
y_pred = svm.predict(X_train)
train_accuracy = float(np.sum(y_pred == y_train))/y_train.shape[0]
results[(lr, reg)] = [train_accuracy, val_accuracy]
if(best_val<val_accuracy):
best_val = val_accuracy
best_svm = svm
################################################################################
# END OF YOUR CODE #
################################################################################
# Print out results.
num_iters=1500,
verbose=True)
toc = time.time()
print 'That took %fs' % (toc - tic)
# A useful debugging strategy is to plot the loss as a function of
# iteration number:
if (show_image != 0):
plt.plot(loss_hist)
plt.xlabel('Iteration number')
plt.ylabel('Loss value')
plt.show()
# Write the LinearSVM.predict function and evaluate the performance on both the
# training and validation set
y_train_pred = svm.predict(X_train)
print 'training accuracy: %f' % (np.mean(y_train == y_train_pred), )
y_val_pred = svm.predict(X_val)
print 'validation accuracy: %f' % (np.mean(y_val == y_val_pred), )
# Use the validation set to tune hyperparameters (regularization strength and
# learning rate). You should experiment with different ranges for the learning
# rates and regularization strengths; if you are careful you should be able to
# get a classification accuracy of about 0.4 on the validation set.
learning_rates = [1e-7, 5e-5]
regularization_strengths = [5e4, 1e5]
# results is dictionary mapping tuples of the form
# (learning_rate, regularization_strength) to tuples of the form
# (training_accuracy, validation_accuracy). The accuracy is simply the fraction
# of data points that are correctly classified.
def SVM(train_data, train_label, validation_data, validation_label, test_data, test_label):
W = np.random.randn(10, 3072) * 0.0001
loss, grad = svm_loss_naive(W, train_data, train_label, 0.000005)
print 'loss: %f \n' % loss
'''
f=lambda w: svm_loss_naive(w, train_data,train_label,0.0)[0]
grad_numerical=grad_check_sparse(f,W,grad,10)
loss, grad = svm_loss_naive(W,train_data,train_label,5e1)
f=lambda w:svm_loss_naive(w,train_data,train_label,5e1)[0]
grad_numerical=grad_check_sparse(f,W,grad,10)
t1 = time.time()
loss_naive, grad_naive = svm_loss_naive(W, train_data, train_label, 0.000005)
t2 = time.time()
print '\nNaive Loss: %e computed in %fs'%(loss_naive, t2-t1)
t1 = time.time()
loss_vectorized,grad_vectorized = svm_loss_vectorized(W, train_data, train_label, 0.000005)
t2 = time.time()
print 'Vectorised loss and gradient: %e computed in %fs\n'%(loss_vectorized, t2-t1)
difference = np.linalg.norm(grad_naive-grad_vectorized, ord='fro')
print 'difference: %f'%difference
'''
from cs231n.classifiers import LinearSVM
svm = LinearSVM()
t1 = time.time()
loss_hist = svm.train(train_data, train_label,
learning_rate=1e-7, reg=5e4, num_iters=1000, verbose=True)
t2 = time.time()
print 'That took %fs' % (t2 - t1)
plt.plot(loss_hist)
plt.xlabel('Iteration number')
plt.ylabel('Loss value')
plt.show()
train_label_predict = svm.predict(train_data)
print 'Training accuracy: %f' % np.mean(train_label == train_label_predict)
validation_label_predict = svm.predict(validation_data)
print 'Validation accuracy: %f' % np.mean(validation_label == validation_label_predict)
learning_rates = [1e-7, 2e-7, 5e-7, 1e-6]
regularization_strengths = [1e4, 2e4, 5e4, 1e5, 5e5, 1e6]
results = {}
best_val = -1
best_svm = None
for learning in learning_rates:
for regularization in regularization_strengths:
svm = LinearSVM()
svm.train(train_data, train_label, learning_rate=learning,
reg=regularization, num_iters=2000)
train_label_predict = svm.predict(train_data)
train_accuracy = np.mean(train_label_predict == train_label)
print 'Training accuracy: %f' % train_accuracy
validation_label_predict = svm.predict(validation_data)
val_accuracy = np.mean(validation_label_predict == validation_label)
print 'Validation accuracy: %f' % val_accuracy
if val_accuracy > best_val:
best_val = val_accuracy
best_svm = svm
results[(learning, regularization)] = (
train_accuracy, val_accuracy)
for lr, reg in sorted(results):
train_accuracy, val_accuracy = results[(lr, reg)]
print 'lr %e reg %e train accuracy: %f val accuracy %f' % (lr, reg, train_accuracy, val_accuracy)
print 'Best validation accuracy achieved during cross validation: %f ' % best_val
x_scatter = [math.log10(x[0]) for x in results]
y_scatter = [math.log10(x[1]) for x in results]
sz = [results[x][0] * 1500 for x in results]
plt.subplot(1, 1, 1)
plt.scatter(x_scatter, y_scatter, sz)
plt.xlabel('log learning rate')
plt.ylabel('log regularization strength')
plt.title('Cifar-10 training accuracy')
plt.show()
sz = [results[x][1] * 1500 for x in results]
plt.subplot(1, 1, 1)
plt.scatter(x_scatter, y_scatter, sz)
plt.xlabel('log learning rate')
plt.ylabel('log regularization strength')
plt.title('Cifar-10 validation accuracy')
plt.show()
y_test_pred = best_svm.predict(test_data)
test_accuracy = np.mean(y_test_pred == test_label)
print 'Linear SVM on raw pixels final test set accuracy: %f' % test_accuracy
print best_svm.W.shape
w = best_svm.W[:, :]
print w.shape
w = w.reshape(10, 32, 32, 3)
w_min, w_max = np.min(w), np.max(w)
classes = ['plane', 'car', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck']
for i in xrange(10):
plt.subplot(2, 5, i + 1)
wimg = 255.0 * (w[i].squeeze() - w_min) / (w_max - w_min)
plt.imshow(wimg.astype('uint8'))
plt.axis('off')
plt.title(classes[i])
plt.show()
