def create_dataset(path, player=ml_ml_rdeep.Bot(), games=2000, phase=1):
data = []
target = []
# For progress bar
bar_length = 30
start = time.time()
for g in range(games - 1):
# For progress bar
if g % 10 == 0:
percent = 100.0 * g / games
sys.stdout.write('\r')
sys.stdout.write("Generating dataset: [{:{}}] {:>3}%".format(
'=' * int(percent / (100.0 / bar_length)), bar_length,
int(percent)))
sys.stdout.flush()
# Randomly generate a state object starting in specified phase.
state = State.generate(phase=phase)
state_vectors = []
while not state.finished():
# Give the state a signature if in phase 1, obscuring information that a player shouldn't see.
given_state = state.clone(signature=state.whose_turn()
) if state.get_phase() == 1 else state
# Add the features representation of a state to the state_vectors array
state_vectors.append(features(given_state))
# Advance to the next state
move = player.get_move(given_state)
state = state.next(move)
winner, score = state.winner()
for state_vector in state_vectors:
data.append(state_vector)
if winner == 1:
result = 'won'
elif winner == 2:
result = 'lost'
target.append(result)
with open(path, 'wb') as output:
pickle.dump((data, target), output, pickle.HIGHEST_PROTOCOL)
# For printing newline after progress bar
print(
"\nDone. Time to generate dataset: {:.2f} seconds".format(time.time() -
start))
return data, target
parser.add_argument(
"-d",
dest="create_dataset",
action="store_true",
help=
"Whether to create a new dataset regardless of whether one already exists")
parser.add_argument("--no-train",
dest="train",
action="store_false",
help="Don't train a model after generating dataset.")
options = parser.parse_args()
if options.create_dataset or not os.path.isfile(options.path):
create_dataset(options.path, player=ml_ml_rdeep.Bot(), games=10000)
if options.train:
# Play around with the model parameters below
# HINT: Use tournament fast mode (-f flag) to quickly test your different models.
# The following tuple specifies the number of hidden layers in the neural
# network, as well as the number of layers, implicitly through its length.
# You can set any number of hidden layers, even just one. Experiment and see what works.
hidden_layer_sizes = (64, 32)
# The learning rate determines how fast we move towards the optimal solution.
# A low learning rate will converge slowly, but a large one might overshoot.
learning_rate = 0.0001
