def random_EV(sum, num_games, shuffles=5, num_random_games=10):
logarrays = []
expvals = []
for i1 in range(num_games):
board = game_sort(random_game_board(sum))
for i2 in range(shuffles):
b = copy.deepcopy(board)
random.shuffle(b)
game = Game(board=b)
syms = game.symmetries()
ev = 0.0
for g in syms:
ev += play_random_games(g, num_random_games)
logarrays.append(g.to_logarray())
expvals.append(ev / 8)
game = Game(board=board)
syms = game.symmetries()
ev = 0.0
for g in syms:
ev += play_random_games(g, num_random_games)
logarrays.append(g.to_logarray())
expvals.append(ev / 8)
minval = min(expvals)
maxval = max(expvals)
dif = maxval - minval
if dif == 0.0:
return [], []
evs = []
for ev in expvals:
for i3 in range(8):
evs.append((ev - minval) / dif)
return logarrays, evs
def train_on_played_games_lowest_2(self, histories, sums_back=10):
histories = sorted(histories, key=lambda x: pow2_sum(x[-1]))
num_hist = 10 #int(len(histories)*0.5)
max_game = pow2_sum(histories[num_hist][-1])
min_game = pow2_sum(histories[0][-1]) - sums_back
act_arrays = {}
for i in range(min_game, max_game, 2):
act_arrays[i] = []
for hist in histories:
max_sum = pow2_sum(hist[-1])
index = 0
while 1:
if index >= len(hist):
break
vec = hist[index]
sum = pow2_sum(vec)
index += 1
if sum < min_game:
continue
if sum >= max_game:
break
act_arrays[sum].append((vec, max_sum - sum))
vecs, vals = [], []
# normalize val
for sum in sorted(act_arrays.keys()):
if len(act_arrays[sum]) == 0:
continue
max_val = max(act_arrays[sum], key=lambda x: x[1])[1]
if max_val == 0:
continue
for pair in act_arrays[sum]:
game = Game(board=list(pair[0]))
game_val = float(pair[1]) / max_val
# apply some function:
#cut_num = 100
#if pair[1] > cut_num:
# game_val = 1.0
#else:
# game_val = float(pair[1]) / cut_num
#rangel = 0.9
#game_val = (1-rangel)/2 + rangel * game_val
for sym in game.symmetries():
vecs.append(sym.to_logarray())
vals.append(game_val)
return vecs, vals
def train_on_played_games_lowest(self, histories, min_game, params):
sums_back = params["sums_back"]
sums_back_from = params["sums_back_from"]
###
min_game -= sums_back_from
act_arrays = {}
if min_game < 2 * sums_back:
sums_back = min_game / 2
for i in range(sums_back + 1):
act_arrays[min_game - i * 2] = []
for hist in histories:
max_sum = pow2_sum(hist[-1])
index = 0
while 1:
vec = hist[index]
sum = pow2_sum(vec)
index += 1
if sum < min_game - 2 * sums_back:
continue
if sum >= min_game:
break
act_arrays[sum].append((vec, max_sum - sum))
# normalize vals
numrange = []
vecs, vals = [], []
for sum in sorted(act_arrays.keys()):
if len(act_arrays[sum]) == 0:
continue
numrange.append(sum)
self.vecs[sum] = []
self.vals[sum] = []
max_val = max(act_arrays[sum], key=lambda x: x[1])[1]
for pair in act_arrays[sum]:
game = Game(board=list(pair[0]))
game_val = float(pair[1]) / max_val
for sym in game.symmetries():
self.vecs[sum].append(sym.to_logarray())
vecs.append(sym.to_logarray())
self.vals[sum].append(game_val)
vals.append(game_val)
# add symetries???
self.train_on_data_lowest(params, numrange)
return vecs, vals
def train_on_played_games(self, histories, sums_back=100, num_hist=5):
histories = sorted(histories, key=lambda x: pow2_sum(x[-1]))
max_game = pow2_sum(histories[num_hist][-1])
min_game = pow2_sum(histories[0][-1]) - sums_back
act_arrays = {}
for i in range(min_game, max_game, 2):
act_arrays[i] = []
for hist in histories:
max_sum = pow2_sum(hist[-1])
index = 0
while 1:
if index >= len(hist):
break
vec = hist[index]
sum = pow2_sum(vec)
index += 1
if sum < min_game:
continue
if sum >= max_game:
break
act_arrays[sum].append((vec, max_sum - sum))
vecs, vals = [[]], [[]]
current_index = 0
for sum in sorted(act_arrays.keys()):
while self.ranges[current_index] < sum:
vecs.append([])
vals.append([])
current_index += 1
if len(act_arrays[sum]) == 0:
continue
max_val = max(act_arrays[sum], key=lambda x: x[1])[1]
if max_val == 0:
continue
for pair in act_arrays[sum]:
game = Game(board=list(pair[0]))
game_val = float(pair[1]) / max_val
for sym in game.symmetries():
vecs[-1].append(sym.to_logarray())
vals[-1].append(game_val)
return vecs, vals