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 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 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 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 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 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(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(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 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)
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 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
