def test_simulated_annealing():
initial = 0
goal = 10
limits = (-goal, goal)
p = AnnotatedProblem(
EasyProblem(initial, initial_cost=initial, extra=limits))
sol = next(simulated_annealing(p, temp_length=10, initial_temp=5))
assert abs(sol.state_node.state - limits[0]) <= 0.1
p2 = HillProblem(initial, goal=goal, initial_cost=initial, extra=limits)
sol = next(simulated_annealing(p2))
assert abs(sol.state_node.state - goal) <= 0.1
p3 = AnnotatedProblem(
HillProblem(initial, goal=initial, initial_cost=initial, extra=limits))
sol = next(simulated_annealing(p3))
assert p3.nodes_expanded == 0
assert p3.goal_tests == 1
assert abs(sol.state_node.state - initial) <= 0.1
p4 = AnnotatedProblem(
HillProblem(initial, goal=goal, initial_cost=initial, extra=limits))
# sol = next(simulated_annealing(p4, limit=2))
sol = next(simulated_annealing(p4, temp_length=1, limit=2))
assert p4.nodes_expanded == 2
p5 = AnnotatedProblem(
HillProblem(initial, goal=1000, initial_cost=initial, extra=limits))
# sol = next(simulated_annealing(p4, limit=2))
sol = next(simulated_annealing(p5, temp_length=100, limit=900))
assert p5.nodes_expanded == 900
def test_simulated_annealing():
initial = 0
goal = 10
limits = (-goal, goal)
p = AnnotatedProblem(EasyProblem(initial, initial_cost=initial, extra=limits))
sol = next(simulated_annealing(p))
assert abs(sol.state - limits[0]) <= 0.1
def test_simulated_annealing():
initial = 0
goal = 10
limits = (-goal, goal)
p = AnnotatedProblem(
EasyProblem(initial, initial_cost=initial, extra=limits))
sol = next(simulated_annealing(p))
assert abs(sol.state_node.state - limits[0]) <= 0.1
p2 = HillProblem(initial, goal=goal, initial_cost=initial, extra=limits)
sol = next(simulated_annealing(p2))
assert abs(sol.state_node.state - goal) <= 0.1
p3 = AnnotatedProblem(
HillProblem(initial, goal=initial, initial_cost=initial, extra=limits))
sol = next(simulated_annealing(p3))
assert p3.nodes_expanded == 0
assert p3.goal_tests == 1
assert abs(sol.state_node.state - initial) <= 0.1
p4 = HillProblem(initial, goal=goal, initial_cost=initial, extra=limits)
sol = next(simulated_annealing(p4, limit=2))
def optimize_clause(h, constraints, pset, nset, gensym):
"""
Returns the set of most specific generalization of h that do NOT
cover x.
"""
c_length = clause_length(h)
p_covered, n_covered = test_coverage(h, constraints, pset, nset)
p_uncovered = [p for p in pset if p not in p_covered]
n_uncovered = [n for n in nset if n not in n_covered]
initial_score = clause_score(clause_accuracy_weight, len(p_covered),
len(p_uncovered), len(n_covered),
len(n_uncovered), c_length)
print('INITIAL SCORE', initial_score)
problem = ClauseOptimizationProblem(h,
initial_cost=-1 * initial_score,
extra=(constraints, c_length,
p_covered, p_uncovered,
n_covered, n_uncovered, gensym))
for sol in simulated_annealing(problem):
print("SOLUTION FOUND", sol.state)
return sol.state
def optimize_clause(h, constraints, pset, nset):
"""
Returns the set of most specific generalization of h that do NOT
cover x.
"""
c_length = clause_length(h)
p_covered, n_covered = test_coverage(h, constraints, pset, nset)
p_uncovered = [p for p in pset if p not in p_covered]
n_uncovered = [n for n in nset if n not in n_covered]
initial_score = clause_score(clause_accuracy_weight, len(p_covered),
len(p_uncovered), len(n_covered),
len(n_uncovered), c_length)
p, pm = choice(p_covered)
pos_partial = list(compute_bottom_clause(p, pm))
# print('POS PARTIAL', pos_partial)
# TODO if we wanted we could add the introduction of new variables to the
# get_variablizations function.
possible_literals = {}
for i, l in enumerate(pos_partial):
possible_literals[i] = [None, l] + [v for v in get_variablizations(l)]
partial_literals = set(
[l for i in possible_literals for l in possible_literals[i]])
additional_literals = h - partial_literals
if len(additional_literals) > 0:
p_index = build_index(p)
operator = Operator(tuple(('Rule', )), h.union(constraints), [])
for add_m in operator.match(p_index, initial_mapping=pm):
break
additional_lit_mapping = {
rename(add_m, l): l
for l in additional_literals
}
for l in additional_lit_mapping:
new_l = additional_lit_mapping[l]
print(pos_partial)
print(add_m)
print(l)
print(new_l)
possible_literals[pos_partial.index(l)].append(new_l)
reverse_pl = {
l: (i, j)
for i in possible_literals for j, l in enumerate(possible_literals[i])
}
clause_vector = [0 for i in range(len(possible_literals))]
for l in h:
i, j = reverse_pl[l]
clause_vector[i] = j
clause_vector = tuple(clause_vector)
flip_weights = [(len(possible_literals[i]) - 1, i)
for i in possible_literals]
# size = 1
# for w, _ in flip_weights:
# size *= (w + 1)
# print("SIZE OF SEARCH SPACE:", size)
num_successors = sum([w for w, c in flip_weights])
temp_length = 2 * num_successors
# print("TEMP LENGTH", temp_length)
# print('INITIAL SCORE', initial_score)
problem = ClauseOptimizationProblem(clause_vector,
initial_cost=-1 * initial_score,
extra=(possible_literals, flip_weights,
constraints, pset, nset))
# for sol in hill_climbing(problem):
for sol in simulated_annealing(problem, temp_length=temp_length):
# print("SOLUTION FOUND", sol.state)
return build_clause(sol.state, possible_literals)
def greedy_annealing(problem):
size = problem.initial.state.n
n_neighbors = (size * (size - 1)) // 2
return simulated_annealing(problem,
initial_temp=0,
temp_length=n_neighbors)
def greedy_annealing(problem):
n = (num_objs * num_objs) // 2
return simulated_annealing(problem, initial_temp=0, temp_length=n)
def annealing(problem):
n = (num_objs * num_objs) // 2
return simulated_annealing(problem, temp_length=n)
def optimize_clause(h, constraints, seed, pset, nset):
"""
Returns the set of most specific generalization of h that do NOT
cover x.
"""
c_length = clause_length(h)
print('# POS', len(pset))
print('# NEG', len(nset))
print('length', c_length)
p_covered, n_covered = test_coverage(h, constraints, pset, nset)
p_uncovered = [p for p in pset if p not in p_covered]
n_uncovered = [n for n in nset if n not in n_covered]
print("P COVERED", len(p_covered))
print("N COVERED", len(n_covered))
initial_score = clause_score(clause_accuracy_weight, len(p_covered),
len(p_uncovered), len(n_covered),
len(n_uncovered), c_length)
p, pm = seed
pos_partial = list(compute_bottom_clause(p, pm))
# print('POS PARTIAL', pos_partial)
# TODO if we wanted we could add the introduction of new variables to the
# get_variablizations function.
possible_literals = {}
for i, l in enumerate(pos_partial):
possible_literals[i] = [None, l] + [v for v in get_variablizations(l)]
partial_literals = set(
[l for i in possible_literals for l in possible_literals[i]])
additional_literals = h - partial_literals
if len(additional_literals) > 0:
p_index = build_index(p)
operator = Operator(tuple(('Rule', )), h.union(constraints), [])
for add_m in operator.match(p_index, initial_mapping=pm):
break
additional_lit_mapping = {
rename(add_m, l): l
for l in additional_literals
}
for l in additional_lit_mapping:
new_l = additional_lit_mapping[l]
reverse_m = {pm[a]: a for a in pm}
l = rename(reverse_m, l)
print(pos_partial)
print(add_m)
print(l)
print(new_l)
print(additional_literals)
if l not in pos_partial:
print("ERROR l not in pos_partial")
import time
time.sleep(1000)
possible_literals[pos_partial.index(l)].append(new_l)
# pprint(possible_literals)
reverse_pl = {
l: (i, j)
for i in possible_literals for j, l in enumerate(possible_literals[i])
}
clause_vector = [0 for i in range(len(possible_literals))]
for l in h:
if l not in reverse_pl:
print("MISSING LITERAL!!!")
import time
time.sleep(1000)
i, j = reverse_pl[l]
clause_vector[i] = j
clause_vector = tuple(clause_vector)
# print("INITIAL CLAUSE VECTOR")
# print(clause_vector)
flip_weights = [(len(possible_literals[i]) - 1, i)
for i in possible_literals]
size = 1
for w, _ in flip_weights:
size *= (w + 1)
print("SIZE OF SEARCH SPACE:", size)
num_successors = sum([w for w, c in flip_weights])
print("NUM SUCCESSORS", num_successors)
temp_length = num_successors
temp_length = 10
# initial_temp = 0.15
# initial_temp = 0.0
print("TEMP LENGTH", temp_length)
print('INITIAL SCORE', initial_score)
problem = ClauseOptimizationProblem(clause_vector,
initial_cost=-1 * initial_score,
extra=(possible_literals, flip_weights,
constraints, pset, nset,
len(p_uncovered),
len(n_covered)))
# for sol in hill_climbing(problem):
for sol in simulated_annealing(
problem,
# initial_temp=initial_temp,
temp_length=temp_length):
# print("SOLUTION FOUND", sol.state)
print('FINAL SCORE', -1 * sol.cost())
return build_clause(sol.state, possible_literals)
def annealing(problem):
num_neighbors = (n * (n-1)) // 2
return simulated_annealing(problem, initial_temp=1.5,
temp_length=num_neighbors)
def greedy_annealing(problem):
size = problem.initial.state.n
n_neighbors = (size * (size - 1)) // 2
return simulated_annealing(problem, cost_limit=0, initial_temp=0, temp_length=n_neighbors)
def greedy_annealing(problem):
size = (n * (n // 2)) // 2
return simulated_annealing(problem, initial_temp=0, temp_length=size)
def annealing(problem):
num_neighbors = (n * (n - 1)) // 2
return simulated_annealing(problem,
initial_temp=1.5,
temp_length=num_neighbors)
def greedy_annealing(problem):
n = (num_objs * num_objs) // 2
return simulated_annealing(problem, initial_temp=0, temp_length=n)
def annealing(problem):
n = (num_objs * num_objs) // 2
return simulated_annealing(problem, temp_length=n)
def greedy_annealing(problem):
size = (n * (n//2)) // 2
return simulated_annealing(problem, initial_temp=0,
temp_length=size)