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 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 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)
