def resolver(metodo_busqueda, iteraciones, haz, reinicios): visor = ConsoleViewer() if (metodo_busqueda == 'hill_climbing'): resultado = hill_climbing(problem=HnefataflProblema(INITIAL), iterations_limit=iteraciones) return resultado if (metodo_busqueda == 'hill_climbing_stochastic'): resultado = hill_climbing_stochastic( problem=HnefataflProblema(INITIAL), iterations_limit=iteraciones) return resultado if (metodo_busqueda == 'beam'): resultado = beam(problem=HnefataflProblema(None), beam_size=haz, iterations_limit=iteraciones) return resultado if (metodo_busqueda == 'hill_climbing_random_restarts'): resultado = hill_climbing_random_restarts( problem=HnefataflProblema(None), restarts_limit=reinicios, iterations_limit=iteraciones) return resultado if (metodo_busqueda == 'simulated_annealing'): resultado = simulated_annealing(problem=HnefataflProblema(INITIAL), iterations_limit=iteraciones) return resultado
def resolver(metodo_busqueda): vwr = BaseViewer() if metodo_busqueda == "hill_climbing": result = hill_climbing(DotaArmamento(INITIAL), viewer=vwr, iterations_limit=1000) elif metodo_busqueda == "beam": result = beam(DotaArmamento(), beam_size=100, viewer=vwr, iterations_limit=1000) elif metodo_busqueda == "hill_climbing_random_restarts": result = hill_climbing_random_restarts(DotaArmamento(), restarts_limit=100, viewer=vwr, iterations_limit=1000) return result
def pixelize_image(self, method, points=None): best_state = None triangle_mask = None if points is None: best_state = cacher.best_state(self.image_name, self.max_points) if best_state is not None: triangle_mask = best_state if triangle_mask is None: triangle_mask = TriangleMask(self.width, self.height) my_problem = SplitProblem( triangle_mask, split_image=self ) if method == "astar": result = astar(my_problem, graph_search = True) elif method == "beam": result = beam(my_problem) elif method == "hill_random": result = hill_climbing_random_restarts(my_problem, 1) elif method == "hill": result = hill_climbing(my_problem) else: print("Invalid method: {}".format(method)) return print("FINAL RESULT REACHED") print("RESULT: {}".format( result.state.triangles)) # TODO: Make caching work with triangle masks cacher.persist_log( self.image_name ) triangle_mask = result.state triangles = triangle_mask.triangles self.display(triangles) if self.wait: a = input("Would you like to improve on this?\n") a = a.upper().strip() if a not in {"Y","YES","YUP","YEAH"}: return method_temp = input("Which method? [{}]\n".format(method)).strip().lower() if method_temp: method = method_temp max_points = input("How many points? [{}]\n".format(self.max_points)).strip() if max_points: self.max_points = int(max_points) return self.pixelize_image(method, points) return triangles
def resolver(metodo_busqueda, iteraciones, haz, reinicios): #problema = Hnefatafl(INICIAL) if metodo_busqueda == "hill_climbing": resultado = hill_climbing(Hnefatafl(INICIAL), iteraciones) if metodo_busqueda == "hill_climbing_stochastic": resultado = hill_climbing_stochastic(Hnefatafl(INICIAL), iteraciones) if metodo_busqueda == "hill_climbing_random_restarts": resultado = hill_climbing_random_restarts(Hnefatafl(None), reinicios, iteraciones) if metodo_busqueda == "beam": resultado = beam(Hnefatafl(INICIAL), beam_size = haz, iterations_limit = iteraciones) if metodo_busqueda == "simulated_annealing": resultado = simulated_annealing(Hnefatafl(INICIAL), iterations_limit = iteraciones) return resultado
def resolver(metodo_busqueda, iteraciones, haz, reinicios): problema = HnefataflProblem(inicial()) if metodo_busqueda == "hill_climbing": resultado = hill_climbing(problema, iteraciones) return resultado if metodo_busqueda == "hill_climbing_stochastic": return hill_climbing_stochastic(problema, iteraciones) if metodo_busqueda == "beam": return beam(problema, haz, iteraciones) if metodo_busqueda == "hill_climbing_random_restarts": return hill_climbing_random_restarts(problema, reinicios, iteraciones) if metodo_busqueda == "simulated_annealing": return simulated_annealing(problema, iterations_limit=iteraciones)
def resolver(metodo_busqueda, iteraciones, haz, reinicios): problema_inicial = Hnefatafl2(INICIAL) if metodo_busqueda == "hill_climbing": return hill_climbing(problema_inicial, iteraciones) if metodo_busqueda == "hill_climbing_stochastic": return hill_climbing_stochastic(problema_inicial, iteraciones) if metodo_busqueda == "beam": return beam(problema_inicial, haz, iteraciones) if metodo_busqueda == "hill_climbing_random_restarts": return hill_climbing_random_restarts(problema_inicial, reinicios, iteraciones) if metodo_busqueda == "simulated_annealing": return simulated_annealing(problema_inicial, iterations_limit=iteraciones)
columna, fila = action state[columna] = fila return tuple(state) def value(self, state): atacando = 0 for columna1, fila1 in enumerate(state): for columna2, fila2 in enumerate(state): if columna2 > columna1: if fila1 == fila2: atacando += 1 else: dif_col = abs(columna1 - columna2) dif_fil = abs(fila1 - fila2) if dif_col == dif_fil: atacando += 1 return -atacando def generate_random_state(self): return tuple([random.randint(0, 8) for _ in range(8)]) result = hill_climbing_random_restarts(EightQueensProblem(), 1000) print result.state print EightQueensProblem().value(result.state)
for queen, current_row in enumerate(state): for queen2, current_row2 in enumerate(state): if queen < queen2: # same row if current_row == current_row2: attacks += 1 else: # diagonal diff_col = abs(queen - queen2) diff_row = abs(current_row - current_row2) if diff_col == diff_row: attacks += 1 return -attacks def generate_random_state(self): state = [] for queen in range(N): row = random.randint(0, N - 1) state.append(row) return tuple(state) if __name__ == '__main__': problem = QueensProblem(INITIAL) result = hill_climbing_random_restarts(problem, restarts_limit=10) print(result.state) print('Attacks:', -problem.value(result.state))
attacks = 0 for queen, current_row in enumerate(state): for queen2, current_row_2 in enumerate(state): if queen < queen2: #same row if current_row == current_row_2: attacks += 1 else: #diagonal diff_col = abs(queen - queen2) diff_row = abs(current_row_2 - current_row_2) if diff_col == diff_row: attacks += 1 return -attacks def generate_random_state(self): state = [] for queens in range(N): row = random.randint(0, N - 1) state.append(row) return tuple(state) if __name__ == '__main__': problem = QueensProblem(INITIAL) result = hill_climbing_random_restarts(problem, restarts_limit=10000, viewer=None) print(result.state) print('Attacks:', -problem.value())
ataques = ataques / 2 return -ataques def generate_random_state(self): estado = [] for reina in range(8): estado.append(random.randint(0, 7)) return tuple(estado) if __name__ == '__main__': result = globals()[metodo_busqueda](Problema...) result = hill_climbing_random_restarts(QueensProblem(None), restarts_limit=100) for fila in range(8): for columna in range(8): if result.state[columna] == fila: print '|*', else: print '| ', print print '-' * 40 print result.value
def _tour_length(self, s): length = 0 for i in xrange(len(s)-1): length += self.distances[s[i]][s[i+1]] return length if __name__ == "__main__": distances = [ \ [0, 6, 5, 7, 8, 2, 2, 6, 6, 5, 7, 5], \ [6, 0, 3, 5, 2, 4, 4, 5, 2, 2, 1, 5], \ [5, 3, 0, 6, 1, 1, 8, 7, 7, 6, 4, 3], \ [7, 5, 6, 0, 3, 5, 1, 1, 7, 3, 8, 4], \ [8, 2, 1, 3, 0, 7, 7, 8, 7, 3, 2, 5], \ [2, 4, 1, 5, 7, 0, 8, 2, 5, 5, 2, 6], \ [2, 4, 8, 1, 7, 8, 0, 1, 7, 8, 1, 8], \ [6, 5, 7, 1, 8, 2, 1, 0, 1, 5, 1, 4], \ [6, 2, 7, 7, 7, 5, 7, 1, 0, 7, 5, 4], \ [5, 2, 6, 3, 3, 5, 8, 5, 7, 0, 4, 2], \ [7, 1, 4, 8, 2, 2, 1, 1, 5, 4, 0, 2], \ [5, 5, 3, 4, 5, 6, 8, 4, 4, 2, 2, 0]] problem = TspProblem(len(distances),distances); result = hill_climbing_random_restarts(problem, restarts_limit=200, viewer=ConsoleViewer()) #result = hill_climbing_random_restarts(problem, restarts_limit=200) print result.state #print result.path()
state[aenum][aen] = val state[enum][en] = 0 return tuple(state) def value(self, state): cant = 0 for enum, item in enumerate(state): for en, it in enumerate(item): if it != GOAL[enum][en]: cant += it return -cant def generate_random_state(self): initial = list((list(INITIAL[0]), list(INITIAL[1]), list(INITIAL[2]))) enum, en = find(initial, 0) aenum, aen = find(initial, randint(1, 8)) initial[enum][en] = initial[aenum][aen] initial[aenum][aen] = 0 return tuple((tuple(initial[0]), tuple(initial[1]), tuple(initial[2]))) visor = BaseViewer() reinicios = 1000 resultado = hill_climbing_random_restarts( Puzzle(INITIAL), iterations_limit=1000, restarts_limit=reinicios, viewer=visor ) # resultado = hill_climbing_random_restars(Puzzle(INITIAL), viewer=visor) print "path", resultado.path() print "resultado", resultado print "visor", visor.stats
next_city = s[0][i + 1] current_dist = self.cityDistances[current_city][next_city] total_dist += current_dist # Add in distance for returning trip to origin of tour total_dist += self.cityDistances[s[0][self.numCities - 1]][s[0][0]] return total_dist problem = TspProblem(12, [[0, 5, 7, 6, 8, 1, 3, 9, 14, 3, 2, 9], \ [5, 0, 6, 10, 4, 3, 12,14, 9, 1, 2, 7], \ [7, 6, 0, 2, 3, 4, 11, 13, 4, 8, 10, 5], \ [6, 10, 2, 0, 5, 7, 9, 11, 13, 5, 3, 1], \ [8, 4, 3, 5, 0, 9, 11, 14, 5, 8, 3, 8], \ [1, 3, 4, 7, 9, 0, 5, 6, 14, 18, 4, 7], \ [3, 12, 11, 9, 11, 5, 0, 19, 4, 3, 5, 6], \ [9, 14, 13, 11, 14, 6, 19, 0, 1, 4, 5, 7], \ [14, 9, 4, 13, 5, 14, 4, 1, 0, 8, 3, 1], \ [3, 1, 8, 5, 8, 18, 3, 4, 8, 0, 4, 5], \ [2, 2, 10, 3, 3, 4, 5, 5, 3, 4, 0, 1], \ [9, 7, 5, 1, 8, 7, 6, 7, 1, 5, 1, 0]]) #vw = ConsoleViewer() #result = hill_climbing_random_restarts(problem, restarts_limit=200, viewer=vw) result = hill_climbing_random_restarts(problem, restarts_limit=200) print result
def resolver(metodo_busqueda, iteraciones, haz, reinicios): print '··· Se van a ejecutar las 10 iteraciones para la busqueda {} ···'.format( metodo_busqueda) #print 'Haz:', haz #print 'Reinicios:', reinicios prob = HnefataflProblem(INITIAL) visor = BaseViewer() if (metodo_busqueda == 'hill_climbing'): # Ascenso de colina for x in range(10): print 'Ejecutando Iteracion {} ...'.format(x) inicio = datetime.now() resultado = hill_climbing(problem=prob, iterations_limit=iteraciones) fin = datetime.now() print 'Tiempo de iteracion {} : {} segundos.'.format( x, (fin - inicio).total_seconds()) grabar('1', max(apuntos)) elif (metodo_busqueda == 'hill_climbing_stochastic' ): # Ascenso de colina, variante estocástica for x in range(10): print 'Ejecutando Iteracion {} ...'.format(x) inicio = datetime.now() resultado = hill_climbing_stochastic(problem=prob, iterations_limit=iteraciones) fin = datetime.now() print 'Tiempo de iteracion {} : {} segundos.'.format( x, (fin - inicio).total_seconds()) grabar('2', max(apuntos)) elif (metodo_busqueda == 'beam'): # Haz local for x in range(10): print 'Ejecutando Iteracion {} ...'.format(x) inicio = datetime.now() resultado = beam(problem=HnefataflProblem(None), iterations_limit=iteraciones, beam_size=haz) fin = datetime.now() print 'Tiempo de iteracion {} : {} segundos.'.format( x, (fin - inicio).total_seconds()) grabar('3', max(apuntos)) elif (metodo_busqueda == 'hill_climbing_random_restarts' ): # Ascenso de colina con reinicios aleatorios for x in range(10): print 'Ejecutando Iteracion {} ...'.format(x) inicio = datetime.now() resultado = hill_climbing_random_restarts( problem=HnefataflProblem(None), iterations_limit=iteraciones, restarts_limit=reinicios) fin = datetime.now() print 'Tiempo de iteracion {} : {} segundos.'.format( x, (fin - inicio).total_seconds()) grabar('4', max(apuntos)) elif (metodo_busqueda == 'simulated_annealing'): # Temple simulado for x in range(10): print 'Ejecutando Iteracion {} ...'.format(x) inicio = datetime.now() resultado = simulated_annealing(problem=prob, iterations_limit=iteraciones) fin = datetime.now() print 'Tiempo de iteracion {} : {} segundos.'.format( x, (fin - inicio).total_seconds()) grabar('5', max(apuntos)) return resultado
totales.append(sum(fila)) # totales por columna for indice_col in range(3): numeros_col = [fila[indice_col] for fila in state] totales.append(sum(numeros_col)) # cuantos hay igual a 15?? correctas = totales.count(15) return correctas def generate_random_state(self): numeros = list(range(1, 10)) shuffle(numeros) state = tuple(numeros[:3]), tuple(numeros[3:6]), tuple(numeros[6:]) return state if __name__ == '__main__': problema = CuadradosProblem(INITIAL_STATE) # resultado = hill_climbing(problema) # resultado = simulated_annealing(problema) resultado = hill_climbing_random_restarts(problema, 1000) print(resultado.state) print('Cuantas dan 15?:', problema.value(resultado.state))
# pero despues restamos los precios de las cosas "rotas" por conflicto for item_a, item_b in CONFLICTOS: if item_a in state and item_b in state: suma -= PRECIOS[item_a] suma -= PRECIOS[item_b] return suma def generate_random_state(self): items_disponibles = list(ITEMS) # creamos una copia para nosotros random.shuffle(items_disponibles) items_equipados = [] for i in range(4): items_equipados.append(items_disponibles.pop()) return tuple(items_equipados) print 'Hill climbing:' v = BaseViewer() result = hill_climbing(ItemsDota(('A', 'B', 'C', 'D')), viewer=v) print result.state print result.value print v.stats print 'Hill climbing random restarts' result = hill_climbing_random_restarts(ItemsDota(), restarts_limit=100) print result.state print result.value
return (None, state) def _tour_length(self, s): length = 0 for i in xrange(len(s) - 1): length += self.distances[s[i]][s[i + 1]] return length if __name__ == "__main__": distances = [ \ [0, 6, 5, 7, 8, 2, 2, 6, 6, 5, 7, 5], \ [6, 0, 3, 5, 2, 4, 4, 5, 2, 2, 1, 5], \ [5, 3, 0, 6, 1, 1, 8, 7, 7, 6, 4, 3], \ [7, 5, 6, 0, 3, 5, 1, 1, 7, 3, 8, 4], \ [8, 2, 1, 3, 0, 7, 7, 8, 7, 3, 2, 5], \ [2, 4, 1, 5, 7, 0, 8, 2, 5, 5, 2, 6], \ [2, 4, 8, 1, 7, 8, 0, 1, 7, 8, 1, 8], \ [6, 5, 7, 1, 8, 2, 1, 0, 1, 5, 1, 4], \ [6, 2, 7, 7, 7, 5, 7, 1, 0, 7, 5, 4], \ [5, 2, 6, 3, 3, 5, 8, 5, 7, 0, 4, 2], \ [7, 1, 4, 8, 2, 2, 1, 1, 5, 4, 0, 2], \ [5, 5, 3, 4, 5, 6, 8, 4, 4, 2, 2, 0]] problem = TspProblem(len(distances), distances) result = hill_climbing_random_restarts(problem, restarts_limit=200, viewer=ConsoleViewer()) #result = hill_climbing_random_restarts(problem, restarts_limit=200) print result.state #print result.path()