def test_networks(datasetname, statesonly, expanded, name, batchsize=20000): """ Measure the accuracy and the legality of a triplet of networks Loads three networks and a dataset and than measure how accurate are the networks predictions with respect to the dataset and if their choices are legal. If the dataset is made only by states (therefore no moves), the accuracy test is not performed. Parameters ---------- datasetname : string The name of the dataset file. statesonly : boolean True if the dataset has doesn't contains informations about the moves. expanded : boolean True if the dataset has been already expanded through symmetries. name : string The name of the network configuration to load """ print("Testing " + name) print("Loading networks...") print("\tloading " + name + "_TO") TOnet = load_net(name + "_TO") print("\tloading " + name + "_FROM") FROMnet = load_net(name + "_FROM") print("\tloading " + name + "_REMOVE") REMOVEnet = load_net(name + "_REMOVE") print("\tNetworks loaded!") data_format = TOnet[3] print(str(data_format)) orderc = ['X', 'X', 'X'] orderc[TOnet[2]] = 'T' orderc[FROMnet[2]] = 'F' orderc[REMOVEnet[2]] = 'R' order = "" + orderc[0] + orderc[1] + orderc[2] print("\tOrder: " + order) print("Loading data...") if statesonly: if (expanded): A, B = load_expanded_states_dataset(datasetname) else: A, B = load_states_dataset(datasetname) else: if expanded: A, B = load_expanded_dataset(datasetname) else: A, B = load_dataset(datasetname) print("\tData loaded! Loaded: " + str(len(B)) + " data") print("Processing data and getting choices") X_TO_set = [] X_FROM_set = [] X_REMOVE_set = [] TO_choice_set = [] FROM_choice_set = [] REMOVE_choice_set = [] y_TO_set = [] y_FROM_set = [] y_REMOVE_set = [] numbatch = int(len(A) / batchsize) + 1 for i in range(1, numbatch + 1): print("\t" + str(i * batchsize * 100.0 / len(A)) + "%") if (i * batchsize <= len(A)): Ai = A[(i - 1) * batchsize:i * batchsize] Bi = B[(i - 1) * batchsize:i * batchsize] else: Ai = A[(i - 1) * batchsize:] Bi = B[(i - 1) * batchsize:] y_TO = process_move_onlyTO(Bi) y_FROM = process_move_onlyFROM(Bi) y_REMOVE = process_move_onlyREMOVE(Bi) init_state = process_state_binary(Ai, data_format) if order == "FTR": X_FROM = init_state FROM_choice = get_choices(FROMnet, X_FROM) X_TO = add_CHOICE_binary_raw(X_FROM, FROM_choice) TO_choice = get_choices(TOnet, X_TO) X_REMOVE = add_CHOICE_binary_raw(X_TO, TO_choice) REMOVE_choice = get_choices(REMOVEnet, X_REMOVE) elif order == "RFT": X_REMOVE = init_state REMOVE_choice = get_choices(REMOVEnet, X_REMOVE) X_FROM = add_CHOICE_binary_raw(X_REMOVE, REMOVE_choice) FROM_choice = get_choices(FROMnet, X_FROM) X_TO = add_CHOICE_binary_raw(X_FROM, FROM_choice) TO_choice = get_choices(TOnet, X_TO) elif order == "FRT": X_FROM = init_state FROM_choice = get_choices(FROMnet, X_FROM) X_REMOVE = add_CHOICE_binary_raw(X_FROM, FROM_choice) REMOVE_choice = get_choices(REMOVEnet, X_REMOVE) X_TO = add_CHOICE_binary_raw(X_REMOVE, REMOVE_choice) TO_choice = get_choices(TOnet, X_TO) elif order == "RTF": X_REMOVE = init_state REMOVE_choice = get_choices(REMOVEnet, X_REMOVE) X_TO = add_CHOICE_binary_raw(X_REMOVE, REMOVE_choice) TO_choice = get_choices(TOnet, X_TO) X_FROM = add_CHOICE_binary_raw(X_TO, TO_choice) FROM_choice = get_choices(FROMnet, X_FROM) elif order == "TRF": X_TO = init_state TO_choice = get_choices(TOnet, X_TO) X_REMOVE = add_CHOICE_binary_raw(X_TO, TO_choice) REMOVE_choice = get_choices(REMOVEnet, X_REMOVE) X_FROM = add_CHOICE_binary_raw(X_REMOVE, REMOVE_choice) FROM_choice = get_choices(FROMnet, X_FROM) elif order == "TFR": X_TO = init_state TO_choice = get_choices(TOnet, X_TO) #print("\tGot TO choices") X_FROM = add_CHOICE_binary_raw(X_TO, TO_choice) FROM_choice = get_choices(FROMnet, X_FROM) #print("\tGot FROM choices") X_REMOVE = add_CHOICE_binary_raw(X_FROM, FROM_choice) REMOVE_choice = get_choices(REMOVEnet, X_REMOVE) else: print("Unknown configuration. Using TFR") X_TO = init_state TO_choice = get_choices(TOnet, X_TO) #print("\tGot TO choices") X_FROM = add_CHOICE_binary_raw(X_TO, TO_choice) FROM_choice = get_choices(FROMnet, X_FROM) #print("\tGot FROM choices") X_REMOVE = add_CHOICE_binary_raw(X_FROM, FROM_choice) REMOVE_choice = get_choices(REMOVEnet, X_REMOVE) for j in range(len(X_TO)): X_TO_set.append(X_TO[j]) X_FROM_set.append(X_FROM[j]) X_REMOVE_set.append(X_REMOVE[j]) TO_choice_set.append(TO_choice[j]) FROM_choice_set.append(FROM_choice[j]) REMOVE_choice_set.append(REMOVE_choice[j]) y_TO_set.append(y_TO[j]) y_FROM_set.append(y_FROM[j]) y_REMOVE_set.append(y_REMOVE[j]) #print("\tGot REMOVE choices") # variable renaming X_TO = X_TO_set X_FROM = X_FROM_set X_REMOVE = X_REMOVE_set TO_choice = TO_choice_set FROM_choice = FROM_choice_set REMOVE_choice = REMOVE_choice_set y_TO = y_TO_set y_FROM = y_FROM_set y_REMOVE = y_REMOVE_set print("Testing legality") legalities = get_legalities(TO_choice, FROM_choice, REMOVE_choice, X_REMOVE, data_format) print("\ttesting the legality of " + str(len(legalities[0])) + " data\n") TO_self_leg = legalities[0] FROM_self_leg = legalities[1] REMOVE_self_leg = legalities[2] FROM_leg = legalities[3] REMOVE_leg = legalities[4] wholeFROM = legalities[5] wholeREMOVE = legalities[6] wholeMOVE = legalities[7] fileT = open(name + "_testing.txt", 'a') leg = ("Legality response on " + datasetname + ":" + "\n\tOnly TO leg:\t" + str(numpy.mean(TO_self_leg) * 100) + "\n\tOnly FROM leg:\t" + str(numpy.mean(FROM_self_leg) * 100) + "\n\tOnly REMOVE leg:\t" + str(numpy.mean(REMOVE_self_leg) * 100) + "\n\tOnly FROM-TO leg:\t" + str(numpy.mean(FROM_leg) * 100) + "\n\tOnly REMOVE-FROM-TO leg:\t" + str(numpy.mean(REMOVE_leg) * 100) + "\n\tWhole FROM leg:\t" + str(numpy.mean(wholeFROM) * 100) + "\n\tWhole REMOVE leg:\t" + str(numpy.mean(wholeREMOVE) * 100) + "\n\tWhole MOVE leg:\t" + str(numpy.mean(wholeMOVE) * 100)) print(leg) fileT.write(leg) print("\nTesting accuracy and special cases\n") # accuracy valutation and legality evaluation for some particular cases: # the FROM move in phase 2 and the REMOVE when is not 0 correctTO = 0 correctFROM = 0 correctREMOVE = 0 correctWHOLE = 0 # legality for FROM in phase 2 legalFROM2 = 0 f2 = 0 # legality for REMOVE != 0 for the network legalREMOVEeat = 0 re = 0 # accuracy when REMOVE != 0 in dataset correctREMOVEyes = 0 ry = 0 # accuracy when FROM != 0 in dataset correctFROMyes = 0 fy = 0 # accuracy for the different phases correctWHOLE1 = 0 p1 = 0 correctWHOLE2 = 0 p2 = 0 correctWHOLE3 = 0 p3 = 0 size = len(TO_choice) print("\tTesting the accuracy of " + str(size) + " data") for i in range(size): # TO DECISION if TO_choice[i] == y_TO[i]: correctTO += 1 # legal FROM decision in phase 2 if (is_phase_2(X_REMOVE[i], data_format)): f2 += 1 # legality l = get_legalities(TO_choice[i:i + 1], FROM_choice[i:i + 1], REMOVE_choice[i:i + 1], X_REMOVE[i:i + 1], data_format) if (l[5] == 1): legalFROM2 += 1 # FROM decision is different from 0 if y_FROM[i] != 0: fy += 1 # FROM decision if FROM_choice[i] == y_FROM[i]: correctFROM += 1 # correct FROM decision if different from 0 if y_FROM[i] != 0: correctFROMyes += 1 # REMOVE decision when present if y_REMOVE[i] != 0: ry += 1 if REMOVE_choice[i] != 0: re += 1 # legality l = get_legalities(TO_choice[i:i + 1], FROM_choice[i:i + 1], REMOVE_choice[i:i + 1], X_REMOVE[i:i + 1], data_format) if (l[6] == 1): legalREMOVEeat += 1 # REMOVE decision if REMOVE_choice[i] == y_REMOVE[i]: correctREMOVE += 1 if (y_REMOVE[i] != 0): correctREMOVEyes += 1 if is_phase_1(X_REMOVE[i], data_format): p1 += 1 elif is_phase_3(X_REMOVE[i], data_format): p3 += 1 else: p2 += 1 # WHOLE move (in different phases of game) if (TO_choice[i] == y_TO[i] and FROM_choice[i] == y_FROM[i] and REMOVE_choice[i] == y_REMOVE[i]): correctWHOLE += 1 if is_phase_1(X_REMOVE[i], data_format): correctWHOLE1 += 1 elif is_phase_3(X_REMOVE[i], data_format): correctWHOLE3 += 1 else: correctWHOLE2 += 1 if (size > 0): correctTO = correctTO * 100.0 / size correctFROM = correctFROM * 100.0 / size correctREMOVE = correctREMOVE * 100.0 / size correctWHOLE = correctWHOLE * 100.0 / size else: correctTO = -1 correctFROM = -1 correctREMOVE = -1 correctWHOLE = -1 if (f2 > 0): legalFROM2 = legalFROM2 * 100.0 / f2 else: legalFROM2 = -1 if (re > 0): legalREMOVEeat = (legalREMOVEeat * 100.0) / re else: legalREMOVEeat = -1 if (ry > 0): correctREMOVEyes = correctREMOVEyes * 100.0 / ry else: correctREMOVEyes = -1 if (fy > 0): correctFROMyes = correctFROMyes * 100.0 / fy else: correctFROMyes = -1 if (p1 > 0): correctWHOLE1 = correctWHOLE1 * 100.0 / p1 else: correctWHOLE1 = -1 if (p2 > 0): correctWHOLE2 = correctWHOLE2 * 100.0 / p2 else: correctWHOLE2 = -1 if (p3 > 0): correctWHOLE3 = correctWHOLE3 * 100.0 / p3 else: correctWHOLE3 = -1 leg = ("\n\tFROM phase 2 leg:\t" + str(legalFROM2) + "\n\tREMOVE when chosen leg:\t" + str(legalREMOVEeat)) if (not statesonly): leg += ("\n--------------------\n\nAccuracy response on " + datasetname + ":" + "\n\tTO accuracy:\t" + str(correctTO) + "\n\tFROM accuracy:\t" + str(correctFROM) + "\n\tREMOVE accuracy:\t" + str(correctREMOVE) + "\n\tWhole MOVE accuracy:\t" + str(correctWHOLE) + "\n\n\tWhole MOVE accuracy in phase 1:\t" + str(correctWHOLE1) + "\n\tWhole MOVE accuracy in phase 2:\t" + str(correctWHOLE2) + "\n\tWhole MOVE accuracy in phase 3:\t" + str(correctWHOLE3) + "\n\n\tFROM not 0 accuracy:\t" + str(correctFROMyes) + "\n\tREMOVE not 0 accuracy:\t" + str(correctREMOVEyes) + "\n\n\n") print(leg) fileT.write(leg) fileT.close()
def choose(TOnet, FROMnet, REMOVEnet, state, data_format): orderc = ['X', 'X', 'X'] orderc[TOnet[1]] = 'T' orderc[FROMnet[1]] = 'F' orderc[REMOVEnet[1]] = 'R' order = "" + orderc[0] + orderc[1] + orderc[2] print(("\tOrder: " + order)) nets = ['X', 'X', 'X'] nets[TOnet[1]] = TOnet nets[FROMnet[1]] = FROMnet nets[REMOVEnet[1]] = REMOVEnet FIRSTpred_fn = nets[0][0] SECONDpred_fn = nets[1][0] THIRDpred_fn = nets[2][0] global illegalTO global illegalFROM global illegalREMOVE illegal = ['X', 'X', 'X'] illegal[TOnet[1]] = illegalTO illegal[FROMnet[1]] = illegalFROM illegal[REMOVEnet[1]] = illegalREMOVE print("Choosing best move: ") print("\tchoosing FIRST position...") # TO choice states = [state] FIRSTstate = process_state_binary(states, data_format) print(data_format) FIRSTprob = FIRSTpred_fn(FIRSTstate) correct = False FIRSTchoice = 0 while not correct: propchoice = numpy.argmax(FIRSTprob[0]) if FIRSTprob[0][propchoice] >= 0: FIRSTchoice = [propchoice] else: print("No legal option aviable") sys.exit() print(("\t\tTOchoice: " + str(FIRSTchoice[0]))) vec_4_leg = [FIRSTchoice, None, None] legalities = get_legalities(vec_4_leg[TOnet[1]], vec_4_leg[FROMnet[1]], vec_4_leg[REMOVEnet[1]], FIRSTstate, data_format) if orderc[0] == 'T': legalities = legalities[0] elif orderc[0] == 'F': legalities = legalities[1] elif orderc[0] == 'R': legalities = legalities[2] if (legalities[0] == 0): FIRSTprob[0][FIRSTchoice[0]] = -1 print("\t\t\tIllegal FIRST choice, retry") illegal[0] += 1 else: correct = True print(orderc) print("\tchoosing SECOND position...") # SECOND choice SECONDstate = add_CHOICE_binary_raw(FIRSTstate, FIRSTchoice) SECONDprob = SECONDpred_fn(SECONDstate) correct = False SECONDchoice = 0 while not correct: propchoice = numpy.argmax(SECONDprob[0]) if SECONDprob[0][propchoice] >= 0: SECONDchoice = [propchoice] else: print("No legal option aviable") sys.exit() print(("\t\tSECONDchoice: " + str(SECONDchoice[0]))) vec_4_leg = [FIRSTchoice, SECONDchoice, None] legalities = get_legalities(vec_4_leg[TOnet[1]], vec_4_leg[FROMnet[1]], vec_4_leg[REMOVEnet[1]], SECONDstate, data_format) if orderc[2] == 'T': legal = legalities[9] elif orderc[2] == 'F': legal = legalities[8] elif orderc[2] == 'R': legal = legalities[5] if (legal[0] == 0): SECONDprob[0][SECONDchoice[0]] = -1 print("\t\t\tIllegal FROM choice, retry") illegal[1] += 1 else: correct = True print("\tchoosing THIRD position...") # REMOVE choice THIRDstate = add_CHOICE_binary_raw(SECONDstate, SECONDchoice) THIRDprob = THIRDpred_fn(THIRDstate) correct = False THIRDchoice = 0 while not correct: propchoice = numpy.argmax(THIRDprob[0]) if THIRDprob[0][propchoice] >= 0: THIRDchoice = [propchoice] else: print("No legal option aviable") sys.exit() print(("\t\tTHIRDchoice: " + str(THIRDchoice[0]))) vec_4_leg = [FIRSTchoice, SECONDchoice, THIRDchoice] legalities = get_legalities(vec_4_leg[TOnet[1]], vec_4_leg[FROMnet[1]], vec_4_leg[REMOVEnet[1]], SECONDstate, data_format)[7] if (legalities[0] == 0): THIRDprob[0][THIRDchoice[0]] = -1 print("\t\t\tIllegal REMOVE choice, retry") illegal[2] += 1 else: correct = True choices = [FIRSTchoice, SECONDchoice, THIRDchoice] return (choices[TOnet[1]][0], choices[FROMnet[1]][0], choices[REMOVEnet[1]][0])
def find_legal_moves(state, bin_state, data_format): """ Compute all the legal partial and complete moves for the given state Parameters ---------- state : State The game state. bin_state : int[] The game state represented as an array data_format : string The representation format of the bin_state Returns ------- set A set of strings with all the legal partial and complete moves """ moves = set() # build 3 set: empty positions, positions with enemy checkers and # positions with owned checkers enemy_pos = [] mine_pos = [] empty_pos = [] for position in range(24): checker = state.positions[position] if checker == 'M': mine_pos.append(position) elif checker == 'E': enemy_pos.append(position) elif checker == 'O': empty_pos.append(position) Tpart = -1 Fpart = -1 Rpart = -1 if (state.my_phase == 1): # the only legal FROM is 0 Fpart = 0 # the legal TO positions are the empty ones for TO_position in empty_pos: Tpart = TO_position + 1 # verify if the option of no remove is legal Rpart = 0 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): moves.add("T" + str(Tpart) + "F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "R" + str(Rpart)) moves.add("F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "F" + str(Fpart)) moves.add("T" + str(Tpart)) moves.add("F" + str(Fpart)) moves.add("R" + str(Rpart)) # if one remove is necessary, all the enemy positions are # candidates else: for REMOVE_position in enemy_pos: Rpart = REMOVE_position + 1 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): moves.add("T" + str(Tpart) + "F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "R" + str(Rpart)) moves.add("F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "F" + str(Fpart)) moves.add("T" + str(Tpart)) moves.add("F" + str(Fpart)) moves.add("R" + str(Rpart)) elif (state.my_phase == 2): # each checker is a legal from position for FROM_position in mine_pos: Fpart = FROM_position + 1 # find the positions which are adjacents to the FROM one adjacent_parts = [] for part in range(len(near[Fpart])): if (near[Fpart][part] == 1): adjacent_parts.append(part) for Tpart in adjacent_parts: TO_position = Tpart - 1 # verify if the option of no remove is legal Rpart = 0 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): moves.add("T" + str(Tpart) + "F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "R" + str(Rpart)) moves.add("F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "F" + str(Fpart)) moves.add("T" + str(Tpart)) moves.add("F" + str(Fpart)) moves.add("R" + str(Rpart)) # if the the legality of the FT couple is confirmed, # one remove is necessary, all the enemy positions are # candidates elif (legality[3][0] == 1): for REMOVE_position in enemy_pos: Rpart = REMOVE_position + 1 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): moves.add("T" + str(Tpart) + "F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "R" + str(Rpart)) moves.add("F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "F" + str(Fpart)) moves.add("T" + str(Tpart)) moves.add("F" + str(Fpart)) moves.add("R" + str(Rpart)) elif (state.my_phase == 3): # each empty position is legal for TO_position in empty_pos: Tpart = TO_position + 1 # each checker is a legal from position for FROM_position in mine_pos: Fpart = FROM_position + 1 # verify if the option of no remove is legal Rpart = 0 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): moves.add("T" + str(Tpart) + "F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "R" + str(Rpart)) moves.add("F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "F" + str(Fpart)) moves.add("T" + str(Tpart)) moves.add("F" + str(Fpart)) moves.add("R" + str(Rpart)) # if one remove is necessary, all the enemy positions are # candidates else: for REMOVE_position in enemy_pos: Rpart = REMOVE_position + 1 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): moves.add("T" + str(Tpart) + "F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "R" + str(Rpart)) moves.add("F" + str(Fpart) + "R" + str(Rpart)) moves.add("T" + str(Tpart) + "F" + str(Fpart)) moves.add("T" + str(Tpart)) moves.add("F" + str(Fpart)) moves.add("R" + str(Rpart)) return moves
def main( datasetname='DATASET.mock.txt', expanded=False, ): """ Computes statistics relative to a dataset legality. Loads a dataset and measures the mean number of legal moves possible in each state and thenumber of states in which a particular move is legal. Parameters ---------- datasetname : string The name of the dataset file. expanded : boolean True if the dataset has been already expanded through symmetries. """ print("Testing " + datasetname + "\nexpanded = " + str(expanded)) print("Testing legality characteristics of " + datasetname + "\nLoading data...") if (expanded): A, B = load_expanded_states_dataset(datasetname) else: A, B = load_states_dataset(datasetname) data_format = "binary raw" X_train = process_state_binary(A, data_format) n_states = len(A) TO_moves = range(1, 25) FROM_moves = range(0, 25) REMOVE_moves = range(0, 25) n_moves = len(TO_moves) * len(FROM_moves) * len(REMOVE_moves) # counter of number of legal moves for each states count_states = [0] * n_states # counter of states in which this move is legal count_moves = [0] * n_moves print( str(n_states) + " data loaded. " + str(n_moves) + " moves considered") fileStates = open(datasetname + "_legmeas_states.txt", 'w') fileMoves = open(datasetname + "_legmeas_moves.txt", 'w') fileRecap = open(datasetname + "_legmeas.txt", 'w') fileStates.write("Testing legality characteristics of " + datasetname + "\n") fileMoves.write("Testing legality characteristics of " + datasetname + "\n") fileMoves.write("T\tF\tR\n") fileRecap.write("Testing legality characteristics of " + datasetname + "\n") perc = 1 start_time = time.time() print("Starting the test...") for i in range(n_states): bin_state = X_train[i] state = A[i] # build 3 set: empty positions, positions with enemy checkers and # positions with owned checkers enemy_pos = [] mine_pos = [] empty_pos = [] for position in range(24): checker = state.positions[position] if checker == 'M': mine_pos.append(position) elif checker == 'E': enemy_pos.append(position) elif checker == 'O': empty_pos.append(position) Tpart = -1 Fpart = -1 Rpart = -1 if (state.my_phase == 1): # the only legal FROM is 0 Fpart = 0 # the legal TO positions are the empty ones for TO_position in empty_pos: Tpart = TO_position + 1 # verify if the option of no remove is legal Rpart = 0 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): count_states[i] += 1 index = (((TO_position) * len(REMOVE_moves) + Fpart) * len(FROM_moves) + Rpart) count_moves[index] += 1 # if one remove is necessary, all the enemy positions are # candidates else: for REMOVE_position in enemy_pos: Rpart = REMOVE_position + 1 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): count_states[i] += 1 index = (( (TO_position) * len(REMOVE_moves) + Fpart) * len(FROM_moves) + Rpart) count_moves[index] += 1 elif (state.my_phase == 2): # each checker is a legal from position for FROM_position in mine_pos: Fpart = FROM_position + 1 # find the positions which are adjacents to the FROM one adjacent_parts = [] for part in range(len(near[Fpart])): if (near[Fpart][part] == 1): adjacent_parts.append(part) for Tpart in adjacent_parts: TO_position = Tpart - 1 # verify if the option of no remove is legal Rpart = 0 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): count_states[i] += 1 index = (((TO_position) * len(REMOVE_moves) + Fpart) * len(FROM_moves) + Rpart) count_moves[index] += 1 # if the the legality of the FT couple is confirmed, # one remove is necessary, all the enemy positions are # candidates elif (legality[3][0] == 1): for REMOVE_position in enemy_pos: Rpart = REMOVE_position + 1 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): count_states[i] += 1 index = (((TO_position) * len(REMOVE_moves) + Fpart) * len(FROM_moves) + Rpart) count_moves[index] += 1 elif (state.my_phase == 3): # each empty position is legal for TO_position in empty_pos: Tpart = TO_position + 1 # each checker is a legal from position for FROM_position in mine_pos: Fpart = FROM_position + 1 # verify if the option of no remove is legal Rpart = 0 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): count_states[i] += 1 index = (((TO_position) * len(REMOVE_moves) + Fpart) * len(FROM_moves) + Rpart) count_moves[index] += 1 # if one remove is necessary, all the enemy positions are # candidates else: for REMOVE_position in enemy_pos: Rpart = REMOVE_position + 1 legality = get_legalities([Tpart], [Fpart], [Rpart], [bin_state], data_format) if (legality[7][0] == 1): count_states[i] += 1 index = (((TO_position) * len(REMOVE_moves) + Fpart) * len(FROM_moves) + Rpart) count_moves[index] += 1 fileStates.write(str(A[i]) + "\t-\t" + str(count_states[i]) + "\n") act_time = time.time() percentage = i * 100 / (n_states * 1.0) # gives feedback about the amount of data processed while (percentage > perc): perc += 1 print( str(round(percentage, 2)) + "%\t" + str(i) + " data processed\ttime passed: " + str(act_time - start_time)) fileStates.flush() act_time = time.time() print("Data processed. Seconds passed: " + str(act_time - start_time)) fileStates.close() for TO_opt in TO_moves: for FROM_opt in FROM_moves: for REMOVE_opt in REMOVE_moves: index = ((TO_opt - 1) * len(FROM_moves) * len(REMOVE_moves) + FROM_opt * len(REMOVE_moves) + REMOVE_opt) num = count_moves[index] fileMoves.write( str(TO_opt) + "\t" + str(FROM_opt) + "\t" + str(REMOVE_opt) + "\t-\t" + str(num) + "\n") fileMoves.close() meanStates = numpy.mean(count_states) meanMoves = numpy.mean(count_moves) fileRecap.write("Mean legal moves per state:\t" + str(meanStates) + "\n") fileRecap.write("Mean states in which the move is legal:\t" + str(meanMoves) + "\n\n") table = {} for count in count_states: # count the number of moves as a percentage of the total percentage = count if percentage in table.keys(): table[percentage] += 1 else: table[percentage] = 1 for percentage in table.keys(): fileRecap.write(str(percentage) + "\t" + str(table[percentage]) + "\n") fileRecap.close()