def neutral_net(train_data,test_data,n_est,maxd):
#ds = SupervisedDataSet(len(train_data[0,:])-1,1)
ds = ClassificationDataSet(len(train_data[0,:])-1,1,nb_classes=2,class_labels=['Lived','Died'])
X=[];y=[]; X1=[]; y1=[]
for row in range(0,len(train_data[:,0])):
X.append(train_data[row,1:].astype(int))
y.append([train_data[row,0].astype(int)])
#ds.addSample(train_data[row,1:].astype(int),train_data[row,0].astype(int))
#for row in range(0,len(test_data[:,0])):
# X.append(test_data[row,1:].astype(int))
# y.append([test_data[row,0].astype(int)])
X=np.array(X); y=np.array(y)
ds.setField('input',X)
ds.setField('target',y)
ds._convertToOneOfMany(bounds=[0,1]) # only for classification
#net = buildNetwork(len(train_data[0,:])-1,100, 1)
read = False
if read:
#net = NetworkReader.readFrom('10_200.xml') # hiddenclass=SigmoidLayer
pass
else:
net = buildNetwork(ds.indim,maxd,ds.outdim,bias=True,hiddenclass=SigmoidLayer,outclass=SoftmaxLayer)#SoftmaxLayer)
trainer = BackpropTrainer(net,dataset=ds,verbose=False,learningrate=0.01,momentum=0.1,weightdecay=0.01)
trainer.trainUntilConvergence(maxEpochs=n_est,continueEpochs=10,validationProportion=0.3)
#NetworkWriter.writeToFile(net, '10_200.xml')
tot = 0.
for a,b in zip(X,y):
val = net.activate(a)
tot+=int((val[0] > val[1] and b==0) or (val[0]<val[1] and b==1))
'''num = int((net.activate(a)<0.5 and b<0.5) or (net.activate(a)>0.5 and b>0.5))
tot+=num'''
for row in range(0,len(test_data[:,0])):
X1.append(test_data[row,1:].astype(int))
y1.append([test_data[row,0].astype(int)])
X1=np.array(X1); y1=np.array(y1)
tot1 = 0.
output = []
for a,b in zip(X1,y1):
val = net.activate(a)
tot1+=int((val[0] > val[1] and b==0) or (val[0]<val[1] and b==1))
output.append(int(val[0]<val[1]))
'''num = int((net.activate(a)<0.5 and b<0.5) or (net.activate(a)>0.5 and b>0.5))
tot1+=num
output.append(int(net.activate(a)>0.5))'''
pr.print_results(output)
return [tot/len(y),tot1/len(y1)]
def initializeNetwork(self):
self.net = buildNetwork(26, 15, 5, hiddenclass=TanhLayer, outclass=SoftmaxLayer) # 15 is just a mean
ds = ClassificationDataSet(26, nb_classes=5)
for x in self.train:
ds.addSample(x.frequency, self.encodingDict[x.lang])
ds._convertToOneOfMany()
trainer = BackpropTrainer(self.net, dataset=ds, weightdecay=0.01, momentum=0.1, verbose=True)
trainer.trainUntilConvergence(maxEpochs=100)
def main():
print "Calculating mfcc...."
mfcc_coeff_vectors_dict = {}
for i in range(1, 201):
extractor = FeatureExtractor(
'/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Happiness/HappinessAudios/' + str(i) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
for i in range(201, 401):
extractor = FeatureExtractor(
'/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Sadness/SadnessAudios/' + str(i - 200) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
audio_with_min_frames, min_frames = get_min_frames_audio(
mfcc_coeff_vectors_dict)
processed_mfcc_coeff = preprocess_input_vectors(
mfcc_coeff_vectors_dict, min_frames)
# frames = min_frames
# print frames
# print len(processed_mfcc_coeff['1'])
# for each_vector in processed_mfcc_coeff['1']:
# print len(each_vector)
print "mffcc found..."
classes = ["happiness", "sadness"]
training_data = ClassificationDataSet(
26, target=1, nb_classes=2, class_labels=classes)
# training_data = SupervisedDataSet(13, 1)
try:
network = NetworkReader.readFrom(
'network_state_frame_level_new2_no_pp1.xml')
except:
for i in range(1, 51):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
for each_vector in mfcc_coeff_vectors:
training_data.appendLinked(each_vector, [1])
for i in range(201, 251):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
for each_vector in mfcc_coeff_vectors:
training_data.appendLinked(each_vector, [0])
training_data._convertToOneOfMany()
print "prepared training data.."
print training_data.indim, training_data.outdim
network = buildNetwork(
training_data.indim, 5, training_data.outdim, fast=True)
trainer = BackpropTrainer(network, learningrate=0.01, momentum=0.99)
print "Before training...", trainer.testOnData(training_data)
trainer.trainOnDataset(training_data, 1000)
print "After training...", trainer.testOnData(training_data)
NetworkWriter.writeToFile(
network, "network_state_frame_level_new2_no_pp.xml")
def predict(self, x_test):
DS = ClassificationDataSet(x_test.shape[1], nb_classes=self.__class_num)
DS.setField('input', x_test)
DS.setField('target', np.zeros((x_test.shape[0], 1)))
DS._convertToOneOfMany()
out = self.__pybrain_bpnn.activateOnDataset(DS)
# this part converts an activation vector to a class number
# i'm saving this for a future purpose
#out = out.argmax(axis=1) # the highest output activation gives the class
#if not self.__class_zero_indexing: # indexing from 1 - add one to result
# out += 1
return out
def main():
print "Calculating mfcc...."
mfcc_coeff_vectors_dict = {}
for i in range(1, 201):
extractor = FeatureExtractor('/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Happiness/HappinessAudios/' + str(i) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
for i in range(201, 401):
extractor = FeatureExtractor('/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Sadness/SadnessAudios/' + str(i - 200) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
audio_with_min_frames, min_frames = get_min_frames_audio(mfcc_coeff_vectors_dict)
processed_mfcc_coeff = preprocess_input_vectors(mfcc_coeff_vectors_dict, min_frames)
frames = min_frames
print "mfcc found...."
classes = ["happiness", "sadness"]
try:
network = NetworkReader.readFrom('network_state_new_.xml')
except:
# Create new network and start Training
training_data = ClassificationDataSet(frames * 26, target=1, nb_classes=2, class_labels=classes)
# training_data = SupervisedDataSet(frames * 39, 1)
for i in range(1, 151):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
training_data.appendLinked(mfcc_coeff_vectors.ravel(), [1])
# training_data.addSample(mfcc_coeff_vectors.ravel(), [1])
for i in range(201, 351):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
training_data.appendLinked(mfcc_coeff_vectors.ravel(), [0])
# training_data.addSample(mfcc_coeff_vectors.ravel(), [0])
training_data._convertToOneOfMany()
network = buildNetwork(training_data.indim, 5, training_data.outdim)
trainer = BackpropTrainer(network, learningrate=0.01, momentum=0.99)
print "Before training...", trainer.testOnData(training_data)
trainer.trainOnDataset(training_data, 1000)
print "After training...", trainer.testOnData(training_data)
NetworkWriter.writeToFile(network, "network_state_new_.xml")
print "*" * 30 , "Happiness Detection", "*" * 30
for i in range(151, 201):
output = network.activate(processed_mfcc_coeff[str(i)].ravel())
# print output,
# if output > 0.7:
# print "happiness"
class_index = max(xrange(len(output)), key=output.__getitem__)
class_name = classes[class_index]
print class_name
def testNetwork(self):
correctAnswers = []
for testItem in self.test:
correctAnswers.append(self.encodingDict[testItem.lang])
ds_test = ClassificationDataSet(26, nb_classes=5)
for x in self.test:
ds_test.addSample(x.frequency, self.encodingDict[x.lang])
ds_test._convertToOneOfMany()
sumCorrect = sum(self.net.activateOnDataset(ds_test).argmax(axis=1) == correctAnswers)
print "\nNeural network: " + str(sumCorrect*100/float(len(self.test))) + "% efficiency"
def train(self, x, y, class_number=-1):
self.__class_num = max(np.unique(y).size, class_number)
if max(y) == self.__class_num:
self.__class_zero_indexing = False
y = np.array([i - 1 for i in y])
DS = ClassificationDataSet(x.shape[1], nb_classes=self.__class_num)
DS.setField('input', x)
DS.setField('target', y.reshape(y.size, 1))
DS._convertToOneOfMany()
hidden_num = (DS.indim + DS.outdim) / 2
self.__pybrain_bpnn = buildNetwork(DS.indim, hidden_num, DS.outdim, bias=True, hiddenclass=SigmoidLayer, outclass=SoftmaxLayer)
trainer = BackpropTrainer(self.__pybrain_bpnn, dataset=DS, learningrate=0.07, lrdecay=1.0, momentum=0.6)
trainer.trainUntilConvergence(DS, maxEpochs=30)
def train(network_file, input_length, output_length, training_data_file,
learning_rate, momentum, stop_on_convergence, epochs, classify):
n = get_network(network_file)
if classify:
ds = ClassificationDataSet(int(input_length),
int(output_length) * 2)
ds._convertToOneOfMany()
else:
ds = SupervisedDataSet(int(input_length), int(output_length))
training_data = get_training_data(training_data_file)
NetworkManager.last_training_set_length = 0
for line in training_data:
data = [float(x) for x in line.strip().split(',') if x != '']
input_data = tuple(data[:(int(input_length))])
output_data = tuple(data[(int(input_length)):])
ds.addSample(input_data, output_data)
NetworkManager.last_training_set_length += 1
t = BackpropTrainer(n,
learningrate=learning_rate,
momentum=momentum,
verbose=True)
print "training network " + network_storage_path + network_file
if stop_on_convergence:
t.trainUntilConvergence(ds, epochs)
else:
if classify:
t.trainOnDataset(ds['class'], epochs)
else:
t.trainOnDataset(ds, epochs)
error = t.testOnData()
print "training done"
if not math.isnan(error):
save_network(n, network_file)
else:
print "error occured, network not saved"
print "network saved"
return error
def mlp():
mlp = buildNetwork(26, 500, 3456, bias=True, outclass=SoftmaxLayer)
#print net['in'], net['hidden0'], net['out']
ds = import_data()
#http://stackoverflow.com/questions/27887936/attributeerror-using-pybrain-splitwithportion-object-type-changed
tstdata_temp, trndata_temp = ds.splitWithProportion(0.25)
tstdata = ClassificationDataSet(26, 1, nb_classes=3456)
for n in xrange(0, tstdata_temp.getLength()):
tstdata.addSample(tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1])
trndata = ClassificationDataSet(26, 1, nb_classes=3456)
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 type(trndata['class'])
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]
trainer = BackpropTrainer(mlp, trndata, verbose = True, learningrate=0.01)
trainer.trainUntilConvergence(maxEpochs=1000)
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
test_data = ClassificationDataSet(4, 1, nb_classes=3)
for n in range(test_data_temp.getLength()):
train_data.addSample(
test_data_temp.getSample(n)[0],
test_data_temp.getSample(n)[1])
val_data = ClassificationDataSet(4, 1, nb_classes=3)
for n in range(val_data_temp.getLength()):
val_data.addSample(
val_data_temp.getSample(n)[0],
val_data_temp.getSample(n)[1])
print(len(val_data))
train_data._convertToOneOfMany()
test_data._convertToOneOfMany()
val_data._convertToOneOfMany()
from pybrain.structure.modules import SoftmaxLayer
net = buildNetwork(4, 5, 3, outclass=SoftmaxLayer)
trainer = BackpropTrainer(net,
dataset=train_data,
learningrate=0.01,
momentum=0.1)
trainer.trainOnDataset(train_data, 100)
import numpy
out = net.activateOnDataset(test_data).argmax(axis=1)
