def experiment_learning_rate(classes):
'''
In this experiment, we train the svm model with different learning rates.
learning rate : 0.01 to 0.5 with a step 0.05
'''
l_rate = 0.01
test_acc_list = []
train_acc_list = []
l_rate_list = []
X_test,y_test = read_vgg_output_data(vgg_features_output_test,classes)
X_train,y_train = read_vgg_output_data(vgg_features_output_train,classes)
for i in range(10):
svm_classifier = train_svm_ovo(classes)
test_acc_list.append(get_accuracy(svm_classifier,X_test,y_test))
train_acc_list.append(get_accuracy(svm_classifier,X_train,y_train))
print(get_accuracy(svm_classifier,X_test,y_test),get_accuracy(svm_classifier,X_train,y_train))
l_rate_list.append(l_rate)
l_rate += 0.05
print('-----------------------------------------')
plt.plot(l_rate_list, train_acc_list, label='training instances')
plt.plot(l_rate_list, test_acc_list,label='test instances')
plt.xlabel('Learning rate')
plt.ylabel('Accuracy of the model')
plt.legend()
plt.show()
def train_svm_ovo(classes,learning_rate=0.2):
'''
output is kc2 w,b.
it is in the form of dictionary where key is tuple class indices and value is w,b tuple.
here read the train data from ../vgg_features_train/
'''
vgg_features_output_train = '../vgg_features_train/'
svm_classifiers = {}
print('training....')
for i in range(len(classes)):
for j in range(i+1,len(classes)):
x,y = read_vgg_output_data(vgg_features_output_train,[classes[i],classes[j]])
'''
y_test has only 1 and 0. so replace 0 with i and 1 with j.
'''
w,b = train_svm_classifier(x, y, learning_rate)
svm_classifiers.update({(i,j) : (w,b)})
#print('done for ' + str(i) + ' ' + str(j))
print('done training.')
return svm_classifiers
def train_test_dataset_split(test_split_ratio, classes):
'''
for every class, split the data into test and train and then save then save the data using pickle.
use filepaths as classnames.
vgg_features_train folder to store training instances.
vgg_features_test folder to store test instances.
'''
vgg_features_output = '../vgg_features/'
vgg_features_output_train = '../vgg_features_train/'
vgg_features_output_test = '../vgg_features_test/'
if(os.path.exists('../vgg_features_train/') == False):
os.mkdir('../vgg_features_train/')
if(os.path.exists('../vgg_features_test/') == False):
os.mkdir('../vgg_features_test/')
for class1 in classes:
x,y = read_vgg_output_data(vgg_features_output,[class1])
'''
splitting the data into test and train
'''
X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = test_split_ratio)
'''
saving train into vgg_features_output_train
and test into vgg_features_output_test
'''
ifile = open(vgg_features_output_train + class1,'wb')
pickle.dump(X_train,ifile)
ifile.close()
ifile = open(vgg_features_output_test + class1,'wb')
pickle.dump(X_test,ifile)
ifile.close()
Z = Z.T
count = 0
for i in range(Z.shape[0]):
if np.argmax(Y_test[i]) == np.argmax(Z[i]):
count += 1
return count * 100 / N
# X_train, Y_train, X_test, Y_test = read_data(DATASET_DIRECTORY,SPLIT_RATIO)
# Read VGG outputs
classes = [
'aeroplane', 'bicycle', 'bird', 'boat', 'car', 'person', 'horse', 'dog',
'cat'
]
X, y = read_vgg_output_data(DATASET_DIRECTORY, classes)
for i in range(X.shape[1]):
if np.max(X[:, i]) > 0:
X[:, i] = (X[:, i] - np.min(X[:, i])) / np.max(X[:, i])
X_train, X_test, Y_train1, Y_test1 = train_test_split(
X, y, test_size=TEST_SPLIT_RATIO)
Y_train = np.zeros(shape=(Y_train1.shape[0], len(classes)))
Y_test = np.zeros(shape=(Y_test1.shape[0], len(classes)))
for i in range(Y_train1.shape[0]):
Y_train[i, int(Y_train1[i])] = 1
for i in range(Y_test1.shape[0]):
Y_test[i, int(Y_test1[i])] = 1
# Architecture
ARCHITECTURE = [4096, 1024, 256, 64, len(classes)]
ann = Neural_Network(ARCHITECTURE)
correct = 0 #no of correct labels
predicted_values = kmeans.predict(data) #predicted values
for i in range(a):
if (mapping[predicted_values[i]] == labels[i][0]):
correct += 1
return 100 * (correct / a)
if __name__ == "__main__":
classes = [
'aeroplane', 'bicycle', 'bird', 'boat', 'car', 'person', 'horse',
'dog', 'cat'
]
clusters = len(classes)
x, y = read_vgg_output_data(vgg_features_output, classes)
y = y.astype(int)
y = y.reshape((y.shape[0], 1))
# kmeans = kmeans(x,clusters)
# ifile = open('kmeans','wb')
# pickle.dump(kmeans,ifile)
# ifile.close()
ifile = open('kmeans', 'rb')
kmeans = pickle.load(ifile)
ifile.close()
print('kmeans stored')
m = create_mapping(kmeans, x, clusters, y, len(classes))
print(accuracy(x, y, kmeans, m))
classes = ['aeroplane','bicycle','bird','boat','car','person','horse','dog','cat']
'''
store the train and test instances accordingly.
'''
train_test_dataset_split(0.2, classes)
svm_classifiers = train_svm_ovo(classes)
ifile = open('svm_weights','wb')
pickle.dump(svm_classifiers,ifile)
ifile.close()
X_test,y_test = read_vgg_output_data(vgg_features_output_test,classes)
'''
read x_test and y_test.
'''
X_test,y_test = read_vgg_output_data(vgg_features_output_test,classes)
'''
After extracting X_test and y_test, printing test accuracy of the model.
'''
print('Accuracy of the model : ' + str(get_accuracy(svm_classifiers, X_test,y_test)))
ifile = open('svm_weights','rb')
svm_classifiers = pickle.load(ifile)