def solve_logical_examples():
#create arrays (0,0), (0,1), (1,0), (1,1)
net_input = [na.array((x1, x2)) for x1 in range(2) for x2 in range(2)]
# create expected output
net_output = [-1, 1, 1, 1]
a, b = dual_perceptron(net_input, net_output)
print "dual form: ", a, b
c, d, k = perceptron(net_input, net_output, .5)
print "perceptron: ", c, d
print "printing perceptron output: "
m = -c[0] / c[1]
d = -d / c[1]
plot_line(m, d, (-.5, 1.5), (-.5, 1.5))
#solve for the weight vector
sum_j = na.zeros(2, na.Float32)
for j in range(len(net_input)):
sum_j += a[j] * net_output[j] * net_input[j]
print "sum_j: ", sum_j
#solve for x2 (which is sum_j[1]); assume 2-d
b = -b / sum_j[1]
co_x1 = -sum_j[0] / sum_j[1]
print "printing dual form perceptron output: "
plot_line(co_x1, b, (-.5, 1.5), (-.5, 1.5))
def main():
start = time.clock()
classifier = perceptron()
# classifier = differentiable_perceptron.diff_perceptron()
trainingData = readDataFile("digitdata/trainingimages", 5000)
trainingLabel = readLabelFile("digitdata/traininglabels", 5000)
testData = readDataFile("digitdata/testimages", 1000)
testLabel = readLabelFile("digitdata/testlabels", 1000)
# change the following settings like number of epochs,
# the ordering of training(random vs natural order), etc.
classifier.setEpoch(100)
classifier.setDecay(1000)
classifier.setRandom(True)
classifier.setRandomize(True)
# ready for training
print("Ready for training.")
classifier.train(trainingData, trainingLabel)
print("Training is done.")
accuracy, confusion_matrix = classifier.classify(testData, testLabel)
print("classification is done.")
print("-----------------------------------------------------------")
print("The accuracy is: ", accuracy)
print("Execution time is: %fs" % (time.clock() - start))
print(confusion_matrix)
classifier.training_curve_plot()
def solve_logical_examples():
#create arrays (0,0), (0,1), (1,0), (1,1)
net_input = [na.array((x1,x2)) for x1 in range(2) for x2 in range(2)]
# create expected output
net_output = [-1,1,1,1]
a,b = dual_perceptron(net_input, net_output)
print "dual form: ", a, b
c,d,k = perceptron(net_input, net_output, .5)
print "perceptron: ", c, d
print "printing perceptron output: "
m = -c[0] / c[1]
d = -d / c[1]
plot_line(m, d, (-.5, 1.5), (-.5, 1.5))
#solve for the weight vector
sum_j = na.zeros(2, na.Float32)
for j in range(len(net_input)):
sum_j += a[j] * net_output[j] * net_input[j]
print "sum_j: ", sum_j
#solve for x2 (which is sum_j[1]); assume 2-d
b = -b / sum_j[1]
co_x1 = -sum_j[0] / sum_j[1]
print "printing dual form perceptron output: "
plot_line(co_x1, b, (-.5, 1.5), (-.5, 1.5))
def Q4():
for m in M:
X = np.random.multivariate_normal(mean, cov, m)
x1, y1 = X.T
X = np.hstack((X, np.ones((m, 1))))
y = np.sign(np.dot(X, w_t))
while (len(np.argwhere(y == 1)) == 0) or (len(np.argwhere(y == -1))
== 0):
X = np.random.multivariate_normal(mean, cov, m)
x1, y1 = X.T
X = np.hstack((X, np.ones((m, 1))))
y = np.sign(np.dot(X, w_t))
svmcls = SVC(C=1e10, kernel='linear')
p = perceptron()
svmcls.fit(X, y)
w_p = p.fit(X, y)
plt.scatter(x1, y1, c=y)
plt.plot(u_0, interval(w_t, u_0), label='true')
plt.plot(u_0, interval(w_p, u_0), label='perceptron')
plt.plot(u_0, interval(np.squeeze(svmcls.coef_), u_0), label='svm')
plt.title('SVM and perceptron as fuction of m={}'.format(m))
plt.legend()
plt.savefig('m{}'.format(m))
plt.show()
def pla(a):
data_test, data_train, labels_test, labels_train = partitioner_l(a, 40)
labels_test = binary_class(labels_test)
labels_train = binary_class(labels_train)
w = perceptron(data_train, labels_train)
p_train = check_accuracy(data_train, labels_train, w)
p_test = check_accuracy(data_test, labels_test, w)
print("TRAINING ACCURACY: " + str(p_train))
print("TESTING ACCURACY: " + str(p_test))
show_line(data_train, labels_train)
def CIFAR10_predict(I, CIFAR10_data):
if print_log:
print "==> START PREDICTION OF NETWORK ", CIFAR10_data["name"], "\n"
if print_log:
print "STEP 1 | CONV + RELU + MP"
# CONVOLUTION 1
image_out = convolution(I, CIFAR10_data["WEIGHTS_CONV_1"],
CIFAR10_data["BIAS_CONV_1"])
# RELU
image_out = relu(image_out)
# MAX_POOL 1
image_out = max_pool(image_out, CIFAR10_data["SIZE_STRIDE_MAX_POOL_1"][0],
CIFAR10_data["SIZE_STRIDE_MAX_POOL_1"][2])
if print_log:
print "STEP 2 | CONV + RELU + MP"
# CONVOLUTION 2
image_out = convolution(image_out, CIFAR10_data["WEIGHTS_CONV_2"],
CIFAR10_data["BIAS_CONV_2"])
# RELU
image_out = relu(image_out)
# MAX_POOL 2
image_out = max_pool(image_out, CIFAR10_data["SIZE_STRIDE_MAX_POOL_2"][0],
CIFAR10_data["SIZE_STRIDE_MAX_POOL_2"][2])
if print_log:
print "STEP 3 | CONV + RELU + MP"
# CONVOLUTION 3
image_out = convolution(image_out, CIFAR10_data["WEIGHTS_CONV_3"],
CIFAR10_data["BIAS_CONV_3"])
# RELU
image_out = relu(image_out)
# MAX_POOL 3
image_out = max_pool(image_out, CIFAR10_data["SIZE_STRIDE_MAX_POOL_3"][0],
CIFAR10_data["SIZE_STRIDE_MAX_POOL_3"][2])
if print_log:
print "RESHAPE"
# RESHAPE
vector = reshape(image_out)
if print_log:
print "PERCEPTRON\n"
prob = perceptron(vector, CIFAR10_data["PERCEPTRON_WEIGHT"],
CIFAR10_data["PERCEPTRON_BIAS"])
return prob
def main():
p = perceptron()
p.baias = 1
for i in range(50):
p.train(numpy.array([0, 0]), 1)
p.train(numpy.array([1, 0]), 0)
p.train(numpy.array([0, 1]), 0)
p.train(numpy.array([1, 1]), 0)
print(p.calculate([0, 0]))
print(p.calculate([1, 0]))
print(p.calculate([0, 1]))
print(p.calculate([1, 1]))
print("weights -> ", p.weight)
print("baias -> ", p.baias)
def solve_apples_bananas():
print "generating points"
pts = gen_random_points(100)
bananas = [pt[0] for pt in pts if pt[1] < 0]
apples = [pt[0] for pt in pts if pt[1] > 0]
plot_bananas(bananas, apples, 'points.png')
print "running perceptron"
cat = na.array([pt[1] for pt in pts])
pts = na.array([pt[0] for pt in pts])
w, b, k = perceptron(pts, cat, .3, 0)
print "perceptron output: ", w, b, k
m = -w[0] / w[1]
b = -b / w[1]
plot_bananas(bananas, apples, 'line.png', m, b)
def solve_apples_bananas():
print "generating points"
pts = gen_random_points(100)
bananas = [pt[0] for pt in pts if pt[1] < 0]
apples = [pt[0] for pt in pts if pt[1] > 0]
plot_bananas(bananas, apples, 'points.png')
print "running perceptron"
cat = na.array([pt[1] for pt in pts])
pts = na.array([pt[0] for pt in pts])
w, b, k = perceptron(pts, cat, .3, 0)
print "perceptron output: ", w, b, k
m = -w[0] / w[1]
b = -b / w[1]
plot_bananas(bananas, apples, 'line.png', m, b)
def question3(self):
if self.count % 5 == 0:
self.text.delete(1.0, END)
self.count += 1
self.text.insert(
END, "Test case " + str(self.count) + " - Requirement 2:\n" + "\n")
training_data, training_class = self.read_training_data_type2(
self.data)
test_data, test_class = self.gen_test_data2()
error1 = perceptron(training_data, training_class, test_data,
test_class)
error2 = single_layer_neural_network(training_data, training_class,
test_data, test_class)
self.text.insert(END, "Perceptron's error rate " + str(error1) + "\n")
self.text.insert(END,
"Neural network's error rate " + str(error2) + "\n")
self.text.insert(END, "------------\n")
print("---------")
def initNER(self):
# ori_train_set = self.load_sentences(self.training_set)
# print ori_train_set
# self.get_dictionary(self.training_set)
# line_eg = "Sheep NNP I-NP O"
# feature generator got from training data
# fea_vector_eg = self.fea_generator.feature_vector_gen(line_eg,'O')
self.sentences = self.load_sentences(self.training_set)
self.test_sentences = self.load_sentences(self.dev_set)
self.fea_generator = fea_gen(self.training_set, self.unk_threshold,
self.sentences, self.test_sentences)
# token_eg = Token(line_eg)
self.netags_list = list(self.fea_generator.netags.keys())
print self.netags_list
self.all_features_train_dict = self.fea_generator.compute_feature_matrix(
self.sentences)
self.all_features_test_dict = self.fea_generator.compute_feature_matrix(
self.test_sentences)
print self.fea_generator.feature_name_list
ran_n = random.randint(1, 1000)
output_name1 = 'all_feature_dict_' + str(
ran_n) + self.training_set + '.p'
output_name2 = 'all_feature_dict_' + str(ran_n) + self.dev_set + '.p'
with open(output_name1, 'wb') as fp:
pickle.dump(self.all_features_train_dict, fp)
with open(output_name2, 'wb') as fp2:
pickle.dump(self.all_features_test_dict, fp2)
# do perceptron learn
print("begin training")
model = perceptron(self.fea_generator, self.sentences,
self.test_sentences, output_name1, output_name2)
learned_w = model.uni_NEtagging()
# print ("learned weights:")
# # print learned_w
# np.savetxt('learned_weights',learned_w,delimiter=',')
print("begin inference")
model.perceptron_predict()
model.result_report()
return None
def question2(self):
if self.count % 5 == 0:
self.text.delete(1.0, END)
self.count += 1
# print("Test case ", self.count)
training_data, training_class = self.read_training_data_type1(
self.data)
test_data, test_class = self.gen_test_data()
# print(len(test_data))
error1 = perceptron(training_data, training_class, test_data,
test_class)
error2 = logistic_algorithm(training_data, training_class, test_data,
test_class)
self.text.insert(
END,
"Test case " + str(self.count) + " - Requirement 1:\n " + "\n")
self.text.insert(END, "Perceptron's error rate" + str(error1) + "\n")
self.text.insert(
END, "Logistic function's error rate " + str(error2) + "\n")
self.text.insert(END, "------------\n")
print("---------")
def Q5():
errs1 = np.zeros((5, 1))
errs2 = np.zeros((5, 1))
for k, m in enumerate(M):
for i in range(500):
# ****************** GENERATING DATA ****************** #
X = np.random.multivariate_normal(mean, cov, m)
y = true_h(X)
while (len(np.argwhere(y == 1)) == 0) or (len(np.argwhere(y == -1))
== 0):
X = np.random.multivariate_normal(mean, cov, m)
y = true_h(X)
# ****************** CLASSIFIERS ****************** #
# SVM
svmcls = SVC(C=1e10, kernel='linear')
svmcls.fit(X, y)
# Perceptron
p = perceptron()
X = np.hstack((X, np.ones((m, 1))))
p.fit(X, y)
# ****************** GENERATING TEST ****************** #
test_points = np.random.multivariate_normal(mean, cov, TEST_SIZE)
test_labels = true_h(test_points)
# ****************** MAKE PREDICTIONS ****************** #
svms_y_hat = svmcls.predict(test_points)
test_points = np.hstack((test_points, np.ones((TEST_SIZE, 1))))
ps_y_hat = p.predict(test_points)
# ****************** GET ACCURACY ****************** #
errs1[k] += get_accuracy(test_labels, svms_y_hat)
errs2[k] += get_accuracy(test_labels, ps_y_hat)
plt.plot(M, np.true_divide(errs1, 500), label='SVM')
plt.plot(M, np.true_divide(errs2, 500), label="Perceptron")
plt.title('Mean accuracy as function of m')
plt.xlabel('samples(m)')
plt.ylabel('Mean Accuracy')
plt.legend()
plt.savefig('Q5')
plt.show()
# variables init
n = int(content[0]) # no of perceptrons
variablecount = int(content[1]) # no of externalinputs
content = content[2:]
content = [x.split(" ") for x in content]
initwt = 1 # initialweights of all
network = [] # all perceptrons
intermediates = [] # inputs + intermediate perceptron outputs
# init intermediate
for i in range(variablecount+n):
intermediates.append(0.0)
# init network
for i in range(n):
p = perceptron(initwt)
network.append(p)
# attach inputs to perceptron
for i in range(n):
for j in content[i]:
if j[0] == '_':
network[i].inputs.append(int(j[1]))
else:
network[i].inputs.append(int(j[0])+variablecount)
# train network
with open('train.txt') as trainingfile:
content = trainingfile.readlines()
content = [x.strip().split("\t") for x in content]
input = [x[0].split(' ') for x in content]
help='test_num for knn')
if __name__ == '__main__':
args = parser.parse_args()
if args.exp_name == 'knn':
args.split = 'both'
# load data
if args.dataset == 'mnist':
data = Mnist(args)
else:
data = Mnist(args)
# perform experiment
if args.exp_name == 'perceptron':
X, y = extract_1_5(data.X, data.y)
# normalize to [-1, 1]
lower_bound = -1 * np.ones(X.shape)
X = lower_bound + 2 * (X / (X.max() - X.min()))
perceptron(X, y, args)
elif args.exp_name == 'knn':
acc = [0 for _ in range(args.k_range)]
# perform knn and "k" search
for i in range(args.k_range):
acc[i] = knn(data, args)
args.k = args.k + 1
draw_search(acc, args)
from perceptron import *
import matplotlib.pyplot as plt
feature = np.array([
[3,3],
[4,3],
[1,1],
])
label = np.array([
[1],
[1],
[-1],
])
a = perceptron(feature, label)
a.train()
test_point = np.array([
[+5,+5],
[-1,-1]])
print a.prediction(test_point)
w,b = a.get_wandb()
#########plot##############################
def plot_function(samples, labels, w, b):
index = 0
for i in samples:
if labels[index] == 1:
def perceptron(self):
self.rango_a = self.val_ra.get()
self.epocas_max = self.val_epocas_max.get()
self.ptron = perceptron(self)
self.convergio = self.ptron.proceso()
else:
cat2.append(row[:-1])
target.append(row[-1])
c = list(zip(input, target))
shuffle(c)
input = [x[0] for x in c]
target = [x[1] for x in c]
input = np.array(input, float)
target = np.array(target, float)
targetp = np.array([x * 2 - 1 for x in target])
w = lms(input, target, args.eta, 100000)
wp = perceptron(input, targetp, args.eta, 100000)
validation = []
with open('classdataVal.csv', newline='') as f:
r = csv.reader(f)
for row in r:
if row:
validation.append(row)
validation = np.transpose(np.array(validation, float))
cat1 = np.transpose(np.array(cat1, float))
cat2 = np.transpose(np.array(cat2, float))
plt.scatter(cat1[0],
cat1[1],
c="b",
marker=".",
description=
'Clasificación de Iris setosa usando el algoritmo del perceptron.')
parser.add_argument('--eta',
type=float,
help='Tasa de aprendizaje. Por defecto es 0.05',
default=0.05)
args = parser.parse_args()
input = []
target = []
with open('bezdekIris.data', newline='') as f:
r = csv.reader(f)
for row in r:
if row:
input.append([1] + row[:-1])
if row[-1] == 'Iris-setosa':
target.append(1)
else:
target.append(-1)
c = list(zip(input, target))
shuffle(c)
input = [x[0] for x in c]
target = [x[1] for x in c]
input = np.array(input, float)
target = np.array(target)
w = perceptron(input, target, args.eta, 15000)
print("Pesos finales: ", w)
from perceptron import *
import numpy as np
if __name__ == '__main__':
print("Homework 1a")
X = np.array([[-1, -1], [1, 0], [-1, 1.5]])
y = np.array([1, -1, 1])
perceptron(X, y, 2)
print("Homework 1b")
X = np.array([[-1, 1.5], [-1, -1], [1, 0]])
y = np.array([1, 1, -1])
perceptron(X, y, 2)
print("Homework 1c")
X = np.array([[-1, -1], [1, 0], [-1, 10]])
y = np.array([1, -1, 1])
perceptron(X, y, 2)
print("Homework 1d")
X = np.array([[1, 0], [-1, 10], [-1, -1]])
y = np.array([-1, 1, 1])
perceptron(X, y, 2)
print("Homework 2")
X = np.array([[-4, 2], [-2, 1], [-1, -1], [2, 2], [1, -2]])
y = np.array([1, 1, -1, -1, -1])
perceptron(X, y, 2)
