Merge pull request #4 from Wwarrior1/parameters_tester

Parameters tester

Author: Wwarrior1

algorithm/algorithm.py

@@ -3,9 +3,8 @@
 
 
 class Algorithm:
-
  @staticmethod
- def execute(data):
+ def execute(data, n, m, e, nep, nsp, ngh, iterations):
 
  """
  Pomaga myslenie o rozwiazaniach jako o kwiatkach. Kazda pszczola siedzi w danym momencie na jednym konkretnym
@@ -21,20 +20,10 @@ def execute(data):
  max_iter - liczba iteracji
  """
 
- n = 25
- m = 9
- e = 3
- nep = 9
- nsp = 3
- ngh = 1
- max_iter = 1000
-
  # inicjalizujemy pule losowymi rozwiazaniami
  pool = [AlgorithmUtils.random_solution(data) for _ in range(n)]
 
- for i in range(max_iter):
- print("Iter ", i)
-
+ for i in range(iterations):
  # dla kazdego rozwiazania obliczamy wynik - ukladamy je od najlepszych do najgorszych
  solutions_ranking = sorted(pool, key=lambda s: calculate_score(data, s), reverse=True)
  # najlepsze e rozwiazan to elitarne...
@@ -54,11 +43,11 @@ def execute(data):
  for gs in good_solutions:
  pool.append(AlgorithmUtils.best_in_neighbourhood(data, gs, ngh, nsp))
  # dla pszczol ktore byly slabe wybieramy dla nich nowe, calkowicie losowe rozwiazania (leca gdzie indziej)
- for _ in range(n-m):
+ for _ in range(n - m):
  pool.append(AlgorithmUtils.random_solution(data))
 
- # podsumowujac - jesli np. n=5, m=3, e=1, to zawsze na koniec iteracji 1 pszczola pochodzi z obszaru
- # elitarnego, 2 z dobrych, a 2 sa losowane od nowa.
+  # podsumowujac - jesli np. n=5, m=3, e=1, to zawsze na koniec iteracji 1 pszczola pochodzi z obszaru
+  # elitarnego, 2 z dobrych, a 2 sa losowane od nowa.
 
  pool = sorted(pool, key=lambda s: calculate_score(data, s), reverse=True)
  return pool[0]

main.py

@@ -1,32 +1,42 @@
+from argparse import ArgumentParser
+from os.path import split
+from time import time
+
 from algorithm.algorithm import Algorithm
 from parsers.input_parser import parse_input
-from utils.solution_checker import check_solution
-from parsers.output_builder import save_solution
-import time
+from parsers.output_builder import save_solution, save_execution_parameters
+from utils.argument_parser_util import add_parser_arguments, str2bool
+from utils.solution_checker import check_solution, calculate_score
 
 
 def main():
- input_file = "files/videos_worth_spreading.in"
- # input_file = "files/kittens.in"
- # input_file = "files/example1.in"
- input_file = "files/me_at_the_zoo.in"
- # input_file = "files/trending_today.in"
-
- # solution_file = "files/example1.out"
- # solution = check_solution(input_file, solution_file)
- # print(solution)
+ input_file, output_file = args.i, args.o
+ n, m, e = args.n, args.m, args.e
+ nep, nsp, ngh = args.nep, args.nsp, args.ngh
+ iterations = args.max
+ should_save = str2bool(args.s)
 
- before = time.time()
- best_solution = Algorithm.execute(parse_input(input_file))
- save_solution(best_solution, "files/out1.out")
- score = check_solution(input_file, "files/out1.out")
- after = time.time()
+ before = time()
+ data = parse_input(input_file)
+ best_solution = Algorithm.execute(data, n, m, e, nep, nsp, ngh, iterations)
+ if should_save:
+ save_solution(best_solution, output_file)
+ score = check_solution(input_file, output_file)
+ else:
+ score = calculate_score(data, best_solution)
+ filename = split(input_file)[1]
+ save_execution_parameters(";", filename, n, m, e, nep, nsp, ngh, iterations, score, output_file)
+ after = time()
 
  print(best_solution)
  print("-----------------------------")
- print("Algorithm took: " + str(round(after-before, 2)) + " s")
+ print("Algorithm took: " + str(round(after - before, 2)) + " s")
  print("-----------------------------")
  print("Saved time: " + str(round(score / 1000, 2)) + " s (score: " + str(score) + ")")
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
+ parser = ArgumentParser(description="Distributed cache problem solver.")
+ add_parser_arguments(parser)
+ args = parser.parse_args()
  main()

