def computeModel(self, path, user):
# Create a supervised dataset for training.
trndata = SupervisedDataSet(24, 1)
tstdata = SupervisedDataSet(24, 1)
#Fill the dataset.
for number in range(0,10):
for variation in range(0,7):
# Pass all the features as inputs.
trndata.addSample(self.getSample(user, number, variation),(user.key,))
for variation in range(7,10):
# Pass all the features as inputs.
tstdata.addSample(self.getSample(user, number, variation),(user.key,))
# Build the LSTM.
n = buildNetwork(24, 50, 1, hiddenclass=LSTMLayer, recurrent=True, bias=True)
# define a training method
trainer = BackpropTrainer(n, dataset = trndata, momentum=0.99, learningrate=0.00002)
# carry out the training
trainer.trainOnDataset(trndata, 2000)
valueA = trainer.testOnData(tstdata)
print '\tMSE -> {0:.2f}'.format(valueA)
self.saveModel(n, '.\NeuralNets\SavedNet_%d' %(user.key))
return n
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 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 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 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 pybrain_high():
back=[]
alldate=New_stock.objects.filter().exclude(name='CIHKY')[0:100]
wholelen=len(alldate)
test=New_stock.objects.filter(name__contains="CIHKY")
testlen=len(test)
# test dateset
testdata= SupervisedDataSet(5, 1)
testwhole=newalldate(test,testlen)
for i in testwhole:
testdata.addSample((i[0],i[2],i[3],i[4],i[5]), (0,))
# 实验 dateset
data= SupervisedDataSet(5, 1)
wholedate=newalldate(alldate,wholelen)
for i in wholedate:
data.addSample((i[0],i[2],i[3],i[4],i[5]), (i[1]))
#print testwhole
# 建立bp神经网络
net = buildNetwork(5, 3, 1,bias=True,hiddenclass=TanhLayer, outclass=SoftmaxLayer)
trainer = BackpropTrainer(net,data)
trainer.trainEpochs(epochs=100)
# train and test the network
# print trainer.train()
trainer.train()
print 'ok'
out=net.activateOnDataset(testdata)
for j in test:
back.append((j.high))
print back
print out
backout=backnormal(back,out)
print 'okokokoko'
print backout # 输出22的测试集合
return out
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)
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 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 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 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 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 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 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 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"
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 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 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 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 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
def _build_dataset(self, data):
"""
Given a input training Dataframe with features and targets it returns the formatted training and validation
datasets for pybrain usage, and randomly shuffled according to the self.seed given at instantiation.
----------
data: pandas Dataframe
It must contains both features and target columns
Returns: (pybrain dataset, pybrain dataset)
The first is the training dataset and the second is the validation dataset
"""
np.random.seed(self.seed)
permutation = np.random.permutation(np.arange(len(data)))
sep = int(self.train_fraction * len(data))
x = data[self.features]
y = data[self.targets]
ds_train = SupervisedDataSet(self.n_feature, self.n_target)
ds_valid = SupervisedDataSet(self.n_feature, self.n_target)
for i in permutation[:sep]:
ds_train.addSample(x.values[i], y.values[i])
for i in permutation[sep:]:
ds_valid.addSample(x.values[i], y.values[i])
return ds_train, ds_valid
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 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 handle(self, *args, **options):
better_thans = BetterThan.objects.all() #.filter(pk__lte=50)
ds = SupervisedDataSet(204960, 1)
for better_than in better_thans:
bt = imread(better_than.better_than.image.file)
wt = imread(better_than.worse_than.image.file)
better_than.better_than.image.file.close()
better_than.worse_than.image.file.close()
# bt = filters.sobel(bt)
# wt = filters.sobel(wt)
bt_input_array = np.reshape(bt, (bt.shape[0] * bt.shape[1]))
wt_input_array = np.reshape(wt, (wt.shape[0] * wt.shape[1]))
input_1 = np.append(bt_input_array, wt_input_array)
input_2 = np.append(wt_input_array, bt_input_array)
ds.addSample(np.append(bt_input_array, wt_input_array), [-1])
ds.addSample(np.append(wt_input_array, bt_input_array), [1])
net = buildNetwork(204960, 2, 1)
train_ds, test_ds = ds.splitWithProportion(options['train_test_split'])
_, test_ds = ds.splitWithProportion(options['test_split'])
trainer = BackpropTrainer(net, ds)
print 'Looking for -1: {0}'.format(net.activate(np.append(bt_input_array, wt_input_array)))
print 'Looking for 1: {0}'.format(net.activate(np.append(wt_input_array, bt_input_array)))
trainer.train()
print 'Looking for -1: {0}'.format(net.activate(np.append(bt_input_array, wt_input_array)))
print 'Looking for 1: {0}'.format(net.activate(np.append(wt_input_array, bt_input_array)))
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 __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 train(self, training_files, learningrate=0.01, scaling=True, noise=False, verbose=True):
print "building dataset..."
ds = SupervisedDataSet(SensorModel.array_length(self.sensor_ids), 1)
# read training file line, create sensormodel object, do backprop
a = None
s = None
for logfile in training_files:
print "loading file", logfile
with open(logfile) as f:
for line in f:
if line.startswith("Received:"):
s = SensorModel(string=line.split(' ', 1)[1])
elif line.startswith("Sending:"):
a = Actions.from_string(string=line.split(' ', 1)[1])
if s is not None and a is not None:
ds.addSample(inp=s.get_array(self.sensor_ids), target=a[self.action_ids[0]])
if noise:
# add the same training sample again but with noise in the sensors
s.add_noise()
ds.addSample(inp=s.get_array(self.sensor_ids), target=a[self.action_ids[0]])
s = None
a = None
print "dataset size:", len(ds)
if scaling:
print "scaling dataset"
self.scaler_input = StandardScaler(with_mean=True, with_std=False).fit(ds.data['input'])
ds.data['input'] = self.scaler_input.transform(ds.data['input'])
ds.data['target'] = ds.data['target']
#self.trainer = BackpropTrainer(self.net, learningrate=learningrate, verbose=verbose)
self.trainer = RPropMinusTrainer(self.net, verbose=verbose, batchlearning=True)
print "training network..."
self.trainer.trainUntilConvergence(dataset=ds, validationProportion=0.25, maxEpochs=10, continueEpochs=2)
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 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
]])
ds.setField('target', training['label_tag'])
print("---------------make test data-------------------------------------")
out = SupervisedDataSet(8, 1)
test_item_pre = pd.merge(train_item_df,
test_user_weekiter,
on=['item_id', 'item_category'],
how='inner')
for i_ter in test_item_pre.index:
out.addSample(
test_item_pre.ix[i_ter, [
'cat_view', 'cat_cart', 'cat_mark', 'cat_bought', 'view_tag',
'mark_tag', 'bought_tag', 'cart_tag'
]], 0)
print("--------------predict length------------------------------------")
print(np.shape(test_item_pre)[0])
print("----------------start training-------------------------------------")
trainer = BackpropTrainer(net, ds)
trainer.trainUntilConvergence(maxEpochs=5)
print(
"--------------------predict-----------------------------------------------"
)
pre = net.activateOnDataset(out)
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from pybrain.structure.modules import sigmoidlayer
rede = buildNetwork(2, 3, 1)
# print(rede['in'])
# print(rede['hidden0'])
# print(rede['out'])
# print(rede['bias'])
base = SupervisedDataSet(2, 1)
base.addSample((0, 0), (0, ))
base.addSample((1, 0), (1, ))
base.addSample((0, 1), (1, ))
base.addSample((1, 1), (0, ))
treinamento = BackpropTrainer(rede,
dataset=base,
learningrate=0.01,
momentum=0.06)
for i in range(1, 30000):
erro = treinamento.train()
if i % 1000 == 0:
print('Erro {erro}')
print(rede.activate([0, 0]))
print(rede.activate([1, 0]))
print(rede.activate([0, 1]))
standardizer(enh_array[1:, 3]), standardizer(enh_array[1:, 4]),
standardizer(enh_array[1:, 5])))
#this is meant to
r_lengths = [[i, i + 12] for i in xrange(0, 12 * 100 * 5, 12)]
#print r_lengths[-1]
#print len(enh_array)
#dataset without time
#print enh_array
for j in r_lengths:
temp_data = enh_array[j[0]:j[1]]
for k in xrange(len(temp_data) - 1):
ds2.addSample(
(temp_data[k][0], temp_data[k][1], temp_data[k][2],
temp_data[k][3], temp_data[k][4]),
(temp_data[k + 1][1] - temp_data[k][1], temp_data[k + 1][2] -
temp_data[k][2], temp_data[k + 1][3] - temp_data[k][3]))
#in this one only 4 inputs.
#both types of ANN will be run, and with 1 and 2 hidden layers
net2 = buildNetwork(
5,
20, # number of hidden units
3,
bias=True,
hiddenclass=TanhLayer,
outclass=LinearLayer)
net4 = buildNetwork(
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), (1))
dataset.addSample((1, 0), (0))
dataset.addSample((0, 1), (0))
dataset.addSample((1, 1), (1))
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]))
__author__ = 'rin' from pybrain.tools.shortcuts import buildNetwork from pybrain.datasets import SupervisedDataSet from pybrain.supervised.trainers import BackpropTrainer from pybrain.structure import TanhLayer #2x3x1 #net = buildNetwork(2,3,1) #2 dim in, 1 dim ds = SupervisedDataSet(2, 1) ds.addSample((0, 0), (0, )) ds.addSample((0, 1), (1, )) ds.addSample((1, 0), (1, )) ds.addSample((1, 1), (0, )) ds2 = SupervisedDataSet(2, 1) ds2.addSample((0, 0), (0, )) ds2.addSample((0, 1), (1, )) ds2.addSample((1, 0), (1, )) ds2.addSample((1, 1), (1, )) #for inpt, target in ds: # print inpt, target #print(net.activate([2, 1])) net = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer) net2 = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer) trainer = BackpropTrainer(net, ds) trainer2 = BackpropTrainer(net, ds2) ##trainer.train()
# Load and prepare training and validation files
train_f = 'housing-training.csv'
validation_f = 'housing-validation.csv'
train_data = np.loadtxt(train_f, delimiter=',')
validation_data = np.loadtxt(validation_f, delimiter=',')
data = np.vstack((train_data, validation_data))
X = data[::, :-1] # feature vectors
y = data[::, -1] # target vector
y = y.reshape(-1, 1) # transform shape to (n,1) for training
# Prepare the dataset for pybrain
input_size = len(X[0])
target_size = len(y[0])
ds = SupervisedDataSet(input_size, target_size)
for inpt, target in zip(X, y):
ds.addSample(inpt, target)
# Build the pybrain network
# source (http://pybrain.org/docs/quickstart/network.html)
n_input = 13 # 12 features so 12 input neurons
n_hidden = 100 # Network spec: 100 hidden units
n_output = 1 # 1 target so a single output neuron
net = buildNetwork(n_input, n_hidden, n_output)
# Train the network on the dataset
trainer = BackpropTrainer(net, ds)
for epoch in range(1000):
print(trainer.train())
# Save model via pickle
output_file = 'model.pkl'
print "minim standarized value: %f" % minim d1 = 0 d2= 1 print "normalizando datos..." for d in range(0, 171, 1): normalized_data.append(((standarized_data[d] - minim)* (d2 - d1) / (maxim - minim)) + d1) # print normalized_data # ################################ https://www.mql5.com/es/articles/497 ##################################3 # ################################ http://es.slideshare.net/mentelibre/diseo-y-entrenamiento-de-redes-neuronales-artificiales ##################################3 #creating the data set trainingSet = SupervisedDataSet(6, 1) for i in range(0, 113, 1): trainingSet.addSample((normalized_data[i], normalized_data[i+1], normalized_data[i+2], normalized_data[i+3], normalized_data[i+4], normalized_data[i+5]), (normalized_data[i+6]))#116 tuples # print "trainginSet" # for inpt, target in trainingSet: # print inpt, target ds = SupervisedDataSet(6, 1) for i in range(119, 159, 1): ds.addSample((normalized_data[i], normalized_data[i+1], normalized_data[i+2], normalized_data[i+3], normalized_data[i+4], normalized_data[i+5]), (normalized_data[i+6]))#44 tuples # print "dataset" # for inpt, target in ds: # print inpt, target net = buildNetwork(6, 3, 1, bias = True, hiddenclass = SigmoidLayer)
from __future__ import print_function
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
data_set = SupervisedDataSet(1, 3)
data_set.addSample((0.120, ), [0, 0, 1])
data_set.addSample((0.80, ), [0, 1, 0])
data_set.addSample((0.70, ), [1, 0, 0])
neural_network = buildNetwork(1, 4, 3, bias=True)
trainer = BackpropTrainer(neural_network, data_set)
for i in range(2000):
print(trainer.train())
while True:
param_1 = float(raw_input("Param 1: \n"))
resp = neural_network.activate((param_1, ))
print("FOI: ", resp)
a = lambda x: exp(multiply(-1, sqrt(x)))
b = lambda x: arctan(x)
network1 = buildNetwork(
1, 3,
1) if not isfile("./Q2A.xml") else NetworkReader.readFrom("./Q2A.xml")
network2 = buildNetwork(
1, 3,
1) if not isfile("./Q2B.xml") else NetworkReader.readFrom("./Q2B.xml")
if not isfile("./Q2A.xml"):
NetworkWriter.writeToFile(network1, "./Q2A.xml")
if not isfile("./Q2B.xml"):
NetworkWriter.writeToFile(network2, "./Q2B.xml")
trainingSets1 = SupervisedDataSet(1, 1)
trainingSets2 = SupervisedDataSet(1, 1)
[
trainingSets1.addSample(trainingSetsA[i], a(trainingSetsA[i]))
for i in range(len(trainingSetsA))
]
[
trainingSets2.addSample(trainingSetsB[i], b(trainingSetsB[i]))
for i in range(len(trainingSetsB))
]
trainer1 = BackpropTrainer(network1, trainingSets1, learningrate=0.1)
trainer2 = BackpropTrainer(network2, trainingSets2, learningrate=0.1)
trainer1.trainUntilConvergence()
trainer2.trainUntilConvergence()
trainOutputA = []
trainOutputB = []
validateOutputA = []
validateOutputB = []
errA = []
# Here we define the data model for the XOR function.
# Each sublist [Inputs, Output] consists of the #following tuples: Inputs: (x,y) and Output: (x XOR y).
dataModel = [[(0, 0), (0, )], [(0, 1), (1, )], [(1, 0), (1, )], [(1, 1),
(0, )]]
# Instantiating the Network.
annet = buildNetwork(2, 2, 1, bias=True)
# To view the structure of the Network.
print annet
# Creation of the default dataset for backpropagation.
datset = SupervisedDataSet(2, 1)
for inputs, target in dataModel:
datset.addSample(inputs, target)
# Creation of the training dataset which would be used to train the network till convergence.
training_set = SupervisedDataSet(2, 1)
for iter in xrange(1000):
# Randomly selecting input-output records from the 4 possible, valid inputs for the XOR gate.
rand_val = rnd.randint(0, 3)
inputs, target = dataModel[rand_val]
training_set.addSample(inputs, target)
# Setting up the trainer which utilizes Back-Propagation technique. Here 'datset' simply serves as the default dataset.
# It won't be utilized for training the network.
trainer = BackpropTrainer(annet, datset, learningrate=0.01, momentum=0.9)
# Training the set for 15 max. learning cycles till convergence using training_set as training data.
rapdict.append([str(i), int(syllablesentencecount(str(i))), rhyme_master_list.index(rhymeschemeofsentence(i))])
except Exception:
print "Hm, for some reason we couldn't do anything with this line - remove symbols from it and try again: " + str(i)
dictionarybuilder()
print rapdict
# makes a dataset
ds = SupervisedDataSet(4,4)
# the dataset is in the form of the amount of syllables and rhyme scheme of TWO lines that are next to each other in the song.
for i in rapdict[:-3]:
if i != "" and rapdict[rapdict.index(i) + 1] != "" and rapdict[rapdict.index(i) + 2] != "" and rapdict[rapdict.index(i) + 3] != "":
twobars = [i[1], i[2], rapdict[rapdict.index(i) + 1][1], rapdict[rapdict.index(i) + 1][2], rapdict[rapdict.index(i) + 2][1], rapdict[rapdict.index(i) + 2][2], rapdict[rapdict.index(i) + 3][1], rapdict[rapdict.index(i) + 3][2]]
print twobars
ds.addSample((twobars[0] / float(20), int(twobars[1]) / float(len(rhyme_master_list)), twobars[2] / float(20), int(twobars[3]) / float(len(rhyme_master_list))), (twobars[4] / float(20), int(twobars[5]) / float(len(rhyme_master_list)), twobars[6] / float(20), int(twobars[7]) / float(len(rhyme_master_list))))
print ds
# Only uncomment this if you are training it on lyrics yourself.
# this part gets a neural network, trains it on lyrics and syllables and then saves it.
"""
net = buildNetwork(4,6,6,6,4,recurrent=True)
t = BackpropTrainer(net,learningrate=0.05,momentum=0.5,verbose=True)
t.trainOnDataset(ds,100)
t.testOnData(verbose=True)
fileObject = open('trained_net', 'w')
pickle.dump(net, fileObject)
fileObject.close()
"""
for i in xrange(window_s, window_s + INPUT_LEN):
if prev != 0:
input_rates.append(exchange_rates[i][1] - prev)
else:
input_rates.append(0)
prev = exchange_rates[i][1]
for i in xrange(window_s + INPUT_LEN, window_s + INPUT_LEN + OUTPUT_LEN):
output_rates.append(exchange_rates[i][1])
y_arr = np.array(output_rates)
angle = np.polyfit(x_arr, y_arr, 1)[0]
# print "learn_angle " + str(angle)
# print "add angle" + str(angle)
# print "add input_rates len " + str(len(input_rates))
ds.addSample(input_rates, [angle])
trainer = BackpropTrainer(rnn_net, **parameters)
trainer.setData(ds)
trainer.train()
del ds # release memory
# predict
rnn_net.reset()
dump_fd = open("./rnn_net.dump", "w")
pickle.dump(rnn_net, dump_fd)
### training end
# frslt = open('../test/rnn_result8.csv', 'w')
# Aprovado
for i in range(1, 8, 1):
if i < 10:
nome = "Aprovado/M0" + str(i) + ".wav"
else:
nome = "Aprovado/M" + str(i) + ".wav"
fs, data = wavfile.read(nome)
p = 20 * np.log10(np.abs(np.fft.rfft(data)))
# GraficoDbxFreq(fs,p)
b = p.tolist()
a = []
for j in range(3000):
a = a + [sum(b[(10 * j):(10 * (j + 1))]) / 10]
base.addSample(tuple(a), (1))
# Negado
for i in range(1, 18, 1):
if i < 10:
nome = "Negado/0" + str(i) + ".wav"
else:
nome = "Negado/" + str(i) + ".wav"
fs, data = wavfile.read(nome)
p = 20 * np.log10(np.abs(np.fft.rfft(data)))
#f = np.linspace(0, fs/2.0, len(p))
b = p.tolist()
a = []
for j in range(3000):
a = a + [sum(b[(10 * j):(10 * (j + 1))]) / 10]
from pybrain.structure import TanhLayer
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.tools.shortcuts import buildNetwork
def pesos_conexiones(n):
for mod in n.modules:
for conn in n.connections[mod]:
print conn
for cc in range(len(conn.params)):
print conn.whichBuffers(cc), conn.params[cc]
ds = SupervisedDataSet(2, 1)
ds.addSample((0, 0), 0)
ds.addSample((0, 100), 1)
ds.addSample((1, 0), 1)
ds.addSample((1, 1), 0)
net = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, ds)
print trainer.trainEpochs(1000)
print net['hidden0']
net.activate([2, 1])
print net['hidden0']
print '\n\n\n\n\n'
def random_data(dataset):
ds=SupervisedDataSet(dataset['input'].shape[1], 2)
ds.clear()
for i in np.random.permutation(len(dataset)):
ds.addSample(dataset['input'][i],dataset['target'][i])
return ds
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
neuralNetwork = buildNetwork(25, 15, 10, bias=True)
dataset = SupervisedDataSet(25, 10)
# entenda o 0 e que nao esta pintada e 1 esta pintada
#a rede vai sair analizando aparti dos dados colocados como pintado ou nao pintados , professor observe a imagem la.
dataset.addSample((0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0,
0, 1, 1, 1, 0), (1, 0, 0, 0, 0, 0, 0, 0, 0, 0)) #0
dataset.addSample((0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0,
0, 0, 1, 0, 0), (0, 1, 0, 0, 0, 0, 0, 0, 0, 0)) #1
dataset.addSample((0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0,
0, 1, 1, 1, 0), (0, 0, 1, 0, 0, 0, 0, 0, 0, 0)) #2
dataset.addSample((0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0,
0, 1, 1, 1, 0), (0, 0, 0, 1, 0, 0, 0, 0, 0, 0)) #3
dataset.addSample((0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0,
0, 0, 0, 1, 0), (0, 0, 0, 0, 1, 0, 0, 0, 0, 0)) #4
dataset.addSample((0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0,
0, 1, 1, 1, 0), (0, 0, 0, 0, 0, 1, 0, 0, 0, 0)) #5
dataset.addSample((0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0,
0, 1, 1, 1, 0), (0, 0, 0, 0, 0, 0, 1, 0, 0, 0)) #6
dataset.addSample((0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0,
0, 0, 0, 1, 0), (0, 0, 0, 0, 0, 0, 0, 1, 0, 0)) #7
dataset.addSample((0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0,
0, 1, 1, 1, 0), (0, 0, 0, 0, 0, 0, 0, 0, 1, 0)) #8
dataset.addSample((0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0,
0, 1, 1, 1, 0), (0, 0, 0, 0, 0, 0, 0, 0, 0, 1)) #9
#ai esta a representaçao do numeros
for letter in word:
if letter in voiceless_con:
embedding_data[3] = 1.0
if letter in voiced_con:
embedding_data[4] = 1.0
return embedding_data
train_path = 'training.txt'
train_wordlist, inputs, outputs = load_data(train_path, '\t')
# print(inputs)
# print(outputs)
dataset = SupervisedDataSet(5, 6)
for index in range(len(inputs)):
dataset.addSample(tuple(inputs[index]), tuple(outputs[index]))
network = buildNetwork(5, 6, 6)
trainer = BackpropTrainer(network, dataset)
#
# for j in range(200):
# trainer.train()
err_train, err_valid = trainer.trainUntilConvergence(maxEpochs=500)
plt.plot(err_train, 'b', err_valid, 'r')
plt.show()
# close the plot to continue the program.
test_path = 'test.txt'
test_wordlist, test_input, english_wordlist = load_test(test_path, '\t')
magic5 = [8, 9, 17, 18, 20]
magic6 = [9, 14, 18, 19, 20]
magic7 = [9, 17, 18, 19, 20]
magic8 = [14, 17, 18, 19, 20]
magic9 = [9, 10, 12, 13, 15]
for tuple in data_training_raw:
tuple_data = []
output_tmp1 = []
for i in range(6, 21):
if i == magic1[0] or i == magic1[1] or i == magic1[2] or i == magic1[
3] or i == magic1[4]:
output_tmp1.append(float(tuple[i]))
else:
tuple_data.append(float(tuple[i]))
ds1.addSample(tuple_data, output_tmp1)
for tuple in data_training_raw:
output_tmp2 = []
tuple_data = []
for i in range(6, 21):
if i == magic2[0] or i == magic2[1] or i == magic2[2] or i == magic2[
3] or i == magic2[4]:
#here
output_tmp2.append(float(tuple[i]))
else:
tuple_data.append(float(tuple[i]))
#here #here
ds2.addSample(tuple_data, output_tmp2)
for tuple in data_training_raw:
tuple_data = []
output_tmp3 = []
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure import SigmoidLayer
from pybrain.datasets import SupervisedDataSet
net = buildNetwork(400,25,10,bias=True,hiddenclass=SigmoidLayer)
import numpy
import scipy
from scipy.io import loadmat as loadmat
data = loadmat("ex4data1.mat")
X = data['X']
y = data['y']
ds = SupervisedDataSet(400,10)
for idx,v in enumerate(X):
ds.addSample(v,y[idx] == y[idx][0])
print len(ds),net
trainer = BackpropTrainer(net, ds)
for i in range(100):
print trainer.train()
print net.params,net.params.shape
#print trainer.trainUntilConvergence()
if __name__ == '__main__':
from pylab import figure, show
# --- example on how to use the GP in 1 dimension
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()
print((gp.testOnArray(array([[0.4]]))))
# --- example on how to use the GP in 2 dimensions
class NeuralNet():
def __init__(self, inputDim, outputDim):
'''
Initializes class parameters
Input:
'''
self.inputDimension = inputDim
self.outputDimension = outputDim
self.net = buildNetwork(inputDim, outputDim)
self.ds = SupervisedDataSet(self.inputDimension, self.outputDimension)
print "dimensions : " + str(self.inputDimension) + "x" + str(
self.outputDimension)
def setTheta(self, theta):
self.net._setParameters(theta)
def getTheta(self):
return self.net.params
def loadTheta(self, thetaFile):
self.net._setParameters(np.loadtxt(thetaFile))
#print ("theta LOAD : ", self.net.params)
return self.net.params
def saveTheta(self, fileName):
'''
Records theta under numpy format
Input: -fileName: name of the file where theta will be recorded
'''
np.savetxt(fileName, self.net.params)
def getTrainingData(self):
for i in range(200):
for j in range(200):
output = []
x = i / 200.0
y = j / 200.0
if x > 0.5 and y > 0.5:
output.append(rd.random() / 2 + 1.5)
else:
output.append(rd.random() / 2)
self.ds.addSample([x, y], output)
def getTrainingData2(self):
for i in range(2000):
output = []
x = rd.random()
y = rd.random() / 2.0
if x > 0.5 and y > 0.5:
output.append(rd.random() / 2 + 1.5)
else:
output.append(rd.random() / 2)
self.ds.addSample([x, y], output)
for i in range(1000):
output = []
x = 0.5 + rd.random() / 2.0
y = 0.5 + rd.random() / 2.0
output.append(rd.random() / 2 + 1.5)
self.ds.addSample([x, y], output)
def train(self):
'''
Perform batch regression
'''
self.getTrainingData2()
trainer = BackpropTrainer(self.net, self.ds)
trainer.train()
def computeOutput(self, inputVal):
'''
Returns the output depending on the given input and theta
Input: -inputVal: numpy N-D array
-theta: numpy N-D array
Output: -fa_out: numpy N-D array, output approximated
'''
assert (inputVal.shape[0] == self.inputDimension
), "NeuralNet: Bad input format"
return self.net.activate(inputVal)
else:
d += 1
x = [0.0 for _ in xrange(NUM_FEATURES)]
players = record['players']
for player in players:
hero_id = player['hero_id'] - 1
# If the left-most bit of player_slot is set,
# this player is on dire, so push the index accordingly
player_slot = player['player_slot']
if player_slot >= 128:
hero_id += NUM_HEROES
x[hero_id] = 1.0
ds.addSample(x, y)
y = 1.0 - y
x = [0.0 for _ in xrange(NUM_FEATURES)]
players = record['players']
for player in players:
hero_id = player['hero_id'] - 1
# If the left-most bit of player_slot is set,
# this player is on dire, so push the index accordingly
player_slot = player['player_slot']
if player_slot < 128:
hero_id += NUM_HEROES
x[hero_id] = 1.0
from pybrain.supervised.trainers import BackpropTrainer
import numpy as np
def fresadora(t):
return ((2 / 5) + (1 / 10 * np.e**(-5 * t)) - ((1 / 2) * np.e**(-t)))
ds = SupervisedDataSet(1, 1)
entradasX = np.arange(0, 10, 0.25)
targetsY = fresadora(entradasX)
for k in range(len(entradasX)):
ds.addSample(entradasX[k], targetsY[k])
#buildNetwork(NUMERO DE NEURONIOS NA ENTRADA, NEURONIOS NA CAMADA OCULTA, CAMADA DE SAIDA, bias=True)
#PARAMETERS
neuronsIn = 3 #neuronios na camada de entrada
neuronsHL = 4 # neuronios na camada oculta
neuronsOut = 1 # neuronios na camada de saida
epochs = 200 #epocas
#rede
nn = buildNetwork(3, 3, 1, bias=True)
#trainer
trainer = BackpropTrainer(nn, ds)
>>> for i in range(len(results)):
>>> print data_set['input'][i][0], 'xor', data_set['input'][i][1], '=', int(results[i] > 0.5)
0.0 xor 0.0 = 0
0.0 xor 1.0 = 1
1.0 xor 0.0 = 1
1.0 xor 1.0 = 0
"""
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.tools.shortcuts import buildNetwork
from pybrain.datasets import SupervisedDataSet
from pybrain.structure import SigmoidLayer
network = buildNetwork(2, 5, 1, hiddenclass=SigmoidLayer)
data_set = SupervisedDataSet(2, 1)
data_set.addSample((0, 0), [0])
data_set.addSample((0, 1), [1])
data_set.addSample((1, 0), [1])
data_set.addSample((1, 1), [0])
trainer = BackpropTrainer(module=network,
dataset=data_set,
momentum=0.00,
learningrate=0.10,
weightdecay=0.0,
lrdecay=1.0)
error = 1
epochsToTrain = 0
while error > 0.0001:
epochsToTrain += 1
def end_function(board, lose):
global net
ds = SupervisedDataSet(97, 1)
if lose:
if board.active == BLACK:
ds.addSample(board_to_input(board), 0)
whiteboard = board_to_input(board)
whiteboard[96] = 0
ds.addSample(whiteboard, 1)
elif board.active == WHITE:
ds.addSample(board_to_input(board), 1)
blackboard = board_to_input(board)
blackboard[96] = 1
ds.addSample(blackboard, 0)
else:
#black loses
if board.active == BLACK:
ds.addSample(board_to_input(board), 0)
whiteboard = board_to_input(board)
whiteboard[96] = 0
ds.addSample(whiteboard, 0)
#black wins
elif board.active == WHITE:
ds.addSample(board_to_input(board), 1)
blackboard = board_to_input(board)
blackboard[96] = 1
ds.addSample(blackboard, 1)
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')
low = float(row[5])
nextClose = float(row[6])
#ds.addSample((low,high,opens,close),(nextClose),)
close_n_value = ((close - close_min_Value) /
(close_max_Value - close_min_Value) - 0.5) * 2
volume_n_value = ((volume - volume_min_Value) /
(volume_max_Value - volume_min_Value) - 0.5) * 2
opens_n_value = ((opens - opens_min_Value) /
(opens_max_Value - opens_min_Value) - 0.5) * 2
high_n_value = ((high - high_min_Value) /
(high_max_Value - high_min_Value) - 0.5) * 2
low_n_value = ((low - low_min_Value) /
(low_max_Value - low_min_Value) - 0.5) * 2
nextClose_n_value = ((close - close_min_Value) /
(close_max_Value - close_min_Value) - 0.5) * 2
ds.addSample((low_n_value, high_n_value, opens_n_value, close_n_value),
(nextClose_n_value, ))
print("Dataset Built")
#print(ds)
#for inpt, target in ds:
# print (inpt, target)
#normalize data
trainer = BackpropTrainer(n, ds)
#for i in range(100):
# s = trainer.train()
#trainer.trainUntilConvergence()
trainer.trainUntilConvergence(verbose=True,
# Calculate updated Q-Values
costVector = list(qValues)
if rewardTransition < 0:
costVector[targetDirDiscrete] = rewardTransition
rw = rewardTransition
else:
costVector[targetDirDiscrete] = ALPHA_FACTOR * costVector[
targetDirDiscrete] + (1.0 - ALPHA_FACTOR) * rewardTransition
rw = (1.0 - ALPHA_FACTOR) * rewardTransition
# Learn the updated Q-value.
if isLearning:
ds.clear()
ds.addSample(
(stepStartingPos[0] / XSIZE, stepStartingPos[1] / YSIZE,
math.sin(oldDir * 0.25 * math.pi),
math.cos(oldDir * 0.25 * math.pi)), rw)
trainer.setData(ds)
trainer.trainEpochs(1)
# ====================================
# Final paint step
# ====================================
if pygame.display.get_active():
clock.tick(2)
screen.blit(screenBuffer, (0, 0))
pygame.display.flip()
print "Trainer Alpha Value: ", trainer.descent.alpha
# Let's look at the events. Key presses from 0 to 8 are possible, as well as space for switching between Q values and best direction painting. ESCape ends the program.
for event in pygame.event.get():
X = dataset.reshape((dataset.shape[0], dataset.shape[1] * dataset.shape[2]))
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = \
train_test_split(X, y, train_size=0.9)
plt.savefig("foto2.png")
# Desde acá no da.
from pybrain.datasets import SupervisedDataSet
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]):
testing.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)
predictions = trainer.testOnClassData(dataset=testing)
from sklearn.metrics import f1_score
num = 0
for playerData in fieldData:
isTrue = 0
if player[0] < playerData[1] and decisionRaw[
-4:] == 'left' or player[0] > playerData[
1] and decisionRaw[-4:] == 'ight' or player[
1] < playerData[2] and decisionRaw[
-4:] == 'down' or player[1] > playerData[
2] and decisionRaw[-2:] == 'up':
isTrue = 1
features.append([playerData, isTrue])
dataSet = SupervisedDataSet(InputLayerSize, 1)
for feature in features:
dataSet.addSample(feature[0], feature[1])
Network = buildNetwork(dataSet.indim,
InputLayerSize * 2,
InputLayerSize * 2,
1,
hiddenclass=SigmoidLayer,
outclass=SigmoidLayer,
bias=True)
trainer = BackpropTrainer(Network,
dataSet,
learningrate=0.001,
momentum=0.001)
trainer.trainUntilConvergence()
def getFitness(self, smMatrix): #Store the sm state into memory
fit = 0
#Fitness function (3) *************************************************************
#Record the sm data for this loop and consider its properties
#print(smMatrix)
#print(len(smMatrix))
#net = buildNetwork(3,10,1, bias = True)
net = FeedForwardNetwork()
inp = LinearLayer(3)
h1 = SigmoidLayer(10)
outp = LinearLayer(1)
# add modules
net.addOutputModule(outp)
net.addInputModule(inp)
net.addModule(h1)
# create connections
iToH = FullConnection(inp, h1)
hToO = FullConnection(h1, outp)
net.addConnection(iToH)
net.addConnection(hToO)
# finish up
net.sortModules()
ds = SupervisedDataSet(3, 1)
trainSet = []
for index_x, x in enumerate(smMatrix):
if index_x > 0 and index_x < len(smMatrix) - 1:
#trainSet.append( [smMatrix[index_x][0], smMatrix[index_x][1], smMatrix[index_x][2], smMatrix[index_x+1][3] ] )
ds.addSample(([
smMatrix[index_x][0], smMatrix[index_x][1],
smMatrix[index_x][2]
]), (smMatrix[index_x + 1][3]))
#print(trainSet)
#print(ds)
trainer = BackpropTrainer(net, ds, weightdecay=0.01)
err = trainer.trainUntilConvergence(maxEpochs=50)
#Visualize the network performance and structure.
#nn = NNregression(ds, epoinc = 10)
#nn.setupNN()
#nn.runTraining()
#self.pesos_conexiones(net)
#print("Input to hidden", iToH.params)
#print("H to output", hToO.params)
#print(iToH.params)
n1 = iToH.params
n1a = zip(*[iter(n1)] * 3)
n2 = hToO.params
sums = []
for x in n1a:
sumr = 0
for y in x:
sumr = sumr + abs(y)
sums.append(sumr)
sums2 = []
for x in n2:
sums2.append(abs(x))
#Choose those neurons that have inputs below a threshold value
a1 = [index for index, value in enumerate(sums) if value > 2.0]
a2 = [index for index, value in enumerate(sums2) if value > 0.5]
inter = len(set(a1).intersection(set(a2)))
fit = inter
#fit = sum(n1a[:]) + sum(n2[:])
print fit
return fit
