def resolver(metodo_busqueda, iteraciones): problema = CspProblem(slots, dominios, restricciones) if metodo_busqueda == "backtrack": resultado = backtrack(problema) return resultado if metodo_busqueda == "min_conflicts": return min_conflicts(problema, iterations_limit=iteraciones)
def resolver(metodo_busqueda, iteraciones): #problema = CspProblem(variables, dominios, restricciones) if metodo_busqueda == 'backtrack': return backtrack(CspProblem(variables, dominios, restricciones)) if metodo_busqueda == 'min_conflicts': return min_conflicts(CspProblem(variables, dominios, restricciones), iterations_limit=iteraciones)
def resolver(metodo_busqueda): problem = CspProblem(variables, dominios, restricciones) if metodo_busqueda == "backtrack": r = backtrack(problem, value_heuristic=LEAST_CONSTRAINING_VALUE, variable_heuristic=MOST_CONSTRAINED_VARIABLE, inference=True) else: r = min_conflicts(problem, iterations_limit=1000) return r
def resolver(metodo_busqueda, iteraciones): problem = CspProblem(variables, dominios, restricciones) if metodo_busqueda == 'backtrack': result = backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE) else: result = min_conflicts(problem, iterations_limit=iteraciones) return result
def resolver(metodo_busqueda, iteraciones): problema = generar_problema_entrega2() if metodo_busqueda == "backtrack": resultado = backtrack(problema) elif metodo_busqueda == "min_conflicts": resultado = min_conflicts(problema, iterations_limit=iteraciones) return resultado
def resolver(metodo_busqueda, iteraciones): if metodo_busqueda == "backtrack": resultado = backtrack(CspProblem(slots, dominios, restricciones), MOST_CONSTRAINED_VARIABLE, LEAST_CONSTRAINING_VALUE) if metodo_busqueda == "min_conflicts": resultado = min_conflicts(CspProblem(slots, dominios, restricciones), iterations_limit = iteraciones) result = {} for key, value in resultado.items(): result[key] = modulos[value] return result
def resolver(cajas): problema = generar_problema_csp_para_amagon(cajas) inicio = datetime.datetime.now() asignacion = min_conflicts(problema, iterations_limit=100) tiempo = (datetime.datetime.now() - inicio).total_seconds() conflictos = _find_conflicts(problema, asignacion) print("Numero de conflictos en la solucion: {}".format(len(conflictos))) print("Tiempo transcurrido: {} segundos".format(tiempo))
def resolver(metodo_busqueda, iteraciones): problema = csp_conferencia() if metodo_busqueda == "backtrack": resultado = backtrack(problema) #resultado = backtrack(problema, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE) elif metodo_busqueda == "min_conflicts": resultado = min_conflicts(problema, iterations_limit=iteraciones) return resultado
def resolver(metodo_busqueda, iteraciones): unary() problem = CspProblem(VARIABLES, DOMAINS, restricciones) if metodo_busqueda == 'backtrack': result = backtrack(problem, value_heuristic=HIGHEST_DEGREE_VARIABLE, variable_heuristic=MOST_CONSTRAINED_VARIABLE, inference=False) if metodo_busqueda == 'min_conflicts': result = min_conflicts(problem, iterations_limit=iteraciones) return result
def resolver(metodo_busqueda, iteraciones): problem = CspProblem(variables, dominios, restricciones) if metodo_busqueda == 'backtrack': resultado = backtrack(problem=problem) grabar('1', resultado, iteraciones=iteraciones) return resultado #def backtrack(problem, variable_heuristic='', value_heuristic='', inference=True): if metodo_busqueda == 'min_conflicts': resultado = min_conflicts(problem=problem, iterations_limit=iteraciones) #print iteraciones, resultado grabar('2', resultado, iteraciones=iteraciones) return resultado
def no_en_diagonal(variables, valores): fila_a = valores[0] columna_a = int(variables[0][1]) fila_b = valores[1] columna_b = int(variables[1][1]) return abs(fila_a - fila_b) != abs(columna_a - columna_b) restricciones = [] for reina_a, reina_b in itertools.combinations(variables, 2): restricciones.append(((reina_a, reina_b), distinta_fila)) restricciones.append(((reina_a, reina_b), no_en_diagonal)) problem = CspProblem(variables, dominios, restricciones) print 'backtrack:' result = backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE, inference=True) print result print 'min_conflicts:' result = min_conflicts(problem, iterations_limit=100) print result
constraints = [(('John', 'Anna', 'Tom'), constraint_unique), (('Tom', 'Anna'), constraint_bigger), (('John', 'Patricia'), constraint_odd_even)] problem = CspProblem(variables, domains, constraints) print('\nSolutions:\n\nNormal:', backtrack(problem)) print('\nMost constrained variable:', backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)) print('\nHighest degree variable:', backtrack(problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE)) print('\nLeast constraining value:', backtrack(problem, variable_heuristic=LEAST_CONSTRAINING_VALUE)) print( '\nMost constrained variable and least constraining value:', backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)) print( '\nHighest degree and least constraining value:', backtrack(problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)) print('\nMinimum conflicts:', min_conflicts(problem))
def resolver(metodo_busqueda, iteraciones): problema = CspProblem(casillas, dominios, restricciones) if metodo_busqueda == "backtrack": return backtrack(problema) if metodo_busqueda == "min_conflicts": return min_conflicts(problema, iterations_limit=iteraciones)
'7V': [x for x in text if len(x) == 2], '8H': [x for x in text if len(x) == 2], '8V': [x for x in text if len(x) == 2], '9V': [x for x in text if len(x) == 2], '10H': [x for x in text if len(x) == 3], '11H': [x for x in text if len(x) == 2], } restricciones = [] def misma_letra_inicio(variables, valores): return valores[0][0] == valores[1][0] restricciones.append((('1H', '1V'), misma_letra_inicio)) restricciones.append((('2V', '2H'), misma_letra_inicio)) restricciones.append((('4H', '4V'), misma_letra_inicio)) restricciones.append((('8H', '8V'), misma_letra_inicio)) restricciones.append((('7H', '7V'), misma_letra_inicio)) def son_distintas(variables, valores): return valores[0] != valores[1] for palabra_a, palabra_b in itertools.combinations(variables, 2): restricciones.append(((palabra_a, palabra_b), son_distintas)) print min_conflicts(CspProblem(variables, dominios, restricciones), iterations_limit=5000)
if var2 not in INTERCONECTADAS[var1]: return False return True def distintos(vars, vals): return len(set(vals)) == len(vals) def escudo_comunicaciones(vars, vals): if 'escudo' in vals and 'comunicacion' in vals: var1, var2 = vars if var1 in INTERCONECTADAS[var2]: return False return True restricciones = [] for pos1, pos2 in itertools.combinations(variables, 2): restricciones.append(((pos1, pos2), motor_u_ocultamiento)) restricciones.append(((pos1, pos2), torpedos_apuntamiento)) restricciones.append(((pos1, pos2), distintos)) restricciones.append(((pos1, pos2), escudo_comunicaciones)) problema = CspProblem(variables, dominios, restricciones) # resultado = backtrack(problema, value_heuristic=LEAST_CONSTRAINING_VALUE, # variable_heuristic=MOST_CONSTRAINED_VARIABLE) resultado = min_conflicts(problema) print(resultado)
from simpleai.search import CspProblem, backtrack, min_conflicts, MOST_CONSTRAINED_VARIABLE, HIGHEST_DEGREE_VARIABLE, LEAST_CONSTRAINING_VALUE variables = ('WA', 'NT', 'SA', 'Q', 'NSW', 'V', 'T') domains = dict((v, ['red', 'green', 'blue']) for v in variables) def const_different(variables, values): return values[0] != values[1] # expect the value of the neighbors to be different constraints = [ (('WA', 'NT'), const_different), (('WA', 'SA'), const_different), (('SA', 'NT'), const_different), (('SA', 'Q'), const_different), (('NT', 'Q'), const_different), (('SA', 'NSW'), const_different), (('Q', 'NSW'), const_different), (('SA', 'V'), const_different), (('NSW', 'V'), const_different), ] my_problem = CspProblem(variables, domains, constraints) print backtrack(my_problem) print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE) print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE) print backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE) print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE) print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE) print min_conflicts(my_problem)
constraints = [((i, j), const_different) for i in range(len(variables)) for j in range(i, len(variables)) if i != j] my_problem = CspProblem(variables.keys(), domains, constraints) t1 = time.time() res = backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE) print('\n\n\n\nMinimum remaining value: {}s'.format(time.time() - t1)) pretty_print(res, variables, values) t1 = time.time() res = backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE) print('\n\n\n\nDegree heuristic: {}s'.format(time.time() - t1)) pretty_print(res, variables, values) t1 = time.time() res = backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE) print('\n\n\n\nLeast constraining value: {}s'.format(time.time() - t1)) pretty_print(res, variables, values) t1 = time.time() res = min_conflicts(my_problem) print('\n\n\n\nForward checking: {}s'.format(time.time() - t1)) pretty_print(res, variables, values) t1 = time.time() res = result = backtrack(my_problem, inference=False) print('\n\n\n\nConstraint propagation: {}s'.format(time.time() - t1)) pretty_print(res, variables, values)
def no_supera_3000(variables, valores): suma = 0 for valor in valores: suma += equipamientos[valor][1] return suma < 3000 def no_armadura(variables, valores): suma1 = 0 for valor in valores: if equipamientos[valor][0] == 1: suma1 += 1 return suma1 == 1 def no_espadas(variables, valores): suma2 = 0 for valor in valores: if equipamientos[valor][0] == 2: suma2 += 1 return suma2 == 1 restricciones.append((variables, no_armadura)) restricciones.append((variables, no_espadas)) restricciones.append((variables, no_supera_3000)) print 'Backtrack', backtrack(CspProblem(variables, dominios, restricciones)) print 'Min Conflicts', min_conflicts(CspProblem(variables, dominios, restricciones), iterations_limit=10000)
if arriba[0]<0: arriba = (-1,-1) abajo = (casilla[0]+1, casilla[1]) if abajo[0] >= largo: abajo = (-1,-1) derecha = (casilla[0], casilla[1]+1) if derecha[1] >= ancho: derecha = (-1,-1) izquierda = (casilla[0], casilla[1]-1) if izquierda[1] < 0: izquierda = (-1,-1) restricciones.append(((arriba, abajo, izquierda, derecha), no_adyacentes)) restricciones.append((variables,cantidad_valida)) def imprimir_tablero(resultado): print '-'*40 for fila in range(largo): fila_print = '' for columna in range(ancho): fila_print += '|%i' %resultado[(fila, columna)] print fila_print print '\n' print 'Backtrack' imprimir_tablero(backtrack(CspProblem(variables,dominio,restricciones))) print 'Min conflicts' imprimir_tablero(min_conflicts(CspProblem(variables,dominio,restricciones), iterations_limit=5000))
from simpleai.search import CspProblem, backtrack, min_conflicts, MOST_CONSTRAINED_VARIABLE, HIGHEST_DEGREE_VARIABLE, LEAST_CONSTRAINING_VALUE variables = ('WA', 'NT', 'SA', 'Q', 'NSW', 'V', 'T') domains = dict((v, ['red', 'green', 'blue']) for v in variables) def const_different(variables, values): return values[0] != values[1] # expect the value of the neighbors to be different constraints = [ (('WA', 'NT'), const_different), (('WA', 'SA'), const_different), (('SA', 'NT'), const_different), (('SA', 'Q'), const_different), (('NT', 'Q'), const_different), (('SA', 'NSW'), const_different), (('Q', 'NSW'), const_different), (('SA', 'V'), const_different), (('NSW', 'V'), const_different), ] my_problem = CspProblem(variables, domains, constraints) print(backtrack(my_problem)) print(backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)) print(backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE)) print(backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE)) print(backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)) print(backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)) print(min_conflicts(my_problem))
((variables[20:30]), const_third_row), ((variables[30:40]), const_fourth_row), ((variables[40:50]), const_fifth_row), ((variables[50:60]), const_sixth_row), ((variables[60:70]), const_seventh_row), ((variables[70:80]), const_eight_row), ((variables[80:90]), const_nineth_row), ((variables[90:100]), const_tenth_row), (list(variables[i] for i in range(0, 100, 10)), const_first_column), (list(variables[i] for i in range(1, 100, 10)), const_second_column), (list(variables[i] for i in range(2, 100, 10)), const_third_column), (list(variables[i] for i in range(3, 100, 10)), const_fourth_column), (list(variables[i] for i in range(4, 100, 10)), const_fifth_column), (list(variables[i] for i in range(5, 100, 10)), const_sixth_column), (list(variables[i] for i in range(6, 100, 10)), const_seventh_column), (list(variables[i] for i in range(7, 100, 10)), const_eight_column), (list(variables[i] for i in range(8, 100, 10)), const_nineth_column), (list(variables[i] for i in range(9, 100, 10)), const_tenth_column), ] #In order to decrease the run time of the algorithm variables, domains, constraints = convert_to_binary(variables, domains, constraints) my_problem = CspProblem(variables, domains, constraints) result = min_conflicts(my_problem) for k, v in result.items(): print(k, v)
return values[0] != values[ 1] #expect the value of neighbors to be different constraints = [ (("WA", "NT"), const_different), (("WA", "SA"), const_different), (("SA", "NT"), const_different), (("SA", "Q"), const_different), (("NT", "Q"), const_different), (("SA", "NSW"), const_different), (("Q", "NSW"), const_different), (("SA", "V"), const_different), (("NSW", "V"), const_different), ] my_problem = CspProblem(variables, domains, constraints) print(backtrack(my_problem)) print(backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE)) print(backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE)) print(backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE)) print( backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)) print( backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE)) print(min_conflicts(my_problem))
def diferentes(variables, valores): return valores[0] != valores[1] def suma_da_bien(variables, valores): return valores[0] == valores[1] + valores[2] restricciones = [] for variable1, variable2 in itertools.combinations(casillas, 2): restricciones.append(((variable1, variable2), diferentes)) restricciones.append((('a', 'b', 'c'), suma_da_bien)) restricciones.append((('b', 'd', 'e'), suma_da_bien)) restricciones.append((('c', 'e', 'f'), suma_da_bien)) restricciones.append((('d', 'g', 'h'), suma_da_bien)) restricciones.append((('e', 'h', 'i'), suma_da_bien)) restricciones.append((('f', 'i', 'j'), suma_da_bien)) if __name__ == '__main__': problema = CspProblem(casillas, dominios, restricciones) resultado = backtrack(problema) print 'backtrack:' print resultado resultado = min_conflicts(problema, iterations_limit=500) print 'min conflicts:' print resultado
x_b, y_b = b return not (vals[0] == vals[1] and (x_a == x_b or y_a == y_b)) dominios = {(x, y): range(9) for x in range(9) for y in range(9)} for valor, posiciones in enumerate(default): for pos in posiciones: dominios[pos] = [valor] variables = dominios.keys() restricciones = [] for par in itertools.combinations(variables, 2): restricciones.append((par, eq_fila_columna)) restricciones.append((par, eq_cuadrante)) problem = CspProblem(variables, dominios, restricciones) print "Inicio..." print "Min conflicts" r = min_conflicts(problem, iterations_limit=200) tablero(r) print "\n\n" print "Backtrack" r = backtrack(problem, value_heuristic=LEAST_CONSTRAINING_VALUE, variable_heuristic=MOST_CONSTRAINED_VARIABLE, inference=True) tablero(r)
def const_different(variables, values): return values[0] != values[ 1] # expect the value of the neighbors to be different constraints = [ (('WA', 'NT'), const_different), (('WA', 'SA'), const_different), (('SA', 'NT'), const_different), (('SA', 'Q'), const_different), (('NT', 'Q'), const_different), (('SA', 'NSW'), const_different), (('Q', 'NSW'), const_different), (('SA', 'V'), const_different), (('NSW', 'V'), const_different), ] my_problem = CspProblem(variables, domains, constraints) print backtrack(my_problem) print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE) print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE) print backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE) print backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE) print backtrack(my_problem, variable_heuristic=HIGHEST_DEGREE_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE) print min_conflicts(my_problem)
constraints.append((('M', 'A4'), equals)) print('Variables:', variables) print('Domains:', domains) problem = CspProblem(variables, domains, constraints) print('Solving with backtracking') result_bt = backtrack(problem, variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE, inference=True) print('Solving with min conflicts') result_mc = min_conflicts(problem, iterations_limit=500) print('Binarizing and solving again with backtracking') new_variables, new_domains, new_constraints = convert_to_binary( variables, domains, constraints) result_btb = backtrack(CspProblem(new_variables, new_domains, new_constraints), variable_heuristic=MOST_CONSTRAINED_VARIABLE, value_heuristic=LEAST_CONSTRAINING_VALUE) def human_result(result): template = """ A4 A3 A2 A1 S E N D + M O R E ---------------