def __init__(self, histogram_list):
self.net = buildNetwork(1024, 100, 1)
ds = SupervisedDataSet(1024, 1)
for histogram in histogram_list:
#print (histogram)
ds.addSample(histogram, (1,))
for x in range(0,15):
ds.addSample(numpy.random.random((1024)) * 255, (0,)) # this noise should never be a face
#print (numpy.random.random((1024)) * 255)
trainer = BackpropTrainer(self.net, ds)
#trainer.trainUntilConvergence()
for x in range(2000):
print ("count:\t" + str(x) + "\terror:\t" + str(trainer.train()))
#trainer.train()
print (trainer.train())
"""
def move_function(board):
global net
best_max_move = None
max_value = -1000
best_min_move = None
min_value = 1000
#value is the chance of black winning
for m in board.get_moves():
nextboard = board.peek_move(m)
value = net.activate(board_to_input(nextboard))
if value > max_value:
max_value = value
best_max_move = m
if value < min_value:
min_value = value
best_min_move = m
ds = SupervisedDataSet(97, 1)
best_move = None
#active player
if board.active == BLACK:
ds.addSample(board_to_input(board), max_value)
best_move = best_max_move
elif board.active == WHITE:
ds.addSample(board_to_input(board), min_value)
best_move = best_min_move
trainer = BackpropTrainer(net, ds)
trainer.train()
NetworkWriter.writeToFile(net, 'CheckersMini/synapsemon_random_black_mini_140.xml')
NetworkWriter.writeToFile(net, 'SynapsemonPie/synapsemon_random_black_mini_140_copy.xml')
return best_move
def neuralNetwork_eval_func(self, chromosome):
node_num, learning_rate, window_size = self.decode_chromosome(chromosome)
if self.check_log(node_num, learning_rate, window_size):
return self.get_means_from_log(node_num, learning_rate, window_size)[0]
folded_dataset = self.create_folded_dataset(window_size)
indim = 21 * (2 * window_size + 1)
mean_AUC = 0
mean_decision_value = 0
mean_mcc = 0
sample_size_over_thousand_flag = False
for test_fold in xrange(self.fold):
test_labels, test_dataset, train_labels, train_dataset = folded_dataset.get_test_and_training_dataset(test_fold)
if len(test_labels) + len(train_labels) > 1000:
sample_size_over_thousand_flag = True
ds = SupervisedDataSet(indim, 1)
for i in xrange(len(train_labels)):
ds.appendLinked(train_dataset[i], [train_labels[i]])
net = buildNetwork(indim, node_num, 1, outclass=SigmoidLayer, bias=True)
trainer = BackpropTrainer(net, ds, learningrate=learning_rate)
trainer.trainUntilConvergence(maxEpochs=self.maxEpochs_for_trainer)
decision_values = [net.activate(test_dataset[i]) for i in xrange(len(test_labels))]
decision_values = map(lambda x: x[0], decision_values)
AUC, decision_value_and_max_mcc = validate_performance.calculate_AUC(decision_values, test_labels)
mean_AUC += AUC
mean_decision_value += decision_value_and_max_mcc[0]
mean_mcc += decision_value_and_max_mcc[1]
if sample_size_over_thousand_flag:
break
if not sample_size_over_thousand_flag:
mean_AUC /= self.fold
mean_decision_value /= self.fold
mean_mcc /= self.fold
self.write_log(node_num, learning_rate, window_size, mean_AUC, mean_decision_value, mean_mcc)
self.add_log(node_num, learning_rate, window_size, mean_AUC, mean_decision_value, mean_mcc)
return mean_AUC
def entrenarSomnolencia(red):
#Se inicializa el dataset
ds = SupervisedDataSet(4096,1)
"""Se crea el dataset, para ello procesamos cada una de las imagenes obteniendo los rostros,
luego se le asignan los valores deseados del resultado la red neuronal."""
print "Somnolencia - cara"
for i,c in enumerate(os.listdir(os.path.dirname('/home/taberu/Imágenes/img_tesis/somnoliento/'))):
try:
im = cv2.imread('/home/taberu/Imágenes/img_tesis/somnoliento/'+c)
pim = pi.procesarImagen(im)
cara = d.deteccionFacial(pim)
if cara == None:
print "No hay cara"
else:
print i
ds.appendLinked(cara.flatten(),10)
except:
pass
trainer = BackpropTrainer(red, ds)
print "Entrenando hasta converger"
trainer.trainUntilConvergence()
NetworkWriter.writeToFile(red, 'rna_somnolencia.xml')
def main():
inputs = ReadCSV('./data/input.csv')
outputs = ReadCSV('./data/output.csv')
test_set = test.keys()
train_set = []
for k in inputs.keys():
if k not in test_set:
train_set.append(k)
print "Number of training samples", len(train_set)
print "Number of testing samples", len(test_set)
net = buildNetwork(178, 6, 5)
ds=SupervisedDataSet(178,5)
for id in train_set:
ds.addSample(inputs[id],outputs[id])
trainer = BackpropTrainer(net, ds, learningrate=0.001, momentum = 0.001)
trainer.trainUntilConvergence(maxEpochs=1000, validationProportion = 0.5)
for id in test_set:
predicted = net.activate(inputs[id])
actual = outputs[id]
print '-----------------------------'
print test[id]
print '-----------------------------'
print 'Trait\t\tPredicted\tActual\tError'
for i in range(0,5):
error = abs(predicted[i] - actual[i])*100/4.0
print traits[i], '\t', predicted[i], '\t', actual[i], '\t', error,"%"
def NeuralNetwork(tRiver, qRiver, pRiver, TRiver, qnewRiver, pnewRiver, TnewRiver):
# build neural network with 20 neurons for historic data on flux, 3 for last 3 temp data, 3 for last precipitation,
# hidden layer with more than input neurons (hinder specification)
# and 3 output neurons (flux for next day, first derivative, second derivative
Ndim = 10+3+3
Nout = 3
net = buildNetwork(Ndim, Ndim, Nout, hiddenclass=TanhLayer)
ds = SupervisedDataSet(Ndim, Nout)
# next big job: find data values to build up library of training set
for t in range(len(tRiver)-3):
input_flow = qRiver[t-20:2:t]
input_prec = pRiver[t-3:t]
input_temp = TRiver[t-3:t]
input_vec = np.hstack([input_flow, input_prec, input_temp])
output_flow = np.hstack([qRiver[t:t+3]]) # first approx, split later for long predictions
ds.addSample(input_vec, output_flow)
trainer = BackpropTrainer(net, ds)
#trainer.train()
trainer.trainUntilConvergence()
# now call it repeatedly on the second set
prediction = net.activate(np.hstack([qnewRiver[:20], pnewRiver[:3], TnewRiver[:3]]))
return prediction
def getErrorPercent(training_dataset, eval_dataset_list, num_hidden, num_epochs):
num_datapoints = len(training_dataset)
num_inputs = len(training_dataset[0][0])
num_outputs = len(training_dataset[0][1])
# print "Num Inputs:", num_inputs
# print "Num Outputs:", num_outputs
# print "Num Hidden Nodes:", num_hidden
NN = buildNetwork(num_inputs, num_hidden, num_outputs, bias=True, hiddenclass=SigmoidLayer, outclass=SigmoidLayer)
dataset = SupervisedDataSet(num_inputs, num_outputs)
for datapoint in training_dataset:
dataset.addSample(datapoint[0], datapoint[1])
trainer = BackpropTrainer(NN, dataset=dataset, momentum=0.0, verbose=False, weightdecay=0.0)
for epoch in range(0, num_epochs):
#print epoch
trainer.train()
errors = []
for eval_set in eval_dataset_list:
total_percent_errors = [0]*num_outputs
for jj in range(0, len(eval_set)):
nn_out = NN.activate(eval_set[jj][0])
percent_error = computeError(eval_set[jj][1], nn_out)
#print percent_error
total_percent_errors = map(operator.add, percent_error, total_percent_errors)
#print total_percent_errors
errors.append(map(operator.div, total_percent_errors, [len(dataset)]*num_outputs))
#print errors
return errors
class NeuralNet(object):
def __init__(self, layers):
self.layers = layers
self.ds = None
self.train_error = []
self.test_error = []
self.norm_error = []
def improve(self, n=10):
trainer = BackpropTrainer(self.nn, self.ds)
for i in xrange(n):
self.train_error.append(trainer.train())
def fit(self, X, y):
self.nn = buildNetwork(*self.layers, bias=True, hiddenclass=SigmoidLayer)
self.ds = SupervisedDataSet(self.layers[0], self.layers[-1])
for i, row in enumerate(X):
self.ds.addSample(row.tolist(), y[i])
self.improve()
def predict(self, X):
r = []
for row in X.tolist():
r.append(self.nn.activate(row))
return numpy.array(r)
def loadDataSet(ds_file):
global X, Y
BB = set()
aaa = {}
ds = SupervisedDataSet(400, 10)
#ds = SupervisedDataSet(1024, 5)
with open(ds_file,"rb") as f:
lines = f.readlines()
for line in lines:
l = [float(a) for a in line.strip().split(',')]
#A = [float(1.0)] + l[:-1]
A = l[:-1]
X.append(A)
B = int(l[-1])
#BB.update([B])
#for aa,bb in enumerate(BB):
# aaa[bb] = aa
#print aaa
#Y.append(aaa[bb])
Y.append(B)
C = []
for i in range(10):
C.append(int(1) if i==B or (i==0 and B==10) else int(0))
ds.addSample(tuple(A), tuple(C))
return ds
def getModel(inputSize,hiddenSize1,hiddenSize2,trainData,target): fnn = FeedForwardNetwork() inLayer = LinearLayer(inputSize,name = 'inLayer') hiddenLayer0 = SigmoidLayer(hiddenSize1,name='hiddenLayer0') hiddenLayer1 = SigmoidLayer(hiddenSize2,name='hiddenLayer1') outLayer = LinearLayer(1,name = 'outLayer') fnn.addInputModule(inLayer) fnn.addModule(hiddenLayer0) fnn.addModule(hiddenLayer1) fnn.addOutputModule(outLayer) inToHidden0 = FullConnection(inLayer,hiddenLayer0) hidden0ToHidden1 = FullConnection(hiddenLayer0,hiddenLayer1) hidden1ToHiddenOutput = FullConnection(hiddenLayer1,outLayer) fnn.addConnection(inToHidden0) fnn.addConnection(hidden0ToHidden1) fnn.addConnection(hidden1ToHiddenOutput) fnn.sortModules() Ds = SupervisedDataSet(inputSize,1) scaler = preprocessing.StandardScaler().fit(trainData) x = scaler.transform(trainData) # print(len(target)) # print(len(x)) for i in range(len(target)): Ds.addSample(x[i],[target[i]]) trainer = BackpropTrainer(fnn,Ds,learningrate=0.01,verbose=False) trainer.trainUntilConvergence(maxEpochs=1000) return fnn
class Brain: def __init__(self, hiddenNodes = 30): # construct neural network self.myClassifierNet = buildNetwork(12, hiddenNodes, 1, bias=True, hiddenclass=TanhLayer) #parameters to buildNetwork are inputs, hidden, output # set up dataset self.myDataset = SupervisedDataSet(12, 1) self.myClassifierTrainer = BackpropTrainer(self.myClassifierNet, self.myDataset) def addSampleImageFromFile(self, imageFile, groupId): "adds a data sample from an image file, including needed processing" myImage = Image.open(imageFile) self.myDataset.addSample(twelveToneParallel(myImage), (groupId,)) def train(self): #myClassifierTrainer.trainUntilConvergence() #this will take forever (possibly literally in the pathological case) for i in range(0, 15): self.myClassifierTrainer.train() #this may result in an inferior network, but in practice seems to work fine def save(self, saveFileName="recognizernet.brain"): saveFile = open(saveFileName, 'w') pickle.dump(self.myClassifierNet, saveFile) saveFile.close() def load(self, saveFileName="recognizernet.brain"): saveFile = open(saveFileName, 'r') myClassifierNet = pickle.load(saveFile) saveFile.close() def classify(self, fileName): myImage = Image.open(fileName) if self.myClassifierNet.activate(twelveToneParallel(myImage)) < 0.5: return 0 else: return 1
def createNet(): """Create and seed the intial neural network""" #CONSTANTS nn_input_dim = 6 #[x_enemy1, y_enemy1, x_enemy2, y_enemy2, x_enemy3, y_enemy3] nn_output_dim = 6 #[x_ally1, y_ally1, x_ally2, y_ally2, x_ally3, y_ally3] allyTrainingPos, enemyTrainingPos = runExperiments.makeTrainingDataset() ds = SupervisedDataSet(nn_input_dim, nn_output_dim) #normalizes and adds it to the dataset for i in range(0, len(allyTrainingPos)): x = normalize(enemyTrainingPos[i]) y = normalize(allyTrainingPos[i]) x = [val for pair in x for val in pair] y = [val for pair in y for val in pair] ds.addSample(x, y) for inpt, target in ds: print inpt, target net = buildNetwork(nn_input_dim, 30, nn_output_dim, bias=True, hiddenclass=TanhLayer) trainer = BackpropTrainer(net, ds) trainer.trainUntilConvergence() NetworkWriter.writeToFile(net, "net.xml") enemyTestPos = runExperiments.makeTestDataset() print(net.activate([val for pair in normalize(enemyTestPos) for val in pair])) return ds
def learn(self):
# convert reinforcement dataset to NFQ supervised dataset
supervised = SupervisedDataSet(self.module.network.indim, 1)
for seq in self.dataset:
lastexperience = None
for state, action, reward in seq:
if not lastexperience:
# delay each experience in sequence by one
lastexperience = (state, action, reward)
continue
# use experience from last timestep to do Q update
(state_, action_, reward_) = lastexperience
Q = self.module.getValue(state_, action_[0])
inp = r_[state_, one_to_n(action_[0], self.module.numActions)]
tgt = Q + 0.5*(reward_ + self.gamma * max(self.module.getActionValues(state)) - Q)
supervised.addSample(inp, tgt)
# update last experience with current one
lastexperience = (state, action, reward)
# train module with backprop/rprop on dataset
trainer = RPropMinusTrainer(self.module.network, dataset=supervised, batchlearning=True, verbose=False)
trainer.trainUntilConvergence(maxEpochs=self.maxEpochs)
def trainDataSet():
cases = Case.objects.exclude(geocode__isnull=True, geocode__grid=-1)
print "Data Representation"
ds = SupervisedDataSet(5245, 5245)
for w in xrange(0,52):
print "Start week w",
dataset_input = [0 for i in xrange(0,5245)]
dataset_output = [0 for i in xrange(0,5245)]
for i in xrange(0,5245):
dataset_input[i] = cases.filter(geocode__grid=i, morbidity__week=w).count()
dataset_output[i] = 1 if (cases.filter(geocode__grid=i, morbidity__week=w+1).count() > 0 or cases.filter(geocode__grid=i, morbidity__week=w+2).count() > 0) else 0
ds.addSample( (dataset_input), (dataset_output))
print " - done week w"
# tstdata, trndata = ds.splitWithProportion(0.25)
print "Train"
net = buildNetwork( 5245, 1000, 5245, bias=True)
trainer = BackpropTrainer(net, ds, learningrate=0.1, momentum=0.99)
terrors = trainer.trainUntilConvergence(verbose = None, validationProportion = 0.33, maxEpochs = 1000, continueEpochs = 10 )
# print terrors[0][-1],terrors[1][-1]
fo = open("data.txt", "w")
for input, expectedOutput in ds:
output = net.activate(input)
count = 0
for q in xrange(0, 5245):
print math.floor(output[q]), math.floor(expectedOutput[q])
if math.floor(output[q]) == math.floor(expectedOutput[q]):
count+=1
m = count/5245
fo.write("{0} :: {1}".format(count, m));
def run_data():
with open('new_data2.txt') as data_file:
data = json.load(data_file)
ds = SupervisedDataSet(1316, 1316)
for i in xrange(0, 51):
print "Adding {}th data sample".format(i),
input = tuple(data[str(i)]['input'])
output = tuple(data[str(i)]['output'])
# print len(input), len(output)
ds.addSample( input, output)
print ":: Done"
print "Train"
net = buildNetwork( 1316, 100, 1316, bias=True, )
trainer = BackpropTrainer(net, ds)
terrors = trainer.trainUntilConvergence(verbose = True, validationProportion = 0.33, maxEpochs = 20, continueEpochs = 10 )
# print terrors[0][-1],terrors[1][-1]
fo = open("results2.txt", "w")
for input, expectedOutput in ds:
output = net.activate(input)
count = 0
for q in xrange(0, 1316):
print output[q], expectedOutput[q]
if math.floor(output[q]) == math.floor(expectedOutput[q]):
count+=1
m = float(count)/1316.00
print "{0} :: {1}".format(count, m)
fo.write("{0} :: {1}\n".format(count, m))
def getDS(il,ol,trainData): DS = SupervisedDataSet(il,ol) # 网数据集里面加样本点 r = trainData.shape[0] for i in xrange(0,r-1): DS.addSample(trainData[i,:il],trainData[i,il]) return DS
class dataset:
# Initialize the dataset with input and label size
def __init__(self, inputsize, labelsize):
self.inputsize = inputsize
self.labelsize = labelsize
self.DS = SupervisedDataSet(self.inputsize, self.labelsize)
# Adds data to existing training dataset
def addTrainingData(self,inputdata, labeldata):
try:
if inputdata.size == self.inputsize and labeldata.size == self.labelsize:
self.DS.appendLinked(inputdata, labeldata)
return 1
except AttributeError:
print "Input error."
return 0
def getTrainingDataset(self):
return self.DS
def generateDataSet(self):
for line in fileinput.input(['data/inputdata3.txt']):
x = line.split(':')
# print ft.feature.getImageFeatureVector(x[0]),np.array([int(x[1])])
self.addTrainingData(ft.feature.getImageFeatureVector(x[0]),np.array([int(x[1])]))
return 1
def _prepare_dataset(self, X, y, model_type):
X, y, sample_weight = check_inputs(X, y, sample_weight=None, allow_none_weights=True,
allow_multiple_targets=model_type == 'regression')
X = self._transform_data(X, y, fit=not self.is_fitted())
if model_type == 'classification':
if not self.is_fitted():
self._set_classes(y)
target = one_hot_transform(y, n_classes=len(self.classes_))
elif model_type == 'regression':
if len(y.shape) == 1:
target = y.reshape((len(y), 1))
else:
# multi regression
target = y
if not self.is_fitted():
self.n_targets = target.shape[1]
else:
raise ValueError('Wrong model type')
dataset = SupervisedDataSet(X.shape[1], target.shape[1])
dataset.setField('input', X)
dataset.setField('target', target)
return dataset
def train(self, params):
"""
Train TDNN network on buffered dataset history
:param params:
:return:
"""
# self.net = buildNetwork(params['encoding_num'] * params['num_lags'],
# params['num_cells'],
# params['encoding_num'],
# bias=True,
# outputbias=True)
ds = SupervisedDataSet(params['encoding_num'] * params['num_lags'],
params['encoding_num'])
history = self.window(self.history, params['learning_window'])
n = params['encoding_num']
for i in xrange(params['num_lags'], len(history)):
targets = numpy.zeros((1, n))
targets[0, :] = self.encoder.encode(history[i])
features = numpy.zeros((1, n * params['num_lags']))
for lags in xrange(params['num_lags']):
features[0, lags * n:(lags + 1) * n] = self.encoder.encode(
history[i - (lags + 1)])
ds.addSample(features, targets)
trainer = BackpropTrainer(self.net,
dataset=ds,
verbose=params['verbosity'] > 0)
if len(history) > 1:
trainer.trainEpochs(params['num_epochs'])
def createBetterSupervisedDataSet(input_file):
print "Creating a BETTER supervised dataset from", input_file
ds = SupervisedDataSet(nFeatures, 1)
answers_by_question = {}
try:
with open(training_data_pickle_name, 'rb') as p:
print "Loading from pickle"
answers_by_question = pickle.load(p)
print "Load successful"
print "Size of answers_by_question:", len(answers_by_question.keys())
except IOError:
answers_by_question = loadAnswersByQuestion(input_file)
print "Saving to a pickle..."
with open(training_data_pickle_name, 'wb') as p:
pickle.dump(answers_by_question, p)
print "Saved to", training_data_pickle_name
# loop to load stuff into ds
for qid in answers_by_question:
for aid in answers_by_question[qid]:
if aid != 'info':
ds.addSample( tuple(answers_by_question[qid][aid]['data']), (answers_by_question[qid][aid]['target'], ) )
# ds.addSample(tuple(ans[1]), (ans[0],))
return ds, answers_by_question
def build_dataset():
ds = SupervisedDataSet(2, 1)
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
return ds
def initializeNetwork(self):
can1 = NNTrainData.NNTrainData(cv2.imread('NNTrain/can1.png'), self.encodingDict["can"])
can2 = NNTrainData.NNTrainData(cv2.imread('NNTrain/can2.png'), self.encodingDict["can"])
can3 = NNTrainData.NNTrainData(cv2.imread('NNTrain/can3.png'), self.encodingDict["can"])
stain1 = NNTrainData.NNTrainData(cv2.imread('NNTrain/stain1.png'), self.encodingDict["stain"])
stain2 = NNTrainData.NNTrainData(cv2.imread('NNTrain/stain2.png'), self.encodingDict["stain"])
stain3 = NNTrainData.NNTrainData(cv2.imread('NNTrain/stain3.png'), self.encodingDict["stain"])
dirt1 = NNTrainData.NNTrainData(cv2.imread('NNTrain/dirt1.png'), self.encodingDict["dirt"])
dirt2 = NNTrainData.NNTrainData(cv2.imread('NNTrain/dirt2.png'), self.encodingDict["dirt"])
dirt3 = NNTrainData.NNTrainData(cv2.imread('NNTrain/dirt3.png'), self.encodingDict["dirt"])
self.trainData.append(can1)
self.trainData.append(can2)
self.trainData.append(can3)
self.trainData.append(stain1)
self.trainData.append(stain2)
self.trainData.append(stain3)
self.trainData.append(dirt1)
self.trainData.append(dirt2)
self.trainData.append(dirt3)
for x in self.trainData:
x.prepareTrainData()
self.net = buildNetwork(4, 3, 3, hiddenclass=TanhLayer, outclass=SoftmaxLayer)
ds = SupervisedDataSet(4, 3)
for x in self.trainData:
ds.addSample((x.contours/100.0, x.color[0]/1000.0, x.color[1]/1000.0, x.color[2]/1000.0), x.output)
trainer = BackpropTrainer(self.net, momentum=0.1, verbose=True, weightdecay=0.01)
trainer.trainOnDataset(ds, 1000)
trainer.testOnData(verbose=True)
print "\nSiec nauczona\n"
class NeuralKinect():
def __init__(self):
# Softmax layer -> great for classification networks
#self.neuralNet = buildNetwork(60, 60, 5, outclass=SoftmaxLayer)
#self.neuralNet = buildNetwork(60, 60, 5, hiddenclass=TanhLayer)
#self.neuralNet = buildNetwork(60, 60, 5, bias=True)
self.neuralNet = buildNetwork(60, 60, 5)
self.dataSet = SupervisedDataSet(60, 5)
def trainBackProp(self):
trainer = BackpropTrainer(self.neuralNet, self.dataSet)
start = time.time()
trainer.trainEpochs(EPOCHS)
end = time.time()
print("Training time -> " + repr(end-start))
print(repr(trainer.train()))
def loadDataSet(self):
points = []
for csvFile in glob.iglob("TrainData/*.csv"):
with open(csvFile, 'rt') as letterSet:
reader = csv.reader(letterSet)
header = str(reader.next())
letter = header[2:3]
targetStr = header[4:9]
print("Processing Dataset for letter -> " + letter)
target = []
for digit in targetStr:
target.append(digit)
rows = 1
for row in reader:
for col in row:
points.append(col)
if rows % 20 == 0:
self.dataSet.addSample(points, target)
points = []
rows += 1
def processResults(self, output):
result = ""
for digit in output:
if digit > 0.5:
result += "1"
else:
result += "0"
print("Network result -> " + chr(64+int(result,2)))
def testNetwork(self):
points = []
for csvFile in glob.iglob("TestData/*.csv"):
with open(csvFile, 'rt') as testPose:
reader = csv.reader(testPose)
rows = 1
for row in reader:
for col in row:
points.append(col)
if rows % 20 == 0:
self.processResults(self.neuralNet.activate(points))
points = []
rows += 1
def get_dataset_for_pybrain_regression(X,y): ds = SupervisedDataSet(250,1) tuples_X = [tuple(map(float,tuple(x))) for x in X.values] tuples_y = [tuple(map(float,(y,))) for y in y.values] for X,y in zip(tuples_X,tuples_y): ds.addSample(X,y) return ds
def learn(self,dataset):
"""
This function trains network
Input:
dataset - Dataset to train network
Returns:
Nothing
"""
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.datasets import SupervisedDataSet
from neuraltrainer import NeuralTrainer
if self._net == None: raise NeuralBrainException("Brain is not configured!")
if dataset == {}: raise NeuralBrainException("Dataset for learning is empty.")
data = SupervisedDataSet(self._input,self._output)
for input,output in dataset.items():
input = self._normalize(input,self._input)
output = self._normalize(output,self._output)
data.addSample(input,output)
data.addSample(input,output)# For better learning 2x
trainer = NeuralTrainer(self._net, data)
trainer.simpleTrain()
def convertDataNeuralNetwork(x, y):
data = SupervisedDataSet(x.shape[1], 1)
for xIns, yIns in zip(x, y):
data.addSample(xIns, yIns)
return data
def NN(xTrain, yTrain, xTest, yTest):
trainData = convertDataNeuralNetwork(xTrain, yTrain)
testData = convertDataNeuralNetwork(xTest, yTest)
fnn = FeedForwardNetwork()
inLayer = SigmoidLayer(trainData.indim)
hiddenLayer = SigmoidLayer(5)
outLayer = LinearLayer(trainData.outdim)
fnn.addInputModule(inLayer)
fnn.addModule(hiddenLayer)
fnn.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
fnn.addConnection(in_to_hidden)
fnn.addConnection(hidden_to_out)
fnn.sortModules()
trainer = BackpropTrainer(fnn, dataset = trainData, momentum = 0.1, verbose = True, weightdecay = 0.01)
for i in xrange(10):
trainer.trainEpochs(500)
rmse = percentError(trainer.testOnClassData(dataset = testData), yTest)
return rmse/100
def main():
rmse = NN(xTrain, yTrain, xTest, yTest)
print rmse
if __name__=="__main__":
main()
def get_train_samples(input_num,output_num):
'''
从new_samples文件夹中读图，根据输入数和输出数制作样本，每一原始样本加入随机噪音生成100个样本
'''
print 'getsample start.'
sam_path='./new_samples'
samples = SupervisedDataSet(input_num,output_num)
nlist = os.listdir(sam_path)
t=int(np.sqrt(input_num))
for n in nlist:
file = os.path.join(sam_path,n)
im = Image.open(file)
im = im.convert('L')
im = im.resize((t,t),Image.BILINEAR)
buf = np.array(im).reshape(input_num,1)
buf = buf<200
buf = tuple(buf)
buf1=int(n.split('.')[0])
buf2=range(output_num)
for i in range(len(buf2)):
buf2[i] = 0
buf2[buf1]=1
buf2 = tuple(buf2)
samples.addSample(buf,buf2)
for i in range(100):
buf3 = list(buf)
for j in range(len(buf)/20):
buf3[np.random.randint(len(buf))] = bool(np.random.randint(2))
samples.addSample(tuple(buf3),buf2)
return samples
def neural_network(data, target, network):
DS = SupervisedDataSet(len(data[0]), 1)
nn = buildNetwork(len(data[0]), 7, 1, bias = True)
kf = KFold(len(target), 10, shuffle = True);
RMSE_NN = []
for train_index, test_index in kf:
data_train, data_test = data[train_index], data[test_index]
target_train, target_test = target[train_index], target[test_index]
for d,t in zip(data_train, target_train):
DS.addSample(d, t)
bpTrain = BackpropTrainer(nn,DS, verbose = True)
#bpTrain.train()
bpTrain.trainUntilConvergence(maxEpochs = 10)
p = []
for d_test in data_test:
p.append(nn.activate(d_test))
rmse_nn = sqrt(np.mean((p - target_test)**2))
RMSE_NN.append(rmse_nn)
DS.clear()
time = range(1,11)
plt.figure()
plt.plot(time, RMSE_NN)
plt.xlabel('cross-validation time')
plt.ylabel('RMSE')
plt.show()
print(np.mean(RMSE_NN))
def run_try(self, rand_chance=0, rand_count=0, rand_count_ref=0, render=False):
ds = SupervisedDataSet(env_size, 1)
observation = env.reset()
random_indexes = []
while len(random_indexes) < rand_count:
random_index = math.floor(random() * rand_count_ref)
if random_index not in random_indexes:
random_indexes.append(random_index)
for t in range(max_frames):
if render:
env.render()
# print(observation)
action = 0 if net.activate(observation)[0] < 0 else 1
if t in random_indexes or random() < rand_chance:
action = (action + 1) % 1
ds.addSample(observation, (action,))
observation, reward, done, info = env.step(action)
if done:
print("Episode finished after {} timesteps".format(t + 1))
break
if t == max_frames - 1:
print("Passed!!")
self.run_try(render=True)
return t, ds
def _set_dataset(self, trn_index, tst_index):
'''
set the dataset according to the index of the training data and the test data
Then do feature normalization
'''
this_trn = self.tot_descs[trn_index]
this_tst = self.tot_descs[tst_index]
this_trn_target = self.tot_target[trn_index]
this_tst_target = self.tot_target[tst_index]
# get the normalizer
trn_normalizer = self._getNormalizer(this_trn)
# feature normal and target log for traning data
trn_normed = self._featureNorm(this_trn, trn_normalizer)
trn_log_tar = np.log(this_trn_target)
# feature normalization for the test data, with the normalizer of the training data
tst_normed = self._featureNorm(this_tst, trn_normalizer)
tst_log_tar = np.log(this_tst_target)
trn_ds_ann = SupervisedDataSet(self.indim, self.outdim)
trn_ds_ann.setField('input', trn_normed)
trn_log_tar = trn_log_tar.reshape((trn_log_tar.shape[0],1))
trn_ds_ann.setField('target', trn_log_tar)
tst_ds_ann = SupervisedDataSet(self.indim, self.outdim)
tst_ds_ann.setField('input', tst_normed)
tst_log_tar = tst_log_tar.reshape((tst_log_tar.shape[0],1))
tst_ds_ann.setField('target', tst_log_tar)
return trn_ds_ann, tst_ds_ann
arr_val = np.concatenate((arr1[12:24], arr2[12:24]), axis=0)
nEpochs = 200
#We will do all 4 types, with data replication
noise_list = [0.03, 0.05]
#add noise
length_data = len(arr_test)
#the four sets are given separately
set_lengths = ((0, 12), (12, 24), (24, 36), (36, 48), (48, 60))
#third set is separated
#an enchanced array that will contain the noisy data
enh_array = np.empty((1, 6)) #np.zeros((38,5))
#build and populate datasets
ds2 = SupervisedDataSet(5, 3)
for noise in noise_list:
enh_array = np.empty((1, 6)) #np.zeros((38,5))
#augment the enhanced array
for i, m in product(set_lengths, xrange(100)):
#i is the dataset
#for each dataset we produce a 100 noise_arrays
temp_data = arr_test[i[0]:i[1]]
#generate an array the size of the current sub array, to be added.
noise_array = np.array([[temp_data[k, 0]] + [temp_data[k, 1]] + [
temp_data[k, j] +
temp_data[k, j] * np.random.uniform(-noise, noise)
for j in xrange(2, 6)
] for k in xrange(len(temp_data))])
enh_array = np.concatenate((enh_array, noise_array), axis=0)
""" A simple example on how to use the GaussianProcess class in pybrain, for one and two dimensions. """ __author__ = "Thomas Rueckstiess, [email protected]" from pybrain.auxiliary import GaussianProcess from pybrain.datasets import SupervisedDataSet from scipy import mgrid, sin, cos, array, ravel from pylab import show, figure ds = SupervisedDataSet(1, 1) gp = GaussianProcess(indim=1, start=-3, stop=3, step=0.05) figure() x = mgrid[-3:3:0.2] y = 0.1*x**2 + x + 1 z = sin(x) + 0.5*cos(y) ds.addSample(-2.5, -1) ds.addSample(-1.0, 3) gp.mean = 0 # new feature "autonoise" adds uncertainty to data depending on # it's distance to other points in the dataset. not tested much yet. # gp.autonoise = True gp.trainOnDataset(ds) gp.plotCurves(showSamples=True) # you can also test the gp on single points, but this deletes the # original testing grid. it can be restored with a call to _buildGrid()
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
neuralNetwork = buildNetwork(2, 3, 1, bias=True)
dataset = SupervisedDataSet(2, 1)
dataset.addSample((0, 0), (0))
dataset.addSample((1, 0), (1))
dataset.addSample((0, 1), (1))
dataset.addSample((1, 1), (0))
trainer = BackpropTrainer(neuralNetwork,
dataset=dataset,
learningRate=0.01,
momentum=0.06)
for i in range(1, 10000):
error = trainer.train()
if i % 10000 == 0:
print("Error in iteration ", i, " is: ", error)
print(neuralNetwork.activate([0, 0]))
print(neuralNetwork.activate([1, 0]))
print(neuralNetwork.activate([0, 1]))
print(neuralNetwork.activate([1, 1]))
print("\n\nFinal result of XOR:\n")
print(neuralNetwork.activate([0, 0]))
print(neuralNetwork.activate([1, 0]))
float(45),
float(45),
float(45),
float(45),
float(45),
float(45),
float(45),
float(45),
float(45)
]
maxima_saida = max(saidas)
saidas = np.matrix(saidas)
saidas = saidas / maxima_saida
parametros_entrada = SupervisedDataSet(20, 1)
i = 0
for entrada in atributos:
parametros_entrada.addSample(entrada, [saidas[0, i]])
i = i + 1
rede_neural = buildNetwork(20, 15, 1, bias=True)
rede_neural.randomize()
treinamento = BackpropTrainer(rede_neural, parametros_entrada, momentum=0.99)
treinamento.trainEpochs(1000)
obj = wocr("../imagens_teste/um.jpg")
atributos_teste = obj.atributos()
atributos_teste = np.matrix(atributos_teste) / maximo_entrada
# Y = scy.transform(y)
# X.reshape(-1, 1)
# Y.reshape(-1, 1)
X = preprocessing.scale(x_np)
Y = preprocessing.scale(y_np)
######################################
#setup the dataset (supervised classification training) for neural network
######################################
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from pybrain.datasets.classification import ClassificationDataSet
from pybrain.datasets import SupervisedDataSet
ds = SupervisedDataSet(4, 1)
for i in range(len(X)):
ds.addSample(X[i], Y[i])
# #split the dataset
trainData, testData = ds.splitWithProportion(0.60)
# ###################################
# #Creating a Neural Network
# ###################################
# # build nerual net with 4 inputs, 5 hidden neuron and 1 output neuron
net = buildNetwork(4, 5, 1, bias=True)
trainer = BackpropTrainer(net, trainData)
train_error = trainer.trainUntilConvergence(dataset=trainData,
maxEpochs=50)
# #evaluate the error rate on training data
occurrences = [w[1] for w in sorted_word_dict[-dict_size:]]
print "These are the 10 most occurring words are"
print sorted_word_dict[-9:]
plt.plot(occurrences)
plt.xlabel('word indices')
plt.ylabel('occurrences')
plt.ylim([0, 5000])
plt.show()
######## Build training set and save to file ############
print "Saving to file..."
#PyBrain has some nice classes to do all this.
from pybrain.datasets import SupervisedDataSet
import numpy as np
DS = SupervisedDataSet(dict_size, 1)
for m_list, target in [[spamlist, 1], [hamlist, 0]]:
for mail in m_list:
#each data point is a list (or vector) the size of the dictionary
wordvector = np.zeros(dict_size)
#now go through the email and put the occurrences of each word
#in it's respective spot (i.e. word_dict[word]) in the vector
for word in mail:
if word in word_dict:
wordvector[word_dict[word]] += 1
DS.appendLinked(np.log(wordvector + 1),
[target]) #put word occurrences on a log scale
#TODO: use MySQL instead of csv
DS.saveToFile('dataset.csv')
class NeuralNetwork():
def __init__(self, hidden_counts, training_list, learning_rate,
balance_num):
self.training_list = training_list
self.set_network(len(training_list[0]) - 4, hidden_counts, 1)
self.set_trainer(learning_rate, balance_num)
def set_network(self, in_count, hidden_counts, out_count):
assert len(hidden_counts) > 0
self.in_count = in_count
self.out_count = out_count
self.net = FeedForwardNetwork()
in_layer = LinearLayer(in_count)
hidden_layers = [SigmoidLayer(count) for count in hidden_counts]
out_layer = SigmoidLayer(out_count)
self.net.addInputModule(in_layer)
for layer in hidden_layers:
self.net.addModule(layer)
self.net.addOutputModule(out_layer)
in_connection = FullConnection(in_layer, hidden_layers[0])
hidden_connections = [
FullConnection(layer1, layer2)
for layer1, layer2 in zip(hidden_layers[0:-1], hidden_layers[1:])
]
out_connection = FullConnection(hidden_layers[-1], out_layer)
self.net.addConnection(in_connection)
for connection in hidden_connections:
self.net.addConnection(connection)
self.net.addConnection(out_connection)
self.net.sortModules()
def set_trainer(self, learning_rate, balance_num):
self.origin_ds = SupervisedDataSet(self.in_count, self.out_count)
self.balance_ds = SupervisedDataSet(self.in_count, self.out_count)
for sample in self.training_list:
feature = sample[3:-1]
label = sample[-1]
self.origin_ds.addSample(feature, label)
if label == 1:
for i in range(balance_num):
self.balance_ds.addSample(feature, label)
else:
self.balance_ds.addSample(feature, label)
self.learning_rate = learning_rate
self.balance_num = balance_num
self.origin_trainer = BackpropTrainer(self.net,
self.origin_ds,
learningrate=learning_rate)
self.balance_trainer = BackpropTrainer(self.net,
self.balance_ds,
learningrate=learning_rate)
def origin_train(self):
return self.origin_trainer.train()
def pos_train(self):
return self.pos_trainer.train()
def balance_train(self):
return self.balance_trainer.train()
def predicate_score(self, feature_list):
return [self.net.activate(feature)[0] for feature in feature_list]
def predicate_label(self, feature_list):
score_list = self.predicate_score(feature_list)
return [1 if score > 0.5 else 0 for score in score_list]
def evaluate(self):
predicate = numpy.array(self.predicate_label(self.origin_ds['input']))
label = self.origin_ds['target'][:, 0].astype('int32')
assert len(predicate.shape) == 1
assert len(label.shape) == 1
positive_true = numpy.logical_and(label, predicate).sum()
positive_predicate = predicate.sum()
positive_label = label.sum()
if positive_predicate == 0: positive_predicate = 1
if positive_label == 0: positive_label = 1
p = positive_true / positive_predicate
r = positive_true / positive_label
if p * r == 0: f1 = 0
else: f1 = 2 * p * r / (p + r)
return positive_true, positive_predicate, positive_label, p, r, f1
#将构建的输出层、隐藏层、输出层加入到fnn中
fnn.addInputModule(inLayer)
fnn.addModule(hiddenLayer)
fnn.addOutputModule(outLayer)
#对各层之间建立完全连接
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
#与fnn建立连接
fnn.addConnection(in_to_hidden)
fnn.addConnection(hidden_to_out)
fnn.sortModules()
#初始化监督数据集
DS = SupervisedDataSet(x.shape[1], 1)
#将训练的数据及标签加入到DS中
for i in range(len(xTrain)):
DS.addSample(xTrain[i], yTrain[i])
#采用BP进行训练，训练至收敛，最大训练次数为1000
trainer = BackpropTrainer(fnn, DS, learningrate=0.01, verbose=True)
trainer.trainUntilConvergence(maxEpochs=1000)
#在测试集上对其效果做验证
values = []
for x in xTest:
values.append(sy.inverse_transform(fnn.activate(x))[0])
#计算RMSE (Root Mean Squared Error)均方差
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
ds = SupervisedDataSet(2, 1)
#entradas e a saida esperada (DataSet)
ds.addSample((0.8, 0.4), (0.7))
ds.addSample((0.5, 0.7), (0.5))
ds.addSample((1.0, 0.8), (0.95))
ds.addSample((0.5, 0.5), (0.6))
#criando rede neural com 2 neuronios, 4 camadas ocultas e uma saida
nn = buildNetwork(2, 4, 1, bias=True)
#iniciando o treino enviando o DataSet e a rede
trainer = BackpropTrainer(nn, ds)
#treinando com 2000 epocas, retorna a margem de erro
for i in xrange(2000):
trainer.train()
#depois de treinada, enviamos os parametros e recebemos a saida
while True:
dormiu = float(raw_input('Dormiu: '))
estudou = float(raw_input('Estudou: '))
#envia os valores para a ativação e depois retorna com base no treino
z = nn.activate((dormiu, estudou))[0] * 10.0
fnn.addModule(hiddenLayer0)
fnn.addOutputModule(outLayer)
# link three layers
in_to_hidden0 = FullConnection(inLayer, hiddenLayer0)
hidden0_to_out = FullConnection(hiddenLayer0, outLayer)
# add the links to neural network
fnn.addConnection(in_to_hidden0)
fnn.addConnection(hidden0_to_out)
# make neural network come into effect
fnn.sortModules()
# definite the dataset as two input , one output
DS = SupervisedDataSet(2, 1)
# add data element to the dataset
for i in np.arange(199):
DS.addSample([u[i], y[i]], [y[i + 1]])
# you can get your input/output this way
X = DS['input']
Y = DS['target']
# split the dataset into train dataset and test dataset
dataTrain, dataTest = DS.splitWithProportion(0.8)
xTrain, yTrain = dataTrain['input'], dataTrain['target']
xTest, yTest = dataTest['input'], dataTest['target']
# train the NN
Created on Fri Sep 08 23:08:48 2017
@author: pedro
"""
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
#import matplotlib.pyplot as plt
arquivo = open('dadosteste.txt', 'r')
texto = arquivo.readlines()
separado = []
for linha in texto:
separado.append(linha.split())
ds = SupervisedDataSet(2, 1)
for i in range(len(separado)):
a = float(separado[i][0])
b = float(separado[i][1])
c = float(separado[i][2])
ds.addSample((a, b), (c))
nn = buildNetwork(2, 4, 1, bias=True) #2 entradas, 4 ocultos e um saida
trainer = BackpropTrainer(nn, ds)
curva_treinamento = []
for i in xrange(2000):
curva_treinamento.append(trainer.train())
print 'Epoca: ', i, 'Erro: ', curva_treinamento[i]
#plt.plot(curva_treinamento)
def simulation(params):
ntry = params["ntry"]
maxEpk = params["maxEpok"]
normalize_data = params["normalize"]
scale_data = params["scale"]
crossvalidation_pct = params["cross_validation_percentage"]
learningRate = params["algorithm"]["params"]["learning_rate"]
moment = params["algorithm"]["params"]["momentum"]
dataXAll, dataYAll, cotationAll = buildDataset(
params["dataset"]["src"], params["dataset"]["features"])
nfeatures = len(dataXAll[0])
# stat variable init
winrateLst = list()
moneyLst = list()
cotationMeanLst = list()
moneyBase = params["start_money"]
moneyMin = moneyBase
moneyMax = moneyBase
pct_bet = params["percentage_bet"]
# / stat variable init
for n in range(0, ntry):
ds = SupervisedDataSet(nfeatures, 3)
dataX = list(dataXAll)
dataY = list(dataYAll)
cotations = list(cotationAll)
# # crossvalidation data construction RANDOM PICK
# datapX = list()
# datapY = list()
# cotationpHDA = list()
# for i in range(0, int(crossvalidation_pct * len(dataX))):
# popi = random.randint(0, len(dataX) - 1)
# datapX.append(dataX[popi])
# datapY.append(dataY[popi])
# cotationpHDA.append(cotations[popi])
# dataX.pop(popi)
# dataY.pop(popi)
# cotations.pop(popi)
# # / crossvalidation data construction
# crossvalidation data construction PICK LAST
datapX = list()
datapY = list()
cotationpHDA = list()
extracti = int(len(dataX) - (crossvalidation_pct * len(dataX)))
datapX = dataX[extracti:len(dataX)]
datapY = dataY[extracti:len(dataY)]
cotationpHDA = cotations[extracti:len(cotations)]
dataX = dataX[0:extracti]
dataY = dataY[0:extracti]
cotations = cotations[0:extracti]
# / crossvalidation data construction
# scalarization && normalization -->
# http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html &&
# http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.Normalizer.html
if scale_data == True:
scalizer = preprocessing.StandardScaler().fit(dataX)
dataX = scalizer.transform(dataX)
if normalize_data == True:
normalizer = preprocessing.Normalizer().fit(dataX)
dataX = normalizer.transform(dataX)
# / scalarization && normalization
# training dataset construction
for i in range(0, len(dataX)):
ds.addSample(dataX[i], dataY[i])
# / training dataset construction
# nn && trainer construction
net = buildNetwork(ds.indim, (ds.indim + ds.outdim) / 2,
ds.outdim,
bias=True,
outclass=SoftmaxLayer) # building the n
trainer = BackpropTrainer(net,
ds,
learningrate=learningRate,
momentum=moment,
verbose=False) # building the trainer
# / nn && trainer construction
# training
trainer.trainUntilConvergence(
maxEpochs=maxEpk) # Train, until convergence
# for epoch in range(0,1000):
# trainer.train()
# / training
# cross validation
win = 0
money = moneyBase
cotationMean = 0.
for i in range(0, len(datapX)):
unit_bet = pct_bet * money if pct_bet * money > 0.5 else 0
toPredict = datapX[i]
if scale_data == True:
toPredict = scalizer.transform(toPredict)
if normalize_data == True:
toPredict = normalizer.transform(toPredict)[0]
prediction = net.activate(toPredict)
indexp, valuep = max(enumerate(prediction),
key=operator.itemgetter(1))
indexe, valuee = max(enumerate(datapY[i]),
key=operator.itemgetter(1))
money = money - unit_bet # bet unit_bet on the prediction (money is lost)
cotationMean += cotationpHDA[i][indexp]
if indexp == indexe:
win = win + 1
money = money + (
unit_bet * cotationpHDA[i][indexp]
) # on good prediction, money increased by unit_bet * predicted issue cotation
# in crossvalidation money min/max retrieve
moneyMin = money if money < moneyMin else moneyMin
moneyMax = money if money > moneyMax else moneyMax
# / in crossvalidation money min/max retrieve
# / cross validation
cotationMean = cotationMean / float(len(datapX))
cotationMeanLst.append(cotationMean)
winrate = win / float(len(datapX))
winrateLst.append(winrate)
moneyLst.append(money)
winrateFinal = sum(winrateLst) / float(ntry)
winrateMin = min(winrateLst)
winrateMax = max(winrateLst)
winrateMedian = numpy.median(numpy.array(winrateLst))
winrateStdDev = numpy.std(numpy.array(winrateLst))
moneyFinal = sum(moneyLst) / float(ntry)
moneyMinSeason = min(moneyLst)
moneyMaxSeason = max(moneyLst)
moneyMedian = numpy.median(numpy.array(moneyLst))
moneyStdDev = numpy.std(numpy.array(moneyLst))
cotationMeanFinal = sum(cotationMeanLst) / float(ntry)
cotationMeanMin = min(cotationMeanLst)
cotationMeanMax = max(cotationMeanLst)
cotationMeanMedian = numpy.median(numpy.array(cotationMeanLst))
cotationMeanStdDev = numpy.std(numpy.array(cotationMeanLst))
results = {
"win_percentage": {
"min": winrateMin,
"max": winrateMax,
"mean": winrateFinal,
"median": winrateMedian,
"standard_deviation": winrateStdDev,
"lst": winrateLst
},
"money_during_cross_validation": {
"min": moneyMin,
"max": moneyMax
},
"money_post_cross_validation": {
"min": moneyMinSeason,
"max": moneyMaxSeason,
"mean": moneyFinal,
"median": moneyMedian,
"standard_deviation": moneyStdDev,
"lst": moneyLst
},
"mean_cotation": {
"min": cotationMeanMin,
"max": cotationMeanMax,
"mean": cotationMeanFinal,
"median": cotationMeanMedian,
"standard_deviation": cotationMeanStdDev,
"lst": cotationMeanLst
}
}
print results
return results
Num = np.zeros((NumOfData, LengthOfPicture, WidthOfPicture), dtype=np.uint8)
for i in range(NumOfData):
img = ImaPreprocess(i)
Num[i] = GetImageMatrix(img)
Label = np.zeros((NumOfData, 1, 10), dtype=np.uint8)
for i in range(NumOfData):
trans = [0 for j in range(10)]
trans[i % 10] = 1
Label[i] = trans
# print Num[21], Label[21]
# print Num[38], Label[38]
net = buildNetwork(LengthOfPicture * WidthOfPicture, HiddenLayerNum, 10)
ds = SupervisedDataSet(LengthOfPicture * WidthOfPicture, 10)
for i in range(NumOfData):
ds.addSample(Num[i].reshape((LengthOfPicture * WidthOfPicture, )),
Label[i])
trainer = BackpropTrainer(net, ds)
def CheckTraining():
print 'Training:',
ErrorTrain = 0
for i in range(NumOfData):
# print net.activate(Num[i].reshape((LengthOfPicture * WidthOfPicture, )))
# print net.activate(Num[i].reshape((LengthOfPicture * WidthOfPicture, ))).argmax(),
# if i % 10 == 9:
# print '\n',
if (i % 10 != net.activate(Num[i].reshape(
minPrice = []
closePrice = []
volumeSold = []
for row in reader:
x.append(row[0] + row[1])
openPrice.append(row[2])
maxPrice.append(row[3])
minPrice.append(row[4])
closePrice.append(row[5])
volumeSold.append(row[6])
windowSize = 9 * 4
net = buildNetwork(windowSize, 8, 4, 2, 1, hiddenclass=SigmoidLayer)
ds = SupervisedDataSet(windowSize, 1)
# , recurrent=True
n = windowSize * 8
for i in range(n):
if i >= windowSize:
ds.addSample(
([closePrice[i - (windowSize - j)] for j in range(windowSize)]),
(closePrice[i]))
trainer = BackpropTrainer(
net, ds) #, learningrate=0.01, lrdecay=1.0, momentum=0.0, weightdecay=0.0)
# trainer = RPropMinusTrainer(net, dataset=ds)
for i in range(100):
print('error: ', trainer.train(), '\n')
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
import matplotlib.pyplot as plt
import sys
import pickle
train_interval = sys.argv[1].split(',')
train_begin = int(train_interval[0])
train_end = int(train_interval[1])
test_interval = sys.argv[2].split(',')
test_begin = int(test_interval[0])
test_end = int(test_interval[1])
ds = SupervisedDataSet(50, 1)
test_params = []
test_targets = []
with open("data/btc_dataset_sample.csv", "r") as btc_dataset:
header = btc_dataset.readline()
count = 0
for line in btc_dataset.readlines():
line = line.replace('\n', '')
values = line.split(';')
if count >= train_begin and count <= train_end:
ds.addSample(values[:-1], values[-1])
elif count >= test_begin and count <= test_end:
test_params.append(values[:-1])
test_targets.append(values[-1])
def main():
#Prompt user for file and directory name
io = IOclass()
#open input file
filePath = "input/" + io.filename
inputFile = open(filePath, "r")
#FOR DEBUGGING (print input file data) ----------------------------------------
#for line in inputFile:
# print line
#------------------------------------------------------------------------------
if io.authorsWorks.lower() is 'none':
print "no directory selected"
else:
movePassagesToDirectory(io)
dir = os.path.dirname(os.path.realpath(__import__("__main__").__file__))
dir += "/bin/"
featureList = []
classifierList = []
for filename in os.listdir(dir):
if filename == "database":
continue;
authorFile = open(dir + filename, "r")
for line in authorFile:
authorVec = []
for feature in line.split(","):
authorVec.append(float(feature))
featureList.append(authorVec)
if filename == io.authorName + ".txt":
classifierList.append(1)
else:
classifierList.append(0)
inputVector = passageToFeature(filePath)
print("Support Vector Machine:\n")
from sklearn import svm
print(" Creating...\n")
train1 = svm.SVC(kernel='rbf')
print(" Training...\n")
train1.fit(featureList, classifierList)
print(" Predicting...\n")
result = train1.predict([inputVector])
if result ==0:
print(" Result: "+"Forgery")
else:
print(" Result: "+"Legit")
score=train1.score(featureList, classifierList)
print(" Mean accuracy of the SVM (training set): "+str(score)+'\n')
print("Nueral Network:\n")
from pybrain.tools.shortcuts import buildNetwork
print(" Creating...\n")
from pybrain.structure import TanhLayer
net = buildNetwork(len(featureList[0]), len(featureList[0])+1, 1, hiddenclass=TanhLayer)
from pybrain.datasets import SupervisedDataSet
#size= amount of features per feature vector
ds = SupervisedDataSet(len(featureList[0]), 1)
for item, classifier in zip(featureList,classifierList):
ds.addSample(tuple(item),(classifier,))
print(" Training...\n")
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(net, ds)
NUM_EPOCHS=100
for i in range(NUM_EPOCHS):
error = trainer.train()
error = trainer.train()
print "Epoch: %d, Error: %7.4f" % (50, error)
print(" Predicting...\n")
result = net.activate(inputVector)
print (" Result: "+str(result)[1:-1] + "% a forgery")
import time
from pybrain.datasets import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised import BackpropTrainer
from pybrain.structure.modules import SigmoidLayer
from pybrain.tools.customxml.networkreader import NetworkReader
from pybrain.tools.customxml.networkwriter import NetworkWriter
trainingDataset = SupervisedDataSet(21, 1)
f_TrainingTime = open('training_time.txt', 'a')
f_TestingTime = open('testing_time.txt', 'a')
f_Training = open ('ISCXTraining.txt', 'r')
trainingTime = time.time()
line = f_Training.readline()
for line in f_Training.xreadlines():
allData = line.strip().split(' ')
inputData = [float(x) for x in allData[2:]]
outputData = int(allData[1]) - 1
if outputData == 0:
outputData = 0.1
else:
outputData = 0.9
inData = tuple(inputData)
outData = tuple([outputData])
saidas.append([1, 0, 0, 0])
saidas.append([1, 0, 0, 0])
saidas.append([1, 0, 0, 1])
saidas.append([1, 0, 0, 1])
saidas.append([1, 0, 0, 1])
saidas.append([1, 0, 0, 1])
saidas.append([1, 0, 0, 1])
saidas.append([1, 0, 0, 1])
saidas.append([1, 0, 0, 1])
saidas.append([1, 0, 0, 1])
saidas.append([1, 0, 0, 1])
saidas.append([1, 0, 0, 1])
saidas = np.matrix(saidas)
contador = 0
parametros_entrada = SupervisedDataSet(22, 4)
for entrada in dados_entrada_normatizados:
parametros_entrada.addSample(entrada, saidas[contador])
contador = contador + 1
rede_neural = buildNetwork(22, 10, 4, bias=True, outputbias=True)
treinamento = BackpropTrainer(rede_neural, parametros_entrada, momentum=0.9)
treinamento.trainEpochs(1000)
objeto = WilsonPDI.wocr("../imagens_teste/um.jpg")
atributos_teste = []
atributos_teste.append(objeto.atributos())
x_train = [[0, 0], [0, 1], [1, 0], [1, 1]]
y_train = [[0], [0], [0], [1]]
# OR
x_train = [[0, 0], [0, 1], [1, 0], [1, 1]]
y_train = [[0], [1], [1], [1]]
# XOR
x_train = [[0, 0], [0, 1], [1, 0], [1, 1]]
y_train = [[0], [1], [1], [0]]
# A NEURAL NETWORK IN 11 LINES OF PYTHON (https://iamtrask.github.io/2015/07/12/basic-python-network/)
x_train = [[0, 0, 1], [0, 1, 1], [1, 0, 1], [1, 1, 1]] # input dataset
y_train = [[0], [0], [1], [1]] # output dataset
# Prepare a dataset
input_size = 3
target_size = 1
ds = SupervisedDataSet(input_size, target_size)
ds.setField('input', x_train)
ds.setField('target', y_train)
# Apparently Y needs to be of shape (n,1) as opposed to (n,) so first we reshape it:
#y_train = y_train.reshape(-1, 1)
# And to train a network:
hidden_size = 100 # arbitrarily chosen
net = buildNetwork(input_size, hidden_size, target_size, bias=True)
trainer = BackpropTrainer(net, ds)
trainer.trainUntilConvergence(verbose=True,
validationProportion=0.15,
maxEpochs=1000,
# 建立三层之间的连接 in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) # 将连接加入神经网络 fnn.addConnection(in_to_hidden) fnn.addConnection(hidden_to_out) # 让神经网络可用 fnn.sortModules() from pybrain.supervised.trainers import BackpropTrainer # 定义数据集的格式是三维输入，一维输出 DS = SupervisedDataSet(3,1) # 往数据集内加样本点 # 假设x1，x2，x3是输入的三个维度向量，y是输出向量，并且它们的长度相同 n = 10000 x1 = [] x2 = [] x3 = [] y = [] for i in range(0 , n): x1.append(random.random()) x2.append(random.random()) x3.append(random.randrange(0, 5, 1))
# -*- coding: utf-8 -*-
"""
Created on Fri Nov 17 13:55:09 2017
@author: Administrator
"""
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import LSTMLayer,LinearLayer
net = buildNetwork(3,3,3, hiddenclass=LSTMLayer,outclass=LinearLayer, bias=True, recurrent=True)
dataSet = SupervisedDataSet(3, 3)
dataSet.addSample((0, 0, 0), (0, 0, 0))
dataSet.addSample((1, 1, 1), (0, 0, 0))
dataSet.addSample((1, 0, 0), (1, 0, 0))
dataSet.addSample((0, 1, 0), (0, 1, 0))
dataSet.addSample((0, 0, 1), (0, 0, 1))
trainer = BackpropTrainer(net, dataSet)
trained = False
acceptableError = 0.001
howmanytries = 0
# train until acceptable error reached
while (trained == False) and (howmanytries < 1000):
error = trainer.train()
if error < acceptableError :
trained = True
else:
# coding=utf-8
#! /usr/bin/python
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
fnn = buildNetwork(4, 3, 2, 1, bias=True)
ds = SupervisedDataSet(4, 1)
fin = open("train")
train = []
train_label = []
for line in fin:
line_list = line.strip().split(' ')
if len(line_list) != 5:
continue
a = [line_list[x] for x in range(4)]
b = [line_list[4]]
ds.addSample(a, b)
trainer = BackpropTrainer(fnn, ds)
trainer.train()
fin = open("test")
test = SupervisedDataSet(4, 1)
for line in fin:
line_list = line.strip().split(' ')
if len(line_list) != 5:
continue
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
import os
from PIL import Image
from pybrain import SigmoidLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
NET = buildNetwork(768, 20, 1, bias=True, hiddenclass=SigmoidLayer)
DATASET = SupervisedDataSet(768, 1)
def get_histogram(img_path):
"""
Loads images contaied in an spesific path and returns its histogram.
"""
print 'Processing file: %s' % img_path
img = Image.open(img_path)
histogram = img.histogram()
if len(histogram) != 768:
raise IOError("Image is not in RGB mode.")
else:
return histogram
# -*- coding: utf-8 -*-
'''
@author:Zhukun Luo
Jiangxi university of finance and economics
'''
import numpy as np
import pybrain
from chapter8 import create_trainset
from chapter8.create_trainset import x_train,y_train,x,y,x_test,y_test
from pybrain.datasets import SupervisedDataSet
import chapter8
training= SupervisedDataSet(x.shape[1],y.shape[1])
for i in range(x_train.shape[0]):
training.addSample(x_train[i], y_train[i])
testing= SupervisedDataSet(x.shape[1],y.shape[1])
for i in range(x_test.shape[0]):
training.addSample(x_test[i], y_test[i])
from pybrain.tools.shortcuts import buildNetwork
net= buildNetwork(x.shape[1],100,y.shape[1],bias=True)
from pybrain.supervised.trainers import BackpropTrainer
trainer=BackpropTrainer(net,training,learningrate=0.01,weightdecay=0.01)
trainer.trainEpochs(epochs=20)#固定运行20步
predictions=trainer.testOnClassData(dataset=testing)
from sklearn.metrics import f1_score
print("F-sore:{0:.2f}".format(*f1_score(y_test.argmax((axis=1))),predictions))
print(" Temperature (in K) = " + str(current_temperature) +
"\n atmospheric pressure (in hPa unit) = " + str(current_pressure) +
"\n humidity (in percentage) = " + str(current_humidiy) +
"\n description = " + str(weather_description))
else:
print(" City Not Found ")
# AI - WIP
import simplejson as json
import math
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.tools.xml.networkwriter import NetworkWriter
from pybrain.tools.xml.networkreader import NetworkReader
ds = SupervisedDataSet(9, 3)
data = open("Z:\\sevendata.json", "r").read()
data = json.loads(data)
len = len(data)
for x in range(len):
try:
ds.addSample(
(data[x]["main"]["temp"], data[x]["main"]["humidity"],
data[x]["main"]["pressure"], data[x - 1]["main"]["temp"],
data[x - 1]["main"]["humidity"], data[x - 1]["main"]["pressure"],
data[x - 2]["main"]["temp"], data[x - 2]["main"]["humidity"],
data[x - 2]["main"]["pressure"]),
(data[x + 24]["main"]["temp"], data[x + 48]["main"]["temp"],
data[x + 72]["main"]["temp"]))
N = 10
print 'make network', N, 'neurons'
XYnet = buildNetwork(N, N, N, hiddenclass=TanhLayer)
print 'build Excitator vector field dataset'
def vf(x, mu=0.4):
dx1 = mu * (x[0] - x[0]**3 / 3.0 + x[1]) * 2
dx2 = mu * (1.05 - x[0]) / 2
dxr = -x[2:]
return hstack((dx1, dx2, dxr))
figure()
XYds = SupervisedDataSet(N, N)
for i in range(10):
x = (rand(N) - 0.5) * 4
xs = [x.copy()]
for j in range(500):
dx = vf(x)
XYds.addSample(x.copy(), dx.copy())
x += 0.1 * (dx + randn(N) * 1.0)
xs.append(x.copy())
xs = array(xs)
plot(xs[:, 0], xs[:, 1], 'k', alpha=0.1)
print 'using backprop to train on vector field'
XYtrainer = BackpropTrainer(XYnet, XYds)
i, err = 0, XYtrainer.train()
while err > 0.001 and i < 100:
def load_dataset():
open_filename = tkFileDialog.askopenfilename()
global ds
ds = SupervisedDataSet.loadFromFile(open_filename)
from pybrain.tools.shortcuts import buildNetwork from pybrain.datasets import SupervisedDataSet from pybrain.supervised.trainers import BackpropTrainer ds = SupervisedDataSet(15, 1) ds.addSample((1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1), 1) ds.addSample((0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0), 3) ds.addSample((1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1), 4) ds.addSample((1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1), 5) ds.addSample((1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1), 6) ds.addSample((1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1), 7) ds.addSample((0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0), 8) ds.addSample((0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0), 9) ds.addSample((1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0), 10) ds.addSample((1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1), 11) ds.addSample((0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0), 12) ds.addSample((0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0), 13) ds.addSample((0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0), 14) ds.addSample((0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0), 15) ds.addSample((0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0), 16) ds.addSample((0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0), 17) ds.addSample((1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1), 18) ds.addSample((0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1), 19) ds.addSample((0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1), 20) ds.addSample((0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0), 21) ds.addSample((0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0), 22) ds.addSample((1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1), 23) ds.addSample((0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1), 24) ds.addSample((0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0), 25) ds.addSample((0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0), 26)
l_inputs[l_num] = l_map.add_input("/input/" + str(l_num + int(10)), 1, 'f',
None, 0, 100.0, h)
# l_inputs[l_num]=l_map.add_input("/input/"+str(l_num),'f',h,None,0,100.0)
l_map.poll(0)
print("creating input", "/input/" + str(l_num + int(10)))
# print ("creating input", "/input/"+str(l_num))
#create mapper signals (outputs)
for l_num in range(num_outputs):
# l_outputs[l_num]=l_map.add_output("/output/"+str(l_num+int(10)),'f',None,0,1)
l_outputs[l_num] = l_map.add_output("/output/" + str(l_num), 1, 'f', None,
0, 1)
l_map.poll(0)
# print ("creating output","/output/"+str(l_num+int(10)))
print("creating output", "/output/" + str(l_num))
#create network
#net = buildNetwork(num_inputs,num_hidden,num_outputs,bias=True, hiddenclass=GaussianLayer, outclass=GaussianLayer)
net = buildNetwork(num_inputs, num_hidden, num_outputs, bias=True)
#create dataSet
ds = SupervisedDataSet(num_inputs, num_outputs)
#while (True):
ontimer()
#master.after(500, ontimer)
master.protocol("WM_DELETE_WINDOW", master.quit)
master.mainloop()
master.destroy()
del master
class ANN:
def __init__(self):
self.name = "ANN"
def getParams(self):
return self.in_to_hidden.params, self.hidden_to_out.params
def create_network(self, nFeatures, hidden1Size=20, nClasses=1):
# create network object
self.ffn = FeedForwardNetwork()
# create layer objects
inLayer = LinearLayer(nFeatures, name="input")
hiddenLayer = SigmoidLayer(hidden1Size, name="hidden1")
#hiddenLayer2 = SigmoidLayer(hidden2Size, name="hidden2")
outLayer = LinearLayer(nClasses, name="output")
# add layers to feed forward network
self.ffn.addInputModule(inLayer)
self.ffn.addModule(hiddenLayer)
#self.ffn.addModule(hiddenLayer2)
self.ffn.addOutputModule(outLayer)
# add bias unit to layers
self.ffn.addModule(BiasUnit(name='bias'))
# establish connections between layers
self.in_to_hidden = FullConnection(inLayer, hiddenLayer)
#hidden_to_hidden = FullConnection(hiddenLayer, hiddenLayer2)
self.hidden_to_out = FullConnection(hiddenLayer, outLayer)
# print "into hidden: {}".format(len(in_to_hidden.params))
# print "into out: {}".format(len(hidden_to_out.params))
# add connections to network
self.ffn.addConnection(self.in_to_hidden)
#self.ffn.addConnection(hidden_to_hidden)
self.ffn.addConnection(self.hidden_to_out)
# necessary, sort layers into correct/certain order
self.ffn.sortModules()
# dataset object
self.train_ds = SupervisedDataSet(nFeatures, nClasses)
self.validate_ds = SupervisedDataSet(nFeatures, nClasses)
# train network
def train(self, TrainX, TrainY, ValidateX, ValidateY):
# clear old dataset
self.train_ds.clear()
self.validate_ds.clear()
# add data to dataset object (ds)
for i in range(TrainX.shape[0]):
self.train_ds.addSample(TrainX[i], TrainY[i])
for i in range(ValidateX.shape[0]):
self.validate_ds.addSample(ValidateX[i], ValidateY[i])
# randomiz weights
self.ffn.randomize()
# Backprop trainer object
self.trainer = BackpropTrainer(self.ffn,
learningrate=.0775,
momentum=.1)
try:
with Timer() as t:
self.train_errors, self.val_errors \
= self.trainer.trainUntilConvergence(trainingData=self.train_ds, \
validationData=self.validate_ds, \
maxEpochs=500, \
continueEpochs=10)
return self.train_errors, self.val_errors
except:
print "Error occured while training model in ANN."
#finally:
# print("ANN.py - Time to trainUntilConvergence: {:.03f} sec.".format(t.interval))
#return 'ANN'
# predict depenent variable for dataset
def predict(self, data):
# if only make prediction for one sample
if (len(data.shape) == 1):
return self.ffn.activate(data)
else:
outputs = np.zeros(data.shape[0])
for i in range(data.shape[0]):
outputs[i] = self.ffn.activate(data[i])
return outputs
