class MoveBrain:
def __init__(self):
self.n = RecurrentNetwork()
inLayer = LinearLayer(8)
hiddenLayer = SigmoidLayer(4)
self.numInputs = 8
outLayer = LinearLayer(4)
self.n.addInputModule(inLayer)
self.n.addModule(hiddenLayer)
self.n.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
self.n.addConnection(in_to_hidden)
self.n.addConnection(hidden_to_out)
self.n.sortModules()
self.ds = SupervisedDataSet(8, 4)
self.trainer = BackpropTrainer(self.n, self.ds)
def run(inputs):
if inputs.size() == self.numInputs:
self.n.activate(inputs)
else:
print "num of inputs do not match"
def addRule(self,rule):
self.ds.append(rule)
def saveNetwork(self):
fileObject = open('networks/avoidandfindv1', 'w')
pickle.dump(self.n, fileObject)
fileObject.close()
class BrainController:
indim = 2
outdim = 2
def __init__(self, trained_net=None):
if trained_net == None:
self.net = RecurrentNetwork()
self.init_network(self.net)
else:
self.net = trained_net
def init_network(self, net):
net.addInputModule(LinearLayer(2, 'in'))
net.addModule(SigmoidLayer(3, 'hidden'))
net.addOutputModule(LinearLayer(2, 'out'))
net.addModule(BiasUnit(name='bias'))
net.addConnection(FullConnection(net['in'], net['hidden']))
net.addConnection(FullConnection(net['hidden'], net['out']))
net.sortModules()
def train(self, data):
ds = SupervisedDataSet(2, 2)
for i in range(0, len(data)):
input, target = data[i]
ds.addSample(input, target)
trainer = BackpropTrainer(self.net,
ds,
learningrate=0.01,
momentum=0.99,
verbose=True)
max_error = 1e-5
error = 1
while abs(error) >= max_error:
error = trainer.train()
#self.validate_net()
f = open('neuro.net', 'w')
pickle.dump(self.net, f)
f.close()
def validate_net(self):
print self.net.activate([0, 0])
print self.net.activate([0, 1])
print self.net.activate([0, 2])
print self.net.activate([1, 0])
print self.net.activate([1, 1])
print self.net.activate([1, 2])
class BrainController:
indim = 2
outdim = 2
def __init__(self, trained_net = None):
if trained_net == None:
self.net = RecurrentNetwork()
self.init_network(self.net)
else:
self.net = trained_net
def init_network(self, net):
net.addInputModule(LinearLayer(2, 'in'))
net.addModule(SigmoidLayer(3, 'hidden'))
net.addOutputModule(LinearLayer(2, 'out'))
net.addModule(BiasUnit(name='bias'))
net.addConnection(FullConnection(net['in'], net['hidden']))
net.addConnection(FullConnection(net['hidden'], net['out']))
net.sortModules()
def train(self, data):
ds = SupervisedDataSet(2, 2)
for i in range(0, len(data)):
input, target = data[i]
ds.addSample(input, target)
trainer = BackpropTrainer(self.net, ds, learningrate=0.01, momentum=0.99,
verbose=True)
max_error = 1e-5
error = 1
while abs(error) >= max_error:
error = trainer.train()
#self.validate_net()
f = open('neuro.net', 'w')
pickle.dump(self.net, f)
f.close()
def validate_net(self):
print self.net.activate([0, 0])
print self.net.activate([0, 1])
print self.net.activate([0, 2])
print self.net.activate([1, 0])
print self.net.activate([1, 1])
print self.net.activate([1, 2])
""" Recurrent networks are working in the same way, except that the recurrent connections need to be explicitly declared upon construction. We can modify our existing network 'net2' and add a recurrent connection on the hidden layer: """ n2.addRecurrentConnection(FullConnection(n2['h'], n2['h'], name='rec')) """ After every structural modification, if we want ot use the network, we call 'sortModules()' again""" n2.sortModules() print n2 """ As the network is now recurrent, successive activations produce different outputs: """ print n2.activate([1, 2]), print n2.activate([1, 2]), print n2.activate([1, 2]) """ The 'reset()' method re-initializes the network, and with it sets the recurrent activations to zero, so now we get the same results: """ n2.reset() print n2.activate([1, 2]), print n2.activate([1, 2]), print n2.activate([1, 2]) """ This is already a good coverage of the basics, but if you're an advanced user you might want to find out about the possibilities of nesting networks within others, using weight-sharing, and more exotic types of networks, connections and modules... but that goes beyond the scope of this tutorial.
train_set, test_set = DS.splitWithProportion(0.7) # build our recurrent network with 10 hidden neurodes, one recurrent # connection, using tanh activation functions net = RecurrentNetwork() hidden_neurodes = 10 net.addInputModule(LinearLayer(len(train_set["input"][0]), name="in")) net.addModule(TanhLayer(hidden_neurodes, name="hidden1")) net.addOutputModule(LinearLayer(len(train_set["target"][0]), name="out")) net.addConnection(FullConnection(net["in"], net["hidden1"], name="c1")) net.addConnection(FullConnection(net["hidden1"], net["out"], name="c2")) net.addRecurrentConnection(FullConnection(net["out"], net["hidden1"], name="cout")) net.sortModules() net.randomize() # train for 30 epochs (overkill) using the rprop- training algorithm trainer = RPropMinusTrainer(net, dataset=train_set, verbose=True) trainer.trainOnDataset(train_set, 30) # test on training set predictions_train = np.array([net.activate(train_set["input"][i])[0] for i in xrange(len(train_set))]) plt.plot(train_set["target"], c="k") plt.plot(predictions_train, c="r") plt.show() # and on test set predictions_test = np.array([net.activate(test_set["input"][i])[0] for i in xrange(len(test_set))]) plt.plot(test_set["target"], c="k") plt.plot(predictions_test, c="r") plt.show()
class LanguageLearner:
__OUTPUT = "Sample at {0} epochs (prompt=\"{1}\", length={2}): {3}"
def __init__(self, trainingText, hiddenLayers, hiddenNodes):
self.__initialized = False
with open(trainingText) as f:
self.raw = f.read()
self.characters = list(self.raw)
self.rawData = list(map(ord, self.characters))
print("Creating alphabet mapping...")
self.mapping = []
for charCode in self.rawData:
if charCode not in self.mapping:
self.mapping.append(charCode)
print("Mapping of " + str(len(self.mapping)) + " created.")
print(str(self.mapping))
print("Converting data to mapping...")
self.data = []
for charCode in self.rawData:
self.data.append(self.mapping.index(charCode))
print("Done.")
self.dataIn = self.data[:-1:]
self.dataOut = self.data[1::]
self.inputs = 1
self.hiddenLayers = hiddenLayers
self.hiddenNodes = hiddenNodes
self.outputs = 1
def initialize(self, verbose):
print("Initializing language learner...")
self.verbose = verbose
# Create network and modules
self.net = RecurrentNetwork()
inp = LinearLayer(self.inputs, name="in")
hiddenModules = []
for i in range(0, self.hiddenLayers):
hiddenModules.append(LSTMLayer(self.hiddenNodes, name=("hidden-" + str(i + 1))))
outp = LinearLayer(self.outputs, name="out")
# Add modules to the network with recurrence
self.net.addOutputModule(outp)
self.net.addInputModule(inp)
for module in hiddenModules:
self.net.addModule(module)
# Create connections
self.net.addConnection(FullConnection(self.net["in"], self.net["hidden-1"]))
for i in range(0, len(hiddenModules) - 1):
self.net.addConnection(FullConnection(self.net["hidden-" + str(i + 1)], self.net["hidden-" + str(i + 2)]))
self.net.addRecurrentConnection(FullConnection(self.net["hidden-" + str(i + 1)], self.net["hidden-" + str(i + 1)]))
self.net.addRecurrentConnection(FullConnection(self.net["hidden-" + str(len(hiddenModules))],
self.net["hidden-" + str(len(hiddenModules))]))
self.net.addConnection(FullConnection(self.net["hidden-" + str(len(hiddenModules))], self.net["out"]))
self.net.sortModules()
self.trainingSet = SequentialDataSet(self.inputs, self.outputs)
for x, y in zip(self.dataIn, self.dataOut):
self.trainingSet.newSequence()
self.trainingSet.appendLinked([x], [y])
self.net.randomize()
print("Neural network initialzed with structure:")
print(self.net)
self.trainer = BackpropTrainer(self.net, self.trainingSet, verbose=verbose)
self.__initialized = True
print("Successfully initialized network.")
def train(self, epochs, frequency, prompt, length):
if not self.__initialized:
raise Exception("Attempted to train uninitialized LanguageLearner")
print ("Beginning training for " + str(epochs) + " epochs...")
if frequency >= 0:
print(LanguageLearner.__OUTPUT.format(0, prompt, length, self.sample(prompt, length)))
for i in range(1, epochs):
print("Error at " + str(i) + " epochs: " + str(self.trainer.train()))
if i % frequency == 0:
print(LanguageLearner.__OUTPUT.format(i, prompt, length, self.sample(prompt, length)))
print("Completed training.")
def sample(self, prompt, length):
self.net.reset()
if prompt == None:
prompt = chr(random.choice(self.mapping))
output = prompt
charCode = ord(prompt)
for i in range(0, length):
sampledResult = self.net.activate([charCode])
charCode = int(round(sampledResult[0]))
if charCode < 0 or charCode >= len(self.mapping):
return output + "#TERMINATED_SAMPLE(reason: learner guessed invalid character)"
output += chr(self.mapping[charCode])
return output
hiddenLayerB = SigmoidLayer(hiddenVector, name='hiddenLayerB') outputLayer = LinearLayer(outputVector, name='outputLayer') n.addInputModule(inLayer) n.addModule(hiddenLayerA) n.addModule(hiddenLayerB) n.addOutputModule(outputLayer) n.addConnection(FullConnection(n['inputLayer'], n['hiddenLayerA'], name='c1')) n.addConnection(FullConnection(n['hiddenLayerA'], n['hiddenLayerB'], name='c2')) n.addConnection(FullConnection(n['hiddenLayerB'], n['outputLayer'], name='c3')) n.addRecurrentConnection(FullConnection(n['hiddenLayerA'], n['hiddenLayerB'], name='rec3')) n.sortModules() print 'Network One (Recurrent)' + str(n.activate([1,2,3])) print 'Network One (Recurrent)' + str(n.activate([1,2,3])) #### #FEED FORWARD NETWORK #### n2 = FeedForwardNetwork() inLayer2 = LinearLayer(inputVector, name='inputLayer') hiddenLayerA2 = SigmoidLayer(hiddenVector, name='hiddenLayerA') hiddenLayerB2 = SigmoidLayer(hiddenVector, name='hiddenLayerB') outputLayer2 = LinearLayer(outputVector, name='outputLayer') n2.addInputModule(inLayer) n2.addModule(hiddenLayerA)
n.addConnection(in_to_hidden) n.addConnection(hidden_to_out) n.sortModules() r.addInputModule(LinearLayer(2, name='in')) r.addModule(SigmoidLayer(3, name='hidden')) r.addOutputModule(LinearLayer(1, name='out')) r.addConnection(FullConnection(n['in'], n['hidden'], name='c1')) r.addConnection(FullConnection(n['hidden'], n['out'], name='c2')) r.addRecurrentConnection(FullConnection(n['hidden'], n['hidden'], name='c3')) r.sortModules() #Show trainable weights print "These are the trainable weights" print in_to_hidden.params print hidden_to_out.params #Test Prints print n.activate([1, 2]) print n print "" print r.activate((2, 2)) print r
# build our recurrent network with 10 hidden neurodes, one recurrent
# connection, using tanh activation functions
net = RecurrentNetwork()
hidden_neurodes = 10
net.addInputModule(LinearLayer(len(train_set["input"][0]), name="in"))
net.addModule(TanhLayer(hidden_neurodes, name="hidden1"))
net.addOutputModule(LinearLayer(len(train_set["target"][0]), name="out"))
net.addConnection(FullConnection(net["in"], net["hidden1"], name="c1"))
net.addConnection(FullConnection(net["hidden1"], net["out"], name="c2"))
net.addRecurrentConnection(
FullConnection(net["out"], net["hidden1"], name="cout"))
net.sortModules()
net.randomize()
# train for 30 epochs (overkill) using the rprop- training algorithm
trainer = RPropMinusTrainer(net, dataset=train_set, verbose=True)
trainer.trainOnDataset(train_set, 30)
# test on training set
predictions_train = np.array(
[net.activate(train_set["input"][i])[0] for i in xrange(len(train_set))])
plt.plot(train_set["target"], c="k")
plt.plot(predictions_train, c="r")
plt.show()
# and on test set
predictions_test = np.array(
[net.activate(test_set["input"][i])[0] for i in xrange(len(test_set))])
plt.plot(test_set["target"], c="k")
plt.plot(predictions_test, c="r")
plt.show()
more fancy than a stack of fully connected layers: """ n3 = buildNetwork(2, 3, 1, bias=False) """ Recurrent networks are working in the same way, except that the recurrent connections need to be explicitly declared upon construction. We can modify our existing network 'net2' and add a recurrent connection on the hidden layer: """ n2.addRecurrentConnection(FullConnection(n2['h'], n2['h'], name='rec')) """ After every structural modification, if we want ot use the network, we call 'sortModules()' again""" n2.sortModules() print n2 """ As the network is now recurrent, successive activations produce different outputs: """ print n2.activate([1, 2]), print n2.activate([1, 2]), print n2.activate([1, 2]) """ The 'reset()' method re-initializes the network, and with it sets the recurrent activations to zero, so now we get the same results: """ n2.reset() print n2.activate([1, 2]), print n2.activate([1, 2]), print n2.activate([1, 2]) """ This is already a good coverage of the basics, but if you're an advanced user and would like to know more about the possibilities of nesting networks within others, using weight-sharing, and more exotic types of networks, connections and modules, then please read on.
if tstresult <= 0.5 :
print('Bingo !!!!!!!!!!!!!!!!!!!!!!')
break
# export network
NetworkWriter.writeToFile(net, 'signal_weight.xml')
# run test
actual_price = np.array([n[3] for n in testing_input])
predict_short = []
predict_long = []
result_long = []
result_short = []
for i, (x, y) in enumerate(zip(testing_input, testing_output)):
z = net.activate(x)
predict_short.append(z[0])
predict_long.append(z[1])
result_long.append(abs(testing_output[0] - z[0]))
result_short.append(abs(testing_output[1] - z[1]))
predict_short = np.asarray(predict_short)
predict_long = np.asarray(predict_long)
short_up_idxs = predict_short > 0
short_down_idxs = predict_short < 0
long_up_idxs = predict_long > 0
long_down_idxs = predict_long < 0
# print test
def normalize_result(data):
max_v = np.max(data)
#!/usr/bin/env python from pybrain.structure import RecurrentNetwork from pybrain.structure import LinearLayer, SigmoidLayer from pybrain.structure import FullConnection n = RecurrentNetwork() n.addInputModule(LinearLayer(2, name='in')) n.addModule(SigmoidLayer(3, name='hidden')) n.addOutputModule(LinearLayer(1, name='out')) n.addConnection(FullConnection(n['in'], n['hidden'], name='con1')) n.addConnection(FullConnection(n['hidden'], n['out'], name='con2')) #The RecurrentNetwork class has one additional method, .addRecurrentConnection(), which looks back in time one timestep. We can add one from the hidden to the hidden layer: n.addRecurrentConnection(FullConnection(n['hidden'], n['hidden'], name='con3')) n.sortModules() print n.activate((2, 2)) print n.activate((2, 2)) print n.activate((2, 2)) n.reset() print n.activate((2, 2)) print n.activate((2, 2)) print n.activate((2, 2))
class neural_network(object):
def __init__(self, name, dataset, trained, store):
self.name = name
self.store = store
self.trained = trained
self.dataset = dataset
self.net = RecurrentNetwork()
self.net.addInputModule(LinearLayer(2, name='in'))
self.net.addModule(SigmoidLayer(3, name='hidden'))
self.net.addOutputModule(LinearLayer(2, name='out'))
self.net.addConnection(FullConnection(self.net['in'], self.net['out'], name='c1'))
self.net.addConnection(FullConnection(self.net['hidden'], self.net['out'], name='c2'))
self.net.addRecurrentConnection(FullConnection(self.net['hidden'], self.net['hidden'], name='c3'))
self.net.sortModules()
'''
self.net = buildNetwork(2, 3, 2)
'''
if not self.trained:
self.train()
return
def save(self):
self.store.save_neural_network(self.name, self.dataset, self.trained)
return
@classmethod
def get_saved(cls, name, store):
result = store.get_neural_network(name)
return cls(name, result[0], result[1], store) if result else None
@classmethod
def get_list(cls, store):
result = store.get_neural_network_list()
print result
return [x for x in result]
@classmethod
def new(cls, name, store, ds_file_uri):
dataset = rttl.dataset_from_file(ds_file_uri)
store.new_neural_network(name, dataset)
return
def evaluate(self, genome):
err = 0.0
for i in range(len(genome) - 1):
print '---------- input ------------'
print genome[i]
output = self.net.activate(genome[i])
print '--------- output ------------'
print output
target = genome[i + 1]
err += (math.fabs(output[0] - target[0]) + math.fabs(output[1] - target[1]))
return 1/err
def train(self):
ds_store = []
for song in self.dataset:
ds_in = song[:len(song) - 1]
ds_out = song[1:]
ds = SupervisedDataSet(2, 2)
for i in range(len(song) -1):
#if ds_in[i] not in ds_store:
ds.addSample(ds_in[i], ds_out[i])
ds_store.append(ds_in[i])
if len(ds):
trainer = BackpropTrainer(self.net, ds, verbose=True)
trainer.trainUntilConvergence()
self.save()
if __name__ == "__main__":
from pybrain.structure import RecurrentNetwork
from pybrain.structure import LinearLayer
from pybrain.structure import SigmoidLayer
from pybrain.structure import FullConnection
net = RecurrentNetwork()
net.addInputModule(LinearLayer(2, "in"))
net.addModule(SigmoidLayer(3, "hidden"))
net.addOutputModule(LinearLayer(1, "out"))
net.addConnection(FullConnection(net["in"], net["hidden"], "c1"))
net.addConnection(FullConnection(net["hidden"], net["out"], "c2"))
net.addRecurrentConnection(FullConnection(net["hidden"], net["hidden"], "c3-recurrent"))
net.sortModules()
print net
for i in xrange(5):
print net.activate([2, 2])
print "reset"
net.reset()
for i in xrange(5):
print net.activate([2, 2])
from pybrain.structure import RecurrentNetwork, LinearLayer, SigmoidLayer from pybrain.structure import FullConnection n = RecurrentNetwork() inLayer = LinearLayer(2, name="Input") hiddenLayer = SigmoidLayer(3, name="Hidden") outLayer = LinearLayer(1, name="Output") n.addInputModule(inLayer) n.addModule(hiddenLayer) n.addOutputModule(outLayer) n.addConnection(FullConnection(inLayer, hiddenLayer, name="C_IH")) n.addConnection(FullConnection(hiddenLayer, outLayer, name="C_HO")) n.addRecurrentConnection(FullConnection(n['Hidden'], n['Hidden'], name='C_HH')) n.sortModules() n.reset() print n.activate((2,2))
hidden_to_out = FullConnection(hiddenLayer, outLayer) n.addConnection(in_to_hidden) n.addConnection(hidden_to_out) n.sortModules() r.addInputModule(LinearLayer(2, name='in')) r.addModule(SigmoidLayer(3, name='hidden')) r.addOutputModule(LinearLayer(1, name='out')) r.addConnection(FullConnection(n['in'], n['hidden'], name='c1')) r.addConnection(FullConnection(n['hidden'], n['out'], name='c2')) r.addRecurrentConnection(FullConnection(n['hidden'], n['hidden'], name='c3')) r.sortModules() #Show trainable weights print "These are the trainable weights" print in_to_hidden.params print hidden_to_out.params #Test Prints print n.activate([1, 2]) print n print "" print r.activate((2, 2)) print r
ds.endOfData()
# Create bp trainer
trainer = BackpropTrainer(net, ds)
# Trains the datasets
print 'Training ...'
epoch = 1000
error = 1.0
while error > delta_error and epoch >= 0:
error = trainer.train()
epoch -= 1
print 'Epoch = %d, Error = %f' % (epoch, error)
# To store the epoch error
err_array = []
for row in df.itertuples(index=False):
result = net.activate(row[0:columns-2])
expect = row[columns-2]
error = abs(expect - result)
err_array.append(error)
print 'Result = %f, Expect = %f, Error = %f' % (result, expect, error)
err_df = pd.DataFrame(err_array)
err_df.plot()
plt.show()
print 'Sum Error = %f' % err_df.sum(axis=0)
for i in range(Xtr.shape[0]):
ds.addSample(Xtr[i,:],Ytr[i])
for i in range(Xte.shape[0]):
dst.addSample(Xte[i,:],Yte[i])
#net = buildNetwork(ds.indim,ds.indim,ds.indim,ds.indim,ds.outdim,recurrent=False)
trainer = BackpropTrainer(net,learningrate=learnRate,momentum=moment,verbose=False)
#trainer.trainOnDataset(ds,30)
trainer.trainUntilConvergence(ds,10)
#trainer.testOnData(verbose=True)
mse = 0.0
for i in range(Xte.shape[0]):
mse += pow(net.activate(Xte[i])[0]-Yte[i],2)
mse /= Xte.shape[0]
mseTrain = 0.0
for i in range(Xtr.shape[0]):
mseTrain += pow(net.activate(Xtr[i])[0]-Ytr[i],2)
mseTrain /= Xtr.shape[0]
print 'mse(test):{},mse(train):{},epoch:{},width:{},depth:{},momentum:{},learnrate:{}'.format(mse,mseTrain,epochs,hidw,depth,moment,learnRate)
testdat.write('{},{},{},{},{},{},{}\n'.format(mse,mseTrain,epochs,hidw,depth,learnRate,moment))
testdat.close()
#modelfile = open('model.dat','w')
#pickle.dump(net,modelfile)
#modelfile.close()
#fh = open('predictions.csv','w') # open file for upload
#fh.write('ID,Prediction\n') # output header line
from pybrain.structure import RecurrentNetwork from pybrain.structure import LinearLayer, SigmoidLayer from pybrain.structure import FullConnection n = RecurrentNetwork() n.addInputModule(LinearLayer(2, name='in')) n.addModule(SigmoidLayer(3, name='hidden')) n.addOutputModule(LinearLayer(1, name='out')) n.addConnection(FullConnection(n['in'], n['hidden'], name='c1')) n.addConnection(FullConnection(n['hidden'], n['out'], name='c2')) n.addRecurrentConnection(FullConnection(n['hidden'], n['hidden'], name='c3')) n.sortModules() n.reset() print(n.activate((2, 2)))
net.addConnection(FullConnection(net[('hidden' + str(x))], net['hidden' + str(x + 1)], name=('c' + str(x + 1))))
net.addConnection(FullConnection(net['hidden' + str(layerCount - 1)], net['out'], name='cOut'))
net.sortModules()
from pybrain.supervised import RPropMinusTrainer
trainer = RPropMinusTrainer(net, dataset=ds)
epochcount = 0
while True:
startingnote = random.choice(range(1, 17))
startingnote2 = random.choice(range(1, 17))
startingduration = random.choice(range(1,17))
startingduration2 = random.choice(range(1, 17))
song = [[startingnote, startingduration, 1, 1, 0, startingnote2, startingduration2, 1, 1, 0]]
length = 50
while len(song) < length:
song.append(net.activate(song[-1]).tolist())
newsong = []
for x in song:
newx = []
newy = []
for i in x:
if len(newx) < 5:
newx.append(int(i))
else:
newy.append(int(i))
newsong.append(newx)
newsong.append(newy)
print newsong
print "The above song is after " + str(epochcount) + " epochs."
trainer.trainEpochs(epochs=1)
ds = SupervisedDataSet(2,1)
ds.addSample([1,1],[0])
ds.addSample([0,0],[0])
ds.addSample([0,1],[1])
ds.addSample([1,0],[1])
#Train the network
trainer = BackpropTrainer(network, ds, momentum=0.99)
print network
print "\nInitial weights: ", network.params
max_error = 1e-7
error, count = 1, 1000
#Train
while abs(error) >= max_error and count > 0:
error = trainer.train()
count = count - 1
print "Final weights: ", network.params
print "Error: ", error
#Test data
print '\n1 XOR 1:',network.activate([1,1])[0]
print '1 XOR 0:',network.activate([1,0])[0]
from pybrain.supervised import RPropMinusTrainer
trainer = RPropMinusTrainer(net, dataset=ds)
epochcount = 0
while True:
startingnote = random.choice(range(1, 17))
startingnote2 = random.choice(range(1, 17))
startingduration = random.choice(range(1, 17))
startingduration2 = random.choice(range(1, 17))
song = [[
startingnote, startingduration, 1, 1, 0, startingnote2,
startingduration2, 1, 1, 0
]]
length = 50
while len(song) < length:
song.append(net.activate(song[-1]).tolist())
newsong = []
for x in song:
newx = []
newy = []
for i in x:
if len(newx) < 5:
newx.append(int(i))
else:
newy.append(int(i))
newsong.append(newx)
newsong.append(newy)
print newsong
print "The above song is after " + str(epochcount) + " epochs."
trainer.trainEpochs(epochs=1)
from pybrain.structure import FullConnection #get no of words from corpus and store in numInputNodes and numOutputNodes numInputNodes = 10 numHiddenNodes = 5 numOutputNodes = 10 #Creating a recurrent network with 1 input node, 1 output node and 10 hidden nodes network = RecurrentNetwork() network.addInputModule(LinearLayer(numInputNodes, name='in')) network.addModule(SigmoidLayer(numHiddenNodes, name='hidden')) network.addOutputModule(LinearLayer(numOutputNodes, name='out')) in_to_hidden = FullConnection(network['in'], network['hidden'], name='connection1') hidden_to_out = FullConnection(network['hidden'], network['out'], name='connection2') hidden_to_hidden = FullConnection(network['hidden'], network['hidden'], name='connection3') network.addConnection(in_to_hidden) network.addConnection(hidden_to_out) network.addRecurrentConnection(hidden_to_hidden) network.sortModules() print network.activate([1,0,0,0,0,0,0,0,0,0]) ''' print in_to_hidden.params print "\n\n" print hidden_to_out.params print "\n\n" print hidden_to_hidden.params print "\n\n" ''' #Input value initially: 1 of n coding of word + previous state s(t-1)
#Train net
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(net, ds, momentum=0.1, verbose=True, weightdecay=0.01)
#for i in range(10):
# if i%20==0:
# print i
# trainer.trainEpochs(1)
trnerr,testerr = trainer.trainUntilConvergence(dataset=ds,maxEpochs=10)
plt.plot(trnerr,'b',valerr,'r')
# <codecell>
print net.activate(Xtest.ix[1,:])
print ytest.ix[1,:]
# <codecell>
to_hidden=numpy.dot(in_to_hidden.params.reshape(hiddenLayer.dim,inLayer.dim),Xtest.ix[0,:].as_matrix())
# <codecell>
to_out=hiddenLayer.activate(to_hidden)
# <codecell>
in_to_hidden.params.reshape(hiddenLayer.dim,inLayer.dim)
# <codecell>
net.addConnection(conn_in_to_hid)
net.addConnection(conn_hid_to_out)
net.addRecurrentConnection(recurrent_connection)
net.sortModules()
# Since our preprocessor_engine does stuff and writes output to output.txt,
# neural_engine takes its input from it
input_file = open('output.txt', 'r')
# each line in output.txt is a preprocessed token.
# Read line by line and remove endline character
input_tokens = input_file.readlines()
input_tokens = [t.strip() for t in input_tokens]
input_file.close()
# for each token, convert it to vector of dimension equal to our vectorizer_engine's dimension
# send that vector to neural network
# output of the network at every time step will be a vector of dimension equal to our vectorizer_engine's dimension
# convert that vector to word using our vectorizer engine and write it to file 'summary-output.txt'
summary_file = open('summary-text.txt', 'w+')
for word in input_tokens:
input_vec = vec_engine.word2vec(word)
output_vec = net.activate(input_vec)
output_word = vec_engine.vec2word(output_vec)
summary_file.write(output_word + " ")
summary_file.flush()
summary_file.close()
max_error = 1
error, epocas = 5, 1000
epocasPercorridas = 0
# Train
while epocas > 0:
error = trainer.train()
epocas = epocas - 1
epocasPercorridas = epocasPercorridas + 1
if error == 0:
break
# print "\n Treinando ate a convergencia. . ."
# trainer.trainUntilConvergence()
# print "\n\nRNA treinada ate a convergencia!"
print "\n\nPesos finais: ", network.params
print "\nErro final: ", error
print "\n\nTotal de epocas percorridas: ", epocasPercorridas
# Test data
print '\n\n1 XOR 1: Esperado = 0, Calculado = ', network.activate([1, 1])[0]
print '1 XOR 0: Esperado = 1, Calculado =', network.activate([1, 0])[0]
print '0 XOR 1: Esperado = 1, Calculado =', network.activate([0, 1])[0]
print '0 XOR 0: Esperado = 0, Calculado =', network.activate([0, 0])[0]
""" Recurrent networks are working in the same way, except that the recurrent connections need to be explicitly declared upon construction. We can modify our existing network 'net2' and add a recurrent connection on the hidden layer: """ n2.addRecurrentConnection(FullConnection(n2['h'], n2['h'], name='rec')) """ After every structural modification, if we want ot use the network, we call 'sortModules()' again""" n2.sortModules() print(n2) """ As the network is now recurrent, successive activations produce different outputs: """ print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2])) """ The 'reset()' method re-initializes the network, and with it sets the recurrent activations to zero, so now we get the same results: """ n2.reset() print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2])) """ This is already a good coverage of the basics, but if you're an advanced user you might want to find out about the possibilities of nesting networks within others, using weight-sharing, and more exotic types of networks, connections and modules... but that goes beyond the scope of this tutorial.
""" Recurrent networks are working in the same way, except that the recurrent connections need to be explicitly declared upon construction. We can modify our existing network 'net2' and add a recurrent connection on the hidden layer: """ n2.addRecurrentConnection(FullConnection(n2['h'], n2['h'], name='rec')) """ After every structural modification, if we want ot use the network, we call 'sortModules()' again""" n2.sortModules() print(n2) """ As the network is now recurrent, successive activations produce different outputs: """ print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2])) """ The 'reset()' method re-initializes the network, and with it sets the recurrent activations to zero, so now we get the same results: """ n2.reset() print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2])) """ This is already a good coverage of the basics, but if you're an advanced user you might want to find out about the possibilities of nesting networks within others, using weight-sharing, and more exotic types of networks, connections and modules... but that goes beyond the scope of this tutorial.
if __name__ == "__main__":
from pybrain.structure import RecurrentNetwork
from pybrain.structure import LinearLayer
from pybrain.structure import SigmoidLayer
from pybrain.structure import FullConnection
net = RecurrentNetwork()
net.addInputModule(LinearLayer(2, "in"))
net.addModule(SigmoidLayer(3, "hidden"))
net.addOutputModule(LinearLayer(1, "out"))
net.addConnection(FullConnection(net["in"], net["hidden"], "c1"))
net.addConnection(FullConnection(net["hidden"], net["out"], "c2"))
net.addRecurrentConnection(FullConnection(net["hidden"], net["hidden"],
"c3-recurrent"))
net.sortModules()
print net
for i in xrange(5):
print net.activate([2, 2])
print "reset"
net.reset()
for i in xrange(5):
print net.activate([2, 2])
final_delta_delta_mfcc = np.concatenate(
(final_delta_delta_mfcc, [temp_delta_delta_mfcc]), axis=0)
final_dataset = np.concatenate((final_dataset, [temp_dataset]),
axis=0)
dataset_op = 0
dataset_ip = 0
ds.clear()
parameters = np.load('parameters.npy')
LSTMre._setParameters(parameters)
output = np.empty((100, 5))
#print(LSTMre.params)
print('____________>output')
for i in range(100):
output[i] = LSTMre.activate(final_dataset[i])
final_op = np.mean(output, axis=0)
print('YOU SAID--------------->')
state = generate_target.final_output(final_op)
#is_it_correct = input('Is it correct?')
'''if is_it_correct == 'n'
is_correct = False
else:
is_correct = True'''
if is_correct:
car_send(state)
'''do_train = input('Do you want to train? Enter --> x <-- to cancel')
if do_train != 'x':
n.addInputModule(LinearLayer(
2,
name='entradas')) #agrega el modulo de 'entrada' a la red con 2 entradas
n.addModule(SigmoidLayer(3, name='ocultas')
) #agrega el modulo de 'oculta' a la red con 3 capas ocultas
#n.addModule(TanhLayer(3, name = 'ocultas'))#agrega el modulo de 'oculta' a la red con 3 capas ocultas
n.addOutputModule(LinearLayer(
1, name='salidas')) #agrega el modulo de 'salida' a la red con 1 salida
#flujo de informacion entre las capas
n.addConnection(
FullConnection(n['entradas'], n['ocultas'], name='con1')
) #agrega y conecta el modulo de conexion de capa 'entrada' a la red con las capas ocultas
n.addConnection(
FullConnection(n['ocultas'], n['salidas'], name='con2')
) #agrega y conecta el modulo de conexion de capa 'salida' a la red con las capas ocultas
n.addRecurrentConnection(
FullConnection(n['ocultas'], n['ocultas'], name='con3')) #metodo adicional
n.sortModules() #ordena la red
#visualizar valores (pesos)
print n #visualizar estructura de la red
print ''
print n.params #todos los pesos
print ''
print n.activate([1, 2]) #prenguntar a la red la salida para cierta entrada
#n.reset()#limpiar la red
