def report_accuracy(self, y, a2, test=False):
corr = np.argmax(a2, axis=1)
pred = np.argmax(y, axis=1)
ratio = float(sum(corr == pred))/y.shape[0]
confusion_matrix = get_confusion_matrix(corr, pred)
logging.info("Correctly classified: {}%".format(
ratio * 100))
logging.info("Confusion matrix:\n{}".format(confusion_matrix))
return ratio, confusion_matrix
def evaluateResults(estimator, test_set, test_labels, estimator_name='Unknown', file_name=''):
result = estimator.predict(test_set)
# print result
aux = result == test_labels
correct = sum(aux.astype(int))
_accuracy = (correct * 100) / len(test_set)
cm = ut.get_confusion_matrix(test_labels, result, estimator_name, file_name=file_name)
print '\n'
_precision, _recall, _f1score, _support = ut.get_measures_for_each_class(test_labels, result)
print 'Estimator ', estimator_name
print 'Average Accuracy:\t', _accuracy
print 'Average Precision:\t', _precision
print 'Average Recall:\t', _recall
print 'Average F1 Measure:\t', _f1score
print '\n'
return result, _accuracy, _precision, _recall, _f1score
def test(self, test_data, test_label, _intv=None):
'''test_data should also be a RDD object'''
import numpy as np
from utils import get_confusion_matrix
pred_tuple = self.predict(test_data, _intv)
# Get actual labels
true_tuple = test_label.collect()
pred, true = np.zeros(len(pred_tuple)), np.zeros(len(pred_tuple))
for i in range(len(pred)):
idx, cl = pred_tuple[i]
idx, cl = true_tuple[i]
if _intv == None:
true[int(idx)] = int(cl)
pred[int(idx)] = int(cl)
else:
true[_intv.index(idx)] = int(cl)
pred[_intv.index(idx)] = int(cl)
confusion_matrix = get_confusion_matrix(pred, true)
return pred_tuple, confusion_matrix
json_str3 = json.dumps(tr_los_dict, indent=4)
json_str4 = json.dumps(te_los_dict, indent=4)
if not os.path.exists('results'):
os.mkdir('results')
with open('results/tr_acc_epoch.json', 'w') as json_file:
json_file.write(json_str1)
with open('results/te_acc_epoch.json', 'w') as json_file:
json_file.write(json_str2)
with open('results/tr_los_epoch.json', 'w') as json_file:
json_file.write(json_str3)
with open('results/te_los_epoch.json', 'w') as json_file:
json_file.write(json_str4)
# plot the accuracy and loss figures
plot_accuracy_curve(train_accuracy, test_accuracy, show=True)
plot_loss_curve(train_loss, test_loss, show=True)
# plot confusion matrix of the predicted results of the latest model
net.eval()
predict_list = np.array([]).astype(int)
label_list = np.array([]).astype(int)
with torch.no_grad():
for images, labels in test_loader:
images = Variable(images.to(device))
labels = Variable(labels.to(device))
outputs = net(images)
predict_y = torch.max(outputs, dim=1)[1]
predict_list = np.hstack((predict_list, predict_y.cpu().numpy()))
label_list = np.hstack((label_list, labels.cpu().numpy()))
cm = get_confusion_matrix(classes, predict_list, label_list)
plot_confusion_matrix(cm, classes, title='Confusion matrix', normalize=True)
test_y = test_y.reshape(10000)
print train_x.shape, train_y.shape, test_x.shape, test_y.shape
#creating a classifer Object
clf = KNeighborsClassifier(n_neighbors=50, n_jobs=-1)
print "Training ...... "
#clf.fit(train_x,train_y)
# clf.fit(X_transformed,cifar10_labels)
# print "start to predict"
# pred_labels = clf.predict(X_test_transformed)
# print np.mean(pred_labels == cifar10_test_label)
#saving trained model
#utils.save_model(clf,"knn_cifar10.pickle")
clf = utils.load_model("knn_cifar10.pickle")
pred = clf.predict(test_x)
acc = get_accuracy(test_y, pred)
print "Accuracy : ", (acc)
print "Test DATA Prediction ", (pred)
cm = utils.get_confusion_matrix(actual=test_y,
pred=pred,
n_classes=10,
class_names=text_labels)
print "Confusion Matrix"
print cm
utils.plot_confusion_matrix(cm,
classes=text_labels,
title='Confusion matrix, without normalization')
characterisation_latency = []
for i in range(len(predC)):
del_st = (Y_pos[i] - 800) // 30 + 1
currC = predC[i][del_st:]
currR = predR[i][del_st:]
cls_out, cls_loc = cls_strategy.get_prediction(currC)
if (cls_out == 1):
currR = currR[cls_loc:]
reg_out, reg_loc = reg_strategy.get_prediction(currR)
strategy_out.append([reg_out])
characterisation_latency.append(cls_loc + reg_loc)
else:
strategy_out.append([0.])
print("\n\nRESULTS")
print("-------\n\n")
print("Average Latency (in sec) : ", np.mean(characterisation_latency) * 30)
strategy_out = scalerY.inverse_transform(strategy_out)
Yr = scalerY.inverse_transform([ele[0] for ele in Yr])
acc, conf = get_confusion_matrix(strategy_out, Yc)
print("Classification accuracy : %.2f%%" % (acc * 100))
print("Classification confusion matrix\n", conf)
print("Overall MAE error : ", get_mae(strategy_out, Yr))
print("Overall RMSE error : ", get_rmse(strategy_out, Yr))
print("Validation after {} iterations".format(iteration))
print("Val accuracy: {:.3f}".format(accuracy))
print("Val miou: {:.3f}".format(miou))
if __name__ == '__main__':
args = parser.parse_args()
resnet50_weights = download_resnet50_weights()
resnet50, deeplab = create_deeplab_model(resnet50_weights,
args.deeplab_weights)
deeplab = resnet50 > deeplab
confusion = np.zeros((21, 21))
print("Start validation")
for i, (image, annotation) in tqdm(enumerate(iter_data(VALIDATION_SET))):
annotation = make_annotation_one_hot_encoded(annotation)
annotation = np.expand_dims(annotation, axis=0)
image = subtract_channel_mean(image)
image = np.expand_dims(image, axis=0).astype(np.float32)
segmentation = deeplab.predict(image)
confusion += get_confusion_matrix(annotation, segmentation)
if i % 20 == 0 and i != 0:
summarize(confusion, i + 1)
summarize(confusion, i + 1)
train_y = data['train_y']
test_x = data['test_x']
test_y = data['test_y']
text_labels = data['text_labels']
#from sklearn import decomposition
#pca = decomposition.PCA(n_components=768)
#pca.fit(train_x)
#utils.save_model(pca,"pca.pkl")
#pca=utils.load_model("pca.pkl")
#train_x = pca.transform(train_x)
#test_x = pca.transform(test_x)
print(train_x.shape, train_y.shape, test_x.shape, test_y.shape)
max = np.max(train_x)
min = np.min(train_x)
mean = np.mean(train_x)
train_x = (train_x - mean) / (max - min)
test_x = (test_x - mean) / (max - min)
pred, accuracy = cnn(train_x, train_y, test_x, test_y)
print("Accuracy : ", (accuracy))
print("Test DATA Prediction ", (pred))
cm = utils.get_confusion_matrix(actual=utils.back_from_onehot(test_y[0:500, ]),
pred=pred,
n_classes=10,
class_names=text_labels)
print("Confusion Matrix")
print(cm)
utils.plot_confusion_matrix(cm,
classes=text_labels,
title='Confusion matrix, without normalization')
deeplab,
error='categorical_crossentropy',
step=0.00001,
verbose=True,
addons=[algorithms.WeightDecay],
decay_rate=0.0001,
)
for i in range(args.epochs):
print("Epoch #{}".format(i + 1))
for x_batch, y_batch in training_iterator():
x_batch = resnet50.predict(x_batch)
optimizer.train(x_batch, y_batch, epochs=1, summary='inline')
print("Start validation")
val_images, val_annotations = next(vaidation_iterator())
segmentation = deeplab.predict(resnet50.predict(val_images))
confusion = get_confusion_matrix(val_annotations, segmentation)
accuracy, miou = segmentation_metrics(confusion)
print("Val accuracy: {:.3f}".format(accuracy))
print("Val miou: {:.3f}".format(miou))
filename = 'deeplab_{:0>3}_{:.3f}_{:.3f}.hdf5'.format(
i, accuracy, miou)
filepath = os.path.join(storage_folder, filename)
print("Saved: {}".format(filepath))
storage.save(deeplab, filepath)
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = keras.optimizers.Adam(lr=0.001)
acc_metric = keras.metrics.SparseCategoricalAccuracy()
train_writer = tf.summary.create_file_writer("logs/train/")
test_writer = tf.summary.create_file_writer("logs/test/")
train_step = test_step = 0
for epoch in range(num_epochs):
confusion = np.zeros((len(class_names), len(class_names)))
# Iterate through training set
for batch_idx, (x, y) in enumerate(ds_train):
with tf.GradientTape() as tape:
y_pred = model(x, training=True)
loss = loss_fn(y, y_pred)
gradients = tape.gradient(loss, model.trainable_weights)
optimizer.apply_gradients(zip(gradients, model.trainable_weights))
acc_metric.update_state(y, y_pred)
confusion += get_confusion_matrix(y, y_pred, class_names)
with train_writer.as_default():
tf.summary.image(
"Confusion Matrix",
plot_confusion_matrix(confusion / batch_idx, class_names),
step=epoch,
)
# Reset accuracy in between epochs (and for testing and test)
acc_metric.reset_states()
def score(self, input_data, label):
input_pad = self.prepare_input(input_data)
label = self.prepare_label(label)
prediction = self.model.predict(input_pad)
get_score_senti(label, prediction)
get_confusion_matrix(label,prediction) #implemented cofusion matrix for it