def learn_batch_performance_params (m_val):
    testing_file = batch_performance_datasets[m_val][0]
    training_file = batch_performance_datasets[m_val][1]
    
    testing_set = file_read (testing_file)
    training_set = file_read (training_file)
    
    partition = partition_data (testing_set)
    D1 = partition.training
    D2 = partition.testing
    
    perceptron_params = perceptron_learn_batch_performance_params (D1, D2)
    perceptron_params_without_margin = perceptron_params.get_params (0)
    perceptron_params_with_margin = perceptron_params.get_params (1)
    print 'perceptron without margin acc(D2): ' + str(perceptron_params_without_margin.accuracy)
    print 'perceptron with margin acc(D2): ' + str(perceptron_params_with_margin.accuracy)
    
    print '\n\nRunning perceptron on Test set...'
    
    perceptron_trained_without_margin = perceptron_train (batch_performance_n, training_set, perceptron_params_without_margin.gamma, perceptron_params_without_margin.eta)
    perceptron_trained_with_margin = perceptron_train (batch_performance_n, training_set, perceptron_params_with_margin.gamma, perceptron_params_with_margin.eta)
    perceptron_mistakes_without_margin = perceptron_test (testing_set, perceptron_trained_without_margin[0], perceptron_trained_without_margin[1])
    perceptron_mistakes_with_margin = perceptron_test (testing_set, perceptron_trained_with_margin[0], perceptron_trained_with_margin[1])
    print 'perecptron without margin acc(Test): ' + str(1.0 - float(perceptron_mistakes_without_margin[len(perceptron_mistakes_without_margin)-1]) / len (testing_set))
    print 'perecptron with margin acc(Test): ' + str(1.0 - float(perceptron_mistakes_with_margin[len(perceptron_mistakes_with_margin)-1]) / len (testing_set))
    
    winnow_params = winnow_learn_batch_performance_params (D1, D2)
    winnow_params_without_margin = winnow_params.get_params (0)
    winnow_params_with_margin = winnow_params.get_params (1)
    print 'winnow without margin acc(D2): ' + str(winnow_params_without_margin.accuracy)
    print 'winnow with margin acc(D2): ' + str(winnow_params_with_margin.accuracy)
    
    print '\n\nRunning winnow on Test set...'
    
    winnow_trained_without_margin = winnow_train (batch_performance_n, training_set, winnow_params_without_margin.gamma, winnow_params_with_margin.eta)
    winnow_trained_with_margin = winnow_train (batch_performance_n, training_set, winnow_params_with_margin.gamma, winnow_params_with_margin.eta)
    winnow_mistakes_without_margin = winnow_test (testing_set, winnow_trained_without_margin)
    winnow_mistakes_with_margin = winnow_test (testing_set, winnow_trained_with_margin)
    print 'winnow without margin acc(Test): ' + str(1.0 - float(winnow_mistakes_without_margin[len(winnow_mistakes_without_margin)-1]) / len(testing_set))
    print 'winnow with margin acc(Test): ' + str(1.0 - float(winnow_mistakes_with_margin[len(winnow_mistakes_with_margin)-1]) / len(testing_set))
Esempio n. 2
0
import perceptron as P
import numpy as np
print_stuff = True

if print_stuff:
    print("\n\n\nPerceptron tests:")
Perc_X_train = np.array([[0, 1], [1, 0], [5, 4], [1, 1], [3, 3], [2, 4], [1, 6]])
Perc_Y_train = np.array([[1], [1], [-1], [1], [-1], [-1], [-1]])
[w, b] = P.perceptron_train(Perc_X_train, Perc_Y_train)
perc_test = P.perceptron_test(Perc_X_train, Perc_Y_train, w, b)
if print_stuff:
    print("W from sample =", w, "B from sample =", b)
    print("Test on self form sample: ", perc_test)
    print("Testing for non-linearly seperable data")
Perc_stuff_X = np.array(
    [[1, 0], [7, 4], [9, 6], [2, 1], [4, 8], [0, 3], [13, 5], [6, 8], [7, 3], [3, 6], [2, 1], [8, 3], [10, 2],
     [3, 5], [5, 1], [1, 9], [10, 3], [4, 1], [6, 6], [2, 2]])
Perc_stuff_Y = np.array(
    [[1], [1], [-1], [1], [-1], [-1], [-1], [1], [1], [-1], [1], [-1], [-1], [-1], [1], [1], [-1], [1], [-1], [-1]])
