Merge pull request #6 from Wwarrior1/comments-refactor

Removed unnecessary debug stage comments

Author: mackoo13

README.md

@@ -2,4 +2,19 @@
 [Operational Research] University project of distributed server caching using Pham's bee algorithm
 
 # Running
-```python main.py```, providing the file name in the source code
+```python main.py [-h] [-i I] [-o O] [-n N] [-m M] [-e E] [-nep NEP] [-nsp NSP]
+ [-ngh NGH] [-max MAX] [-s S]
+
+opcjonalne argumenty:
+ -h, --help display help
+ -i I, -input_file I input file path
+ -o O, -output_file O output file path
+ -n N, -bees N number of bees
+ -m M, -good_solutions M number of good solutions
+ -e E, -elite_solutions E number of elite solutions
+ -nep NEP number of solutions in elite neighbourhood
+ -nsp NSP number of solutions in good solutions' neighbourhood
+ -ngh NGH neighbourhood radius
+ -max MAX, -iterations MAX number of iterations
+ -s S, -save_solution S save solution to the output file? (true/false)
+```

algorithm/algorithm.py

@@ -6,48 +6,20 @@ class Algorithm:
  @staticmethod
  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
- kwiatku, czyli pszczola jest reprezentacja konkretnego rozwiazania.
-
- n - liczba pszczol, czyli rozwiazan w puli w kazdej iteracji. Ta liczba nigdy sie nie zmieni!
- m - liczba rozwiazan dobrych (w tym elitarnych)
- e - liczba rozwiazan elitarnych (czyli najlepszych)
- nep - kazda pszczola elitarna wybierze nep zblizonych rozwiazan, zeby wybrac jedno najlepsze
- jesli wszystkie beda gorsze, zostanie na tym samym kwiatku, na ktorym jest teraz.
- nsp - j.w., tylko dla rozwiazan dobrych, a nie elitarnych.
- ngh - promien sasiedztwa, czyli jak dalekie rozwiazania rozpatrujemy po elitarnych/dobrych
- max_iter - liczba iteracji
- """
-
- # inicjalizujemy pule losowymi rozwiazaniami
  pool = [AlgorithmUtils.random_solution(data) for _ in range(n)]
 
  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...
  elite_solutions = solutions_ranking[0:e]
- # ... a kolejne (m-e) to po prostu dobre
  good_solutions = solutions_ranking[e:m]
 
- # tworzymy nowa pule rozwiazan
  pool = []
- # kazde elitarne rozwiazanie zastepujemy jednym, najlepszym sposrod nep wybranych z sasiedztwa
- # UWAGA: to ze np. nep=4, nie znaczy ze dostajemy 4 nowe pszczoly. Po prostu sprawdzamy 4 rozwiazania, ale
- # tylko do najlepszego z nich poleci pszczola. Jedna pszczola tu przyleciala i jedna tu zostanie!
- # Nie jest powiedziane, ze ta pszczola bedzie znowu elitarna w kolejnej itreracji - to moze sie zmienic
  for es in elite_solutions:
  pool.append(AlgorithmUtils.best_in_neighbourhood(data, es, ngh, nep))
- # to samo dla dobrych rozwiazan
  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):
  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.
-
  pool = sorted(pool, key=lambda s: calculate_score(data, s), reverse=True)
  return pool[0]

algorithm/utils.py

@@ -6,9 +6,6 @@ class AlgorithmUtils:
 
  @staticmethod
  def random_solution(data):
- """
- Nie jest do doskonaly sposob, ale na nic lepszego nie wpadlismy
- """
 
  res = dict()
  avg_video_size = sum(data.videos_sizes)/len(data.videos_sizes)
@@ -28,28 +25,13 @@ def random_solution(data):
  @staticmethod
  def random_neighbour(data, solution, radius):
 
- """
- Na razie to dziala tak, ze 'radius' razy losujemy sasiada w odleglosci 1
- Potencjalnie mozemy wyladowac w odleglosci radius lub mniejszej (w szczegolnosci wrocic do solution) - to chyba
- nie szkodzi?
- Nie ma tez gwarancji, ze sie nie powtorza - to chyba nie szkodzi?
- Prawdopodobienstwo wylosowania kazdego rozwiazania niekoniecznie jest rowne. Ale watpie czy da sie lepiej.
-
- TODO or not TODO? Zostawiamy to, czy ktos ma lepszy pomysl? Ja nie. :)
- """
-
  res = AlgorithmUtils.solution_copy(solution)
  if radius == 0:
  return res
 
- # licze to wczesniej, zeby nie robic tego wielokrotnie w list comprehension
  free_space_on_server = \
  [AlgorithmUtils.free_space(data, solution, s) for s in range(data.amount_of_cache_servers)]
 
- # generujemy liste moliwych do wykonania elementarnych modyfikacji rozwiazania
- # sa to operacje dwoch typow: dodaj albo usun
- # dodac mozemy te filmy, ktore sie smieszcza
- # usunac mozemy te, ktore sa aktualnie w rozwiazaniu
  acceptable_ops = [(s, v)
  for s in range(data.amount_of_cache_servers)
  for v in range(len(data.videos_sizes))
@@ -69,15 +51,6 @@ def random_neighbour(data, solution, radius):
  @staticmethod
  def best_in_neighbourhood(data, solution, radius, number_of_bees):
 
- """
- Wysylamy losowo 'number_of_bees' pszczol do zbadania obszaru o promieniu radius.
- Zwracamy najlepsze z tych rozwiazan.
-
- TODO Staralem sie wyliczac score od razu, zeby potem nie robic tego ponownie przy max(...) i w ostatnim ifie
- Stad taka dziwna lista krotek: neighbours = [(solution, score(solution)), ...]
- Da sie to bardziej zoptymalizowac?
- """
-
  neighbours = []
  for _ in range(number_of_bees):
  neighbour = AlgorithmUtils.random_neighbour(data, solution, radius)
@@ -87,20 +60,11 @@ def best_in_neighbourhood(data, solution, radius, number_of_bees):
 
  @staticmethod
  def free_space(data, solution, server):
-
- """
- Ile wolnych MB na danym serwerze (do sprawdzania, czy mozna dodac film)
- """
-
  return data.cache_size - sum([data.videos_sizes[v] for v in solution[server]])
 
  @staticmethod
  def solution_copy(solution):
 
- """
- Bo python.
- """
-
  res = dict()
  for s in solution:
  res[s] = solution[s][:]