def play(): # get from sudoku.py easy1 = '..3.2.6..9..3.5..1..18.64....81.29..7.......8..67.82....26.95..8..2.3..9..5.1.3..' harder1 = '4173698.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......' for puzzle in [easy1, harder1]: # for puzzle in [easy1]: s = Sudoku(puzzle) # Initial sudoku state print("\nInitial problem:") s.display(s.infer_assignment()) # The state of the puzzle after running AC3. AC3(s) if s.goal_test(s.curr_domains): print("\nAfter AC3 constraint propagation\n") s.display(s.infer_assignment()) # if goal test fail try to find solution elif not s.goal_test(s.curr_domains): # run back track search solution = backtracking_search(s, select_unassigned_variable=mrv) if solution: print("\nSolved using backtracking:") s.display(s.infer_assignment()) else: print("\nCould not be solved using backtrack\n") s.display(s.infer_assignment())
def solve(params, initial_guess, converge_step): (X,y,m) = params #A function which calculates the gradient at a point grad_func = lc.gen_gradient_function(X,y,m) # A function which calculates the likelihood at a point llh_func = lc.gen_likelihood_function(X,y,m) delta = sys.float_info.max # Initial values for change between iteration guess = initial_guess LLVal = 0 # Dummy likelihood value iterct = 0 # For storing likelihoods (for tracking convergence) likelihood_record = [] ## Main Steepest Descent Lofunc while delta > converge_step: oldLLVal = LLVal oldGuess = guess grad = grad_func(guess) searchDir = -grad step = backtracking_search(grad_func, llh_func, guess, searchDir) guess = guess + searchDir * step # Calculate current likelihood for convergence determination LLVal = llh_func(guess) delta = abs( oldLLVal - LLVal ) likelihood_record.append(LLVal) # Update the user and break out if needed iterct += 1 print("Iter: " + str(iterct) + ", objective is " + str(LLVal) + " step size: " + str(step)) if iterct > 10000: print("Reached 10000 iterations w/o convergence, aborting computation") break return (guess,likelihood_record)
def main(): file_text,select_unassigned_var,order_domain_vals,inference,domains = get_input() input_lines = [line.strip() for line in file_text.split('\n')] variables,values,limits,unary_inc,unary_ex,binary_eq,binary_ne,binary_mutual_ex = read_file(input_lines) var_names = variables.keys() val_names = values.keys() create_constraint_matrices(var_names,val_names,unary_inc,unary_ex,binary_eq,binary_ne,binary_mutual_ex) result = backtracking_search(values,variables,limits[0],limits[1],_constraint_matrices, select_unassigned_var, order_domain_vals, inference, domains) if result is None: print "Unsolvable!!!" exit(0) result_keys = result.keys() result_keys.sort() for valuable in result_keys: print "%s %s" % (valuable,result[valuable])
def game(): print("================================= Sudoku ==================================") print("CS 550 Artificial Intelligence | Prof. Roch | Assignment 4 | kingofthenorth") print("============================= Creating game... ============================") game_start = time.time() for puzzle in [easy1, harder1]: # Creates an instance of the puzzle to work with s = Sudoku(puzzle) # Creates a viewable interface of the working sudoku puzzle print("\nInitial problem:") s.display(s.infer_assignment()) # Applies the AC3 constraint AC3(s) print("\nAfter AC3 constraint propagation applied!") # Keeps track of time of the puzzle puzzle_start = time.time() # If goal is not reached yet, keep trying to find a solution if not s.goal_test(s.curr_domains): print("\nBacktracking search starting...") result = backtracking_search(s, select_unassigned_variable=mrv) if result: # Success print("\nBacktracking solution:") s.display(s.infer_assignment()) else: # Failure print("\nBacktracking failed! :(") current = time.time() # Time information to be relayed print("\nPuzzle time: {} | Overall time: {}".format( elapsed(puzzle_start, current), elapsed(game_start, current)))
from csp_lib.sudoku import (Sudoku, easy1, harder1) from constraint_prop import AC3 from backtrack import backtracking_search from csp_lib.backtrack_util import mrv, mac easy_puzzle = Sudoku(easy1) easy_puzzle.display(easy_puzzle.infer_assignment()) print(AC3(easy_puzzle)) easy_puzzle.display(easy_puzzle.infer_assignment()) hard_puzzle = Sudoku(harder1) hard_puzzle.display(hard_puzzle.infer_assignment()) print(AC3(easy_puzzle)) result = backtracking_search(hard_puzzle, select_unassigned_variable=mrv, inference=mac) #print("result = " + str(result)) hard_puzzle.display(hard_puzzle.infer_assignment()) #easy_puzzle.display(easy_puzzle.infer_assignment()) ''' print("\n") print("Domains Stuff") print("print(easy_puzzle.domains)") print(easy_puzzle.domains) print("print(len(easy_puzzle.domains))") print(len(easy_puzzle.domains)) print("print(type(easy_puzzle.domains[0]))") print(type(easy_puzzle.domains[0])) print("print(type(easy_puzzle.domains[2]))")
def is_solved(sudoku: Sudoku): for var in sudoku.curr_domains: if len(sudoku.curr_domains[var]) is not 1: return False return True if __name__ == "__main__": for puzzle in [easy1, harder1]: # for puzzle in [easy1]: s = Sudoku(puzzle) # construct a Sudoku problem print("New Sudoku Puzzle") s.display(s.infer_assignment()) AC3(s) if is_solved(s): print("Solved via AC3") s.display(s.infer_assignment()) else: print("Could not solve via AC3: Current Puzzle") s.display(s.infer_assignment()) print("Trying to solve via Back Track") backtracking_search(s, inference=forward_checking, order_domain_values=lcv, select_unassigned_variable=mrv) if is_solved(s): print("Solved via Back Track") s.display(s.infer_assignment()) else: print("Puzzle could not be solved: Current State") s.display(s.infer_assignment())
from csp_lib.sudoku import (Sudoku, easy1, harder1) from constraint_prop import AC3 from csp_lib.backtrack_util import mrv, forward_checking, first_unassigned_variable, unordered_domain_values, no_inference from backtrack import backtracking_search for puzzle in [easy1, harder1]: s = Sudoku(puzzle) # construct a Sudoku problem print("---initial state---") s.display(s.infer_assignment()) print("\n") AC3(s) print("---after AC3---") s.display(s.infer_assignment()) print("\n") if not s.goal_test(s.curr_domains): solved = backtracking_search(s, select_unassigned_variable=mrv, inference=forward_checking) print("---after backtracking---") s.display(solved)
for puzzle in [easy1, harder1]: sudoku_instance = Sudoku(puzzle) print("We have the following Sudoku puzzle to solve:", end="\n\n") sudoku_instance.display(sudoku_instance.infer_assignment()) print("\nStarting constraint propagation (AC3) algorithm.") AC3(sudoku_instance) print("AC3 algorithm was successfully completed.") if sudoku_instance.goal_test(sudoku_instance.curr_domains): print("Problem was solved by AC3. Here is the solution:", end="\n\n") sudoku_instance.display(sudoku_instance.infer_assignment()) print() else: print("Problem was not solved by AC3. Here is how it looks like:", end="\n\n") sudoku_instance.display(sudoku_instance.infer_assignment()) print() print("We should start searching ...") search_result = backtracking_search(sudoku_instance, mrv, lcv, mac) print("Search has been completed successfully.") if sudoku_instance.goal_test(search_result): print("Given constraint satisfaction problem has been " "successfully solved by backtracking search algorithm. Here " "it the solution:", end='\n\n') sudoku_instance.display(sudoku_instance.infer_assignment()) else: print("Backtracking search algorithm was not able to solve the " "problem.", end='\n\n') sudoku_instance.display(sudoku_instance.infer_assignment())
h = Sudoku(puzzle) # construct a Sudoku problem hard1 print("Initial State hard") print() h.display(h.infer_assignment()) print() print('Solving the problem. Apply AC3...') print() AC3(h) print() for var in h.curr_domains: h.curr_domains[var] = list(h.domains[var]) if not h.goal_test(h.curr_domains): print("After AC3") h.display(h.infer_assignment()) print() print("Try backtraking") print() solved = backtracking_search(h, select_unassigned_variable=mrv, order_domain_values=lcv, inference=forward_checking) print("Final status") print() if solved is None: print("The problem was not solved") else: if h.goal_test(solved): h.display(solved) else: print("Invalid solution")
def solve(params, initial_guess, converge_step): ### VALUE INITIALIZATION (X, y, m) = params (N, P) = np.shape(X) #A function which calculates the gradient at a point grad_func = lc.gen_gradient_function(X, y, m) # A function which calculates the likelihood at a point llh_func = lc.gen_likelihood_function(X, y, m) # A function to calculate the Hessian (only used for initialization) hess_func = gen_hessian_function(X, y, m) delta = sys.float_info.max # Initial values for change between iteration guess = initial_guess LLVal = 0 # Dummy likelihood value iterct = 0 # For storing likelihoods (for tracking convergence) likelihood_record = [] ### STEEPEST DESCENT BURN-IN # Do a few iterations of steepest descent to burn in Hessian B = hess_func(guess) while npla.cond(B) > 1e6: oldLLVal = LLVal oldGuess = guess grad = grad_func(guess) searchDir = -grad step = backtracking_search(grad_func, llh_func, guess, searchDir) guess = guess + searchDir * step B = hess_func(guess) oldGrad = grad ### ACTUAL BFGS CODE # We now have a suitable B for inversion. Calculate it and update w/ BFGS H = B.I grad = grad_func( guess) #Also compute gradient so BGFS has a "previous gradient" # BFGS Mainloop while delta > converge_step: # Find search direction and update searchDir = -np.dot(H, oldGrad) step = backtracking_search(grad_func, llh_func, guess, searchDir) guess = guess + searchDir * step # Update gradient guess grad = grad_func(guess) # Update inverse Hessian approximation s = (guess - oldGuess) y = (grad - oldGrad) p = 1 / np.asscalar(np.dot(y.T, s)) I = np.identity(P) # Calculate update matrix (I - p * s * y.T) updMat = I - p * s * y.T # Update H H = updMat * H * updMat + p * s * s.T # Calculate current likelihood for convergence determination LLVal = llh_func(guess) delta = abs(oldLLVal - LLVal) # Update recordkeeping values oldLLVal = LLVal oldGuess = guess oldGrad = grad likelihood_record.append(LLVal) # Update the user and break out if needed iterct += 1 print("Iter: " + str(iterct) + ", objective is: " + str(LLVal)\ + " Step size is: " + str(step)) if iterct > 10000: print( "Reached 10000 iterations w/o convergence, aborting computation" ) break return (guess, likelihood_record)
for puzzle in [easy1]: easy = Sudoku(easy1) # constructing the easy Sudoku problem print("Easy Sudoku Problem:") easy.display(easy.infer_assignment()) AC3(easy) #Calling Constraint Propagation to solve print("\n") print("After calling AC3:") easy.display(easy.infer_assignment()) if not easy.goal_test(easy.curr_domains): print("\n") print("Backtracking easy problem...") result = backtracking_search(easy, select_unassigned_variable=mrv) if result: print("After backtracking:") easy.display(easy.infer_assignment()) for puzzle in [harder1]: hard = Sudoku(puzzle) # constructing the hard Sudoku problem print("\n") print("Hard Sudoku Problem:") hard.display(hard.infer_assignment()) AC3(hard) #Calling Constraint Propagation to solve print("\n") print("After calling AC3:") hard.display(hard.infer_assignment())
from csp_lib.sudoku import (Sudoku, easy1, harder1) from constraint_prop import AC3 from csp_lib.backtrack_util import mrv, mac from backtrack import backtracking_search import queue for puzzle in [easy1, harder1]: s = Sudoku(puzzle) # construct a Sudoku problem s.display(s.infer_assignment()) constraints_satisfied = AC3( s ) # returns true or false This is to trigger Backtrack_search, Revise alters domains if constraints_satisfied is True: # goal test instead solved = backtracking_search(csp=s, select_unassigned_variable=mrv, inference=mac) if solved is not None: print("backtrack search solution:") s.display(s.infer_assignment()) else: print("This sudoku puzzle is not solvable") else: s.display( s.infer_assignment() ) # will display an updated board, because e was manipulated inside algorithm using revise def # or do I test to see if its solved, # goalstate '''Output . . 3 | . 2 . | 6 . . 9 . . | 3 . 5 | . . 1 . . 1 | 8 . 6 | 4 . . ------+-------+------
from csp_lib.sudoku import (Sudoku, easy1, harder1) from constraint_prop import AC3 from csp_lib.backtrack_util import mrv from backtrack import backtracking_search for puzzle in [easy1, harder1]: s = Sudoku(puzzle) # construct a Sudoku problem # display initial state print("\nSudoku puzzle initial state") s.display(s.infer_assignment()) # run constraint satisfaction arc consistency AC3(s) # iterate through variables and add them to puzzle if possible for val in s.domains: if len(s.domains[val]) == 1: s.suppose(val, s.domains[val][0]) # display state after AC3 print("\nSudoku puzzle state after AC3") s.display(s.infer_assignment()) # check if goal has been reached by AC3 if not s.goal_test(s.curr_domains): # run backtracking search if domains need work solved = backtracking_search(s) print("\nSudoku state after AC3 and backtracking search") s.display(s.infer_assignment())