def scramble_cube(self, n_moves=1000): move_list = [] move_string = '' move_formula = pc.Formula(move_string) while (len(move_list) < n_moves): move = self.random_move() move_string = move_string + ' ' + move move_formula = pc.Formula(move_string).optimise() move_list = move_formula.__repr__().split(" ") output_moves = copy.deepcopy(move_formula) solution = move_formula.reverse() return output_moves, solution
def cubeSolve(moves): count = 0 space = " " cube = pc.Cube() cube(random_alg) #First solve the Bottom face if count == 0: face = 'D' solvedFace = solved.get_face(face) tempMoves = list(moves) for i in range(len(moves)): move = tempMoves.pop(0) count = 0 my_formula = pc.Formula(move) cube(my_formula) cubeFace = cube.get_face(face) for i in range(0, 3): for y in range(0, 3): if (cubeFace[i][y] == solvedFace[i][y]): count += 1 if count >= 9: print(fCount) count += 9 + len(tempMoves) break #If bottom face is solved solve the lower parts of the surrounding faces if count >= 9: faceLoop = ['D', 'F', 'R', 'B', 'L'] rMoves = len(tempMoves) for i in range(rMoves): move = tempMoves.pop(0) fCount = 0 my_formula = pc.Formula(move) cube(my_formula) for face in faces: solvedFace = solved.get_face(face) cubeFace = cube.get_face(face) for i in range(0, 3): for y in range(0, 3): if (cubeFace[i][y] == solvedFace[i][y]): fCount += 1 if fCount >= 33: count += 33 break if (count == 0): count = howClose(moves) % 3 return count
def generate_game(max_moves=max_moves): # generate a single game with max number of permutations number_moves mycube = pc.Cube() global possible_moves formula = [] cube_original = cube2np(mycube) number_moves = max_moves # randint(3,max_moves) for j in range(number_moves): formula.append(possible_moves[randint(0, len(possible_moves) - 1)]) # my_formula = pc.Formula("R U R' U' D' R' F R2 U' D D R' U' R U R' D' F'") my_formula = pc.Formula(formula) # print(my_formula) mycube = mycube((my_formula)) # use this instead if you want it in OG data type cube_scrambled = mycube.copy() solution = my_formula.reverse() # print(mycube) return cube_scrambled, solution
def generate_game(max_moves=6): # generate a single game with max number of permutations number_moves mycube = pc.Cube() global possible_moves formula = [] cube_original = cube2np(mycube) number_moves = max_moves #randint(3,max_moves) action = randint(0, len(possible_moves) - 1) for j in range(number_moves): formula.append(possible_moves[action]) new_action = randint(0, len(possible_moves) - 4) delta = action % 3 action_face = action - delta if new_action >= action_face: new_action += 3 action = new_action #my_formula = pc.Formula("R U R' U' D' R' F R2 U' D D R' U' R U R' D' F'") my_formula = pc.Formula(formula) mycube = mycube((my_formula)) # use this instead if you want it in OG data type cube_scrambled = mycube solution = my_formula.reverse() #print(mycube) return cube_scrambled, formula, solution
def gen_sequence_plus_1(n_steps=6): cube = pc.Cube() transformation = [ choice(list(action_map_small.keys())) for _ in range(n_steps - 1) ] my_formula = pc.Formula(transformation) cube(my_formula) my_formula.reverse() cubes = [] distance_to_solved = [] for i, s in enumerate(my_formula): cubes.append(cube.copy()) cube(s.name) distance_to_solved.append(n_steps - i - 1) cubes.append(pc.Cube()) distance_to_solved.append(0) return cubes, distance_to_solved
def test_for_basic_ability_to_solve(): c = pc.Cube() alg = pc.Formula() random_alg = alg.random() c(random_alg) solver = CFOPSolver(c) solver.solve()
def gen_sample(max_steps=6): n_steps = randrange(max_steps + 1) cube = pc.Cube() transformation = [choice(list(action_map.keys())) for _ in range(n_steps)] my_formula = pc.Formula(transformation) cube(my_formula) return cube
def robot_turn(self, cube, formula): y_next = {"L": "F", "F": "R", "R": "B", "B": "L", "U": "U", "D": "D"} new_formula = pc.Formula() for i in formula: new_formula += i.set_face(y_next[i.face]) return cube("y'"), new_formula
def scramble(): cube = pc.Cube() actions = [] for i in range(3): actions.append(r.choice(list(action_map.keys()))) formula = pc.Formula(actions) cube(formula) return cube, formula
def calculate_solve(self, part='ALL'): if type(part != str): return 1 part = part.upper() if part == 'ALL': # Solve the entire cube formula = pycuber.Formula(self.all_moves) formula.reverse() return str(formula)
def kociemba(self, cube): base = os.path.dirname(os.path.realpath(__file__)) executable = os.path.join(base, "kociemba") cachepath = os.path.join(base, "cache") # execute arm binary on arm if platform.machine() == "armv7l": executable += "-armv7l" # get color map of current cube as kociemba expects the center # pieces to be in the right position cmap = {} for i in list("UDLRBF"): cmap[cube.get_face(i)[1][1].colour] = i # check if the executable really is executable # as the file came from a zip during installation it # may not have the executable flag set st = os.stat(executable) if not (st.st_mode & stat.S_IEXEC): os.chmod(executable, st.st_mode | stat.S_IEXEC) # get cube string cube_str = self.dump_cube(cube, cmap) # run external kociemba program try: proc = subprocess.Popen([executable, cachepath, cube_str], stdout=subprocess.PIPE, stderr=subprocess.PIPE) response = proc.communicate() response_stdout = response[0].decode('UTF-8') if proc.returncode != 0: print("Program returned an error code", proc.returncode) print("Response: ", response_stdout) return None except OSError as e: if e.errno == errno.ENOENT: print(("Unable to locate program %s" % executable)) else: print(("Error occured \"%s\"" % str(e))) return None except ValueError as e: print("Value error occured. Check your parameters.") return None if response_stdout != "Unsolvable cube!\n": return pc.Formula(response_stdout) return None
def test_solver(self): cube = pycuber.Cube() initial_cube = str(cube) alg = pycuber.Formula() random_alg = alg.random() cube(random_alg) assert initial_cube != str(cube), "Randomization haven't worked." solution = solve_fast(cube) print(solution) for step in solution.split(" "): cube.perform_step(step) assert initial_cube == str(cube), "Fast solution doesn't work"
def generate_game(max_moves=10): # generate a single game with max number of permutations number_moves mycube = pc.Cube() global possible_moves formula = [] number_moves = max_moves #randint(3,max_moves) for j in range(number_moves): formula.append(possible_moves[randint(0, len(possible_moves) - 1)]) my_formula = pc.Formula(formula) mycube = mycube((my_formula)) cube_scrambled = mycube.copy() return cube_scrambled
def step(self, action): lookup = [ "R", "L", "D", "U", "B", "F", "R'", "L'", "D'", "U'", "B'", "F'" ] #We are not accounting for half turns tcube = self.cube.copy() step_taken = pc.Formula(lookup[action]) self.cube(step_taken) rwd, over = self.reward(tcube) return utils.flatten_1d_b(self.cube), rwd, over
def reset(self, max_scrambles): self.cube = pc.Cube() alg = pc.Formula() #Random arrangement random_alg = alg.random() if max_scrambles == None: pass else: max_scrambles = np.random.choice(list(range(max_scrambles))) random_alg = random_alg[:max_scrambles] self.cube(random_alg) # print(utils.perc_solved_cube(self.cube)*100) return utils.flatten_1d_b(self.cube) #return states
def turn_2s_into_2_moves(formula): out_list = [] for move in formula: str_move = str(move) if (("2" in str_move) & (len(str_move) == 2)): out_move = str_move[0] out_list.append(out_move) elif (("2" in str_move) & (len(str_move) == 3)): out_move = str_move[0] + str_move[-1] out_list.append(out_move) else: out_move = str_move out_list.append(out_move) return pc.Formula(out_list)
def howClose(moves): count = 0 space = " " string = space.join(moves) my_formula = pc.Formula(string) cube = pc.Cube() cube(random_alg) cube(my_formula) for face in faces: solvedFace = solved.get_face(face) cubeFace = cube.get_face(face) for i in range(0, 3): for y in range(0, 3): if (cubeFace[i][y] == solvedFace[i][y]): count = count + 1 return count
def generate_sequence(prob=100, reward={}): # prob is the probability that we will solve the cube by reversing the actions which scrambled it # prob is 100 by default scrambled_cube = pc.Cube() actions = [] states_cube_list = [] value_list = [] # The following lines scrambles the cubes using 3 actions for i in range(3): actions.append(r.choice(list(action_map.keys()))) formula = pc.Formula(actions) scrambled_cube(formula) # The following loop tries to solve the scrambled cube 10 times for i in range(10): # cube is a copy of the scrambled_cube # the scrambled state is being kept in scrambled_cube while cube is being solved cube = scrambled_cube.copy() total_steps = 0 random_number = r.randint(0, 100) if random_number <= prob: # The following code solves the cube by reversing the actions that it was scrambled with formula.reverse() for k, move in enumerate(formula): states_cube_list.append(cube.copy()) cube(move) total_steps += 1 else: while total_steps < 6 and cube_completeness(cube) < 1: best_move = list(action_map.keys()) max_value = 0 for move in action_map.keys(): init_cube = cube.copy() init_cube(move) if flatten_string(init_cube) in reward: if reward[flatten_string(init_cube)] > max_value: best_move = [move] max_value = reward[flatten_string(init_cube)] elif reward[flatten_string(init_cube)] > max_value: best_move.append(move) states_cube_list.append(cube.copy()) cube(r.choice(best_move)) total_steps += 1 final_reward = 100 * (cube_completeness(cube) == 1) - 5 * total_steps for step, state in enumerate(states_cube_list): value = final_reward * math.pow(0.9, step + 1) value_list.append(value) return states_cube_list, value_list
def get_best_move(self, model, last_move, noise=None, return_cubes=False, return_moves=False): moves = [ 'F', 'U', 'R', 'D', 'L', 'B', 'F\'', 'U\'', 'R\'', 'D\'', 'L\'', 'B\'' ] if (last_move is not None): reverse_last_move = pc.Formula(last_move).reverse().__str__() moves.remove(reverse_last_move) predictions = [] cubes = [] for move in moves: new_cube = self.copy() new_cube(move) cubes.append(new_cube) predictions.append(model.predict_score(new_cube)) if (noise): avg_prediction = int(np.floor(np.mean(predictions))) if (avg_prediction >= len(noise)): sum_noise = noise[-1] else: sum_noise = noise[avg_prediction] predictions = [ p + np.random.normal(0, sum_noise) for p in predictions ] predictions_dict = dict(zip(moves, predictions)) out_array = [moves[np.argmin(predictions)], predictions_dict] if (return_cubes): out_array.append(cubes) if (return_moves): out_array.append(moves) return out_array
def __init__(self, n_moves=100): def get_game_states(move_formula, solve_formula): cube = Cube() cube(move_formula) game_states = [] for move in solve_formula: cube(move) game_state = cube.copy() game_states.append(game_state) return game_states def turn_2s_into_2_moves(formula): out_list = [] for move in formula: str_move = str(move) if (("2" in str_move) & (len(str_move) == 2)): out_move = str_move[0] out_list.append(out_move) elif (("2" in str_move) & (len(str_move) == 3)): out_move = str_move[0] + str_move[-1] out_list.append(out_move) else: out_move = str_move out_list.append(out_move) return pc.Formula(out_list) moves = [ 'F', 'U', 'R', 'D', 'L', 'B', 'F\'', 'U\'', 'R\'', 'D\'', 'L\'', 'B\'' ] move_list = np.random.choice(moves, n_moves) move_formula = pc.Formula(" ".join(move_list)).optimise() move_formula = turn_2s_into_2_moves(move_formula) self.solve_formula = copy.copy(move_formula) self.solve_formula.reverse() self.game_states = get_game_states(move_formula, self.solve_formula)
def get_new_sets(self, model, last_set): base_formula = last_set['Formula'] if (base_formula.__str__() == '[]'): last_move = last_set['Formula'][-1].__str__() base_formula = base_formula[0] last_move = None else: last_move = base_formula[-1] _, prediction_dict, cubes, moves = self.get_best_move( model, last_move, return_cubes=True, return_moves=True) formulas = [ pc.Formula(base_formula.__str__() + ' ' + move) for move in moves ] predictions = [prediction_dict[move] for move in moves] out_sets = np.array(zip(formulas, cubes, predictions), dtype=last_set.dtype) return out_sets
def gen_sample(n_steps=6): cube = pc.Cube() transformation = [choice(list(action_map.keys())) for _ in range(n_steps)] my_formula = pc.Formula(transformation) cube(my_formula) my_formula.reverse() sample_X = [] sample_Y = [] cubes = [] for s in my_formula: sample_X.append(flatted_1d(cube)) sample_Y.append(action_map[s.name]) cubes.append(cube.copy()) cube(s.name) return sample_X, sample_Y, cubes
def generate_sample(steps=3): # this method generates samples of a cube that is randomly scrambled for a number of steps, default 3 steps # returns a list of the state, flattened state, action, and distance from solved for the cube at each step cube = pc.Cube() actions = [] for i in range(steps): actions.append(choice(list(action_map.keys()))) formula = pc.Formula(actions) cube(formula) formula.reverse() actions_list = [] states_cube_list = [] states_1d_list = [] distance_list = [] i = 0 for s in formula: actions_list.append(s) states_cube_list.append(cube.copy()) distance_list.append(steps - i) cube(s) i += 1 return actions_list, states_cube_list, distance_list
def gen_sample_2(move_list, n_steps=6): cube = pc.Cube() transformation = [] for act in move_list: transformation.append(new_action__per_number[act]) # transformation = [choice(list(action_map.keys())) for _ in range(n_steps)] print(transformation) my_formula = pc.Formula(transformation) cube(my_formula) my_formula.reverse() sample_X = [] sample_Y = [] cubes = [] for s in my_formula: sample_X.append(flatten_1d_b(cube)) sample_Y.append(action_map[s.name]) cubes.append(cube.copy()) cube(s.name) return sample_X, sample_Y, cubes
def solve_search(self, model, max_iter=100, show=False): def get_new_sets(self, model, last_set): base_formula = last_set['Formula'] if (base_formula.__str__() == '[]'): last_move = last_set['Formula'][-1].__str__() base_formula = base_formula[0] last_move = None else: last_move = base_formula[-1] _, prediction_dict, cubes, moves = self.get_best_move( model, last_move, return_cubes=True, return_moves=True) formulas = [ pc.Formula(base_formula.__str__() + ' ' + move) for move in moves ] predictions = [prediction_dict[move] for move in moves] out_sets = np.array(zip(formulas, cubes, predictions), dtype=last_set.dtype) return out_sets def prune_set(self, model, new_sets, alpha=4): cube_prediction = model.predict_score(self) out_sets = new_sets[new_sets['Prediction'] < (cube_prediction + alpha)] return out_sets def get_minimum_state(saved_states): index = np.argmin(saved_states['Prediction']) out_state = saved_states[index] return out_state, index def stuck_in_loop(current_state): f = current_state['Formula'] if (len(f) < 3): return False elif (f[-1] == f[-2] == f[-3]): return True else: return False original_cube = self.copy() saved_states = np.empty(0, dtype=[('Formula', object), ('Cube', object), ('Prediction', 'f8')]) last_set = np.array([(pc.Formula(), self.copy(), 100)], dtype=saved_states.dtype) current_state = last_set for _ in range(max_iter + 1): if (self.is_completed()): break if ((_ > 0) & (saved_states.size == 0)): break new_sets = get_new_sets(self, model, last_set) pruned_set = prune_set(self, model, new_sets) if (pruned_set.size > 0): saved_states = np.append(saved_states, pruned_set) current_state, current_state_index = get_minimum_state( saved_states) saved_states = np.delete(saved_states, current_state_index) if (stuck_in_loop(current_state)): current_state, current_state_index = get_minimum_state( saved_states) saved_states = np.delete(saved_states, current_state_index) self = current_state['Cube'].copy() last_set = current_state current_state return original_cube, self, _, current_state['Formula']
cube = pc.Cube() totalScore = 0 # Load the model saver.restore(sess, "./models/model.ckpt") # saver.restore(sess, "./best_model/model.ckpt") # while(1): print("New Episode") saa = int(input("Shuffle : ") ) cube = pc.Cube() transformation = [choice(list(action_map_small.keys())) for z in range(saa)] my_formula = pc.Formula(transformation) cube(my_formula) run = True print("********************************************************") print("START : ") print([cube]) print("********************************************************") time.sleep(3) while run: if perc_solved_cube(cube) == 1: run = False
def test_inverse(): # test to make sure they invert correctly based off of hand inverted algs for i, alg in enumerate(orig_algs): plausible = pc.Formula(alg).reverse() assert str(plausible) == inverted_algs[i]
global line3 line1, = ax.plot([0, .18], [0, 54], 'r.') line2, = ax.plot([0, .18], [0, 54], 'go') line3, = ax.plot([0, .18], [0, 54], 'b.') if len(sys.argv) < 4: print("Must include 'numGens popSize numberOfMoves'") exit() elif int(sys.argv[2]) < 2 or int(sys.argv[2]) % 2 != 0: print("Pop size must be 2 or greater and even") exit() elif int(sys.argv[3]) < 1: print("numAllowedMoves must be 1 or more") exit() alg = pc.Formula() random_alg = alg.random() #Converts moves to a decimal fraction, used for plotting and sharing def moves2dec(movesCube): fraction = "0." for move in movesCube: index = moves.index(move) if (index < 10): fraction += "0" + str(index) else: fraction += str(index) return float(fraction)
def test_double_inverting(): # two inverts successive should revert back to the original algorithm for alg in orig_algs: assert alg == str(pc.Formula(alg).reverse().reverse())
def scramble_cube(mycube): algo = pc.Formula() random_alg = algo.random() return mycube(random_alg), random_alg