def separable():
print("----------------separable-----------------------")
mat = Arff("./separableIsSquare.arff", label_count=1)
np_mat = mat.data
data = mat[:, :-1]
labels = mat[:, -1].reshape(-1, 1)
print(data[:, 1])
print(labels)
### Make the Classifier #####
P3Class = None
for lr in range(10, 0, -1):
P3Class = PerceptronClassifier(lr=0.1*lr, shuffle=False)
P3Class.fit(data, labels, standard_weight_value=None)
Accuracy = P3Class.score(data, labels)
print("Learning Rate = ", 0.1*lr)
print("Accuracy = [{:.2f}]".format(Accuracy))
print("Epochs = ", P3Class.get_epochs_trained())
# print(P3Class)
## could not get graphing to work in time...
# graph(data[:, 0], data[:, 1], labels=mat[:, -1])
w = P3Class.get_weights()
y = lambda x: (-w[0]/w[1])*x - (w[2]/w[1])
grapher = Grapher()
grapher.graph(data[:, 0], data[:, 1], labels=mat[:, -1], title="Separable")
grapher.add_function(y)
grapher.show("separable.svg")
def inseparable():
print("----------------Inseparable-----------------------")
mat = Arff("./impossible.arff", label_count=1)
np_mat = mat.data
data = mat[:, :-1]
labels = mat[:, -1].reshape(-1, 1)
### Make the Classifier #####
P4Class = None
for lr in range(10, 0, -1):
P4Class = PerceptronClassifier(lr=0.1*lr, deterministic=10, shuffle=False)
P4Class.fit(data, labels, standard_weight_value=None)
Accuracy = P4Class.score(data, labels)
print("Learning Rate = ", 0.1*lr)
print("Accuracy = [{:.2f}]".format(Accuracy))
print("Epochs = ", P4Class.get_epochs_trained())
w = P4Class.get_weights()
y = lambda x: (-w[0]/w[1])*x - (w[2]/w[1])
grapher = Grapher()
grapher.graph(data[:, 0], data[:, 1], labels=mat[:, -1], title="Inseparable")
grapher.add_function(y)
grapher.show("Inseparable.svg")
def our_avg_run(avg_num_of_run,filename):
dataset = load_dataset(filename)
ptraining_error = []
perceptron_error = []
for i in range(avg_num_of_run):
(training_set, testing_set) = split_dataset(dataset, PROBABILITY_TRAINING_SET)
testing_set = dataset
if IS_VERBOSE:
print("training set size: %s testing set size: %s num instances: %s" %
(len(training_set), len(testing_set), len(dataset)))
(train_x, train_y) = split_attribute_and_label(training_set)
(test_x, test_y) = split_attribute_and_label(testing_set)
p = PerceptronClassifier(ETA, THRESHOLD, UPPER_BOUND, False)
p.fit(train_x, train_y)
t_result_list = p.predict(train_x)
ptraining_error.append(calculate_error(train_y, t_result_list))
result_list = p.predict(test_x)
perceptron_error.append(calculate_error(test_y, result_list))
print(p.weights)
return sum(perceptron_error) / len(perceptron_error) , sum(ptraining_error) / len(ptraining_error)
def debug():
print("------------arff-------------------")
mat = Arff("../data/perceptron/debug/linsep2nonorigin.arff", label_count=1)
data = mat.data[:, 0:-1]
labels = mat.data[:, -1].reshape(-1, 1)
PClass = PerceptronClassifier(
lr=0.1, shuffle=False, deterministic=10, printIt=False)
PClass.fit(data, labels)
Accuracy = PClass.score(data, labels)
print("Accuray = [{:.2f}]".format(Accuracy))
print("Final Weights =", PClass.get_weights())
def evaluation():
print("--------------arf2------------------------------")
mat = Arff("../data/perceptron/evaluation/data_banknote_authentication.arff", label_count=1)
np_mat = mat.data
data = mat[:, :-1]
labels = mat[:, -1].reshape(-1, 1)
#### Make Classifier ####
P2Class = PerceptronClassifier(lr=0.1, shuffle=False, deterministic=10)
P2Class.fit(data, labels)
Accuracy = P2Class.score(data, labels)
print("Accuray = [{:.2f}]".format(Accuracy))
print("Final Weights =", P2Class.get_weights())
def runMahCode(arff, shuffle=True, determ=0, training=False, lr=.1, quiet=False):
mat = Arff(arff,label_count=1)
data = mat.data[:,0:-1]
labels = mat.data[:,-1:]
PClass = PerceptronClassifier(lr=lr,shuffle=shuffle,deterministic=determ)
Accuracy = 0.0
if (training):
X_train, y_train, X_test, y_test = PerceptronClassifier.split_training(data,labels)
PClass.fit(X_train,y_train)
Accuracy = PClass.score(X_test,y_test)
else:
PClass.fit(data,labels)
Accuracy = PClass.score(data,labels)
if not quiet:
print("Accuracy = [{:.5f}]".format(Accuracy))
print("Final Weights =",PClass.get_weights())
else:
return Accuracy
def basic():
print("-------------basic---------------")
x = np.array([[0,0,1],[1,1,1],[1,0,1],[0,1,1]])
y = np.array([[0],[1],[1],[0]])
# print(x)
# print(y)
pc = PerceptronClassifier(lr=1)
# print(pc)
print(pc.fit(x, y).score(np.array([[0,0,0],[0,1,0],[1,0,0],[1,1,0]]), np.array([[0],[0],[1],[1]])))
print(pc)
def voting():
print("--------------voting---------------------")
mat = Arff("../data/perceptron/vote.arff", label_count=1)
np_mat = mat.data
avg = []
for iteration in range(5):
print("xxxxxxxxxxx " + str(iteration) + " xxxxxxxx")
training, testing = _shuffle_split(mat.data, .3)
data = training[:, :-1]
labels = training[:, -1].reshape(-1, 1)
P5Class = PerceptronClassifier(lr=0.1, shuffle=True)
P5Class.fit(data, labels)
Accuracy = P5Class.score(data, labels)
print("Accuracy = [{:.2f}]".format(Accuracy))
print("Epochs = ", P5Class.get_epochs_trained())
tData = testing[:, :-1]
tLabels = testing[:, -1].reshape(-1, 1)
tAccuracy = P5Class.score(tData, tLabels)
print("Test Accuracy = [{:.2f}]".format(tAccuracy))
weights = P5Class.get_weights()
print(weights)
sort_weights = sorted(zip(weights, list(range(len(weights)))), key=lambda x: abs(x[0]), reverse=True)
print("sorted:\r\n", sort_weights)
scores = P5Class.getTrace().getColumns("epochScore")
print('scores', scores)
avg.append((float(scores[-2][0]) - float(scores[0][0])) / len(scores))
print('avg', avg)
grapher = Grapher()
grapher.graph(list(range(len(avg))), avg, labels=[1]*len(avg), points=False, title="Average Scores", xlabel="Iteration", ylabel="score")
grapher.show("AverageScores.svg")
from perceptron import PerceptronClassifier
from arff import Arff
import numpy as np
mat = Arff("../data/perceptron/evaluation/data_banknote_authentication.arff",
label_count=1)
data = mat.data[:, 0:-1]
labels = mat.data[:, -1:]
PClass = PerceptronClassifier(lr=0.1, shuffle=False, deterministic=10)
PClass.fit(data, labels)
Accuracy = PClass.score(data, labels)
print("Accuray = [{:.5f}]".format(Accuracy))
print("Final Weights =", PClass.get_weights())
plt.show();
# add the plot later
# # 3. Train on both sets
# Linearly Separable:
# In[9]:
data = linSep[:,:-1]
labels = linSep[:,-1:]
for lr in np.linspace(.01, 1, 10):
PClass = PerceptronClassifier(lr=lr,shuffle=True,deterministic=0)
PClass.fit(data,labels)
Accuracy = PClass.score(data,labels)
print(Accuracy)
# Because everything is centered very close to zero, it doesn't take very long for the learning rate to differentiate the two sets.
#
# We also see that the learning rate doesn't change much.
# In[10]:
data = nonLin[:,:-1]
labels = nonLin[:,-1:]
for lr in np.linspace(.01, 1, 10):
PClass = PerceptronClassifier(lr=lr,shuffle=True,deterministic=0)
import matplotlib.pyplot as plt
from utils import DatasetGenerator
from perceptron import PerceptronClassifier
import numpy as np
discr_func = 'ellipse' # choose one of ['linear', 'ellipse', 'quadratic']
data_generator = DatasetGenerator()
X, y = data_generator.generate_separable_data(num_points=57,
discr_func=discr_func)
clf = PerceptronClassifier(discr_func=discr_func)
clf.fit(X, y)
plt.xlim(-14, 14)
plt.ylim(-14, 14)
# plot data points
plt.scatter(X[:, 0], X[:, 1], s=25, c=y)
# plot separating curve
xmin, xmax = plt.xlim()
ymin, ymax = plt.ylim()
xlist = np.linspace(xmin, xmax, 100)
ylist = np.linspace(ymin, ymax, 100)
XX, YY = np.meshgrid(xlist, ylist)
xy = np.vstack([XX.ravel(), YY.ravel()]).T
Z = clf.score(xy).reshape(XX.shape)
plt.contour(XX, YY, Z, levels=[0], colors=['r'])
plt.show()
mat = Arff("votingMissingValuesReplaced.arff", label_count=1)
# mat = Arff("test2.arff", label_count=1)
data = mat.data[:, 0:-1]
labels = mat.data[:, -1].reshape(-1, 1)
X_train, y_train, X_eval, y_eval = split(data,
labels) # split data in 70/30
# PClass = PerceptronClassifier(lr=0.1, shuffle=False, deterministic=10) #initialize perceptron with settings
# PClass = PerceptronClassifier(lr=0.1, shuffle=False)
PClass = PerceptronClassifier(lr=0.1, shuffle=True)
row, col = data.shape # using all zeros initial weight, if not provided, it will do random
initial_weight = np.zeros((col + 1, 1))
PClass.fit(X_train, y_train, initial_weight) # train the perceptron
# PClass.fit(data, labels, initial_weight)
# graph(data[:,0].reshape(-1,1),data[:,1].reshape(-1,1),labels, "linearly separable") # plotting scatter plot
# index = list(range(1, PClass.num_epoch + 1)) # plotting scatter plot with each epoch's error during training
# plt.scatter(index, PClass.epoch_error)
# plt.plot(index, PClass.epoch_error)
# plt.show()
# y = lambda x: -1.3333* x # plotting the line
# y = lambda x: 0.8181 * x
# graph_function(y)
Accuracy = PClass.score(X_eval, y_eval)
# Accuracy = PClass.score(data, labels)
print("Accuracy = [{:.2f}]".format(Accuracy))
weights = PClass.get_weights()
import sys
sys.path.append('../')
from tools import arff
from perceptron import PerceptronClassifier
# arff_file = "data_banknote_authentication.arff"
# arff_file = "dataset_1.arff"
# arff_file = "dataset_2.arff"
arff_file = "voting_data.arff"
mat = arff.Arff(arff_file)
np_mat = mat.data
data = mat[:, :-1]
labels = mat[:, -1].reshape(-1, 1)
#### Make Classifier ####
P2Class = PerceptronClassifier(None, lr=0.1, shuffle=True)
X_train, y_train, X_test, y_test = P2Class._train_test_split(data, labels, 70)
P2Class.fit(X_train, y_train)
misclassifications = P2Class.misclassifications
print('Train split accuracy: {}'.format(P2Class.score(X_train, y_train)))
print('Test split accuracy: {}'.format(P2Class.score(X_test, y_test)))
print("Final Weights =", P2Class.get_weights())
for i in range(len(misclassifications)):
print('epoch: {}, {}'.format(i + 1, misclassifications[i]))
# Accuracy = P2Class.score(data,labels)
# print("Accuray = [{:.2f}]".format(Accuracy))
i, 0] > net2[i, 0]:
correct += 1
return correct / row
if __name__ == "__main__":
mat = Arff("iris.arff", label_count=1)
data = mat.data[:, 0:-1]
labels = mat.data[:, -1].reshape(-1, 1)
X_train, y_train, X_eval, y_eval = split(data, labels)
P1 = PerceptronClassifier(lr=0.1, shuffle=True) # train each perceptron
y = process_label(y_train, 0)
row, col = X_train.shape
initial_weight = np.zeros((col + 1, 1))
P1.fit(X_train, y, initial_weight)
print("P1 training accuracy = ", P1.score(X_train, y))
P2 = PerceptronClassifier(lr=0.1, shuffle=True)
y = process_label(y_train, 1)
row, col = X_train.shape
initial_weight = np.zeros((col + 1, 1))
P2.fit(X_train, y, initial_weight)
print("P2 training accuracy = ", P2.score(X_train, y))
P3 = PerceptronClassifier(lr=0.1, shuffle=True)
y = process_label(y_train, 2)
row, col = X_train.shape
initial_weight = np.zeros((col + 1, 1))
P3.fit(X_train, y, initial_weight)
print("P3 training accuracy = ", P3.score(X_train, y))
