def runWorker():
# import DistML.DistML as worker
if not ps.isWorker():
return
from model.logistic_regression import LogisticRegression
# TODO split data for diff worker
data = datasets.load_iris()
X = normalize(data.data[data.target != 0])
y = data.target[data.target != 0]
y[y == 1] = 0
y[y == 2] = 1
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.33,
seed=1)
clf = LogisticRegression(gradient_descent=True)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
def train():
dirname = os.path.dirname(__file__)
output_dirname = os.path.join(dirname, 'results')
try:
os.stat(output_dirname)
except:
os.mkdir(output_dirname)
file_name = 'resources/dataset_train.csv'
dirname = os.path.dirname(__file__)
file_name = os.path.join(dirname, file_name)
d = DataSet(file_name)
d.loadDataSet()
to_remove = [
d.data_set[0].index('Index'),
d.data_set[0].index('First Name'),
d.data_set[0].index('Last Name'),
d.data_set[0].index('Birthday'),
d.data_set[0].index('Best Hand'),
d.data_set[0].index('Hogwarts House'),
# Tests 7/10/18
d.data_set[0].index('Arithmancy'),
d.data_set[0].index('Defense Against the Dark Arts'),
d.data_set[0].index('Divination'),
d.data_set[0].index('Muggle Studies'),
d.data_set[0].index('History of Magic'),
d.data_set[0].index('Transfiguration'),
d.data_set[0].index('Potions'),
d.data_set[0].index('Care of Magical Creatures'),
d.data_set[0].index('Charms'),
d.data_set[0].index('Flying'),
]
X = np.array([[
d.data_set[i][j] for j in range(len(d.data_set[0]))
if j not in to_remove
] for i in range(len(d.data_set))])
features = X[0, :]
X = convert_to_float(X[1:, ])
y_col_nb = d.data_set[0].index('Hogwarts House')
y = np.array(d.extractColumn(y_col_nb)[1:])
m = MeanImputation(X)
m.train()
m.transform()
sc = Scaling(X)
sc.train()
sc.transform()
l = LogisticRegression(X=X, y=y, optimizer_params={'alpha': 0.5, 'n': 50})
l.train()
return features, l.beta
def main():
data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000)
myStupidClassifier = StupidRecognizer(data.trainingSet, data.validationSet,
data.testSet)
myPerceptronClassifier = Perceptron(data.trainingSet,
data.validationSet,
data.testSet,
learningRate=0.005,
epochs=30)
myLogisticRegressionClassifier = LogisticRegression(data.trainingSet,
data.validationSet,
data.testSet,
learningRate=0.001,
epochs=50,
error='mse')
# Train the classifiers
print("=========================")
print("Training..")
#print("\nStupid Classifier has been training..")
#myStupidClassifier.train()
#print("Done..")
#print("\nPerceptron has been training..")
#myPerceptronClassifier.train()
#print("Done..")
print("\nLogistic Regression Classifier has been training..")
myLogisticRegressionClassifier.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
#stupidPred = myStupidClassifier.evaluate()
#perceptronPred = myPerceptronClassifier.evaluate()
LogisticRegressionPred = myLogisticRegressionClassifier.evaluate()
# Report the result
print("=========================")
evaluator = Evaluator()
#print("Result of the stupid recognizer:")
# evaluator.printComparison(data.testSet, stupidPred)
#evaluator.printAccuracy(data.testSet, stupidPred)
#print("\nResult of the Perceptron recognizer:")
# evaluator.printComparison(data.testSet, perceptronPred)
#evaluator.printAccuracy(data.testSet, perceptronPred)
print("Result of the Logistic Regression:")
evaluator.printAccuracy(data.testSet, LogisticRegressionPred)
def transfer():
# Send a matrix of features
# Send an array of targets
# Send school
# Send l2, C
# Send sgd / gd + params (alpha, n, batch_size)
if request.method == 'GET':
try:
# Load the data (sent via a .py script similar to test_and_debug/test_api.py)
data = json.loads(request.json)
school = data['school']
regularization = data['regularization']
method = regularization['method']
if method is None:
C = 0
else:
C = float(regularization['C'])
optimizer = data['optimizer']
optimizer_params = data['optimizer_params']
X = np.array(data['X'])
y = np.array(data['y'])
sc = Scaling(X, school=school)
sc.train()
sc.transform()
l = LogisticRegression(sc.X,
y,
regularization=method,
C=C,
optimizer=optimizer,
optimizer_params=optimizer_params)
l.transfer_learning(school)
beta = l.beta
for b in beta:
beta[b] = list(beta[b])
return jsonify({'loss': l.loss(), 'beta': beta})
except ValueError:
return "Please enter values in the correct format: {\"school\":str, \"astronomy\":-1000<f"
def predict():
if request.method == 'GET':
try:
try:
# Data is sent via a .py script like in test_and_debug/test_api.py
data = json.loads(request.json)
school = data['school']
astronomy = float(
data['astronomy']) # -1000 < astronomy < 1000
herbology = float(data['herbology']) # -10 < herbology < 10
ancient_runes = float(
data['ancient_runes']) # 250 < ancient_runes < 750
except:
# Data is sent via an url (e.g. in Chrome)
# http://127.0.0.1:5000/predict?school=hogwarts&astronomy=-800&herbology=-2&ancient_runes=300
data = request.args
school = data.get('school')
astronomy = float(data.get('astronomy'))
herbology = float(data.get('herbology'))
ancient_runes = float(data.get('ancient_runes'))
X = np.array([[astronomy, herbology, ancient_runes]])
if school == 'hogwarts':
logreg = LogisticRegression(path_to_beta='results/beta.json')
sc = Scaling(X, path_to_scaling='results/scaling.json')
else:
logreg = LogisticRegression(
path_to_beta='results/beta_%s.json' % school)
sc = Scaling(X,
path_to_scaling='results/scaling_%s.json' %
school)
sc.transform()
prediction = logreg.predict(X_to_predict=sc.X)
return jsonify({
'house': prediction[0][0],
'probas': prediction[1][0]
})
except ValueError:
return "Please enter values in the correct format: {\"school\":str, \"astronomy\":-1000<float<1000, \"herbology\":-10<float<10, \"ancient_runes\":250<float<750}."
def __init__(self,
classifier_type,
classifier_params,
kernel_name,
kernel_params,
id_model=0):
# define kernel
self.kernel = Kernel(kernel_name, kernel_params)
self.tag_kernel = str(
id_model
) + "_kernel_" + kernel_name # kernel tag used to kernel mat saves
# define classifier
if classifier_type == "svm":
self.classifier = SVM(classifier_params)
elif classifier_type == "l_regression":
self.classifier = LogisticRegression(lambda_regularisation=0.01)
# kernel mat
self.kernel_mat_train = None
self.kernel_mat_val = None
self.kernel_mat_test = None
# load save kernel matrix
self.do_save_kernel = kernel_params["save_kernel"]
self.save_name = kernel_params["save_name"]
if kernel_params["load_kernel"]:
self.kernel_mat_train = load_object("train_" + self.tag_kernel +
"_" +
kernel_params["load_name"])
self.kernel_mat_val = load_object("val_" + self.tag_kernel + "_" +
kernel_params["load_name"])
self.kernel_mat_test = load_object("test_" + self.tag_kernel +
"_" +
kernel_params["load_name"])
if self.kernel_mat_train is None:
print("## kernel load failed: kernel not found")
else:
print("## kernel matrix loaded")
def main():
data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000)
myStupidClassifier = StupidRecognizer(data.trainingSet, data.validationSet,
data.testSet)
# parameters
learnRate = 0.005
maxEpochs = 20
#epochNumber = 30
xEpochs = []
yAccuracyPerceptron = []
yAccuracyLogistic = []
# loop for gathering data for graph plotting
for epochNumber in xrange(1, maxEpochs + 1):
myPerceptronClassifier = Perceptron(
data.trainingSet,
data.validationSet,
data.testSet,
learningRate=learnRate, #0.005,
epochs=epochNumber)
# Uncomment this to run Logistic Neuron Layer
myLRClassifier = LogisticRegression(
data.trainingSet,
data.validationSet,
data.testSet,
learningRate=learnRate, #0.005,
epochs=epochNumber #30
)
# Train the classifiers
print("=========================")
print("Training..")
print("\nStupid Classifier has been training..")
myStupidClassifier.train()
print("Done..")
print("\nPerceptron has been training..")
myPerceptronClassifier.train()
print("Done..")
print("\nLogistic Regression has been training..")
myLRClassifier.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
stupidPred = myStupidClassifier.evaluate()
perceptronPred = myPerceptronClassifier.evaluate()
lrPred = myLRClassifier.evaluate()
# Report the result
print("=========================")
evaluator = Evaluator()
print("Result of the stupid recognizer:")
#evaluator.printComparison(data.testSet, stupidPred)
evaluator.printAccuracy(data.testSet, stupidPred)
print("\nResult of the Perceptron recognizer:")
#evaluator.printComparison(data.testSet, perceptronPred)
evaluator.printAccuracy(data.testSet, perceptronPred)
print("\nResult of the Logistic Regression recognizer:")
#evaluator.printComparison(data.testSet, lrPred)
evaluator.printAccuracy(data.testSet, lrPred)
# accumulate plotting data
xEpochs.append(epochNumber)
yAccuracyPerceptron.append(
accuracy_score(data.testSet.label, perceptronPred) * 100)
yAccuracyLogistic.append(
accuracy_score(data.testSet.label, lrPred) * 100)
# === end of for loop ===
# plot the graph
plt.plot(xEpochs, yAccuracyPerceptron, marker='o', label='Perceptron')
plt.plot(xEpochs,
yAccuracyLogistic,
marker='o',
color='r',
label='Logistic Neuron')
plt.xlabel('Number of epochs')
plt.ylabel('Accuracy [%]')
plt.title(
'Performance on different epochs\n(using: testSet | learningRate: ' +
str(learnRate) + ')')
#plt.legend()
plt.legend(loc=4)
#plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, mode="expand", borderaxespad=0.)
#plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.show()
def main():
data = MNISTSeven("data/mnist_seven.csv", 3000, 1000, 1000, oneHot=True)
myStupidClassifier = StupidRecognizer(data.trainingSet, data.validationSet,
data.testSet)
myPerceptronClassifier = Perceptron(data.trainingSet,
data.validationSet,
data.testSet,
learningRate=0.005,
epochs=30)
myLRClassifier = LogisticRegression(data.trainingSet,
data.validationSet,
data.testSet,
learningRate=0.005,
epochs=30)
# Report the result #
print("=========================")
evaluator = Evaluator()
# Train the classifiers
print("=========================")
print("Training..")
# print("\nStupid Classifier has been training..")
# myStupidClassifier.train()
# print("Done..")
# print("\nPerceptron has been training..")
# myPerceptronClassifier.train()
# print("Done..")
# print("\nLogistic Regression has been training..")
# myLRClassifier.train()
# print("Done..")
myMLP = MultilayerPerceptron(data.trainingSet,
data.validationSet,
data.testSet,
learningRate=0.01,
epochs=30,
loss="ce",
outputActivation="softmax",
weight_decay=0.1)
print("\nMLP has been training..")
myMLP.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
# stupidPred = myStupidClassifier.evaluate()
# perceptronPred = myPerceptronClassifier.evaluate()
# lrPred = myLRClassifier.evaluate()
mlpPred = myMLP.evaluate(data.validationSet)
# # Report the result
# print("=========================")
# evaluator = Evaluator()
# print("Result of the stupid recognizer:")
# #evaluator.printComparison(data.testSet, stupidPred)
# evaluator.printAccuracy(data.testSet, stupidPred)
# print("\nResult of the Perceptron recognizer:")
# #evaluator.printComparison(data.testSet, perceptronPred)
# evaluator.printAccuracy(data.testSet, perceptronPred)
# print("\nResult of the Logistic Regression recognizer:")
# #evaluator.printComparison(data.testSet, lrPred)
# evaluator.printAccuracy(data.testSet, lrPred)
print("\nResult of the Multilayer Perceptron recognizer:")
#evaluator.printComparison(data.testSet, lrPred)
# evaluator.printAccuracy(data.testSet, mlpPred)
plot = PerformancePlot("MLP validation")
plot.draw_performance_epoch(myMLP.performances, myMLP.epochs)
def main():
data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=True)
myStupidClassifier = StupidRecognizer(data.trainingSet, data.validationSet,
data.testSet)
myPerceptronClassifier = Perceptron(data.trainingSet,
data.validationSet,
data.testSet,
learningRate=0.005,
epochs=30)
myLRClassifier = LogisticRegression(data.trainingSet,
data.validationSet,
data.testSet,
learningRate=0.005,
epochs=30)
myMLPClassifier = MultilayerPerceptron(data.trainingSet,
data.validationSet, data.testSet)
# Report the result #
print("=========================")
evaluator = Evaluator()
# Train the classifiers
print("=========================")
print("Training..")
#print("\nStupid Classifier has been training..")
#myStupidClassifier.train()
#print("Done..")
#print("\nPerceptron has been training..")
#myPerceptronClassifier.train()
#print("Done..")
#print("\nLogistic Regression has been training..")
#myLRClassifier.train()
#print("Done..")
print("\nMLP has been training..")
myMLPClassifier.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
#stupidPred = myStupidClassifier.evaluate()
#perceptronPred = myPerceptronClassifier.evaluate()
#lrPred = myLRClassifier.evaluate()
mlpPred = myMLPClassifier.evaluate()
# Report the result
print("=========================")
evaluator = Evaluator()
#print("Result of the stupid recognizer:")
#evaluator.printComparison(data.testSet, stupidPred)
#evaluator.printAccuracy(data.testSet, stupidPred)
#print("\nResult of the Perceptron recognizer:")
#evaluator.printComparison(data.testSet, perceptronPred)
#evaluator.printAccuracy(data.testSet, perceptronPred)
#print("\nResult of the Logistic Regression recognizer:")
#evaluator.printComparison(data.testSet, lrPred)
#evaluator.printAccuracy(data.testSet, lrPred)
print("\nResult of the MLP recognizer:")
#evaluator.printComparison(data.testSet, lrPred)
# evaluator.printAccuracy(data.testSet, mlpPred)
# Draw
plot = PerformancePlot("Logistic Regression validation")
def classify_one():
data = MNISTSeven("../data/mnist_seven.csv",
3000,
1000,
1000,
one_hot=True,
target_digit='7')
# NOTE:
# Comment out the MNISTSeven instantiation above and
# uncomment the following to work with full MNIST task
# data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000,
# one_hot=False)
# NOTE:
# Other 1-digit classifiers do not make sense now for comparison purpose
# So you should comment them out, let alone the MLP training and evaluation
# Train the classifiers #
print("=========================")
print("Training..")
# Stupid Classifier
myStupidClassifier = StupidRecognizer(data.training_set,
data.validation_set, data.test_set)
print("\nStupid Classifier has been training..")
myStupidClassifier.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
stupidPred = myStupidClassifier.evaluate()
# Perceptron
myPerceptronClassifier = Perceptron(data.training_set,
data.validation_set,
data.test_set,
learning_rate=0.005,
epochs=10)
print("\nPerceptron has been training..")
myPerceptronClassifier.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
perceptronPred = myPerceptronClassifier.evaluate()
# Logistic Regression
myLRClassifier = LogisticRegression(data.training_set,
data.validation_set,
data.test_set,
learning_rate=0.20,
epochs=30)
print("\nLogistic Regression has been training..")
myLRClassifier.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
lrPred = myLRClassifier.evaluate()
# Logistic Regression
myMLPClassifier = MultilayerPerceptron(data.training_set,
data.validation_set,
data.test_set,
learning_rate=0.30,
epochs=50)
print("\nMultilayer Perceptron has been training..")
myMLPClassifier.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
mlpPred = myMLPClassifier.evaluate()
# Report the result #
print("=========================")
evaluator = Evaluator()
print("Result of the stupid recognizer:")
# evaluator.printComparison(data.testSet, stupidPred)
evaluator.printAccuracy(data.test_set, stupidPred)
print("\nResult of the Perceptron recognizer (on test set):")
# evaluator.printComparison(data.testSet, perceptronPred)
evaluator.printAccuracy(data.test_set, perceptronPred)
print("\nResult of the Logistic Regression recognizer (on test set):")
# evaluator.printComparison(data.testSet, perceptronPred)
evaluator.printAccuracy(data.test_set, lrPred)
print("\nResult of the Multi-layer Perceptron recognizer (on test set):")
# evaluator.printComparison(data.testSet, perceptronPred)
evaluator.printAccuracy(data.test_set, mlpPred)
# Draw
plot = PerformancePlot("Logistic Regression")
plot.draw_performance_epoch(myLRClassifier.performances,
myLRClassifier.epochs)
def main():
data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000)
myStupidClassifier = StupidRecognizer(data.trainingSet, data.validationSet,
data.testSet)
mylogisticClassifier = LogisticRegression(data.trainingSet,
data.validationSet,
data.testSet,
learningRate=0.005,
epochs=30)
# Train the classifiers
print("=========================")
print("Training..")
print("\nStupid Classifier has been training..")
myStupidClassifier.train()
print("Done..")
print("\nLogsticregression has been training..")
mylogisticClassifier.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
stupidPred = myStupidClassifier.evaluate()
perceptronPred = mylogisticClassifier.evaluate()
# Report the result
print("=========================")
evaluator = Evaluator()
print("Result of the stupid recognizer:")
# evaluator.printComparison(data.testSet, stupidPred)
evaluator.printAccuracy(data.testSet, stupidPred)
print("\n Result of the Logsticregression recognizer:")
# evaluator.printComparison(data.testSet, perceptronPred)
evaluator.printAccuracy(data.testSet, perceptronPred)
for i in range(2):
for j in range(2):
learningRate = (i + 1) * 0.002
epochs = (j + 1) * 20
mylogisticClassifier = LogisticRegression(
data.trainingSet,
data.validationSet,
data.testSet,
learningRate=learningRate,
epochs=epochs)
# Train the classifiers
print("=========================")
print("learning rate :" + str(learningRate))
print("epoch :" + str(epochs))
print("Training..")
print("\nLogsticregression has been training..")
mylogisticClassifier.train()
print("Done..")
# Do the recognizer
# Explicitly specify the test set to be evaluated
perceptronPred = mylogisticClassifier.evaluate()
# Report the result
print("=========================")
evaluator = Evaluator()
print("\n Result of the Logsticregression recognizer:")
# evaluator.printComparison(data.testSet, perceptronPred)
evaluator.printAccuracy(data.testSet, perceptronPred)
class Model:
def __init__(self,
classifier_type,
classifier_params,
kernel_name,
kernel_params,
id_model=0):
# define kernel
self.kernel = Kernel(kernel_name, kernel_params)
self.tag_kernel = str(
id_model
) + "_kernel_" + kernel_name # kernel tag used to kernel mat saves
# define classifier
if classifier_type == "svm":
self.classifier = SVM(classifier_params)
elif classifier_type == "l_regression":
self.classifier = LogisticRegression(lambda_regularisation=0.01)
# kernel mat
self.kernel_mat_train = None
self.kernel_mat_val = None
self.kernel_mat_test = None
# load save kernel matrix
self.do_save_kernel = kernel_params["save_kernel"]
self.save_name = kernel_params["save_name"]
if kernel_params["load_kernel"]:
self.kernel_mat_train = load_object("train_" + self.tag_kernel +
"_" +
kernel_params["load_name"])
self.kernel_mat_val = load_object("val_" + self.tag_kernel + "_" +
kernel_params["load_name"])
self.kernel_mat_test = load_object("test_" + self.tag_kernel +
"_" +
kernel_params["load_name"])
if self.kernel_mat_train is None:
print("## kernel load failed: kernel not found")
else:
print("## kernel matrix loaded")
def fit(self, X, y, X_train_repres=None):
"""
fit the model
use X_train_repres if filled as it is faster
"""
self.X_train = X
self.deal_with_kernel_mat_train(X_train_repres)
self.classifier.fit(self.kernel_mat_train, y)
def predict(self, X_test, X_test_repres=None, X_train_repres=None):
"""
predict from X_test
for spectrum and mismatch only
X_test_repres : representation of X_test in RKHS
X_train_repres : representation of X_train in RKHS
use X_train_repres, X_test_repres if filled as it is faster
"""
self.deal_with_kernel_mat_test(X_test, X_test_repres, X_train_repres)
return self.classifier.predict(self.kernel_mat_test)
def predict_val(self, X_val, X_val_repres=None, X_train_repres=None):
"""
predict from X_test
for spectrum and mismatch only
X_val_repres : representation of X_val in RKHS
X_train_repres : representation of X_train in RKHS
use X_train_repres, X_test_repres if filled as it is faster
"""
self.deal_with_kernel_mat_val(X_val, X_val_repres, X_train_repres)
return self.classifier.predict(self.kernel_mat_val)
def predict_train(self):
"""
to compute the train loss
"""
return self.classifier.predict(self.kernel_mat_train)
## functions to calculate or load Kernel matrix and save it if needed
def deal_with_kernel_mat_train(self, X_train_repres):
"""
compute kernel matrix and save it if do_save_kernel
"""
if self.kernel_mat_train is None:
# compute kernel
self.kernel_mat_train = self.kernel.get_kernel_mat(
self.X_train, self.X_train, X_train_repres=X_train_repres)
# save it or not
dump_object(self.kernel_mat_train,
"train_" + self.tag_kernel + "_" + self.save_name,
self.do_save_kernel)
def deal_with_kernel_mat_test(self,
X_test,
X_test_repres=None,
X_train_repres=None):
"""
compute kernel matrix and save it if do_save_kernel
"""
if self.kernel_mat_test is None:
# compute kernel
self.kernel_mat_test = self.kernel.get_kernel_mat(
X_test,
self.X_train,
test=True,
X_test_repres=X_test_repres,
X_train_repres=X_train_repres)
# save it or not
dump_object(self.kernel_mat_test,
"test_" + self.tag_kernel + "_" + self.save_name,
self.do_save_kernel)
def deal_with_kernel_mat_val(self,
X_val,
X_val_repres,
X_train_repres=None):
"""
compute kernel matrix and save it if do_save_kernel
"""
if self.kernel_mat_val is None:
# compute kernel
self.kernel_mat_val = self.kernel.get_kernel_mat(
X_val,
self.X_train,
test=True,
X_test_repres=X_val_repres,
X_train_repres=X_train_repres)
# save it or not
dump_object(self.kernel_mat_val,
"val_" + self.tag_kernel + "_" + self.save_name,
self.do_save_kernel)
def set_c_svm(self, c_svm):
"""
set c_svm in SVM classifier
"""
self.classifier.C = c_svm
return self