def main(): generated_data = [0 for i in range(10000)] rate, data = get_data_from_wav("../../data/natabhairavi_violin.wav") data = data[1000:190000] print("Got wav") ds = SequentialDataSet(1, 1) for sample, next_sample in zip(data, cycle(data[1:])): ds.addSample(sample, next_sample) net = buildNetwork(1, 5, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] # save errors for plotting later EPOCHS_PER_CYCLE = 5 CYCLES = 10 EPOCHS = EPOCHS_PER_CYCLE * CYCLES for i in xrange(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i+1) * EPOCHS_PER_CYCLE print("\r epoch {}/{}".format(epoch, EPOCHS), end="") stdout.flush() # predict new values old_sample = [100] for i in xrange(500000): new_sample = net.activate(old_sample) old_sample = new_sample generated_data[i] = new_sample[0] print(new_sample) wavfile.write("../../output/test.wav", rate, np.array(generated_data))
def getPyBrainDataSet(sequence, nTrain, predictionStep=1, useTimeOfDay=True, useDayOfWeek=True): print "generate a pybrain dataset of sequences" print "the training data contains ", str(nTrain - predictionStep), "records" inDim = 1 + int(useTimeOfDay) + int(useDayOfWeek) ds = SequentialDataSet(inDim, 1) if useTimeOfDay: print "include time of day as input field" if useDayOfWeek: print "include day of week as input field" for i in xrange(nTrain - predictionStep): if useTimeOfDay and useDayOfWeek: sample = np.array([ sequence['data'][i], sequence['timeofday'][i], sequence['dayofweek'][i] ]) elif useTimeOfDay: sample = np.array([sequence['data'][i], sequence['timeofday'][i]]) elif useDayOfWeek: sample = np.array([sequence['data'][i], sequence['dayofweek'][i]]) else: sample = np.array([sequence['data'][i]]) ds.addSample(sample, sequence['data'][i + predictionStep]) return ds
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 visulizeDataSet(network, data, seqno, in_labels, out_labels): seq = data.getSequence(seqno) tmpDs = SequentialDataSet(data.indim, data.outdim) tmpDs.newSequence() for i in xrange(data.getSequenceLength(seqno)): tmpDs.addSample(seq[0][i], seq[1][i]) nplots = len(in_labels) + len(out_labels) for i in range(len(in_labels)): p = PL.subplot(nplots, 1, i + 1) p.clear() p.plot(tmpDs['input'][:, i]) p.set_ylabel(in_labels[i]) for i in range(len(out_labels)): p = PL.subplot(nplots, 1, i + 1 + len(in_labels)) p.clear() output = ModuleValidator.calculateModuleOutput(network, tmpDs) p.plot(tmpDs['target'][:, i], label='train') p.plot(output[:, i], label='sim') p.legend() p.set_ylabel(out_labels[i])
def seqDataSetPair(data, in_labels, out_labels, seq_title, tseqs, vseqs): tds = SequentialDataSet(len(in_labels), len(out_labels)) vds = SequentialDataSet(len(in_labels), len(out_labels)) ds = None for i in xrange(len(data[in_labels[0]])): if i == 0 or data[seq_title][i] != data[seq_title][i - 1]: if int(data[seq_title][i]) in tseqs: ds = tds ds.newSequence() elif int(data[seq_title][i]) in vseqs: ds = vds ds.newSequence() else: ds = None if ds == None: continue din = [data[l][i] for l in in_labels] dout = [data[l][i] for l in out_labels] ds.addSample(din, dout) return (tds, vds)
def train(self, params): n = params['encoding_num'] net = buildNetwork(n, params['num_cells'], n, hiddenclass=LSTMLayer, bias=True, outputbias=params['output_bias'], recurrent=True) net.reset() ds = SequentialDataSet(n, n) trainer = RPropMinusTrainer(net, dataset=ds) history = self.window(self.history, params) resets = self.window(self.resets, params) for i in xrange(1, len(history)): if not resets[i-1]: ds.addSample(self.encoder.encode(history[i-1]), self.encoder.encode(history[i])) if resets[i]: ds.newSequence() if len(history) > 1: trainer.trainEpochs(params['num_epochs']) net.reset() for i in xrange(len(history) - 1): symbol = history[i] output = self.net.activate(self.encoder.encode(symbol)) predictions = self.encoder.classify(output, num=params['num_predictions']) if resets[i]: net.reset() return net
def train(self, params): """ Train LSTM network on buffered dataset history After training, run LSTM on history[:-1] to get the state correct :param params: :return: """ if params['reset_every_training']: n = params['encoding_num'] self.net = buildNetwork(n, params['num_cells'], n, hiddenclass=LSTMLayer, bias=True, outputbias=params['output_bias'], recurrent=True) self.net.reset() # prepare training dataset ds = SequentialDataSet(params['encoding_num'], params['encoding_num']) history = self.window(self.history, params) resets = self.window(self.resets, params) for i in xrange(1, len(history)): if not resets[i - 1]: ds.addSample(self.encoder.encode(history[i - 1]), self.encoder.encode(history[i])) if resets[i]: ds.newSequence() print "Train LSTM network on buffered dataset of length ", len(history) if params['num_epochs'] > 1: trainer = RPropMinusTrainer(self.net, dataset=ds, verbose=params['verbosity'] > 0) if len(history) > 1: trainer.trainEpochs(params['num_epochs']) # run network on buffered dataset after training to get the state right self.net.reset() for i in xrange(len(history) - 1): symbol = history[i] output = self.net.activate(self.encoder.encode(symbol)) self.encoder.classify(output, num=params['num_predictions']) if resets[i]: self.net.reset() else: self.trainer.setData(ds) self.trainer.train() # run network on buffered dataset after training to get the state right self.net.reset() for i in xrange(len(history) - 1): symbol = history[i] output = self.net.activate(self.encoder.encode(symbol)) self.encoder.classify(output, num=params['num_predictions']) if resets[i]: self.net.reset()
def create_data(self, inputs, targets): data = SequentialDataSet(inputs, targets) for i in xrange(0, len(self.dataframe) - 1): data.newSequence() ins = self.dataframe.ix[i].values target = self.dataframe.ix[i + 1].values[0] data.appendLinked(ins, target) self.data = data
def rnn_dataset(self, X, y): # Create an empty dataset. ds = SequentialDataSet(len(X.columns), len(y.columns)) # And add all rows... for i in range(0, len(X.index)): ds.addSample(tuple(X.ix[i, :].values), tuple(y.ix[i, :].values)) return ds
def rnn_dataset(X, y): """ Create a recurrent neural network dataset according to the pybrain specification and return this new format. """ # Create an empty dataset ds = SequentialDataSet(len(X.columns), len(y.columns)) # And add all rows for i in range(0, len(X.index)): ds.addSample(tuple(X.iloc[i, :].values), tuple(y.iloc[i, :].values)) return ds
def train(self, params, verbose=False): if params['reset_every_training']: if verbose: print 'create lstm network' random.seed(6) if params['output_encoding'] == None: self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput, hiddenclass=LSTMLayer, bias=True, outputbias=True, recurrent=True) elif params['output_encoding'] == 'likelihood': self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput, hiddenclass=LSTMLayer, bias=True, outclass=SigmoidLayer, recurrent=True) self.net.reset() ds = SequentialDataSet(self.nDimInput, self.nDimOutput) networkInput = self.window(self.networkInput, params) targetPrediction = self.window(self.targetPrediction, params) # prepare a training data-set using the history for i in xrange(len(networkInput)): ds.addSample(self.inputEncoder.encode(networkInput[i]), self.outputEncoder.encode(targetPrediction[i])) mycount = 0 if params['num_epochs'] > 1: trainer = RPropMinusTrainer(self.net, dataset=ds, verbose=verbose) if verbose: print " train LSTM on ", len( ds), " records for ", params['num_epochs'], " epochs " if len(networkInput) > 1: trainer.trainEpochs(params['num_epochs']) else: self.trainer.setData(ds) self.trainer.train() # run through the training dataset to get the lstm network state right self.net.reset() for i in xrange(len(networkInput)): self.net.activate(ds.getSample(i)[0])
def ltsmXY(tin, tout, title='ltsm.png'): #datain = zip(tin[:-3], tin[1:-2], tin[2:-1]) #datain = zip(tin[:-8], tin[1:-7], tin[2:-6], tin[3:-5], tin[4:-4], tin[5:-3],tin[6:-2], tin[7:-1]) #datain = zip(tin[:-12], tin[1:-11], tin[2:-10], tin[3:-9], tin[4:-8], tin[5:-7],tin[6:-6], tin[7:-5], tin[8:-4], tin[9:-3], tin[10:-2], tin[11:-1]) datain = zip(tin[:-16], tin[1:-15], tin[2:-14], tin[3:-13], tin[4:-12], tin[5:-11],tin[6:-10], tin[7:-9], tin[8:-8], tin[9:-7], tin[10:-6], tin[11:-5], tin[12:-4], tin[13:-3], tin[14:-2], tin[15:-1]) #dataout = tout[3:] #dataout = tout[8:] #dataout = tout[12:] dataout = tout[16:] #ds = SequentialDataSet(3, 1) #ds = SequentialDataSet(8, 1) #ds = SequentialDataSet(12, 1) ds = SequentialDataSet(16, 1) for x, y in zip(datain[:len(datain)/2], dataout[:len(datain)/2]): ds.addSample(x, y) # add layers until overfitting the training data #net = buildNetwork(3,5,1,hiddenclass=LSTMLayer, outputbias=False, recurrent=True) #net = buildNetwork(8, 8, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) #net = buildNetwork(12, 20, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) net = buildNetwork(16, 20, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] EPOCHS_PER_CYCLE = 5 CYCLES = 100 EPOCHS = EPOCHS_PER_CYCLE * CYCLES for i in xrange(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i+1) * EPOCHS_PER_CYCLE #print "\r epoch {}/{}".format(epoch, EPOCHS) stdout.flush() print "final error =", train_errors[-1] pred_out = [] for i in range(len(datain)): pred_out.append(net.activate(datain[i])) fig = plt.figure() #tout[16:].plot(ax=ax, title='Occupancy') plt.plot(tout[16:].index, tout[16:], 'y', linewidth=1.5) plt.plot(tout[16:].index, pred_out, 'b+') plt.legend(['Occupancy', 'LTSM']) fig.tight_layout() plt.savefig(title,inches='tight')
def create_train_set (consumption): #create train/test set global active_max ds = SequentialDataSet(1, 1) consumption_data = normalize (consumption) active_max = max(consumption_data[1],active_max) consumption = consumption_data[0] size = len (consumption) for i in range(0, size-1): ds.addSample(consumption[i], consumption[i+1]) return ds
def create_train_set(consumption): #create train/test set global active_max ds = SequentialDataSet(1, 1) consumption_data = normalize(consumption) active_max = max(consumption_data[1], active_max) consumption = consumption_data[0] size = len(consumption) for i in range(0, size - 1): ds.addSample(consumption[i], consumption[i + 1]) return ds
def ltsm(data): from pybrain.datasets import SequentialDataSet from itertools import cycle datain = zip(data[:-6], data[1:-5], data[2:-4], data[3:-3], data[4:-2], data[5:-1]) dataout = data[6:] ds = SequentialDataSet(6, 1) for x, y in zip(datain, dataout): ds.addSample(x, y) from pybrain.tools.shortcuts import buildNetwork from pybrain.structure.modules import LSTMLayer net = buildNetwork(6, 7, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) from pybrain.supervised import RPropMinusTrainer from sys import stdout trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] EPOCHS_PER_CYCLE = 5 CYCLES = 100 EPOCHS = EPOCHS_PER_CYCLE * CYCLES for i in xrange(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i+1) * EPOCHS_PER_CYCLE #print "\r epoch {}/{}".format(epoch, EPOCHS) stdout.flush() print "final error =", train_errors[-1] ''' plt.figure() plt.plot(range(0, EPOCHS, EPOCHS_PER_CYCLE), train_errors) plt.xlabel('epoch') plt.ylabel('error') plt.show() ''' test_error = 0. cnt = 0 for sample, target in ds.getSequenceIterator(0): #print "sample = ", sample #print "predicted next sample = %4.1f" % net.activate(sample) #print "actual next sample = %4.1f" % target test_error += abs(net.activate(sample) - target) cnt += 1 test_error /= cnt print "test (train) error =", test_error
def getPyBrainDataSetScalarEncoder(sequence, nTrain, encoderInput, encoderOutput, predictionStep=1, useTimeOfDay=True, useDayOfWeek=True): """ Use scalar encoder for the data :param sequence: :param nTrain: :param predictionStep: :param useTimeOfDay: :param useDayOfWeek: :return: """ print "generate a pybrain dataset of sequences" print "the training data contains ", str(nTrain - predictionStep), "records" if encoderInput is None: inDim = 1 + int(useTimeOfDay) + int(useDayOfWeek) else: inDim = encoderInput.n + int(useTimeOfDay) + int(useDayOfWeek) if encoderOutput is None: outDim = 1 else: outDim = encoderOutput.n ds = SequentialDataSet(inDim, outDim) if useTimeOfDay: print "include time of day as input field" if useDayOfWeek: print "include day of week as input field" for i in xrange(nTrain - predictionStep): sample = getSingleSample(i, sequence, useTimeOfDay, useDayOfWeek) if encoderOutput is None: dataSDROutput = [sequence['normdata'][i + predictionStep]] else: dataSDROutput = encoderOutput.encode( sequence['data'][i + predictionStep]) ds.addSample(sample, dataSDROutput) return ds
def __init__(self, task, agent): EpisodicExperiment.__init__(self, task, agent) # create model and training set (action dimension + 1 for time) self.modelds = SequentialDataSet(self.task.indim + 1, 1) self.model = [ GaussianProcess(indim=self.modelds.getDimension('input'), start=(-10, -10, 0), stop=(10, 10, 300), step=(5, 5, 100)) for _ in range(self.task.outdim) ] # change hyper parameters for all gps for m in self.model: m.hyper = (20, 2.0, 0.01)
def train(d, cycles=100, epochs_per_cycle=7): ds = SequentialDataSet(1, 1) net = buildNetwork(1, 5, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=False) for sample, next_sample in zip(d, cycle(d[1:])): ds.addSample(sample, next_sample) trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] # save errors for plotting later for i in xrange(cycles): trainer.trainEpochs(epochs_per_cycle) train_errors.append(trainer.testOnData()) stdout.flush() return net, train_errors
def train(context, trainX, trainY): ds = SequentialDataSet(4, 1) for dataX, dataY in zip(trainX, trainY): ds.addSample(dataX, dataY) net = buildNetwork(4, 1, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) trainer = RPropMinusTrainer(net, dataset=ds) EPOCHS_PER_CYCLE = 5 CYCLES = 5 for i in range(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) return net, trainer.testOnData()
def create_train_set(open_price, close_price): global open_max global close_max ds = SequentialDataSet(1, 1) open_data = normalize(open_price) close_data = normalize(close_price) open_max = open_data[1] close_max = close_data[1] open_price = open_data[0] close_price = close_data[0] size = len(open_price) for i in range(0, size): ds.addSample(open_price[i], close_price[i]) return ds
def __init__(self, ds): self.alldata = SequentialDataSet(ds.num_features, 1) # Now add the samples to the data set. idx = 1 self.alldata.newSequence() for sample in ds.all_moves: self.alldata.addSample(sample.get_features(), [ds.get_classes().index(sample.class_)]) idx += 1 if (idx%6 == 0): self.alldata.newSequence() self.tstdata, self.trndata = self.alldata.splitWithProportion(0.25) #print "Number of training patterns: ", len(self.trndata) #print "Input and output dimensions: ", self.trndata.indim, self.trndata.outdim #print "First sample (input, target, class):" #print self.trndata['input'][0], self.trndata['target'][0], self.trndata['class'][0] # 5 hidden layers. self.rnn = buildNetwork(self.trndata.indim, 3, self.trndata.outdim, hiddenclass=LSTMLayer, outclass=SigmoidLayer, recurrent=True) self.rnn.randomize() self.trainer = BackpropTrainer(self.nn, dataset=self.trndata, momentum=0.1, verbose=True, weightdecay=0.01)
def create_train_set (open_price, close_price): global open_max global close_max ds = SequentialDataSet(1, 1) open_data = normalize (open_price) close_data = normalize (close_price) open_max = open_data[1] close_max = close_data[1] open_price = open_data[0] close_price = close_data[0] size = len (open_price) for i in range(0, size): ds.addSample(open_price[i], close_price[i]) return ds
def buildAppropriateDataset(module): """ build a sequential dataset with 2 sequences of 3 samples, with arndom input and target values, but the appropriate dimensions to be used on the provided module. """ if module.sequential: d = SequentialDataSet(module.indim, module.outdim) for dummy in range(2): d.newSequence() for dummy in range(3): d.addSample(randn(module.indim), randn(module.outdim)) else: d = SupervisedDataSet(module.indim, module.outdim) for dummy in range(3): d.addSample(randn(module.indim), randn(module.outdim)) return d
def __init__(self): SequentialDataSet.__init__(self, 1, 1) self.newSequence() self.addSample([-1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.newSequence() self.addSample([1], [1]) self.addSample([1], [-1]) self.newSequence() self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.newSequence() self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([1], [1]) self.addSample([-1], [1]) self.addSample([-1], [1]) self.addSample([-1], [1]) self.addSample([-1], [1]) self.addSample([-1], [1]) self.newSequence() self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([1], [1])
def __init__(self): SequentialDataSet.__init__(self, 1,1) self.newSequence() self.addSample([-1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.newSequence() self.addSample([1], [1]) self.addSample([1], [-1]) self.newSequence() self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([1], [1]) self.addSample([1], [-1]) self.newSequence() self.addSample([1], [1]) self.addSample([1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([1], [1]) self.addSample([-1], [1]) self.addSample([-1], [1]) self.addSample([-1], [1]) self.addSample([-1], [1]) self.addSample([-1], [1]) self.newSequence() self.addSample([-1], [-1]) self.addSample([-1], [-1]) self.addSample([1], [1])
def AddDataSequential(self, data): self.ds = SequentialDataSet(self.inputsize, self.outputsize) for i in xrange(len(data) - 1, 0, -1): t = data[i] k = i - 1 while k > -1: self.ds.appendLinked(data[k], t) k -= 1 self.ds.newSequence() """print self.ds.getNumSequences() for i in range(self.ds.getNumSequences()): for input, target in self.ds.getSequenceIterator(i): print i, TransToIntList_45(input), TransToIntList_45(target)""" self.trainer = RPropMinusTrainer(self.net, dataset=self.ds, learningrate=0.1) return 0
def __init__(self): SequentialDataSet.__init__(self, 0, 1) self.newSequence() self.addSample([], [0]) self.addSample([], [1]) self.addSample([], [0]) self.addSample([], [1]) self.addSample([], [0]) self.addSample([], [1]) self.newSequence() self.addSample([], [0]) self.addSample([], [1]) self.addSample([], [0]) self.addSample([], [1]) self.addSample([], [0]) self.addSample([], [1])
def __init__(self): SequentialDataSet.__init__(self, 0, 1) self.newSequence() self.addSample([],[0]) self.addSample([],[1]) self.addSample([],[0]) self.addSample([],[1]) self.addSample([],[0]) self.addSample([],[1]) self.newSequence() self.addSample([],[0]) self.addSample([],[1]) self.addSample([],[0]) self.addSample([],[1]) self.addSample([],[0]) self.addSample([],[1])
def __init__(self, inp, target, nb_classes=0, class_labels=None): """Initialize an empty dataset. `inp` is used to specify the dimensionality of the input. While the number of targets is given by implicitly by the training samples, it can also be set explicity by `nb_classes`. To give the classes names, supply an iterable of strings as `class_labels`.""" # FIXME: hard to keep nClasses synchronized if appendLinked() etc. is used. SequentialDataSet.__init__(self, inp, target) # we want integer class numbers as targets self.convertField('target', int) if len(self) > 0: # calculate class histogram, if we already have data self.calculateStatistics() self.nClasses = nb_classes self.class_labels = list(range(self.nClasses)) if class_labels is None else class_labels # copy classes (targets may be changed into other representation) self.setField('class', self.getField('target'))
def __init__(self, inp, target, nb_classes=0, class_labels=None): """Initialize an empty dataset. `inp` is used to specify the dimensionality of the input. While the number of targets is given by implicitly by the training samples, it can also be set explicity by `nb_classes`. To give the classes names, supply an iterable of strings as `class_labels`.""" # FIXME: hard to keep nClasses synchronized if appendLinked() etc. is used. SequentialDataSet.__init__(self, inp, target) # we want integer class numbers as targets self.convertField('target', int) if len(self) > 0: # calculate class histogram, if we already have data self.calculateStatistics() self.nClasses = nb_classes self.class_labels = range(self.nClasses) if class_labels is None else class_labels # copy classes (targets may be changed into other representation) self.setField('class', self.getField('target'))
def handle(self, *args, **options): ticker = args[0] print("****** STARTING PREDICTOR " + ticker + " ******* ") prices = Price.objects.filter( symbol=ticker).order_by('-created_on').values_list('price', flat=True) data = normalization(list(prices[0:NUM_MINUTES_BACK].reverse())) data = [int(x * MULT_FACTOR) for x in data] ds = SequentialDataSet(1, 1) for sample, next_sample in zip(data, cycle(data[1:])): ds.addSample(sample, next_sample) net = buildNetwork(1, 5, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] # save errors for plotting later EPOCHS_PER_CYCLE = 5 CYCLES = 100 EPOCHS = EPOCHS_PER_CYCLE * CYCLES for i in xrange(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i + 1) * EPOCHS_PER_CYCLE print("\r epoch {}/{}".format(epoch, EPOCHS), end="") stdout.flush() print() print("final error =", train_errors[-1]) for sample, target in ds.getSequenceIterator(0): show_pred_sample = net.activate(sample) / MULT_FACTOR show_sample = sample / MULT_FACTOR show_target = target / MULT_FACTOR show_diff = show_pred_sample - show_target show_diff_pct = 100 * show_diff / show_pred_sample print("{} => {}, act {}. ({}%)".format( show_sample[0], round(show_pred_sample[0], 3), show_target[0], int(round(show_diff_pct[0], 0))))
def getPyBrainDataSetScalarEncoder(sequence, nTrain, encoderInput, encoderOutput, predictionStep=1, useTimeOfDay=True, useDayOfWeek=True): """ Use scalar encoder for the data :param sequence: :param nTrain: :param predictionStep: :param useTimeOfDay: :param useDayOfWeek: :return: """ print "generate a pybrain dataset of sequences" print "the training data contains ", str(nTrain-predictionStep), "records" if encoderInput is None: inDim = 1 + int(useTimeOfDay) + int(useDayOfWeek) else: inDim = encoderInput.n + int(useTimeOfDay) + int(useDayOfWeek) if encoderOutput is None: outDim = 1 else: outDim = encoderOutput.n ds = SequentialDataSet(inDim, outDim) if useTimeOfDay: print "include time of day as input field" if useDayOfWeek: print "include day of week as input field" for i in xrange(nTrain-predictionStep): sample = getSingleSample(i, sequence, useTimeOfDay, useDayOfWeek) if encoderOutput is None: dataSDROutput = [sequence['normdata'][i+predictionStep]] else: dataSDROutput = encoderOutput.encode(sequence['data'][i+predictionStep]) ds.addSample(sample, dataSDROutput) return ds
def reset(self, params, repetition): print params self.nDimInput = 1 #3 self.inputEncoder = PassThroughEncoder() if params['output_encoding'] == None: self.outputEncoder = PassThroughEncoder() self.nDimOutput = 1 elif params['output_encoding'] == 'likelihood': self.outputEncoder = ScalarBucketEncoder() self.nDimOutput = self.outputEncoder.encoder.n if (params['dataset'] == 'nyc_taxi' or params['dataset'] == 'nyc_taxi_perturb_baseline'): self.dataset = NYCTaxiDataset(params['dataset']) else: raise Exception("Dataset not found") self.testCounter = 0 self.resets = [] self.iteration = 0 # initialize LSTM network random.seed(6) if params['output_encoding'] == None: self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput, hiddenclass=LSTMLayer, bias=True, outputbias=True, recurrent=True) elif params['output_encoding'] == 'likelihood': self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput, hiddenclass=LSTMLayer, bias=True, outclass=SigmoidLayer, recurrent=True) print self.net['out'] print self.net['hidden0'] self.trainer = BackpropTrainer(self.net, dataset=SequentialDataSet( self.nDimInput, self.nDimOutput), learningrate=0.01, momentum=0, verbose=params['verbosity'] > 0) (self.networkInput, self.targetPrediction, self.trueData) = \ self.dataset.generateSequence( prediction_nstep=params['prediction_nstep'], output_encoding=params['output_encoding'], noise=params['noise'])
def train(self, params, verbose=False): if params['reset_every_training']: if verbose: print 'create lstm network' random.seed(6) if params['output_encoding'] == None: self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput, hiddenclass=LSTMLayer, bias=True, outputbias=True, recurrent=True) elif params['output_encoding'] == 'likelihood': self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput, hiddenclass=LSTMLayer, bias=True, outclass=SigmoidLayer, recurrent=True) self.net.reset() ds = SequentialDataSet(self.nDimInput, self.nDimOutput) networkInput = self.window(self.networkInput, params) targetPrediction = self.window(self.targetPrediction, params) # prepare a training data-set using the history for i in xrange(len(networkInput)): ds.addSample(self.inputEncoder.encode(networkInput[i]), self.outputEncoder.encode(targetPrediction[i])) if params['num_epochs'] > 1: trainer = RPropMinusTrainer(self.net, dataset=ds, verbose=verbose) if verbose: print " train LSTM on ", len(ds), " records for ", params['num_epochs'], " epochs " if len(networkInput) > 1: trainer.trainEpochs(params['num_epochs']) else: self.trainer.setData(ds) self.trainer.train() # run through the training dataset to get the lstm network state right self.net.reset() for i in xrange(len(networkInput)): self.net.activate(ds.getSample(i)[0])
def AddData(self, datainput, dataoutput): if len(dataoutput) != len(datainput): print("Not equals data", len(dataoutput), len(datainput)) return 1 self.ds = SupervisedDataSet(self.inputsize, self.outputsize) for i in xrange(len(dataoutput)): self.ds.appendLinked(datainput[i], dataoutput[i]) self.trainer = RPropMinusTrainer(self.net, dataset=self.ds, learningrate=0.1) return 0
def __init__(self, task, agent): EpisodicExperiment.__init__(self, task, agent) # create model and training set (action dimension + 1 for time) self.modelds = SequentialDataSet(self.task.indim + 1, 1) self.model = [GaussianProcess(indim=self.modelds.getDimension('input'), start=(-10, -10, 0), stop=(10, 10, 300), step=(5, 5, 100)) for _ in range(self.task.outdim)] # change hyper parameters for all gps for m in self.model: m.hyper = (20, 2.0, 0.01)
def train(self, params): self.net.reset() ds = SequentialDataSet(self.nDimInput, self.nDimOutput) trainer = RPropMinusTrainer(self.net, dataset=ds, verbose=False) history = self.window(self.history, params) resets = self.window(self.resets, params) for i in xrange(params['prediction_nstep'], len(history)): if not resets[i-1]: ds.addSample(self.inputEncoder.encode(history[i-params['prediction_nstep']]), self.outputEncoder.encode(history[i][0])) if resets[i]: ds.newSequence() # print ds.getSample(0) # print ds.getSample(1) # print ds.getSample(1000) # print " training data size", ds.getLength(), " len(history) ", len(history), " self.history ", len(self.history) # print ds if len(history) > 1: trainer.trainEpochs(params['num_epochs']) self.net.reset() for i in xrange(len(history) - params['prediction_nstep']): symbol = history[i] output = self.net.activate(ds.getSample(i)[0]) if resets[i]: self.net.reset()
def train(self, params): """ Train LSTM network on buffered dataset history After training, run LSTM on history[:-1] to get the state correct :param params: :return: """ if params['reset_every_training']: n = params['encoding_num'] self.net = buildNetwork(n, params['num_cells'], n, hiddenclass=LSTMLayer, bias=True, outputbias=params['output_bias'], recurrent=True) self.net.reset() # prepare training dataset ds = SequentialDataSet(params['encoding_num'], params['encoding_num']) history = self.window(self.history, params) resets = self.window(self.resets, params) for i in xrange(1, len(history)): if not resets[i - 1]: ds.addSample(self.encoder.encode(history[i - 1]), self.encoder.encode(history[i])) if resets[i]: ds.newSequence() if params['num_epochs'] > 1: trainer = RPropMinusTrainer(self.net, dataset=ds, verbose=params['verbosity'] > 0) if len(history) > 1: trainer.trainEpochs(params['num_epochs']) # run network on buffered dataset after training to get the state right self.net.reset() for i in xrange(len(history) - 1): symbol = history[i] output = self.net.activate(self.encoder.encode(symbol)) self.encoder.classify(output, num=params['num_predictions']) if resets[i]: self.net.reset() else: self.trainer.setData(ds) self.trainer.train() # run network on buffered dataset after training to get the state right self.net.reset() for i in xrange(len(history) - 1): symbol = history[i] output = self.net.activate(self.encoder.encode(symbol)) self.encoder.classify(output, num=params['num_predictions']) if resets[i]: self.net.reset()
def reset(self, params, repetition): random.seed(params['seed']) if params['encoding'] == 'basic': self.encoder = BasicEncoder(params['encoding_num']) elif params['encoding'] == 'distributed': self.encoder = DistributedEncoder( params['encoding_num'], maxValue=params['encoding_max'], minValue=params['encoding_min'], classifyWithRandom=params['classify_with_random']) else: raise Exception("Encoder not found") if params['dataset'] == 'simple': self.dataset = SimpleDataset() elif params['dataset'] == 'reber': self.dataset = ReberDataset(maxLength=params['max_length']) elif params['dataset'] == 'high-order': self.dataset = HighOrderDataset( numPredictions=params['num_predictions'], seed=params['seed']) else: raise Exception("Dataset not found") self.computeCounter = 0 self.history = [] self.resets = [] self.randoms = [] self.currentSequence = [] self.targetPrediction = [] self.replenishSequence(params, iteration=0) self.net = buildNetwork(params['encoding_num'], params['num_cells'], params['encoding_num'], hiddenclass=LSTMLayer, bias=True, outputbias=params['output_bias'], recurrent=True) self.trainer = BackpropTrainer(self.net, dataset=SequentialDataSet( params['encoding_num'], params['encoding_num']), learningrate=0.01, momentum=0, verbose=params['verbosity'] > 0) self.sequenceCounter = 0
def trainNetwork(dirname): numFeatures = 5000 ds = SequentialDataSet(numFeatures, 1) tracks = glob.glob(os.path.join(dirname, 'train??.wav')) for t in tracks: track = os.path.splitext(t)[0] # load training data print "Reading %s..." % track data = numpy.genfromtxt(track + '_seg.csv', delimiter=",") labels = numpy.genfromtxt(track + 'REF.txt', delimiter='\t')[0::10,1] numData = data.shape[0] # add the input to the dataset print "Adding to dataset..." ds.newSequence() for i in range(numData): ds.addSample(data[i], (labels[i],)) # initialize the neural network print "Initializing neural network..." net = buildNetwork(numFeatures, 50, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) # train the network on the dataset print "Training neural net" trainer = RPropMinusTrainer(net, dataset=ds) ## trainer.trainUntilConvergence(maxEpochs=50, verbose=True, validationProportion=0.1) error = -1 for i in range(100): new_error = trainer.train() print "error: " + str(new_error) if abs(error - new_error) < 0.1: break error = new_error # save the network print "Saving neural network..." NetworkWriter.writeToFile(net, os.path.basename(dirname) + 'net')
def main(): generated_data = [0 for i in range(10000)] rate, data = get_data_from_wav("../../data/natabhairavi_violin.wav") data = data[1000:190000] print("Got wav") ds = SequentialDataSet(1, 1) for sample, next_sample in zip(data, cycle(data[1:])): ds.addSample(sample, next_sample) net = buildNetwork(1, 5, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] # save errors for plotting later EPOCHS_PER_CYCLE = 5 CYCLES = 10 EPOCHS = EPOCHS_PER_CYCLE * CYCLES for i in xrange(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i + 1) * EPOCHS_PER_CYCLE print("\r epoch {}/{}".format(epoch, EPOCHS), end="") stdout.flush() # predict new values old_sample = [100] for i in xrange(500000): new_sample = net.activate(old_sample) old_sample = new_sample generated_data[i] = new_sample[0] print(new_sample) wavfile.write("../../output/test.wav", rate, np.array(generated_data))
def getReberDS(maxLength, display = 0): """ @param maxLength (int): maximum length of the sequence """ [in_seq, out_seq] = generateSequencesVector(maxLength) target = out_seq last_target = target[-1] last_target[np.argmax(out_seq[-1])] = 1 target[-1] = last_target ds = SequentialDataSet(7, 7) i = 0 for sample, next_sample in zip(in_seq, target): ds.addSample(sample, next_sample) if display: print(" sample: %s" % sample) print(" target: %s" % next_sample) print("next sample: %s" % out_seq[i]) print() i += 1 return (ds, in_seq, out_seq)
def getReberDS(maxLength, display=0): """ @param maxLength (int): maximum length of the sequence """ [in_seq, out_seq] = generateSequencesVector(maxLength) target = out_seq last_target = target[-1] last_target[np.argmax(out_seq[-1])] = 1 target[-1] = last_target ds = SequentialDataSet(7, 7) i = 0 for sample, next_sample in zip(in_seq, target): ds.addSample(sample, next_sample) if display: print(" sample: %s" % sample) print(" target: %s" % next_sample) print("next sample: %s" % out_seq[i]) print() i += 1 return (ds, in_seq, out_seq)
def getPyBrainDataSet(sequence, nTrain, predictionStep=1, useTimeOfDay=True, useDayOfWeek=True): print "generate a pybrain dataset of sequences" print "the training data contains ", str(nTrain-predictionStep), "records" inDim = 1 + int(useTimeOfDay) + int(useDayOfWeek) ds = SequentialDataSet(inDim, 1) if useTimeOfDay: print "include time of day as input field" if useDayOfWeek: print "include day of week as input field" for i in xrange(nTrain-predictionStep): if useTimeOfDay and useDayOfWeek: sample = np.array([sequence['data'][i], sequence['timeofday'][i], sequence['dayofweek'][i]]) elif useTimeOfDay: sample = np.array([sequence['data'][i], sequence['timeofday'][i]]) elif useDayOfWeek: sample = np.array([sequence['data'][i], sequence['dayofweek'][i]]) else: sample = np.array([sequence['data'][i]]) ds.addSample(sample, sequence['data'][i+predictionStep]) return ds
def init_nn(self, datain, dataout): INPUTS = 5 OUTPUTS = 1 HIDDEN = 20 self.net = buildNetwork(INPUTS, HIDDEN, OUTPUTS, hiddenclass=LSTMLayer, outclass=SigmoidLayer, recurrent=True, bias=True) self.ds = SequentialDataSet(INPUTS, OUTPUTS) for x, y in itertools.izip(datain, dataout): self.ds.newSequence() self.ds.appendLinked(tuple(x), tuple(y)) self.net.randomize() trainer = BackpropTrainer(self.net, self.ds) for _ in range(1000): print trainer.train()
def create_data(dataframe, inputs, targets): data = SequentialDataSet(inputs, targets) for i in range(0, dataframe.shape[0] - 1): row = dataframe.iloc[i] data.newSequence() ins = row.values target = dataframe.iloc[i + 1].values[0] data.appendLinked(ins, target) return data
def say_hello_text(username = "******",text="You are good"): object_data_new = pd.read_csv('/Users/ruiyun_zhou/Documents/cmpe-274/data/data.csv') data_area_new = object_data_new[object_data_new.Area==username] data_area_new_1=data_area_new[data_area_new.Disease== text] data_list_new = data_area_new_1['Count'].values.tolist() print data_list_new.__len__() data_list=data_list_new ds = SequentialDataSet(1,1) isZero=0; for sample,next_sample in zip(data_list,cycle(data_list[1:])): ds.addSample(sample, next_sample) if sample: isZero=1 if(isZero==0): return '[0, 0]' net = buildNetwork(1,5,1,hiddenclass=LSTMLayer,outputbias=False,recurrent=True) trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] # save errors for plotting later EPOCHS_PER_CYCLE = 5 CYCLES = 10 EPOCHS = EPOCHS_PER_CYCLE * CYCLES for i in xrange(CYCLES): print "Doing epoch %d" %i trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i+1) * EPOCHS_PER_CYCLE # return '<p>%d</p>\n' % (data_list_new.__len__()) # print("final error =", train_errors[-1]) # print "Value for last week is %4.1d" % abs(data_list[-1]) # print "Value for next week is %4.1d" % abs(net.activate(data_list[-1])) # result = (abs(data_list[-1])) result = (abs(net.activate(data_list[-1]))) result_1 = (abs(net.activate(result))) return '[%d, %d]' % (result,result_1)
def train(data,name): ds = SequentialDataSet(1, 1) for sample, next_sample in zip(data, cycle(data[1:])): ds.addSample(sample, next_sample) net = buildNetwork(1, 200, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] # save errors for plotting later EPOCHS_PER_CYCLE = 5 CYCLES = 20 EPOCHS = EPOCHS_PER_CYCLE * CYCLES store=[] for i in xrange(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i+1) * EPOCHS_PER_CYCLE print("\r epoch {}/{}".format(epoch, EPOCHS)) print tm.time()-atm stdout.flush() for sample, target in ds.getSequenceIterator(0): store.append(net.activate(sample)) abcd=pd.DataFrame(store) abcd.to_csv(pwd+"lstmdata/"+name+".csv",encoding='utf-8') print "result printed to file"
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 __init__(self, inputsize, outputsize, hiden=[1]): self.inputsize = inputsize self.outputsize = outputsize self.hiden = hiden self.err = 1 self.old_err = 1 #print type(self.hiden) if type(self.hiden) == str: #print "type str" self.hiden = self.hiden[1:-1] b = self.hiden.split(", ") c = [] for i in b: c.append(int(i)) self.hiden = c[:] b = [] b.append(self.inputsize) b += self.hiden b.append(self.outputsize) #print b#"%s, %s, %s, hiddenclass=TanhLayer"%(self.inputsize, self.hiden, self.outputsize) self.net = FeedForwardNetwork() self.inputlayer = LinearLayer(self.inputsize, "Input") self.net.addInputModule(self.inputlayer) self.outputlayer = LinearLayer(self.outputsize, "Output") self.net.addOutputModule(self.outputlayer) self.hidenlayers = [] for i in xrange(len(self.hiden)): self.hidenlayers.append(SigmoidLayer(self.hiden[i], "hiden%s" % i)) self.net.addModule(self.hidenlayers[-1]) self.net.addConnection( FullConnection(self.inputlayer, self.outputlayer)) for i in xrange(len(self.hidenlayers)): self.net.addConnection( FullConnection(self.inputlayer, self.hidenlayers[i])) self.net.addConnection( FullConnection(self.hidenlayers[i], self.outputlayer)) for i in xrange(len(self.hidenlayers)): for j in xrange(i + 1, len(self.hidenlayers)): self.net.addConnection( FullConnection(self.hidenlayers[i], self.hidenlayers[j])) #self.print_conections(self.net) self.net.sortModules() self.ds = SupervisedDataSet(self.inputsize, self.outputsize)
def handle(self, *args, **options): ticker = args[0] print("****** STARTING PREDICTOR " + ticker + " ******* ") #prices = Price.objects.filter(symbol=ticker).order_by('-created_on').values_list('price',flat=True) #data = prices[0:NUM_MINUTES_BACK].reverse() #data = [ x * MULT_FACTOR for x in data] from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer from pybrain.datasets import SequentialDataSet from pybrain.structure import SigmoidLayer, LinearLayer from pybrain.structure import LSTMLayer import itertools import numpy as np INPUTS = 5 OUTPUTS = 1 HIDDEN = 40 net = buildNetwork(INPUTS, HIDDEN, OUTPUTS, hiddenclass=LSTMLayer, outclass=LinearLayer, recurrent=True, bias=True) ds = SequentialDataSet(INPUTS, OUTPUTS) ds.addSample([0,1,2,3,4],[5]) ds.addSample([5,6,7,8,9],[10]) ds.addSample([10,11,12,13,14],[15]) ds.addSample([16,17,18,19,20],[21]) net.randomize() trainer = BackpropTrainer(net, ds) for _ in range(1000): trainer.train() x=net.activate([0,1,2,3,4]) print x
print 'Data Converted' # Put time series into a supervised dataset, where the target for # each sample is the next sample from pybrain.datasets import SequentialDataSet from itertools import cycle INPUT = 3 HIDDEN_LAYERS = 5 OUTPUT = 3 ds = SequentialDataSet(INPUT, OUTPUT) # Adding sequence of numbers (of both features) into neural network for (sample, next_sample, sam_v, next_sam_v, sam_t, next_sam_t) in zip(pitch_data, cycle(pitch_data[1:]), velocity_data, cycle(velocity_data[1:]), tick_data, cycle(tick_data[1:])): #ds.addSample((sample, velocity_data[i], tick_data[i]), next_sample) ds.addSample((sample, sam_v, sam_t), (next_sample, next_sam_v, next_sam_t)) # Build a simple LSTM networ end of the song somewhere around last 15 sec when my line pop. stupid friend decide it is a good time to send LL stickerk with 1 input node, 5 LSTM cells and 1 output node: from pybrain.tools.shortcuts import buildNetwork from pybrain.structure.modules import LSTMLayer print 'Constructing neutral network. . .' net = buildNetwork(
def rnn(): # load dataframe from csv file df = pi.load_data_frame('../../data/NABIL.csv') # column name to match with indicator calculating modules # TODO: resolve issue with column name df.columns = [ 'Transactions', 'Traded_Shares', 'Traded_Amount', 'High', 'Low', 'Close'] data = df.Close.values # TODO: write min_max normalization # normalization # cp = dataframe.pop(' Close Price') # x = cp.values temp = np.array(data).reshape(len(data),1) min_max_scaler = preprocessing.MinMaxScaler() data = min_max_scaler.fit_transform(temp) # dataframe[' Close Price'] = x_scaled # prepate sequential dataset for pyBrain rnn network ds = SequentialDataSet(1, 1) for sample, next_sample in zip(data, cycle(data[1:])): ds.addSample(sample, next_sample) # build rnn network with LSTM layer # if saved network is available if(os.path.isfile('random.xml')): net = NetworkReader.readFrom('network.xml') else: net = buildNetwork(1, 20, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) # build trainer trainer = RPropMinusTrainer(net, dataset=ds, verbose = True) train_errors = [] # save errors for plotting later EPOCHS_PER_CYCLE = 5 CYCLES = 5 EPOCHS = EPOCHS_PER_CYCLE * CYCLES for i in range(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i+1) * EPOCHS_PER_CYCLE print("\r epoch {}/{}".format(epoch, EPOCHS), end="") sys.stdout.flush() # save the network NetworkWriter.writeToFile(net,'network.xml') print() print("final error =", train_errors[-1]) predicted = [] for dat in data: predicted.append(net.activate(dat)[0]) # data = min_max_scaler.inverse_transform(data) # predicted = min_max_scaler.inverse_transform(predicted) predicted_array = min_max_scaler.inverse_transform(np.array(predicted).reshape(-1,1)) print(predicted_array[-1]) plt.figure() legend_actual, = plt.plot(range(0, len(data)),temp, label = 'actual', linestyle = '--', linewidth = 2, c = 'blue') legend_predicted, = plt.plot(range(0, len(data)), predicted_array, label = 'predicted', linewidth = 1.5, c='red') plt.legend(handles=[legend_actual, legend_predicted]) plt.savefig('error.png') plt.show()
class prettyfloat(float): def __repr__(self): return "%4.1f" % self df=pd.read_csv(train_file, sep=',',header=None) training_features = [] for row in df.values: # mean temp, mean Dew Point, mean humidity, mean sea level PressurehPa feature_set = [float(row[2]),float(row[5]),float(row[8]),float(row[11])] nans = list( filter((lambda x: math.isnan(x)), feature_set) ) if (len(nans) > 0): continue training_features.append(feature_set) consecutive_days_pressure_dropping_by = 0 ds = SequentialDataSet(5, 1) for sample, next_sample in zip(training_features, cycle(training_features[1:])): ds.newSequence() yesterdays_sample = sample yesterdays_pressure = yesterdays_sample[3] todays_pressure = next_sample[3] raining = 0.0 if (todays_pressure > yesterdays_pressure): consecutive_days_pressure_dropping_by += (todays_pressure - yesterdays_pressure) else: raining = 1.0 consecutive_days_pressure_dropping_by = 0 yesterdays_sample.append(float(consecutive_days_pressure_dropping_by)) ds.appendLinked(yesterdays_sample, raining) net = buildNetwork(5, 10, 1,
from pybrain.datasets import SequentialDataSet from itertools import cycle ds = SequentialDataSet(1, 1) with open('training.txt') as file: data = [1.0, 0.0] for line in file: for x in list(line): data.append(ord(x)) #data = [1] * 3 + [2] * 3 for sample, next_sample in zip(data, cycle(data[:1])): ds.addSample(sample, next_sample) from pybrain.tools.shortcuts import buildNetwork from pybrain.structure.modules import LSTMLayer net = buildNetwork(1, 100, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) from pybrain.supervised import RPropMinusTrainer from sys import stdout trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] # save errors for plotting later EPOCHS_PER_CYCLE = 5 CYCLES = 100 EPOCHS = EPOCHS_PER_CYCLE * CYCLES for i in xrange(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i+1) * EPOCHS_PER_CYCLE print "\r epoch {}/{}".format(epoch, EPOCHS)
#!/usr/bin/env python # -*- coding: utf-8 -*- import csv from numpy import * from pybrain.datasets import SequentialDataSet,UnsupervisedDataSet from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised import BackpropTrainer sequencia = [] NEURONIOS = 10e4 if __name__ == "__main__": sequencias = SequentialDataSet(1,1) for x in range(0,100): sequencia.append(x) for i,v in enumerate(sequencia): if i+1 < len(sequencia): sequencias.addSample(v, sequencia[i+1]) print(sequencias) rn = buildNetwork(sequencias.indim, NEURONIOS, sequencias.outdim, recurrent=True) sorteio = BackpropTrainer(rn, sequencias, learningrate=1/(NEURONIOS/100)) while 1: try: print(sorteio.train()) except KeyboardInterrupt: