def test_get_parsing_results(self):
self.initialise_segment_table("abnese_lengthening_segment_table.txt")
configurations["MORPHEME_BOUNDARY_FLAG"] = True
configurations["LENGTHENING_FLAG"] = True
configurations["HMM_ENCODING_LENGTH_MULTIPLIER"] = 100
configurations["DATA_ENCODING_LENGTH_MULTIPLIER"] = 20
hmm = HMM({
'q0': ['q1'],
'q1': (['qf'], ['aabb', 'abb', 'bbaabb', 'aba', 'aaba', 'bbaa'])
})
rule1 = Rule([], [{
"long": "+"
}], [], [{}, {
"bound": "+"
}],
obligatory=True)
rule2 = Rule([], [{
"syll": "+"
}], [{
"cons": "+"
}], [{
"cons": "+"
}],
obligatory=True)
rule_set = RuleSet([rule1, rule2])
grammar = Grammar(hmm, rule_set)
data = [
u'baba:a', u'babaab:ab', u'ab:a', u'aab:a', u'aab:ab', u'ab:ab'
]
hypothesis = Hypothesis(grammar, data)
simulated_annealing = SimulatedAnnealing(hypothesis, 0)
print(simulated_annealing._get_parsing_results())
def main():
'''set the simulated annealing algorithm params'''
temp = 1000
stopping_temp = 0.00000001
alpha = 0.9995
stopping_iter = 10000000
'''set the dimensions of the grid'''
size_width = 200
size_height = 200
'''set the number of nodes'''
population_size = 70
'''generate random list of nodes'''
nodes = NodeGenerator(size_width, size_height, population_size).generate()
'''run simulated annealing algorithm with 2-opt'''
sa = SimulatedAnnealing(nodes, temp, alpha, stopping_temp, stopping_iter)
sa.anneal()
'''animate'''
sa.animateSolutions()
'''show the improvement over time'''
sa.plotLearning()
def main():
parser = argparse.ArgumentParser(
description='Input TSP file and hyperparameters')
parser.add_argument('--tsp_file', '-f', help='TSP file path')
args = parser.parse_args()
tsp_file = args.tsp_file
processor = TSPProcessor(tsp_file)
nodes = processor.euc2d_process()
'''set the simulated annealing algorithm params'''
temp = 10000
stopping_temp = 0.00000001
alpha = 0.999995
stopping_iter = 10000000
'''set the dimensions of the grid'''
size_width = 200
size_height = 200
'''set the number of nodes'''
population_size = 70
'''generate random list of nodes'''
# nodes = NodeGenerator(size_width, size_height, population_size).generate()
'''run simulated annealing algorithm with 2-opt'''
sa = SimulatedAnnealing(nodes, temp, alpha, stopping_temp, stopping_iter)
sa.anneal()
'''animate'''
save_path = os.path.join(
os.path.join(os.path.dirname(tsp_file), 'result_gif'),
os.path.basename(tsp_file) + '.gif')
sa.animateSolutions(save_path)
'''show the improvement over time'''
sa.plotLearning()
def main():
cities = City.load_cities('./data/data50.txt')
graph = Graph(cities)
init_sol = graph.nearestNeighbourSolution()
history = SimulatedAnnealing(graph, init_sol, 0.9998, 10, 0.0000001,
1000000).anneal()
DynamicPlot().show(cities, history, graph)
def findRoutes():
start_time = time()
body = None
body = request.get_json(force=True)
temp = request.args.get('use_heuristic')
flag = False
if temp != "false":
flag = True
print(body)
lista = list(body)
if len(lista) < 2:
return []
destinations = None
destinations = RouteController()
for i in lista:
destinations.add_cord(Coordinate(i['lat'], i['lng'], 'A'))
#TODO
sa = None
sa = SimulatedAnnealing(destinations,
initial_temperature=1000,
cooling_rate=0.0015,
use_heuristic=flag)
sa.run()
response = []
for i in sa.best:
response.append({'lat': i.lat, 'lng': i.long})
elapsed_time = time() - start_time
print("Elapsed time: %0.10f seconds." % elapsed_time)
return jsonify(response)
def main():
'''set the simulated annealing algorithm params'''
temp = 1000
stopping_temp = 0.00000001
alpha = 0.9995
stopping_iter = 10000000
'''set the dimensions of the grid'''
size_width = 50
size_height = 50
'''set the number of nodes'''
population_size = 100
'''generate random list of nodes'''
'''nodes = NodeGenerator(size_width, size_height, population_size).generate()'''
f = open('data.txt')
xs = []
ys = []
for data in f.readlines():
data = data.strip('\n')
nums = data.split(" ")
while '' in nums:
nums.remove('')
xs.append(int(nums[0]))
ys.append(int(nums[1]))
nodes = np.column_stack((xs, ys))
f.close()
'''run simulated annealing algorithm with 2-opt'''
sa = SimulatedAnnealing(nodes, temp, alpha, stopping_temp, stopping_iter)
sa.anneal()
'''animate'''
sa.animateSolutions()
'''show the improvement over time'''
sa.plotLearning()
def test_simulated_annealing_runtime(self):
import simulations.turkish_vowel_harmony as current_simulation
configurations.load_configurations_from_dict(
current_simulation.configurations_dict)
self.initialise_segment_table('turkish_segment_table.txt')
initial_hmm = None
initial_rule_set = None
initial_hypothesis = Hypothesis.create_initial_hypothesis(
current_simulation.data, initial_hmm, initial_rule_set)
target_tuple = current_simulation.target_tuple
data = current_simulation.data
target_rule_set = RuleSet.load_form_flat_list(target_tuple[1])
target_hypothesis = Hypothesis.create_hypothesis(
HMM(target_tuple[0]), target_rule_set, data)
target_energy = target_hypothesis.get_energy()
simulated_annealing = SimulatedAnnealing(initial_hypothesis,
target_energy)
simulated_annealing.before_loop()
# mutate hypothesis for some time before measuring steps
for i in range(500):
simulated_annealing.make_step()
@timeit_best_of_N
def make_step_profiled():
simulated_annealing.make_step()
make_step_profiled()
def test_simulate_annealing(self):
sa_parameter = {
"cycles": 100,
"trails": 10,
"P_start": 0.7,
"P_end": 0.001
}
parameter = json.dumps(sa_parameter)
self.simulated_annealing = SimulatedAnnealing(
self.dataset, self.combinations_df, self.normal_profile_selection,
parameter)
self.simulated_annealing.start()
best_costs = self.simulated_annealing.best_results_list
best_scrap_list = []
for profile_dict in best_costs:
scrap_sum = 0
for uuid, raw_profile in profile_dict.items():
scrap_sum += raw_profile.scrap
best_scrap_list.append(scrap_sum)
plt.plot(best_scrap_list)
plt.show()
def main():
'''define some global variables'''
results = []
'''set the simulated annealing algorithm parameter grid'''
temp = 50000
stopping_temp = 0.000000001
alpha = .999
stopping_iter = 10000000
'''generate random list of nodes'''
nodes = np.array([[20, 20], [60, 20], [100, 40], [120, 80], [160, 20],
[200, 40], [180, 60], [180, 100], [140, 140], [200, 160],
[180, 200], [140, 180], [100, 160], [80, 180], [60, 200],
[20, 160], [40, 120], [100, 120], [60, 80], [20, 40]])
nodes = np.random.permutation(nodes)
'''run simulated annealing algorithm with 2-opt'''
sa = SimulatedAnnealing(nodes, temp, alpha, stopping_temp, stopping_iter)
start_time = time.time()
sa.anneal()
execution_time = time.time() - start_time
'''general plots'''
print('Min weight: ', sa.min_weight)
print('Iterations: ', sa.iteration)
print('Execution time: ', execution_time)
'''animate'''
sa.animateSolutions()
'''show the improvement over time'''
sa.plotLearning()
def main():
try:
n = int(sys.argv[1])
# Run Single File
except ValueError:
g = GraphInterface.fromFile(sys.argv[1])
a = SimulatedAnnealing(g)
start = datetime.now()
paths, costs = a.run(max_iterations=100)
cost = costs[-1]
end = datetime.now()
print(f"File: {sys.argv[1]}.\nTime (s): {(end - start).total_seconds()}. \nCost: {int_just(cost,5)} \nSolution: {paths}.")
else:
# Run all files for all problems <= argv[1]
if len(sys.argv) >= 3 and sys.argv[2] == "all":
results = []
for i in range(1, n + 1):
a, b = run_problem_size(i, print_individual=False)
results.append((a, b))
for t, i in zip(results, range(1, n + 1)):
print(
f"Cities: {int_just(i, 3)}Average time: {int_just(t[0], 6)} Average Cost (s): {int_just( t[1], 12)}")
# Run all files for problems of size argv[1]
else:
a, b = run_problem_size(n)
print(
f"\nFor {n} cities. \nAverage Time: {a} \nAverage Cost: {b}.")
def run(self, path, DEBUG=False):
painter = Painter(path, DEBUG=DEBUG)
simulated_annealing = SimulatedAnnealing(self.coordinates,
max_interations=5000000,
alpha=0.9995,
min_temperature=0.00000001)
solution, costs = simulated_annealing.execute()
painter.plot_path(solution, self.coordinates)
painter.plot_costs(costs)
print("Best solution: {}".format(solution))
print("Costs: {}".format(costs))
def run_annealing(problem_path: str, temperature: float, iterations: int) -> List[
float]:
"""
Args:
problem_path:
temperature
Returns:
A list detailing the costs at each iteration.
"""
g = GraphInterface.fromFile(problem_path)
a = SimulatedAnnealing(g, temperature=temperature)
path, costs = a.run(max_iterations=iterations)
return costs
def test_random_solution_generation(self):
sa_parameter = {
"cycles": 100,
"trails": 50,
"P_start": 0.7,
"P_end": 0.001
}
parameter = json.dumps(sa_parameter)
self.simulated_annealing = SimulatedAnnealing(self.dataset,
self.combinations_df,
parameter)
dict = self.simulated_annealing.get_random_solution(
self.dataset, self.combinations_df, self.normal_profile_selection)
def run_simulated_annealing(initial_temperature, cooling_coefficient,
minimal_temperature):
print('Running Simulated Annealing...')
print()
sa = SimulatedAnnealing(states, initial_temperature, cooling_coefficient,
minimal_temperature, inc_support, dec_support)
sa.run()
print('Found optimal route with value of ' + str(sa.best_solution.value) +
'.')
print(
str(sa.best_solution.calculate_real_value()) +
' electoral votes were collected.')
sa.best_solution.print()
print()
def run_large_problem(temperature: float, iterations: int) -> None:
""" Runs the simulated annealing on a 36 city problem.
Args:
temperature: An annealing constant to use in the model.
iterations: The number of iterations to run through.
"""
g = GraphInterface.fromFile("problems/problem36")
a = SimulatedAnnealing(g, temperature=temperature)
start = datetime.now()
path, costs = a.run(max_iterations=iterations)
print(f"total seconds: {(datetime.now()-start).total_seconds()}")
with open("big_problem_costs.csv", "w") as f:
f.write(",".join([str(c) for c in costs]))
print(f"Max cost was {max(costs)}| Min cost was {min(costs)}.")
def simulatedAnnealingSolver(inputs, T=100, n_iter=10000, temp_update=.9):
if inputs["rides"] < 100:
n_iter = 300
temp_update = .9
elif inputs["rides"] < 1000:
n_iter = 1000
temp_update = .95
else:
n_iter = 5000
temp_update = .99
model = SimulatedAnnealing(inputs,
T=T,
n_iter=n_iter,
temp_update=temp_update)
model.fit()
print("score ", model.cur_score)
return model.solution
def compute_route(self):
util = JobConfig()
max_step = self.max_step
max_util = self.num_mappers * self.num_reducers * self.bandwidth
if self.build_paths():
# Executing simulated annealing for map-reduce routing
simulated_annealing = SimulatedAnnealing(max_util, \
max_step, \
self.routing_init_state, \
self.routing_generate_neighbor, \
self.routing_compute_util)
util = simulated_annealing.run()
# print "util: ", util.get_util()
return util
def compute_route(self):
util = JobConfig()
if self.build_paths():
max_step = self.max_step
max_util = self.cur_demand.get_net()
# Executing simulated annealing for map-reduce routing
simulated_annealing = SimulatedAnnealing(max_util, \
max_step, \
self.routing_init_state, \
self.routing_generate_neighbor, \
self.routing_compute_util, \
self.check_constraint)
util = simulated_annealing.run()
# print "util: ", util.get_util()
return util
def executar(self):
self.listaDadosIniciais = Configuracao.gerarDadosIniciais(
self.configuracao)
resultado = Resultado(self.configuracao.problema)
for a in range(4):
algoritmo = None
if (a == 0):
algoritmo = Algoritmo(Configuracao.algoritmos[a],
HillClimbing(self.configuracao))
elif (a == 1):
algoritmo = Algoritmo(Configuracao.algoritmos[a],
HillClimbingRestart(self.configuracao))
elif (a == 2):
algoritmo = Algoritmo(Configuracao.algoritmos[a],
SimulatedAnnealing(self.configuracao))
else:
algoritmo = Algoritmo(Configuracao.algoritmos[a],
GeneticAlgorithm(self.configuracao))
for iteracao in range(10):
algoritmo.executar(self.listaDadosIniciais[iteracao], iteracao)
algoritmo.gerarEstatisticas()
Graficos.gerarGraficoFuncaoObjetivo(algoritmo, self.configuracao)
resultado.adicionar(algoritmo)
inicioComparativo = time.perf_counter()
self.finalizar(resultado)
terminoComparativo = time.perf_counter()
print(
f"Geração da tabela/gráfico de comparativo de performance em {terminoComparativo - inicioComparativo:0.4f} segundos"
)
def execute_job(self, job):
available_hosts = [h for h in self.graph.get_hosts() if h.is_free()]
util = JobConfig()
# There are enough nodes to run the job
if len(available_hosts) > (self.num_mappers + self.num_reducers):
max_util = self.num_mappers * self.num_reducers * self.bandwidth
max_step = self.max_step
# Executing simulated annealing for map-reduce placement
simulated_annealing = SimulatedAnnealing(max_util, \
max_step, \
self.placement_init_state, \
self.placement_generate_neighbor, \
self.placement_compute_util)
util = simulated_annealing.run()
return util
def run_problem_size(n: int, print_individual: bool = True) -> List[
Tuple[float, float]]:
""" Runs all problems for a single problem size.
Args:
n: The size of problems to consider
"""
times = []
nodes = []
for f in os.listdir(f"problems/{n}/"):
g = GraphInterface.fromFile(f"problems/{n}/{f}")
a = SimulatedAnnealing(g)
start = datetime.now()
path, costs = a.run(max_iterations=10000)
cost = costs[-1]
end = datetime.now()
times.append((end - start).total_seconds())
nodes.append(cost)
return ((sum(times)/ len(times)), (sum(nodes) / len(nodes)))
def solve(files, variables, temperature, cooling, inner_loop, ratio):
instances = 50
duration_sum = 0
weight_usage_ratio_sum = 0
satisfied_ratio_sum = 0
for file in files:
sa = SimulatedAnnealing(temperature, cooling, inner_loop, ratio,
File(file))
start_time = time.time()
result = sa.evaluate()
duration = time.time() - start_time
print(result.value, result.satisfied_ratio, result.weight_usage_ratio,
result.bit_array)
duration_sum += duration
weight_usage_ratio_sum += result.weight_usage_ratio
satisfied_ratio_sum += result.satisfied_ratio
# break
# from seconds to milliseconds
duration_avg = (duration_sum / instances) * 1000
weight_usage_ratio_avg = (weight_usage_ratio_sum / instances)
satisfied_ratio_avg = (satisfied_ratio_sum / instances)
return duration_avg, weight_usage_ratio_avg, satisfied_ratio_avg
def benchmark():
REPEATS = 10
SECONDS = [5, 10, 30, 60, 300, 1200]
for seconds in SECONDS:
v = 0
time_s = datetime.now()
for k in range(REPEATS):
rs = RandomSearch(states, seconds, inc_support, dec_support)
rs.run()
v += rs.best_solution.value
time_e = datetime.now()
tt = (time_e - time_s).total_seconds()
print_csv('Random Search', str(seconds), str(v / REPEATS),
str(tt / REPEATS))
for seconds in SECONDS:
v = 0
time_s = datetime.now()
for k in range(REPEATS):
ls = LocalSearch(states, seconds, inc_support, dec_support)
ls.run()
v += ls.best_solution.value
time_e = datetime.now()
tt = (time_e - time_s).total_seconds()
print_csv('Local Search', str(seconds), str(v / REPEATS),
str(tt / REPEATS))
for seconds in SECONDS:
for initial_cadence in [10, 25, 50]:
for critical_event in [10, 25, 50]:
v = 0
time_s = datetime.now()
for k in range(REPEATS):
ts = TabuSearch(states, seconds, initial_cadence,
critical_event, inc_support, dec_support)
ts.run()
v += ts.best_solution.value
time_e = datetime.now()
tt = (time_e - time_s).total_seconds()
print_csv('Tabu Search', str(seconds), str(initial_cadence),
str(critical_event), str(v / REPEATS),
str(tt / REPEATS))
for crossover in ['pmx', 'ox']:
for mutate in ['transposition', 'insertion', 'inversion']:
for seconds in SECONDS:
for population_size in [10, 25, 50]:
v = 0
time_s = datetime.now()
for k in range(REPEATS):
ga = GeneticAlgorithm(states, seconds, population_size,
crossover, mutate, inc_support,
dec_support)
ga.run()
v += ga.best_solution.value
time_e = datetime.now()
tt = (time_e - time_s).total_seconds()
print_csv('Genetic Algorithm ' + crossover + ' ' + mutate,
str(seconds), str(population_size),
str(v / REPEATS), str(tt / REPEATS))
for initial_temperature in [100, 500, 1000]:
for cooling_coefficient in [0.9, 0.99, 0.999, 0.9999]:
for minimal_temperature in [
initial_temperature * 0.25, initial_temperature * 0.5,
initial_temperature * 0.75
]:
v = 0
time_s = datetime.now()
for k in range(REPEATS):
sa = SimulatedAnnealing(states, initial_temperature,
cooling_coefficient,
minimal_temperature, inc_support,
dec_support)
sa.run()
v += sa.best_solution.value
time_e = datetime.now()
tt = (time_e - time_s).total_seconds()
print_csv('Simulated Annealing', str(initial_temperature),
str(cooling_coefficient), str(minimal_temperature),
str(v / REPEATS), str(tt / REPEATS))
file_log_handler.setFormatter(file_log_formatter)
logger.addHandler(file_log_handler)
feature_tables_dir_path = join(dir_name, "tests/fixtures/feature_tables")
constraint_sets_dir_path = join(dir_name, "tests/fixtures/constraint_sets")
feature_table_file_path = join(feature_tables_dir_path,
current_simulation.feature_table_file_name)
feature_table = FeatureTable.load(feature_table_file_path)
constraint_set_file_path = join(
constraint_sets_dir_path, current_simulation.constraint_set_file_name)
constraint_set = ConstraintSet.load(constraint_set_file_path)
corpus = Corpus(current_simulation.corpus)
data = corpus.get_words()
max_word_length_in_data = max([len(word) for word in data])
lexicon = Lexicon(data, max_word_length_in_data)
grammar = Grammar(constraint_set, lexicon)
hypothesis = Hypothesis(grammar, data)
if hasattr(current_simulation, "target_energy"):
target_energy = current_simulation.target_energy
else:
target_energy = None
simulated_annealing = SimulatedAnnealing(hypothesis, target_energy)
simulated_annealing.run()
from datasets import Datasets
from simulated_annealing import SimulatedAnnealing
path = '/Users/michal/PycharmProjects/MRP/datasets/*.tsp'
data = Datasets(path)
#name = 'ali535'
# name = 'berlin11_modified'
name = 'berlin52'
# name = 'fl417'
# name = 'gr666'
# name = 'kroA100'
# name = 'kroA150'
# name = 'nrw1379'
# name = 'pr2392'
SA = SimulatedAnnealing(data, name)
stats = SA(t_start=10000000000, t_min=10)
for iterator, log in enumerate(stats.items()):
print('ITERATION {}'.format(iterator))
print('\t\tbest distance - {}'.format(log[0]))
print('\t\tbest route - {}'.format(log[1]))
print('\n')
Argmax(Map(Function(Sum(HoleNode())), VarList('actions'))),
Argmax(
Map(Function(Sum(Map(Function(HoleNode()), NoneNode()))),
VarList('actions'))),
Argmax(
Map(
Function(
Sum(
Map(
Function(
Minus(Times(HoleNode(), HoleNode()),
HoleNode())), NoneNode()))),
VarList('actions'))),
]
chosen = int(sys.argv[1])
n_SA_iterations = 3000
max_game_rounds = 500
n_games = 1000
init_temp = 1
d = 1
algo_name = 'HOLESA_' + str(chosen)
start_SA = time.time()
SA = SimulatedAnnealing(n_SA_iterations, max_game_rounds, n_games,
init_temp, d, algo_name)
best_program, _ = SA.run(incomplete[chosen])
end_SA = time.time() - start_SA
print('Best program after SA - Time elapsed = ', end_SA)
print(best_program.to_string())
# k and n_states are paired together in order to make a fair comparison
# between algorithms. This is because IW if k is low will have a low number
# of states returned.
k_options = [3, 4, 5]
k = k_options[int(sys.argv[4])]
n_states_options = [94, 201, 622] # k=3 94, k=4 201, k=5 622, k=6 1244
n_states = n_states_options[int(sys.argv[4])]
n_games = 100
init_temp = 1
d = 1
max_game_rounds = 500
max_nodes = 100
n_MC_simulations = 1000
inner_SA = SimulatedAnnealing(n_SA_iterations, max_game_rounds, n_games, init_temp, d, False)
outer_SA = SimulatedAnnealing(1000, max_game_rounds, n_games, init_temp, d, True)
dsl = DSL()
if search_type == 0:
# IW
tree = ParseTree(dsl=dsl, max_nodes=max_nodes, k=k, is_IW=True)
search_algo = IteratedWidth(tree, n_states, k)
suffix = 'IW' + '_LS' + str(LS_type) + '_SA' + str(n_SA_iterations) + '_ST' + str(n_states) + '_k' + str(k) + '_GA' + str(n_games)
elif search_type == 1:
# BFS
tree = ParseTree(dsl=dsl, max_nodes=max_nodes, k=k, is_IW=False)
search_algo = BFS(tree, n_states)
suffix = 'BFS' + '_LS' + str(LS_type) + '_SA' + str(n_SA_iterations) + '_ST' + str(n_states) + '_k' + str(k) + '_GA' + str(n_games)
for q_cities in num_cities:
for i in xrange(q_cities):
city = City()
cities_list.append(city)
if args.numtests == 1:
show_window = True
print '----------- SIMULATED ANNEALING WITH %d CITIES -----------' % q_cities
simulated_annealing_s = []
for i in xrange(args.numtests):
print 'Test ', i + 1
if show_window:
simulated_window = ManageGraph()
else:
simulated_window = None
simulated_annealing_s.append(SimulatedAnnealing(simulated_window, cities_list, show_window=show_window))
min_simulated.append(min(i.get_best_distance() for i in simulated_annealing_s))
simulated_avg.append(sum(sa_best.get_best_distance() for sa_best in simulated_annealing_s) / float(len(simulated_annealing_s)))
max_simulated.append(max(i.get_best_distance() for i in simulated_annealing_s))
print '----------- GENETIC ALGORITHM WITH %d CITIES -----------' % q_cities
genetic_algorithm_s = []
for i in xrange(args.numtests):
print 'Test ', i + 1
if show_window:
genetic_window = ManageGraph()
else:
genetic_window = None
genetic_algorithm_s.append(GeneticAlgorithm(genetic_window, cities_list, show_window=show_window))
from board import Board
from simulated_annealing import SimulatedAnnealing
import time
if __name__ == '__main__':
startTime = time.time()
for i in range(0, 5):
print("i: {}".format(i))
board = Board()
print("Rainhas:")
print(board)
SimulatedAnnealing(board).run()
endTime = time.time()
elapsedTime = (endTime - startTime)
average = elapsedTime / 10
print("Tempo total: {} ".format(elapsedTime))
print("Tempo médio: {}".format(average))
max_temp = settings.options.max_temp # initial temperature
min_temp = settings.options.min_temp # final temperature
eq_iter = settings.options.iters # iterations at same temperature
temp_change = settings.options.temp_rate # temperature reduction factor
# execute the algorithm
filename = settings.options.data_filename
if not filename:
raise UserWarning("enter data filename through the -df flag.")
constraints = [
SameRoomAndTime(),
SameStudents(),
DifferentTime(),
Precedence(),
SameInstructor(),
Spread()
]
soft_constraints = [RoomCost(), PreferenceRoom(), StudentsTakingClass()]
solver = SimulatedAnnealing(TtDataReader(), H1())
plotter = TtPlotter()
plotter.register_constraints(constraints)
plotter.register_soft_constraints(soft_constraints)
solver.register_plotter(plotter)
solver.register_constraints(constraints)
solver.register_soft_constraints(soft_constraints)
best_solution = solver.solve(filename)
# print(best_solution)
# print(best_solution.cost())