parsers/output_builder.py

@@ -3,3 +3,13 @@ def save_solution(solution, name):
  f.write(str(len(solution)) + "\n")
  for s in solution:
  f.write(str(s) + " " + " ".join([str(v) for v in solution[s]]) + "\n")
+
+
+def save_execution_parameters(separator, file, n, m, e, nep, nsp, ngh, iterations, score, output_file):
+ with open(output_file, 'a') as f:
+ f.write(separator.join(str(x) for x in (file, n, m, e, nep, nsp, ngh, iterations, score)) + "\n")
+
+
+def clear_results_file(separator, output_file):
+ with open(output_file, 'w') as out:
+ out.write(separator.join(("file", "n", "m", "e", "nep", "nsp", "ngp", "iterations", "score")) + "\n")

utils/argument_parser_util.py

@@ -0,0 +1,55 @@
+from argparse import ArgumentTypeError
+from os.path import join
+
+from os import getcwd
+
+
+def add_parser_arguments(parser):
+ default_input_filename = "me_at_the_zoo.in"
+ parser.add_argument("-i", "-input_file", help="Path to input file.", type=str,
+ default=join(getcwd(), "files", default_input_filename))
+
+ default_output_filename = "solution.out"
+ parser.add_argument("-o", "-output_file", help="Path to output file.", type=str,
+ default=join(getcwd(), "files", default_output_filename))
+
+ default_n = 25
+ parser.add_argument("-n", "-bees", help="Amount of bees.", type=int,
+ default=default_n)
+
+ default_m = 9
+ parser.add_argument("-m", "-good_solutions", help="Amount of good solutions.", type=int,
+ default=default_m)
+
+ default_e = 3
+ parser.add_argument("-e", "-elite_solutions", help="Amount of elite solutions.", type=int,
+ default=default_e)
+
+ default_nep = 9
+ parser.add_argument("-nep", help="???", type=int,
+ default=default_nep)
+
+ default_nsp = 3
+ parser.add_argument("-nsp", help="???", type=int,
+ default=default_nsp)
+
+ default_ngh = 1
+ parser.add_argument("-ngh", help="Neighborhood radius.", type=int,
+ default=default_ngh)
+
+ default_max_iter = 100
+ parser.add_argument("-max", "-iterations", help="Amount of iterations.", type=int,
+ default=default_max_iter)
+
+ default_s = "True"
+ parser.add_argument("-s", "-save_solution", help="Should solution be saved?", type=str,
+ default=default_s)
+
+
+def str2bool(v):
+ if v.lower() in ('yes', 'true', 't', 'y', '1'):
+ return True
+ if v.lower() in ('no', 'false', 'f', 'n', '0'):
+ return False
+ else:
+ raise ArgumentTypeError('Boolean value expected.')

utils/parameters_tester.py

@@ -0,0 +1,38 @@
+from os.path import join, split
+from subprocess import call
+from time import time
+
+from concurrent.futures import ProcessPoolExecutor
+from os import getcwd
+
+from parsers.output_builder import clear_results_file
+
+
+def main():
+ main_path = __get_path()
+ input_dir = join(split(getcwd())[0], "files")
+ input_file = join(input_dir, "me_at_the_zoo.in")
+ output_dir = join(split(getcwd())[0], "files")
+ output_file = join(output_dir, "results.csv")
+ clear_results_file(';', output_file)
+ before = time()
+ with ProcessPoolExecutor(None) as executor:
+ # todo make ranges and steps as parameters? maybe add more parameters to manipulate
+ for bees in range(10, 11, 10):
+ for iterations in range(100, 150, 50):
+ for tries_with_same_parameters in range(0, 10):
+ command = "python {0} -i {1} -o {2} -n {3} -max {4} -s False" \
+ .format(main_path, input_file, output_file, bees, iterations)
+ executor.submit(call, command)
+ after = time()
+ print("Execution took: " + str(round(after - before, 2)) + " s")
+
+
+def __get_path():
+ directory = split(getcwd())[0]
+ filename = "main.py"
+ return join(directory, filename)
+
+
+if __name__ == '__main__':
+ main()