wincyj komentarzy

Author: mackoo13

algorithm/algorithm.py

@@ -8,41 +8,57 @@ class Algorithm:
  def execute(data):
 
  """
- :return: score of the best solution found
+ 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
  """
 
- n = 4 # nr of bees == solutions
+ n = 4
  m = 3
  e = 1
- nep = 4 # 1 elite bee goes to 4 different places
- # from these 4 places chooses exactly 1
- nsp = 2 # 2 good bees goes to 2 different places
- # from these 4 places chooses exactly 1
- ngh = 4 # max distance from center (e.g. elite solution)
+ nep = 4
+ nsp = 2
+ ngh = 4
  max_iter = 8
 
- # n losowych rozwiazan (pszczol)
+ # inicjalizujemy pule losowymi rozwiazaniami
  pool = [AlgorithmUtils.random_solution(data) for _ in range(n)]
 
  for i in range(max_iter):
  print("Iter ", i)
 
- # calcuate all solutions and sort them all
+ # dla kazdego rozwiazania obliczamy wynik - ukladamy je od najlepszych do najgorszych
  solutions_ranking = sorted(pool, key=lambda s: calculate_score(data, s), reverse=True)
- # choose 1 elite
+ # 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 = []
- # choose 1 solution from each elite solutions
+ # 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))
- # choose 1 solution from each good solutions
+ # 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 rozwiazania (leca gdzie indziej)
+ # 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.
+
  print(max(pool, key=lambda s: calculate_score(data, s)))
  return calculate_score(data, pool[0])

algorithm/utils.py

@@ -31,7 +31,7 @@ def random_neighbour(data, solution, radius):
  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 nie wiem jak inaczej to zrobic.
+ 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. :)
  """
@@ -40,15 +40,18 @@ def random_neighbour(data, solution, radius):
  if radius == 0:
  return res
 
- # TODO - optimize free_space here
- # I guess free_space is invoked many times in list comprehension
- # we could previously preapre a list of free_spaces for each server
+ # 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)]
 
- # lista wszystkich operacji
+ # 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))
- if v in res[s] or data.videos_sizes[v] <= AlgorithmUtils.free_space(data, solution, s)]
+ if v in res[s] or data.videos_sizes[v] <= free_space_on_server[s]]
 
  op = random.choice(acceptable_ops)
  s = op[0]

main.py

@@ -7,8 +7,8 @@ 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"
+ 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)
@@ -19,7 +19,7 @@ def main():
  after = time.time()
 
  print("-----------------------------")
- print("Algorithm took time: " + 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")
 

parsers/input_parser.py

@@ -8,12 +8,7 @@ def parse_input(path_to_file: str):
  Parses input file.
 
  :param path_to_file: path to input file as string
- :return: tuple consisting of 8 values: amount of videos (int), amount of endpoints (int),
- amount of request descriptions (int), amount of cache servers (int),
- cache servers size (int), videos sizes (dictionary consisting of pairs:
- video id (int), video size (int) )
- dict of endpoints (consisting of pairs: endpoint_id, endpoint),
- list of requests (list of RequestInfo)
+ :return: Data objet containing a complete description of input (see datarepresentation/data.py)
  """
  amount_of_videos, amount_of_endpoints, amount_of_request_descriptions, \
  amount_of_cache_servers, cache_size = -1, -1, -1, -1, -1
@@ -54,9 +49,6 @@ def parse_input(path_to_file: str):
 
  return Data(endpoints, videos_sizes, amount_of_cache_servers, requests, cache_size)
 
- # return (amount_of_videos, amount_of_endpoints, amount_of_request_descriptions,
- # amount_of_cache_servers, cache_size, videos_sizes, endpoints, requests)
-
 
 def __parse_general_data(line_content: list):
  return tuple(int(x) for x in line_content)