[w, b] = P.perceptron_train(Perc_stuff_X, Perc_stuff_Y)
someTest = P.perceptron_test(Perc_stuff_X, Perc_stuff_Y, w, b)
if print_stuff:
    print("Non-linearly seperable data test w=", w, "b=", b, "Accuracy on self =", someTest)
Perc_random_X = np.array([[1.84724509, 2.23182926],
                          [1.22695894, 1.6611229],
                          [2.13212121, 4.63313796],
                          [7.78081405, 4.11930532],
                          [7.28450063, 3.90368111],
                          [1.29216053, 2.76912245],
                          [7.0384763, 2.80881342],
                          [1.22081714, 3.80955021],
Esempio n. 3
0
yTest = np.genfromtxt(os.path.join(data_dir, 'yTest.csv'), delimiter=',')

# Visualize the image
'''
idx = 0
datapoint = XTrain[idx, 1:]
plt.imshow(datapoint.reshape((28,28), order = 'F'), cmap='gray')
plt.show()
'''

# TODO: Test perceptron_predict function, defined in perceptron.py
yPred = perceptron.perceptron_predict(w, XTrain[0])

# TODO: Test perceptron_train function, defined in perceptron.py
w = np.zeros(XTrain.shape[1])
w = perceptron.perceptron_train(w, XTrain, yTrain, 10)

# TODO: Test RBF_kernel function, defined in perceptron.py
K = perceptron.RBF_kernel(XTrain[0:5], XTrain[0:5], 10.0)

# TODO: Test kernel_perceptron_predict function, defined in perceptron.py
a = np.zeros(XTrain.shape[0])
yPred = perceptron.kernel_perceptron_predict(a, XTrain, yTrain, XTrain[0],
                                             10.0)

# TODO: Test kernel_perceptron_train function, defined in perceptron.py
a = np.zeros(XTrain.shape[0])
a0 = perceptron.kernel_perceptron_train(a, XTrain, yTrain, 5, 100)

# TODO: Run experiments outlined in HW4 PDF
w = np.zeros(XTrain.shape[1])
Esempio n. 4
0
C_3 = km.K_Means_better(X_2, K_3)
# Visuals for debugging, Uncomment matplot header to use
print("C_3: \n", C_3)
plt.scatter(C_3[:,0], C_3[:,1], label='centers')
plt.scatter(X_2[:,0], X_2[:,1], label='samples')
plt.title('X_2, K=3')
# plt.savefig("k_means_results_3.png")  #Uncomment to save plot as file
plt.show()


# PERCEPTRON TESTING

# Hand-Tested Data
X = np.array( [[1,1], [1,-1], [-1,1], [-1,-1]] )
Y = np.array( [[1], [-1], [-1], [-1]] )
W = p.perceptron_train(X,Y)
print("Hand-Tested Data    W1: ",W[0][0],"  W2: ",W[0][1],"  b:",W[1][0])
test_acc = p.perceptron_test(X,Y,W[0],W[1])
print("Accurancy:",test_acc,"\n")

# Percepton Test Data 
X = np.array( [[0,1], [1,0], [5,4], [1,1], [3,3], [2,4], [1,6]] )
Y = np.array( [[1], [1], [-1], [1], [-1], [-1], [-1]] )
W = p.perceptron_train(X,Y)
print("Preceptron Test Data 1    W1: ",W[0][0],"  W2: ",W[0][1],"  b:",W[1][0])
test_acc = p.perceptron_test(X,Y,W[0],W[1])
print("Accurancy:",test_acc,"\n")

# Perceptron Test Data - Writeup
X = np.array( [[-2,1], [1,1], [1.5,-0.5], [-2,-1], [-1,-1.5], [2,-2]] )
Y = np.array( [[1], [1], [1], [-1], [-1], [-1]] )
Esempio n. 5
0
def main():
    # params to tune
    bias = 0
    # epochs = 20

    # arrays containing train and test
    train = np.array(parse_features('trainingimages', 5000))
    train_labels = np.array(parse_labels('traininglabels', 5000))
    test = np.array(parse_features('testimages', 1000))
    test_labels = np.array(parse_labels('testlabels', 1000))

    # initialize weight vectors
    w = np.array([[0 for i in range(28 * 28 + 1)] for j in range(10)])
    w = w.astype(float)
    train_acc = []  # [0 for i in range(epochs)]

    # training
    # for j in range(epochs):
    epochs = 1
    while True:
        mistakes = 0
        alpha = 1.0 / (1.0 + epochs)
        for i in range(5000):
            mistakes += P.perceptron_train(w, alpha, train[i], train_labels[i])

        train_acc.append((5000 - mistakes) / (5000.0))  # accuracy so far
        print train_acc[epochs - 1], epochs

        # stop training if not improving much
        #if epochs != 1 and train_acc[epochs-1] - train_acc[epochs-2] < 0.001:
        if epochs == 20:
            break
        epochs += 1
    # draw training accuracies in the end

    # testing
    accuracy = 0
    for i in range(1000):
        guess = P.perceptron_decision(w, test[i])
        if guess == test_labels[i]:
            accuracy += 1
    accuracy /= 1000.0
    print "test accuracy:"
    print accuracy

    # building confusion matrix
    confusion_counts = [[0 for i in range(10)] for j in range(10)]
    confusion_totals = [[0 for i in range(10)] for j in range(10)]
    confusion = [[0 for i in range(10)] for j in range(10)]
    for i in range(0, 1000):
        digit = test_labels[i]
        for j in range(0, 10):
            confusion_totals[digit][j] += 1  # the whole digit row +=1
        guess = P.perceptron_decision(w, test[i])
        confusion_counts[digit][guess] += 1

    for i in range(0, 10):
        for j in range(0, 10):
            rate = (confusion_counts[i][j] + 0.0) / confusion_totals[i][j]
            confusion[i][j] = "{0:.3f}".format(rate)
    for i in range(0, 10):
        print confusion[i]

    # draw training accuracies
    fig = plt.figure()

    plt.xlabel('num of epochs')
    plt.ylabel('training accuracy')
    plt.title('Training Curve')

    ax = fig.add_subplot(111)
    for i, j in zip(range(epochs), train_acc):
        ax.annotate(str("{0:.2f}".format(j)), xy=(i, j))

    plt.plot(range(epochs), train_acc)
    plt.savefig('training_curve_bias.png', bbox_inches='tight')
Esempio n. 6
0
            ptron = perceptron_learn(ptron, examples[i], true_classes[i],
                                     learn_rate)
        accuracy = perceptron_accuracy(ptron, examples, true_classes)
    print("Final accuracy: " + str(accuracy))
    return ptron


def plot_everything(ptron, examples):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    for example in examples:
        ax.scatter(example[0],
                   example[1],
                   example[2],
                   'z',
                   s=20,
                   c=[(example[0], example[1], example[2])])
    xx, yy = np.meshgrid(np.arange(0, 1.1, 0.1), np.arange(0, 1.1, 0.1))
    # ax + by + cz + d == 0  becomes z == (-d - ax - by)/c
    z = (-ptron[3] - ptron[0] * xx - ptron[1] * yy) / ptron[2]
    ax.plot_surface(xx, yy, z, alpha=0.2)
    plt.show()


import perceptron
ptron = perceptron.new_perceptron()
examples, classes = perceptron.create_data()
perceptron.plot_everything(ptron, examples)
perceptron.perceptron_train(ptron, examples, classes, 0.01, 100)
perceptron.plot_everything(ptron, examples)
Esempio n. 7
0
                    '--input_data_dir',
                    type=str,
                    default='../data/perceptron',
                    help='Directory for the perceptron dataset.')
FLAGS, unparsed = parser.parse_known_args()

print('\033[1m' + '1. Perceptron Convergence:\n' + '\033[0m')

# Read the training data for Exercise 5.
Xtrain, ttrain = read_data(FLAGS.input_data_dir + "/perceptron.txt")

print('Exercise 5(a): \n')

# Train the perceptron algorithm on the training data.

w, weights, err = perceptron_train(Xtrain, ttrain, 10)

# Print the weight vector at different epochs.

print("Weight vector at the end of each epoch:\n")
ep = []
for i in range(weights.shape[0] - 1):
    print("Epoch %d:" % (i + 1))
    print(weights[i + 1])
    ep = np.append(ep, i + 1)

# Plot of errors at different epochs.

plt.xlabel('Epoch')
plt.ylabel("Errors")
plt.plot(ep, err, 'bo-', label='Total errors during epoch')
Esempio n. 8
0
print("Clustering")
#test
C1 = clu.K_Means(cluX1, 3)
#print(C1)
#writeup
C2 = clu.K_Means(cluX2, 2)
print("\tK=2", C2)
C3 = clu.K_Means(cluX2, 3)
print("\tK=3", C3)
#writeup
CBetter1 = clu.K_Means_better(cluX2, 2)
print("\tBetter K=2", CBetter1)
CBetter2 = clu.K_Means_better(cluX2, 3)
print("\tBetter K=3", CBetter2)
print()

print("Perceptron")
#test
W_B1 = per.perceptron_train(perX1, perY1)
perAcc1 = per.perceptron_test(perX1, perY1, W_B1[0], W_B1[1])
#print("\tW",W_B1[0])
#print("\tB",W_B1[1])
#print("\tAccuracy", perAcc1)
#writeup
W_B2 = per.perceptron_train(perX2, perY2)
perAcc2 = per.perceptron_test(perX2, perY2, W_B2[0], W_B2[1])
print("\tW", W_B2[0])
print("\tB", W_B2[1])
print("\tAccuracy", perAcc2)
###################################################################################################################################################
# filename: testPreceptron.py
# author: Sara Davis
# date: 10/10/2018
# version: 1.0
# description: runs testPerceptron.py
#############################################################################################################################################

import numpy as np

from perceptron import perceptron_train
from perceptron import perceptron_test

#X_test = np.array([[0,1], [1,0], [5,4], [1,1], [3,3], [2,4], [1,6]]) #should be -2, -2, 6
#Y_test = np.array([[1], [1], [0], [1], [0], [0], [0]])
X_test = np.array([[0, 0], [1, 1], [0, 1], [2, 2], [1, 0], [1, 2]])
Y_test = np.array([[-1], [1], [-1], [1], [-1], [1]])
X = np.array([[-2, 1], [1, 1], [1.5, -.5], [-2, -1], [-1, -1.5], [2, -2]])
Y = np.array([[1], [1], [1], [-1], [-1], [-1]])

W = perceptron_train(X, Y)
print(W)

test_acc = perceptron_test(X_test, Y_test, W[0], W[1])
print(test_acc)
Esempio n. 10
0
  X = []
  Y = []
  for item in x_str:
    temp = [float(x) for x in item.split(',')]
    X.append(temp)
  if len(y_str)>0:
    for item in y_str:
      temp = int(item)
      Y.append(temp)
  X = np.array(X)
  Y = np.array(Y)
  return X, Y


X,Y = load_data("data_1.txt")
w,b = p.perceptron_train(X,Y)
test_acc = p.perceptron_test(X,Y,w,b)
print("Perceptron:",test_acc)

X,Y = load_data("data_2.txt")
w,b = p.perceptron_train(X,Y)
X,Y = load_data("data_1.txt")
test_acc = p.perceptron_test(X,Y,w,b)
print("Perceptron:",test_acc)


def df_test1(x):
  return np.array([2*x[0]])

x = gd.gradient_descent(df_test1,np.array([5.0]),0.1)   
print("Gradient Descent:", x)
# Read the training and test data.

trdata1, trlabels1 = read_examples(FLAGS.input_data_dir +
                                   "/newsgroups_train1.txt")
trdata2, trlabels2 = read_examples(FLAGS.input_data_dir +
                                   "/newsgroups_train2.txt")

tsdata1, tslabels1 = read_examples(FLAGS.input_data_dir +
                                   "/newsgroups_test1.txt")
tsdata2, tslabels2 = read_examples(FLAGS.input_data_dir +
                                   "/newsgroups_test2.txt")

# Train the perceptron algorithm on training datasets for 10,000 epochs.

w1, ws1, error1 = perceptron_train(trdata1, trlabels1, 10000)
w2, ws2, error2 = perceptron_train(trdata2, trlabels2, 10000)

# Save the returned parameter vectors from training in appropriate text files.

p1 = np.savetxt('newsgroups_model_p1.txt', w1)

p2 = np.savetxt('newsgroups_model_p2.txt', w2)

# Evaluate the perceptron algorithm on the corresponding test examples for each version by reading the parameter vectors
# from the corresponding text files.

with open('newsgroups_model_p1.txt', 'r') as f:
    wp1 = f.readlines()

wp1 = np.asarray(wp1, dtype=np.float64)
Esempio n. 12
0
# Part 1: Split Training data into training and validation set
split_training_data.run()

# Part 2: Transform each email in the training set into a feature vector
(feature_vector_list_training,
 is_spam_list_training,
 vocabulary_list) = create_feature_vectors.run('./output_data/training_set')

# Part 3/4: Train the data on the training set and return the last weight vector. Test the percent
# error when this weight is run on the validation set
print('\n=========================================================================================')
print('Problem 4:')
(weight_vector,
 total_number_of_misclassifications,
 number_of_runs) = perceptron.perceptron_train(feature_vector_list_training, is_spam_list_training)

(feature_vector_list_validation,
 is_spam_list_validation,
 _) = create_feature_vectors.run('./output_data/validation_set', vocabulary_list)

training_set_error = perceptron.perceptron_test(
                            weight_vector, feature_vector_list_training, is_spam_list_training)
validation_set_error = perceptron.perceptron_test(
                            weight_vector, feature_vector_list_validation, is_spam_list_validation)

print('Total number of misclassifications: ' + str(total_number_of_misclassifications))
print('Training set error: ' + str(training_set_error))
print('Validation set error: ' + str(validation_set_error))

# Part 5: Find words in the vocabulary with the most positive and negative weights
Esempio n. 13
0
# Read the training and test data.

trdata1, trlabels1 = read_examples(FLAGS.input_data_dir +
                                   "/newsgroups_train1.txt")
trdata2, trlabels2 = read_examples(FLAGS.input_data_dir +
                                   "/newsgroups_train2.txt")

tsdata1, tslabels1 = read_examples(FLAGS.input_data_dir +
                                   "/newsgroups_test1.txt")
tsdata2, tslabels2 = read_examples(FLAGS.input_data_dir +
                                   "/newsgroups_test2.txt")

# Train the perceptron algorithm on training datasets for 10,000 epochs.

w1, _, _ = perceptron_train(trdata1, trlabels1, 10000)
w2, _, _ = perceptron_train(trdata2, trlabels2, 10000)

# Train and test the SVM algortihm on the newsgroups datasets.

svm_tra = svm.SVC(kernel='linear', C=5.0)
svm_tra.fit(trdata1, trlabels1)
pred = svm_tra.predict(tsdata1)

ac = np.mean(pred == tslabels1) * 100
print('Accuracy of linear svm on test dataset version 1: %0.3f%%.' % (ac))

svm_tra1 = svm.SVC(kernel='linear', C=5.0)
svm_tra1.fit(trdata2, trlabels2)
pred = svm_tra1.predict(tsdata2)
Esempio n. 14
0
data, labels = read_examples(FLAGS.input_data_dir + '/spam_train_svm.txt')
data1, labels1 = read_examples(FLAGS.input_data_dir + '/spam_test_svm.txt')

print("SVM algorithm: \n")
svm = svm.SVC(C=5, kernel='linear')
svm.fit(data, labels)

svm_test = svm.predict(data1)
accuracy = np.mean(labels1 == svm_test)
print("Accuracy of SVM with linear kernel: %0.2f%%." % (accuracy * 100))

print("\nPerceptron algorithm: \n")

# Train the perceptron algorithm on the training data.

w, _, error = perceptron_train(data, labels, 50)

# Save the returned parameter vector in spam_model_p.txt.

p = np.savetxt('spam_model_p.txt', w)

# Report number of mistakes during each epoch and total number of mistakes during training.

print("\nNumber of mistakes during each epoch:")

eph = 1
for i in error:
    print("Epoch %d: %d" % (eph, i))
    eph += 1

print("\nTotal number of mistakes: %d" % np.sum(error))
X_t, t_t = read_data(FLAGS.input_data_dir + '/optdigits.tes')
X_t_sc = scalling(X_t)

t10 = np.zeros((len(t), 10))
for i in range(10):
    for j in range(len(t)):
        if t[j] == i:
            t10[j, i] = 1
        else:
            t10[j, i] = -1

accrucys = []
for j in range(1, 21):
    pred_ehp = []
    for i in range(10):
        w = perceptron_train(X_sc[1000:, :], t10[1000:, i], j)
        w = w / np.linalg.norm(w)
        pred = X_sc[:1000, :].dot(w)
        pred_ehp.append(pred)
    labels = np.argmax(pred_ehp, axis=0)
    ac = np.mean(labels == t[:1000]) * 100
    print(j, ac)
    accrucys.append(ac)
print('max accrucy in epoch:', np.argmax(accrucys) + 1)
set_eph = 8
set_eph = np.argmax(accrucys) + 1

st = timeit.default_timer()
pred_ehp = []
for i in range(10):
    w = perceptron_train(X_sc[1000:, :], t10[1000:, i], set_eph)