def training(d):
# net = buildNetwork(d.indim, 55, d.outdim, bias=True,recurrent=False, hiddenclass =SigmoidLayer , outclass = SoftmaxLayer)
net = FeedForwardNetwork()
inLayer = SigmoidLayer(d.indim)
hiddenLayer1 = SigmoidLayer(d.outdim)
hiddenLayer2 = SigmoidLayer(d.outdim)
outLayer = SigmoidLayer(d.outdim)
net.addInputModule(inLayer)
net.addModule(hiddenLayer1)
net.addModule(hiddenLayer2)
net.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer1)
hidden_to_hidden = FullConnection(hiddenLayer1, hiddenLayer2)
hidden_to_out = FullConnection(hiddenLayer2, outLayer)
net.addConnection(in_to_hidden)
net.addConnection(hidden_to_hidden)
net.addConnection(hidden_to_out)
net.sortModules()
print net
t = BackpropTrainer(net, d, learningrate = 0.9,momentum=0.9, weightdecay=0.01, verbose = True)
t.trainUntilConvergence(continueEpochs=1200, maxEpochs=1000)
NetworkWriter.writeToFile(net, 'myNetwork'+str(time.time())+'.xml')
return t
def train(self, epochs=None):
trainer = BackpropTrainer(
self.net,
self.training_data
)
if epochs:
trainer.trainEpochs(epochs)
else:
trainer.trainUntilConvergence()
def main(f_samples):
f_reading = open(f_samples, 'r')
global data
data = []
for line in f_reading:
line = line.split()
data.append( (float(line[0]), float(line[-1])) )
#function
data_module = lambda x: map( lambda z: data[z], filter( lambda y: y% 5 == x, xrange(len(data)) ) )
global data1
data1 = [data_module(0), data_module(1), data_module(2), data_module(3), data_module(4)]
global data_transformed
data_transformed = take(data, rate = 60)
global data_transformed_training
data_transformed_training = map( lambda x: data_transformed[x], filter( lambda x: uniform(0, 1) > 0.3, xrange(len(data_transformed)) ))
#Learning process-----------------------------------------------------------------
global net, samples, trainer
net = FeedForwardNetwork()
inLayer = LinearLayer(3)
hiddenLayer0 = SigmoidLayer(1)
hiddenLayer1 = SigmoidLayer(3)
outLayer = LinearLayer(1)
net.addInputModule(inLayer)
# net.addModule(hiddenLayer0)
# net.addModule(hiddenLayer1)
net.addOutputModule(outLayer)
# net.addConnection(FullConnection(inLayer, hiddenLayer0))
net.addConnection(FullConnection(inLayer, outLayer))
# net.addConnection(FullConnection(hiddenLayer0, outLayer))
# net.addConnection(FullConnection(hiddenLayer0, hiddenLayer1))
# net.addConnection(FullConnection(hiddenLayer1, outLayer))
net.sortModules()
print net
##Net with 3 inputs, 8 hidden neurons in a layerand 8 in another, and 1 out.
#net = buildNetwork(3,8,8,1)
##Set with 2 inputs and one output for each sample
samples = SupervisedDataSet(3,1)
for i in data_transformed_training:
samples.addSample(i['past'], i['next'] - i['average'])
trainer = BackpropTrainer(net, samples)
print 'Training'
trainer.trainUntilConvergence(maxEpochs= 10)
print 'Comparing'
compare_net_samples(net, data_transformed)
print "Number of samples %d for training." %len(data_transformed_training)
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 training(d):
"""
Builds a network and trains it.
"""
n = buildNetwork(d.indim, INPUTS-3,INPUTS-4, d.outdim,recurrent=True)
print n;
t = BackpropTrainer(n, d, learningrate = 0.02, momentum = 0.88)
#for epoch in range(0,700):
t.trainUntilConvergence(d, 1190)
return t
def train(self, **kwargs):
if "verbose" in kwargs:
verbose = kwargs["verbose"]
else:
verbose = False
"""t = BackpropTrainer(self.rnn, dataset=self.trndata, learningrate = 0.1, momentum = 0.0, verbose = True)
for i in range(1000):
t.trainEpochs(5)
"""
# pdb.set_trace()
#print self.nn.outdim, " nn | ", self.trndata.outdim, " trndata "
trainer = BackpropTrainer(self.nn, self.trndata, learningrate = 0.0005, momentum = 0.99)
assert (self.tstdata is not None)
assert (self.trndata is not None)
b1, b2 = trainer.trainUntilConvergence(verbose=verbose,
trainingData=self.trndata,
validationData=self.tstdata,
maxEpochs=10)
#print b1, b2
#print "new parameters are: "
#self.print_connections()
return b1, b2
def train(training_data):
training_set = ClassificationDataSet(len(feats), nb_classes=len(classes))
for inst in training_data:
training_set.appendLinked(inst.features(), [inst.class_idx()])
training_set._convertToOneOfMany([0, 1])
net_placeholder[0] = buildNetwork(
training_set.indim,
int((training_set.indim + training_set.outdim)/2),
training_set.outdim, bias=True,
hiddenclass=TanhLayer,
outclass=SoftmaxLayer
)
trainer = BackpropTrainer(
net_placeholder[0], training_set, momentum=0.75, verbose=False, learningrate=0.05
)
trainer.trainUntilConvergence(maxEpochs=100, validationProportion=0.1)
def build_net(self):
if os.path.exists(self.NET_FILE):
return NetworkReader.readFrom(self.NET_FILE)
ds = ClassificationDataSet(len(feats), nb_classes=len(classes))
for c in classes:
print c
with codecs.open(os.path.join(self.data_root, c+".txt"), 'r', 'utf8') as f:
for line in f:
r = Record("11", line, c, "")
ds.appendLinked(r.features(), [r.class_idx()])
ds._convertToOneOfMany([0, 1])
net = buildNetwork(ds.indim, int((ds.indim + ds.outdim)/2), ds.outdim, bias=True, hiddenclass=TanhLayer, outclass=SoftmaxLayer)
trainer = BackpropTrainer(net, ds, momentum=0.75, verbose=True)
trainer.trainUntilConvergence(maxEpochs=300)
NetworkWriter.writeToFile(net, self.NET_FILE)
return net
def learn_until_convergence(self, learning_rate, momentum, max_epochs, continue_epochs, verbose=True):
if verbose:
print "Training neural network..."
trainer = BackpropTrainer(self.network, self.learn_data, learningrate=learning_rate, momentum=momentum)
training_errors, validation_errors = trainer.trainUntilConvergence(continueEpochs=continue_epochs,
maxEpochs=max_epochs)
self.x = range(1, len(training_errors) + 1)
self.err = training_errors
return self.network
def create_network(timesteps):
trndata, validdata, tstdata = read_data_MNIST(timesteps)
rnn = buildNetwork(
trndata.indim, 20, trndata.outdim, hiddenclass=LSTMLayer, outclass=SoftmaxLayer, outputbias=True, recurrent=True
)
# 20 is the number of LSTM blocks in the hidden layer
# we use the BPTT algo to train
trainer = BackpropTrainer(rnn, dataset=trndata, verbose=True, momentum=0.9, learningrate=0.00001)
print "Training started ..."
t1 = time.clock()
# trainer.trainEpochs(10)
trainer.trainUntilConvergence(maxEpochs=1000)
t2 = time.clock()
print "Training 1000 epochs took : ", (t2 - t1) / 60.0, "minutes "
# train for 1000 epochs
trnresult = 100.0 * (1.0 - testOnSequenceData(rnn, trndata))
tstresult = 100.0 * (1.0 - testOnSequenceData(rnn, tstdata))
print "Train Error : %5.2f%%" % trnresult, " , test error :%5.2f%%" % tstresult
def neuralNetworkRegression(X,Y):
print ("NEURAL NETWORK REGRESSION")
print ("Executing...")
X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(X, Y, test_size = 0.10, random_state = 5)
Y_test = Y_test.reshape(-1,1)
Y_train = Y_train.reshape(-1,1)
RMSEerror = []
train = np.vstack((X_train, X_test)) # append both testing and training into one array
outputTrain = np.vstack((Y_train, Y_test))
outputTrain = outputTrain.reshape( -1, 1 )
inputSize = train.shape[1]
targetSize = outputTrain.shape[1]
ds = SupervisedDataSet(inputSize, targetSize)
ds.setField('input', train)
ds.setField('target', outputTrain)
hiddenSize = 100
epochs = 100 # got after parameter tuning
# neural network training model
net = buildNetwork( inputSize, hiddenSize, targetSize, bias = True )
trainer = BackpropTrainer(net, ds)
# uncomment out to plot epoch vs rmse
# takes time to execute as gets best epoch value
# getting the best value of epochs
print ("training for {} epochs...".format( epochs ))
'''
for i in range(epochs):
print (i)
mse = trainer.train()
rmse = mse ** 0.5
RMSEerror.append(rmse)
plt.plot(range(epochs), RMSEerror)
plt.xlabel("Epochs")
plt.ylabel("RMSE")
plt.title("RMSE vs Epochs")
plt.savefig("../Graphs/Network/Question 2c/RMSE vs Epochs.png")
plt.show()
'''
print ("Model training in process...")
train_mse, validation_mse = trainer.trainUntilConvergence(verbose = True, validationProportion = 0.15, maxEpochs = epochs, continueEpochs = 10)
p = net.activateOnDataset(ds)
mse = mean_squared_error(outputTrain, p)
rmse = mse ** 0.5
print ("Root Mean Squared Error for Best Parameters : " + str(rmse))
def main(args=[__file__]):
trnDs, tstDs = getSeparateDataSets()
net = buildNetwork(trnDs.indim, int((trnDs.indim + trnDs.outdim)/2), trnDs.outdim, bias=True, hiddenclass=TanhLayer, outclass=SoftmaxLayer)
trainer = BackpropTrainer(net, trnDs, momentum=0.75, verbose=True, learningrate=0.05)
trainer.trainUntilConvergence(maxEpochs=100, validationProportion=0.1)
eval = evaluate(net, tstDs)
print "accuracy:", eval.getWeightedAccuracy()
print "recall:", eval.getWeightedRecall()
print "precision:", eval.getWeightedPrecision()
print "F-measure:", eval.getWeightedFMeasure()
if detailed:
for evalRes in eval.evals:
print "Class:", evalRes.clazz
print "Accuracy:", evalRes.getAccuracy()
print "Recall:", evalRes.getRecall()
print "Precision:", evalRes.getPrecision()
print "F-measure:", evalRes.getFMeasure()
print '-'*35
print '-'*70
def train(self):
"""t = BackpropTrainer(self.rnn, dataset=self.trndata, learningrate = 0.1, momentum = 0.0, verbose = True)
for i in range(1000):
t.trainEpochs(5)
"""
print self.nn.outdim, " nn | ", self.trndata.outdim, " trndata "
trainer = BackpropTrainer(self.nn, self.trndata, learningrate = 0.0005, momentum = 0.99)
b1, b2 = trainer.trainUntilConvergence(verbose=True,
trainingData=self.trndata,
validationData=self.tstdata,
maxEpochs=10)
print b1, b2
print "new parameters are: "
self.print_connections()
def get_third_nn(value, good_data, bad_data):
build_network = FeedForwardNetwork()
inLayer = LinearLayer(len(good_data[0]))
hiddenLayer = SigmoidLayer(value)
outLayer = SigmoidLayer(1)
build_network.addInputModule(inLayer)
build_network.addModule(hiddenLayer)
build_network.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
in_to_out = FullConnection(inLayer, outLayer)
build_network.addConnection(in_to_hidden)
build_network.addConnection(hidden_to_out)
build_network.addConnection(in_to_out)
build_network.sortModules()
trainer = BackpropTrainer(build_network,
get_supervised_data_set(good_data, bad_data))
result = trainer.trainUntilConvergence()
return result[0][-1]
def trainNetworkBackprop(self, dataset, maxIter):
trainer = BackpropTrainer(self.net, dataset)
print "\tInitialised backpropogation traininer. Now execute until convergence::"
trainer.trainUntilConvergence(verbose=True, maxEpochs=maxIter)
print "\tConvergence achieved."
class RWR(DirectSearchLearner):
""" Reward-weighted regression.
The algorithm is currently limited to discrete-action episodic tasks, subclasses of POMDPTasks.
"""
# parameters
batchSize = 20
# feedback settings
verbose = True
greedyRuns = 20
supervisedPlotting = False
# settings for the supervised training
learningRate = 0.005
momentum = 0.9
maxEpochs = 20
validationProportion = 0.33
continueEpochs = 2
# parameters for the variation that uses a value function
# TODO: split into 2 classes.
valueLearningRate = None
valueMomentum = None
#valueTrainEpochs = 5
resetAllWeights = False
netweights = 0.01
def __init__(self, net, task, valueNetwork=None, **args):
self.net = net
self.task = task
self.setArgs(**args)
if self.valueLearningRate == None:
self.valueLearningRate = self.learningRate
if self.valueMomentum == None:
self.valueMomentum = self.momentum
if self.supervisedPlotting:
from pylab import ion
ion()
# adaptive temperature:
self.tau = 1.
# prepare the datasets to be used
self.weightedDs = ImportanceDataSet(self.task.outdim, self.task.indim)
self.rawDs = ReinforcementDataSet(self.task.outdim, self.task.indim)
self.valueDs = SequentialDataSet(self.task.outdim, 1)
# prepare the supervised trainers
self.bp = BackpropTrainer(self.net,
self.weightedDs,
self.learningRate,
self.momentum,
verbose=False,
batchlearning=True)
# CHECKME: outsource
self.vnet = valueNetwork
if valueNetwork != None:
self.vbp = BackpropTrainer(self.vnet,
self.valueDs,
self.valueLearningRate,
self.valueMomentum,
verbose=self.verbose)
# keep information:
self.totalSteps = 0
self.totalEpisodes = 0
def shapingFunction(self, R):
return exp(self.tau * R)
def updateTau(self, R, U):
self.tau = sum(U) / dot((R - self.task.minReward), U)
def reset(self):
self.weightedDs.clear()
self.valueDs.clear()
self.rawDs.clear()
self.bp.momentumvector *= 0.0
if self.vnet != None:
self.vbp.momentumvector *= 0.0
if self.resetAllWeights:
self.vnet.params[:] = randn(len(
self.vnet.params)) * self.netweights
def greedyEpisode(self):
""" run one episode with greedy decisions, return the list of rewards recieved."""
rewards = []
self.task.reset()
self.net.reset()
while not self.task.isFinished():
obs = self.task.getObservation()
act = self.net.activate(obs)
chosen = argmax(act)
self.task.performAction(chosen)
reward = self.task.getReward()
rewards.append(reward)
return rewards
def learn(self, batches):
self.greedyAvg = []
self.rewardAvg = []
self.lengthAvg = []
self.initr0Avg = []
for b in range(batches):
if self.verbose:
print()
print(('Batch', b + 1))
self.reset()
self.learnOneBatch()
self.totalEpisodes += self.batchSize
# greedy measure (avg over some greedy runs)
rws = 0.
for dummy in range(self.greedyRuns):
tmp = self.greedyEpisode()
rws += (sum(tmp) / float(len(tmp)))
self.greedyAvg.append(rws / self.greedyRuns)
if self.verbose:
print(('::', round(rws / self.greedyRuns, 5), '::'))
def learnOneBatch(self):
# collect a batch of runs as experience
r0s = []
lens = []
avgReward = 0.
for dummy in range(self.batchSize):
self.rawDs.newSequence()
self.valueDs.newSequence()
self.task.reset()
self.net.reset()
acts, obss, rewards = [], [], []
while not self.task.isFinished():
obs = self.task.getObservation()
act = self.net.activate(obs)
chosen = drawIndex(act)
self.task.performAction(chosen)
reward = self.task.getReward()
obss.append(obs)
y = zeros(len(act))
y[chosen] = 1
acts.append(y)
rewards.append(reward)
avgReward += sum(rewards) / float(len(rewards))
# compute the returns from the list of rewards
current = 0
returns = []
for r in reversed(rewards):
current *= self.task.discount
current += r
returns.append(current)
returns.reverse()
for i in range(len(obss)):
self.rawDs.addSample(obss[i], acts[i], returns[i])
self.valueDs.addSample(obss[i], returns[i])
r0s.append(returns[0])
lens.append(len(returns))
r0s = array(r0s)
self.totalSteps += sum(lens)
avgLen = sum(lens) / float(self.batchSize)
avgR0 = mean(r0s)
avgReward /= self.batchSize
if self.verbose:
print((
'***',
round(avgLen, 3),
'***',
'(avg init exp. return:',
round(avgR0, 5),
')',
))
print(('avg reward', round(avgReward,
5), '(tau:', round(self.tau, 3), ')'))
print(lens)
# storage:
self.rewardAvg.append(avgReward)
self.lengthAvg.append(avgLen)
self.initr0Avg.append(avgR0)
# if self.vnet == None:
# # case 1: no value estimator:
# prepare the dataset for training the acting network
shaped = self.shapingFunction(r0s)
self.updateTau(r0s, shaped)
shaped /= max(shaped)
for i, seq in enumerate(self.rawDs):
self.weightedDs.newSequence()
for sample in seq:
obs, act, dummy = sample
self.weightedDs.addSample(obs, act, shaped[i])
# else:
# # case 2: value estimator:
#
#
# # train the value estimating network
# if self.verbose: print('Old value error: ', self.vbp.testOnData())
# self.vbp.trainEpochs(self.valueTrainEpochs)
# if self.verbose: print('New value error: ', self.vbp.testOnData())
#
# # produce the values and analyze
# rminusvs = []
# sizes = []
# for i, seq in enumerate(self.valueDs):
# self.vnet.reset()
# seq = list(seq)
# for sample in seq:
# obs, ret = sample
# val = self.vnet.activate(obs)
# rminusvs.append(ret-val)
# sizes.append(len(seq))
#
# rminusvs = array(rminusvs)
# shapedRminusv = self.shapingFunction(rminusvs)
# # CHECKME: here?
# self.updateTau(rminusvs, shapedRminusv)
# shapedRminusv /= array(sizes)
# shapedRminusv /= max(shapedRminusv)
#
# # prepare the dataset for training the acting network
# rvindex = 0
# for i, seq in enumerate(self.rawDs):
# self.weightedDs.newSequence()
# self.vnet.reset()
# for sample in seq:
# obs, act, ret = sample
# self.weightedDs.addSample(obs, act, shapedRminusv[rvindex])
# rvindex += 1
# train the acting network
tmp1, tmp2 = self.bp.trainUntilConvergence(
maxEpochs=self.maxEpochs,
validationProportion=self.validationProportion,
continueEpochs=self.continueEpochs,
verbose=self.verbose)
if self.supervisedPlotting:
from pylab import plot, legend, figure, clf, draw
figure(1)
clf()
plot(tmp1, label='train')
plot(tmp2, label='valid')
legend()
draw()
return avgLen, avgR0
def neuralNetworkRegression(X, Y, X_TEST, Y_TEST):
"""
:param X: data consisting of features (excluding class variable)
:param Y: column vector consisting of class variable
:return: models neural network regression with fine-tuning of epochs
"""
print "NEURAL NETWORK REGRESSION"
print "Executing..."
print
try:
print "Loading saved model..."
net = pickle.load(open("Models/neural.sav", 'rb'))
""" predict new value """
prediction = net.activate(X_TEST)
print "Predicted: ",prediction," True: ", Y_TEST#, "Error: ",np.sqrt(mean_squared_error(map(float,Y_test), ridge.predict(X_test)))
return prediction
except:
# can change to model on the entire dataset but by convention splitting the dataset is a better option
X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(X, Y, test_size = 0.10, random_state = 5)
Y_test = Y_test.reshape(-1,1)
Y_train = Y_train.reshape(-1,1)
RMSEerror = []
train = np.vstack((X_train, X_test)) # append both testing and training into one array
outputTrain = np.vstack((Y_train, Y_test))
outputTrain = [float(s.item()) for s in outputTrain]
outputTrain = np.asarray(outputTrain, dtype=np.float64)
# print outputTrain
outputTrain = outputTrain.reshape( -1, 1 )
inputSize = train.shape[1]
targetSize = outputTrain.shape[1]
ds = SupervisedDataSet(inputSize, targetSize)
ds.setField('input', train)
ds.setField('target', outputTrain)
hiddenSize = 3
epochs = 10000 # got after parameter tuning
# neural network training model
net = buildNetwork( inputSize, hiddenSize, targetSize, hiddenclass=TanhLayer, bias = True )
trainer = BackpropTrainer(net, ds, learningrate=0.1)
print "Model training in process..."
train_mse, validation_mse = trainer.trainUntilConvergence(verbose = True, validationProportion = 0.15, maxEpochs = epochs, continueEpochs = 10)
p = net.activateOnDataset(ds)
mse = mean_squared_error(map(float, outputTrain), map(float, p))
rmse = mse ** 0.5
print "Root Mean Squared Error for Best Parameters : " + str(rmse)
""" save model """
# pickle.dump(net, open("Models/neural.sav", 'wb'))
""" predict new value """
prediction = net.activate(X_TEST)
print "Predicted: ",prediction," True: ", Y_TEST#, "Error: ",np.sqrt(mean_squared_error(map(float,Y_test), ridge.predict(X_test)))
return prediction
class RWR(DirectSearchLearner):
""" Reward-weighted regression.
The algorithm is currently limited to discrete-action episodic tasks, subclasses of POMDPTasks.
"""
# parameters
batchSize = 20
# feedback settings
verbose = True
greedyRuns = 20
supervisedPlotting = False
# settings for the supervised training
learningRate = 0.005
momentum = 0.9
maxEpochs = 20
validationProportion = 0.33
continueEpochs = 2
# parameters for the variation that uses a value function
# TODO: split into 2 classes.
valueLearningRate = None
valueMomentum = None
#valueTrainEpochs = 5
resetAllWeights = False
netweights = 0.01
def __init__(self, net, task, valueNetwork=None, **args):
self.net = net
self.task = task
self.setArgs(**args)
if self.valueLearningRate == None:
self.valueLearningRate = self.learningRate
if self.valueMomentum == None:
self.valueMomentum = self.momentum
if self.supervisedPlotting:
from pylab import ion
ion()
# adaptive temperature:
self.tau = 1.
# prepare the datasets to be used
self.weightedDs = ImportanceDataSet(self.task.outdim, self.task.indim)
self.rawDs = ReinforcementDataSet(self.task.outdim, self.task.indim)
self.valueDs = SequentialDataSet(self.task.outdim, 1)
# prepare the supervised trainers
self.bp = BackpropTrainer(self.net, self.weightedDs, self.learningRate,
self.momentum, verbose=False,
batchlearning=True)
# CHECKME: outsource
self.vnet = valueNetwork
if valueNetwork != None:
self.vbp = BackpropTrainer(self.vnet, self.valueDs, self.valueLearningRate,
self.valueMomentum, verbose=self.verbose)
# keep information:
self.totalSteps = 0
self.totalEpisodes = 0
def shapingFunction(self, R):
return exp(self.tau * R)
def updateTau(self, R, U):
self.tau = sum(U) / dot((R - self.task.minReward), U)
def reset(self):
self.weightedDs.clear()
self.valueDs.clear()
self.rawDs.clear()
self.bp.momentumvector *= 0.0
if self.vnet != None:
self.vbp.momentumvector *= 0.0
if self.resetAllWeights:
self.vnet.params[:] = randn(len(self.vnet.params)) * self.netweights
def greedyEpisode(self):
""" run one episode with greedy decisions, return the list of rewards recieved."""
rewards = []
self.task.reset()
self.net.reset()
while not self.task.isFinished():
obs = self.task.getObservation()
act = self.net.activate(obs)
chosen = argmax(act)
self.task.performAction(chosen)
reward = self.task.getReward()
rewards.append(reward)
return rewards
def learn(self, batches):
self.greedyAvg = []
self.rewardAvg = []
self.lengthAvg = []
self.initr0Avg = []
for b in range(batches):
if self.verbose:
print
print 'Batch', b + 1
self.reset()
self.learnOneBatch()
self.totalEpisodes += self.batchSize
# greedy measure (avg over some greedy runs)
rws = 0.
for dummy in range(self.greedyRuns):
tmp = self.greedyEpisode()
rws += (sum(tmp) / float(len(tmp)))
self.greedyAvg.append(rws / self.greedyRuns)
if self.verbose:
print '::', round(rws / self.greedyRuns, 5), '::'
def learnOneBatch(self):
# collect a batch of runs as experience
r0s = []
lens = []
avgReward = 0.
for dummy in range(self.batchSize):
self.rawDs.newSequence()
self.valueDs.newSequence()
self.task.reset()
self.net.reset()
acts, obss, rewards = [], [], []
while not self.task.isFinished():
obs = self.task.getObservation()
act = self.net.activate(obs)
chosen = drawIndex(act)
self.task.performAction(chosen)
reward = self.task.getReward()
obss.append(obs)
y = zeros(len(act))
y[chosen] = 1
acts.append(y)
rewards.append(reward)
avgReward += sum(rewards) / float(len(rewards))
# compute the returns from the list of rewards
current = 0
returns = []
for r in reversed(rewards):
current *= self.task.discount
current += r
returns.append(current)
returns.reverse()
for i in range(len(obss)):
self.rawDs.addSample(obss[i], acts[i], returns[i])
self.valueDs.addSample(obss[i], returns[i])
r0s.append(returns[0])
lens.append(len(returns))
r0s = array(r0s)
self.totalSteps += sum(lens)
avgLen = sum(lens) / float(self.batchSize)
avgR0 = mean(r0s)
avgReward /= self.batchSize
if self.verbose:
print '***', round(avgLen, 3), '***', '(avg init exp. return:', round(avgR0, 5), ')',
print 'avg reward', round(avgReward, 5), '(tau:', round(self.tau, 3), ')'
print lens
# storage:
self.rewardAvg.append(avgReward)
self.lengthAvg.append(avgLen)
self.initr0Avg.append(avgR0)
# if self.vnet == None:
# # case 1: no value estimator:
# prepare the dataset for training the acting network
shaped = self.shapingFunction(r0s)
self.updateTau(r0s, shaped)
shaped /= max(shaped)
for i, seq in enumerate(self.rawDs):
self.weightedDs.newSequence()
for sample in seq:
obs, act, dummy = sample
self.weightedDs.addSample(obs, act, shaped[i])
# else:
# # case 2: value estimator:
#
#
# # train the value estimating network
# if self.verbose: print 'Old value error: ', self.vbp.testOnData()
# self.vbp.trainEpochs(self.valueTrainEpochs)
# if self.verbose: print 'New value error: ', self.vbp.testOnData()
#
# # produce the values and analyze
# rminusvs = []
# sizes = []
# for i, seq in enumerate(self.valueDs):
# self.vnet.reset()
# seq = list(seq)
# for sample in seq:
# obs, ret = sample
# val = self.vnet.activate(obs)
# rminusvs.append(ret-val)
# sizes.append(len(seq))
#
# rminusvs = array(rminusvs)
# shapedRminusv = self.shapingFunction(rminusvs)
# # CHECKME: here?
# self.updateTau(rminusvs, shapedRminusv)
# shapedRminusv /= array(sizes)
# shapedRminusv /= max(shapedRminusv)
#
# # prepare the dataset for training the acting network
# rvindex = 0
# for i, seq in enumerate(self.rawDs):
# self.weightedDs.newSequence()
# self.vnet.reset()
# for sample in seq:
# obs, act, ret = sample
# self.weightedDs.addSample(obs, act, shapedRminusv[rvindex])
# rvindex += 1
# train the acting network
tmp1, tmp2 = self.bp.trainUntilConvergence(maxEpochs=self.maxEpochs,
validationProportion=self.validationProportion,
continueEpochs=self.continueEpochs,
verbose=self.verbose)
if self.supervisedPlotting:
from pylab import plot, legend, figure, clf, draw
figure(1)
clf()
plot(tmp1, label='train')
plot(tmp2, label='valid')
legend()
draw()
return avgLen, avgR0
def main(f_samples):
f_reading = open(f_samples, 'r')
global data
data = []
for line in f_reading:
line = line.split()
data.append( (float(line[0]), float(line[-1])) )
#function
data_module = lambda x: map( lambda z: data[z], filter( lambda y: y% 5 == x, xrange(len(data)) ) )
global data1
data1 = [data_module(0), data_module(1), data_module(2), data_module(3), data_module(4)]
global data_transformed
data_transformed = take(data, rate = 60)
global data_transformed_training
data_transformed_training = map( lambda x: data_transformed[x], filter( lambda x: uniform(0, 1) > 0.3, xrange(len(data_transformed)) ))
#Learning process-----------------------------------------------------------------
global net, samples, trainer
net = FeedForwardNetwork()
inLayer = LinearLayer(3)
hiddenLayer0 = SigmoidLayer(1)
hiddenLayer1 = SigmoidLayer(3)
outLayer = LinearLayer(1)
net.addInputModule(inLayer)
# net.addModule(hiddenLayer0)
# net.addModule(hiddenLayer1)
net.addOutputModule(outLayer)
# net.addConnection(FullConnection(inLayer, hiddenLayer0))
net.addConnection(FullConnection(inLayer, outLayer))
# net.addConnection(FullConnection(hiddenLayer0, outLayer))
# net.addConnection(FullConnection(hiddenLayer0, hiddenLayer1))
# net.addConnection(FullConnection(hiddenLayer1, outLayer))
net.sortModules()
print net
##Net with 3 inputs, 8 hidden neurons in a layer and 8 in another, and 1 out.
#net = buildNetwork(3,8,8,1)
##Set with 2 inputs and one output for each sample
samples = SupervisedDataSet(3,1)
for i in data_transformed_training:
samples.addSample(i['past'], i['next'] - i['average'])
trainer = BackpropTrainer(net, samples)
print 'Training'
trainer.trainUntilConvergence(maxEpochs= 10)
#Comparing step-------------------------------------------------------------------
print 'Naive1'
aux = map(lambda y: y['past'], data_transformed)
aux2 = map(lambda y: y['next']-y['average'], data_transformed)
compare_forecast_samples(Forecaster(predict_function = lambda x: aux2[aux.index(x)-1]), data_transformed)
print 'Network'
compare_forecast_samples(Forecaster(predict_function = net.activate), data_transformed)
print "Number of samples %d for training." %len(data_transformed_training)
leg = plt.legend([dot1, dot2], ['0','1'])
ax = plt.gca().add_artist(leg)
plt.show()
"""
elif sys.argv[1] == 'nn':
DS = ClassificationDataSet(165)
training_data = np.array(training_data)
training_target = np.vstack(np.array(training_target))
print len(training_data[0])
#print len(training_target[0])
assert(training_data.shape[0] == training_target.shape[0])
DS.setField('input', training_data)
DS.setField('target', training_target)
tstdata, trndata = DS.splitWithProportion(0.15)
hidden_layer_neurons = (DS.indim+DS.outdim)/2
rnn = buildNetwork(DS.indim,hidden_layer_neurons,DS.outdim,hiddenclass=LSTMLayer,outclass=SigmoidLayer,outputbias=False,recurrent=True)
#print hidden_layer_neurons
# define a training method
trainer = BackpropTrainer(rnn,dataset=trndata, verbose=True)
trainer.trainUntilConvergence(verbose = True, validationProportion = 0.3, maxEpochs = 1000, continueEpochs = 10)
print 'Percent Error on Test dataset: ' , percentError(trainer.testOnClassData(tstdata, verbose=True), tstdata['target'] )
print 'Percent Error on Test dataset: ' , percentError(trainer.testOnClassData(tstdata, verbose=True), tstdata['target'] )
#print 'Percent Error on Training dataset: ' , percentError(trainer.testOnClassData(trndata), trndata['target'] )
else:
print("Current classifier algorithms available: svm, knn, dt, kmeans, nn")
sys.exit(1)
if running_tests:
print "\nMax Accuracy: " + str(max(accuracy_arr))
outData = tuple([outputData])
trainingDataset.addSample(inData, outData)
f_Training.close()
network = buildNetwork (trainingDataset.indim,
12,
trainingDataset.outdim,
bias = True,
hiddenclass = SigmoidLayer,
outclass = SigmoidLayer)
trainer = BackpropTrainer (network, trainingDataset, learningrate = 0.01, momentum = 0.9, verbose = True, weightdecay = 0.0)
training = trainer.trainUntilConvergence(dataset = trainingDataset,
maxEpochs = 25,
continueEpochs = 10,
verbose = True,
validationProportion = 0.2)
training_Time = time.time() - trainingTime
print("Training time: %s seconds" % (training_Time))
f_Testing = open('ISCXTesting.txt', 'r')
f_Output = open('ISCXTesting.dat.out', 'w')
testingTime = time.time()
line = f_Testing.readline()
for line in f_Testing.xreadlines():
allData = line.strip().split(' ')
synergy_dict = read_synergy_data(synergy)
# dump_drug_dict_as_flat(pca_dict, out)
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 train(net, data_set):
trainer = BackpropTrainer(net, data_set, learningrate=0.04, momentum=0.5, verbose=True)
trainer.trainUntilConvergence(dataset=data_set, maxEpochs=5000)
def show_weights(net):
for mod in net.modules:
for conn in net.connections[mod]:
print(conn)
for cc in range(len(conn.params)):
print(conn.whichBuffers(cc), conn.params)
print('\n')
#show_weights(net)
trainer = BackpropTrainer(net,
dataset=train_data,
learningrate=0.01,
momentum=0.1)
trainer.trainUntilConvergence(maxEpochs=1000)
#show_weights(net)
out_test = net.activateOnDataset(test_data).argmax(axis=1)
print("Erro de teste: %f" % percentError(out_test, test_data['target'][:, 0]))
out_val = net.activateOnDataset(val_data).argmax(axis=1)
print("Erro de validadação: %f" %
percentError(out_val, val_data['target'][:, 0]))
print("-------------------------------------------\nTeste:")
print("saída da rede:\t", out_test)
print("correto :\t", test_data['target'][:, 0])
'''
from datetime import datetime, timedelta
trainIn = []
for x in row[:numberOfInputs]:
trainIn.append(x)
trainOut = []
for x in row[numberOfInputs:]:
trainOut.append(x)
d.appendLinked(trainIn, trainOut)
# build a neural network with the second parameter being the number of hidden layers
n = buildNetwork(d.indim, 3, d.outdim, recurrent=True)
# configure the trainer
t = BackpropTrainer(n, learningrate=0.01, momentum=0.99, verbose=True)
# split the data randomly into 75% training - 25% testing
train, test = d.splitWithProportion(0.75)
print "{} - {}".format(len(train), len(test))
# train the data with n number of epochs
t.trainOnDataset(train, 10)
# test the data with the remaining data
t.testOnData(test, verbose=True)
# try the same test but with a different method
net = buildNetwork(d.indim, 3, d.outdim, bias=True, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, d)
trainer.trainUntilConvergence(verbose=True)
[entry['age_id']])
#particionando dataset para treino
train_data, part_data = dataset.splitWithProportion(0.7)
#particao para teste/validacao
test_data, val_data = part_data.splitWithProportion(0.5)
network = buildNetwork(dataset.indim, 4, dataset.outdim)
trainer = BackpropTrainer(network,
dataset=train_data,
learningrate=0.01,
momentum=0.1,
verbose=True)
training_errors, val_errors = trainer.trainUntilConvergence(dataset=train_data)
out = network.activateOnDataset(test_data)
for i in range(len(out)):
print("out: %f, correct: %f" % (out[i], test_data['target'][i]))
'''
while True:
while True:
start = datetime.now()
user_string = "Eu quero fotos do homem-aranha, na minha mesa, agora."
user_input = input("Digite a frase abaixo:\n\n %s \n\nPara sair digite 'exit'." % (user_string))
if user_string == user_input:
tempo_corrido = datetime.now() - start
our_out = network.activate([len(user_string), tempo_corrido.seconds])
print("O output é: %f" % (our_out[0]))
train = pd.read_hdf('../input/train.h5')
train = train[col]
d_mean = train.median(axis=0)
train = []
ds = SupervisedDataSet(len(col), 1)
ds.setField('input', o.train[col].fillna(d_mean))
ds.setField('target', pd.DataFrame(o.train['y']))
nn = buildNetwork(
len(col), 2, 1,
hiddenclass=TanhLayer) #hiddenclass=SigmoidLayer, outclass=LinearLayer
tr = BackpropTrainer(nn,
ds,
learningrate=0.001,
momentum=0.0000001,
verbose=True)
tr.trainUntilConvergence(maxEpochs=5,
continueEpochs=2,
verbose=True,
validationProportion=0.35)
while True:
test = o.features[col].fillna(d_mean)
pred = o.target
pred['y'] = [float(nn.activate(row)) for row in test.values]
o, reward, done, info = env.step(pred)
if done:
print("Info Result: ", info["public_score"])
break
if o.features.timestamp[0] % 100 == 0:
print(reward)
def neuralNetworkRegression(X,Y):
"""
:param X: data consisting of features (excluding class variable)
:param Y: column vector consisting of class variable
:return: models neural network regression with fine-tuning of epochs
"""
print "NEURAL NETWORK REGRESSION"
print "Executing..."
print
# can change to model on the entire dataset but by convention splitting the dataset is a better option
X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(X, Y, test_size = 0.10, random_state = 5)
Y_test = Y_test.reshape(-1,1)
Y_train = Y_train.reshape(-1,1)
RMSEerror = []
train = np.vstack((X_train, X_test)) # append both testing and training into one array
outputTrain = np.vstack((Y_train, Y_test))
outputTrain = outputTrain.reshape( -1, 1 )
inputSize = train.shape[1]
targetSize = outputTrain.shape[1]
ds = SupervisedDataSet(inputSize, targetSize)
ds.setField('input', train)
ds.setField('target', outputTrain)
hiddenSize = 100
epochs = 100 # got after parameter tuning
# neural network training model
net = buildNetwork( inputSize, hiddenSize, targetSize, bias = True )
trainer = BackpropTrainer(net, ds)
# uncomment out to plot epoch vs rmse
# takes time to execute as gets best epoch value
# getting the best value of epochs
"""
print "training for {} epochs...".format( epochs )
for i in range(epochs):
print i
mse = trainer.train()
rmse = mse ** 0.5
RMSEerror.append(rmse)
plt.plot(range(epochs), RMSEerror)
plt.xlabel("Epochs")
plt.ylabel("RMSE")
plt.title("RMSE vs Epochs")
plt.savefig("../Graphs/Network/Question 2c/RMSE vs Epochs.png")
plt.show()
"""
print "Model training in process..."
train_mse, validation_mse = trainer.trainUntilConvergence(verbose = True, validationProportion = 0.15, maxEpochs = epochs, continueEpochs = 10)
p = net.activateOnDataset(ds)
mse = mean_squared_error(outputTrain, p)
rmse = mse ** 0.5
print "Root Mean Squared Error for Best Parameters : " + str(rmse)
import os from pybrain.datasets import ClassificationDataSet from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised import BackpropTrainer from pybrain.structure.modules import SoftmaxLayer classes = ['apple', 'orange', 'peach', 'banana']*10 input = ['ap','or','pea','bana'] data = ClassificationDataSet(len(input), 1, nb_classes=len(classes), class_labels=classes) data._convertToOneOfMany( ) # recommended by PyBrain fnn = buildNetwork( data.indim, 5, data.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=data, momentum=0.99, verbose=True, weightdecay=0.01) trainer.trainUntilConvergence(maxEpochs=80) # stop training and start using my trained network here output = fnn.activate(input) class_index = max(xrange(len(output)), key=output.__getitem__) class_name = classes[class_index] print class_name
iris = datasets.load_iris()
X, y = iris.data, iris.target
dataset = ClassificationDataSet(4, 1, nb_classes=3)
for sample_input, sample_output in zip(X, y):
dataset.addSample(sample_input, sample_output)
# Partitioning data for training
training_data, partitioned_data = dataset.splitWithProportion(0.6)
# Spliting data for testing and validation
testing_data, validation_data, = partitioned_data.splitWithProportion(0.5)
network = buildNetwork(dataset.indim, 2, 2, dataset.outdim)
trainer = BackpropTrainer(network,
dataset=training_data,
learningrate=0.01,
momentum=0.1,
verbose=True)
training_errors, validation_errors = trainer.trainUntilConvergence(
dataset=training_data, maxEpochs=200)
plt.plot(training_errors, 'b', validation_errors, 'r')
plt.legend()
plt.show()
outputs = network.activateOnDataset(testing_data)
for out, target in zip(outputs, testing_data['target']):
print(f"output: {out}, target: {target}")
synergy_dict = read_synergy_data(synergy)
# dump_drug_dict_as_flat(pca_dict, out)
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 train(log_filepath, sensor_idxs, action_idxs, max_laps):
f_log = open(log_filepath, 'rb')
x = []
d = []
l = []
n_lap = 0
last_dist = 0
for i,line in enumerate(f_log):
sys.stdout.write('Processing log line '+str(i+1)+'\r')
sys.stdout.flush()
# if re.match('^LAP\s5.*', line):
# print 'lines: ',len(x)
if re.match('^Received: \(', line):
current_dist = parse_line(line, [distFromStart_idx])[0]
if float(current_dist) - float(last_dist) < -1000:
n_lap += 1
last_dist = current_dist
if n_lap > max_laps:
break
l.append(max(n_lap,1))
x.append(parse_line(line, sensor_idxs))
elif re.match('^Sending: \(', line):
d.append(parse_line(line, action_idxs))
sys.stdout.write('\n')
x = np.array(x, dtype=float)
d = np.array(d, dtype=float)
assert x.shape[0] == d.shape[0], 'X and D have different number of samples!'
n_hidden = 100
ds = SupervisedDataSet(x.shape[1], d.shape[1])
ds.setField('input', x)
ds.setField('target', d)
net = buildNetwork(x.shape[1], n_hidden, d.shape[1], bias=True, outputbias=True, hiddenclass=TanhLayer, outclass=TanhLayer)
trainer = BackpropTrainer(net, ds, learningrate=0.01, verbose=True)
trainer.trainUntilConvergence(validationProportion=0.15, maxEpochs=10, continueEpochs=10)
# trainer.trainOnDataset(ds, 200, verbose=True)
params = net.params
w_in = net.params[:n_hidden*x.shape[1]].reshape((n_hidden,x.shape[1]))
b_in = net.params[n_hidden*x.shape[1]:n_hidden*x.shape[1]+n_hidden]
w_out = net.params[n_hidden*x.shape[1]+n_hidden:n_hidden*x.shape[1]+n_hidden+n_hidden*d.shape[1]].reshape((d.shape[1],n_hidden))
b_out = net.params[n_hidden*x.shape[1]+n_hidden+n_hidden*d.shape[1]:]
for mod in net.modules:
if mod._name == 'out':
continue
params = net.connections[mod][0].params
if mod._name == 'in':
w_in = params.reshape(x.shape[1],n_hidden)
if mod._name == 'hidden0':
w_out = params
if mod._name =='bias':
b_in = params
if mod._name =='outputbias':
b_out = params
for i in range(10):
true_val = d[i]
man_pred = w_out.T.dot(np.tanh(w_in.T.dot(x[i]) + b))
aut_pred = net.activate(x[i])
def trainNetworkBackprop(self, dataset,maxIter):
trainer = BackpropTrainer(self.net, dataset)
print "\tInitialised backpropogation traininer. Now execute until convergence::"
trainer.trainUntilConvergence(verbose=True,maxEpochs=maxIter)
print "\tConvergence achieved."
