def train(self, verbose=True): """Train the Multi-layer Perceptrons Parameters ---------- verbose : boolean Print logging messages with validation accuracy if verbose is True. """ #### #evalutation is copy paste from Run.py ... evaluator = Evaluator() if verbose == True: print "epoch-nr. & Result of the Multi-layer Perceptron recognizer (on test set):" for epoch in range(self.epochs): self._train_one_epoch(); if verbose == True: print epoch evaluator.printAccuracy(self.test_set, self.evaluate()) pass
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000) myPerceptronClassifier = Perceptron(data.trainingSet, data.validationSet, data.testSet, learningRate=0.01, epochs=10) # Train the classifiers print("=========================") print("Training..") print("\nTraining the Perceptron..") myPerceptronClassifier.train() print("Done..") # Do the recognizer perceptronPred = myPerceptronClassifier.evaluate() # Report the result print("=========================") evaluator = Evaluator() print("\nResult of the Perceptron recognizer:") #evaluator.printComparison(data.testSet, perceptronPred) evaluator.printAccuracy(data.testSet, perceptronPred)
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, epochs=10) # Train the classifiers print("=========================") print("Training..") myStupidClassifier.train() myPerceptronClassifier.train() # Do the recognizer stupidPred = myStupidClassifier.evaluate() perceptronPred = myPerceptronClassifier.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)
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=False) myMLP = MultilayerPerceptron(data.trainingSet, data.validationSet, data.testSet, learningRate=0.005, epochs=30) # myMLP.fortest() myMLP.train() # Do the recognizer # Explicitly specify the test set to be evaluated MLPPred = myMLP.evaluate() # Report the result print("=========================") evaluator = Evaluator() print("\nResult of the MLP:") evaluator.printAccuracy(data.testSet, MLPPred) # Draw plot = PerformancePlot("MLP validation") plot.draw_performance_epoch(myMLP.performances, myMLP.epochs)
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000) myPerceptronClassifier = Perceptron(data.trainingSet, data.validationSet, data.testSet, learningRate=0.01, epochs=10) # Train the classifiers print("=========================") print("Training..") print("\nTraining the Perceptron..") myPerceptronClassifier.train() print("Done..") # Do the recognizer perceptronPred = myPerceptronClassifier.evaluate() # Report the result print("=========================") evaluator = Evaluator() print("\nResult of the Perceptron recognizer:") #evaluator.printComparison(data.testSet, perceptronPred) evaluator.printAccuracy(data.testSet, perceptronPred)
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 main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000) # myStupidClassifier = StupidRecognizer(data.trainingSet, # data.validationSet, # data.testSet) # Uncomment this to make your Perceptron evaluated # myPerceptronClassifier = Perceptron(data.trainingSet, # data.validationSet, # data.testSet, # learningRate=0.005, # epochs=30) myNeuralNetwork = LogisticRegression(data.trainingSet, data.validationSet, data.testSet) # Train the classifiers print("=========================") print("Training..") # print("\nStupid Classifier has been training..") # myStupidClassifier.train() # print("Done..") print("\nNeural Network training..") #myPerceptronClassifier.train() myNeuralNetwork.train() print("Done..") # Do the recognizer # Explicitly specify the test set to be evaluated # stupidPred = myStupidClassifier.evaluate() # Uncomment this to make your Perceptron evaluated # perceptronPred = myPerceptronClassifier.evaluate() neuralPred = myNeuralNetwork.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) # Uncomment this to make your Perceptron evaluated # evaluator.printAccuracy(data.testSet, perceptronPred) evaluator.printAccuracy(data.testSet, neuralPred) # evaluator.printConfusionMatrix(data.testSet, perceptronPred) evaluator.printConfusionMatrix(data.testSet, neuralPred)
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) myLRClassifier = 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("\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)
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000) myStupidClassifier = StupidRecognizer(data.trainingSet, data.validationSet, data.testSet) # Uncomment this to make your Perceptron evaluated myPerceptronClassifier = Perceptron( data.trainingSet, data.validationSet, data.testSet, learningRate=1.0, #0.005, epochs=1 #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..") # Do the recognizer # Explicitly specify the test set to be evaluated stupidPred = myStupidClassifier.evaluate() # Uncomment this to make your Perceptron evaluated perceptronPred = myPerceptronClassifier.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) # Uncomment this to make your Perceptron evaluated evaluator.printAccuracy(data.testSet, perceptronPred) evaluator.printConfusionMatrix(data.testSet, perceptronPred) evaluator.printClassificationResult(data.testSet, perceptronPred, ['class 0', 'class 1']) #target_names)
def main(): # ------------ NOTE -------------- # oneHot = False, as the framwork provided implements binary one-hot encoding (is it a 7 = True/False) # Our targets are one-of-k encoded (e.g. 1= (0,1,0,0,0,0,0,0,0)). Network predicts the exact number on the picture not just 7 = True/False data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=False) myMLPClassifier = MultilayerPerceptron( data.trainingSet, data.validationSet, data.testSet, hiddenLayerSizes=[ 65, 30 ], # size of hidden layers, input and output layers sizes are constant learningRate=0.028, # learning rate epochs=50) # epochs # Train the classifiers print("=========================") print("Training..") print("\nMLP 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:") print("\nResult of the MLP:") #evaluator.printComparison(data.testSet, lrPred) evaluator.printAccuracy(data.testSet, mlpPred) # Draw plot = PerformancePlot("MLP validation") plot.draw_performance_epoch(myMLPClassifier.performances, myMLPClassifier.epochs)
def classify_all(): data = MNISTSeven("../data/mnist_seven.csv", 4000, 500, 500, one_hot=False) mlp = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, output_task="classify_all", cost='crossentropy', output_activation='softmax', learning_rate=0.30, epochs=50) mlp.train() pred = mlp.evaluate() evaluator = Evaluator() evaluator.printAccuracy(data.test_set, pred)
def classify_all(): data = MNISTSeven("../data/mnist_seven.csv", 4000, 500, 500, one_hot=False) mlp = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, output_task="classify_all", cost='crossentropy', output_activation='softmax', learning_rate=0.30, epochs=50) mlp.train() pred = mlp.evaluate() evaluator = Evaluator() evaluator.printAccuracy(data.test_set, pred)
def trainAndEvaluateClassifier(classifier, test_set, verbose=False, graph=False): # Train print("Train " + classifier.__class__.__name__ + "..") classifier.train(verbose=verbose, graph=graph) print("Done..") print("") # Evaluate print("Evaluate..") pred = classifier.evaluate() print("Done..") print("") # Results print("Result:") evaluator = Evaluator() # evaluator.printComparison(data.test_set, stupidPred) evaluator.printAccuracy(test_set, pred) print("")
def train(self, verbose=True): """Train the perceptron with the perceptron learning algorithm. Parameters ---------- verbose : boolean Print logging messages with validation accuracy if verbose is True. """ evaluator = Evaluator() for i in range(self.epochs): for input, label in zip(self.trainingSet.input, self.trainingSet.label): input = self.augmentedInput(input) output = 1 if self.fire(input) else 0 error = label - output self.updateWeights(input, error) if verbose: print("Epoch: " + str(i+1)) evaluator.printAccuracy(self.validationSet, self.evaluate(self.validationSet))
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=False) myMLPClassifier = MultilayerPerceptron(data.trainingSet, data.validationSet, data.testSet, learningRate=0.05, epochs=20) #no more changes after 20 epochs #Removed old stuff # Report the result # print("=========================") evaluator = Evaluator() # Train the classifiers print("=========================") print("Training..") print("\nMLP 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("\nResult of the MLP recognizer:") #evaluator.printComparison(data.testSet, lrPred) evaluator.printAccuracy(data.testSet, mlpPred) # Draw plot = PerformancePlot("MLP validation") plot.draw_performance_epoch(myMLPClassifier.performances, myMLPClassifier.epochs)
def train(self, verbose=True): """Train the perceptron with the perceptron learning algorithm. Parameters ---------- verbose : boolean Print logging messages with validation accuracy if verbose is True. """ evaluator = Evaluator() for i in range(self.epochs): if verbose: logging.debug("Epoch: " + str(i)) evaluator.printAccuracy(self.validationSet, self.evaluate(self.validationSet)) for j in range(len(self.trainingSet.input)): input = self.trainingSet.input[j] label = self.trainingSet.label[j] predictedClass = self.classify(input) error = label - predictedClass self.updateWeights(input, error)
def main(): # ------------ NOTE -------------- # oneHot does not work: It makes not sense to have binary labeled data (targetDigit or notTargetDigit), # but having a MLP with 10 output nodes and softmax function. It needs to be trained with digit labels, not binary ones! data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=False) myMLPClassifier = MultilayerPerceptron(data.trainingSet, data.validationSet, data.testSet, hiddenLayerSizes=[65,30], # size of hidden layers, input and output layers sizes are constant learningRate=0.028, # learning rate epochs=50) # epochs # Train the classifiers print("=========================") print("Training..") print("\nMLP 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:") print("\nResult of the MLP:") #evaluator.printComparison(data.testSet, lrPred) evaluator.printAccuracy(data.testSet, mlpPred) # Draw plot = PerformancePlot("MLP validation") plot.draw_performance_epoch(myMLPClassifier.performances, myMLPClassifier.epochs)
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=False) myMLPClassifier = MultilayerPerceptron(data.trainingSet, data.validationSet, data.testSet, loss='ce', layers=[128, 150], learningRate=0.005, epochs=10) # Report the result # # Train the classifiers print("=========================") print("Training..") 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("\nResult of the Multi Layer Perceptron recognizer:") evaluator.printComparison(data.testSet, mlpPred) evaluator.printAccuracy(data.testSet, mlpPred) # Draw plot = PerformancePlot("Multi Layer Perceptron validation") plot.draw_performance_epoch(myMLPClassifier.performances, myMLPClassifier.epochs)
def train(self, verbose=True): """Train the Multi-layer Perceptrons Parameters ---------- verbose : boolean Print logging messages with validation accuracy if verbose is True. """ evaluator = Evaluator() accuracies = [] for epoch in range(self.epochs): print("Training Epoch", epoch) for i, input, label in zip(range(len(self.training_set.input)), self.training_set.input, self.training_set.label): vec = np.zeros(self.layers[-1].n_out) vec[label] = 1 out = self._feed_forward(input) error = self._compute_error(vec) for layer, nextLayer in zip(self.layers[:-1], self.layers[1:]): weights = nextLayer.weights[1:].T layer.computeDerivative(error, weights) error = layer.deltas for layer in self.layers: layer.updateWeights(self.learning_rate) if verbose: evaluator.printAccuracy(self.test_set, self.evaluate()) accuracies.append( evaluator.getAccuracy(self.test_set, self.evaluate())) return accuracies
def main(): # 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.005, # 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() # Multi-layer Perceptron myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, learning_rate=0.05, epochs=30) print("\nMulti-layer 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("Multi-layer Perceptron on MNIST task") plot.draw_performance_epoch(myMLPClassifier.performances, myMLPClassifier.epochs)
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) myLRClassifier = LogisticRegression(data.trainingSet, data.validationSet, data.testSet, learningRate=0.005, epochs=30) MlpClassifier = MultilayerPerceptron(data.trainingSet, data.validationSet, data.testSet, learningRate=0.1, epochs = 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..") print("\nStarting Backpropagation MLP training...") MlpClassifier.train() print("Done..") # Do the recognizer # Explicitly specify the test set to be evaluated stupidPred = myStupidClassifier.evaluate() # perceptronPred = myPerceptronClassifier.evaluate() # lrPred = myLRClassifier.evaluate() mlpPred = MlpClassifier.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, perceptronPred) # evaluator.printAccuracy(data.testSet, lrPred) print("\nResult of the MLP recognizer:") # evaluator.printComparison(data.testSet, perceptronPred) evaluator.printAccuracy(data.testSet, mlpPred) # eval.printConfusionMatrix(data.testSet, pred) # eval.printClassificationResult(data.testSet, pred, target_names) print("=========================")
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=False) # myLRClassifier = LogisticRegression(data.trainingSet, # data.validationSet, # data.testSet, # learningRate=0.005, # epochs=30) hidden_layers = [ LogisticLayer(128, 32, isClassifierLayer=True) for layer in range(1) ] mlp = MultilayerPerceptron(data.trainingSet, data.validationSet, data.testSet, hidden_layers, learningRate=0.005, epochs=30) # Train the classifiers #print("=========================") print("Training...") # print("\nLogistic Regression has been training..") # myLRClassifier.train() # print("Done..") print("Training MLP...") mlp.train() print("Done.") # Do the recognizer # Explicitly specify the test set to be evaluated # stupidPred = myStupidClassifier.evaluate() # perceptronPred = myPerceptronClassifier.evaluate() # lrPred = myLRClassifier.evaluate() mlpPred = mlp.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("Result of the MLP recognizer:") evaluator.printComparison(data.testSet, mlpPred) evaluator.printAccuracy(data.testSet, mlpPred) # Draw plot = PerformancePlot("Logistic Regression validation") # plot.draw_performance_epoch(myLRClassifier.performances, # myLRClassifier.epochs) plot.draw_performance_epoch(mlp.performances, mlp.epochs)
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=False) data.trainingSet.input = np.insert(data.trainingSet.input, 0, 1, axis=1) data.validationSet.input = np.insert(data.validationSet.input, 0, 1, axis=1) data.testSet.input = np.insert(data.testSet.input, 0, 1, axis=1) 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) MLPClassifier = MultilayerPerceptron(data.trainingSet, data.validationSet, data.testSet, netStruct = [800, 100, 10], actFunc = ['relu', 'relu', 'softmax'], dropout = True, loss = 'crossentropy', learningRate = 0.001, epochs = 300) # 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..") MLPClassifier.train() print("Done..") # Do the recognizer # Explicitly specify the test set to be evaluated # stupidPred = myStupidClassifier.evaluate() # perceptronPred = myPerceptronClassifier.evaluate() # lrPred = myLRClassifier.evaluate() mlpPred = MLPClassifier.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("MLP validation") # plot.draw_performance_epoch(MLPClassifier.performances, # MLPClassifier.epochs) plt.plot(range(MLPClassifier.epochs), MLPClassifier.performances, 'r--') plt.show()
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=False) # 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) myMLPlassifier = MultilayerPerceptron(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..") print("\nMLP has been training..") myMLPlassifier.train() print("Done..") # Do the recognizer # Explicitly specify the test set to be evaluated # stupidPred = myStupidClassifier.evaluate() # perceptronPred = myPerceptronClassifier.evaluate() # lrPred = myLRClassifier.evaluate() mplPred = myMLPlassifier.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("Result of the MLP recognizer:") #evaluator.printComparison(data.testSet, stupidPred) evaluator.printAccuracy(data.testSet, mplPred) # Draw plot = PerformancePlot("MLP validation") plot.draw_performance_epoch(myMLPlassifier.performances, myMLPlassifier.epochs)
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, one_hot=False) # Train # Denoising Auto Encoder n_encoder_neurons = 100 myDAE = DenoisingAutoEncoder(data.training_set, data.validation_set, data.test_set, n_hidden_neurons=n_encoder_neurons, noise_ratio=0.2, learning_rate=0.05, epochs=5) print("Train autoencoder..") myDAE.train(verbose=True) print("Done..") # Multilayer Perceptron layers = [] # Add auto envoder hidden layer. layers.append(LogisticLayer(data.training_set.input.shape[1], n_encoder_neurons, weights=myDAE.get_weights(), cost="mse", activation="sigmoid", learning_rate=0.05)) # Add another hidden layer just like in the previous exercise. n_second_hidden_neurons = 100 layers.append(LogisticLayer(n_encoder_neurons, n_second_hidden_neurons, cost="mse", activation="sigmoid", learning_rate=0.05)) # Add output classifier layer with one neuron per digit. n_out_neurons = 10 layers.append(LogisticLayer(n_second_hidden_neurons, n_out_neurons, cost="crossentropy", activation="softmax", learning_rate=0.05)) myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, layers=layers, epochs=15) print("Train MLP..") myMLPClassifier.train(verbose=True) print("Done..") print("") # Evaluate print("Evaluate..") mlpPred = myMLPClassifier.evaluate() print("Done..") print("") print("Results:") evaluator = Evaluator() print("") # 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) # evaluator.printComparison(data.testSet, perceptronPred) evaluator.printAccuracy(data.test_set, mlpPred) # Draw plot = PerformancePlot("DAE + MLP on MNIST task") plot.draw_performance_epoch(myMLPClassifier.performances, myMLPClassifier.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)
def main(): # 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.005, # 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() # Multi layer perceptron layers = [LogisticLayer(data.training_set.input.shape[1], 30, None, 'sigmoid', False), LogisticLayer(30, 10, None, 'softmax', True)] myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, layers=layers, learning_rate=0.005, epochs=30) print("\nLogistic Regression 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.test_set, mlpPred) evaluator.printAccuracy(data.test_set, mlpPred)
def main(): #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.005, # 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() # Build up the network from specific layers # Here is an example of a MLP acting like the Logistic Regression layers = [] layers.append(LogisticLayer(784, 5, None, "sigmoid", True)) layers.append(LogisticLayer(5, 10, None, "softmax", False)) myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, learning_rate=0.5, epochs=30, layers=layers) print("\nLogistic Regression 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) # 3D Plot learning_rates + epochs -> accuracies print("Creating 3D plot. This may take some minutes...") learning_rate_sample_count = 5 epochs_sample_count = 20 xticks = np.logspace(-10.0, 0, base=10, num=learning_rate_sample_count, endpoint=False) accuracies = [] learning_rates = [] epoch_values = [] for i in itertools.product(range(learning_rate_sample_count)): learning_rate = 100 / np.exp(i) print("Calculating accuracy for: learning rate = %s" % (learning_rate)) myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, learning_rate=learning_rate, epochs=epochs_sample_count, layers=layers) epoch_accuracies = myMLPClassifier.train(False) lrPred = myMLPClassifier.evaluate() epoch_values.append([e for e in range(epochs_sample_count)]) learning_rates.append( [learning_rate for _ in range(epochs_sample_count)]) accuracies.append(epoch_accuracies) accuracies_merged = list(itertools.chain(*accuracies)) epochs_merged = list(itertools.chain(*epoch_values)) learning_rates_merged = list(itertools.chain(*learning_rates)) print(accuracies_merged) print(epochs_merged) print(learning_rates) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(np.log10(learning_rates_merged), epochs_merged, accuracies_merged) ax.set_xlabel("Learning Rate") ax.set_xticks(np.log10(xticks)) ax.set_xticklabels(xticks) ax.set_ylabel('Epochs') ax.set_zlabel('Accuracy') plt.show()
def main(): data = MNISTSeven("../data/mnist_seven.csv", 3000, 1000, 1000, oneHot=False) 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) mlp = MultilayerPerceptron(data.trainingSet, data.validationSet, data.testSet, layers=None, inputWeights=None, outputTask='classification', outputActivation='softmax', loss='cee', learningRate=0.01, epochs=50) # 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..") mlp.train() print("Done..") # Do the recognizer # Explicitly specify the test set to be evaluated stupidPred = myStupidClassifier.evaluate() #perceptronPred = myPerceptronClassifier.evaluate() #lrPred = myLRClassifier.evaluate() mlppred = MultilayerPerceptron.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("Result of the mlp:") evaluator.printAccuracy(data.testSet, mlppred) # Draw #plot = PerformancePlot("Logistic Regression validation") #plot.draw_performance_epoch(myLRClassifier.performances, #myLRClassifier.epochs) ####可能有问题 plot = PerformancePlot("mlp validation") plot.draw_performance_epoch(mlp.performances, mlp.epochs)
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, # 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 the autoencoder..") myDAE = DenoisingAutoEncoder(data.training_set, data.validation_set, data.test_set, learning_rate=0.05, epochs=10) print("\nAutoencoder has been training..") myDAE.train() print("Done..") # Multi-layer Perceptron # NOTES: # Now take the trained weights (layer) from the Autoencoder # Feed it to be a hidden layer of the MLP, continue training (fine-tuning) # And do the classification # Correct the code here myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, learning_rate=0.05, epochs=30, input_weights=myDAE._get_weights()) print("\nMulti-layer 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 DAE + MLP recognizer (on test set):") # evaluator.printComparison(data.testSet, perceptronPred) evaluator.printAccuracy(data.test_set, mlpPred) # Draw #plot = PerformancePlot("DAE + MLP on MNIST task") #plot.draw_performance_epoch(myMLPClassifier.performances, # myMLPClassifier.epochs) #print myDAE._get_weights().shape[1] weights = 0.5 * myDAE._get_weights() + 0.5 wplot = WeightVisualizationPlot(weights) wplot.draw_weights()
def main(): #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.005, # 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() # Build up the network from specific layers # Here is an example of a MLP acting like the Logistic Regression layers = [] layers.append(LogisticLayer(784, 5, None, "sigmoid", True)) layers.append(LogisticLayer(5, 10, None, "softmax", False)) myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, learning_rate=0.5, epochs=30, layers=layers) print("\nLogistic Regression 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) # 3D Plot learning_rates + epochs -> accuracies print("Creating 3D plot. This may take some minutes...") learning_rate_sample_count = 5 epochs_sample_count = 20 xticks = np.logspace(-10.0, 0, base=10, num=learning_rate_sample_count, endpoint=False) accuracies = [] learning_rates = [] epoch_values = [] for i in itertools.product(range(learning_rate_sample_count)): learning_rate = 100 / np.exp(i) print("Calculating accuracy for: learning rate = %s" % (learning_rate)) myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, learning_rate=learning_rate, epochs=epochs_sample_count, layers=layers) epoch_accuracies = myMLPClassifier.train(False) lrPred = myMLPClassifier.evaluate() epoch_values.append([e for e in range(epochs_sample_count)]) learning_rates.append([learning_rate for _ in range(epochs_sample_count)]) accuracies.append(epoch_accuracies) accuracies_merged = list(itertools.chain(*accuracies)) epochs_merged = list(itertools.chain(*epoch_values)) learning_rates_merged = list(itertools.chain(*learning_rates)) print(accuracies_merged) print(epochs_merged) print(learning_rates) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(np.log10(learning_rates_merged), epochs_merged, accuracies_merged) ax.set_xlabel("Learning Rate") ax.set_xticks(np.log10(xticks)) ax.set_xticklabels(xticks) ax.set_ylabel('Epochs') ax.set_zlabel('Accuracy') plt.show()
def main(): # 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 the autoencoder..") myDAE = DenoisingAutoEncoder(data.training_set, data.validation_set, data.test_set, learning_rate=0.05, epochs=30) print("\nAutoencoder has been training..") myDAE.train() print("Done..") # Multi-layer Perceptron # NOTES: # Now take the trained weights (layer) from the Autoencoder # Feed it to be a hidden layer of the MLP, continue training (fine-tuning) # And do the classification # Correct the code here myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, learning_rate=0.05, epochs=30) print("\nMulti-layer 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 DAE + MLP recognizer (on test set):") # evaluator.printComparison(data.testSet, perceptronPred) evaluator.printAccuracy(data.test_set, mlpPred) # Draw plot = PerformancePlot("DAE + MLP on MNIST task") plot.draw_performance_epoch(myMLPClassifier.performances, myMLPClassifier.epochs)
def main(): # 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 the autoencoder..") myDAE = DenoisingAutoEncoder(data.training_set, data.validation_set, data.test_set, learning_rate=dae_lr, noiseRatio=dae_nr, hiddenLayerNeurons=hiddenLayerNeurons, epochs=dae_epochs) print("\nAutoencoder has been training..") myDAE.train() print("Done..") # Multi-layer Perceptron # NOTES: # Now take the trained weights (layer) from the Autoencoder # Feed it to be a hidden layer of the MLP, continue training (fine-tuning) # And do the classification myMLPLayers = [] # First hidden layer number_of_1st_hidden_layer = hiddenLayerNeurons myMLPLayers.append(LogisticLayer(data.training_set.input.shape[1]-1, # bias "1" already added so remove one number_of_1st_hidden_layer, weights=myDAE._get_weights(), activation="sigmoid", is_classifier_layer=False)) # Output layer number_of_output_layer = 10 myMLPLayers.append(LogisticLayer(number_of_1st_hidden_layer, number_of_output_layer, None, activation="softmax", is_classifier_layer=True)) # Correct the code here myMLPClassifier = MultilayerPerceptron(data.training_set, data.validation_set, data.test_set, layers=myMLPLayers, learning_rate=mlp_lr, epochs=mlp_epochs) # remove double added bias "1" myMLPClassifier.__del__() print("\nMulti-layer 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 DAE + MLP recognizer (on test set):") # evaluator.printComparison(data.testSet, perceptronPred) evaluator.printAccuracy(data.test_set, mlpPred) os.chdir("..") # Draw plot = PerformancePlot("DAE + MLP on MNIST task on validation set") plot.draw_performance_epoch(myMLPClassifier.performances, myMLPClassifier.epochs, "plots", filename) print("drawing weights of auto encoder mlp input…") weight_plotter = WeightVisualizationPlot(myDAE.autoencMLP) weight_plotter.plot()