def main():
# criando o dataset, onde os dados de entrada no dataset será um vetor de tamanho 2
# e o dado de saída será um escalar
dataset = SupervisedDataSet(2, 1)
criandoDataset(dataset)
# criando a rede neural
# onde terá, respectivamente, a quantidade de entrada na rede
# quantidade de neurônios na camada intermediária
# dimensão de saída da rede
# utilizando uma adaptação da rede ao longo do tempo
network = buildNetwork(dataset.indim, 4, dataset.outdim, bias=True)
# criando o método de treino da rede
# passando a rede
# passando o dataset
# passando a taxa de aprendizado
# aumentando o cálculo que maximiza o treinamento da rede
trainer = BackpropTrainer(network,
dataset,
learningrate=0.01,
momentum=0.99)
# looping que faz o treino da função
for epocas in range(0, 1000):
trainer.train()
# realizando o teste
datasetTeste = SupervisedDataSet(2, 1)
criandoDataset(datasetTeste)
trainer.testOnData(datasetTeste, verbose=True)
def montaRede(dadosEntrada, dadosSaida):
"""
Função na qual def
:param dadosEntrada: parâmetros de entrada na rede neural
:param dadosSaida: parâmetros de saída da rede neural
:return: retorna a rede de treinamento treinada e os dados supervisionados
"""
entradaTreino = np.concatenate(
(dadosEntrada[:35], dadosEntrada[50:85], dadosEntrada[100:135]))
saidaTreino = np.concatenate(
(dadosSaida[:35], dadosSaida[50:85], dadosSaida[100:135]))
entradaTeste = np.concatenate(
(dadosEntrada[35:50], dadosEntrada[85:100], dadosEntrada[135:]))
saidaTeste = np.concatenate(
(dadosSaida[35:50], dadosSaida[85:100], dadosSaida[135:]))
treinaRede(entradaTreino, saidaTreino)
# criando o dataset de treinamento
# serão 4 dados de entrada
# será um dado de saída
treinamento = treinaRede(entradaTreino, saidaTreino)
# rede neural do tamanho do treinamento
# com 2 neurônios na camada intermediária
# com o dado de output sendo o tamanho da rede
# utilizando bias
redeNeural = buildNetwork(treinamento.indim,
2,
treinamento.outdim,
bias=True)
# criando a rede neural treinada
redeNeuralTreinada = BackpropTrainer(redeNeural,
treinamento,
learningrate=0.3,
momentum=0.9)
for epocas in range(0, 10000):
redeNeuralTreinada.train()
teste = SupervisedDataSet(4, 1)
for i in range(len(entradaTeste)):
teste.addSample(entradaTeste[i], saidaTeste[i])
return redeNeuralTreinada, teste
hiddenLayerTwo = SigmoidLayer(4, "two")
outLayer = LinearLayer(1)
inToHiddenOne = FullConnection(inLayer, hiddenLayerOne)
hiddenOneToTwo = FullConnection(hiddenLayerOne, hiddenLayerTwo)
hiddenTwoToOut = FullConnection(hiddenLayerTwo, outLayer)
#wire the layers and connections to a net
net = FeedForwardNetwork()
net.addInputModule(inLayer)
net.addModule(hiddenLayerOne)
net.addModule(hiddenLayerTwo)
net.addOutputModule(outLayer)
net.addConnection(inToHiddenOne)
net.addConnection(hiddenOneToTwo)
net.addConnection(hiddenTwoToOut)
net.sortModules()
print(net)
trainer = BackpropTrainer(net, ds)
for i in range(20):
for j in range(1000):
trainer.train()
printNetResult(i, net)
print(net)
print(inToHiddenOne.params)
print(hiddenOneToTwo.params)
print(hiddenTwoToOut.params)
T = BackpropTrainer(N, D, learningrate=0.1, momentum=0.9)
i = 0
error = []
time_before = time.time()
while i < 50 and T.testOnData(D) > 0.001:
errordata = T.testOnData(D)
if i % 1 == 0:
print i, '\tMSE:', round(errordata, 6), '\tTime:', round(
time.time() - time_before, 6)
#Store the error in a list to plot
error.append(errordata)
T.train()
i += 1
#print 'It took ', time.time()-time_before, ' seconds to train the NN'
#Display the error in a chart
plot(error)
show()
#------------------------------------------------------------------
#Test the NN
#for counter,item in enumerate(train_data):
#print 'Real:', answer[counter], ' NN:', N.activate(item)[0]
#------------------------------------------------------------------------------
#Save the trained network to a pickle
#Train the NN with backpropagation
T = BackpropTrainer(N, D, learningrate = 0.1, momentum = 0.9)
i=0
error = []
time_before = time.time()
while i < 50 and T.testOnData(D) > 0.001:
errordata = T.testOnData(D)
if i % 1 == 0:
print i, '\tMSE:', round(errordata,6), '\tTime:', round(time.time()-time_before,6)
#Store the error in a list to plot
error.append(errordata)
T.train()
i += 1
#print 'It took ', time.time()-time_before, ' seconds to train the NN'
#Display the error in a chart
plot(error)
show()
#------------------------------------------------------------------
#Test the NN
#for counter,item in enumerate(train_data):
#print 'Real:', answer[counter], ' NN:', N.activate(item)[0]
class NeuralNetwork(object):
"""
The neural network class does all the heavy lifting to incorporate pybrain
neural networks into the NowTrade ecosystem.
"""
def __init__(self,
train_data,
prediction_data,
network_type=FEED_FORWARD_NETWORK,
network_dataset_type=SUPERVISED_DATASET,
trainer_type=BACKPROP_TRAINER):
self.train_data = train_data
self.prediction_data = prediction_data
self.network_type = network_type
self.network_dataset_type = network_dataset_type
self.trainer_type = trainer_type
self.network = None
self.network_dataset = None
self.dataset = None
self.trainer = None
self.trained_iterations = 0
self.momentum = None
self.learning_rate = None
self.hidden_layers = None
self.prediction_window = None
self.logger = logger.Logger(self.__class__.__name__)
self.logger.info('train_data: %s prediction_data: %s, network_type: %s, \
network_dataset_type: %s, trainer_type: %s'
%(train_data, prediction_data, network_type, \
network_dataset_type, trainer_type))
def save(self):
"""
Returns the pickled trained/tested neural network as a string.
"""
return cPickle.dumps(self)
def save_to_file(self, filename):
"""
Saves a neural network to file for later use.
Look into pybrain.datasets.supervised.SupervisedDataSet.saveToFile()
http://pybrain.org/docs/api/datasets/superviseddataset.html
"""
file_handler = open(filename, 'wb')
cPickle.dump(self, file_handler)
file_handler.close()
def build_network(self, dataset, new=True, **kwargs):
"""
Builds a neural network using the dataset provided.
Expected keyword args:
- 'hidden_layers'
- 'prediction_window'
- 'learning_rate'
- 'momentum'
"""
self.hidden_layers = kwargs.get('hidden_layers', 3)
self.prediction_window = kwargs.get('prediction_window', 1)
self.learning_rate = kwargs.get('learning_rate', 0.1)
self.momentum = kwargs.get('momentum', 0.01)
if not new:
self.network.sorted = False
self.network.sortModules()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else:
raise InvalidNetworkDatasetType()
else:
if self.network_type == FEED_FORWARD_NETWORK:
self.network = buildNetwork(len(self.train_data),
self.hidden_layers, 1)
else:
raise InvalidNetworkType()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else:
raise InvalidNetworkDatasetType()
if self.trainer_type == BACKPROP_TRAINER:
self.trainer = BackpropTrainer(self.network,
learningrate=self.learning_rate,
momentum=self.momentum,
verbose=True)
self.trainer.setData(self.network_dataset)
else:
raise InvalidTrainerType()
def ready_supervised_dataset(self, dataset):
"""
Ready the supervised dataset for training.
@TODO: Need to randomize the data being fed to the network.
See randomBatches() here: http://pybrain.org/docs/api/datasets/superviseddataset.html
"""
self.network_dataset = SupervisedDataSet(len(self.train_data), 1)
# Currently only supports log function for normalizing data
training_values = np.log(dataset.data_frame[self.train_data])
results = np.log(dataset.data_frame[self.prediction_data].shift(
-self.prediction_window))
training_values['PREDICTION_%s' % self.prediction_data[0]] = results
training_values = training_values.dropna()
for _, row_data in enumerate(training_values.iterrows()):
_, data = row_data
sample = list(data[:-1])
result = [data[-1]]
self.network_dataset.addSample(sample, result)
def train(self, cycles=1):
"""
Trains the network the number of iteration specified in the cycles parameter.
"""
for _ in range(cycles):
res = self.trainer.train()
self.trained_iterations += 1
return res
def train_until_convergence(self,
max_cycles=1000,
continue_cycles=10,
validation_proportion=0.25):
"""
Wrapper around the pybrain BackpropTrainer trainUntilConvergence method.
@see: http://pybrain.org/docs/api/supervised/trainers.html
"""
self.trainer = \
self.trainer.trainUntilConvergence(maxEpochs=max_cycles,
continueEpochs=continue_cycles,
validationProportion=validation_proportion)
def _activate(self, data):
"""
Activates the network using the data specified.
Returns the network's prediction.
"""
return self.network.activate(data)[0]
def activate_all(self, data_frame):
"""
Activates the network for all values in the dataframe specified.
"""
dataframe = np.log(data_frame[self.train_data])
res = []
for _, row_data in enumerate(dataframe.iterrows()):
_, data = row_data
sample = list(data)
res.append(self._activate(sample))
return np.exp(res)
class StrategyANN(Strategy):
def __init__(self, features_num, hidden_neurons_num):
super().__init__()
self.is_learning = True
self.features_num = features_num
# self.net = buildNetwork(features_num, hidden_neurons_num, 1, bias = True)
# self.net = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
# self.net = ConvolutionalBoardNetwork(Board.BOARD_SIZE, 5, 3)
# self.trainer = BackpropTrainer(self.net)
self.net_attack = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
self.net_defence = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
self.trainer_attack = BackpropTrainer(self.net_attack)
self.trainer_defence = BackpropTrainer(self.net_defence)
self.gamma = 0.9
self.errors = []
self.buf = np.zeros(200)
self.buf_index = 0
self.setup()
def update_at_end(self, old, new):
if not self.needs_update():
return
if new.winner == Board.STONE_EMPTY:
reward = 0
else:
reward = 2 if self.stand_for == new.winner else -2
if old is None:
if self.prev_state is not None:
self._update_impl(self.prev_state, new, reward)
else:
self._update_impl(old, new, reward)
def update(self, old, new):
if not self.needs_update():
return
if self.prev_state is None:
self.prev_state = old
return
if new is None:
self._update_impl(self.prev_state, old, 0)
self.prev_state = old
def _update_impl(self, old, new, reward):
old_input = self.get_input_values(old)
v1_a = self.net_attack.activate(self.get_input_values(new))
target = self.gamma * v1_a
ds_a = SupervisedDataSet(self.features_num, 1)
ds_a.addSample(old_input, target + max(0, reward))
ds_d = SupervisedDataSet(self.features_num, 1)
ds_d.addSample(old_input, target + min(0, reward))
# self.trainer.setData(ds)
# err = self.trainer.train()
self.trainer_attack.setData(ds_a)
self.trainer_attack.train()
self.trainer_defence.setData(ds_d)
self.trainer_defence.train()
# self.buf[self.buf_index] = err
# self.buf_index += 1
# if self.buf_index >= self.buf.size:
# if len(self.errors) < 2000:
# self.errors.append(np.average(self.buf))
# self.buf.fill(0)
# self.buf_index = 0
def board_value(self, board, context):
iv = self.get_input_values(board)
# return self.net.activate(iv)
return self.net_attack.activate(iv), self.net_defence.activate(iv)
def _decide_move(self, moves):
best_move_a, best_av = None, None
best_move_d, best_dv = None, None
for m in moves:
iv = self.get_input_values(m)
av, dv = self.net_attack.activate(iv), self.net_defence.activate(iv)
if best_av is None or best_av < av:
best_move_a, best_av = m, av
if best_dv is None or best_dv < dv:
best_move_d, best_dv = m, dv
return best_move_a if best_av >= best_dv else best_move_d
def preferred_board(self, old, moves, context):
if not moves:
return old
if len(moves) == 1:
return moves[0]
if np.random.rand() < self.epsilon: # exploration
the_board = random.choice(moves)
the_board.exploration = True
return the_board
else:
# board_most_value = max(moves, key=lambda m: self.board_value(m, context))
# return board_most_value
return self._decide_move(moves)
def get_input_values(self, board):
'''
Returns:
-----------
vector: numpy.1darray
the input vector
'''
# print('boar.stone shape: ' + str(board.stones.shape))
v = board.stones
# print('vectorized board shape: ' + str(v.shape))
# print('b[%d], w[%d]' % (black, white))
iv = np.zeros(v.shape[0] * 2 + 2)
iv[0:v.shape[0]] = (v == Board.STONE_BLACK).astype(int)
iv[v.shape[0]:v.shape[0] * 2] = (v == Board.STONE_WHITE).astype(int)
who = board.whose_turn_now()
iv[-2] = 1 if who == Board.STONE_BLACK else 0 # turn to black move
iv[-1] = 1 if who == Board.STONE_WHITE else 0 # turn to white move
# print(iv.shape)
# print(iv)
return iv
def save(self, file):
pass
def load(self, file):
pass
def setup(self):
self.prev_state = None
def mind_clone(self):
pass
def train(self, x_data, y_data):
trainer = BackpropTrainer(self.net, self._prepare_dataset(x_data, y_data))
trainer.train()
class StrategyANN(Strategy):
def __init__(self, features_num, hidden_neurons_num):
super().__init__()
self.is_learning = True
self.features_num = features_num
# self.net = buildNetwork(features_num, hidden_neurons_num, 1, bias = True)
# self.net = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
# self.net = ConvolutionalBoardNetwork(Board.BOARD_SIZE, 5, 3)
# self.trainer = BackpropTrainer(self.net)
self.net_attack = buildNetwork(features_num,
hidden_neurons_num,
hidden_neurons_num,
1,
bias=True)
self.net_defence = buildNetwork(features_num,
hidden_neurons_num,
hidden_neurons_num,
1,
bias=True)
self.trainer_attack = BackpropTrainer(self.net_attack)
self.trainer_defence = BackpropTrainer(self.net_defence)
self.gamma = 0.9
self.errors = []
self.buf = np.zeros(200)
self.buf_index = 0
self.setup()
def update_at_end(self, old, new):
if not self.needs_update():
return
if new.winner == Board.STONE_EMPTY:
reward = 0
else:
reward = 2 if self.stand_for == new.winner else -2
if old is None:
if self.prev_state is not None:
self._update_impl(self.prev_state, new, reward)
else:
self._update_impl(old, new, reward)
def update(self, old, new):
if not self.needs_update():
return
if self.prev_state is None:
self.prev_state = old
return
if new is None:
self._update_impl(self.prev_state, old, 0)
self.prev_state = old
def _update_impl(self, old, new, reward):
old_input = self.get_input_values(old)
v1_a = self.net_attack.activate(self.get_input_values(new))
target = self.gamma * v1_a
ds_a = SupervisedDataSet(self.features_num, 1)
ds_a.addSample(old_input, target + max(0, reward))
ds_d = SupervisedDataSet(self.features_num, 1)
ds_d.addSample(old_input, target + min(0, reward))
# self.trainer.setData(ds)
# err = self.trainer.train()
self.trainer_attack.setData(ds_a)
self.trainer_attack.train()
self.trainer_defence.setData(ds_d)
self.trainer_defence.train()
# self.buf[self.buf_index] = err
# self.buf_index += 1
# if self.buf_index >= self.buf.size:
# if len(self.errors) < 2000:
# self.errors.append(np.average(self.buf))
# self.buf.fill(0)
# self.buf_index = 0
def board_value(self, board, context):
iv = self.get_input_values(board)
# return self.net.activate(iv)
return self.net_attack.activate(iv), self.net_defence.activate(iv)
def _decide_move(self, moves):
best_move_a, best_av = None, None
best_move_d, best_dv = None, None
for m in moves:
iv = self.get_input_values(m)
av, dv = self.net_attack.activate(iv), self.net_defence.activate(
iv)
if best_av is None or best_av < av:
best_move_a, best_av = m, av
if best_dv is None or best_dv < dv:
best_move_d, best_dv = m, dv
return best_move_a if best_av >= best_dv else best_move_d
def preferred_board(self, old, moves, context):
if not moves:
return old
if len(moves) == 1:
return moves[0]
if np.random.rand() < self.epsilon: # exploration
the_board = random.choice(moves)
the_board.exploration = True
return the_board
else:
# board_most_value = max(moves, key=lambda m: self.board_value(m, context))
# return board_most_value
return self._decide_move(moves)
def get_input_values(self, board):
'''
Returns:
-----------
vector: numpy.1darray
the input vector
'''
# print('boar.stone shape: ' + str(board.stones.shape))
v = board.stones
# print('vectorized board shape: ' + str(v.shape))
# print('b[%d], w[%d]' % (black, white))
iv = np.zeros(v.shape[0] * 2 + 2)
iv[0:v.shape[0]] = (v == Board.STONE_BLACK).astype(int)
iv[v.shape[0]:v.shape[0] * 2] = (v == Board.STONE_WHITE).astype(int)
who = board.whose_turn_now()
iv[-2] = 1 if who == Board.STONE_BLACK else 0 # turn to black move
iv[-1] = 1 if who == Board.STONE_WHITE else 0 # turn to white move
# print(iv.shape)
# print(iv)
return iv
def save(self, file):
pass
def load(self, file):
pass
def setup(self):
self.prev_state = None
def mind_clone(self):
pass
print_net()
print("TRAINING")
def squashIrisSpecies(species):
return 1/float(species) - 0.167
dataset = SupervisedDataSet(4, 3)
for datum in IRIS_TRAIN_SET:
species = datum[-1]
if species == 1:
ideals = [1,0,0]
elif species == 2:
ideals = [0,1,0]
elif species == 3:
ideals = [0,0,1]
dataset.addSample(datum[:-1], ideals)
trainer = BackpropTrainer(net, dataset=dataset, learningrate=0.01, verbose=True)
for i in range(1000):
error = trainer.train()
if i % 20 == 0:
print("Iteration {0} error {1}".format(i, error))
print("POST TRAINING")
print_net()
for test in IRIS_TEST_SET:
inputs = test[:-1]
species = test[-1]
print(test, net.activate(inputs))
from pybrain.datasets.supervised import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure.modules.tanhlayer import TanhLayer
from pybrain.supervised.trainers.backprop import BackpropTrainer
from pybrain.supervised.trainers.mixturedensity import BackpropTrainerMix
def printNetResult(identifier, net):
print(identifier, net.activate((0, 0)), net.activate((0, 1)), net.activate((1, 0)), net.activate((1, 1)))
ds = SupervisedDataSet(2,1)
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
for input, target in ds:
print(input, target)
#net = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)#1000
# net = buildNetwork(2, 6, 1, bias=True) # 3000
net = buildNetwork(2, 3, 1, bias=True)
trainer = BackpropTrainer(net, ds)
for i in range(20):
for j in range(1000):
trainer.train()
printNetResult(i, net)
out = [r[i]]
ds.appendLinked(inl, out)
#trainer = RPropMinusTrainer(n, dataset = ds)
trainer = BackpropTrainer(n, dataset = ds)
print("Generating dataset took", time()-start)
lastlen = 0
start = time()
try:
while True:
epochstart = time()
error = trainer.train()
tpe = time()-epochstart
epochs += 1
out = str(error) + " error " + str(epochs) + " epochs " + str(tpe) + " time per epoch"
clearspaces = " "*(lastlen-len(out))
lastlen = len(out)
if epochs%100 == 0:
thisrun = time()-start
totaltime += thisrun
start = time()
try:
NetworkWriter.writeToFile(n, 'net.xml')
pickle.dump({"epochs":epochs, "time":totaltime}, open( "stats.p", "wb" ) )
print("Autosaved network and stats after 100 epochs and ",thisrun,"seconds. Total time",round(totaltime/36)/100, "hours")
except:
print("Error autosaving network")
from pybrain.structure.networks.feedforward import FeedForwardNetwork
from pybrain.supervised.trainers.backprop import BackpropTrainer
network = FeedForwardNetwork() # create network
inputLayer = SigmoidLayer(1) # maybe LinearLayer ?
hiddenLayer = SigmoidLayer(4)
outputLayer = SigmoidLayer(1) # maybe LinearLayer ?
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)
# Connection
network.addConnection(FullConnection(inputLayer, hiddenLayer))
network.addConnection(FullConnection(hiddenLayer, outputLayer))
network.sortModules()
dataTrain = SupervisedDataSet(1, 1) # input, target
dataTrain.addSample(
1, 0.76
) # it seems to me that input(our x), target(value y) from function sin(x)*sin(2*x)
trainer = BackpropTrainer(
network, dataTrain) # it's back prop, we use our network and our data
print(trainer.train()) # i think it's value trained
print(network.params) # i think that are wights
# print(network)
# print(network.activate([-1]))
class NeuralNetwork(object):
"""
The neural network class does all the heavy lifting to incorporate pybrain
neural networks into the NowTrade ecosystem.
"""
def __init__(self, train_data, prediction_data, network_type=FEED_FORWARD_NETWORK,
network_dataset_type=SUPERVISED_DATASET,
trainer_type=BACKPROP_TRAINER):
self.train_data = train_data
self.prediction_data = prediction_data
self.network_type = network_type
self.network_dataset_type = network_dataset_type
self.trainer_type = trainer_type
self.network = None
self.network_dataset = None
self.dataset = None
self.trainer = None
self.trained_iterations = 0
self.momentum = None
self.learning_rate = None
self.hidden_layers = None
self.prediction_window = None
self.logger = logger.Logger(self.__class__.__name__)
self.logger.info('train_data: %s prediction_data: %s, network_type: %s, \
network_dataset_type: %s, trainer_type: %s'
%(train_data, prediction_data, network_type, \
network_dataset_type, trainer_type))
def save(self):
"""
Returns the pickled trained/tested neural network as a string.
"""
return cPickle.dumps(self)
def save_to_file(self, filename):
"""
Saves a neural network to file for later use.
Look into pybrain.datasets.supervised.SupervisedDataSet.saveToFile()
http://pybrain.org/docs/api/datasets/superviseddataset.html
"""
file_handler = open(filename, 'wb')
cPickle.dump(self, file_handler)
file_handler.close()
def build_network(self, dataset, new=True, **kwargs):
"""
Builds a neural network using the dataset provided.
Expected keyword args:
- 'hidden_layers'
- 'prediction_window'
- 'learning_rate'
- 'momentum'
"""
self.hidden_layers = kwargs.get('hidden_layers', 3)
self.prediction_window = kwargs.get('prediction_window', 1)
self.learning_rate = kwargs.get('learning_rate', 0.1)
self.momentum = kwargs.get('momentum', 0.01)
if not new:
self.network.sorted = False
self.network.sortModules()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else: raise InvalidNetworkDatasetType()
else:
if self.network_type == FEED_FORWARD_NETWORK:
self.network = buildNetwork(len(self.train_data), self.hidden_layers, 1)
else: raise InvalidNetworkType()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else: raise InvalidNetworkDatasetType()
if self.trainer_type == BACKPROP_TRAINER:
self.trainer = BackpropTrainer(self.network,
learningrate=self.learning_rate,
momentum=self.momentum,
verbose=True)
self.trainer.setData(self.network_dataset)
else: raise InvalidTrainerType()
def ready_supervised_dataset(self, dataset):
"""
Ready the supervised dataset for training.
@TODO: Need to randomize the data being fed to the network.
See randomBatches() here: http://pybrain.org/docs/api/datasets/superviseddataset.html
"""
self.network_dataset = SupervisedDataSet(len(self.train_data), 1)
# Currently only supports log function for normalizing data
training_values = np.log(dataset.data_frame[self.train_data])
results = np.log(dataset.data_frame[self.prediction_data].shift(-self.prediction_window))
training_values['PREDICTION_%s' %self.prediction_data[0]] = results
training_values = training_values.dropna()
for _, row_data in enumerate(training_values.iterrows()):
_, data = row_data
sample = list(data[:-1])
result = [data[-1]]
self.network_dataset.addSample(sample, result)
def train(self, cycles=1):
"""
Trains the network the number of iteration specified in the cycles parameter.
"""
for _ in range(cycles):
res = self.trainer.train()
self.trained_iterations += 1
return res
def train_until_convergence(self, max_cycles=1000, continue_cycles=10,
validation_proportion=0.25):
"""
Wrapper around the pybrain BackpropTrainer trainUntilConvergence method.
@see: http://pybrain.org/docs/api/supervised/trainers.html
"""
self.trainer = \
self.trainer.trainUntilConvergence(maxEpochs=max_cycles,
continueEpochs=continue_cycles,
validationProportion=validation_proportion)
def _activate(self, data):
"""
Activates the network using the data specified.
Returns the network's prediction.
"""
return self.network.activate(data)[0]
def activate_all(self, data_frame):
"""
Activates the network for all values in the dataframe specified.
"""
dataframe = np.log(data_frame[self.train_data])
res = []
for _, row_data in enumerate(dataframe.iterrows()):
_, data = row_data
sample = list(data)
res.append(self._activate(sample))
return np.exp(res)