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 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 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)
'''
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
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 = []
training_normalization(args.f2, args.min, args.max)
for i in range(len(normal_array[0])):
prediction = NN.activate([
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 = []
training_normalization(args.f2,args.min,args.max)
for i in range (len(normal_array[0])):
prediction= NN.activate([normal_array[0][i],normal_array[1][i],normal_array[2][i],normal_array[3][i],normal_array[4][i]])
class NeuralNetwork:
""" Neural network class """
def __init__(self, num_inputs, num_outputs, num_hidden_layers): ### Neural Network Variables ###
self.num_inputs = num_inputs; # Number of inputs
self.num_outputs = num_outputs; # Number of outputs
self.num_hidden_layers = num_hidden_layers; # Number of hidden layers
self.dataset = None; # Dataset object
self.network = None; # Network object
self.backprop = None; # Backpropogation object
self.epochs = 0; # Epochs
self.RMSE = 0; # RMSE
self.training_time = 0; # Calculated training time
logger.info("New neural network object created.");
def run(self, operator, epochs):
logger.info("Starting up neural network for %s.", operator);
self.epochs = epochs;
self.buildDataset();
self.buildNetwork();
# XOR data
if operator is "XOR":
self.addData([0,0], [0]);
self.addData([0,1], [1]);
self.addData([1,0], [1]);
self.addData([1,1], [0]);
# NXOR data
if operator is "NXOR":
self.addData([0,0], [1]);
self.addData([0,1], [0]);
self.addData([1,0], [0]);
self.addData([1,1], [1]);
self.backProp();
self.testData();
self.trainData();
self.testData();
return ;
def buildDataset(self):
self.dataset = SupervisedDataSet(self.num_inputs, self.num_outputs);
logger.info("Dataset object built.");
return True;
def addData(self, data_in, data_out):
self.dataset.addSample(data_in, data_out);
logger.info("Data appended.");
return True;
def buildNetwork(self):
self.network = buildNetwork(self.num_inputs, self.num_hidden_layers, self.num_outputs);
logger.info("Network created.");
return True;
def backProp(self):
self.backprop = BackpropTrainer(self.network, learningrate = 0.01, momentum = 0.99);
logger.info("Back propogation trainer created.");
return True;
def testData(self):
self.RMSE = math.sqrt(self.backprop.testOnData(self.dataset));
logger.info('RMSE: %s', str(self.RMSE));
return True;
def trainData(self):
start = timeit.default_timer();
self.backprop.trainOnDataset(self.dataset, self.epochs);
stop = timeit.default_timer();
self.training_time = stop - start;
logger.info("Training time: %s", str(self.training_time));
return True;
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 = []
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 _createFilePath(self, filePath, defaultPath=True):
if defaultPath:
return self.path + filePath + FILE_EXTENSION
return filePath + FILE_EXTENSION
def save(self, filePath, defaultPath=True):
'''saves the neural network
:param string filePath: filepath for the to be saved network
'''
with open(self._createFilePath(filePath, defaultPath), 'w') as f:
pickle.dump(self.net, f)
def load(self, filePath, defaultPath=True):
'''loades the neural network
:param string filePath: filepath for the to be loaded network
:return: instance of a saved neural network
:rtype: NeuralNetwork
'''
with open(self._createFilePath(filePath, defaultPath), 'r') as f:
self.net = pickle.load(f)
return self
def __repr__(self):
return "%s\n%s" % (self.__class__.__name__, str(self.net))
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 = []
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))
__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
