def stat1():
from util.corpus import MyCorpus
from eval.evaluation import evaluate
dataSetName = 'BBN'
trainFilePath = 'data/{}/train.json'.format(dataSetName)
testFilePath = 'data/{}/test.json'.format(dataSetName)
corpus = MyCorpus(filePathList=[trainFilePath, testFilePath])
X_train, y_train = corpus.loadFile(filePath=trainFilePath)
X_test, y_test = corpus.loadFile(filePath=testFilePath)
y = np.load('10_24_17_32/epoch17.npy')
ground = MyCorpus.oneHotDecode(y_test)
scores = []
outputFile = open('a.txt', 'w', encoding='utf-8')
for threshold in np.arange(0.3, 0.6, 0.01):
y1 = MyCorpus.threshold(y, threshold)
y1 = MyCorpus.oneHotDecode(y1)
score = evaluate(y1, ground)
scores.append((threshold, score))
outputFile.write('%.3f\t%.3f\t%.3f\t%.3f\n' %
(threshold, score[0], score[3], score[6]))
print(scores)
print('Max: ' +
str(max(scores, key=lambda kv: sum([kv[1][0], kv[1][3], kv[1][6]]))))
outputFile.close()
def ab_min(board: chess.Board, alpha: int, beta: int, depth: int,
tt: {}) -> int:
"""
Min node of an alpha/beta tree, it calls ab_max until depth == 0
:param board: the chess board
:param alpha: alpha
:param beta: beta
:param depth: depth
:param tt: transpositions tables
:return: evaluation
"""
if depth == 0 or board.is_game_over():
return ev.evaluate(board)
best_eval = math.inf
for coup in board.legal_moves:
board.push(coup)
h = zb.zobrist_hash(board)
if h in tt:
it: HashItem = tt[h]
if it.depth <= depth:
ab = tt[h].evaluation
else:
ab = ab_max(board, alpha, beta, depth - 1, tt)
else:
ab = ab_max(board, alpha, beta, depth - 1, tt)
board.pop()
best_eval = min(best_eval, ab)
if best_eval <= alpha:
tt[h] = HashItem(h, depth, best_eval, (alpha, beta))
return best_eval
beta = min(beta, best_eval)
tt[h] = HashItem(h, depth, best_eval, (alpha, beta))
return best_eval
def on_epoch_end(self, epoch, logs={}):
y_prob = self.model.predict(self.X_test)
np.save(self.saveDir + 'epoch{:0>2}.npy'.format(epoch), y_prob)
y_predict = MyCorpus.topK(y_prob, topK=1)
predictions = MyCorpus.oneHotDecode(y_predict)
ground_truth = MyCorpus.oneHotDecode(self.y_test)
metrics = evaluate(predictions, ground_truth)
logging.info('acc, ma_f1, mi_f1: {}'.format(metrics[0], metrics[3],
metrics[6]))
with open(self.saveDir + 'metric.txt', 'a') as metricFile:
metricFile.write('\t'.join(map(str, metrics)) + '\n')
self.history.append(metrics)
def _min(board, profondeur):
"""
:param board: le tableau du jeu
:type board: chess.Board
:param profondeur: profondeur de l'algo
:type profondeur: int
"""
if profondeur == 0 or board.is_game_over():
return ev.evaluate(board)
val = math.inf
for play in board.legal_moves:
board.push(play)
val = min(val, _max(board, profondeur - 1))
board.pop()
return val
def on_epoch_end(self, epoch, logs={}):
y_prob = self.model.predict(self.X_test)
np.save(self.saveDir + 'epoch{:0>2}.npy'.format(epoch), y_prob)
scores = []
for threshold in np.arange(0.3, 0.6, 0.1):
y_predict = MyCorpus.threshold(y_prob, threshold=threshold)
predictions = MyCorpus.oneHotDecode(y_predict)
ground_truth = MyCorpus.oneHotDecode(self.y_test)
metrics = evaluate(predictions, ground_truth)
scores.append(metrics)
maxScore = max(scores, key=lambda kv: sum([kv[0], kv[3], kv[6]]))
logging.info('acc, ma_f1, mi_f1: {}'.format(maxScore[0], maxScore[3],
maxScore[6]))
with open(self.saveDir + 'metric.txt', 'a') as metricFile:
metricFile.write('\t'.join(map(str, maxScore)) + '\n')
self.history.append(maxScore)
def ab_max(board: chess.Board, alpha, beta, depth) -> int:
"""
:param board: the board of the game
:param alpha: alpha val
:param beta: beta val
:param depth: depth
:return: the evaluation of the branch
"""
if depth == 0 or board.is_game_over():
return ev.evaluate(board)
best_eval = -math.inf
for coup in board.legal_moves:
board.push(coup)
best_eval = max(best_eval, ab_min(board, alpha, beta, depth - 1))
board.pop()
if best_eval >= beta:
return best_eval
alpha = max(alpha, best_eval)
return best_eval
def ab_min(board: chess.Board, alpha, beta, depth: int) -> int:
"""
:param board: board of the chess game
:param alpha: alpha
:param beta: beta
:param depth: profondeur
:return: the branch evaluation
"""
if depth == 0 or board.is_game_over():
return ev.evaluate(board)
best_eval = math.inf
for coup in board.legal_moves:
board.push(coup)
best_eval = min(best_eval, ab_max(board, alpha, beta, depth - 1))
board.pop()
if best_eval <= alpha:
return best_eval
beta = min(beta, best_eval)
return best_eval
else:
if os.path.exists(modelName):
model = load_model(modelName)
else:
model = lstm(corpus)
metricHistory = MetricHistory(X_test, y_test)
model.fit(X_train,
y_train,
epochs=20,
batch_size=128,
validation_split=0.1,
shuffle=True,
callbacks=[metricHistory])
model.save(modelName)
logging.info(str(metricHistory.history))
y_prob = model.predict(X_test)
y_predict = corpus.hybrid(y_prob, threshold=0.5)
predictions = corpus.oneHotDecode(y_predict)
ground_truth = corpus.oneHotDecode(y_test)
accuracy, macro_precision, macro_recall, macro_f1, micro_precision, micro_recall, micro_f1 = evaluate(
predictions, ground_truth)
print('---- Final result ----')
print('accuracy:', accuracy)
print('macro_precision, macro_recall, macro_f1:', macro_precision,
macro_recall, macro_f1)
print('micro_precision, micro_recall, micro_f1:', micro_precision,
micro_recall, micro_f1)
import chess
import eval.evaluation as ev
import ia.alpha_beta_tt as ab
from util.funcs import game_over_reason
board = chess.Board()
count = 0
depth = 4
while not board.is_game_over():
print("---------------------------------")
print("nbrcoups", count, "score:", ev.evaluate(board), "profondeur:",
depth)
print("---------------------------------")
print(board)
move = ab.best_play(board, board.turn, depth)
board.push(move)
count += 1
game_over_reason(board)
# Entrez dans le mode de jeu ia/ia.
if argument == 1:
# Tour de jeu correspondant au joueur.
if joueurIA == 1:
# Exécution du mode de jeu correspondant : Algorithme alpha_beta
if algorithmeIA1 == 1:
board.push(ab.best_play(board, board.turn, profondeurIA1))
print(
"\n----------------------------------------------------------------------------------------------------")
print("+Joueur Actuel+")
print("ia N°1 / Blanc", "Profondeur : ", profondeurIA1, "Algorithme : alpha_beta\n")
print("+Joueur Adverse+")
print("ia N°2 / Noir", "Profondeur : ", profondeurIA2)
print("\nNombre de coups actuels : ", count, "Score : ", ev.evaluate(board), "\n\n")
print(board)
print(
"----------------------------------------------------------------------------------------------------\n")
count += 1
# Exécution du mode de jeu correspondant : Algorithme min_max
elif algorithmeIA1 == 0:
board.push(mm.best_play(board, board.turn, profondeurIA1))
print(
"\n-------------------------------------------------------------------------------------------------")
print("+Joueur Actuel+")
print("ia N°1 / Blanc", "Profondeur : ", profondeurIA1, "Algorithme : min_max\n")
print("+Joueur Adverse+")
print("ia N°2 / Noir", "Profondeur : ", profondeurIA2)
print("\nNombre de coups actuels : ", count, "Score : ", ev.evaluate(board), "\n\n")