def test_squared_errors_3(self):
"""
Tupla obtenida de los test anteriores con un error relativamente bajo ( < 2 )
"""
weights = [
1.0, 0.9999999898725264, -1.0, 0.9999999941226553,
0.7789066176302455, 0.9999999976272673, 0.7685086147538794, 1.0,
0.7789465050493634, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
]
moderate_constant = 0.01
iterations = 30
errors = []
for i in range(iterations):
board = experiment_generator()
print('Obteniendo traza del juego...')
game_trace = get_game_trace_with_random_player(board, weights)
print(f'Se obtuvieron {game_trace.__len__()} tuplas')
training_examples = get_training_examples(game_trace, weights)
print('Ajustando pesos...')
weights = gen(training_examples, weights, moderate_constant)
errors.append(squared_error(training_examples, weights))
print(f'Pesos obtenidos : {weights}')
print(f'Error cuadratico : {errors[-1]}')
for i in range(iterations):
print('Error {}: {}'.format(i, errors[i]))
for i in range(iterations - 1):
self.assertGreaterEqual(
errors[i], errors[i + 1],
f'El error {i} no es mayor o igual que el error {i+1}, los errores deben decrecer'
)
def test_squared_errors_2(self):
weights = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
moderate_constant = 0.5
iterations = 5
errors = []
for i in range(iterations):
board = experiment_generator()
print('Obteniendo traza del juego...')
game_trace = get_game_trace_with_random_player(board, weights)
print(f'Se obtuvieron {game_trace.__len__()} tuplas')
training_examples = get_training_examples(game_trace, weights)
print('Ajustando pesos...')
weights = gen(training_examples, weights, moderate_constant)
errors.append(squared_error(training_examples, weights))
print(f'Pesos obtenidos : {weights}')
print(f'Error cuadratico : {errors[-1]}')
for i in range(iterations):
print('Error {}: {}'.format(i, errors[i]))
for i in range(iterations - 1):
self.assertGreaterEqual(
errors[i], errors[i + 1],
f'El error {i} no es mayor o igual que el error {i+1}, los errores deben decrecer'
)
def train_3(weights, moderate_constant, max_error):
board = experiment_generator()
game_trace = get_game_trace_with_old_vesion(board, weights, weights)
training_examples = get_training_examples(game_trace, weights)
weights = gen(training_examples, weights, moderate_constant)
error = squared_error(training_examples, weights)
return weights, error, error <= max_error
def test_squared_errors9(self):
logging.basicConfig(filename='./logs/test_with_random_player_mu09.log',
level=logging.INFO)
logging.info(
'------------------------------------------------------------------------------------------------'
)
logging.info('Started')
moderate_constant = 0.9
iterations = 50
weights = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
errors = []
won = 0
lost = 0
for i in range(iterations):
board = experiment_generator()
logging.info('Obteniendo traza del juego...')
game_trace = get_game_trace_with_random_player(board, weights)
logging.info(f'Se obtuvieron {game_trace.__len__()} tuplas')
training_examples = get_training_examples(game_trace, weights)
board_features = training_examples[training_examples.__len__() -
1][0]
logging.info(training_examples[training_examples.__len__() - 1])
if board_features[6] >= 1:
won = won + 1
elif board_features[13] >= 1:
lost = lost + 1
logging.info('Ajustando pesos...')
weights = gen(training_examples, weights, moderate_constant)
errors.append(squared_error(training_examples, weights))
logging.info(weights)
# if errors[i -1] < errors[i]:
# moderate_constant = max(0.1, moderate_constant - 0.1)
# logging.info(moderate_constant)
for i in range(iterations):
logging.info('Error {}: {}'.format(i, errors[i]))
# for i in range(iterations-1):
# self.assertGreaterEqual(errors[i], errors[i+1],
# f'El error {i} no es mayor o igual que el error {i+1}, los errores deben decrecer')
logging.info(f'Ganados: {won}')
logging.info(f'Perdidos: {lost}')
logging.info('Finished')
logging.info(
'------------------------------------------------------------------------------------------------'
)
return weights
def test_squared_errors_4(self):
"""
Probar : a mayor cantidad de iteraciones, menor constante de entrenamiento
"""
weights = [0, 1, -1, 2, -1, 3, -1, 2, -1, 1, -1, 1, -1, 1, -2]
moderate_constant = 0.001
iterations = 100
errors = []
board = experiment_generator()
game_trace = get_game_trace_with_random_player(board, weights)
training_examples = get_training_examples(game_trace, weights)
weights = gen(training_examples, weights, moderate_constant)
best_weights = weights
best_game_trace = game_trace
error = squared_error(training_examples, best_weights)
errors.append(error)
for i in range(iterations - 1):
board = experiment_generator()
game_trace = get_game_trace_with_random_player(board, best_weights)
training_examples = get_training_examples(game_trace, best_weights)
weights = gen(training_examples, best_weights, moderate_constant)
error = squared_error(training_examples, best_weights)
print(f'Error : {error}')
# Solo actualizo los pesos si la cantidad de jugadas realizadas para ganar
# es menor igual que lo que se tiene hasta el momento como minimo.
if game_trace.__len__() <= best_game_trace.__len__():
best_weights = weights
best_game_trace = game_trace
error = squared_error(training_examples, best_weights)
errors.append(error)
print(
f'Tuplas obtenidas en traza de juego : {best_game_trace.__len__()}'
)
print(f'Error cuadratico : {error}')
for i in range(errors.__len__()):
print('Error {}: {}'.format(i, errors[i]))
print(f'Pesos obtenidos: {best_weights}')
def orchestrate(self):
training_examples = get_training_examples(self.game_trace,
self.weights)
self.weights = gen(training_examples, self.weights,
self.moderate_constant)
self.error = squared_error(training_examples, self.weights)
for te in training_examples:
print(te)
print(f'Moderate constant: {self.moderate_constant}')
print(f'Game trace: {self.game_trace}')
print(f'Pesos obtenidos: {self.weights}')
print(f'Error cuadratico: {self.error}')
print(training_examples[i])
game_trace = []
iter = 6
for i in range(iter):
board = experiment_generator()
# T es un tablero con la primer ficha negra colocada en una posicion aleatoria
turn = board.BLACK_PIECE
board_features = []
while not board.is_game_over():
if turn == Board.BLACK_PIECE:
board.best_move(turn, weights, game_trace)
turn = Board.WHITE_PIECE
elif turn == board.WHITE_PIECE:
board.random_movement(turn, game_trace)
#board.best_move(turn, weights_old, game_trace)
turn = Board.BLACK_PIECE
u = (iter - i) * 0.1
print(u)
weights_old = weights
training_examples = get_training_examples(game_trace, weights)
weights = generalizer.gen(training_examples, weights, u)
print(weights)
#print_training(training_examples)
