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