def train(X, y):
""" Trains and predicts dataset with a Neural Network classifier """
ds = ClassificationDataSet(len(X.columns), 1, nb_classes=2)
for k in xrange(len(X)):
ds.addSample(X.iloc[k], np.array(y[k]))
tstdata, trndata = ds.splitWithProportion(0.20)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
input_size = len(X.columns)
target_size = 1
hidden_size = 5
fnn = None
if os.path.isfile('fnn.xml'):
fnn = NetworkReader.readFrom('fnn.xml')
else:
fnn = buildNetwork(trndata.indim,
hidden_size,
trndata.outdim,
outclass=SoftmaxLayer)
trainer = BackpropTrainer(fnn,
dataset=trndata,
momentum=0.05,
learningrate=0.1,
verbose=False,
weightdecay=0.01)
trainer.trainUntilConvergence(verbose=False,
validationProportion=0.15,
maxEpochs=100,
continueEpochs=10)
NetworkWriter.writeToFile(fnn, 'oliv.xml')
predictions = trainer.testOnClassData(dataset=tstdata)
return tstdata['class'], predictions
def main():
images, labels = load_labeled_training(flatten=True)
images = standardize(images)
# images, labels = load_pca_proj(K=100)
shuffle_in_unison(images, labels)
ds = ClassificationDataSet(images.shape[1], 1, nb_classes=7)
for i, l in zip(images, labels):
ds.addSample(i, [l - 1])
# ds._convertToOneOfMany()
test, train = ds.splitWithProportion(0.2)
test._convertToOneOfMany()
train._convertToOneOfMany()
net = shortcuts.buildNetwork(train.indim, 1000, train.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(net, dataset=train, momentum=0.1, learningrate=0.01, weightdecay=0.05)
# trainer = RPropMinusTrainer(net, dataset=train)
# cv = validation.CrossValidator(trainer, ds)
# print cv.validate()
net.randomize()
tr_labels_2 = net.activateOnDataset(train).argmax(axis=1)
trnres = percentError(tr_labels_2, train["class"])
# trnres = percentError(trainer.testOnClassData(dataset=train), train['class'])
testres = percentError(trainer.testOnClassData(dataset=test), test["class"])
print "Training error: %.10f, Test error: %.10f" % (trnres, testres)
print "Iters: %d" % trainer.totalepochs
for i in range(100):
trainer.trainEpochs(10)
trnres = percentError(trainer.testOnClassData(dataset=train), train["class"])
testres = percentError(trainer.testOnClassData(dataset=test), test["class"])
trnmse = trainer.testOnData(dataset=train)
testmse = trainer.testOnData(dataset=test)
print "Iteration: %d, Training error: %.5f, Test error: %.5f" % (trainer.totalepochs, trnres, testres)
print "Training MSE: %.5f, Test MSE: %.5f" % (trnmse, testmse)
def consturt_train_data(self):
# print len(self.output_train)
# print len(self.eigenvector)
ds = ClassificationDataSet(self.vct_len, 1, nb_classes=2)
for i in range(len(self.output_train)):
ds.appendLinked(self.eigenvector[i], self.output_train[i])
# print ds
# print ds
ds.calculateStatistics()
# split training, testing, validation data set (proportion 4:1)
tstdata_temp, trndata_temp = ds.splitWithProportion(0.25)
tstdata = ClassificationDataSet(self.vct_len, 1, nb_classes=2)
for n in range(0, tstdata_temp.getLength()):
tstdata.appendLinked(
tstdata_temp.getSample(n)[0],
tstdata_temp.getSample(n)[1])
trndata = ClassificationDataSet(self.vct_len, 1, nb_classes=2)
for n in range(0, trndata_temp.getLength()):
trndata.appendLinked(
trndata_temp.getSample(n)[0],
trndata_temp.getSample(n)[1])
# one hot encoding
# print trndata
testdata = ClassificationDataSet(self.vct_len, 1, nb_classes=2)
test_data_temp = self.test_data
for n in range(len(test_data_temp)):
testdata.addSample(test_data_temp[n], [0])
# print testdata
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
testdata._convertToOneOfMany()
return trndata, tstdata, testdata, ds
class NeuralNetwork(BaseWorkflow):
def __init__(self, purpose='train', num_inputs=None, num_ouputs=None, classes=None, class_lables=None):
super(NeuralNetwork, self).__init__()
self.purpose = purpose
self.data_path = self.config.neural_net.get(self.purpose, None)
self.file_name = 'neural_net'
self.all_data = ClassificationDataSet(num_inputs,
num_ouputs,
nb_classes=classes,
class_labels=class_lables)
self.train = None
self.test = None
self.neural_network = None
self.train_result = None
self.test_result = None
self.cross_validation_result = None
def process(self):
self.prepare_train_test()
self.build_network()
trainer = self.train_network(dataset=self.train)
self.score_train_test(trainer=trainer)
self.cross_validate(dataset=self.all_data)
def add_sample(self, correlogram_matrix=None, target=None, sample_path=None):
self.all_data.addSample(correlogram_matrix, target)
logger.info('sample added from {sample_path}'.format(sample_path=sample_path))
def prepare_train_test(self):
self.test, self.train = self.all_data.splitWithProportion(0.25)
def build_network(self):
self.neural_network = buildNetwork(self.train.indim, 7, self.train.outdim, outclass=SoftmaxLayer) # feed forward network
def train_network(self, dataset=None):
starter_trainer = BackpropTrainer(self.neural_network, dataset=dataset, momentum=0.1, verbose=True, weightdecay=0.01)
starter_trainer.trainUntilConvergence(validationProportion=0.25, maxEpochs=100)
return starter_trainer
def score_train_test(self, trainer=None):
self.test_result = percentError(trainer.testOnClassData(dataset=self.test), self.test['class'])
logger.info('test error result: {result}'.format(result=self.test_result))
self.train_result = percentError(trainer.testOnClassData(dataset=self.train), self.train['class'] )
logger.info('train error result: {result}'.format(result=self.train_result))
def cross_validate(self, dataset=None):
trainer = BackpropTrainer(self.neural_network, dataset=dataset, momentum=0.1, verbose=True, weightdecay=0.01)
validator = CrossValidator(trainer=trainer, dataset=dataset, n_folds=10)
mean_validation_result = validator.validate()
self.cross_validation_result = mean_validation_result
logger.info('cross val result: {result}'.format(result=self.cross_validation_result))
@staticmethod
def save_network_to_xml(net=None, file_name=None):
NetworkWriter.writeToFile(net, file_name)
@staticmethod
def read_network_from_xml(file_name=None):
return NetworkReader.readFrom(file_name)
def prepare_datasets(inp,out,dataframe, ratio):
'''conversion from pandas dataframe to ClassificationDataSet of numpy
parameters:
inp: list of names of input features
out: list of names of output features(target value)
ratio: ratio of dimension of test to train dataset
'''
inp_dim = len(inp)
out_dim = len(out)
no_classes = 2
alldata = ClassificationDataSet(inp_dim,out_dim,no_classes)
inp = dataframe[inp]
out = dataframe[out]
#for [a,b,c],d in zip(inp.values,out.values):
for i in range(len(inp.values)):
d = out.values[i]
if d=='up': d = 0
elif d == 'down': d = 1
else: d =2
alldata.addSample(inp.values[i],d)
tstdata_temp, trndata_temp = alldata.splitWithProportion( ratio )
# to convert supervised datasets to classification datasets
tstdata = trndata = ClassificationDataSet(inp_dim, out_dim, no_classes)
for n in range(0, tstdata_temp.getLength()):
tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1] )
for n in range(0, trndata_temp.getLength()):
trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1])
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
return alldata, trndata, tstdata
def conductGeneration(generation, corpus):
'''
Conducts a generation of learning and testing on the input data
generation (int) --- the number of the generation
corpus (object) --- corpus object containing info needed
'''
# Set up the dataset skeleton
alldata = ClassificationDataSet(2, 1, nb_classes=3, class_labels=['a', 'b', 'c'])
# means = [(-1,0),(2,4),(3,1)]
# cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])]
# alldata = ClassificationDataSet(2, 1, nb_classes=3)
# for n in xrange(400):
# for klass in range(3):
# input = multivariate_normal(means[klass],cov[klass])
# print type(input)
# alldata.addSample(input, [klass])
alldata.addSample((0, 1), (1))
alldata.addSample((1, 0), (0))
alldata.addSample((0, 0), (2))
alldata.addSample((1, 1), (0))
trndata, partdata = alldata.splitWithProportion(0.5)
return alldata
def build_sample_nn(): means = [(-1,0),(2,4),(3,1)] cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])] alldata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(400): for klass in range(3): input = multivariate_normal(means[klass],cov[klass]) alldata.addSample(input, [klass]) tstdata_temp, trndata_temp = alldata.splitWithProportion(0.25) tstdata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(0, tstdata_temp.getLength()): tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1] ) trndata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(0, trndata_temp.getLength()): trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1] ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) fnn = buildNetwork( trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01) return trainer, fnn, tstdata
class NeuralNetLearner:
def __init__(self):
self.bunch = load_digits()
self.X = np.asarray(self.bunch.data, 'float32')
self.Y = np.asarray(self.bunch.target, 'float32')
#self.X, self.Y = nudge_dataset(self.X, self.bunch.target)
self.X = (self.X - np.min(self.X, 0)) / (np.max(self.X, 0) + 0.0001) # 0-1 scaling
self.ds = ClassificationDataSet(64, nb_classes=10, class_labels=self.bunch.target_names)
for (x, y) in zip(self.X, self.Y):
self.ds.addSample(x, y)
self.test_data, self.train_data = self.ds.splitWithProportion(0.3)
self.network = buildNetwork(64, 10, 1)
def get_datasets(self):
return self.train_data, self.test_data
def activate(self, x):
self.network.activate(x.tolist())
def fitness_func(self, x):
if not (x.size == 64):
print("Bad input vector: ", x)
return
sum_of_squared_error = 0
for (input, target) in self.ds:
sum_of_squared_error += (target - self.activate(input.tolist()))
return (sum_of_squared_error / self.ds.length)
def get_weights(self):
return
def createnetwork(n_hoglist,n_classlist,n_classnum,n_hiddensize=100):
n_inputdim=len(n_hoglist[0])
n_alldata = ClassificationDataSet(n_inputdim,1, nb_classes=n_classnum)
for i in range(len(n_hoglist)):
n_input = n_hoglist[i]
n_class = n_classlist[i]
n_alldata.addSample(n_input, [n_class])
n_tstdata, n_trndata = n_alldata.splitWithProportion( 0.25 )
n_trndata._convertToOneOfMany( )
n_tstdata._convertToOneOfMany( )
print "Number of training patterns: ", len(n_trndata)
print "Input and output dimensions: ", n_trndata.indim, n_trndata.outdim
print "First sample (input, target, class):"
print n_trndata['input'][0], n_trndata['target'][0], n_trndata['class'][0]
n_fnn = buildNetwork(n_trndata.indim,n_hiddensize, n_trndata.outdim, outclass=SoftmaxLayer)
n_trainer = BackpropTrainer(n_fnn, dataset=n_trndata, momentum=0.1, verbose=True, weightdecay=0.01)
n_result = 1
while n_result > 0.1:
print n_result
n_trainer.trainEpochs(1)
n_trnresult = percentError(n_trainer.testOnClassData(),
n_trndata['class'])
n_tstresult = percentError(n_trainer.testOnClassData(
dataset=n_tstdata), n_tstdata['class'])
print "epoch: %4d" % n_trainer.totalepochs, \
" train error: %5.2f%%" % n_trnresult, \
" test error: %5.2f%%" % n_tstresult
n_result = n_tstresult
def trainModel(self):
self.finalDataSet = np.c_[self.flattenNumericalData, self.flattenCategoryData, self.flattenTargetDataConverted]
self.finalHeaderSet = self.flattenNumericalHeader + self.flattenCategoryHeader + self.flattenTargetHeader
self.nattributes = self.flattenNumericalData.shape[1] + self.flattenCategoryData.shape[1]
ds = ClassificationDataSet(self.nattributes, 1, nb_classes=self.nbClasses)
for rowData in self.finalDataSet:
target = rowData[-1]
variables = rowData[0:-1]
ds.addSample(variables, target)
self.testDataSet, self.trainDataSet = ds.splitWithProportion(0.25)
self.testDataSet._convertToOneOfMany()
self.trainDataSet._convertToOneOfMany()
print self.testDataSet
print self.trainDataSet
self.net = buildNetwork(self.nattributes, self.nhiddenNerons, self.noutput, hiddenclass=TanhLayer, outclass=SigmoidLayer, bias=True)
self.trainer = BackpropTrainer(self.net, self.trainDataSet, learningrate=0.001, momentum=0.99)
begin0 = time.time()
# self.trainer.trainUntilConvergence(verbose=True, dataset=ds, validationProportion=0.25, maxEpochs=10)
for i in xrange(10):
begin = time.time()
self.trainer.trainEpochs(10)
end = time.time()
print 'iteration ', i, ' takes ', end-begin, 'seconds'
end0 = time.time()
print 'total time consumed: ', end0 - begin0
class NNetwork: def __init__(self): self.ds = ClassificationDataSet(7, 1, nb_classes=8) #8 since we have 8 gestures, 7 since we have 7 features def add_data(self, training_data): for gesture in training_data: self.ds.addSample(gesture[1], gesture[0]) #a method to add all the training data we have def newData(self, training_data): #a method for replacing the data already existing and adding data from scratch self.ds = ClassificationDataSet(7, 1, nb_classes=8) for gesture in training_data: self.ds.addSample(gesture[1], gesture[0]) def train(self, shouldPrint): tstdata, trndata = self.ds.splitWithProportion(0.2) #splits the data into training and verification data trndata._convertToOneOfMany() tstdata._convertToOneOfMany() self.fnn = buildNetwork(trndata.indim, 64, trndata.outdim, outclass=SoftmaxLayer) #builds a network with 64 hidden neurons self.trainer = BackpropTrainer(self.fnn, dataset=trndata, momentum=0.1, learningrate=0.01, verbose=True, weightdecay=0.1) #uses the backpropagation algorithm self.trainer.trainUntilConvergence(dataset=trndata, maxEpochs=100, verbose=True, continueEpochs=10, validationProportion=0.20) #early stopping with 20% as testing data trnresult = percentError( self.trainer.testOnClassData(), trndata['class'] ) tstresult = percentError( self.trainer.testOnClassData(dataset=tstdata ), tstdata['class'] ) if shouldPrint: print "epoch: %4d" % self.trainer.totalepochs, " train error: %5.2f%%" % trnresult, " test error: %5.2f%%" % tstresult def activate(self, data): #tests a particular data point (feature vector) return self.fnn.activate(data)
def conductGeneration(generation, corpus):
'''
Conducts a generation of learning and testing on the input data
generation (int) --- the number of the generation
corpus (object) --- corpus object containing info needed
'''
# Set up the dataset skeleton
alldata = ClassificationDataSet(2,
1,
nb_classes=3,
class_labels=['a', 'b', 'c'])
# means = [(-1,0),(2,4),(3,1)]
# cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])]
# alldata = ClassificationDataSet(2, 1, nb_classes=3)
# for n in xrange(400):
# for klass in range(3):
# input = multivariate_normal(means[klass],cov[klass])
# print type(input)
# alldata.addSample(input, [klass])
alldata.addSample((0, 1), (1))
alldata.addSample((1, 0), (0))
alldata.addSample((0, 0), (2))
alldata.addSample((1, 1), (0))
trndata, partdata = alldata.splitWithProportion(0.5)
return alldata
def train(self, inputData, verbose=True):
# Set of data to classify:
# - IMG_SIZE input dimensions per data point
# - 1 dimensional output
# - 4 clusters of classification
all_faces = ClassificationDataSet(IMG_SIZE, 1, nb_classes=4)
for entry in inputData:
(emotion, data) = entry
all_faces.addSample(data, [emotion])
# Generate a test and a train set from our data
test_faces, train_faces = all_faces.splitWithProportion(0.25)
# Hack to convert a 1-dimensional output into 4 output neurons
test_faces._convertToOneOfMany()
train_faces._convertToOneOfMany()
# Set up the actual network. These are the tunable params
self.fnn = buildNetwork(
train_faces.indim,
20,
train_faces.outdim,
outclass=SoftmaxLayer
)
# Set up the network trainer. Also nice tunable params
trainer = BackpropTrainer(
self.fnn,
dataset=train_faces,
momentum=0.1,
verbose=False,
weightdecay=0.01
)
tabledata = []
# Train this bitch.
if verbose:
# Report after every epoch if verbose
for i in range(EPOCHS):
trainer.trainEpochs(1)
trnresult = percentError( trainer.testOnClassData(),
train_faces['class'] )
tstresult = percentError( trainer.testOnClassData(
dataset=test_faces ), test_faces['class'] )
tabledata.append((trainer.totalepochs,trnresult,tstresult))
else:
trainer.trainEpochs(EPOCHS)
if verbose:
print "Epoch\tTrain Error\tTest Error"
for line in tabledata:
print "%4d\t" % line[0], \
"%5.2f%%\t\t" % line[1], \
"%5.2f%%" % line[2]
def nn():
DS = ClassificationDataSet(28, 1, nb_classes=4)
train = pickle.load(open('train_extracted_df.pkl', 'r'))
y = train["median_relevance"]
kfold_train_test = pickle.load(open('kfold_train_test.pkl', 'r'))
features = ['query_tokens_in_title', 'query_tokens_in_description', 'percent_query_tokens_in_description', 'percent_query_tokens_in_title', 'query_length', 'description_length', 'title_length', 'two_grams_in_q_and_t', 'two_grams_in_q_and_d', 'q_mean_of_training_relevance', 'q_median_of_training_relevance', 'avg_relevance_variance', 'average_title_1gram_similarity_1', 'average_title_2gram_similarity_1', 'average_title_1gram_similarity_2', 'average_title_2gram_similarity_2', 'average_title_1gram_similarity_3', 'average_title_2gram_similarity_3', 'average_title_1gram_similarity_4', 'average_title_2gram_similarity_4', 'average_description_1gram_similarity_1', 'average_description_2gram_similarity_1', 'average_description_2gram_similarity_2', 'average_description_1gram_similarity_2', 'average_description_1gram_similarity_3', 'average_description_2gram_similarity_3', 'average_description_1gram_similarity_4', 'average_description_2gram_similarity_4']
train = train[features]
for i in range(len(y)):
DS.addSample(train.values[i],y[i])
X = DS['input']
Y = DS['target']
dataTrain, dataTest = DS.splitWithProportion(0.8)
xTrain, yTrain = dataTrain['input'], dataTrain['target']
xTest, yTest = dataTest['input'], dataTest['target']
#fnn = RecurrentNetwork()
fnn = FeedForwardNetwork()
#fnn=buildNetwork(1,40,1,hiddenclass=TanhLayer, bias=True, outclass=SoftmaxLayer)
#fnn=buildNetwork(1,40,1,hiddenclass=LSTMLayer, bias=True, outclass=SoftmaxLayer)
inLayer = LinearLayer(28, name='inLayer')
hiddenLayer = SigmoidLayer(40, name='hiddenLayer0')
outLayer =LinearLayer(4, name='outLayer')
fnn.addInputModule(inLayer)
fnn.addModule(hiddenLayer)
fnn.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
fnn.addConnection(in_to_hidden)
fnn.addConnection(hidden_to_out)
fnn.sortModules()
trainer = BackpropTrainer(fnn, DS, verbose = True, learningrate=0.01)
#trainer.trainUntilConvergence(maxEpochs=1000)
trainer.trainEpochs(epochs=5)
prediction = fnn.activateOnDataset(dataTest)
out=[]
total_score = 0
for i in prediction:
class_index = max(xrange(len(i)), key=i.__getitem__)
out.append(class_index+1)
print str((class_index+1-yTest[class_index+1])/yTest[class_index+1])
df=pd.DataFrame(out,columns=['predict'])
df['real']=dataTest['target']
coun = 0
for i,row in df.iterrows():
if row[0]== row[1]:
coun+=1
print coun
print "df['real']", df['real'],type(df['real'][0])
print "df['predict']",df['predict'],type(df['predict'][0])
print df
v=Validator()
#v.MSE(out,dataTest['target'])
print "out",out
print "dataTest['target']",dataTest['target']
def prepare_datasets(inp, out, dataframe, ratio):
'''conversion from pandas dataframe to ClassificationDataSet of numpy
Parameters:
inp: list of names of input features
out: list of names of output features(target value)
dataframe: dataframe of the stock data
ratio: ratio of dimension of test to train dataset
Returns:
alldata: dataset for supervised classification
trndata: training dataset
tstdata: testing dataset
'''
inp_dim = len(inp)
out_dim = len(out)
no_classes = 2
alldata = ClassificationDataSet(inp_dim, out_dim, no_classes)
inp = dataframe[inp]
out = dataframe[out]
# for [a,b,c],d in zip(inp.values,out.values):
for i in range(len(inp.values)):
d = out.values[i]
if d == 'up':
d = 0
else: # d == 'down':
d = 1
# else:
# d = 2
alldata.addSample(inp.values[i], d)
alldata._convertToOneOfMany(bounds=[0, 1])
tstdata, trndata = alldata.splitWithProportion(ratio)
tstdata_temp, trndata_temp = alldata.splitWithProportion(ratio)
# to convert supervised datasets to classification datasets
# tstdata = trndata = ClassificationDataSet(inp_dim, out_dim, no_classes)
# for n in range(0, tstdata_temp.getLength()):
# tstdata.addSample(
# tstdata_temp.getSample(n)[0],
# tstdata_temp.getSample(n)[1])
# for n in range(0, trndata_temp.getLength()):
# trndata.addSample(
# trndata_temp.getSample(n)[0],
# trndata_temp.getSample(n)[1])
# trndata._convertToOneOfMany()
# tstdata._convertToOneOfMany()
return alldata, trndata, tstdata
def main():
# Get Data
dataSets = genfromtxt('normalizedData.csv', delimiter=',')
alldata = ClassificationDataSet(13, 1, nb_classes=3)
for dataSet in dataSets:
alldata.addSample(dataSet[1:14], int(dataSet[0]) - 1)
# Split the data
tstdata_temp, trndata_temp = alldata.splitWithProportion(0.25)
tstdata = ClassificationDataSet(13, 1, nb_classes=3)
for n in range(0, tstdata_temp.getLength()):
tstdata.addSample(
tstdata_temp.getSample(n)[0],
tstdata_temp.getSample(n)[1])
trndata = ClassificationDataSet(13, 1, nb_classes=3)
for n in range(0, trndata_temp.getLength()):
trndata.addSample(
trndata_temp.getSample(n)[0],
trndata_temp.getSample(n)[1])
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
# Build Network
fnn = buildNetwork(trndata.indim, 4, 4, 4, trndata.outdim)
# Construct Trainer
trainer = BackpropTrainer(fnn, trndata, learningrate=0.1)
# Train
while True:
trainer.trainEpochs(1)
trnresult = percentError(trainer.testOnClassData(), trndata['class'])
print("Training Test Error: %5.2f%%" % trnresult)
if trnresult < 1:
break
tstresult = percentError(trainer.testOnClassData(dataset=tstdata),
tstdata['class'])
print("test error: %5.2f%%" % tstresult)
out1 = fnn.activate([
0.70789474, 0.13636364, 0.60962567, 0.31443299, 0.41304348, 0.83448276,
0.70253165, 0.11320755, 0.51419558, 0.47098976, 0.33333333, 0.58608059,
0.71825963
])
out2 = fnn.activate([
0.26578947, 0.70355731, 0.54545455, 0.58762887, 0.10869565, 0.3862069,
0.29746835, 0.54716981, 0.29652997, 0.11262799, 0.25203252, 0.47619048,
0.21540656
])
out3 = fnn.activate([
0.81578947, 0.66403162, 0.73796791, 0.71649485, 0.2826087, 0.36896552,
0.08860759, 0.81132075, 0.29652997, 0.67576792, 0.10569106, 0.12087912,
0.20114123
])
print(out1, out2, out3)
def main():
means = [(-1,0),(2,4),(3,1)]
cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])]
alldata = ClassificationDataSet(2, 1, nb_classes=3)
for n in xrange(400):
for klass in range(3):
input = multivariate_normal(means[klass],cov[klass])
alldata.addSample(input, [klass])
tstdata, trndata = alldata.splitWithProportion( 0.25 )
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata['input'][0], trndata['target'][0], trndata['class'][0]
fnn = buildNetwork( trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer )
trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01)
ticks = arange(-3.,6.,0.2)
X, Y = meshgrid(ticks, ticks)
# need column vectors in dataset, not arrays
griddata = ClassificationDataSet(2,1, nb_classes=3)
for i in xrange(X.size):
griddata.addSample([X.ravel()[i],Y.ravel()[i]], [0])
griddata._convertToOneOfMany() # this is still needed to make the fnn feel comfy
for i in range(20):
trainer.trainEpochs(1)
trnresult = percentError( trainer.testOnClassData(),
trndata['class'] )
tstresult = percentError( trainer.testOnClassData(
dataset=tstdata ), tstdata['class'] )
print "epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
out = fnn.activateOnDataset(griddata)
out = out.argmax(axis=1) # the highest output activation gives the class
out = out.reshape(X.shape)
figure(1)
ioff() # interactive graphics off
clf() # clear the plot
hold(True) # overplot on
for c in [0,1,2]:
here, _ = where(tstdata['class']==c)
plot(tstdata['input'][here,0],tstdata['input'][here,1],'o')
if out.max()!=out.min(): # safety check against flat field
contourf(X, Y, out) # plot the contour
ion() # interactive graphics on
draw() # update the plot
ioff()
show()
def makeIrisDatasets():
# taken from iris data set at machine learning repository
alldata = ClassificationDataSet(4, 1, nb_classes=3, \
class_labels=['set','vers','virg'])
for p in pat:
t = p[2]
alldata.addSample(p[0], t)
tstdata, trndata = alldata.splitWithProportion(0.33)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
return trndata, tstdata
def createDS():
pat = [[[5.1, 3.5, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.0, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.7, 3.2, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.1, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.6, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.9, 1.7, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.4, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.4, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 2.9, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.7, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.4, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.0, 1.4, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[4.3, 3.0, 1.1, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.8, 4.0, 1.2, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.7, 4.4, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.9, 1.3, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.5, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.7, 3.8, 1.7, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.5, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.4, 1.7, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.7, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.6, 1.0, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.3, 1.7, 0.5], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.4, 1.9, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.0, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.4, 1.6, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 3.5, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 3.4, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.7, 3.2, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.1, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.4, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 4.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.5, 4.2, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.2, 1.2, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.5, 3.5, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 3.0, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.4, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.5, 1.3, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[4.5, 2.3, 1.3, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 3.2, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.5, 1.6, 0.6], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.9, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.0, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.2, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.3, 3.7, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.3, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[7.0, 3.2, 4.7, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.4, 3.2, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.9, 3.1, 4.9, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.3, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.5, 2.8, 4.6, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.8, 4.5, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 3.3, 4.7, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[4.9, 2.4, 3.3, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.6, 2.9, 4.6, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.2, 2.7, 3.9, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.0, 2.0, 3.5, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.9, 3.0, 4.2, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.2, 4.0, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.9, 4.7, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.9, 3.6, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.1, 4.4, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 3.0, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.7, 4.1, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.2, 2.2, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.5, 3.9, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.9, 3.2, 4.8, 1.8], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.8, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 2.5, 4.9, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.8, 4.7, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.4, 2.9, 4.3, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.6, 3.0, 4.4, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.8, 2.8, 4.8, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.0, 5.0, 1.7], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.9, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.6, 3.5, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.4, 3.8, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.4, 3.7, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.7, 3.9, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.7, 5.1, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[5.4, 3.0, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 3.4, 4.5, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.1, 4.7, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 2.3, 4.4, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 3.0, 4.1, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.5, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.6, 4.4, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 3.0, 4.6, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.6, 4.0, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[5.0, 2.3, 3.3, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.7, 4.2, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 3.0, 4.2, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.9, 4.2, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.2, 2.9, 4.3, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.1, 2.5, 3.0, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.8, 4.1, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 3.3, 6.0, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.7, 5.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[7.1, 3.0, 5.9, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.9, 5.6, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.8, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[7.6, 3.0, 6.6, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[4.9, 2.5, 4.5, 1.7], [0, 0, 1], [2], ['Iris-virginica']], [[7.3, 2.9, 6.3, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 2.5, 5.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.6, 6.1, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.2, 5.1, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.7, 5.3, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.8, 3.0, 5.5, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[5.7, 2.5, 5.0, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.8, 5.1, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 3.2, 5.3, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.5, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 3.8, 6.7, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 2.6, 6.9, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.0, 2.2, 5.0, 1.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.2, 5.7, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.6, 2.8, 4.9, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 2.8, 6.7, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.7, 4.9, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.3, 5.7, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.2, 6.0, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.2, 2.8, 4.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.1, 3.0, 4.9, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.8, 5.6, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.0, 5.8, 1.6], [0, 0, 1], [2], ['Iris-virginica']], [[7.4, 2.8, 6.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[7.9, 3.8, 6.4, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.8, 5.6, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.8, 5.1, 1.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.1, 2.6, 5.6, 1.4], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 3.0, 6.1, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 3.4, 5.6, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 3.1, 5.5, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.0, 3.0, 4.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.1, 5.4, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.1, 5.6, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.1, 5.1, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.7, 5.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.8, 3.2, 5.9, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.3, 5.7, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.0, 5.2, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.5, 5.0, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.2, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.2, 3.4, 5.4, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.9, 3.0, 5.1, 1.8], [0, 0, 1], [2], ['Iris-virginica']]]
alldata = ClassificationDataSet(4, 1, nb_classes=3, \
class_labels=['set','vers','virg'])
for p in pat:
t = p[2]
alldata.addSample(p[0],t)
tstdata, trndata = alldata.splitWithProportion( 0.33 )
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
return trndata, tstdata
def EvaluateArtificialNeuralNetwork(training_data, Input_features, Output_feature, NUMBER_CLASSES, HIDDEN_NEURONS, NUMBER_LAYERS, dataset_name, ParameterVal):
X = training_data[Input_features]
Y = training_data[Output_feature]
ds = ClassificationDataSet(X.shape[1], nb_classes=NUMBER_CLASSES)
for k in xrange(len(X)):
ds.addSample((X.ix[k,:]), Y.ix[k,:])
tstdata_temp, trndata_temp = ds.splitWithProportion(.25)
tstdata = ClassificationDataSet(X.shape[1], nb_classes=NUMBER_CLASSES)
for n in xrange(0, tstdata_temp.getLength()):
tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1] )
trndata = ClassificationDataSet(X.shape[1], nb_classes=NUMBER_CLASSES)
for n in xrange(0, trndata_temp.getLength()):
trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1] )
if NUMBER_CLASSES > 1:
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
'''*****Actual computation with one layer and HIDDEN_NEURONS number of neurons********'''
fnn = buildNetwork( trndata.indim, HIDDEN_NEURONS , trndata.outdim, outclass=SoftmaxLayer )
trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=False, weightdecay=0.01)
trainer.trainUntilConvergence(maxEpochs=3)
trnresult = percentError( trainer.testOnClassData(), trndata['class'] )
tstresult = percentError( trainer.testOnClassData(dataset=tstdata ), tstdata['class'] )
print ("Accuracy with Artificial Neural Network: epoch: " + str(trainer.totalepochs) + " TrainingSet:" + str(1-trnresult/100) + " TestSet:" + str(1-tstresult/100))
'''****** Graphical Representation*****'''
'''tot_hidden_tests, X_train, X_test, Y_train, Y_test, training_error, test_error = InitiateErrorCalcData(ParameterVal, training_data[Input_features], training_data[Output_feature])
for hidden_unit in tot_hidden_tests:
print ("Computing hidden unit :" + str(hidden_unit))
model = buildNetwork( trndata.indim, hidden_unit , trndata.outdim, outclass=SoftmaxLayer )
temp_trainer = BackpropTrainer( model, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01)
temp_trainer.trainUntilConvergence(maxEpochs=3)
training_error.append(MSE( temp_trainer.testOnClassData(), trndata['class'] ))
test_error.append(MSE( temp_trainer.testOnClassData(dataset=tstdata ), tstdata['class'] ))
PlotErrors(tot_hidden_tests, training_error, test_error, dataset_name, "Number of Hidden Units for single layer ANN", "MSE")'''
'''*****Graphical representation with multiple layers and HIDDEN_NEURONS number of neurons********'''
'''ffn = FeedForwardNetwork()
def makeIrisDatasets():
# taken from iris data set at machine learning repository
alldata = ClassificationDataSet(4, 1, nb_classes=3, \
class_labels=['set','vers','virg'])
for p in pat:
t = p[2]
alldata.addSample(p[0],t)
tstdata, trndata = alldata.splitWithProportion( 0.33 )
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
return trndata, tstdata
def createDS():
# taken from iris data set at machine learning repository
pat = [[[5.1, 3.5, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.0, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.7, 3.2, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.1, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.6, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.9, 1.7, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.4, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.4, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 2.9, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.7, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.4, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.0, 1.4, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[4.3, 3.0, 1.1, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.8, 4.0, 1.2, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.7, 4.4, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.9, 1.3, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.5, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.7, 3.8, 1.7, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.5, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.4, 1.7, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.7, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.6, 1.0, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.3, 1.7, 0.5], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.4, 1.9, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.0, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.4, 1.6, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 3.5, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 3.4, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.7, 3.2, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.1, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.4, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 4.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.5, 4.2, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.2, 1.2, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.5, 3.5, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 3.0, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.4, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.5, 1.3, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[4.5, 2.3, 1.3, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 3.2, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.5, 1.6, 0.6], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.9, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.0, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.2, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.3, 3.7, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.3, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[7.0, 3.2, 4.7, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.4, 3.2, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.9, 3.1, 4.9, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.3, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.5, 2.8, 4.6, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.8, 4.5, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 3.3, 4.7, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[4.9, 2.4, 3.3, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.6, 2.9, 4.6, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.2, 2.7, 3.9, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.0, 2.0, 3.5, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.9, 3.0, 4.2, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.2, 4.0, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.9, 4.7, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.9, 3.6, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.1, 4.4, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 3.0, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.7, 4.1, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.2, 2.2, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.5, 3.9, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.9, 3.2, 4.8, 1.8], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.8, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 2.5, 4.9, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.8, 4.7, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.4, 2.9, 4.3, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.6, 3.0, 4.4, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.8, 2.8, 4.8, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.0, 5.0, 1.7], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.9, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.6, 3.5, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.4, 3.8, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.4, 3.7, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.7, 3.9, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.7, 5.1, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[5.4, 3.0, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 3.4, 4.5, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.1, 4.7, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 2.3, 4.4, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 3.0, 4.1, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.5, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.6, 4.4, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 3.0, 4.6, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.6, 4.0, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[5.0, 2.3, 3.3, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.7, 4.2, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 3.0, 4.2, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.9, 4.2, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.2, 2.9, 4.3, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.1, 2.5, 3.0, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.8, 4.1, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 3.3, 6.0, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.7, 5.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[7.1, 3.0, 5.9, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.9, 5.6, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.8, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[7.6, 3.0, 6.6, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[4.9, 2.5, 4.5, 1.7], [0, 0, 1], [2], ['Iris-virginica']], [[7.3, 2.9, 6.3, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 2.5, 5.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.6, 6.1, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.2, 5.1, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.7, 5.3, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.8, 3.0, 5.5, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[5.7, 2.5, 5.0, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.8, 5.1, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 3.2, 5.3, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.5, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 3.8, 6.7, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 2.6, 6.9, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.0, 2.2, 5.0, 1.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.2, 5.7, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.6, 2.8, 4.9, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 2.8, 6.7, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.7, 4.9, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.3, 5.7, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.2, 6.0, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.2, 2.8, 4.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.1, 3.0, 4.9, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.8, 5.6, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.0, 5.8, 1.6], [0, 0, 1], [2], ['Iris-virginica']], [[7.4, 2.8, 6.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[7.9, 3.8, 6.4, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.8, 5.6, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.8, 5.1, 1.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.1, 2.6, 5.6, 1.4], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 3.0, 6.1, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 3.4, 5.6, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 3.1, 5.5, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.0, 3.0, 4.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.1, 5.4, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.1, 5.6, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.1, 5.1, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.7, 5.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.8, 3.2, 5.9, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.3, 5.7, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.0, 5.2, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.5, 5.0, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.2, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.2, 3.4, 5.4, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.9, 3.0, 5.1, 1.8], [0, 0, 1], [2], ['Iris-virginica']]]
alldata = ClassificationDataSet(4, 1, nb_classes=3, \
class_labels=['set','vers','virg'])
for p in pat:
t = p[2]
alldata.addSample(p[0],t)
tstdata, trndata = alldata.splitWithProportion( 0.33 )
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
return trndata, tstdata
def run_neural_network(xn, xt, yl, epochs, hidden_neurons):
f = open('total_list_probe_mac_all.txt', 'rb')
role_list = pickle.load(f)
teacher_list = [a for a in role_list if a[0] == 1]
student_list = [a for a in role_list if a[0] == 0]
print 'len st: ', len(student_list), 'len te: ', len(teacher_list)
student_list = random.sample(student_list, len(teacher_list))
total_list = student_list + teacher_list
shuffle(total_list)
alldata = ClassificationDataSet(72, 1, nb_classes=2)
for (o, i) in total_list:
alldata.addSample(i, o)
tstdata, trndata = alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata['input'][0], trndata['target'][0], trndata['class'][0]
fnn = buildNetwork(trndata.indim,
hidden_neurons,
trndata.outdim,
outclass=SoftmaxLayer)
trainer = BackpropTrainer(fnn,
trndata,
momentum=0.1,
verbose=True,
weightdecay=0.01)
for i in range(epochs):
trnresult = percentError(trainer.testOnClassData(), trndata['class'])
tstresult = percentError(trainer.testOnClassData(dataset=tstdata),
tstdata['class'])
trainer.trainEpochs(1)
xn.append(trnresult)
xt.append(tstresult)
yl.append(i)
print "epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
def neuralNetworksTrain(self):
alldata = ClassificationDataSet( 23, 1, nb_classes=2)
train_input_data = self.loadData(self.train_file)
test_input_data = self.loadData(self.test_file)
target = [x[1] for x in train_input_data]
target = target[1:]
features = [x[2:] for x in train_input_data]
features = features[1:]
for i in range(0,len(features)):
alldata.addSample(features[i], target[i])
tstdata, trndata = alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
INPUT_FEATURES = 23
CLASSES = 2
HIDDEN_NEURONS = 200
WEIGHTDECAY = 0.1
MOMENTUM = 0.1
EPOCH = 2
fnn = buildNetwork(trndata.indim, HIDDEN_NEURONS, trndata.outdim,outclass=LinearLayer)
trainer = BackpropTrainer(fnn, dataset=trndata, momentum=MOMENTUM,verbose=True, weightdecay=WEIGHTDECAY)
trainer.trainEpochs(EPOCH)
pred = trainer.testOnClassData(dataset=tstdata)
actual = tstdata['class']
self.computeAccuracy(actual,pred)
#trnresult = percentError(trainer.testOnClassData(),
# trndata['class'])
#tstresult = percentError(trainer.testOnClassData(
# dataset=tstdata), tstdata['class'])
# print("epoch: %4d" % trainer.totalepochs,
# " train error: %5.2f%%" % trnresult,
# " test error: %5.2f%%" % tstresult)
#out = fnn.activateOnDataset(griddata)
# the highest output activation gives the class
#out = out.argmax(axis=1)
#out = out.reshape(X.shape)
testFeatures = [x[2:] for x in test_input_data]
testFeatures = testFeatures[1:]
prediction = [fnn.activate(x) for x in testFeatures]
i=0
print "Neural Network Architecture:"
print "Layers: Input layer, Hidden Layer and Output Layers"
print "Epoch = "+str(EPOCH)
print "Neurons in the hidden layer:"+str(HIDDEN_NEURONS)
print "Precision recall F score support metrics for Neural Networks "
print precision_recall_fscore_support(actual,pred)
print "confusion matrix"
print confusion_matrix(actual,pred)
def create_dataset():
'''Create a random dataset to train and test the network on '''
means = [(-1,0),(2,4),(3,1)]
cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])]
alldata=ClassificationDataSet(2,1,nb_classes=3)
for n in xrange(400):
for klass in range(3):
input=multivariate_normal(means[klass],cov[klass])
alldata.addSample(input,[klass])
tstdata,trndata=alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
return (trndata,tstdata)
def classif():
means = [(-1, 0), (2, 4), (3, 1)]
cov = [diag([1, 1]), diag([0.5, 1.2]), diag([1.5, 0.7])]
alldata = ClassificationDataSet(2, 1, nb_classes=3)
for n in xrange(400):
for klass in range(3):
input = multivariate_normal(means[klass], cov[klass])
alldata.addSample(input, [klass])
tstdata, trndata = alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata['input'][0], trndata['target'][0], trndata['class'][0]
fnn = buildNetwork(trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(fnn,
dataset=trndata,
momentum=0.1,
verbose=True,
weightdecay=0.01)
ticks = arange(-3., 6., 0.2)
X, Y = meshgrid(ticks, ticks)
# need column vectors in dataset, not arrays
griddata = ClassificationDataSet(2, 1, nb_classes=3)
for i in xrange(X.size):
griddata.addSample([X.ravel()[i], Y.ravel()[i]], [0])
griddata._convertToOneOfMany(
) # this is still needed to make the fnn feel comfy
for i in range(20):
trainer.trainEpochs(5)
trnresult = percentError(trainer.testOnClassData(), trndata['class'])
tstresult = percentError(trainer.testOnClassData(dataset=tstdata),
tstdata['class'])
print "epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
out = fnn.activateOnDataset(griddata)
out = out.argmax(
axis=1) # the highest output activation gives the class
out = out.reshape(X.shape)
print out
def main():
ds = ClassificationDataSet(30, class_labels=POSITIONS)
data = data_set()
for name, positions in data.iteritems():
for position, state in positions.iteritems():
if position == 'fetalalt':
position = 'fetal'
ds.addSample(state, [POSITIONS.index(position)])
testing_ds, training_ds = ds.splitWithProportion( 0.25 )
testing_ds._convertToOneOfMany()
training_ds._convertToOneOfMany()
ds._convertToOneOfMany()
hidden = HIDDEN_NEURONS
net = buildNetwork(ds.indim, hidden, ds.outdim, hiddenclass=SoftmaxLayer)
trainer = BackpropTrainer(net, ds, verbose=True, learningrate=0.01, momentum=0.1)
trainer.trainUntilConvergence(maxEpochs=ITERATIONS, validationProportion=0.1)
wrong = 0
for name, positions in data.iteritems():
for position, state in positions.iteritems():
if position == 'fetalalt':
position = 'fetal'
guess = POSITIONS[net.activate(state).argmax()]
if guess != position:
wrong += 1
print "%10s actual: %10s guess: %10s" % (name, position, guess)
print 'wrong: ', wrong, '/', len(data) * 4
out_name = 'network-wrong-%02d-hidden-%d.pickle' % (wrong, hidden)
print "will save to '%s'" % out_name
print "Do you want to use this? (y/n): ",
answer = sys.stdin.readline().strip()
while answer not in ('y', 'n'):
print "Enter (y/n): ",
answer = sys.stdin.readline().strip()
if answer == 'y':
with open(out_name, 'w') as f:
pickle.dump(net, f)
subprocess.call(['rm', 'network-good.pickle'])
subprocess.call(['ln', '-s', out_name, 'network-good.pickle'])
subprocess.call(['touch', os.path.join('..', 'server', 'app.py')])
def init_classifier(self, hidden_units = 20): data = ClassificationDataSet(len(self.channels), nb_classes=5) # Prepare the dataset for i in range(len(self.classification_proc)): data.appendLinked(self.y_proc[i], self.classification_proc[i]) # Make global for test purposes self.data = data # Prepare training and test data, 75% - 25% proportion self.testdata, self.traindata = data.splitWithProportion(0.25) #self.traindata._convertToOneOfMany() #self.testdata._convertToOneOfMany() # CHECK the number of hidden units fnn = buildNetwork(self.traindata.indim, hidden_units, self.traindata.outdim) # CHECK meaning of the parameters trainer = BackpropTrainer(fnn, dataset=self.traindata, momentum=0, verbose=True, weightdecay=0.01) return fnn, trainer, data
def fnn():
data = orange.ExampleTable("D:\\Back-up-THICK_on_Vista\\Orange\\W1BIN.tab")#input_dict['data'])
addMetaID(data)
n_attrs = len(data.domain.attributes)
classes = list(data.domain.classVar.values)
pbdata = ClassificationDataSet(n_attrs, class_labels=classes)
for ex in data:
pbdata.appendLinked([x.value for x in list(ex)[:n_attrs]], [classes.index(ex.getclass().value)])
tstdata, trndata = pbdata.splitWithProportion( 0.25 )
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata['input'][0], trndata['target'][0], trndata['class'][0]
def run_neural_network(xn, xt, yl, epochs, hidden_neurons):
f = open('total_list_probe_mac_all.txt', 'rb')
role_list = pickle.load(f)
teacher_list = [a for a in role_list if a[0] == 1]
student_list = [a for a in role_list if a[0] == 0]
print 'len st: ', len(student_list), 'len te: ', len(teacher_list)
student_list = random.sample(student_list, len(teacher_list))
total_list = student_list + teacher_list
shuffle(total_list)
alldata = ClassificationDataSet(72, 1, nb_classes=2)
for (o, i) in total_list:
alldata.addSample(i, o)
tstdata, trndata = alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata['input'][0], trndata['target'][0], trndata['class'][0]
fnn = buildNetwork(trndata.indim, hidden_neurons, trndata.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer( fnn, trndata, momentum=0.1, verbose=True, weightdecay=0.01)
for i in range(epochs):
trnresult = percentError( trainer.testOnClassData(),
trndata['class'] )
tstresult = percentError( trainer.testOnClassData(
dataset=tstdata ), tstdata['class'] )
trainer.trainEpochs(1)
xn.append(trnresult)
xt.append(tstresult)
yl.append(i)
print "epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
def main():
images, labels = load_labeled_training(flatten=True)
images = standardize(images)
#images, labels = load_pca_proj(K=100)
shuffle_in_unison(images, labels)
ds = ClassificationDataSet(images.shape[1], 1, nb_classes=7)
for i, l in zip(images, labels):
ds.addSample(i, [l - 1])
#ds._convertToOneOfMany()
test, train = ds.splitWithProportion(0.2)
test._convertToOneOfMany()
train._convertToOneOfMany()
net = shortcuts.buildNetwork(train.indim,
1000,
train.outdim,
outclass=SoftmaxLayer)
trainer = BackpropTrainer(net,
dataset=train,
momentum=0.1,
learningrate=0.01,
weightdecay=0.05)
#trainer = RPropMinusTrainer(net, dataset=train)
#cv = validation.CrossValidator(trainer, ds)
#print cv.validate()
net.randomize()
tr_labels_2 = net.activateOnDataset(train).argmax(axis=1)
trnres = percentError(tr_labels_2, train['class'])
#trnres = percentError(trainer.testOnClassData(dataset=train), train['class'])
testres = percentError(trainer.testOnClassData(dataset=test),
test['class'])
print "Training error: %.10f, Test error: %.10f" % (trnres, testres)
print "Iters: %d" % trainer.totalepochs
for i in range(100):
trainer.trainEpochs(10)
trnres = percentError(trainer.testOnClassData(dataset=train),
train['class'])
testres = percentError(trainer.testOnClassData(dataset=test),
test['class'])
trnmse = trainer.testOnData(dataset=train)
testmse = trainer.testOnData(dataset=test)
print "Iteration: %d, Training error: %.5f, Test error: %.5f" % (
trainer.totalepochs, trnres, testres)
print "Training MSE: %.5f, Test MSE: %.5f" % (trnmse, testmse)
def split_samples(ratio):
samples = {}
for sound in SOUNDS:
samples[sound] = glob.glob(os.path.join('.', sound, '*'))
print len(samples[sound]), " x ", sound
ds = ClassificationDataSet(FEATURES, 1, nb_classes=3) #TODO: what's the 2nd parameter?
for sound in samples:
for f in samples[sound]:
# if f.lower() != ".\\kick\\XR10bd01.WAV".lower():
# continue
print f
features = process_sample(*load_sample(f))
ds.addSample(features, [SOUND_INDICES[sound]]) #why put this in an array?
training_set, test_set = ds.splitWithProportion( ratio )
training_set._convertToOneOfMany( )
test_set._convertToOneOfMany( )
return training_set, test_set
def fnn():
data = orange.ExampleTable(
"D:\\Back-up-THICK_on_Vista\\Orange\\W1BIN.tab") #input_dict['data'])
addMetaID(data)
n_attrs = len(data.domain.attributes)
classes = list(data.domain.classVar.values)
pbdata = ClassificationDataSet(n_attrs, class_labels=classes)
for ex in data:
pbdata.appendLinked([x.value for x in list(ex)[:n_attrs]],
[classes.index(ex.getclass().value)])
tstdata, trndata = pbdata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata['input'][0], trndata['target'][0], trndata['class'][0]
def main():
(X, Y, Ynames) = load_magic_data()
X = StandardScaler().fit_transform(X)
X, Y = shuffle(X, Y, n_samples=None, random_state=None)
N = len(Y)
alldata = ClassificationDataSet(inp=10, target=1, nb_classes=2)
for i in range(N):
alldata.addSample(X[i], Y[i])
tstdata, trndata = alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata['input'][0], trndata['target'][0], trndata['class'][0]
fnn = buildNetwork(trndata.indim, 15, trndata.outdim, bias=True)
trainer = BackpropTrainer(fnn,
dataset=trndata,
momentum=0,
learningrate=0.005,
verbose=True)
trainer.trainUntilConvergence(maxEpochs=100)
trnresult = 100 - percentError(trainer.testOnClassData(), trndata['class'])
tstresult = 100 - percentError(trainer.testOnClassData(dataset=tstdata),
tstdata['class'])
print "Epoch:%4d" % trainer.totalepochs, \
" train accuracy: %5.2f%%" % trnresult, \
" test accuracy: %5.2f%%" % tstresult
plt.figure(figsize=(8, 8))
plt.plot(trainer.trainingErrors)
plt.xlabel('Training Steps')
plt.ylabel('Training Error')
plt.show()
def generateDS(input_, out, num, xtrain, ytrain):
alldata = ClassificationDataSet(input_, out, nb_classes=num)
for x, y in zip(xtrain, ytrain):
alldata.addSample(x, y)
tstdata_temp, trndata_temp = alldata.splitWithProportion(.3)
tstdata = ClassificationDataSet(input_, out, nb_classes=num)
for n in xrange(tstdata_temp.getLength()):
tstdata.addSample(*[tstdata_temp.getSample(n)[i] for i in range(2)])
trndata = ClassificationDataSet(input_, out, nb_classes=num)
for n in xrange(trndata_temp.getLength()):
trndata.addSample(*[trndata_temp.getSample(n)[i] for i in range(2)])
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
return trndata, tstdata
def split_dataset(data_path, ratio):
dataset = ClassificationDataSet(256, 10)
with open("../data/semeion.data") as data:
for record in data:
line = record[:1812]
line = line.replace(' ', ', ')
data = line[:2046]
dataList = data.split(',')
dataList = map(float, dataList)
ans = line[2048:-2]
ansList = ans.split(',')
ansList = map(int, ansList)
dataset.appendLinked(dataList, ansList)
train_data, test_data = dataset.splitWithProportion(ratio)
return train_data, test_data
def split_dataset(data_path, ratio):
dataset = ClassificationDataSet(256, 10)
with open("../data/semeion.data") as data:
for record in data:
line = record[:1812]
line = line.replace(' ', ', ')
data = line[:2046]
dataList = data.split(',')
dataList = map(float, dataList)
ans = line[2048:-2]
ansList = ans.split(',')
ansList = map(int, ansList)
dataset.appendLinked(dataList, ansList)
train_data, test_data = dataset.splitWithProportion(ratio)
return train_data, test_data
def initializeDatasets(nCount, klassCount):
means = [(-1, 0), (2, 4), (3, 1)]
cov = [diag([1.0, 1]), diag([0.5, 1.2]), diag([1.5, 0.7])]
alldata = ClassificationDataSet(2, 1, nb_classes=3)
for n in xrange(nCount):
for klass in range(klassCount):
input = multivariate_normal(means[klass], cov[klass])
alldata.addSample(input, [klass])
tstdata, trndata = alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata["input"][0], trndata["target"][0], trndata["class"][0]
return tstdata, trndata
def init_classifier(self, hidden_units=20):
data = ClassificationDataSet(len(self.channels), nb_classes=5)
# Prepare the dataset
for i in range(len(self.classification_proc)):
data.appendLinked(self.y_proc[i], self.classification_proc[i])
# Make global for test purposes
self.data = data
# Prepare training and test data, 75% - 25% proportion
self.testdata, self.traindata = data.splitWithProportion(0.25)
#self.traindata._convertToOneOfMany()
#self.testdata._convertToOneOfMany()
# CHECK the number of hidden units
fnn = buildNetwork(self.traindata.indim, hidden_units,
self.traindata.outdim)
# CHECK meaning of the parameters
trainer = BackpropTrainer(fnn,
dataset=self.traindata,
momentum=0,
verbose=True,
weightdecay=0.01)
return fnn, trainer, data
def neuralNetworksTrain(self):
alldata = ClassificationDataSet( 23, 1, nb_classes=2)
train_input_data = self.loadData(self.train_file)
test_input_data = self.loadData(self.test_file)
target = [x[1] for x in train_input_data]
target = target[1:]
features = [x[2:] for x in train_input_data]
features = features[1:]
for i in range(0,len(features)):
alldata.addSample(features[i], target[i])
tstdata, trndata = alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
INPUT_FEATURES = 23
CLASSES = 2
HIDDEN_NEURONS = 200
WEIGHTDECAY = 0.1
MOMENTUM = 0.1
EPOCH = 2
fnn = buildNetwork(trndata.indim, HIDDEN_NEURONS, trndata.outdim,outclass=LinearLayer)
trainer = BackpropTrainer(fnn, dataset=trndata, momentum=MOMENTUM,verbose=True, weightdecay=WEIGHTDECAY)
trainer.trainEpochs(EPOCH)
pred = trainer.testOnClassData(dataset=tstdata)
actual = tstdata['class']
self.computeAccuracy(actual,pred)
testFeatures = [x[2:] for x in test_input_data]
testFeatures = testFeatures[1:]
prediction = [fnn.activate(x) for x in testFeatures]
i=0
print "Neural Network Architecture:"
print "Layers: Input layer, Hidden Layer and Output Layers"
print "Epoch = "+str(EPOCH)
print "Neurons in the hidden layer:"+str(HIDDEN_NEURONS)
print "Precision recall F score support metrics for Neural Networks "
print precision_recall_fscore_support(actual,pred)
print "confusion matrix"
print confusion_matrix(actual,pred)
def hello_classify(): from pybrain.datasets import ClassificationDataSet from pybrain.utilities import percentError from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer from pybrain.structure.modules import SoftmaxLayer from pylab import ion, ioff, figure, draw, contourf, clf, show, hold, plot from scipy import diag, arange, meshgrid, where from numpy.random import multivariate_normal means = [(-1,0),(2,4),(3,1)] cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])] alldata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(400): for klass in range(3): input = multivariate_normal(means[klass],cov[klass]) alldata.addSample(input, [klass]) tstdata, trndata = alldata.splitWithProportion( 0.25 ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0] fnn = buildNetwork( trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01) ticks = arange(-3.,6.,0.2) X, Y = meshgrid(ticks, ticks) # need column vectors in dataset, not arrays griddata = ClassificationDataSet(2,1, nb_classes=3) for i in xrange(X.size): griddata.addSample([X.ravel()[i],Y.ravel()[i]], [0]) griddata._convertToOneOfMany() # this is still needed to make the fnn feel comfy
def split_into_train_and_test_dataset(raw_dataset, split_ratio=0.75):
"""
:param raw_dataset:
:param split_ratio:
:return:
"""
# for each test point:input(x1, x2), output(class)
classification_dataset = ClassificationDataSet(2, 1, nb_classes=2)
# add data element to the dataset
for i in range(len(raw_dataset)):
x1, x2, class_for_each_point = raw_dataset[i]
classification_dataset.addSample([x1, x2], [class_for_each_point])
train_dataset, test_dataset = classification_dataset.splitWithProportion(split_ratio)
# small technique:train_dataset's out dimension change from 1 to 2, and class info in train_dataset['class']
train_dataset._convertToOneOfMany()
test_dataset._convertToOneOfMany()
return train_dataset, test_dataset
def main():
# Get Data
dataSets = genfromtxt('normalizedData.csv', delimiter=',')
alldata = ClassificationDataSet(13, 1, nb_classes=3)
for dataSet in dataSets:
alldata.addSample(dataSet[1:14], int(dataSet[0]) - 1)
# Split the data
tstdata_temp, trndata_temp = alldata.splitWithProportion(0.25)
tstdata = ClassificationDataSet(13, 1, nb_classes=3)
for n in range(0, tstdata_temp.getLength()):
tstdata.addSample(
tstdata_temp.getSample(n)[0],
tstdata_temp.getSample(n)[1])
trndata = ClassificationDataSet(13, 1, nb_classes=3)
for n in range(0, trndata_temp.getLength()):
trndata.addSample(
trndata_temp.getSample(n)[0],
trndata_temp.getSample(n)[1])
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
# Build Network
fnn = buildNetwork(trndata.indim, 4, 4, 4, trndata.outdim)
# Construct Trainer
trainer = BackpropTrainer(fnn, trndata, learningrate=0.1)
# Train
while True:
trainer.trainEpochs(1)
trnresult = percentError(trainer.testOnClassData(), trndata['class'])
print("Training Test Error: %5.2f%%" % trnresult)
if trnresult < 1:
break
tstresult = percentError(trainer.testOnClassData(dataset=tstdata),
tstdata['class'])
print("test error: %5.2f%%" % tstresult)
def trainNeuralNetwork():
""" Trains a neural network with the current dataset """
print("Generating training and testing data....")
statements, labels = generateBalancedDataset()
""" Vectorize the statements """
vect = TfidfVectorizer(analyzer="word",
ngram_range=(1, 2),
stop_words="english",
max_df=0.70,
min_df=3)
print("Vectorizing the statements and labels...")
statements = vect.fit_transform(statements)
n_input_neurons = len(vect.vocabulary_)
""" vectorize the labels """
v_labels = []
for label in labels:
if label == "left":
v_labels.append(np.array([1, 0]))
elif label == "right":
v_labels.append(np.array([0, 1]))
labels = v_labels
""" Build the dataset """
print("building the dataset...")
ds = ClassificationDataSet(n_input_neurons,
2,
nb_classes=2,
class_labels=["left", "right"])
for k, statement in enumerate(statements):
ds.addSample(statement.toarray()[0], labels[k])
""" Split training and testing data """
training_data, testing_data = ds.splitWithProportion(0.1)
""" Build the neural network accordingly """
nn = buildNetwork(n_input_neurons, int(float(n_input_neurons) / 2), 2)
""" Build the nn trainer """
trainer = BackpropTrainer(nn, dataset=ds, verbose=True)
return (trainer, vect, nn, testing_data)
def main():
(X, Y, Ynames) = load_magic_data()
X = StandardScaler().fit_transform(X)
X,Y = shuffle(X, Y, n_samples=None, random_state=None)
N = len(Y)
alldata = ClassificationDataSet(inp = 10, target = 1, nb_classes=2)
for i in range(N):
alldata.addSample(X[i],Y[i])
tstdata, trndata = alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata['input'][0], trndata['target'][0], trndata['class'][0]
fnn = buildNetwork(trndata.indim, 15, trndata.outdim, bias=True)
trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0, learningrate = 0.005, verbose=True)
trainer.trainUntilConvergence(maxEpochs=100)
trnresult = 100 - percentError(trainer.testOnClassData(), trndata['class'])
tstresult = 100 - percentError(trainer.testOnClassData(dataset=tstdata), tstdata['class'])
print "Epoch:%4d" % trainer.totalepochs, \
" train accuracy: %5.2f%%" % trnresult, \
" test accuracy: %5.2f%%" % tstresult
plt.figure(figsize=(8,8))
plt.plot(trainer.trainingErrors)
plt.xlabel('Training Steps')
plt.ylabel('Training Error')
plt.show()
def Neural_Network(X, y, tst_size, col_size, n_epochs): ## Load the dataset into the neural network. ds = ClassificationDataSet(3*col_size, 1) for i in range(len(X)): ds.addSample(X[i], y[i]) ## Split the data into training and testing. tstdata_tmp, trndata_tmp = ds.splitWithProportion(tst_size) tstdata = ClassificationDataSet(3*col_size, 1, nb_classes = 2) for n in xrange(0, tstdata_tmp.getLength()): tstdata.addSample( tstdata_tmp.getSample(n)[0], tstdata_tmp.getSample(n)[1] ) trndata = ClassificationDataSet(3*col_size, 1, nb_classes = 2) for n in xrange(0, trndata_tmp.getLength()): trndata.addSample( trndata_tmp.getSample(n)[0], trndata_tmp.getSample(n)[1] ) ## And this code converts 1 output to 40 binary outputs, to encode classes with one output neuron per class. trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) ## Training. fnn = buildNetwork(trndata.indim, col_size , trndata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=trndata) ## Compute percentage error. trainer.trainEpochs (n_epochs) score = (100 - percentError( trainer.testOnClassData (dataset=tstdata ), tstdata['class']))/100 return score
def Neural_Network(X, y, tst_size, col_size, n_epochs): ## Load the dataset into the neural network. ds = ClassificationDataSet(3*col_size, 1) for i in range(len(X)): ds.addSample(X[i], y[i]) ## Split the data into training and testing. tstdata_tmp, trndata_tmp = ds.splitWithProportion(tst_size) tstdata = ClassificationDataSet(3*col_size, 1, nb_classes = 2) for n in range(0, tstdata_tmp.getLength()): tstdata.addSample( tstdata_tmp.getSample(n)[0], tstdata_tmp.getSample(n)[1] ) trndata = ClassificationDataSet(3*col_size, 1, nb_classes = 2) for n in range(0, trndata_tmp.getLength()): trndata.addSample( trndata_tmp.getSample(n)[0], trndata_tmp.getSample(n)[1] ) ## And this code converts 1 output to 40 binary outputs, to encode classes with one output neuron per class. trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) ## Training. fnn = buildNetwork(trndata.indim, col_size , trndata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=trndata) ## Compute percentage error. trainer.trainEpochs (n_epochs) score = (100 - percentError( trainer.testOnClassData (dataset=tstdata ), tstdata['class']))/100 return score
def train_readout_nn(net_file, net_key, readout_window=np.arange(0, 1), num_hidden=2):
(samps, all_stim_classes, Ninternal) = get_samples(net_file, net_key, readout_window)
alldata = ClassificationDataSet(Ninternal, 1, nb_classes=len(all_stim_classes))
for readout_state,stim_class in samps:
alldata.addSample(readout_state, [stim_class])
tstdata, trndata = alldata.splitWithProportion( 0.25 )
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
fnn = buildNetwork( trndata.indim, num_hidden, trndata.outdim, hiddenclass=TanhLayer, outclass=SoftmaxLayer)
trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0.1, verbose=False, weightdecay=0.01)
test_errors = []
num_slope_samps = 10
slope = 0.0
while True:
if len(test_errors) >= num_slope_samps:
coef = np.polyfit(np.arange(num_slope_samps), test_errors[-num_slope_samps:], 1)
slope = coef[0]
if slope > 0.0:
print 'Test error slope > 0.0, stopping'
break
trainer.train()
train_err = percentError( trainer.testOnClassData(), trndata['class'])
test_err = percentError( trainer.testOnClassData(dataset=tstdata), tstdata['class'])
print "Iteration: %d, train_err=%0.4f, test_err=%0.4f, slope=%0.4f" % (trainer.totalepochs, train_err, test_err, slope)
test_errors.append(test_err)
return (train_err, test_err, fnn, trainer)
# Now initialize the neural network, use width*height*3 for the size of the data because all of the images need to
# be resized and then flattened
print "Loading image files..."
ds = ClassificationDataSet(width * height * 3)
for k in xrange(len(allFiles)):
img = Image.open(allFiles[k])
img = img.resize([width, height], PIL.Image.ANTIALIAS)
imgArray = numpy.asarray(img.getdata())
ds.addSample(ravel(imgArray), supportedFruits.index(allTargets[k]))
# Split the data set into 75/25, the 75% being the data that is used to train, the 25% will be used to test
# the quality of the neural network training
# train until convergence does an automatic split
if numEpochs == 0:
tstdata, trndata = ds.splitWithProportion(0.00)
else:
tstdata, trndata = ds.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
# Build a new neural network
print "Building the neural network, in-dimension: " + str(
trndata.indim) + ", out-dimension: " + str(trndata.outdim)
# fnn = buildNetwork(trndata.indim, 25, trndata.outdim, outclass=SoftmaxLayer) #25 worked ok
fnn = buildNetwork(trndata.indim, 100, trndata.outdim, outclass=SoftmaxLayer)
# Create a new backpropagation trainer
print "Creating backpropagation trainer..."
#trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0.1, learningrate=0.01 , verbose=True, weightdecay=0.01)
print 'time taken: ', time.clock() # in seconds
# can probably merge the upper 2?
counter = 0
ds = ClassificationDataSet(unique_ingreds_length, unique_cuisine_length , nb_classes=unique_cuisine_length)
for k in xrange(recipes_length):
ds.addSample(big_data_matrix[k],cuisine_matrix[k])
counter += 1
print "added into dataset... ", counter, " / ", recipes_length
# No memory error when using a desktop with 16g ram
print 'classification dataset done!'
print 'time taken: ', time.clock()
tstdata, trndata = ds.splitWithProportion( 0.25 )
tstdata_temp, trndata_temp = ds.splitWithProportion(0.25)
tstdata = ClassificationDataSet(unique_ingreds_length, unique_cuisine_length , nb_classes=unique_cuisine_length)
for n in xrange(0, tstdata_temp.getLength()):
tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1] )
trndata = ClassificationDataSet(unique_ingreds_length, unique_cuisine_length , nb_classes=unique_cuisine_length)
for n in xrange(0, trndata_temp.getLength()):
trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1] )
trndata._convertToOneOfMany( )
tstdata._convertToOneOfMany( )
print 'split = ok'
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel
# pybrain has its own data sample class that we must add
# our training and test set to
ds = ClassificationDataSet(4096, 1 , nb_classes=40)
for k in xrange(len(X)):
ds.addSample(ravel(X[k]),y[k])
# their equivalent of train test split
test_data, training_data = ds.splitWithProportion( 0.25 )
len(training_data.data['input'][0])
test_data
# pybrain's version of dummy variables
test_data._convertToOneOfMany( )
training_data._convertToOneOfMany( )
training_data['input']
training_data['target']
test_data.indim
olivettiData = datasets.fetch_olivetti_faces()
dataFeatures = olivettiData.data
dataTargets = olivettiData.target
#plt.matshow(olivettiData.images[11], cmap=cm.Greys_r)
#plt.show()
#print dataTargets[11]
#print dataFeatures.shape
dataSet = ClassificationDataSet(4096, 1, nb_classes=40)
for i in xrange(len(dataFeatures)):
dataSet.addSample(np.ravel(dataFeatures[i]), dataTargets[i])
testData, trainingData = dataSet.splitWithProportion(0.25)
trainingData._convertToOneOfMany()
testData._convertToOneOfMany()
neuralNetwork = buildNetwork(trainingData.indim,
64,
trainingData.outdim,
outclass=SoftmaxLayer)
trainer = BackpropTrainer(neuralNetwork,
dataset=trainingData,
momentum=0.2,
learningrate=0.01,
verbose=True,
weightdecay=0.02)
raw_inputs = raw_data[:, 0:-1]
raw_target = raw_data[:, 9:]
assert (raw_inputs.shape[0] == raw_target.shape[0]
), "Inputs count and target count do not match"
all_data = ClassificationDataSet(9,
1,
nb_classes=2,
class_labels=['Benign', 'Malignant'])
all_data.setField('input', raw_inputs)
all_data.setField('target', raw_target)
all_data.setField('class', raw_target)
test_data_temp, training_data_temp = all_data.splitWithProportion(0.33)
test_data = ClassificationDataSet(9,
1,
nb_classes=2,
class_labels=['Benign', 'Malignant'])
for n in xrange(0, test_data_temp.getLength()):
test_data.addSample(
test_data_temp.getSample(n)[0],
test_data_temp.getSample(n)[1])
training_data = ClassificationDataSet(9,
1,
nb_classes=2,
class_labels=['Benign', 'Malignant'])
for n in xrange(0, training_data_temp.getLength()):
image = Image.open("8x8.png")
image = image.convert('LA')
image.thumbnail((8, 8), Image.ANTIALIAS)
image.save("numberOut.png")
#set y as target
X, y = digits.data, digits.target
#add the contents of digits to a dataset
daSet = ClassificationDataSet(64, 1)
for k in xrange(len(X)):
daSet.addSample(X.ravel()[k], y.ravel()[k])
#split the dataset into training and testing
testData, trainData = daSet.splitWithProportion(0.40)
#convert the data into 10 separate digits
trainData._convertToOneOfMany()
testData._convertToOneOfMany()
#check for the save file and load
if os.path.isfile('dig.xml'):
net = NetworkReader.readFrom('dig.xml')
net.sorted = False
net.sortModules()
else:
# net = FeedForwardNetwork()
net = buildNetwork(64,
37,
10,
def exec_algo(xml_file, output_location):
rootObj=ml.parse(xml_file)
#Getting the root element so that we get the subclasses and its members and member function
file=open(rootObj.MachineLearning.classification.datafile)
var_inp=rootObj.MachineLearning.classification.input
var_out=rootObj.MachineLearning.classification.output
classes=rootObj.MachineLearning.classification.classes
DS=ClassificationDataSet(var_inp,var_out,nb_classes=classes)
for line in file.readlines():
data=[float(x) for x in line.strip().split(',') if x != '']
inp=tuple(data[:var_inp])
output=tuple(data[var_inp:])
DS.addSample(inp,output)
split=rootObj.MachineLearning.classification.split
tstdata,trndata=DS.splitWithProportion(split)
trdata=ClassificationDataSet(trndata.indim,var_out,nb_classes=classes)
tsdata=ClassificationDataSet(tstdata.indim,var_out,nb_classes=classes)
for i in xrange(trndata.getLength()):
trdata.addSample(trndata.getSample(i)[0],trndata.getSample(i)[1])
for i in xrange(tstdata.getLength()):
tsdata.addSample(tstdata.getSample(i)[0],tstdata.getSample(i)[1])
trdata._convertToOneOfMany()
tsdata._convertToOneOfMany()
hiddenNeurons=rootObj.MachineLearning.classification.algorithm.RadialBasisFunctionNetwork.hiddenNeurons
fnn=FeedForwardNetwork()
inputLayer=LinearLayer(trdata.indim)
hiddenLayer=GaussianLayer(hiddenNeurons)
outputLayer=LinearLayer(trdata.outdim)
fnn.addInputModule(inputLayer)
fnn.addModule(hiddenLayer)
fnn.addOutputModule(outputLayer)
in_to_hidden=FullConnection(inputLayer,hiddenLayer)
hidden_to_outputLayer=FullConnection(hiddenLayer,outputLayer)
fnn.addConnection(in_to_hidden)
fnn.addConnection(hidden_to_outputLayer)
fnn.sortModules()
learningrate=rootObj.MachineLearning.classification.algorithm.RadialBasisFunctionNetwork.learningRate
momentum=rootObj.MachineLearning.classification.algorithm.RadialBasisFunctionNetwork.momentum
epochs=rootObj.MachineLearning.classification.algorithm.RadialBasisFunctionNetwork.epochs
trainer=BackpropTrainer(fnn,dataset=trdata, verbose=True, learningrate=learningrate, momentum=momentum)
trainer.trainEpochs(epochs=epochs)
#trainer.train()
#trainer.trainUntilConvergence(dataset=trdata, maxEpochs=500, verbose=True, continueEpochs=10, validationProportion=0.25)
trresult=percentError(trainer.testOnClassData(),trdata['class'])
#testingResult=percentError(trainer.testOnClassData(dataset=tsdata),tsdata['class'])
#print "Training accuracy : %f , Testing Accuracy: %f" % (100-trresult,100-testingResult)
print "Training accuracy : %f " % (100-trresult)
ts=time.time()
directory = output_location + sep + str(int(ts)) ;
makedirs(directory)
fileObject=open(output_location + sep + str(int(ts)) + sep + 'pybrain_RBF','w')
pickle.dump(trainer,fileObject)
pickle.dump(fnn,fileObject)
fileObject.close()
class2vec1=np.reshape(class2im1,np.size(class2im1)) class2vec2=np.reshape(class2im2,np.size(class2im1)) class2vec3=np.reshape(class2im3,np.size(class2im1)) class2vec4=np.reshape(class2im4,np.size(class2im1)) class2vec5=np.reshape(class2im5,np.size(class2im1)) trainData1=np.array([class1vec1,class1vec2,class1vec3,class1vec4,class1vec5,class2vec1,class2vec2,clas s2vec3,class2vec4,class2vec5]) ncomponents=9 pca = PCA(n_components=ncomponents) pca.fit(trainData1) trainData=pca.transform(trainData1) trainLabels=np.array([1,1,1,1,1,2,2,2,2,2]) trnData = ClassificationDataSet(ncomponents, 1, nb_classes=2) for i in range(len(trainLabels)): trnData.addSample(trainData[i,:], trainLabels[i]-1) tstdata, trndata = trnData.splitWithProportion( 0.40 ) trnData._convertToOneOfMany( ) fnn = buildNetwork( trnData.indim, 20, trnData.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trnData, momentum=0.1, verbose=True, weightdecay=0.01) for i in range(20): trainer.trainEpochs(5) trnresult=percentError(trainer.testOnClassData(),trnData['class']) print "epoch: %4d" % trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ outTrain=fnn.activateOnDataset(trnData) outTrainLabels=outTrain.argmax(axis=1)+1 numErrTrain=numErr=sum(abs(outTrainLabels!=trainLabels)) accTrain=1-numErrTrain/len(trainLabels) from __future__ import division import numpy as np from pybrain.datasets import ClassificationDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from pylab import ion, ioff, figure, draw, contourf, clf, show, hold, plot
from scipy import diag, arange, meshgrid, where
from numpy.random import multivariate_normal
means = [(-1, 0), (2, 4), (3, 1)]
cov = [diag([1, 1]), diag([0.5, 1.2]), diag([1.5, 0.7])]
alldata = ClassificationDataSet(2, 1, nb_classes=3)
for n in xrange(400):
for klass in range(3):
input = multivariate_normal(means[klass], cov[klass])
alldata.addSample(input, [klass])
tstdata_temp, trndata_temp = alldata.splitWithProportion(0.25)
tstdata = ClassificationDataSet(2, 1, nb_classes=3)
for n in xrange(0, tstdata_temp.getLength()):
tstdata.addSample(
tstdata_temp.getSample(n)[0],
tstdata_temp.getSample(n)[1])
trndata = ClassificationDataSet(2, 1, nb_classes=3)
for n in xrange(0, trndata_temp.getLength()):
trndata.addSample(
trndata_temp.getSample(n)[0],
trndata_temp.getSample(n)[1])
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from pylab import ion, ioff, figure, draw, contourf, clf, show, hold, plot
from scipy import diag, arange, meshgrid, where
from numpy.random import multivariate_normal
means = [(-1, 0), (2, 4), (3, 1)]
cov = [diag([1, 1]), diag([0.5, 1.2]), diag([1.5, 0.7])]
alldata = ClassificationDataSet(2, 1, nb_classes=3)
for n in xrange(400):
for klass in range(3):
input = multivariate_normal(means[klass], cov[klass])
alldata.addSample(input, [klass])
tstdata, trndata = alldata.splitWithProportion(0.25)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
print "Number of training patterns: ", len(trndata)
print "Input and output dimensions: ", trndata.indim, trndata.outdim
print "First sample (input, target, class):"
print trndata['input'][0], trndata['target'][0], trndata['class'][0]
fnn = buildNetwork(trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(fnn,
dataset=trndata,
momentum=0.1,
verbose=True,
weightdecay=0.01)
