def __init__(self, features_num, hidden_neurons_num):
super().__init__()
self.is_learning = True
self.features_num = features_num
# self.net = buildNetwork(features_num, hidden_neurons_num, 1, bias = True)
# self.net = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
# self.net = ConvolutionalBoardNetwork(Board.BOARD_SIZE, 5, 3)
# self.trainer = BackpropTrainer(self.net)
self.net_attack = buildNetwork(features_num,
hidden_neurons_num,
hidden_neurons_num,
1,
bias=True)
self.net_defence = buildNetwork(features_num,
hidden_neurons_num,
hidden_neurons_num,
1,
bias=True)
self.trainer_attack = BackpropTrainer(self.net_attack)
self.trainer_defence = BackpropTrainer(self.net_defence)
self.gamma = 0.9
self.errors = []
self.buf = np.zeros(200)
self.buf_index = 0
self.setup()
def begin1():
cbf = readFromCsv("cbf2")
numdataset = np.array(cbf, dtype=np.float64)
#训练数据，验证数据，今天的数据
tgdataset, vadataset, tydata = dataSplit(numdataset)
#归一的参数
gydata, dmean, dstd = gyData(tgdataset)
#验证和今天的数据
gyvadata = calFeature(vadataset, dmean, dstd)
gytydata = calFeature(tydata, dmean, dstd)
#神经网络
trainingset = buildTrainingSet(gydata)
for i in range(1000):
net = buildNetwork(15,
8,
1,
bias=True,
hiddenclass=TanhLayer,
outclass=TanhLayer)
trainer = BackpropTrainer(net, trainingset)
trainer.trainEpochs(epochs=100)
rate = va.calRightRate(gyvadata, net)
if rate > 0.6:
NetworkWriter.writeToFile(
net, '../netv3/zxtx_8l_100t_6_' + str(rate) + ".xml")
print(va.calRightRate(gyvadata, net))
print(va.calRightRate(gytydata, net))
print(str(i) + " times " + str(rate))
# begin1();
def __init__(self,
module,
dataset=None,
learningrate=0.01,
lrdecay=1.0,
momentum=0.,
verbose=False,
batchlearning=False,
weightdecay=0.):
BackpropTrainer.__init__(self, module, dataset, learningrate, lrdecay,
momentum, verbose, batchlearning)
def montaRede(dadosEntrada, dadosSaida):
"""
Função na qual def
:param dadosEntrada: parâmetros de entrada na rede neural
:param dadosSaida: parâmetros de saída da rede neural
:return: retorna a rede de treinamento treinada e os dados supervisionados
"""
entradaTreino = np.concatenate(
(dadosEntrada[:35], dadosEntrada[50:85], dadosEntrada[100:135]))
saidaTreino = np.concatenate(
(dadosSaida[:35], dadosSaida[50:85], dadosSaida[100:135]))
entradaTeste = np.concatenate(
(dadosEntrada[35:50], dadosEntrada[85:100], dadosEntrada[135:]))
saidaTeste = np.concatenate(
(dadosSaida[35:50], dadosSaida[85:100], dadosSaida[135:]))
treinaRede(entradaTreino, saidaTreino)
# criando o dataset de treinamento
# serão 4 dados de entrada
# será um dado de saída
treinamento = treinaRede(entradaTreino, saidaTreino)
# rede neural do tamanho do treinamento
# com 2 neurônios na camada intermediária
# com o dado de output sendo o tamanho da rede
# utilizando bias
redeNeural = buildNetwork(treinamento.indim,
2,
treinamento.outdim,
bias=True)
# criando a rede neural treinada
redeNeuralTreinada = BackpropTrainer(redeNeural,
treinamento,
learningrate=0.3,
momentum=0.9)
for epocas in range(0, 10000):
redeNeuralTreinada.train()
teste = SupervisedDataSet(4, 1)
for i in range(len(entradaTeste)):
teste.addSample(entradaTeste[i], saidaTeste[i])
return redeNeuralTreinada, teste
def train(input, hidden, output, dataset):
"""
Method to build and train a neural network with backpropagation until it converges
:param input: input nodes for network (1)
:param hidden: hidden nodes for network
:param output: output nodes for network (1)
:param dataset: SupervisedDataSet, maps input->output: 1->1, 2->2 ... 8->8
:return: the trained neural network
"""
net = buildNetwork(input, hidden, output, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, dataset, learningrate=0.01)
trainer.trainUntilConvergence(verbose=False, validationProportion=0.15, maxEpochs=1000, continueEpochs=10)
return net
def build_network(self, dataset, new=True, **kwargs):
"""
Builds a neural network using the dataset provided.
Expected keyword args:
- 'hidden_layers'
- 'prediction_window'
- 'learning_rate'
- 'momentum'
"""
self.hidden_layers = kwargs.get('hidden_layers', 3)
self.prediction_window = kwargs.get('prediction_window', 1)
self.learning_rate = kwargs.get('learning_rate', 0.1)
self.momentum = kwargs.get('momentum', 0.01)
if not new:
self.network.sorted = False
self.network.sortModules()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else: raise InvalidNetworkDatasetType()
else:
if self.network_type == FEED_FORWARD_NETWORK:
self.network = buildNetwork(len(self.train_data), self.hidden_layers, 1)
else: raise InvalidNetworkType()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else: raise InvalidNetworkDatasetType()
if self.trainer_type == BACKPROP_TRAINER:
self.trainer = BackpropTrainer(self.network,
learningrate=self.learning_rate,
momentum=self.momentum,
verbose=True)
self.trainer.setData(self.network_dataset)
else: raise InvalidTrainerType()
def get_trained_ann(dataset, ann=None, test_train_prop=0.25, max_epochs=50):
tstdata, trndata = dataset.splitWithProportion(test_train_prop)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
if not ann:
ann = build_ann(trndata.indim, trndata.outdim)
# ann = build_exp_ann(trndata.indim, trndata.outdim)
# trainer = RPropMinusTrainer(ann)
trainer = BackpropTrainer(ann, dataset=trndata,learningrate=0.01, momentum=0.5, verbose=True)
trnresult = tstresult = 0
# for i in range(10):
trainer.trainUntilConvergence(maxEpochs=max_epochs, verbose=True)
trnresult = percentError( trainer.testOnClassData(), trndata['class'] )
tstresult = percentError( trainer.testOnClassData(dataset=tstdata ), tstdata['class'] )
# print trnresult, tstresult
return ann, trnresult, tstresult
def init(self):
self.networks = []
self.trainers = []
self.starting_weights = []
for i in range(self.size): #@UnusedVariable
if self.num_hid2 == 0:
network = buildNetwork(self.num_inp,
self.num_hid1,
self.num_out,
hiddenclass=SigmoidLayer,
bias=True)
else:
network = buildNetwork(self.num_inp,
self.num_hid1,
self.num_hid2,
self.num_out,
hiddenclass=SigmoidLayer,
bias=True)
starting_weights = network.params.copy()
trainer = BackpropTrainer(network,
learningrate=LEARNING_RATE,
momentum=MOMENTUM_LOW,
verbose=False)
self.networks.append(network)
self.trainers.append(trainer)
self.starting_weights.append(starting_weights)
def NetworkTrain(trainDataSet, mnetwork=NetworkBuild(), file='NetworkDump.pkl',maxEpochs=100):
mnetwork = NetworkBuild(new = True)
assert len(mnetwork[0].inmodules) == len(mnetwork[1].keys())
print('DEBUG')
#print(trainDataSet)
print("lens " + str(len(trainDataSet[0][0])) + " " + str(len(mnetwork[0].inmodules)))
# 定义数据集的格式
DS = SupervisedDataSet(len(trainDataSet[0][0]), len(trainDataSet[0][1]))
for itrainDataSet in trainDataSet:
indata = itrainDataSet[0]
outdata = itrainDataSet[1]
DS.addSample(indata, outdata)
# 如果要获得里面的输入／输出时，可以用
# 如果要把数据集切分成训练集和测试集，可以用下面的语句，训练集：测试集＝8:2
# 为了方便之后的调用，可以把输入和输出拎出来
# 训练器采用BP算法
# verbose = True即训练时会把Total error打印出来，库里默认训练集和验证集的比例为4:1，可以在括号里更改
mnetwork[0].sortModules()
trainer = BackpropTrainer(mnetwork[0], DS, verbose=True, learningrate=0.01)
# 0.0575
# maxEpochs即你需要的最大收敛迭代次数，这里采用的方法是训练至收敛，我一般设为1000
trainer.trainUntilConvergence(maxEpochs=maxEpochs)
'''
for mod in mnetwork[0].modules:
print "Module:", mod.name
if mod.paramdim > 0:
print "--parameters:", mod.params
for conn in mnetwork[0].connections[mod]:
print "-connection to", conn.outmod.name
if conn.paramdim > 0:
print "- parameters", conn.params
if hasattr(mnetwork[0], "recurrentConns"):
print "Recurrent connections"
for conn in mnetwork[0].recurrentConns:
print "-", conn.inmod.name, " to", conn.outmod.name
if conn.paramdim > 0:
print "- parameters", conn.params
'''
pickle.dump(mnetwork, open(file, 'wb'))
return mnetwork
def train(self,
dataset,
maxEpochs=10,
learningrate=0.01,
momentum=0.99,
continueEpochs=10,
validationProportion=0.25):
'''trains a network with the given dataset
:param SupervisedDataSet dataset: the training dataset
:param int maxEpochs: max number of iterations to train the network
:parma float learningrate: helps to
:param float momentum: helps out of local minima while training, to get better results
'''
self.trainer = BackpropTrainer(self.net,
learningrate=learningrate,
momentum=momentum)
self.trainer.trainOnDataset(dataset, maxEpochs)
def train(self, x, y, class_number=-1):
self.__class_num = max(np.unique(y).size, class_number)
if max(y) == self.__class_num:
self.__class_zero_indexing = False
y = np.array([i - 1 for i in y])
DS = ClassificationDataSet(x.shape[1], nb_classes=self.__class_num)
DS.setField('input', x)
DS.setField('target', y.reshape(y.size, 1))
DS._convertToOneOfMany()
hidden_num = (DS.indim + DS.outdim) / 2
self.__pybrain_bpnn = buildNetwork(DS.indim, hidden_num, DS.outdim, bias=True, hiddenclass=SigmoidLayer, outclass=SoftmaxLayer)
trainer = BackpropTrainer(self.__pybrain_bpnn, dataset=DS, learningrate=0.07, lrdecay=1.0, momentum=0.6)
trainer.trainUntilConvergence(DS, maxEpochs=30)
def trainConvergence(self, dataset, maxEpochs = 10, learningrate = 0.01, momentum = 0.99, continueEpochs=10, validationProportion=0.25):
'''trains a network with the given dataset nutil it converges
:param SupervisedDataSet dataset: the training dataset
:param int maxEpochs: max number of iterations to train the network
:parma float learningrate: helps to
:param float momentum: helps out of local minima while training, to get better results
'''
self.trainer = BackpropTrainer(self.net, learningrate = learningrate, momentum = momentum)
self.trainer.trainUntilConvergence(dataset, maxEpochs, False, continueEpochs, validationProportion)
def __init__(self, features_num, hidden_neurons_num):
super().__init__()
self.is_learning = True
self.features_num = features_num
# self.net = buildNetwork(features_num, hidden_neurons_num, 1, bias = True)
# self.net = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
# self.net = ConvolutionalBoardNetwork(Board.BOARD_SIZE, 5, 3)
# self.trainer = BackpropTrainer(self.net)
self.net_attack = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
self.net_defence = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
self.trainer_attack = BackpropTrainer(self.net_attack)
self.trainer_defence = BackpropTrainer(self.net_defence)
self.gamma = 0.9
self.errors = []
self.buf = np.zeros(200)
self.buf_index = 0
self.setup()
def train(self, players=2, games=300, epochs=50, print_fitness=False):
"""
nn = Coup_NN()
nn.train(2, print_fitness=True)
"""
from pybrain.tools.shortcuts import buildNetwork
from pybrain import SigmoidLayer
from pybrain.supervised.trainers.backprop import BackpropTrainer
from pybrain.datasets import SupervisedDataSet
from simulations import simulations
from collections import Counter
INPUT_NEURONS_PER_PLAYER = 5
OUTPUT_NEURONS = 5
HIDDEN_NEURONS = 10
ds = SupervisedDataSet(players * INPUT_NEURONS_PER_PLAYER, OUTPUT_NEURONS)
self.NETS[players] = buildNetwork(players * INPUT_NEURONS_PER_PLAYER, HIDDEN_NEURONS, OUTPUT_NEURONS, bias=True, outputbias= True, hiddenclass=SigmoidLayer)
trainer = BackpropTrainer(self.NETS[players], ds, learningrate= 0.1)
WINS = []
POSITIONS = []
for _ in range(games):
game_result = simulations.duel(Play_Coup(2))
WINS.append(game_result.winner.alpha)
POSITIONS.append(game_result.influence_binary)
ds.addSample(game_result.influence_binary, game_result.winner.influence_binary)
trainer.trainEpochs(epochs)
if print_fitness:
norm_results = dict(Counter(WINS).most_common())
nn_results = dict(Counter(self.game_winner(self.NETS[players].activate(p)) for p in POSITIONS).most_common())
print(''.ljust(25), 'normal', 'nn')
for pair in set(nn_results.keys() + norm_results.keys()):
print(pair.ljust(25), str(norm_results.get(pair,0)).ljust(6), str(nn_results.get(pair,0)).ljust(6))
with open('coup_nn-{0}'.format(players), 'w') as neunet:
pickle.dump(self.NETS[players], neunet)
def main ( ) :
# criando os dados para treino
datasetTreino = montaDados ()
# criando os dados para teste
datasetTeste = montaDados()
# definindo a estrutura de como será a rede neural
# a entrada será a dimensão de entrada do dataset = 3
# terá 6 neurônios na primeira camada intermediária
# terá 6 neurônios na segunda camada escondida
# terá como dimensão de saída o tamanho do dado de saída = 1
# terá a função de autocorreção para melhor adaptação da rede
network = buildNetwork( datasetTreino.indim, 12, 6, datasetTreino.outdim, bias=True )
# criando a rede neural
# terá como estrutura de rede neural definida no objeto network
# utilizará os dados do dataset para treino
neuralNetwork = BackpropTrainer ( network, datasetTreino, learningrate=0.01, momentum=0.9 )
# treinando a rede
neuralNetwork.trainEpochs ( 1500 )
# validando a rede
neuralNetwork.testOnData ( datasetTeste, verbose=True )
def main():
# criando o dataset, onde os dados de entrada no dataset será um vetor de tamanho 2
# e o dado de saída será um escalar
dataset = SupervisedDataSet(2, 1)
criandoDataset(dataset)
# criando a rede neural
# onde terá, respectivamente, a quantidade de entrada na rede
# quantidade de neurônios na camada intermediária
# dimensão de saída da rede
# utilizando uma adaptação da rede ao longo do tempo
network = buildNetwork(dataset.indim, 4, dataset.outdim, bias=True)
# criando o método de treino da rede
# passando a rede
# passando o dataset
# passando a taxa de aprendizado
# aumentando o cálculo que maximiza o treinamento da rede
trainer = BackpropTrainer(network,
dataset,
learningrate=0.01,
momentum=0.99)
# looping que faz o treino da função
for epocas in range(0, 1000):
trainer.train()
# realizando o teste
datasetTeste = SupervisedDataSet(2, 1)
criandoDataset(datasetTeste)
trainer.testOnData(datasetTeste, verbose=True)
def train(network_file, input_length, output_length, training_data_file,
learning_rate, momentum, stop_on_convergence, epochs, classify):
n = get_network(network_file)
if classify:
ds = ClassificationDataSet(int(input_length),
int(output_length) * 2)
ds._convertToOneOfMany()
else:
ds = SupervisedDataSet(int(input_length), int(output_length))
training_data = get_training_data(training_data_file)
NetworkManager.last_training_set_length = 0
for line in training_data:
data = [float(x) for x in line.strip().split(',') if x != '']
input_data = tuple(data[:(int(input_length))])
output_data = tuple(data[(int(input_length)):])
ds.addSample(input_data, output_data)
NetworkManager.last_training_set_length += 1
t = BackpropTrainer(n,
learningrate=learning_rate,
momentum=momentum,
verbose=True)
print "training network " + network_storage_path + network_file
if stop_on_convergence:
t.trainUntilConvergence(ds, epochs)
else:
if classify:
t.trainOnDataset(ds['class'], epochs)
else:
t.trainOnDataset(ds, epochs)
error = t.testOnData()
print "training done"
if not math.isnan(error):
save_network(n, network_file)
else:
print "error occured, network not saved"
print "network saved"
return error
def build_network(self, dataset, new=True, **kwargs):
"""
Builds a neural network using the dataset provided.
Expected keyword args:
- 'hidden_layers'
- 'prediction_window'
- 'learning_rate'
- 'momentum'
"""
self.hidden_layers = kwargs.get('hidden_layers', 3)
self.prediction_window = kwargs.get('prediction_window', 1)
self.learning_rate = kwargs.get('learning_rate', 0.1)
self.momentum = kwargs.get('momentum', 0.01)
if not new:
self.network.sorted = False
self.network.sortModules()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else:
raise InvalidNetworkDatasetType()
else:
if self.network_type == FEED_FORWARD_NETWORK:
self.network = buildNetwork(len(self.train_data),
self.hidden_layers, 1)
else:
raise InvalidNetworkType()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else:
raise InvalidNetworkDatasetType()
if self.trainer_type == BACKPROP_TRAINER:
self.trainer = BackpropTrainer(self.network,
learningrate=self.learning_rate,
momentum=self.momentum,
verbose=True)
self.trainer.setData(self.network_dataset)
else:
raise InvalidTrainerType()
def __init__(self, **kwargs):
self.max_depth = 0
self.stats = {}
self.calculation_time = float(kwargs.get('time', 1))
self.max_moves = int(kwargs.get('max_moves', Board.BOARD_SIZE_SQ))
# Exploration constant, increase for more exploratory moves,
# decrease to prefer moves with known higher win rates.
self.C = float(kwargs.get('C', 1.4))
self.features_num = Board.BOARD_SIZE_SQ * 3 + 2
self.hidden_neurons_num = self.features_num * 2
self.net = buildNetwork(self.features_num,
self.hidden_neurons_num,
2,
bias=True,
outclass=SigmoidLayer)
self.trainer = BackpropTrainer(self.net)
self.total_sim = 0
self.observation = []
def begin2():
cbf = readFromCsv("cbf2")
numdataset = np.array(cbf, dtype=np.float64)
#训练数据，验证数据，今天的数据
tgdataset, vadataset, tydata = dataSplit(numdataset)
#归一的参数
gydata, dmean, dstd = gyData(tgdataset)
#验证和今天的数据
gyvadata = calFeature(vadataset, dmean, dstd)
gytydata = calFeature(tydata, dmean, dstd)
tset = buildTrainingSet(gyvadata)
net = NetworkReader.readFrom("../netv3/zxtx_8l_100t_6_0.785714285714.xml")
trainer = BackpropTrainer(net, tset)
trainer.trainEpochs(epochs=100)
li = []
for ele in gytydata[0]:
li.append(ele)
print(dec2int(net.activate(li[:-1])))
def main():
print "Calculating mfcc...."
mfcc_coeff_vectors_dict = {}
for i in range(1, 201):
extractor = FeatureExtractor(
'/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Happiness/HappinessAudios/' + str(i) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
for i in range(201, 401):
extractor = FeatureExtractor(
'/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Sadness/SadnessAudios/' + str(i - 200) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
audio_with_min_frames, min_frames = get_min_frames_audio(
mfcc_coeff_vectors_dict)
processed_mfcc_coeff = preprocess_input_vectors(
mfcc_coeff_vectors_dict, min_frames)
# frames = min_frames
# print frames
# print len(processed_mfcc_coeff['1'])
# for each_vector in processed_mfcc_coeff['1']:
# print len(each_vector)
print "mffcc found..."
classes = ["happiness", "sadness"]
training_data = ClassificationDataSet(
26, target=1, nb_classes=2, class_labels=classes)
# training_data = SupervisedDataSet(13, 1)
try:
network = NetworkReader.readFrom(
'network_state_frame_level_new2_no_pp1.xml')
except:
for i in range(1, 51):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
for each_vector in mfcc_coeff_vectors:
training_data.appendLinked(each_vector, [1])
for i in range(201, 251):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
for each_vector in mfcc_coeff_vectors:
training_data.appendLinked(each_vector, [0])
training_data._convertToOneOfMany()
print "prepared training data.."
print training_data.indim, training_data.outdim
network = buildNetwork(
training_data.indim, 5, training_data.outdim, fast=True)
trainer = BackpropTrainer(network, learningrate=0.01, momentum=0.99)
print "Before training...", trainer.testOnData(training_data)
trainer.trainOnDataset(training_data, 1000)
print "After training...", trainer.testOnData(training_data)
NetworkWriter.writeToFile(
network, "network_state_frame_level_new2_no_pp.xml")
def main():
print "Calculating mfcc...."
mfcc_coeff_vectors_dict = {}
for i in range(1, 201):
extractor = FeatureExtractor('/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Happiness/HappinessAudios/' + str(i) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
for i in range(201, 401):
extractor = FeatureExtractor('/home/venkatesh/Venki/FINAL_SEM/Project/Datasets/Sadness/SadnessAudios/' + str(i - 200) + '.wav')
mfcc_coeff_vectors = extractor.calculate_mfcc()
mfcc_coeff_vectors_dict.update({str(i): (mfcc_coeff_vectors, mfcc_coeff_vectors.shape[0])})
audio_with_min_frames, min_frames = get_min_frames_audio(mfcc_coeff_vectors_dict)
processed_mfcc_coeff = preprocess_input_vectors(mfcc_coeff_vectors_dict, min_frames)
frames = min_frames
print "mfcc found...."
classes = ["happiness", "sadness"]
try:
network = NetworkReader.readFrom('network_state_new_.xml')
except:
# Create new network and start Training
training_data = ClassificationDataSet(frames * 26, target=1, nb_classes=2, class_labels=classes)
# training_data = SupervisedDataSet(frames * 39, 1)
for i in range(1, 151):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
training_data.appendLinked(mfcc_coeff_vectors.ravel(), [1])
# training_data.addSample(mfcc_coeff_vectors.ravel(), [1])
for i in range(201, 351):
mfcc_coeff_vectors = processed_mfcc_coeff[str(i)]
training_data.appendLinked(mfcc_coeff_vectors.ravel(), [0])
# training_data.addSample(mfcc_coeff_vectors.ravel(), [0])
training_data._convertToOneOfMany()
network = buildNetwork(training_data.indim, 5, training_data.outdim)
trainer = BackpropTrainer(network, learningrate=0.01, momentum=0.99)
print "Before training...", trainer.testOnData(training_data)
trainer.trainOnDataset(training_data, 1000)
print "After training...", trainer.testOnData(training_data)
NetworkWriter.writeToFile(network, "network_state_new_.xml")
print "*" * 30 , "Happiness Detection", "*" * 30
for i in range(151, 201):
output = network.activate(processed_mfcc_coeff[str(i)].ravel())
# print output,
# if output > 0.7:
# print "happiness"
class_index = max(xrange(len(output)), key=output.__getitem__)
class_name = classes[class_index]
print class_name
def __init__(self, **kwargs):
self.max_depth = 0
self.stats = {}
self.calculation_time = float(kwargs.get('time', 1))
self.max_moves = int(kwargs.get('max_moves', Board.BOARD_SIZE_SQ))
# Exploration constant, increase for more exploratory moves,
# decrease to prefer moves with known higher win rates.
self.C = float(kwargs.get('C', 1.4))
self.features_num = Board.BOARD_SIZE_SQ * 3 + 2
self.hidden_neurons_num = self.features_num * 2
self.net = buildNetwork(self.features_num, self.hidden_neurons_num, 2, bias=True, outclass=SigmoidLayer)
self.trainer = BackpropTrainer(self.net)
self.total_sim = 0
self.observation = []
def fit(self, inp, y, sample_weight=None):
self.classes_, y = numpy.unique(y, return_inverse=True)
self.n_classes_ = len(self.classes_)
n_features = inp.shape[1]
random_state = check_random_state(self.random_state)
# We need to build an ImportanceDataSet from inp, y and sample_weight
dataset = ImportanceDataSet(n_features, self.n_classes_)
if sample_weight is None:
sample_weight = numpy.ones(len(y))
for x, label_pos, weight in izip(inp, y, sample_weight):
target = numpy.zeros(self.n_classes_)
target[label_pos] = 1
weight = weight * numpy.ones(self.n_classes_)
dataset.newSequence()
dataset.addSample(x, target, weight)
if self.hidden_neurons is None:
hidden_neurons = (n_features + self.n_classes_)/2
else:
hidden_neurons = self.hidden_neurons
self.network_ = buildNetwork(
n_features, hidden_neurons, self.n_classes_,
outclass=self._get_output_class()
)
# Set the initial parameters in a repeatable way
net_params = random_state.random_sample(self.network_.paramdim)
self.network_.params[:] = net_params
self.trainer_ = BackpropTrainer(
self.network_, dataset=dataset, learningrate=self.learning_rate,
lrdecay=self.lr_decay, momentum=self.momentum,
weightdecay=self.weight_decay
)
self.trainer_.trainUntilConvergence(
random_state, maxEpochs=self.max_epochs,
continueEpochs=self.continue_epochs,
validationProportion=self.validation_percent
)
return self
def get_trained_ann(dataset, ann=None, test_train_prop=0.25, max_epochs=50):
tstdata, trndata = dataset.splitWithProportion(test_train_prop)
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
if not ann:
ann = build_ann(trndata.indim, trndata.outdim)
# ann = build_exp_ann(trndata.indim, trndata.outdim)
# trainer = RPropMinusTrainer(ann)
trainer = BackpropTrainer(ann,
dataset=trndata,
learningrate=0.01,
momentum=0.5,
verbose=True)
trnresult = tstresult = 0
# for i in range(10):
trainer.trainUntilConvergence(maxEpochs=max_epochs, verbose=True)
trnresult = percentError(trainer.testOnClassData(), trndata['class'])
tstresult = percentError(trainer.testOnClassData(dataset=tstdata),
tstdata['class'])
# print trnresult, tstresult
return ann, trnresult, tstresult
testdata, traindata = alldata.splitWithProportion(0.25)
testdata._convertToOneOfMany()
traindata._convertToOneOfMany()
print("data dimensions ", len(traindata), traindata.indim, testdata.indim)
print("sample test data input", traindata['input'][0])
print("sample test data target", traindata['target'][0])
print("sample test data class", traindata["class"][0])
#for key in traindata.data:
# print(key)
fnn = buildNetwork(traindata.indim, 5, traindata.outdim, outclass = SoftmaxLayer)
trainer = BackpropTrainer(fnn, dataset=traindata, momentum=0.1, verbose=True, weightdecay=0.01)
ticks = arange(-3., 6., 0.2)
X, Y = meshgrid(ticks, ticks)
griddata = ClassificationDataSet(2, 1, nb_classes=3)
for i in range(X.size):
griddata.addSample([X.ravel()[i],Y.ravel()[i]], [0])
griddata._convertToOneOfMany()
for i in range(20):
trainer.trainEpochs(1) # usually 5
trainresult = percentError(trainer.testOnClassData(), traindata["class"])
testresult = percentError(trainer.testOnClassData(), testdata["class"])
from pybrain.datasets.supervised import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure.modules.tanhlayer import TanhLayer
from pybrain.supervised.trainers.backprop import BackpropTrainer
from pybrain.supervised.trainers.mixturedensity import BackpropTrainerMix
def printNetResult(identifier, net):
print(identifier, net.activate((0, 0)), net.activate((0, 1)), net.activate((1, 0)), net.activate((1, 1)))
ds = SupervisedDataSet(2,1)
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
for input, target in ds:
print(input, target)
#net = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)#1000
# net = buildNetwork(2, 6, 1, bias=True) # 3000
net = buildNetwork(2, 3, 1, bias=True)
trainer = BackpropTrainer(net, ds)
for i in range(20):
for j in range(1000):
trainer.train()
printNetResult(i, net)
net.addModule(hiddenLayer0)
net.addModule(hiddenLayer1)
net.addOutputModule(outLayer)
in_to_hidden0 = FullConnection(inLayer, hiddenLayer0)
hidden0_to_hidden1 = FullConnection(hiddenLayer0, hiddenLayer1)
hidden1_to_out = FullConnection(hiddenLayer1, outLayer)
net.addConnection(in_to_hidden0)
net.addConnection(hidden0_to_hidden1)
net.addConnection(hidden1_to_out)
net.sortModules()
#net = buildNetwork(2, 4, 3, 1, bias=True, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, ds, verbose = True, learningrate=0.01)
#trainer = BackpropTrainer(net, ds)
net_output_file = open("hw1data.net",'w')
print net
print >> net_output_file, net
for mod in net.modules:
print "Module:", mod.name
print >> net_output_file,"Module:", mod.name
if mod.paramdim > 0:
print "--parameters:", mod.params
print >> net_output_file, "--parameters:", mod.params
for conn in net.connections[mod]:
print >> net_output_file, "-connection to", conn.outmod.name
denorm_output = []
# prediction = [[],[],[]]
prediction = []
training_normalization(args.f1,args.min,args.max)
#initialize dataset for neural network with 5 input + bias and 3 target
DS = SupervisedDataSet(5,1)
#adding datasets to the network
for i in range (0,len(normal_array[0])):
# DS.addSample([normal_array[0][i],normal_array[1][i],normal_array[2][i],normal_array[3][i],normal_array[4][i]],[normal_array[5][i],normal_array[6][i],normal_array[7][i]])
DS.addSample([normal_array[0][i],normal_array[1][i],normal_array[2][i],normal_array[3][i],normal_array[4][i]],[normal_array[5][i]])
# NN = buildNetwork(5,4,3,bias =True,hiddenclass=TanhLayer)
NN = buildNetwork(DS.indim,5,DS.outdim,bias = True,hiddenclass=TanhLayer)
TRAINER = BackpropTrainer(NN,dataset=DS,learningrate = 0.01,momentum = 0.99)
print 'MSE before',TRAINER.testOnData(DS)
TRAINER.trainOnDataset(DS,500)
print 'MSE after',TRAINER.testOnData(DS)
# testing
#clearing arrays
normal_array = [[],[],[],[],[],[],[],[]]
normalized_input = [[],[],[],[],[]]
max_array = [[],[],[],[],[],[],[],[]]
min_array = [[],[],[],[],[],[],[],[]]
range_array = [[],[],[],[],[],[],[],[]]
x_axis = []
pred_arr = []
act_arr = []
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers.backprop import BackpropTrainer
from odyseus_model import OdyseusRecursiveTwoThrusters
import numpy as np
import optparse
from tools.common_run import add_common_options
if __name__ == "__main__":
usage = "python run_pretrain.py resulting_file.neu \n this script pretrain net of model described in|" \
" OdyseusRecursiveTwoThrusters, for 5 input nodes. Resulting network is saved to desired file"
parser = optparse.OptionParser(usage=usage)
opts, args = parser.parse_args()
ds = SupervisedDataSet(5, 2)
ds.addSample((50,50,50,0,0),(0,1))
ds.addSample((0,50,50,50,0),(1,1))
ds.addSample((0,0,50,0,0), (1,1))
ds.addSample((0,0,50,50,50),(1,0))
net = OdyseusRecursiveTwoThrusters.random_net()
trainer = BackpropTrainer(net, ds)
trainer.trainEpochs(3600)
np.savetxt(args[0], trainer.module.params, delimiter=',')
class NeuralNetwork(object):
"""
The neural network class does all the heavy lifting to incorporate pybrain
neural networks into the NowTrade ecosystem.
"""
def __init__(self, train_data, prediction_data, network_type=FEED_FORWARD_NETWORK,
network_dataset_type=SUPERVISED_DATASET,
trainer_type=BACKPROP_TRAINER):
self.train_data = train_data
self.prediction_data = prediction_data
self.network_type = network_type
self.network_dataset_type = network_dataset_type
self.trainer_type = trainer_type
self.network = None
self.network_dataset = None
self.dataset = None
self.trainer = None
self.trained_iterations = 0
self.momentum = None
self.learning_rate = None
self.hidden_layers = None
self.prediction_window = None
self.logger = logger.Logger(self.__class__.__name__)
self.logger.info('train_data: %s prediction_data: %s, network_type: %s, \
network_dataset_type: %s, trainer_type: %s'
%(train_data, prediction_data, network_type, \
network_dataset_type, trainer_type))
def save(self):
"""
Returns the pickled trained/tested neural network as a string.
"""
return cPickle.dumps(self)
def save_to_file(self, filename):
"""
Saves a neural network to file for later use.
Look into pybrain.datasets.supervised.SupervisedDataSet.saveToFile()
http://pybrain.org/docs/api/datasets/superviseddataset.html
"""
file_handler = open(filename, 'wb')
cPickle.dump(self, file_handler)
file_handler.close()
def build_network(self, dataset, new=True, **kwargs):
"""
Builds a neural network using the dataset provided.
Expected keyword args:
- 'hidden_layers'
- 'prediction_window'
- 'learning_rate'
- 'momentum'
"""
self.hidden_layers = kwargs.get('hidden_layers', 3)
self.prediction_window = kwargs.get('prediction_window', 1)
self.learning_rate = kwargs.get('learning_rate', 0.1)
self.momentum = kwargs.get('momentum', 0.01)
if not new:
self.network.sorted = False
self.network.sortModules()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else: raise InvalidNetworkDatasetType()
else:
if self.network_type == FEED_FORWARD_NETWORK:
self.network = buildNetwork(len(self.train_data), self.hidden_layers, 1)
else: raise InvalidNetworkType()
if self.network_dataset_type == SUPERVISED_DATASET:
self.ready_supervised_dataset(dataset)
else: raise InvalidNetworkDatasetType()
if self.trainer_type == BACKPROP_TRAINER:
self.trainer = BackpropTrainer(self.network,
learningrate=self.learning_rate,
momentum=self.momentum,
verbose=True)
self.trainer.setData(self.network_dataset)
else: raise InvalidTrainerType()
def ready_supervised_dataset(self, dataset):
"""
Ready the supervised dataset for training.
@TODO: Need to randomize the data being fed to the network.
See randomBatches() here: http://pybrain.org/docs/api/datasets/superviseddataset.html
"""
self.network_dataset = SupervisedDataSet(len(self.train_data), 1)
# Currently only supports log function for normalizing data
training_values = np.log(dataset.data_frame[self.train_data])
results = np.log(dataset.data_frame[self.prediction_data].shift(-self.prediction_window))
training_values['PREDICTION_%s' %self.prediction_data[0]] = results
training_values = training_values.dropna()
for _, row_data in enumerate(training_values.iterrows()):
_, data = row_data
sample = list(data[:-1])
result = [data[-1]]
self.network_dataset.addSample(sample, result)
def train(self, cycles=1):
"""
Trains the network the number of iteration specified in the cycles parameter.
"""
for _ in range(cycles):
res = self.trainer.train()
self.trained_iterations += 1
return res
def train_until_convergence(self, max_cycles=1000, continue_cycles=10,
validation_proportion=0.25):
"""
Wrapper around the pybrain BackpropTrainer trainUntilConvergence method.
@see: http://pybrain.org/docs/api/supervised/trainers.html
"""
self.trainer = \
self.trainer.trainUntilConvergence(maxEpochs=max_cycles,
continueEpochs=continue_cycles,
validationProportion=validation_proportion)
def _activate(self, data):
"""
Activates the network using the data specified.
Returns the network's prediction.
"""
return self.network.activate(data)[0]
def activate_all(self, data_frame):
"""
Activates the network for all values in the dataframe specified.
"""
dataframe = np.log(data_frame[self.train_data])
res = []
for _, row_data in enumerate(dataframe.iterrows()):
_, data = row_data
sample = list(data)
res.append(self._activate(sample))
return np.exp(res)
min_max_scaler = preprocessing.MinMaxScaler()
train_data = min_max_scaler.fit_transform(train_data)
#Create the training data
D = SupervisedDataSet(len(train_data[0]), 1) #input, target
for counter, item in enumerate(train_data):
D.addSample(train_data[counter], answer[counter])
#print D['target']
#Create the NN
N = buildNetwork(len(train_data[0]), 200, 1, bias=True) #152 76=(152+1)/2
#Train the NN with backpropagation
T = BackpropTrainer(N, D, learningrate=0.1, momentum=0.9)
i = 0
error = []
time_before = time.time()
while i < 50 and T.testOnData(D) > 0.001:
errordata = T.testOnData(D)
if i % 1 == 0:
print i, '\tMSE:', round(errordata, 6), '\tTime:', round(
time.time() - time_before, 6)
#Store the error in a list to plot
error.append(errordata)
T.train()
#Create the training data
D = SupervisedDataSet(len(train_data[0]),1) #input, target
for counter,item in enumerate(train_data):
D.addSample(train_data[counter], answer[counter])
#print D['target']
#Create the NN
N = buildNetwork(len(train_data[0]),200,1, bias=True) #152 76=(152+1)/2
#Train the NN with backpropagation
T = BackpropTrainer(N, D, learningrate = 0.1, momentum = 0.9)
i=0
error = []
time_before = time.time()
while i < 50 and T.testOnData(D) > 0.001:
errordata = T.testOnData(D)
if i % 1 == 0:
print i, '\tMSE:', round(errordata,6), '\tTime:', round(time.time()-time_before,6)
#Store the error in a list to plot
error.append(errordata)
T.train()
i += 1
training_normalization(args.f1, args.min, args.max)
#initialize dataset for neural network with 5 input + bias and 3 target
DS = SupervisedDataSet(5, 1)
#adding datasets to the network
for i in range(0, len(normal_array[0])):
# DS.addSample([normal_array[0][i],normal_array[1][i],normal_array[2][i],normal_array[3][i],normal_array[4][i]],[normal_array[5][i],normal_array[6][i],normal_array[7][i]])
DS.addSample([
normal_array[0][i], normal_array[1][i], normal_array[2][i],
normal_array[3][i], normal_array[4][i]
], [normal_array[5][i]])
# NN = buildNetwork(5,4,3,bias =True,hiddenclass=TanhLayer)
NN = buildNetwork(DS.indim, 5, DS.outdim, bias=True, hiddenclass=TanhLayer)
TRAINER = BackpropTrainer(NN, dataset=DS, learningrate=0.01, momentum=0.99)
print 'MSE before', TRAINER.testOnData(DS)
TRAINER.trainOnDataset(DS, 500)
print 'MSE after', TRAINER.testOnData(DS)
# testing
#clearing arrays
normal_array = [[], [], [], [], [], [], [], []]
normalized_input = [[], [], [], [], []]
max_array = [[], [], [], [], [], [], [], []]
min_array = [[], [], [], [], [], [], [], []]
range_array = [[], [], [], [], [], [], [], []]
x_axis = []
pred_arr = []
act_arr = []
net.addModule(hiddenLayer0)
net.addModule(hiddenLayer1)
net.addOutputModule(outLayer)
in_to_hidden0 = FullConnection(inLayer, hiddenLayer0)
hidden0_to_hidden1 = FullConnection(hiddenLayer0, hiddenLayer1)
hidden1_to_out = FullConnection(hiddenLayer1, outLayer)
net.addConnection(in_to_hidden0)
net.addConnection(hidden0_to_hidden1)
net.addConnection(hidden1_to_out)
net.sortModules()
#net = buildNetwork(2, 4, 3, 1, bias=True, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, ds, verbose=True, learningrate=0.01)
#trainer = BackpropTrainer(net, ds)
net_output_file = open("hw1data.net", 'w')
print net
print >> net_output_file, net
for mod in net.modules:
print "Module:", mod.name
print >> net_output_file, "Module:", mod.name
if mod.paramdim > 0:
print "--parameters:", mod.params
print >> net_output_file, "--parameters:", mod.params
for conn in net.connections[mod]:
print >> net_output_file, "-connection to", conn.outmod.name
def ANN(
trainFeature, trainLabel, testFeature, testLabel, netStructure, para_rate, para_momentum
): # netStructure is a list [in, hidden, out], momentum is a parameter in SGD
sampleNum = trainFeature.shape[0]
featureNum = trainFeature.shape[1]
Dataset = SupervisedDataSet(featureNum, 1)
i = 0
while i < sampleNum:
print(i)
Dataset.addSample(list(trainFeature[i]), [trainLabel[i]])
i += 1
Network = buildNetwork(
netStructure[0],
netStructure[1],
netStructure[2],
netStructure[3],
hiddenclass=SigmoidLayer,
outclass=SigmoidLayer,
)
T = BackpropTrainer(Network, Dataset, learningrate=para_rate, momentum=para_momentum, verbose=True)
# print(Dataset['input'])
errorList = []
errorList.append(T.testOnData(Dataset))
T.trainOnDataset(Dataset)
errorList.append(T.testOnData(Dataset))
T.trainOnDataset(Dataset)
while abs(T.testOnData(Dataset) - errorList[-1]) > 0.0001:
T.trainOnDataset(Dataset)
errorList.append(T.testOnData(Dataset))
pass # this step is for the output of predictedLabel
print(np.array([Network.activate(x) for x in trainFeature]))
# print(testLabel)
print(Network.activate([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
return errorList
while len(b) < len(r):
b = [0] + b
a = a[::-1]
b = b[::-1]
r = r[::-1]
ds.newSequence()
for i in range(len(a)):
inl = [a[i], b[i]]
out = [r[i]]
ds.appendLinked(inl, out)
#trainer = RPropMinusTrainer(n, dataset = ds)
trainer = BackpropTrainer(n, dataset = ds)
print("Generating dataset took", time()-start)
lastlen = 0
start = time()
try:
while True:
epochstart = time()
error = trainer.train()
tpe = time()-epochstart
epochs += 1
out = str(error) + " error " + str(epochs) + " epochs " + str(tpe) + " time per epoch"
clearspaces = " "*(lastlen-len(out))
return n
n = buildNetwork(mx_lag, mx_lag/2, 1, hiddenclass=LSTMLayer, bias=True, recurrent=True)
#n.randomize()
ts = get_sysprice_list('2011-01-01 00:00:00', '2013-05-31 23:00:00', frequency='daily')
ds = NN_data(ts, mx_lag)[0]
forecast_actual_data = get_sysprice_list('2013-06-01 00:00:00', '2013-06-18 23:00:00', frequency='daily')
'''min_by_mae = [1000, 1000]
min_by_mse = [1000,1000]
best_net_by_mse = None
best_net_by_mae = None'''
#n=pickle.load(open("/home/martin/dev/python_pickle/min_by_mae_nn.p", "rb"))
#n = mk_nn(10)
trainer = BackpropTrainer(n, ds, verbose=True)
trainer.trainUntilConvergence(maxEpochs=5)
forecast = NN_forecast("2013-05-01", "2013-05-31", max_lag=mx_lag, trained_nnet = n, forecast_period_in_days=31)
print_errors(forecast.values, forecast_actual_data.values)
#start timing
'''limit = 120 # seconds
start = time.clock()
while(True):
duration = time.clock()- start
if duration >= limit:
print "execution time: " + str(duration) + "seconds"
break
n = mk_nn(10)
trainer = BackpropTrainer(n, ds, verbose=True, weightdecay=0.01)
#trainer.trainUntilConvergence()
class PyBrainNetwork(ANNWrapper):
def __init__(self, hidden_neurons=None, output_class="softmax",
learning_rate=0.01, lr_decay=1.0, momentum=0.0,
weight_decay=0.0, max_epochs=None, continue_epochs=10,
validation_percent=0.25, random_state=None):
super(PyBrainNetwork, self).__init__()
self.hidden_neurons = hidden_neurons
self.output_class = output_class
self.learning_rate = learning_rate
self.lr_decay = lr_decay
self.momentum = momentum
self.weight_decay = weight_decay
self.max_epochs = max_epochs
self.continue_epochs = continue_epochs
self.validation_percent = validation_percent
self.random_state = random_state
self.network_ = None
self.trainer_ = None
def fit(self, inp, y, sample_weight=None):
self.classes_, y = numpy.unique(y, return_inverse=True)
self.n_classes_ = len(self.classes_)
n_features = inp.shape[1]
random_state = check_random_state(self.random_state)
# We need to build an ImportanceDataSet from inp, y and sample_weight
dataset = ImportanceDataSet(n_features, self.n_classes_)
if sample_weight is None:
sample_weight = numpy.ones(len(y))
for x, label_pos, weight in izip(inp, y, sample_weight):
target = numpy.zeros(self.n_classes_)
target[label_pos] = 1
weight = weight * numpy.ones(self.n_classes_)
dataset.newSequence()
dataset.addSample(x, target, weight)
if self.hidden_neurons is None:
hidden_neurons = (n_features + self.n_classes_)/2
else:
hidden_neurons = self.hidden_neurons
self.network_ = buildNetwork(
n_features, hidden_neurons, self.n_classes_,
outclass=self._get_output_class()
)
# Set the initial parameters in a repeatable way
net_params = random_state.random_sample(self.network_.paramdim)
self.network_.params[:] = net_params
self.trainer_ = BackpropTrainer(
self.network_, dataset=dataset, learningrate=self.learning_rate,
lrdecay=self.lr_decay, momentum=self.momentum,
weightdecay=self.weight_decay
)
self.trainer_.trainUntilConvergence(
random_state, maxEpochs=self.max_epochs,
continueEpochs=self.continue_epochs,
validationProportion=self.validation_percent
)
return self
def activate(self, x):
return self.network_.activate(x)
def _get_output_class(self):
if self.output_class == "softmax":
return SoftmaxLayer
elif self.output_class == "tanh":
return TanhLayer
elif self.output_class == "sigmoid":
return SigmoidLayer
elif self.output_class == "linear":
return LinearLayer
else:
raise ValueError(
"output_class can be: softmax, tanh, sigmoid, linear"
)
# 将数据扁平化
X = datasets.reshape((datasets.shape[0], datasets.shape[1] * datasets.shape[2]))
X_train ,X_test, y_train, y_test = train_test_split(X, y, train_size=0.9)
# 添加数据到数据格式中
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])
# 搭建三层网络
net = buildNetwork(X.shape[1], 150, y.shape[1] ,bias=True)
# 使用BP算法
trainer = BackpropTrainer(net, training ,weightdecay=0.01)
# 训练步数
trainer.trainEpochs(epochs=50)
# 保存模型
# model_filename = open('CAPTCHA_predictor.model','wb')
# pickle.dump(trainer,model_filename,0)
# model_filename.close()
predictions = trainer.testOnClassData(dataset=testing)
from sklearn.metrics import f1_score,classification_report
print(classification_report(y_test.argmax(axis=1), predictions))
f_input_cost.write("%f %f\n" % (x, z_cost))
f_input.close()
f_input_cost.close()
eval_dataset = SupervisedDataSet(1, 1)
eval_costset = SupervisedDataSet(1, 1)
for i in range(RANDOM_TRAINING_SAMPLES):
x = random.uniform(-3, 3)
z = fn(x)
z_cost = cost_fn(x)
eval_dataset.addSample([x], [z])
eval_costset.addSample([x], [z_cost])
value_network = buildNetwork(1, 20, 1, hiddenclass=SigmoidLayer, bias=True)
value_trainer = BackpropTrainer(value_network,
learningrate=0.01,
momentum=0.90,
verbose=True)
print value_network
cost_network = buildNetwork(1,
40,
20,
1,
hiddenclass=SigmoidLayer,
bias=True)
cost_trainer = BackpropTrainer(cost_network,
learningrate=0.01,
momentum=0.00,
verbose=True)
'''
Created on Nov 21, 2011
@author: reza
'''
from pybrain.datasets.supervised import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers.backprop import BackpropTrainer
if __name__ == '__main__':
dataset = SupervisedDataSet(2, 1)
dataset.addSample([0, 0], [0])
dataset.addSample([0, 1], [1])
dataset.addSample([1, 0], [1])
dataset.addSample([1, 1], [0])
network = buildNetwork(2, 4, 1)
trainer = BackpropTrainer(network, learningrate = 0.01, momentum = 0.2,
verbose = False)
print 'MSE before', trainer.testOnData(dataset)
trainer.trainOnDataset(dataset, 1000)
print 'MSE after', trainer.testOnData(dataset)
z = network.activate([0, 0])
print z
print 'Final Weights: ', network.params
hiddenLayerTwo = SigmoidLayer(4, "two")
outLayer = LinearLayer(1)
inToHiddenOne = FullConnection(inLayer, hiddenLayerOne)
hiddenOneToTwo = FullConnection(hiddenLayerOne, hiddenLayerTwo)
hiddenTwoToOut = FullConnection(hiddenLayerTwo, outLayer)
#wire the layers and connections to a net
net = FeedForwardNetwork()
net.addInputModule(inLayer)
net.addModule(hiddenLayerOne)
net.addModule(hiddenLayerTwo)
net.addOutputModule(outLayer)
net.addConnection(inToHiddenOne)
net.addConnection(hiddenOneToTwo)
net.addConnection(hiddenTwoToOut)
net.sortModules()
print(net)
trainer = BackpropTrainer(net, ds)
for i in range(20):
for j in range(1000):
trainer.train()
printNetResult(i, net)
print(net)
print(inToHiddenOne.params)
print(hiddenOneToTwo.params)
print(hiddenTwoToOut.params)
def main():
# carregando o dataset do iris
dataset = montaDataset()
# carregando os datasets temporários
# separando 60% dos dados
# para treino e 30 % para teste
datasetTreinoTemporario, dadosRepartidosTemporario = dataset.splitWithProportion(
0.6)
# carregando os datasets temporários
# separando os dados repartidos
# em 50 % para teste e
# os outros 50 % para validação
datasetTesteTemporario, datasetValidacaoTemporario = dadosRepartidosTemporario.splitWithProportion(
0.5)
# montandos os datasets finais
datasetTreino = montaDatasetConvertido(datasetTreinoTemporario)
datasetTeste = montaDatasetConvertido(datasetTesteTemporario)
datasetValidacao = montaDatasetConvertido(datasetValidacaoTemporario)
# definindo a estrutura da rede adpatadas ao SoftmaxLayer
# com dimensão 4 de entrada
# com 20 neurônios na 1 camada intermediária
# com 2 camadas
# com dimensão 3 na saída
# terá como saída adaptada à classe SoftmaxLayer
network = buildNetwork(4, 20, 2, 3, outclass=SoftmaxLayer)
# convertendo os dados para o objeto ConvertToOneOfMany
datasetTreino._convertToOneOfMany()
datasetTeste._convertToOneOfMany()
datasetValidacao._convertToOneOfMany()
# criando a rede neural treinada
# passando a estrutura da rede neural
# dataset para treino
neuralNetwork = BackpropTrainer(network,
dataset=datasetTreino,
learningrate=0.02,
momentum=0.14,
verbose=True)
# treinando a rede até ela convergir
# e semparando os erros em um array de erro do treino
# e um array dos erros da validação
errosTreino, validacaoErros = neuralNetwork.trainUntilConvergence(
dataset=datasetTreino, maxEpochs=1000)
# criando a camada externa de teste
outTest = network.activateOnDataset(datasetTeste).argmax(axis=1)
print(5 * "-" + " Precisão de teste de treinamento " + 5 * "-" + "\n")
print("Precisão no teste : {} %".format(
100 - percentError(outTest, datasetTeste["class"])))
# criando a camada externa de validação
outVal = network.activateOnDataset(datasetValidacao).argmax(axis=1)
print("\n" + 5 * "-" + " Precisão de teste de treinamento " + 5 * "-" +
"\n")
print("Precisão na validação : {} %".format(
100 - percentError(outVal, datasetTeste["class"])))
# fazendo o plot gráfico dos erros
plt.plot(errosTreino, "b", validacaoErros, "r")
plt.show()
n.sortModules()
print 'build set'
alldata = ClassificationDataSet(dim, 1, nb_classes=2)
(data,label,items) = BinReader.readData(ur'F:\AliRecommendHomeworkData\1212新版\train15_17.expand.samp.norm.bin')
#(train,label,data) = BinReader.readData(r'C:\data\small\norm\train1217.bin')
for i in range(len(data)):
alldata.addSample(data[i],label[i])
tstdata, trndata = alldata.splitWithProportion(0.25)
trainer = BackpropTrainer(n,trndata,momentum=0.1,verbose=True,weightdecay=0.01)
print 'start'
#trainer.trainEpochs(1)
trainer.trainUntilConvergence(maxEpochs=2)
trnresult = percentError(trainer.testOnClassData(),trndata['class'])
tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['class'])
print "epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
print 'get result'
#trainer.trainUntilConvergence()
from pybrain.datasets.supervised import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers.backprop import BackpropTrainer
dataset = SupervisedDataSet(2, 1)
dataset.addSample([1, 1], [0])
dataset.addSample([1, 0], [1])
dataset.addSample([0, 1], [1])
dataset.addSample([0, 0], [0])
network = buildNetwork(dataset.indim, 2, dataset.outdim, bias=True)
trainer = BackpropTrainer(network, dataset, learningrate=0.01, momentum=0.99)
for epoch in range(1000):
trainer.train()
test_data = SupervisedDataSet(2, 1)
test_data.addSample([1, 1], [0])
test_data.addSample([1, 0], [1])
test_data.addSample([0, 1], [1])
test_data.addSample([0, 0], [0])
trainer.testOnData(test_data, verbose=True)
print
#PYBRAIN
from pybrain.tools.shortcuts import buildNetwork
from pybrain import LinearLayer, SigmoidLayer, FeedForwardNetwork, FullConnection, BiasUnit, SoftmaxLayer
from pybrain.supervised.trainers.backprop import BackpropTrainer
from pybrain.structure.modules.tanhlayer import TanhLayer
from pybrain.datasets import SupervisedDataSet
ds = SupervisedDataSet(2,1 )
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
net = buildNetwork(2, 2, 1, bias=True, outputbias= True, hiddenclass=SigmoidLayer)
trainer = BackpropTrainer(net, ds, learningrate= 0.1)
t1 = time()
trainer.trainEpochs(2000)
print "Time PyBrain {}".format(time()-t1)
#PRINT RESULTS
for x in X:
print "{} ==> {}".format( x, net.activate(x) )
# Run:
# python2 feed_forward_neural_network.py X,
# where X is the desired amount of hidden nodes
from sys import argv
hidden = int(argv[1]) # X
# Expects one dimensional input and target output
ds = SupervisedDataSet(1, 1)
for x in range(1, 9):
ds.addSample(x, x)
# 1 input, X hidden, 1 output
network = buildNetwork(1, hidden, 1, hiddenclass=TanhLayer)
# Init BackpropTrainer
trainer = BackpropTrainer(network, dataset=ds)
# Train until convergence
trainer.trainUntilConvergence(verbose=False,
validationData=0.15,
maxEpochs=1000,
continueEpochs=10)
# Activating the network on different integers such as the inputs in the data-set
print("// Hidden nodes: {}".format(hidden))
for x in range(1, 9):
print("{} --> {}".format(x, network.activate([x])[0]))
# Activating with decimal inputs outside of dataset
print("\nDecimal input outside dataset:")
for x in range(100, 109):
def train(self, x_data, y_data):
trainer = BackpropTrainer(self.net, self._prepare_dataset(x_data, y_data))
trainer.train()
def base_experiment():
(eval_dataset, eval_costset) = DomainFnApprox.make_evaluation_datasets()
random_train_dataset = SupervisedDataSet(2, 1)
random_train_costset = SupervisedDataSet(2, 1)
for i in range(RANDOM_TRAINING_SAMPLES):
x = random.uniform(X_MIN, X_MAX)
y = random.uniform(Y_MIN, Y_MAX)
z = FN(x, y)
z_cost = COST_FN(x, y)
random_train_dataset.addSample([x, y], [z])
random_train_costset.addSample([x, y], [z_cost])
value_network = buildNetwork(2,
80,
20,
1,
hiddenclass=SigmoidLayer,
bias=True)
value_trainer = BackpropTrainer(value_network,
learningrate=LEARNING_RATE,
momentum=MOMENTUM,
verbose=True)
print 'Value Network Topology:'
print value_network
cost_network = buildNetwork(2,
80,
20,
1,
hiddenclass=SigmoidLayer,
bias=True)
cost_trainer = BackpropTrainer(cost_network,
learningrate=LEARNING_RATE,
momentum=MOMENTUM,
verbose=True)
# test_derivatives(value_network, [1, 1])
# test_derivatives(cost_network, [1, 1])
print 'Value MSE before: %.4f' % value_trainer.testOnData(eval_dataset)
value_trainer.trainUntilConvergence(random_train_dataset,
continueEpochs=6,
maxEpochs=MAX_EPOCHS)
# value_trainer.trainOnDataset(random_train_dataset, 1000)
print 'Value MSE after: %.4f' % value_trainer.testOnData(eval_dataset)
print 'Cost MSE before: %.4f' % cost_trainer.testOnData(eval_costset)
cost_trainer.trainUntilConvergence(random_train_costset,
continueEpochs=6,
maxEpochs=MAX_EPOCHS)
# cost_trainer.trainOnDataset(random_train_costset, 1000)
print 'Cost MSE after: %.4f' % cost_trainer.testOnData(eval_costset)
# test_derivatives(value_network, [1, 1])
# test_derivatives(cost_network, [1, 1])
f_value = open('../data/learnedvalue.txt', 'w')
f_cost = open('../data/learnedcost.txt', 'w')
unit = (X_MAX - X_MIN) / (EVAL_SAMPLES_AXIS - 1)
for i in range(EVAL_SAMPLES_AXIS):
for j in range(EVAL_SAMPLES_AXIS):
x = X_MIN + i * unit
y = Y_MIN + j * unit
z = value_network.activate([x, y])
z_cost = cost_network.activate([x, y])
f_value.write('%f %f %f\n' % (x, y, z[0]))
f_cost.write('%f %f %f\n' % (x, y, z_cost[0]))
f_value.close()
f_cost.close()
class StrategyANN(Strategy):
def __init__(self, features_num, hidden_neurons_num):
super().__init__()
self.is_learning = True
self.features_num = features_num
# self.net = buildNetwork(features_num, hidden_neurons_num, 1, bias = True)
# self.net = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
# self.net = ConvolutionalBoardNetwork(Board.BOARD_SIZE, 5, 3)
# self.trainer = BackpropTrainer(self.net)
self.net_attack = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
self.net_defence = buildNetwork(features_num, hidden_neurons_num, hidden_neurons_num, 1, bias = True)
self.trainer_attack = BackpropTrainer(self.net_attack)
self.trainer_defence = BackpropTrainer(self.net_defence)
self.gamma = 0.9
self.errors = []
self.buf = np.zeros(200)
self.buf_index = 0
self.setup()
def update_at_end(self, old, new):
if not self.needs_update():
return
if new.winner == Board.STONE_EMPTY:
reward = 0
else:
reward = 2 if self.stand_for == new.winner else -2
if old is None:
if self.prev_state is not None:
self._update_impl(self.prev_state, new, reward)
else:
self._update_impl(old, new, reward)
def update(self, old, new):
if not self.needs_update():
return
if self.prev_state is None:
self.prev_state = old
return
if new is None:
self._update_impl(self.prev_state, old, 0)
self.prev_state = old
def _update_impl(self, old, new, reward):
old_input = self.get_input_values(old)
v1_a = self.net_attack.activate(self.get_input_values(new))
target = self.gamma * v1_a
ds_a = SupervisedDataSet(self.features_num, 1)
ds_a.addSample(old_input, target + max(0, reward))
ds_d = SupervisedDataSet(self.features_num, 1)
ds_d.addSample(old_input, target + min(0, reward))
# self.trainer.setData(ds)
# err = self.trainer.train()
self.trainer_attack.setData(ds_a)
self.trainer_attack.train()
self.trainer_defence.setData(ds_d)
self.trainer_defence.train()
# self.buf[self.buf_index] = err
# self.buf_index += 1
# if self.buf_index >= self.buf.size:
# if len(self.errors) < 2000:
# self.errors.append(np.average(self.buf))
# self.buf.fill(0)
# self.buf_index = 0
def board_value(self, board, context):
iv = self.get_input_values(board)
# return self.net.activate(iv)
return self.net_attack.activate(iv), self.net_defence.activate(iv)
def _decide_move(self, moves):
best_move_a, best_av = None, None
best_move_d, best_dv = None, None
for m in moves:
iv = self.get_input_values(m)
av, dv = self.net_attack.activate(iv), self.net_defence.activate(iv)
if best_av is None or best_av < av:
best_move_a, best_av = m, av
if best_dv is None or best_dv < dv:
best_move_d, best_dv = m, dv
return best_move_a if best_av >= best_dv else best_move_d
def preferred_board(self, old, moves, context):
if not moves:
return old
if len(moves) == 1:
return moves[0]
if np.random.rand() < self.epsilon: # exploration
the_board = random.choice(moves)
the_board.exploration = True
return the_board
else:
# board_most_value = max(moves, key=lambda m: self.board_value(m, context))
# return board_most_value
return self._decide_move(moves)
def get_input_values(self, board):
'''
Returns:
-----------
vector: numpy.1darray
the input vector
'''
# print('boar.stone shape: ' + str(board.stones.shape))
v = board.stones
# print('vectorized board shape: ' + str(v.shape))
# print('b[%d], w[%d]' % (black, white))
iv = np.zeros(v.shape[0] * 2 + 2)
iv[0:v.shape[0]] = (v == Board.STONE_BLACK).astype(int)
iv[v.shape[0]:v.shape[0] * 2] = (v == Board.STONE_WHITE).astype(int)
who = board.whose_turn_now()
iv[-2] = 1 if who == Board.STONE_BLACK else 0 # turn to black move
iv[-1] = 1 if who == Board.STONE_WHITE else 0 # turn to white move
# print(iv.shape)
# print(iv)
return iv
def save(self, file):
pass
def load(self, file):
pass
def setup(self):
self.prev_state = None
def mind_clone(self):
pass
#PYBRAIN
from pybrain.tools.shortcuts import buildNetwork
from pybrain import LinearLayer, SigmoidLayer, FeedForwardNetwork, FullConnection, BiasUnit, SoftmaxLayer
from pybrain.supervised.trainers.backprop import BackpropTrainer
from pybrain.structure.modules.tanhlayer import TanhLayer
from pybrain.datasets import SupervisedDataSet
ds = SupervisedDataSet(2, 1)
ds.addSample((0, 0), (0, ))
ds.addSample((0, 1), (1, ))
ds.addSample((1, 0), (1, ))
ds.addSample((1, 1), (0, ))
net = buildNetwork(2,
2,
1,
bias=True,
outputbias=True,
hiddenclass=SigmoidLayer)
trainer = BackpropTrainer(net, ds, learningrate=0.1)
t1 = time()
trainer.trainEpochs(2000)
print "Time PyBrain {}".format(time() - t1)
#PRINT RESULTS
for x in X:
print "{} ==> {}".format(x, net.activate(x))
class MonteCarlo(object):
def __init__(self, **kwargs):
self.max_depth = 0
self.stats = {}
self.calculation_time = float(kwargs.get('time', 1))
self.max_moves = int(kwargs.get('max_moves', Board.BOARD_SIZE_SQ))
# Exploration constant, increase for more exploratory moves,
# decrease to prefer moves with known higher win rates.
self.C = float(kwargs.get('C', 1.4))
self.features_num = Board.BOARD_SIZE_SQ * 3 + 2
self.hidden_neurons_num = self.features_num * 2
self.net = buildNetwork(self.features_num, self.hidden_neurons_num, 2, bias=True, outclass=SigmoidLayer)
self.trainer = BackpropTrainer(self.net)
self.total_sim = 0
self.observation = []
def select(self, board, moves, who, **kwargs):
# Bail out early if there is no real choice to be made.
if not moves:
return
if len(moves) == 1:
return moves[0]
if Game.on_training:
self.calculation_time = 60
else:
self.calculation_time = 1
self.max_depth = 0
self.stats = {}
games = 0
begin = time.time()
while time.time() - begin < self.calculation_time:
self.sim(board)
games += 1
if games > 10:
break
self.stats.update(games=games, max_depth=self.max_depth, time=str(time.time() - begin))
print(self.stats['games'], self.stats['time'])
move, _ = self.get_best(board, moves, who)
return move
def sim(self, board):
visited_path = []
state = board
winner = Board.STONE_EMPTY
for _ in range(1, self.max_moves + 1):
moves, player, _ = Game.possible_moves(state)
state_new, state_new_val = self.get_best(state, moves, player)
visited_path.append((player, state, state_new, state_new_val))
over, winner, _ = state_new.is_over(state)
if over:
break
state = state_new
self.total_sim += 1
ds = SupervisedDataSet(self.features_num, 2)
for player, state, new, val in visited_path:
plays = val[1] * self.total_sim + 1
wins = val[0] * self.total_sim
if player == winner:
wins += 1
ds.addSample(self.get_input_values(state, new, player), (wins, plays))
self.trainer.trainOnDataset(ds)
def get_best(self, state, moves, who):
outputs = []
for s in moves:
out = self.net.activate(self.get_input_values(state, s, who))
outputs.append(out)
a = np.array(outputs)
b = a[:, 0] / a[:, 1] + self.C * np.log(np.sum(a[:, 1])) / a[:, 1]
i = np.argmax(b)
return moves[i], a[i]
def get_input_values(self, board, new_board, who):
v = board.stones
sz = v.shape[0]
iv = np.zeros(self.features_num)
iv[0:sz] = (v == Board.STONE_BLACK).astype(int)
iv[sz:sz * 2] = (v == Board.STONE_WHITE).astype(int)
iv[sz * 2:sz * 3] = (new_board.stones != v).astype(int)
iv[-2] = 1 if who == Board.STONE_BLACK else 0 # turn to black move
iv[-1] = 1 if who == Board.STONE_WHITE else 0 # turn to white move
return iv
def swallow(self, who, st0, st1, **kwargs):
self.observation.append((who, st0, st1))
def absorb(self, winner, **kwargs):
self.total_sim += 1
ds = SupervisedDataSet(self.features_num, 2)
for who, s0, s1 in self.observation:
if who != Board.STONE_BLACK:
continue
input_vec = self.get_input_values(s0, s1, who)
val = self.net.activate(input_vec)
plays = val[1] * self.total_sim + 1
wins = val[0] * self.total_sim
if who == winner:
wins += 1
ds.addSample(input_vec, (wins, plays))
self.trainer.trainOnDataset(ds)
def void(self):
self.observation = []
return ls;
#读入字符串
dataset = readFromCsv("cbf");
#化为float
numdataset = np.array(dataset,dtype=np.float64);
#原始分割为两组
trainingset,vdataset = dataSplit(numdataset);
# print(len(trainingset),len(vdataset));
#分别归一化
gytdataset = gyData(trainingset);
gyvdataset = gyData(vdataset);
#下面的是训练神经网络
# #最终的训练集,用归一化的数据来构成训练集
bts = buildTrainingSet(gytdataset);
# ll = [3382.9879,3384.0262,3358.7953,3373.3446,179423841,2.31148615058,4.4,4.4,4.35,4.36,0.4556,4518585,19794038.0,4363744000.0,4363744000.0];
# print(calTodayFeature(ll,trainingset));
net = buildNetwork(15, 4, 2, bias=True,hiddenclass=SigmoidLayer,outclass=SigmoidLayer)
trainer = BackpropTrainer(net, bts)
trainer.trainEpochs(epochs=100);
NetworkWriter.writeToFile(net, '../net/jxkj_4l_100t.xml')
#
print(ve.calRightRate(gyvdataset,net));
class NeuralNetwork(object):
'''Neural network wrapper for the pybrain implementation
'''
def __init__(self):
self.path = os.path.dirname(os.path.abspath(__file__)) + "/../../data/"
self.net = None
self.trainer = None
def createNew(self, nInputs, nHiddenLayers, nOutput, bias):
'''builds a new neural network
:param int nInputs: the number of input nodes
:param int nHiddenLayers: the number of hidden layers
:parma int nOutputs: the number of output nodes
:param bool bias: if True an bias node will be added
:return: instance of a new neural network
:rtype: NeuralNetwork
'''
self.net = buildNetwork(nInputs, nHiddenLayers, nOutput, bias=bias, hiddenclass=TanhLayer)
return self
def train(self, dataset, maxEpochs = 10, learningrate = 0.01, momentum = 0.99, continueEpochs=10, validationProportion=0.25):
'''trains a network with the given dataset
:param SupervisedDataSet dataset: the training dataset
:param int maxEpochs: max number of iterations to train the network
:parma float learningrate: helps to
:param float momentum: helps out of local minima while training, to get better results
'''
self.trainer = BackpropTrainer(self.net, learningrate = learningrate, momentum = momentum)
self.trainer.trainOnDataset(dataset, maxEpochs)
def trainConvergence(self, dataset, maxEpochs = 10, learningrate = 0.01, momentum = 0.99, continueEpochs=10, validationProportion=0.25):
'''trains a network with the given dataset nutil it converges
:param SupervisedDataSet dataset: the training dataset
:param int maxEpochs: max number of iterations to train the network
:parma float learningrate: helps to
:param float momentum: helps out of local minima while training, to get better results
'''
self.trainer = BackpropTrainer(self.net, learningrate = learningrate, momentum = momentum)
self.trainer.trainUntilConvergence(dataset, maxEpochs, False, continueEpochs, validationProportion)
def test(self, data=None, verbose=False):
if not self.trainer:
raise ValueError("call train() first, to create a valid trainer object")
return self.trainer.testOnData(data, verbose)
def activate(self, value, rnd=False):
inpt = self.net.activate(value)[0]
if rnd:
return self._clazz(inpt)
return inpt
def _clazz(self, inpt):
clazz = round(inpt)
if (clazz < 0):
return 0
if (clazz > 1):
return 1
return int(clazz)
def save(self, name):
'''saves the neural network
:param string name: filename for the to be saved network
'''
f = open(self.path + name + FILE_EXTENSION, 'w')
pickle.dump(self.net, f)
f.close()
def load(self, name):
'''loades the neural network
:param string name: filename for the to be loaded network
:return: instance of a saved neural network
:rtype: NeuralNetwork
'''
f = open(self.path + name + FILE_EXTENSION, 'r')
self.net = pickle.load(f)
f.close()
return self
def __repr__(self):
return "%s\n%s" % (self.__class__.__name__, str(self.net))
net.reset()
for i, t in seq:
res = net.activate(i)
if verbose:
print(t, res)
r += sum((t-res)**2)
samples += 1
if verbose:
print('-'*20)
r /= samples
if not silent:
print('MSE:', r)
return r
if __name__ == "__main__":
N = buildParityNet()
DS = ParityDataSet()
evalRnnOnSeqDataset(N, DS, verbose = True)
print('(preset weights)')
N.randomize()
evalRnnOnSeqDataset(N, DS)
print('(random weights)')
# Backprop improves the network performance, and sometimes even finds the global optimum.
N.reset()
bp = BackpropTrainer(N, DS, verbose = True)
bp.trainEpochs(5000)
evalRnnOnSeqDataset(N, DS)
print('(backprop-trained weights)')
__author__ = 'Stubborn'
from pybrain.datasets.supervised import SupervisedDataSet
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers.backprop import BackpropTrainer
D = SupervisedDataSet(2, 1)
# 2 imput --> 1 output
D.addSample([0,0], [0])
D.addSample([0,1], [1])
D.addSample([1,0], [1])
D.addSample([1,1], [0])
# 4 kombinationer av input och dess output "OR" funktion
N = buildNetwork(2, 4, 1)
# multilayer perception? med 1 gomt lager
T = BackpropTrainer(N, learningrate = 0.01, momentum = 0.99)
# momentum = reduced learningrate
print (('MSE before'), T.testOnData(D))
T.trainOnDataset(D, 1000)
T.trainUntilConvergence()
print (('MSE after'), T.testOnData(D))
print D