def CNN(X_train, y_train, X_test, X_hidden): print("Combined") #l2 normalize preprocessing.normalize(X, 'l2') preprocessing.normalize(X_train, 'max') preprocessing.normalize(X_test, 'max') preprocessing.normalize(X_hidden, 'max') print("Done normalization") X_train = equalize_hist(X_train) X_test = equalize_hist(X_test) X_hidden = equalize_hist(X_hidden) nn = Classifier( layers=[ Convolution("Rectifier", channels=98, kernel_shape=(3,3), pool_shape = (2,2), pool_type="max"), #Convolution("Rectifier", channels=100, kernel_shape=(3,3), dropout=0.25, #weight_decay=0.0001, pool_shape = (2,2), pool_type="max"), Layer("Softmax")], learning_rate=0.01, n_iter=25, random_state= 42) nn.fit(X_train, y_train) print('\nTRAIN SCORE', nn.score(X_train, y_train)) pub_res = list(nn.predict(X_test)) hid_res = list(nn.predict(X_hidden)) return pub_res+hid_res
class TestClassifierFunctionality(unittest.TestCase): def setUp(self): self.nn = MLPC(layers=[L("Linear")], n_iter=1) def test_FitAutoInitialize(self): a_in, a_out = numpy.zeros((8,16)), numpy.random.randint(0, 5, (8,)) self.nn.fit(a_in, a_out) assert_true(self.nn.is_initialized) def test_ExplicitValidSet(self): a_in, a_out = numpy.zeros((8,16)), numpy.random.randint(0, 5, (8,)) self.nn.valid_set = (a_in, a_out) self.nn.fit(a_in, a_out) assert_true(self.nn.is_initialized) def test_PartialFit(self): a_in, a_out = numpy.zeros((8,4)), numpy.random.randint(0, 5, (8,)) self.nn.partial_fit(a_in, a_out, classes=[0,1,2,3]) self.nn.partial_fit(a_in*2.0, a_out+1, classes=[0,1,2,3]) def test_PredictUninitializedNoUnitCount(self): a_in = numpy.zeros((8,16)) assert_raises(AssertionError, self.nn.predict, a_in) def test_PredictUninitializedNoLabels(self): self.nn.layers[-1].units = 4 a_in = numpy.zeros((8,16)) assert_raises(AssertionError, self.nn.predict, a_in) def test_PredictClasses(self): a_in, a_out = numpy.zeros((8,16)), numpy.random.randint(0, 5, (8,)) self.nn.fit(a_in, a_out) a_test = self.nn.predict(a_in) assert_equal(type(a_out), type(a_test)) assert_equal(a_out.shape[0], a_test.shape[0]) def test_PredictMultiClass(self): a_in, a_out = numpy.zeros((8,16)), numpy.random.randint(0, 3, (8,2)) self.nn.fit(a_in, a_out) a_test = self.nn.predict(a_in) assert_equal(type(a_out), type(a_test)) assert_equal(a_out.shape, a_test.shape) def test_EstimateProbalities(self): a_in, a_out = numpy.zeros((8,16)), numpy.random.randint(0, 5, (8,)) self.nn.fit(a_in, a_out) a_test = self.nn.predict_proba(a_in) assert_equal(type(a_out), type(a_test)) def test_CalculateScore(self): a_in, a_out = numpy.zeros((8,16)), numpy.random.randint(0, 5, (8,)) self.nn.fit(a_in, a_out) f = self.nn.score(a_in, a_out) assert_equal(type(f), numpy.float64)
def learn_data(self): first_half = [] fh_wins = [] second_half = [] sh_wins = [] key_t = [] for key, stats in self.results.items(): if key[0] < 2006: first_half += [stats.stat_arr()] fh_wins += [stats.wins] else: second_half += [stats.stat_arr()] sh_wins += [stats.wins] key_t += [key] x_ = np.array([second_half]) x = np.array([first_half]) y_learn = np.array([fh_wins]) nn = Classifier(layers=[Layer("Sigmoid", units=100), Layer("Softmax")], learning_rate=0.01, n_iter=50) nn.fit(x, y_learn) prdt = nn.predict(x_) for i in range(len(second_half)): if prdt[0][i] >= 10 or sh_wins[i] >= 11: print((str(key_t[i]) + " actually won " + str(sh_wins[i]) + " and " + "was predicted with " + str(prdt[0][i])))
def train_sknn(X, y): ''' NeuralNet with sknn ''' X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=5) X_train, X_test = impute_nan(X_train, X_test) X_train, X_test = normalize_features(X_train, X_test) nn = Classifier(layers=[Layer("Tanh", units=12), Layer("Softmax")], learning_rate=0.005, n_iter=25) # gs = GridSearchCV(nn, param_grid={ # 'learning_rate': [0.05, 0.01, 0.005, 0.001], # 'hidden0__units': [4, 8, 12,100], # 'hidden0__type': ["Rectifier", "Sigmoid", "Tanh"]}) # gs.fit(X_train, y_train) # print(gs.best_estimator_) nn.fit(X_train, y_train) predicted = nn.predict(X_test).flatten() labels = y_test return predicted, labels
def mlp(number_layers, number_neurons_1, number_neurons_2, number_neurons_3, number_neurons_4, dropout_rate): layers = [] number_neurons = [] number_neurons.append(number_neurons_1) number_neurons.append(number_neurons_2) number_neurons.append(number_neurons_3) number_neurons.append(number_neurons_4) for i in np.arange(number_layers): layers.append(Layer("Sigmoid", units=number_neurons[i], dropout = dropout_rate)) layers.append(Layer("Softmax", units=2)) scores = [] for i in np.arange(n_validations): X_train, X_test, Y_train, Y_test = sklearn.cross_validation.train_test_split(X,Y, test_size=0.3, random_state=1) predictor = Classifier( layers=layers, learning_rate=0.001, n_iter=25) predictor.fit(X_train, Y_train) scores.append(metrics.accuracy_score(Y_test, predictor.predict(X_test))) return -median(scores)
def autoEncoderOptimization(data): rbm = ae.AutoEncoder( layers=[ ae.Layer("Tanh", units=300), ae.Layer("Sigmoid", units=200), ae.Layer("Tanh", units=100) ], learning_rate=0.002, n_iter=10 ) rbm.fit(data["train"]) model = Classifier( layers=[ Layer("Tanh", units=300), Layer("Sigmoid", units=200), Layer("Tanh", units=100), Layer("Rectifier", units=100), Layer("Rectifier", units=50), Layer("Softmax") ], ) rbm.transfer(model) model.fit(data["train"], data["label"]) prediction = model.predict(data["train"]) print accuracy_score(data["label"], prediction)
def autoEncoderOptimization(data): rbm = ae.AutoEncoder(layers=[ ae.Layer("Tanh", units=300), ae.Layer("Sigmoid", units=200), ae.Layer("Tanh", units=100) ], learning_rate=0.002, n_iter=10) rbm.fit(data["train"]) model = Classifier(layers=[ Layer("Tanh", units=300), Layer("Sigmoid", units=200), Layer("Tanh", units=100), Layer("Rectifier", units=100), Layer("Rectifier", units=50), Layer("Softmax") ], ) rbm.transfer(model) model.fit(data["train"], data["label"]) prediction = model.predict(data["train"]) print accuracy_score(data["label"], prediction)
def main(): vals, actions = matrixFromCSV("C:\\Users\\Chrisd\\Documents\\College\\Spring 2016\\379K\\Kaggle\\Kaggle\\train.csv") X_train, X_test, y_train, y_test = train_test_split(vals, actions, test_size=0.33, random_state=22) totalTest, totalAns = matrixFromCSV("C:\\Users\\Chrisd\\Documents\\College\\Spring 2016\\379K\\Kaggle\\Kaggle\\test.csv") nn = Classifier( layers=[ Layer("Softmax", units=10), Layer("Linear", units=10), Layer("Sigmoid")], learning_rate=0.001, n_iter=20) nn.fit(X_train,y_train) pickle.dump(nn, open('nn.pkl', 'wb')) '''rs = RandomizedSearchCV(nn, param_distributions={ 'learning_rate': stats.uniform(0.001, 0.05), 'hidden0__units': stats.randint(4, 100), 'hidden1__units': stats.randint(4, 100), 'hidden1__type': ["Linear","Rectifier", "Sigmoid", "Tanh"]}) rs.fit(X_train, y_train) pickle.dump(rs, open('rs.pkl', 'wb')) rs = pickle.load(open('rs.pkl', 'rb'))''' #print(X_test.shape) #X_test.reshape(9,1)''' nn = pickle.load(open('nn.pkl', 'rb')) answer = nn.predict(X_test) writeToCSV(answer) print(getPercent(answer,y_test))
def MLP_leave_one_cross_validation(sample, lable): length = len(sample) right, first, second, third = 0, 0, 0, 0 false_list = [] for k in range(0, length): nn = Classifier(layers=[Layer("ExpLin", units=1000), Layer("Softmax")], learning_rate=0.001, n_iter=27) train_sample = copy.deepcopy(sample) lable_sample = copy.deepcopy(lable) test_sample = np.array([sample[k]]) test_lable = lable[k] train_sample = np.delete(train_sample, k, 0) lable_sample = np.delete(lable_sample, k, 0) nn.fit(train_sample, lable_sample) test_result = nn.predict(test_sample) print "predict_label: ", test_result[0][0] print "true_label: ", test_lable[0] if (test_lable[0] == 0): if (test_result[0][0] == test_lable[0]): print True first += 1 right += 1 else: print False false_list.append(k) elif (test_lable[0] == 1): if (test_result[0][0] == test_lable[0]): print True second += 1 right += 1 else: print False false_list.append(k) else: if (test_result[0][0] == test_lable[0]): print True third += 1 right += 1 else: print False false_list.append(k) print "...................................................................................................." print k print "...................................................................................................." # G1_rate = 1.0 * first / 59 # S_rate = 1.0 * second / 58 # G2_rate = 1.0 * third / 65 print "class G1:", 1.0 * first / 59 print "class S:", 1.0 * second / 58 print "class G2:", 1.0 * third / 65 print "class total:", 1.0 * right / 182 print false_list
def wrapper_for_backprop_neural_network_code(train_x, train_y, test_x, test_y): score = None nn = Classifier( layers=[Layer('Sigmoid', units=5), Layer('Softmax')], learning_rate=.001, n_iter=25) nn.fit(train_x, train_y) predicted = nn.predict(test_x) score = accuracy_score(predicted, test_y) return score
def wrapper_for_backprop_neural_network_code(train_x, train_y, test_x, test_y): score = None nn = Classifier(layers=[Layer('Sigmoid', units=5), Layer('Softmax')], learning_rate=.001, n_iter=25) nn.fit(train_x, train_y) predicted = nn.predict(test_x) score = accuracy_score(predicted, test_y) return score
def CNN(X_train, y_train, X_test): nn = Classifier( layers=[ Convolution("Rectifier", channels=20, kernel_shape=(5,5), dropout=0.25), Layer("Tanh", units=300), Layer("Tanh", units=100), Layer("Softmax")], learning_rate=0.02, n_iter=10) nn.fit(X_train, y_train) print('\nTRAIN SCORE', nn.score(X_train, y_train)) return list(nn.predict(X_test))
class SoftmaxNeuralNetwork: def __init__(self): # learning rate self.nn = Classifier(layers=[Layer("Softmax", units=100), Layer("Softmax")], learning_rate=0.001, n_iter=25) def train(self, training_input, correct_output): self.nn.fit(training_input, correct_output) def predict(self, training_example): return self.nn.predict(training_example)
def CNN(X_train, y_train, X_test, X_hidden): print("1 Con, 1 tanh") #l2 normalize preprocessing.normalize(X, 'l2') preprocessing.normalize(X_train, 'max') preprocessing.normalize(X_test, 'max') preprocessing.normalize(X_hidden, 'max') print("Done normalization") X_train = equalize_hist(X_train) X_test = equalize_hist(X_test) X_hidden = equalize_hist(X_hidden) nn = Classifier( layers=[ Layer("Tanh", units = 98, weight_decay=0.0001), Layer("Softmax")], learning_rate=0.01, n_iter=1000, batch_size= 5) nn.fit(X_train, y_train) print('\nTRAIN SCORE', nn.score(X_train, y_train)) pub_res = list(nn.predict(X_test)) hid_res = list(nn.predict(X_hidden)) return pub_res+hid_res
def main(): train_X, train_Y, test_X, test_Y, train_Xs, train_Ys = load_mnist(".") model = Classifier( layers=[ Layer("Sigmoid", units=1000), Layer("Softmax", units=10)], learning_rule='sgd', learning_rate=0.01, n_iter=10, verbose=1) #model.fit(train_X, train_Y) train_Y = train_Y.flatten() test_Y = test_Y.flatten() #pickle.dump(model, open("mnist_model.pkl", "w")) model = pickle.load(open("mnist_model.pkl", "r")) labels_train = model.predict(train_X).flatten() labels_test = model.predict(test_X).flatten() num_train = labels_train.shape[0] num_test = labels_test.shape[0] train_err = float(np.sum(labels_train != train_Y))/num_train test_err = float(np.sum(labels_test != test_Y))/num_test print "Training error:", train_err print "Test error:", test_err
class ClassifierNeuralNet(): def __init__(self): self.nn = Classifier( layers=[ Layer("Sigmoid", units =100), Layer("Softmax")], learning_rate = 0.001, n_iter = 200) def train(self): data = parser.load_echo_data('data/training_data.csv') self.nn.fit(data.data, data.target) def predictData(self, data): return self.nn.predict(data)
def train(X, y, w, num_classes, model=None, lr=0.01): if model is None: model = Classifier( layers=[ Layer("Sigmoid", units=args.num_hidden), Layer("Softmax", units=num_classes)], learning_rule='sgd', learning_rate=lr, n_iter=1, verbose=1) model.fit(X, y)#, w=w) pickle.dump(model, open(args.outfile, "w")) labels = model.predict(X).flatten() print "Split accuracy", float(np.sum(labels == y))/X.shape[0] return model
def predictCategoryNN(training_set, test_set, target, test_targert, componentsList): scaler = StandardScaler() scaler.fit(training_set[componentsList]) training_set[componentsList] = scaler.transform( training_set[componentsList]) test_set[componentsList] = scaler.transform(test_set[componentsList]) nn = Classifier(layers=[Layer("Sigmoid", units=100), Layer("Softmax")], learning_rate=0.001, n_iter=25) nn.fit(training_set[componentsList].as_matrix(), target.as_matrix()) return nn.predict(test_set[componentsList].as_matrix()), pd.DataFrame( test_targert), nn.score(test_set[componentsList].as_matrix(), test_targert.as_matrix())
def CNN(X_train, y_train, X_test): nn = Classifier(layers=[ Convolution("Rectifier", channels=20, kernel_shape=(5, 5), dropout=0.25), Layer("Tanh", units=300), Layer("Tanh", units=100), Layer("Softmax") ], learning_rate=0.02, n_iter=10) nn.fit(X_train, y_train) print('\nTRAIN SCORE', nn.score(X_train, y_train)) return list(nn.predict(X_test))
def main(): X_train, t_train, train_ids = create_data_matrix(0, 200, TRAIN_DIR) # X_valid, t_valid, valid_ids = create_data_matrix(10, 15, TRAIN_DIR) print 'Data matrix (training set):', "X_train", X_train # print 'Classes (training set):', "t_train", t_train print "Number of files processed:", len(t_train) # save to CSV X_train.to_csv("X_train.csv") np.savetxt("t_train.csv", t_train, delimiter="\n") # convert DF to numpy array X_train = X_train.as_matrix(columns=None) # train using neural net nn = Classifier( layers=[ Layer("Rectifier", units=X_train.shape[1]), Layer("Softmax")], learning_rate=0.001, n_iter=100) nn.fit(X_train, t_train) nn.predict(X_train)
def mlp( number_layers, number_neurons_1, number_neurons_2, number_neurons_3, number_neurons_4, dropout_rate_1, dropout_rate_2, dropout_rate_3, dropout_rate_4, weight_decay, activation_1, activation_2, activation_3, activation_4, learning_rate, ): layers = [] number_neurons = [] activation = [] dropout = [] number_neurons.append(number_neurons_1) number_neurons.append(number_neurons_2) number_neurons.append(number_neurons_3) number_neurons.append(number_neurons_4) activation.append(activation_1) activation.append(activation_2) activation.append(activation_3) activation.append(activation_4) dropout.append(dropout_rate_1) dropout.append(dropout_rate_2) dropout.append(dropout_rate_3) dropout.append(dropout_rate_4) for i in np.arange(number_layers): layers.append(Layer(activation[i], units=number_neurons[i], dropout=dropout[i], weight_decay=weight_decay)) layers.append(Layer("Softmax", units=2)) predictor = Classifier(layers=layers, learning_rate=learning_rate, n_iter=25) predictor.fit(X_train, Y_train) return -metrics.accuracy_score(Y_test, predictor.predict(X_test))
def mlpclassifier(input_data, output_labels,filename) : from sknn.mlp import Classifier, Layer mlpC = Classifier( layers=[ #Layer("Maxout", units=100, pieces=2), Layer("Softmax")], learning_rate=0.001, n_iter=25) X_train, X_test, Y_train, Y_test = train_test_split(input_data, output_labels, test_size=0.25, random_state=42) mlpC.fit(X_train, Y_train) predictionsMLP= mlpC.predict(X_test) calc_conf_matrix(Y_test, predictionsMLP, 'Multi Layer Perceptron confusion matrix', filename+'_cm') roc_plot(input_data,output_labels, mlpC,filename+'_roc') coeff_of_deterimination(mlpC, input_data, output_labels, 5)
def classifyNeuralNetworkClassifier(XTrain, XTest, YTrain, YTest, params): activation = params['activation'] actLastLayer = params['actLastLayer'] rule = params['rule'] noOfUnits = params['units'] rate = params['rate'] noOfIter = params['iter'] nn = Classifier(layers=[Layer(activation, units=noOfUnits), Layer(actLastLayer)], learning_rule=rule, learning_rate=0.02, n_iter=10) nn.fit(XTrain, YTrain) YPred = nn.predict(XTest) diff = YPred - YTest.reshape(YPred.shape) score = diff[diff == 0].size score = (100.0 * score) / (YPred.size) return score
def test_mlp_classifier( data, layers=[Layer("Rectifier", units=10), Layer('Softmax')], learning_rate=0.02, n_iter=1, scale=1): #preprossing data if necessary X_raw, y = data #normalize data for better performance if scale == 1: X = preprocessing.scale(X_raw) else: X = X_raw #since our test set is not labeled I am using the training data provided for train, validation and test print("Create, train, test, validation_sets") #split the data into training/validation set and testing set X_train_valid, X_test, y_train_valid, y_test = train_test_split( X, y, test_size=0.2, random_state=42) #split the training set into training set and validation set X_train, X_valid, y_train, y_valid = train_test_split(X_train_valid, y_train_valid, test_size=0.2, random_state=23) #build the different layers of the model print("Building the model...") nn = Classifier(layers=layers, learning_rate=learning_rate, n_iter=n_iter) #train the model print("Training...") nn.fit(X_train, y_train) #test the model print("Testing...") y_valid = nn.predict(X_train) #return the validation score print("Score...") score = nn.score(X_test, y_test) return score, layers, learning_rate, n_iter
class TestClassifierFunctionality(unittest.TestCase): def setUp(self): self.nn = MLPC(layers=[L("Linear")], n_iter=1) def test_FitAutoInitialize(self): a_in, a_out = numpy.zeros((8, 16)), numpy.zeros((8, ), dtype=numpy.int32) self.nn.fit(a_in, a_out) assert_true(self.nn.is_initialized) def test_PartialFit(self): a_in, a_out = numpy.zeros((8, 4)), numpy.zeros((8, ), dtype=numpy.int32) self.nn.partial_fit(a_in, a_out, classes=[0, 1, 2, 3]) self.nn.partial_fit(a_in * 2.0, a_out + 1, classes=[0, 1, 2, 3]) def test_PredictUninitializedNoUnitCount(self): a_in = numpy.zeros((8, 16)) assert_raises(AssertionError, self.nn.predict, a_in) def test_PredictUninitializedNoLabels(self): self.nn.layers[-1].units = 4 a_in = numpy.zeros((8, 16)) assert_raises(ValueError, self.nn.predict, a_in) def test_PredictClasses(self): a_in, a_out = numpy.zeros((8, 16)), numpy.zeros((8, ), dtype=numpy.int32) self.nn.fit(a_in, a_out) a_test = self.nn.predict(a_in) assert_equal(type(a_out), type(a_test)) assert_equal(a_out.shape, a_test.shape) def test_EstimateProbalities(self): a_in, a_out = numpy.zeros((8, 16)), numpy.zeros((8, ), dtype=numpy.int32) self.nn.fit(a_in, a_out) a_test = self.nn.predict_proba(a_in) assert_equal(type(a_out), type(a_test)) def test_CalculateScore(self): a_in, a_out = numpy.zeros((8, 16)), numpy.zeros((8, ), dtype=numpy.int32) self.nn.fit(a_in, a_out) f = self.nn.score(a_in, a_out) assert_equal(type(f), numpy.float64)
class NeuralNetwork(object): """Class NeuralNetwork - Represent a neural network""" def __init__(self, number_layers, numbers_neurons, learning_rate, **kwargs): """Create neural network from the parameters""" self.input_layer = Layer("Sigmoid", units=46) self.output_layer = Layer("Softmax") self.hidden_layers = [] for i in range(number_layers): layer = Layer("Sigmoid", units=numbers_neurons[i]) self.hidden_layers.append(layer) self.learning_rate = learning_rate #training data self.X_train = kwargs.get('X_train', None) self.Y_train = kwargs.get('Y_train', None) #test data self.X_test = kwargs.get('X_test', None) self.Y_test = kwargs.get('Y_test', None) self.net = Classifier(layers=([self.input_layer]+self.hidden_layers+[self.output_layer]), learning_rate=self.learning_rate, n_iter=1000) self.is_ready = False def train(self): """Train of the neural network""" self.net.fit(self.X_train, self.Y_train) self.is_ready = True def get_auc(self): """Returns the area under the roc curve""" if not self.is_ready: self.train() output_test = self.net.predict(self.X_test) return metrics.roc_auc_score(self.Y_test, output_test) def classify(self): """Returns the mean accuracy on the given test data and labels.""" score = 0 score = self.net.score(self.X_test, self.Y_test) return score
def test_artificial_neural_network(self): # To do the following you need to run command: pip install scikit-neuralnetwork from sknn.mlp import Classifier, Layer import numpy as np X = np.array([[181, 80, 44], [177, 70, 43], [160, 60, 38], [154, 54, 37], [166, 65, 40], [190, 90, 47], [175, 64, 39], [177, 70, 40], [159, 55, 37], [171, 75, 42], [181, 85, 43]]) Y = np.array(['male', 'male', 'female', 'female', 'male', 'male', 'female', 'female', 'female', 'male', 'male']) nn = Classifier( layers=[ Layer("Maxout", units=100, pieces=2), Layer("Softmax")], learning_rate=0.001, n_iter=25) nn.fit(X, Y) prediction = nn.predict([[190, 70, 43]]) print prediction
def classifyNeuralNetworkClassifier(XTrain, XTest, YTrain, YTest, params): activation = params['activation'] actLastLayer = params['actLastLayer'] rule = params['rule'] noOfUnits = params['units'] rate = params['rate'] noOfIter = params['iter'] nn = Classifier( layers=[Layer(activation, units=noOfUnits), Layer(actLastLayer)], learning_rule=rule, learning_rate=0.02, n_iter=10) nn.fit(XTrain, YTrain) YPred = nn.predict(XTest) diff = YPred - YTest.reshape(YPred.shape) score = diff[diff == 0].size score = (100.0 * score) / (YPred.size) return score
def mlp(number_layers, number_neurons_1, number_neurons_2, number_neurons_3, number_neurons_4, dropout_rate_1, dropout_rate_2, dropout_rate_3, dropout_rate_4, weight_decay, activation_1, activation_2, activation_3, activation_4, learning_rate): layers = [] number_neurons = [] activation = [] dropout = [] number_neurons.append(number_neurons_1) number_neurons.append(number_neurons_2) number_neurons.append(number_neurons_3) number_neurons.append(number_neurons_4) activation.append(activation_1) activation.append(activation_2) activation.append(activation_3) activation.append(activation_4) dropout.append(dropout_rate_1) dropout.append(dropout_rate_2) dropout.append(dropout_rate_3) dropout.append(dropout_rate_4) for i in np.arange(number_layers): layers.append( Layer(activation[i], units=number_neurons[i], dropout=dropout[i], weight_decay=weight_decay)) layers.append(Layer("Softmax", units=2)) predictor = Classifier(layers=layers, learning_rate=learning_rate, n_iter=25) predictor.fit(X_train, Y_train) return -metrics.accuracy_score(Y_test, predictor.predict(X_test))
def test_artificial_neural_network(self): # To do the following you need to run command: pip install scikit-neuralnetwork from sknn.mlp import Classifier, Layer import numpy as np X = np.array([[181, 80, 44], [177, 70, 43], [160, 60, 38], [154, 54, 37], [166, 65, 40], [190, 90, 47], [175, 64, 39], [177, 70, 40], [159, 55, 37], [171, 75, 42], [181, 85, 43]]) Y = np.array([ 'male', 'male', 'female', 'female', 'male', 'male', 'female', 'female', 'female', 'male', 'male' ]) nn = Classifier( layers=[Layer("Maxout", units=100, pieces=2), Layer("Softmax")], learning_rate=0.001, n_iter=25) nn.fit(X, Y) prediction = nn.predict([[190, 70, 43]]) print prediction
def main(): print '[INFO, time: %s] Getting Data....' % (time.strftime('%H:%M:%S')) testing_file = file('test.p', 'r') training_file = file('train.p', 'r') train = pickle.load(training_file) test = pickle.load(testing_file) testing_file.close() training_file.close() trainX = train[:,:-1] trainy = train[:,-1] testX = test[:,:-1] testy = test[:,-1] # print '[INFO, time: %s] Downsampling ...' % (time.strftime('%H:%M:%S')) # trainX = downsample_features(trainX) # testX = downsample_features(testX) trainX, testX = normalize(trainX, testX) print '[INFO, time: %s] Fitting %s ...' % (time.strftime('%H:%M:%S'), 'Neural Network with default paramenters') clf = Classifier( layers=[ Layer("Sigmoid",units=800,pieces=2), Layer("Sigmoid",units=250,pieces=2), Layer("Softmax")], learning_rate=0.001, n_iter=25, verbose=True, valid_size=0.1 ) clf.fit(trainX, trainy) print '[INFO, time: %s] Making Predictions...' % (time.strftime('%H:%M:%S')) prediction = clf.predict(testX) print '[RESULT, time: %s] accuracy = %f' % (time.strftime('%H:%M:%S'),accuracy_score(testy, prediction))
class TestClassifierFunctionality(unittest.TestCase): def setUp(self): self.nn = MLPC(layers=[L("Linear")], n_iter=1) def test_FitAutoInitialize(self): a_in, a_out = numpy.zeros((8,16)), numpy.zeros((8,), dtype=numpy.int32) self.nn.fit(a_in, a_out) assert_true(self.nn.is_initialized) def test_PartialFit(self): a_in, a_out = numpy.zeros((8,4)), numpy.zeros((8,), dtype=numpy.int32) self.nn.partial_fit(a_in, a_out, classes=[0,1,2,3]) self.nn.partial_fit(a_in*2.0, a_out+1, classes=[0,1,2,3]) def test_PredictUninitialized(self): a_in = numpy.zeros((8,16)) assert_raises(ValueError, self.nn.predict, a_in) def test_PredictClasses(self): a_in, a_out = numpy.zeros((8,16)), numpy.zeros((8,), dtype=numpy.int32) self.nn.fit(a_in, a_out) a_test = self.nn.predict(a_in) assert_equal(type(a_out), type(a_test)) assert_equal(a_out.shape, a_test.shape) def test_EstimateProbalities(self): a_in, a_out = numpy.zeros((8,16)), numpy.zeros((8,), dtype=numpy.int32) self.nn.fit(a_in, a_out) a_test = self.nn.predict_proba(a_in) assert_equal(type(a_out), type(a_test)) def test_CalculateScore(self): a_in, a_out = numpy.zeros((8,16)), numpy.zeros((8,), dtype=numpy.int32) self.nn.fit(a_in, a_out) f = self.nn.score(a_in, a_out) assert_equal(type(f), numpy.float64)
def number(number): #def number(): digits = load_digits() Xdata = digits.data Xdata = scale(Xdata) X_train, X_test, y_train, y_test, images_train, images_test = train_test_split( Xdata, digits.target, digits.images, test_size=0.25, random_state=42) nn = Classifier(layers=[Layer("Sigmoid", units=100), Layer("Softmax")], learning_rate=0.001, n_iter=25) #http://aka.ms/vcpython27 #http://blog.sciencenet.cn/blog-669638-1080739.html #C:\Python27\Lib\site-packages\lasagne\layers\pool.py nn.fit(X_train, y_train) print nn.score(X_test, y_test) X_test[0] = scale(number) predicted = nn.predict(X_test) print("predicted is ", predicted[0])
def wrapper_for_backprop_neural_network_cnn(train_x, train_y, test_x, test_y): score = None # nn = Classifier( # layers=[ # Convolution("Rectifier", channels=8, kernel_shape=(3,3)), # Layer("Softmax")], # learning_rate=0.02, # n_iter=5) # nn.fit(X_train, y_train) nn = Classifier(layers=[ Convolution('Sigmoid', channels=8, kernel_shape=(3, 3)), Layer('Softmax') ], learning_rate=.001, n_iter=10, dropout_rate=0.1) nn.fit(train_x, train_y) # print(test_x.shape, train_x.shape) predicted = nn.predict(test_x) score = accuracy_score(predicted, test_y) return score
def wrapper_for_backprop_neural_network_cnn(train_x, train_y, test_x, test_y): score = None # nn = Classifier( # layers=[ # Convolution("Rectifier", channels=8, kernel_shape=(3,3)), # Layer("Softmax")], # learning_rate=0.02, # n_iter=5) # nn.fit(X_train, y_train) nn = Classifier( layers=[ Convolution('Sigmoid', channels=8, kernel_shape=(3,3)), Layer('Softmax')], learning_rate=.001, n_iter=10, dropout_rate=0.1) nn.fit(train_x, train_y) # print(test_x.shape, train_x.shape) predicted = nn.predict(test_x) score = accuracy_score(predicted, test_y) return score
def train_sknn(X, y): ''' NeuralNet with sknn ''' X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 5) X_train, X_test = impute_nan(X_train, X_test) X_train, X_test = normalize_features(X_train, X_test) nn = Classifier( layers=[ Layer("Tanh", units=12), Layer("Softmax")], learning_rate=0.005, n_iter=25) # gs = GridSearchCV(nn, param_grid={ # 'learning_rate': [0.05, 0.01, 0.005, 0.001], # 'hidden0__units': [4, 8, 12,100], # 'hidden0__type': ["Rectifier", "Sigmoid", "Tanh"]}) # gs.fit(X_train, y_train) # print(gs.best_estimator_) nn.fit(X_train, y_train) predicted = nn.predict(X_test).flatten() labels = y_test return predicted, labels
def main(): while True: data_set_name = input( "Please provide the name of the data set you want to work with: ") # Load, Randomize, Normalize, Discretize Dataset data_set = Dataset() data_set.read_file_into_dataset( "C:\\Users\\Grant\\Documents\\School\\Winter 2016\\CS 450\\Neural\\" + data_set_name) data_set.randomize() data_set.data = normalize(data_set.data) #data_set.discretize() #print(data_set.data) data_set.set_missing_data() # Split Dataset split_percentage = 0.7 data_sets = data_set.split_dataset(split_percentage) training_set = data_sets[0] testing_set = data_sets[1] # Create Custom Classifier, Train Dataset, Predict Target From Testing Set iterations = int(input("How many iterations do you want to do? ")) layers = int( input("How many layers do you want in your neural network? ")) num_nodes = [] for i in range(layers): if i + 1 == layers: number = int(input("How many nodes on the output layer? ")) else: number = int( input("How many nodes on the " + str(i) + " layer? ")) num_nodes.append(number) neuralNetwork = NeuralNetwork(iterations) neuralNetwork.create_layered_network( num_nodes, training_set.feature_names.__len__()) #neuralNetwork.display_network() neuralNetwork.train(training_set) predictions = neuralNetwork.predict(testing_set) # Check Results my_accuracy = get_accuracy(predictions, testing_set.target) print("Accuracy: " + str(my_accuracy) + "%") # Compare To Existing Implementations layers_objs = [] for i in range(layers): if i + 1 == layers: layers_objs.append(Layer("Softmax", units=num_nodes[i])) else: layers_objs.append(Layer("Sigmoid", units=num_nodes[i])) mlp_nn = Classifier(layers=layers_objs, learning_rate=0.4, n_iter=iterations) mlp_nn.fit(np.array(training_set.data), np.array(training_set.target)) predictions = mlp_nn.predict(np.array(testing_set.data)) mlp_nn_accuracy = get_accuracy(predictions, testing_set.target) print("NN Accuracy: " + str(mlp_nn_accuracy) + "%") create_csv_file( neuralNetwork.accuracies, "C:\\Users\\Grant\\Documents\\School\\Winter 2016\\CS 450\\Neural\\" + data_set_name + ".csv") # Do another or not toContinue = False while True: another = input("Do you want to examine another dataset? (y / n) ") if another != 'y' and another != 'n': print("Please provide you answer in a 'y' or 'n' format.") elif another == 'y': toContinue = True break else: toContinue = False break if not toContinue: break
clf = Classifier(layers=[ Layer('Sigmoid', units=hu), Layer('Softmax', units=2) ], learning_rule=lr, learning_rate=lrt, n_iter=ni) startTime = datetime.now() clf.fit(X_train, y_train) endTime = datetime.now() y_score = clf.predict_proba(X_test) y_hat = clf.predict(X_test) ys = [y_s[y_h] for y_s, y_h in zip(y_score, y_hat)] tmp = np.append(X_test, np.reshape(y_test, (1, y_test.shape[0])).T, axis=1) tmp = np.append(tmp, np.reshape(y_hat, (1, y_hat.shape[0])).T, axis=1) tmp = np.append(tmp, y_score, axis=1) tmp = np.append(tmp, np.asarray(ys), axis=1) output['data'] = [['X_' + str(i) for i in range(1, X_test.shape[1] + 1)] + ['y_label', 'y_hat', 'y_score', 'y_score', 'ys']] + \ tmp.tolist()
def main(): while True: data_set_name = input("Please provide the name of the data set you want to work with: ") # Load, Randomize, Normalize, Discretize Dataset data_set = Dataset() data_set.read_file_into_dataset("C:\\Users\\Grant\\Documents\\School\\Winter 2016\\CS 450\\Neural\\" + data_set_name) data_set.randomize() data_set.data = normalize(data_set.data) #data_set.discretize() #print(data_set.data) data_set.set_missing_data() # Split Dataset split_percentage = 0.7 data_sets = data_set.split_dataset(split_percentage) training_set = data_sets[0] testing_set = data_sets[1] # Create Custom Classifier, Train Dataset, Predict Target From Testing Set iterations = int(input("How many iterations do you want to do? ")) layers = int(input("How many layers do you want in your neural network? ")) num_nodes = [] for i in range(layers): if i + 1 == layers: number = int(input("How many nodes on the output layer? ")) else: number = int(input("How many nodes on the " + str(i) + " layer? ")) num_nodes.append(number) neuralNetwork = NeuralNetwork(iterations) neuralNetwork.create_layered_network(num_nodes, training_set.feature_names.__len__()) #neuralNetwork.display_network() neuralNetwork.train(training_set) predictions = neuralNetwork.predict(testing_set) # Check Results my_accuracy = get_accuracy(predictions, testing_set.target) print("Accuracy: " + str(my_accuracy) + "%") # Compare To Existing Implementations layers_objs = [] for i in range(layers): if i + 1 == layers: layers_objs.append(Layer("Softmax", units=num_nodes[i])) else: layers_objs.append(Layer("Sigmoid", units=num_nodes[i])) mlp_nn = Classifier(layers=layers_objs, learning_rate=0.4, n_iter=iterations) mlp_nn.fit(np.array(training_set.data), np.array(training_set.target)) predictions = mlp_nn.predict(np.array(testing_set.data)) mlp_nn_accuracy = get_accuracy(predictions, testing_set.target) print("NN Accuracy: " + str(mlp_nn_accuracy) + "%") create_csv_file(neuralNetwork.accuracies, "C:\\Users\\Grant\\Documents\\School\\Winter 2016\\CS 450\\Neural\\" + data_set_name + ".csv") # Do another or not toContinue = False while True: another = input("Do you want to examine another dataset? (y / n) ") if another != 'y' and another != 'n': print("Please provide you answer in a 'y' or 'n' format.") elif another == 'y': toContinue = True break else: toContinue = False break if not toContinue: break
clf = Classifier( layers=[Layer('Sigmoid', units=hu), Layer('Softmax', units=3)], learning_rule=lr, learning_rate=lrt, n_iter=ni ) startTime = datetime.datetime.now() clf.fit(X_train, y_train) endTime = datetime.datetime.now() y_score = clf.predict_proba(X_test) y_hat = clf.predict(X_test) ys = [y_s[y_h-1] for y_s, y_h in zip(y_score, y_hat)] tmp = np.append(X_test, np.reshape(y_test, (1,y_test.shape[0])).T, axis=1) tmp = np.append(tmp, np.reshape(y_hat, (1,y_hat.shape[0])).T, axis=1) tmp = np.append(tmp, y_score, axis=1) tmp = np.append(tmp, np.asarray(ys), axis=1) output['data'] = [['X_' + str(i) for i in range(1, X_test.shape[1] + 1)] + ['y_label', 'y_hat', 'y_score_1', 'y_score_2', 'y_score_3', 'ys']] + \ tmp.tolist() acc = accuracy_score(y_hat, y_test) confMatrix = confusion_matrix(y_test, y_hat).tolist()
# Saving the NN pickle.dump(nn, open("Convoluted.pk1", "wb")) # ----------------------------------------------------------------------------------------------------------- # # Estimating the generalisation error with CV: all classes indivudually and multiclass log-loss print("CV for class-wise generalisation errors") num_folds = 2 kf = KFold(y, n_folds=num_folds) y_pred = y * 0 l_loss = np.zeros((num_folds,1), dtype= float) p = 0 for train, test in kf: X_train, X_test, y_train, y_test = X[train,:], X[test,:], y[train], y[test] nn_cv = Classifier(layers=lay, learning_rate=0.001, n_iter=2) nn_cv.fit(X=X_train, y=y_train) y_pred[test] = nn_cv.predict(X_test) y_pred2 = nn_cv.predict_proba(X_test) l_loss[p, 0] = log_loss(y_test, y_pred2) p += 1 print(classification_report(y, y_pred, target_names=namesClasses)) log_loss_CV = np.average(l_loss, axis=0) # Calculating the multiclass log-loss print("Multiclass Log-loss by CV: ", log_loss_CV) print("Finished program") print("--- %s seconds ---" % (round(time.time() - start_time, 4))) # Calculates machine time for the program
return (v) dataset = pd.read_csv("../input/dataset.csv") y = dataset['subset'].ravel() X = dataset['cdr3'].ravel() for i in range(len(X)): X[i] = vectorize(X[i]) X = np.array([np.array(xi) for xi in X]) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42) print(X_test) clf = Classifier(layers=[Layer("Rectifier", units=100), Layer("Softmax")], learning_rate=0.02, n_iter=100) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) score = nn.score(X_test, y_test) print(score) print(y_test) score = accuracy_score(y_test, y_pred) print(score)
device = 1 featureCondition = 16 classificationCondition = 1 offsetFeatureOn = False my_test_size = 0.3 my_random_state = 42 data, label = splitMomentDataByFeatureAndLabel(userid, device, featureCondition, classificationCondition, offsetFeatureOn=offsetFeatureOn) data = data.astype(float) label = label.astype(int) trainingData, testData, trainingLabel, testLabel = train_test_split( data, label, test_size=my_test_size, random_state=my_random_state) nn = Classifier( layers=[Layer("Softmax", units=100, pieces=2), Layer("Softmax")], learning_rate=0.001, n_iter=10000) nn.fit(trainingData, trainingLabel) y_valid = nn.predict(testData) print testLabel print y_valid
# First we try the a MLP set to a default configuration, so we can see if SMAC can improve its performance scores = [] for i in np.arange(n_validations): X_train, X_test, Y_train, Y_test = sklearn.cross_validation.train_test_split( X, Y, test_size=0.3, random_state=1) predictor = Classifier(layers=[ Layer("Sigmoid", units=100, dropout=0), Layer("Sigmoid", units=100, dropout=0), Layer("Softmax", units=2) ], learning_rate=0.001, n_iter=25) predictor.fit(X_train, Y_train) scores.append(metrics.accuracy_score(Y_test, predictor.predict(X_test))) print(('The default accuracy is %f' % median(scores))) # We set some parameters for the optimizer value, parameters = opt.minimize( mlp, n_iter, parameter_definition, # number of evaluations num_runs=2, # number of independent SMAC runs seed=2, # random seed num_procs=2, # two cores mem_limit_function_mb=1000, # Memory limit t_limit_function_s=10000 # Time limit in seconds )
# Create a classifier object with the classifier and parameter candidates svm_grid_model = GridSearchCV(estimator=svm.SVC(), param_grid= parameter_candidates, refit= True) # Train the classifier on audio feature and target= audio genre svm_grid_model.fit(X_train, y_train) # View the accuracy score print('Best score for Audio Classification:', svm_grid_model.best_score_) # View the best parameters for the model found using grid search print('Best C:',svm_grid_model.best_estimator_.C) print('Best Kernel:',svm_grid_model.best_estimator_.kernel) print('Best Gamma:',svm_grid_model.best_estimator_.gamma) expected = y_test predicted_nn = nn_best.predict(X_test) predicted_svm = svm_grid_model.predict(X_test) #plotting Confusion Matrix import itertools def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues): fig = plt.figure(figsize=(8, 8)) plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45)
##### Crear el modelo de Backpropagation ##### #Simple modelS = Classifier(layers=[Layer("Rectifier", units=100, pieces=2), Layer("Softmax")],learning_rate=0.001, n_iter=25) #Cruzado modelC = Classifier(layers=[Layer("Rectifier", units=100, pieces=2), Layer("Softmax")],learning_rate=0.001, n_iter=25) ##### Entrenamos la red ##### modelS.fit(data_x_entre, data_y_entre) ##### Predicciones ##### #Simple predic = modelS.predict(data_x_prueb) #Cruzado predic_cross = cross_val_predict(modelC,data_x,data_y,cv=10) ##### Score ##### #Simple scor = modelS.score(data_x_prueb, data_y_prueb) #Cruzado scor_cross = cross_val_score(modelC,data_x, data_y,cv=10).mean() ##### Error cuadratico ##### #Simple
print "Starting neural network training" nn = Classifier( layers=[ Layer("Rectifier", units=49), Layer("Softmax")], learning_rate=0.01, batch_size = 100, n_iter=100) # Training nn.fit(X_train,Y) pickle.dump(nn, open('nn_susy_classification.pkl', 'wb')) if not runTraining: nn = pickle.load(open('nn_susy_classification.pkl', 'rb')) # Testing pred_train = nn.predict(X_train) pred_test = nn.predict(X_test) probabilities_train = nn.predict_proba(X_train) probabilities_test = nn.predict_proba(X_test) print "Training sample...." print " Signal identified as signal (%) : ",100.0*np.sum(pred_train[nBackgroundEvents:nBackgroundEvents+nSignalEvents]==1.0)/nSignalEvents print " Signal identified as background (%) : ",100.0*np.sum(pred_train[nBackgroundEvents:nBackgroundEvents+nSignalEvents]==0.0)/nSignalEvents print " Background identified as signal (%) : ",100.0*np.sum(pred_train[0:nBackgroundEvents]==1.0)/nBackgroundEvents print " Background identified as background (%): ",100.0*np.sum(pred_train[0:nBackgroundEvents]==0.0)/nBackgroundEvents print "" print "Testing sample...." print " Signal identified as signal (%) : ",100.0*np.sum(pred_test[nBackgroundEvents:nBackgroundEvents+nSignalEvents]==1.0)/nSignalEvents print " Signal identified as background (%) : ",100.0*np.sum(pred_test[nBackgroundEvents:nBackgroundEvents+nSignalEvents]==0.0)/nSignalEvents print " Background identified as signal (%) : ",100.0*np.sum(pred_test[0:nBackgroundEvents]==1.0)/nBackgroundEvents print " Background identified as background (%): ",100.0*np.sum(pred_test[0:nBackgroundEvents]==0.0)/nBackgroundEvents
# plot_utils.plot_learning_curve(svc_linear1, wisconsin_training_inputs, wisconsin_training_classes, cv=10, ylim=[0.7, 1.05], figure_title="Learning Curve vs # Training Size (SVM - Linear) ", n_jobs=1, train_sizes=np.linspace(.1, 1.0, 10)) # plot_utils.plot_learning_curve_with_test(ada_classifier2, wisconsin_training_inputs, wisconsin_training_classes, wisconsin_testing_inputs, wisconsin_testing_classes, cv=10, ylim=[0.0, 20], figure_title="Learning Curve of Adaboost vs # Samples wisconsin's Data (Errors)", n_jobs=1, train_sizes=np.linspace(.1, 1.0, 10)) ## Multilayer neural network from sknn.mlp import Classifier, Layer from sklearn.pipeline import Pipeline from sklearn.preprocessing import MinMaxScaler nn = Classifier( layers=[ Layer("Softmax")], learning_rate=0.01, n_iter=25) nn.fit(wisconsin_training_inputs, wisconsin_training_classes) y_pred = nn.predict(wisconsin_testing_inputs) score = nn.score(wisconsin_testing_inputs, wisconsin_testing_classes) print("nn score: ", score) print("y_pred: ", y_pred) ## plot the confusion matrix # plot_utils.plot_confusion_matrix(wisconsin_testing_classes, y_pred, figure_title="Confusion Matrix - Breast Cancer Data Testing (Neural Network)") plotter = PlotUtils() ## plotting the learning curve with training and test errors # plotter.plot_learning_curve_train_test_errors(nn, wisconsin_training_inputs, wisconsin_training_classes, wisconsin_testing_inputs, wisconsin_testing_classes, cv_int=10, ylim=[0.0, 0.10]) # plotter.plot_learning_curve_train_test_errors(nn, parkinson_training_inputs, parkinson_training_classes, parkinson_testing_inputs, parkinson_testing_classes, cv_int=10, ylim=[0.0, 0.30])
Layer("Rectifier", units=30), Layer("Rectifier", units=30), Layer("Softmax") ], learning_rate=.01, learning_rule='sgd', random_state=100, n_iter=T, # <---- Parameter being varied #learning_momentum=T, #valid_size=T, verbose=False) #Fit model model1 = clsfr.fit(X_trainn, Y_train) #Predictions y_hat = clsfr.predict(X_testnn) #Print scores print 'sgd test %s' % accuracy_score(y_hat, Y_test) end_time = time.time() times.append((end_time - start_time)) results.append(accuracy_score(y_hat, Y_test)) print 'time: ', (end_time - start_time) print # Plot results (accuracy & runtime) get_ipython().magic(u'matplotlib inline') fig, ax1 = plt.subplots() ax2 = ax1.twinx() ax1.plot(levels, results, 'g')
import numpy as np from sknn.mlp import Classifier, Layer from generate_data import get_training_set training_samples = 1000 test_size = 100 x_train, y_train = get_training_set(training_samples) x_test, y_test = get_training_set(test_size) nn = Classifier( layers=[ Layer("Maxout", units=100, pieces=2), Layer("Softmax")], learning_rate=0.001, n_iter=25) nn.fit(x_train, y_train) y_predicted = nn.predict(x_test) diff = y_predicted[0] - y_test hits = np.sum(diff == 0) hit_pct = hits*1.0 / test_size * 100 print 'test set of {test_size}, correctly predicts {hits}, equals {hit_pct} %'.format(**locals())
for l in range(0, cluster_size): if cluster_array[l] == m: index = l # print "Index Value : " + str(index) # MLP nn = Classifier(layers=[ Layer("Sigmoid", units=100), Layer("Softmax", name="OutputLayer", units=cluster_size) ], learning_rate=0.01, n_iter=100) nn.fit(X_Train, pred) pred_RBF = nn.predict(X_Test) for m in range(0, len(pred_RBF)): if pred_RBF[m] == index: pred_RBF[m] = 1 else: pred_RBF[m] = 0 acc_r = accuracy_score(Y_Test, pred_RBF) rec_r = recall_score(Y_Test, pred_RBF) prec_r = precision_score(Y_Test, pred_RBF) mclass_RBF.append(100 - (acc_r * 100)) rec_RBF.append(rec_r) prec_RBF.append(prec_r) # SVM - RBF Kernel
nn = Classifier(layers=[Layer("Rectifier", units=36), Layer("Softmax")], learning_rate=0.01, batch_size=100, n_iter=2000, valid_size=0.25, n_stable=200) # Training nn.fit(X_train, Y) pickle.dump(nn, open('nn_susy_classification.pkl', 'wb')) if not runTraining: nn = pickle.load(open('nn_susy_classification.pkl', 'rb')) # Testing pred_train = nn.predict(X_train) pred_test = nn.predict(X_test) probabilities_train = nn.predict_proba(X_train) probabilities_test = nn.predict_proba(X_test) print "Training sample...." print " Signal identified as signal (%) : ", 100.0 * np.sum( pred_train[nBackgroundEvents:nBackgroundEvents + nSignalEvents] == 1.0) / nSignalEvents print " Signal identified as background (%) : ", 100.0 * np.sum( pred_train[nBackgroundEvents:nBackgroundEvents + nSignalEvents] == 0.0) / nSignalEvents print " Background identified as signal (%) : ", 100.0 * np.sum( pred_train[0:nBackgroundEvents] == 1.0) / nBackgroundEvents print " Background identified as background (%): ", 100.0 * np.sum( pred_train[0:nBackgroundEvents] == 0.0) / nBackgroundEvents
dropout_rate=0.35, valid_size=0.15, learning_momentum=0.4, batch_size=20, #learning_rule='adam', n_iter=100, verbose=True) nn.fit(trI,trL); res=nn.score(teI,teL); print res yres = nn.predict(teI); print("\tReport:") print(classification_report(teL,yres)) print '\nConfusion matrix:\n',confusion_matrix(teL, yres) #print yres,teL """ 74 % accuracy
nn = Classifier(layers=[ Convolution("Rectifier", channels=9, kernel_shape=(3, 3), border_mode='full'), Convolution("Rectifier", channels=9, kernel_shape=(3, 3), border_mode='full'), Convolution("Rectifier", channels=9, kernel_shape=(3, 3), border_mode='full'), Convolution("Rectifier", channels=9, kernel_shape=(3, 3), border_mode='full'), Layer("Softmax") ], learning_rate=0.01, n_iter=10, verbose=True) nn.fit(trainX, trainY) # compute the predictions for the test data and show a classification report preds = nn.predict(testX) print "accuracy score : %s" % (accuracy_score(testY, preds)) print "classification report : " print classification_report(testY, preds)
from sknn.mlp import Classifier, Layer nn = Classifier(layers=[Layer("Rectifier", units=100), Layer("Softmax")], learning_rate=0.02, n_iter=10) nn.fit(X_train, y_train) y_valid = nn.predict(X_valid) score = nn.score(X_test, y_test)
for unitNumber in range(len(unitList)): print "result for %s dropout" %unitList[unitNumber] nn = Classifier( layers=[ Layer("Rectifier", units = 300), Layer("Softmax")], dropout_rate = unitList[unitNumber], learning_rate=0.001, loss_type = 'mcc', n_iter=25) nn.fit(xtrain, ytrain) ypredict = nn.predict(xtest) #) for i in range(len(xtest))] mm = [count_correct(ypredict.T, ytest.T, i) for i in range(len(ypredict.T))] mm1 = [count_correct_one(ypredict.T, ytest.T, i) for i in range(len(ypredict.T))] mm2 = [count_correct_zero(ypredict.T, ytest.T, i) for i in range(len(ypredict.T))] print mm print mm1 print mm2 count = 0 for i in range(len(ytest)): if ytest[i].tolist() == ypredict[i].tolist(): #print ytest[i].tolist()
y = train.ix[:, 0:1].as_matrix() from sknn.mlp import Classifier, Layer # This is the important stuff to adjust print "Creating classifier\n" nn = Classifier(layers=[ Layer('Tanh', units=100), Layer('Sigmoid', units=25), Layer('Softmax', units=5) ], learning_rate=.03, n_iter=73, batch_size=10) """ Uncomment to actually train whole data and write file """ outfile = open('output.csv', 'w') # change the file name writer = csv.writer(outfile) writer.writerow(['Id', 'y']) print "About to fit\n" nn.fit(X, y) print "About to predict" prediction = nn.predict(test.as_matrix()) print prediction ids = test.ix[:, 0:1] for i in range(prediction.shape[0]): writer.writerow([i + 45324, prediction[i][0]]) outfile.close()
else: train_output.append(0) i = i + 1 train_output = np.asarray(train_output) from sknn.mlp import Classifier, Layer nn = Classifier( layers=[Layer("Maxout", units=100, pieces=2), Layer("Softmax")], learning_rate=0.001, n_iter=500) nn.fit(trainDataVecs, train_output) result = nn.predict(testDataVecs) result = result.tolist() #print(result) #print(len(result)) #print(type(result)) #print(type(result[0])) true_positives = 0.0 true_negatives = 0.0 false_positives = 0.0 false_negatives = 0.0 for i in range(600): if (i < 300): if (result[i][0] == 1):
#Set random_state=0 for testing X_train, X_test, y_train, y_test, i_train, i_test = train_test_split( X_data, y_data, range(0, len(y_data)), test_size=0.20) classifier = Classifier( layers=[Layer("Sigmoid", units=int(sys.argv[4])), Layer("Softmax")], learning_rate=float(sys.argv[2]), n_iter=int(sys.argv[3])) classifier.fit(X_train, y_train) old_stdout = sys.stdout sys.stdout = open(os.devnull, 'w') results = classifier.predict(X_test) #May produce junk output results_proba = classifier.predict_proba(X_test) #May produce junk output sys.stdout.close() sys.stdout = old_stdout results = np.reshape(results, (results.shape[0], 1)) results_proba = np.reshape(results_proba, (results.shape[0], 2)) y_test = np.reshape(y_test, results.shape) Acc = 100 * (results == y_test).sum() / float(len(y_test)) Pre = 100 * (np.logical_and(results == 1, y_test == 1)).sum() / float( (results == 1).sum()) Rec = 100 * (np.logical_and(results == 1, y_test == 1)).sum() / float( (y_test == 1).sum()) F1S = 2 * (Pre * Rec) / float(Pre + Rec)