def run(epochs, network_file, file_length, part_length, dominant_frequncies, show_graph, verbose_output):
start_time = time.time()
learner = dominant_freqs_learner.DominantFreqsLearner(file_length, part_length ,dominant_frequncies)
all_files = get_all_split_files()
if verbose_output:
print 'started adding files to dataset at ' + time.ctime()
for f in all_files:
try:
learner.add_split_file(f, channel=None, verbose=verbose_output)
except:
pass
dataset_add_time = time.time() - start_time
if verbose_output:
print 'finished adding file to dataset at ' + time.ctime()
errors = []
learning_start_time = time.time()
for epoch in range(epochs):
error = learner.train_single_epoch()
if verbose_output:
print '{0}: epoch {1} : {2}'.format(time.ctime(), epoch, error)
errors.append(error)
learning_time = time.time() - learning_start_time
NetworkWriter.writeToFile(learner._net, network_file)
if show_graph:
plot_graph(errors)
return (errors, dataset_add_time, learning_time)
def main():
start_time = time.time()
novice = ArtificialNovice()
genius = ArtificialGenius()
game = HangmanGame(genius, novice)
if __debug__:
print "------------------- EVALUATION ------------------------"
network = NetworkReader.readFrom("../IA/network_weight_1000.xml")
j = 0
while j < 1:
game.launch(False, None, network)
j += 1
print ("--- %s total seconds ---" % (time.time() - start_time))
else:
print "------------------- LEARNING ------------------------"
network = buildNetwork(3, 4, 1, hiddenclass=SigmoidLayer)
ds = SupervisedDataSet(3, 1)
i = 0
while i < 100:
game.launch(True, ds)
i += 1
print " INITIATE trainer : "
trainer = BackpropTrainer(network, ds)
print " START trainer : "
start_time_trainer = time.time()
trainer.train()
print ("--- END trainer in % seconds ---" % (time.time() - start_time_trainer))
print " START EXPORT network : "
NetworkWriter.writeToFile(network, "../IA/network_weight_test_learning.xml")
print " END EXPORT network : "
def main():
start_time = time.time()
novice = ArtificialNovice()
genius = ArtificialGenius()
game = HangmanGame(genius, novice)
if __debug__:
print "------------------- EVALUATION ------------------------"
network = NetworkReader.readFrom('../IA/network_weight_1000.xml')
j = 0
while j < 1:
game.launch(False, None, network)
j += 1
print("--- %s total seconds ---" % (time.time() - start_time))
else:
print "------------------- LEARNING ------------------------"
network = buildNetwork(3, 4, 1, hiddenclass=SigmoidLayer)
ds = SupervisedDataSet(3, 1)
i = 0
while i < 100:
game.launch(True, ds)
i += 1
print " INITIATE trainer : "
trainer = BackpropTrainer(network, ds)
print " START trainer : "
start_time_trainer = time.time()
trainer.train()
print("--- END trainer in % seconds ---" %
(time.time() - start_time_trainer))
print " START EXPORT network : "
NetworkWriter.writeToFile(network,
'../IA/network_weight_test_learning.xml')
print " END EXPORT network : "
def learn(self):
try:
self.data_for_training = []
mem = Memory('http://localhost:9200')
data = mem.get_data()
categories = list(data.keys())
for category in data:
for req in data[category]:
self.data_for_training.append(
[req.token, [categories.index(category)]])
net = buildNetwork(len(self.data_for_training[0][0]),
15,
len(categories),
hiddenclass=SoftmaxLayer,
recurrent=False)
ds = ClassificationDataSet(len(self.data_for_training[0][0]),
nb_classes=len(categories),
class_labels=categories)
for data in self.data_for_training:
ds.addSample(data[0], data[1])
ds._convertToOneOfMany()
trainer = BackpropTrainer(net,
ds,
momentum=0.1,
learningrate=0.01,
verbose=True)
trainer.trainUntilConvergence(maxEpochs=500)
NetworkWriter.writeToFile(net, 'net.xml')
except Exception as e:
raise e
return net
def run(epochs, network_file, file_length, part_length, dominant_frequncies,
show_graph, verbose_output):
start_time = time.time()
learner = dominant_freqs_learner.DominantFreqsLearner(
file_length, part_length, dominant_frequncies)
all_files = get_all_split_files()
if verbose_output:
print 'started adding files to dataset at ' + time.ctime()
for f in all_files:
try:
learner.add_split_file(f, channel=None, verbose=verbose_output)
except:
pass
dataset_add_time = time.time() - start_time
if verbose_output:
print 'finished adding file to dataset at ' + time.ctime()
errors = []
learning_start_time = time.time()
for epoch in range(epochs):
error = learner.train_single_epoch()
if verbose_output:
print '{0}: epoch {1} : {2}'.format(time.ctime(), epoch, error)
errors.append(error)
learning_time = time.time() - learning_start_time
NetworkWriter.writeToFile(learner._net, network_file)
if show_graph:
plot_graph(errors)
return (errors, dataset_add_time, learning_time)
def train_nn(trainer,
structure=(2, ),
momentum=0.99,
learningrate=0.001,
train_time=200):
load_json = json.load(open(trainer.file_location, "r"))
training_data = load_json["data"]
metadata = load_json["metadata"][0] # 0 because is an array
struct = (3, ) + structure + (3, )
print("TRAINING")
net = buildNetwork(
*struct, bias=True) # * converts list tuple into separate parameters
ds = SupervisedDataSet(3, 3)
for i in training_data:
in_pos = trainer.get_bin(i["pos"], metadata["max_pos"],
metadata["num_pos"])
in_vel = trainer.get_bin(i["vel"], metadata["max_vel"],
metadata["num_vel"])
in_ang = trainer.get_bin(i["ang"], metadata["max_ang"],
metadata["num_ang"])
inp = [in_pos, in_vel, in_ang]
out = [i["out1"], i["out2"], i["out3"]]
ds.addSample(inp, out)
train = BackpropTrainer(net,
ds,
learningrate=learningrate,
momentum=momentum)
train.trainEpochs(train_time)
NetworkWriter.writeToFile(net, 'nn_trained_networks/trained_nn.xml')
def main():
first_layer_size = 11 + 1 + 1 + 150 + 5 + 5 + 5 + 1
net = buildNetwork(first_layer_size, 200, 1)
path = os.path.join(os.path.dirname(os.path.dirname(os.getcwd())),
'network.xml')
NetworkWriter.writeToFile(net, path)
print("Neural Network initialized.")
def save_network(self,name_of_the_net):
print "Saving the trained network to file"
if self.network is None:
print "Network has not been trained!!"
else:
NetworkWriter.writeToFile(self.network, name_of_the_net)
print "Saving Finished"
def train(self):
print "Training"
trndata, tstdata = self.ds.splitWithProportion(.1)
self.trainer.trainUntilConvergence(verbose=True,
trainingData=trndata,
maxEpochs=1000)
self.trainer.testOnData(tstdata, verbose= True)
# if raw_input('Save Network?: y/n\n')=='y':
NetworkWriter.writeToFile(self.net, 'Network1.xml')
print 'Saving network'
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 save_network(self,name_of_the_net):
print "Saving the trained network to file"
if self.network is None:
print "Network has not been trained!!"
else:
NetworkWriter.writeToFile(self.network, name_of_the_net)
fileName = name_of_the_net.replace('.xml','')
fileName = fileName+'_testIndex.txt'
np.savetxt(fileName,self.tstIndex)
print "Saving Finished"
def neuralNet(info, test_data):
ann = FeedForwardNetwork()
'''
Initiate the input nodes, hidden layer nodes,
and the output layer nodes.
'''
inputLayer = LinearLayer(5)
hiddenLayer = SigmoidLayer(20)
outputLayer = LinearLayer(1)
'''
Add the nodes to the corresponding layer
'''
ann.addInputModule(inputLayer)
ann.addModule(hiddenLayer)
ann.addOutputModule(outputLayer)
'''
Connect the input layer to hidden layer,
then connect hidden layer to output layer
'''
in_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outputLayer)
ann.addConnection(in_to_hidden)
ann.addConnection(hidden_to_out)
ann.sortModules ()
data_set = SupervisedDataSet(5, 1)
for data in info:
data_set.addSample(data[:-1], data[-1])
trainer = BackpropTrainer(ann, data_set, verbose=False)
#test_data, train_data = data_set.splitWithProportion(0.2)
train_data = data_set
test_data = test_data
'''
Using 50 epochs for testing purposes, it will train
the network until convergence within the first 50 epochs
'''
train = trainer.trainUntilConvergence(dataset=train_data, maxEpochs=10)
NetworkWriter.writeToFile(ann, 'filename5.xml')
for d in test_data:
out = ann.activate(d)
#print (train)
print (out)
'''
def nn_train(pvar,ovar,code,date1,date2,niter,np,nh):
print "Doing Networ "+pvar+" "+ovar+" "+date1+" "+date2+" "+str(iter)
# ----------------------- add samples ------------------
# get the training data
print "adding training data "+pvar+" "
file="eod_main.db"
sqldir = os.path.join(datadir,"sql")
sqlfile = os.path.join(sqldir,file)
conn,cur=open_sql(sqlfile)
d = rd_sql(cur,code,'AND date > "'+date1+'" AND date < "'+date2+'"')
print "Read no of days "+str(len(d))
if pvar == "basic8":
print "calling nn_pp_basic8"
pp = nn_pp_basic8(d,3,3)
oclose,ohigh,olow,oclose_disc,o3day=nn_po_basic(d,3,3)
if ovar == "close":
po=oclose
if ovar == "high":
po=ohigh
if ovar == "3day":
po=o3day
ds = SupervisedDataSet(np,1)
for i in range(0,len(po)):
ds.addSample(pp[i],po[i])
# ----------------------- Build and Train ------------------
print "Training Network"
net = buildNetwork(np,nh,1,hiddenclass=TanhLayer)
trainer = BackpropTrainer(net,ds)
xxx = trainer.trainUntilConvergence(maxEpochs=niter,validationProportion=0.01)
#for n in range(0,niter):
# xxx=trainer.train(validationProportion=0.0)
# if n % 100 ==0:
# print "{} : {}".format(n,xxx)
# -------------- Save network parameters ------------------
print "Saving Network"
netdir2 = os.path.join(basedir,"inv")
netdir = os.path.join(netdir2,"analyse")
netfile = os.path.join(netdir,'net_'+pvar+'_'+ovar+'_'+date1+'_'+date1+'_'+str(niter)+'.xml')
NetworkWriter.writeToFile(net, netfile)
return
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 dump(self, dirPath):
"""
Save a representation of this classifier and it's network at the given path.
"""
if os.path.isdir(dirPath) and os.listdir(dirPath):
raise IOError("The directory exists and is not empty: {}".format(dirPath))
util.mkdir_p(dirPath)
#save network
NetworkWriter.writeToFile(self.net, os.path.join(dirPath, self._NET_NAME))
#save classifier
with open(os.path.join(dirPath, self._CLASSIFIER_NAME), 'w') as f:
f.write(serializer.dump(self))
def save(self, filename):
tmpfile = filename + '~net~'
NetworkWriter.writeToFile(self.net, tmpfile)
with open(tmpfile, 'rb') as f:
network_data = f.read()
os.unlink(tmpfile)
with open(filename + '~', 'wb') as f:
out = pickle.Pickler(f)
out.dump( (const.PWINDOW, self.window) )
out.dump( (const.PSIZE, self.size) )
out.dump( (const.PRATIO, self.ratio) )
out.dump( (const.PMULTIPLIER, self.multiplier) )
out.dump( (const.PNETWORK, network_data) )
f.flush()
os.rename(filename + '~', filename)
def __init__(self, num, traindata, inputdata, hiddenNN, type='Tanh', maxepochs=2000, ifprint=False, toload = False,
lRate = 0.0001, moment = 0.005):
self.dataSet = self.createDataSet(traindata[0], traindata[1]) #trainIn trainOut
if (toload==True):
self.net = NetworkReader.readFrom('nets/newnettemplate{}.xml'.format(num))
print(self.net)
else:
self.net = self.createNet(inputdata.shape[1], hiddenNN, type, ifprint=True)
self.trainer = self.trainTrainer(maxepochs, lRate, moment, ifprint)
NetworkWriter.writeToFile(self.net, 'nets/newnettemplatetest{}.xml'.format(num))
self.predictedVals = None
self.predictedX = None
self.resultTrainVals = None
def train_bp():
global net
net = buildNetwork(30, 2, 1, bias=True, hiddenclass=TanhLayer)
ds = SupervisedDataSet(30, 1)
read_bp_data(ds, "../collect_data/data/data.csv")
read_bp_data(ds, "../collect_data/data/white_data.csv")
read_bp_data(ds, "../collect_data/data/black_data.csv")
print len(ds)
#for inpt, target in ds:
#print inpt, target
trainer = BackpropTrainer(net, ds)
trainer.trainUntilConvergence(maxEpochs=10000)
NetworkWriter.writeToFile(
net, os.path.join(curdir, '../collect_data/data/bpstudy.xml'))
#test
'''
def xmlInvariance(n, forwardpasses=1):
""" try writing a network to an xml file, reading it, rewrite it, reread it, and compare
if the result looks the same (compare string representation, and forward processing
of some random inputs) """
# We only use this for file creation.
tmpfile = tempfile.NamedTemporaryFile(dir='.')
f = tmpfile.name
tmpfile.close()
NetworkWriter.writeToFile(n, f)
tmpnet = NetworkReader.readFrom(f)
NetworkWriter.writeToFile(tmpnet, f)
endnet = NetworkReader.readFrom(f)
# Unlink temporary file.
os.unlink(f)
netCompare(tmpnet, endnet, forwardpasses, True)
def neural_train(filename, testfile, output):
tag, data = readfile(filename)
testtag, testdata = readfile(testfile)
net = buildNetwork(len(data[0]), 80, 10)
ds = SupervisedDataSet(len(data[0]), 10)
for x in range(0, len(data)):
ds.addSample(data[x], trans(tag[x]))
testds = SupervisedDataSet(len(data[0]), 10)
for x in range(0, len(testdata)):
testds.addSample(testdata[x], trans(testtag[x]))
trainer = BackpropTrainer(net, ds, learningrate = 0.001, momentum = 0.99)
print "training..."
trainer.trainUntilConvergence(verbose=True,
trainingData=ds,
validationData=testds,
maxEpochs=500)
print "done"
NetworkWriter.writeToFile(net, output)
def xmlInvariance(n, forwardpasses = 1):
""" try writing a network to an xml file, reading it, rewrite it, reread it, and compare
if the result looks the same (compare string representation, and forward processing
of some random inputs) """
# We only use this for file creation.
tmpfile = tempfile.NamedTemporaryFile(dir='.')
f = tmpfile.name
tmpfile.close()
NetworkWriter.writeToFile(n, f)
tmpnet = NetworkReader.readFrom(f)
NetworkWriter.writeToFile(tmpnet, f)
endnet = NetworkReader.readFrom(f)
# Unlink temporary file.
os.unlink(f)
netCompare(tmpnet, endnet, forwardpasses, True)
def train(self, dataSet):
"""
Builds a network and trains it.
"""
if os.stat(self.predictor_path).st_size != 0:
self.network = NetworkReader.readFrom(self.predictor_path)
else:
self.network = buildNetwork(dataSet.indim, 4, dataSet.outdim,recurrent=True)
t = None
if len(dataSet) > 0:
t = BackpropTrainer(self.network, dataSet, learningrate = self.learningrate, momentum = self.momentum, verbose = False)
for epoch in range(0, self.epochs):
t.train()
NetworkWriter.writeToFile(self.network, self.predictor_path)
return t
def main():
start_time = time.time()
dataModel = [
[(0,0,0), (1,0,0,0,0,0,0,0)],
[(0,0,1), (0,1,0,0,0,0,0,0)],
[(0,1,0), (0,0,1,0,0,0,0,0)],
[(0,1,1), (0,0,0,1,0,0,0,0)],
[(1,0,0), (0,0,0,0,1,0,0,0)],
[(1,0,1), (0,0,0,0,0,1,0,0)],
[(1,1,0), (0,0,0,0,0,0,1,0)],
[(1,1,1), (0,0,0,0,0,0,0,1)],
]
ds = SupervisedDataSet(3, 8)
for input, target in dataModel:
ds.addSample(input, target)
# create a large random data set
random.seed()
trainingSet = SupervisedDataSet(3, 8);
for ri in range(0,2000):
input,target = dataModel[random.getrandbits(3)];
trainingSet.addSample(input, target)
net = buildNetwork(3, 8, 8, bias=True)
trainer = BackpropTrainer(net, ds, learningrate = 0.001)
for i in range(10):
trainer.trainUntilConvergence(verbose=True,
trainingData=trainingSet,
validationData=ds,
maxEpochs=1)
NetworkWriter.writeToFile(net, 'savedNeuralNets/trainedNet'+str(i)+'.xml')
print("The Program took %s seconds to run" % (time.time() - start_time))
def trainNetwork(dirname):
numFeatures = 5000
ds = SequentialDataSet(numFeatures, 1)
tracks = glob.glob(os.path.join(dirname, 'train??.wav'))
for t in tracks:
track = os.path.splitext(t)[0]
# load training data
print "Reading %s..." % track
data = numpy.genfromtxt(track + '_seg.csv', delimiter=",")
labels = numpy.genfromtxt(track + 'REF.txt', delimiter='\t')[0::10,1]
numData = data.shape[0]
# add the input to the dataset
print "Adding to dataset..."
ds.newSequence()
for i in range(numData):
ds.addSample(data[i], (labels[i],))
# initialize the neural network
print "Initializing neural network..."
net = buildNetwork(numFeatures, 50, 1,
hiddenclass=LSTMLayer, outputbias=False, recurrent=True)
# train the network on the dataset
print "Training neural net"
trainer = RPropMinusTrainer(net, dataset=ds)
## trainer.trainUntilConvergence(maxEpochs=50, verbose=True, validationProportion=0.1)
error = -1
for i in range(100):
new_error = trainer.train()
print "error: " + str(new_error)
if abs(error - new_error) < 0.1: break
error = new_error
# save the network
print "Saving neural network..."
NetworkWriter.writeToFile(net, os.path.basename(dirname) + 'net')
def main():
start_time = time.time()
dataModel = createTheDataModel([2,5,9,15])
trainingSet = SupervisedDataSet(228, 1)
for input, target in dataModel:
trainingSet.addSample(input, target)
net = buildNetwork(228, 220, 1, bias=True)
numberOfEpochsToTrainFor = 2
for epochNumber in range(1, 3):
trainer = BackpropTrainer(net, trainingSet)
trainer.trainEpochs(2)
NetworkWriter.writeToFile(net, 'savedNeuralNets/trainedNet1-epoch' + str(epochNumber * numberOfEpochsToTrainFor) + '.xml')
seconds = str(int(time.time() - start_time))
print("The Program took %s seconds to run" % (seconds))
def entrenarO(red):
#Se inicializa el dataset
ds = SupervisedDataSet(4096,1)
"""Se crea el dataset, para ello procesamos cada una de las imagenes obteniendo las figuras,
luego se le asignan los valores deseados del resultado la red neuronal."""
print "O - Figura"
for i,c in enumerate(os.listdir(os.path.dirname('C:\\Users\\LuisD\\Desktop\\Reconocimiento\\prueba/'))):
try:
im = cv2.imread('C:\\Users\\LuisD\\Desktop\\Reconocimiento\\prueba/'+c)
cv2.resize(im,(64,64))
pim = pi.ProcesarImagen(im)
ds.appendLinked(pim.flatten(),10)
except:
pass
print len(ds)
print i,c
trainer = BackpropTrainer(red, ds)
print "Entrenando hasta converger"
trainer.trainUntilConvergence()
NetworkWriter.writeToFile(red, 'rna_o.xml')
theNet.addOutputModule(outLayer)
theNet.sortModules()
hidden_to_out = pybrain.structure.FullConnection(hiddenLayer2,outLayer, name = 'hidden to output')
theNet.addConnection(hidden_to_out)
theNet.sortModules()
inp = data['input']
oup = data['target']
print(inp[2,:])
print(oup[2,:])
testData, trainData = data.splitWithProportion(0.2)
trainer = BackpropTrainer(theNet, trainData, verbose=True)
for i in range(2500):
print ("epoch " + str(i))
trainer.trainEpochs(1)
if i%20 == 0:
NetworkWriter.writeToFile(theNet,"/Users/arcadigonzalez/PycharmProjects/anncomp_pro/ANN_Backups/"+str(i))
NetworkWriter.writeToFile(theNet,"/Users/arcadigonzalez/Google Drive/NN_BU/NN1/"+str(i))
print("resting processor, writing file")
time.sleep(122)
def saveNetwork(self, fname):
""" save the trained network to a file """
NetworkWriter.writeToFile(self.Trainer.module, fname)
logging.info("Network saved to: " + fname)
def write_to_file(self, file_name):
if self.net is not None:
NetworkWriter.writeToFile(self.net, file_name)
def main():
global player1
global player2
global AI_1_ID
global DECK_1_ID
global AI_2_ID
global DECK_2_ID
global NUM_GAMES
global CLEAR_RESULTS
global path_to_result
global neural_net
ai_1_id = AI_1_ID
deck_1_id = DECK_1_ID
ai_2_id = AI_2_ID
deck_2_id = DECK_2_ID
numgames = NUM_GAMES
clear_results = CLEAR_RESULTS
if (len(sys.argv) > 5):
''' Number of games to be simulated '''
ai_1_id = sys.argv[1]
deck_1_id = sys.argv[2]
ai_2_id = sys.argv[3]
deck_2_id = sys.argv[4]
numgames = sys.argv[5]
if (len(sys.argv) > 6):
sixth_arg = sys.argv[6]
if (sixth_arg == "T"):
clear_results = True
elif (sixth_arg == "O"):
clear_results = True
path_to_result = os.path.join(os.path.dirname(os.getcwd()),'game_results',ai_1_id + '(' + deck_1_id
+ ')_' + ai_2_id + '(' + deck_2_id + ').csv')
else:
clear_results = True
path_to_result = os.path.join(os.path.dirname(os.getcwd()),'game_results',sixth_arg)
if (len(sys.argv) <= 5):
print("!!! WARNING: Wrong number of arguments. Default values were used. !!!")
if not numgames.isdigit():
sys.stderr.write("Usage: %s [NUMGAMES]\n" % (sys.argv[0]))
exit(1)
for i in range(int(numgames)):
if (i == 0):
test_full_game(ai_1_id,deck_1_id,ai_2_id,deck_2_id, clear_results)
else:
test_full_game(ai_1_id,deck_1_id,ai_2_id,deck_2_id, False)
os.path.join(os.getcwd())
if (player1.__class__ is Q_learner):
net = player1.neural_network
path = os.path.join(os.path.dirname(os.getcwd()), 'network.xml')
NetworkWriter.writeToFile(net, path)
neural_net = net
if (player2.__class__ is Q_learner):
net = player2.neural_network
path = os.path.join(os.path.dirname(os.getcwd()), 'network.xml')
NetworkWriter.writeToFile(net, path)
neural_net = net
def save_arguments(net,filename):
NetworkWriter.writeToFile(net, filename)
print 'Arguments save to file net.csv'
dataSet.addSample(feature[0], feature[1])
Network = buildNetwork(dataSet.indim,
InputLayerSize * 2,
InputLayerSize * 2,
1,
hiddenclass=SigmoidLayer,
outclass=SigmoidLayer,
bias=True)
trainer = BackpropTrainer(Network,
dataSet,
learningrate=0.001,
momentum=0.001)
trainer.trainUntilConvergence()
rightAnswers = 0
for feature in features:
outputs = Network.activate(feature[0])
maxValue = -1
maxValueIndex = -1
if outputs[0] > 0.5 and feature[1] == 1:
rightAnswers += 1
print(outputs[0], feature[1], outputs[0] > 0.5 and feature[1] == 1)
print('Right answers: ', rightAnswers / len(features) * 100, "%")
Network._name = 'SupervisedNetwork'
NetworkWriter.writeToFile(Network, "BestSupervised")
t = BackpropTrainer(n, learningrate = 0.01 ,
momentum = mom)
#train the neural network from the train DataSet
cterrori=1.0
print "trainer momentum:"+str(mom)
for iter in range(25):
t.trainOnDataset(trndata, 1000)
ctrndata = mv.calculateModuleOutput(n,trndata)
cterr = v.MSE(ctrndata,trndata['target'])
relerr = abs(cterr-cterrori)
cterrori = cterr
print 'iteration:',iter+1,'MSE error:',cterr
myplot(trndata,ctrndata,iter=iter+1)
if cterr < 1.e-5 or relerr < 1.e-7:
break
#write the network using xml file
myneuralnet = os.path.join(os.getcwd(),'myneuralnet.xml')
if os.path.isfile(myneuralnet):
NetworkWriter.appendToFile(n,myneuralnet)
else:
NetworkWriter.writeToFile(n,myneuralnet)
#calculate the test DataSet based on the trained Neural Network
ctsts = mv.calculateModuleOutput(n,tsts)
tserr = v.MSE(ctsts,tsts['target'])
print 'MSE error on TSTS:',tserr
myplot(trndata,ctrndata,tsts,ctsts)
pylab.show()
trainer = BackpropTrainer(nn, dataset=alldata, learningrate=0.01, momentum=0.1, verbose=False, weightdecay=0.002,
batchlearning=False)
numberOfEpoch = 60
x_errors = np.zeros((1, numberOfEpoch), dtype=int)
errors = np.zeros((2, numberOfEpoch), dtype=float)
for i in range(numberOfEpoch):
trainer.trainEpochs(1)
trnresult = percentError(trainer.testOnClassData(), alldata['class'])
tstresult = percentError(trainer.testOnClassData(dataset=alldatatest), alldatatest['class'])
x_errors[0, i] = trainer.totalepochs
errors[0, i] = trnresult
errors[1, i] = tstresult
current = time.time() - start
print("epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult,\
" time : %5.1f" % current)
end = time.time()
print("Time elapsed :" + str(end - start))
plt.plot(x_errors[0,:],errors[0,:],'g',x_errors[0,:],errors[1,:],'b')
plt.legend(["train error","test error"])
plt.show()
NetworkWriter.writeToFile(nn, 'base.xml')
treinamentoRedeNeural(NETWORK, DATASET,
(CAMINHO_RESULTADO + "TREINAMENTO.csv"))
# VALIDACAO
audio = carregarAudios(
"caminho da pasta com os audios de validacao do falante 1/", 1)
audioAposFFT = aplicarFFTnasAmostras(audio)
arrayComOsSegundosDoAudio = separacaoEmSegundosDoAudio(audioAposFFT)
validacaoRedeNeural(NETWORK, arrayComOsSegundosDoAudio, "1.ogg",
[10, 10, 10, 10, 10],
(CAMINHO_RESULTADO + "VALIDACAO.csv"))
NetworkWriter.writeToFile(NETWORK, (CAMINHO_RESULTADO + "network.xml"))
# SESSAO 2 => TESTE
# # CRIANDO OS DIRETORIOS
# os.mkdir("resultado/" + VERSAO)
#
# # VALIDACAO
# audio = carregarAudios("caminho da pasta com os audios de validacao do falante x/", 1)
#
# audioAposFFT = aplicarFFTnasAmostras(audio)
#
# arrayComOsSegundosDoAudio = separacaoEmSegundosDoAudio(audioAposFFT)
#
# validacaoRedeNeural(NETWORK, arrayComOsSegundosDoAudio, "1.ogg", [10, 10, 10, 10, 10],
# (CAMINHO_RESULTADO + "VALIDACAO.csv"))
t = BackpropTrainer(n, learningrate=0.01, momentum=mom)
#train the neural network from the train DataSet
cterrori = 1.0
print("trainer momentum:" + str(mom))
for iter in range(25):
t.trainOnDataset(trndata, 1000)
ctrndata = mv.calculateModuleOutput(n, trndata)
cterr = v.MSE(ctrndata, trndata['target'])
relerr = abs(cterr - cterrori)
cterrori = cterr
print('iteration:', iter + 1, 'MSE error:', cterr)
myplot(trndata, ctrndata, iter=iter + 1)
if cterr < 1.e-5 or relerr < 1.e-7:
break
#write the network using xml file
myneuralnet = os.path.join(os.getcwd(), 'myneuralnet.xml')
if os.path.isfile(myneuralnet):
NetworkWriter.appendToFile(n, myneuralnet)
else:
NetworkWriter.writeToFile(n, myneuralnet)
#calculate the test DataSet based on the trained Neural Network
ctsts = mv.calculateModuleOutput(n, tsts)
tserr = v.MSE(ctsts, tsts['target'])
print('MSE error on TSTS:', tserr)
myplot(trndata, ctrndata, tsts, ctsts)
pylab.show()
# split up training data for cross validation
print "Split data into training and test sets..."
net = buildNetwork(200, 134, 2, bias=True, outclass=SoftmaxLayer)
trainer = BackpropTrainer(net, dataset=trndata)
print "training for {} epochs..."
trainer.trainUntilConvergence( verbose = True, validationProportion = 0.15, maxEpochs = 1000, continueEpochs = 10 )
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
NetworkWriter.writeToFile(net, 'oliv-x2-80.xml')
# predict using test data
# print "Making predictions..."
# ypreds = []
# ytrues = []
# for i in range(Xtest.getLength()]):
# pred = fnn.activate(getSample(i)[0])
# ypreds.append(pred.argmax())
# ytrues.append(ytest[i])
# print "Accuracy on test set: %7.4f" % accuracy_score(ytrues, ypreds,
# normalize=True)
training_input,input_len = build_training_input(pca_dict, synergy_dict)
# input_len = training_input[list(training_input.keys())[0]]['INPUT']
target_len = 1
ds = SupervisedDataSet(input_len, target_len)
for t1 in training_input:
for t2 in training_input[t1]:
print("Input Vector", training_input[t1][t2]['INPUT'], training_input[t1][t2]['OUTPUT'])
ds.addSample(training_input[t1][t2]['INPUT'], training_input[t1][t2]['OUTPUT'])
n = buildNetwork(ds.indim, 3, ds.outdim, bias=True)
t = BackpropTrainer(n, learningrate=0.001, momentum=0.05, verbose=True)
print("Training")
t.trainUntilConvergence(ds,
verbose=True)
NetworkWriter.writeToFile(n, 'trainedNetwork.xml')
# n = NetworkReader.readFrom('trainedNetwork_2.xml')
predictions = {}
for d1 in pca_dict:
if not predictions.get(d1, None):
predictions[d1]={}
for d2 in pca_dict:
predictions[d1][d2] = n.activate(pca_dict[d1] + pca_dict[d2])[0]
with open('predictions_4.json', 'w') as outfile:
json.dump(predictions, outfile)
def saveNetwork(self, filename):
NetworkWriter.writeToFile(self.network, filename)
#!/usr/bin/env python3.7
import dict
import json
import numpy as np
import random
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.tools.customxml import NetworkWriter
from pybrain.structure import TanhLayer, SoftmaxLayer, LinearLayer
net = buildNetwork(len(dict.train_x[0]),
5,
len(dict.train_y[0]),
hiddenclass=LinearLayer,
recurrent=False)
ds = SupervisedDataSet(len(dict.train_x[0]), len(dict.train_y[0]))
i = 0
for inp in dict.train_x:
ds.addSample(inp, dict.train_y[i])
i += 1
trainer = BackpropTrainer(net, ds, learningrate=0.05)
trainer.trainEpochs(500)
NetworkWriter.writeToFile(net, 'net.xml')
def export_network(self, filename):
NetworkWriter.writeToFile(self.net_shared, filename)
vals.append(float(n.activate(x)))
error = 0.0
num = 0.0;
for o, t in zip(vals, prediction_outputs):
if abs(t - o) < 10:
error += abs(t - o)
num = num + 1
error = error / num
if error < local_min_error:
local_min_error = error
if error < min_error and num >= 16:
NetworkWriter.writeToFile(n, "20 prediction games with num = 16.xml")
min_error = error
num_n = num
min_vals = []
for x in vals:
x = float(x)
min_vals.append(x)
print("\n")
for x in vals:
print x
print("\n")
print(min_error)
print(num_n)
print("\n")
for x in min_vals:
#build a network
net = buildNetwork(inputdim, noofhiddenunits, outputdim, bias=True, outclass=SoftmaxLayer)
#defing a backpropagator
trainer = BackpropTrainer(net, dataset=traindata)
print "training for {} epochs..."
trainerror,valerror=trainer.trainUntilConvergence( verbose = True, validationProportion = 0.15, maxEpochs = 1000, continueEpochs = 10 )
# plt.plot(trainerror,'b',valerror,'r')
# plt.show()
# trainer.trainOnDataset(traindata,500)
trnresult = percentError( trainer.testOnClassData(),traindata['class'] )
tstresult = percentError( trainer.testOnClassData(dataset=testdata ), testdata['class'] )
# valiresult = percentError( trainer.testOnClassData(dataset=validata ), validata['class'] )
print "epoch: %4d" % trainer.totalepochs," train error: %5.2f%%" % trnresult, " test error: %5.2f%%" % tstresult
# , "valid error:%5.2ff%" %valiresult
# if os.path.isfile('clean-oliv.xml'):
# fnn = NetworkReader.readFrom('clean-oliv.xml')
# else:
# fnn = buildNetwork( traindata.indim, 64 , traindata.outdim, outclass=SoftmaxLayer )
# NetworkWriter.writeToFile(net, 'clean-oliv.xml')
NetworkWriter.writeToFile(net, 'clean-oliv-136.xml')
cut_score = 0.0001
else:
cut_score = 0.001
if (args.c == "True"):
while (i < 1000 and score > cut_score):
score = trainer.train()
i = i + 1
#print "Score: ", score, " loop: ", i
print >> FH, "Score: ", score, " loop: ", i
FH.flush()
mse = score # Store last MSE value as network MSE
mse = round(mse, 4)
netfilename = netname + ".mse_" + str(mse) + ".local.net"
NetworkWriter.writeToFile(trainer.module,
netfilename) # Save network as XML file
#--------------------- TEST NETWORK on testset ---------------------------
net2 = NetworkReader.readFrom(netfilename)
rp, rn, tp09, fp09, fn09, tn09 = 0, 0, 0, 0, 0, 0
rp, rn, tp09, fp09, fn09, tn09, target, predicted = testNetwork(testdata)
FHper = open(netfilename + ".performance", "a")
print >> FHper, "# Test data:%s" % t_test
for x in xrange(len(target)):
print >> FHper, target[x], "\t", predicted[x]
# Measures
#add sample data set
for i in range(len(traininglist)):
DS.addSample(traininglist[i], traininglabels[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']
#step3
# trainner use BP algorithm
verbose = True
trainer = BackpropTrainer(fnn,
dataTrain,
verbose=True,
learningrate=0.5,
lrdecay=0.5,
momentum=0)
trainer.trainUntilConvergence(DS, maxEpochs=10)
NetworkWriter.writeToFile(fnn, 'networkClassifier.txt')
print("#############")
out = fnn.activateOnDataset(DS)
print(out)
# u can give an input, and use activate function to see the result.
#fnn.activate(input)
# Reference: http://pybrain.org/docs/tutorial/netmodcon.html#examining-a-network; https://www.zengmingxia.com/use-pybrain-to-fit-neural-networks/
ds = SupervisedDataSet( 28 ** 2, 10)
for row in data_training:
ds.addSample(row[1], row[2])
net = buildNetwork(28 ** 2, 35, 10, bias=True, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, ds)
def outputsToNumber(outputs):
max = outputs[0]
value = 0
for x in range(0, 10):
if outputs[x] > max:
max = outputs[x]
value = x
return value
print "Beginning a training pass..."
for _ in range(0, 5):
print trainer.train()
for thing in data_training[0:20]:
print "expected label: ", thing[0], "nnet label: ", outputsToNumber(net.activate(thing[1]))
fileObject = open('trainedNetwork', 'w')
cPickle.dump(net, fileObject)
fileObject.close()
NetworkWriter.writeToFile(net, 'nnet.xml')
exif_data
return data
dataTraining = getDataImage('image/retangulo.png')
size = largura*altura*3
network = buildNetwork(size, 120, 120, 1)
dataSet = SupervisedDataSet(size, 1)
dataSet.addSample(getDataImage('image/retangulo.png'), (1))
dataSet.addSample(getDataImage('image/retangulo2.png'), (1))
dataSet.addSample(getDataImage('image/retangulo3.png'), (1))
dataSet.addSample(getDataImage('image/retangulo4.png'), (1))
dataSet.addSample(getDataImage('image/retangulo5.png'), (1))
dataSet.addSample(getDataImage('image/retangulo6.png'), (1))
dataSet.addSample(getDataImage('image/retangulo7.png'), (1))
dataSet.addSample(getDataImage('image/retangulo8.png'), (1))
trainer = BackpropTrainer(network, dataSet)
error = 1
iteration = 0
output = []
while error > 0.001:
error = trainer.train()
output.append(error)
iteration += 1
print(iteration, error)
NetworkWriter.writeToFile(network, "dataBase-Ai.xml")
def saveresult(self, destname=None):
if destname == None:
destname = self.destname
NetworkWriter.writeToFile(self.__fnn, destname + '.xml')
joblib.dump(self.__sy, destname + '_sy.pkl', compress=3)
joblib.dump(self.__sx, destname + '_sx.pkl', compress=3)
ds.addSample((21, -16, 444, 0, -1, -21, 16, -444, 0, 1), (-1, 1)) ds.addSample((-146, 29, -126, 0, -1, 146, -29, 126, 0, 1), (-1, 1)) ds.addSample((68, 34, 192, -2, -1, -68, -34, -192, 2, 1), (1, -1)) ds.addSample((-44, 45, 132, -1, -1, 44, -45, -132, 1, 1), (1, -1)) ds.addSample((38, 5, -554, 1, -1, -38, -5, 554, -1, 1), (1, -1)) ds.addSample((238, 175, 962, -2, -1, -238, -175, -962, 2, 1), (1, -1)) ds.addSample((56, 74, -86, -2, -1, -56, -74, 86, 2, 1), (1, -1)) ds.addSample((151, 45, 684, -2, -1, -151, -45, -684, 2, 1), (1, -1)) ds.addSample((-35, -16, -288, -1, -1, 35, 16, 288, 1, 1), (1, -1)) ds.addSample((-116, -45, -164, 2, -1, 116, 45, 164, -2, 1), (-1, 1)) ds.addSample((99, 59, 174, -3, -1, -99, -59, -174, 3, 1), (1, -1)) ds.addSample((-125, -162, -345, -3, -1, 125, 162, 345, 3, 1), (1, -1)) ds.addSample((51, -59, 24, -4, -1, -51, 59, -24, 4, 1), (1, -1)) ds.addSample((-53, 57, 104, 0, -1, 53, -57, -104, 0, 1), (1, -1)) ds.addSample((-86, -88, 48, 0, -1, 86, 88, -48, 0, 1), (1, -1)) ds.addSample((36, 81, 84, -2, -1, -36, -81, -84, 2, 1), (1, -1)) ds.addSample((-48, -123, -704, 3, -1, 48, 123, 704, -3, 1), (-1, 1)) ds.addSample((-123, -25, 52, 2, -1, 123, 25, -52, -2, 1), (-1, 1)) ds.addSample((-221, -32, 244, 1, -1, 221, 32, -244, -1, 1), (-1, 1)) ds.addSample((128, 86, 650, -2, -1, -128, -86, -650, 2, 1), (1, -1)) ds.addSample((33, 26, -96, 1, -1, -33, -26, 96, -1, 1), (-1, 1)) ds.addSample((-8, 10, -30, -1, -1, 8, -10, 30, 1, 1), (1, -1)) ds.addSample((-40, -77, -498, 1, -1, 40, 77, 498, -1, 1), (-1, 1)) net = buildNetwork(10, 17, 2, bias=True, hiddenclass=TanhLayer) trainer = BackpropTrainer(net, ds) result = trainer.trainUntilConvergence(maxEpochs=10000) print(result) NetworkWriter.writeToFile(net, 'LoserBowlANN.xml')
trainer = BackpropTrainer(net, trainingDataSet, learningrate = 0.001, momentum = 0.99)
trainer.trainUntilConvergence(trainingData=trainingDataSet, maxEpochs=20)
#measure success
total = 0
correct = 0
for input, output in training:
guess = net.activate(input)
if output[0] == round(guess):
correct += 1
total += 1
#print output[0], ',', guess[0]
accuracy = correct/float(total)
#print "features: ", features
#print "total: ", total
#print "correct: ", correct
print "accuracy: ", accuracy
#save network for future use
filename = 'networks/newest/' + str(round(accuracy,3)) + '--' + datetime.now().strftime('%Y-%m-%d-%H-%M-%S') + '.xml'
NetworkWriter.writeToFile(net, filename)
def save_network(net):
NetworkWriter.writeToFile(
net, config["trained_models_paths"]["nn_nets"] +
'/trained_nn.xml') # '../nn_trained_networks/trained_nn.xml')
print("Saving network to:",
config["trained_models_paths"]["nn_nets"] + '/trained_nn.xml')
def train(data_file, vis_matrix, vis_graph, save_file=''):
load_params()
#import dataset
ds = ClassificationDataSet(micro_dim, 1, nb_classes=num_classes)
extract_data(data_file, ds)
tr, val = ds.splitWithProportion(2/3.)
#softmax output layer
tr._convertToOneOfMany()
val._convertToOneOfMany()
#build network
layer_sizes = [tr.indim]
for layer_size in num_hidden:
layer_sizes.append(layer_size)
layer_sizes.append(tr.outdim)
if save_file == '':
ann = buildNetwork(layer_sizes, hiddenclass=SigmoidLayer, recurrent=False, outclass=SoftmaxLayer, bias=inc_bias)
iteration = 0
else:
ann = NetworkReader.readFrom(save_file)
match = re.search('([0-9]+)_(?:[0-9]{1,3}).xml', save_file)
if match == None:
print 'Net save files should be named I_E.xml, where I is the iteration and E is the rounded error from 0-100'
exit(1)
else:
iteration = int(match.group(1)) + 1
#training
trainer = BackpropTrainer(ann, dataset=tr, momentum=momentum, weightdecay=weight_decay)
done = False
errors, variations = [], []
testing_errors, testing_variations = [], []
while(not done):
trainer.trainEpochs(num_epochs)
# visualize iteration
if vis_matrix or vis_graph:
vertices, edges = vertsEdges(ann)
if vis_matrix:
matrixVisualizer(edges)
if vis_graph:
graphVisualizer(vertices, edges, iteration)
# calculate and print error info
training_error, testing_error, training_variation, testing_variation = trainer.testOnData(), trainer.testOnData(dataset=val), calcVariation(trainer), calcVariation(trainer, dataset=val)
errors.append(training_error)
variations.append(training_variation)
testing_errors.append(testing_error)
testing_variations.append(testing_variation)
fig, ax1 = plt.subplots()
iterations = range(iteration+1)
ax1.plot(iterations, map(log10, errors), 'r-')
ax1.plot(iterations, map(log10, testing_errors), 'b-')
ax1.set_xlabel('iteration')
ax1.set_ylabel('log mean squared error (red=train, blue=test)')
for tick in ax1.get_yticklabels():
tick.set_color('b')
ax2 = ax1.twinx()
ax2.plot(iterations, map(log10, variations), 'r--')
ax2.plot(iterations, map(log10, testing_variations), 'b--')
ax2.set_ylabel('log variation (L1 error) (red=train, blue=test)')
for tick in ax2.get_yticklabels():
tick.set_color('r')
plt.savefig('error-3layer-48.pdf')
plt.close()
print 'iter %d, training error %f, testing error %f, training variation %f, testing variation %f' % (iteration, training_error, testing_error, training_variation, testing_variation)
#save every <snapshot> iterations
if iteration % snapshot == -1:
file_data = (iteration, int(errors[-1]*100))
print 'Saving model %d_%d.xml...' % file_data
NetworkWriter.writeToFile(ann, '%d_%d.xml' % file_data)
# go to the next iteration if not done
iteration = iteration + 1
if iteration >= max_iterations:
done = True
#testing
val_errors, val_variations = [], []
for i in range(5):
val_error, val_variation = trainer.testOnData(dataset=val), calcVariation(trainer, dataset=val)
print 'error %f, variation %f' % (val_error, val_variation)
val_errors.append(val_error)
val_variations.append(val_variation)
tr, val = ds.splitWithProportion(0.9)
val._convertToOneOfMany()
print 'average error %f, average variation %f' % (np.average(val_errors), np.average(val_variations))
#plotting
iterations = range(max_iterations)
fig, ax1 = plt.subplots()
ax1.plot(iterations, map(log10, errors), 'b-')
ax1.set_xlabel('iteration')
ax1.set_ylabel('log mean squared error')
for tick in ax1.get_yticklabels():
tick.set_color('b')
ax1.set_title('error for validation dataset: %f, variation for validation dataset: %f' % (val_error, val_variation))
ax2 = ax1.twinx()
ax2.plot(iterations, map(log10, variations), 'r-')
ax2.set_ylabel('log variation (L1 error)')
for tick in ax2.get_yticklabels():
tick.set_color('r')
plt.savefig('error-4layer-48-96.pdf')
def reset_network():
net = NetworkReader.readFrom(config["trained_models_paths"]["nn_nets"] +
'/trained_nn_original.xml')
NetworkWriter.writeToFile(
net, config["trained_models_paths"]["nn_nets"] + '/trained_nn.xml')
print("Network reset")
def save_arguments(net):
NetworkWriter.writeToFile(net, 'huge_data.csv')
print 'Arguments save to file net.csv'
def trainNetwork(dirname):
numFeatures = 2000
ds = SequentialDataSet(numFeatures, 1)
tracks = glob.glob(os.path.join(dirname, "*.csv"))
for t in tracks:
track = os.path.splitext(t)[0]
# load training data
print "Reading %s..." % t
data = numpy.genfromtxt(t, delimiter=",")
numData = data.shape[0]
# add the input to the dataset
print "Adding to dataset..."
ds.newSequence()
for i in range(numData):
# ds.addSample(data[i], (labels[i],))
input = data[i]
label = input[numFeatures]
if label > 0:
label = midi_util.frequencyToMidi(label)
ds.addSample(input[0:numFeatures], (label,))
# initialize the neural network
print "Initializing neural network..."
# net = buildNetwork(numFeatures, 50, 1,
# hiddenclass=LSTMLayer, bias=True, recurrent=True)
# manual network building
net = RecurrentNetwork()
inlayer = LinearLayer(numFeatures)
# h1 = LSTMLayer(70)
# h2 = SigmoidLayer(50)
octaveLayer = LSTMLayer(5)
noteLayer = LSTMLayer(12)
combinedLayer = SigmoidLayer(60)
outlayer = LinearLayer(1)
net.addInputModule(inlayer)
net.addOutputModule(outlayer)
# net.addModule(h1)
# net.addModule(h2)
net.addModule(octaveLayer)
net.addModule(noteLayer)
net.addModule(combinedLayer)
# net.addConnection(FullConnection(inlayer, h1))
# net.addConnection(FullConnection(h1, h2))
# net.addConnection(FullConnection(h2, outlayer))
net.addConnection(FullConnection(inlayer, octaveLayer))
net.addConnection(FullConnection(inlayer, noteLayer))
# net.addConnection(FullConnection(octaveLayer,combinedLayer))
for i in range(5):
net.addConnection(
FullConnection(
octaveLayer, combinedLayer, inSliceFrom=i, inSliceTo=i + 1, outSliceFrom=i * 12, outSliceTo=(i + 1) * 12
)
)
net.addConnection(FullConnection(noteLayer, combinedLayer))
net.addConnection(FullConnection(combinedLayer, outlayer))
net.sortModules()
# train the network on the dataset
print "Training neural net"
trainer = RPropMinusTrainer(net, dataset=ds)
## trainer.trainUntilConvergence(maxEpochs=50, verbose=True, validationProportion=0.1)
error = -1
for i in range(150):
new_error = trainer.train()
print "error: " + str(new_error)
if abs(error - new_error) < 0.005:
break
error = new_error
# save the network
print "Saving neural network..."
NetworkWriter.writeToFile(net, os.path.basename(dirname) + "designnet")
while remainingEpoch > 0:
trainer.trainEpochs(1)
trnresult = percentError(trainer.testOnClassData(), alldata["class"])
tstresult = percentError(trainer.testOnClassData(dataset=alldatatest), alldatatest["class"])
if tstresult < 4.12:
low = True
if low:
remainingEpoch = remainingEpoch - 1
x_errors[0, i] = trainer.totalepochs
errors[0, i] = trnresult
errors[1, i] = tstresult
current = time.time() - start
print(
"epoch: %4d" % trainer.totalepochs,
" train error: %5.2f%%" % trnresult,
" test error: %5.2f%%" % tstresult,
" time : %5.1f s" % current,
)
end = time.time()
print("Time elapsed :" + str(end - start))
plt.plot(x_errors[0, :], errors[0, :], "g", x_errors[0, :], errors[1, :], "b")
plt.legend(["train error", "test error"])
plt.show()
NetworkWriter.writeToFile(nn, "base.xml")
def learn(self,
pathdataset=["dstc4_train"],
Pathdataroot="data",
numberOfHiddenUnit=20,
EPOCHS_PER_CYCLE=10,
CYCLES=40,
weightdecayw=0.01):
print "Start learning LSTM, and make dictionary file"
#Construct dictionary: variable name -> corresponding index of element in i/o vector
print "Star make dictionary: variable name -> corresponding index of element in i/o vector"
self.dictOut = {
} #"TOPIC_SLOT_VALUE" -> corresponding index of element
self.dictIn = {
} #"SPEAKER_{val}"or"TOPIC_{val}","WORD_{word}" "BIO_{BIO}", "CLASS_{slot,value}", ""{defined label}-> corresponding index of element
#-target vector dictionary
index = 0
totalNumSlot = 0
for topic in self.tagsets.keys():
for slot in self.tagsets[topic].keys():
totalNumSlot += 1
for value in self.tagsets[topic][slot]:
self.dictOut[topic + "_" + slot + "_" + value] = index
index += 1
print "totalNumSlot:" + str(totalNumSlot)
print "outputSize:" + str(len(self.dictOut.keys()))
#-input dictionry
dataset = []
for pathdat in pathdataset:
dataset.append(
dataset_walker.dataset_walker(pathdat,
dataroot=Pathdataroot,
labels=False))
#--(sub input vector 1) Class features i.e., Slot and value ratio (Similar to base line)
index = 0
for topic in self.tagsets.keys():
for slot in self.tagsets[topic].keys():
if ("CLASS_" + slot) not in self.dictIn:
self.dictIn["CLASS_" + slot] = index
index += 1
for value in self.tagsets[topic][slot]:
if ("CLASS_" + value) not in self.dictIn:
self.dictIn["CLASS_" + value] = index
index += 1
self.TOTALSIZEOFCLASSFeature = index
f = open(self.FileNameofNumClassFeature, "wb")
pickle.dump(self.TOTALSIZEOFCLASSFeature, f)
f.close()
#--(sub input vector 2) Sentence features
if not self.isUseSentenceRepresentationInsteadofBOW:
index = 0
for elemDataset in dataset:
for call in elemDataset:
for (uttr, _) in call:
#General info1 (CLASS; this feature must be rejistered at first)
if ("SPEAKER_" + uttr["speaker"]) not in self.dictIn:
self.dictIn["SPEAKER_" + uttr["speaker"]] = index
index += 1
if ("TOPIC_" + uttr["segment_info"]["topic"]
) not in self.dictIn:
self.dictIn["TOPIC_" +
uttr["segment_info"]["topic"]] = index
index += 1
#General info2
#-BIO
if ("BIO_" + uttr['segment_info']['target_bio']
) not in self.dictIn:
self.dictIn[
"BIO_" +
uttr['segment_info']['target_bio']] = index
index += 1
#BOW
if LSTMWithBOWTracker.isIgnoreUtterancesNotRelatedToMainTask:
if not (uttr['segment_info']['target_bio'] == "O"):
#-BOW
splitedtrans = self.__getRegurelisedBOW(
uttr["transcript"])
for word in splitedtrans:
if ("WORD_" + word) not in self.dictIn:
self.dictIn["WORD_" + word] = index
index += 1
self.TOTALSIZEOFSENTENCEFeature = index
f = open(self.FileNameofNumSentenceFeature, "wb")
pickle.dump(self.TOTALSIZEOFSENTENCEFeature, f)
f.close()
elif self.isUseSentenceRepresentationInsteadofBOW:
index = 0
for i in range(0, LSTMWithBOWTracker.D2V_VECTORSIZE):
self.dictIn[str(index) + "thElemPV"] = index
index += 1
index = 0
for i in range(0, LSTMWithBOWTracker.D2V_VECTORSIZE):
self.dictIn[str(index) + "thAvrWord"] = index
index += 1
assert self.D2V_VECTORSIZE == LSTMWithBOWTracker.D2V_VECTORSIZE, "D2V_VECTORSIZE is restrected to be same over the class"
else:
assert False, "Unexpected block"
#--(sub input vector 3) Features M1s defined
index = 0
if self.isEnableToUseM1sFeature:
rejisteredFeatures = self.__rejisterM1sInputFeatureLabel(
self.tagsets, dataset)
for rFeature in rejisteredFeatures:
assert rFeature not in self.dictIn, rFeature + " already registered in input vector. Use different label name. "
self.dictIn[rFeature] = index
index += 1
self.TOTALSIZEOFM1DEFINEDFeature = index
f = open(self.FileNameofNumM1Feature, "wb")
pickle.dump(self.TOTALSIZEOFM1DEFINEDFeature, f)
f.close()
print "inputSize:" + str(len(self.dictIn.keys()))
assert self.dictIn[
"CLASS_INFO"] == 0, "Unexpected index CLASS_INFO should has value 0"
assert self.dictIn[
"CLASS_Fort Siloso"] == 334, "Unexpected index CLASS_Fort Siloso should has value 334"
assert self.dictIn[
"CLASS_Yunnan"] == 1344, "Unexpected index CLASS_Yunnan should has value 1611"
#--write
fileObject = open('dictInput.pic', 'w')
pickle.dump(self.dictIn, fileObject)
fileObject.close()
fileObject = open('dictOutput.pic', 'w')
pickle.dump(self.dictOut, fileObject)
fileObject.close()
#Build RNN frame work
print "Start learning Network"
#Capability of network is: (30 hidden units can represents 1048576 relations) wherease (10 hidden units can represents 1024)
#Same to Henderson (http://www.aclweb.org/anthology/W13-4073)?
net = buildNetwork(len(self.dictIn.keys()),
numberOfHiddenUnit,
len(self.dictOut.keys()),
hiddenclass=LSTMLayer,
outclass=SigmoidLayer,
outputbias=False,
recurrent=True)
#Train network
#-convert training data into sequence of vector
convDataset = [] #[call][uttr][input,targetvec]
iuttr = 0
convCall = []
for elemDataset in dataset:
for call in elemDataset:
for (uttr, label) in call:
if self.isIgnoreUtterancesNotRelatedToMainTask:
if uttr['segment_info']['target_bio'] == "O":
continue
#-input
convInput = self._translateUtteranceIntoInputVector(
uttr, call)
#-output
convOutput = [0.0] * len(
self.dictOut.keys()) #Occured:+1, Not occured:0
if "frame_label" in label:
for slot in label["frame_label"].keys():
for value in label["frame_label"][slot]:
convOutput[self.dictOut[
uttr["segment_info"]["topic"] + "_" +
slot + "_" + value]] = 1
#-post proccess
if self.isSeparateDialogIntoSubDialog:
if uttr['segment_info']['target_bio'] == "B":
if len(convCall) > 0:
convDataset.append(convCall)
convCall = []
convCall.append([convInput, convOutput])
#print "Converted utterance" + str(iuttr)
iuttr += 1
if not self.isSeparateDialogIntoSubDialog:
if len(convCall) > 0:
convDataset.append(convCall)
convCall = []
#Online learning
trainer = RPropMinusTrainer(net, weightdecay=weightdecayw)
EPOCHS = EPOCHS_PER_CYCLE * CYCLES
for i in xrange(CYCLES):
#Shuffle order
ds = SequentialDataSet(len(self.dictIn.keys()),
len(self.dictOut.keys()))
datInd = range(0, len(convDataset))
random.shuffle(
datInd
) #Backpropergation already implemeted data shuffling, however though RpropMinus don't.
for ind in datInd:
ds.newSequence()
for convuttr in convDataset[ind]:
ds.addSample(convuttr[0], convuttr[1])
#Evaluation and Train
epoch = (i + 1) * EPOCHS_PER_CYCLE
print "\r epoch {}/{} Error={}".format(
epoch, EPOCHS, trainer.testOnData(dataset=ds))
stdout.flush()
trainer.trainOnDataset(dataset=ds, epochs=EPOCHS_PER_CYCLE)
NetworkWriter.writeToFile(
trainer.module, "LSTM_" + "Epoche" + str(i + 1) + ".rnnw")
NetworkWriter.writeToFile(trainer.module, "LSTM.rnnw")
